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
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
/*
* Copyright (C) 2020, Raspberry Pi (Trading) Ltd.
*
* rpi_stream.h - Raspberry Pi device stream abstraction class.
*/
#pragma once
#include <queue>
#include <string>
#include <unordered_map>
#include <vector>
#include <libcamera/ipa/raspberrypi.h>
#include <libcamera/ipa/raspberrypi_ipa_interface.h>
#include <libcamera/stream.h>
#include "libcamera/internal/v4l2_videodevice.h"
namespace libcamera {
namespace RPi {
using BufferMap = std::unordered_map<unsigned int, FrameBuffer *>;
/*
* Device stream abstraction for either an internal or external stream.
* Used for both Unicam and the ISP.
*/
class Stream : public libcamera::Stream
{
public:
Stream()
: id_(ipa::RPi::MaskID)
{
}
Stream(const char *name, MediaEntity *dev, bool importOnly = false)
: external_(false), importOnly_(importOnly), name_(name),
dev_(std::make_unique<V4L2VideoDevice>(dev)), id_(ipa::RPi::MaskID)
{
}
V4L2VideoDevice *dev() const;
std::string name() const;
bool isImporter() const;
void resetBuffers();
void setExternal(bool external);
bool isExternal() const;
void setExportedBuffers(std::vector<std::unique_ptr<FrameBuffer>> *buffers);
const BufferMap &getBuffers() const;
int getBufferId(FrameBuffer *buffer) const;
void setExternalBuffer(FrameBuffer *buffer);
void removeExternalBuffer(FrameBuffer *buffer);
int prepareBuffers(unsigned int count);
int queueBuffer(FrameBuffer *buffer);
void returnBuffer(FrameBuffer *buffer);
int queueAllBuffers();
void releaseBuffers();
private:
class IdGenerator
{
public:
IdGenerator(int max)
: max_(max), id_(0)
{
}
int get()
{
int id;
if (!recycle_.empty()) {
id = recycle_.front();
recycle_.pop();
} else {
id = id_++;
ASSERT(id_ <= max_);
}
return id;
}
void release(int id)
{
recycle_.push(id);
}
void reset()
{
id_ = 0;
recycle_ = {};
}
private:
int max_;
int id_;
std::queue<int> recycle_;
};
void clearBuffers();
int queueToDevice(FrameBuffer *buffer);
/*
* Indicates that this stream is active externally, i.e. the buffers
* might be provided by (and returned to) the application.
*/
bool external_;
/* Indicates that this stream only imports buffers, e.g. ISP input. */
bool importOnly_;
/* Stream name identifier. */
std::string name_;
/* The actual device stream. */
std::unique_ptr<V4L2VideoDevice> dev_;
/* Tracks a unique id key for the bufferMap_ */
IdGenerator id_;
/* All frame buffers associated with this device stream. */
BufferMap bufferMap_;
/*
* List of frame buffers that we can use if none have been provided by
* the application for external streams. This is populated by the
* buffers exported internally.
*/
std::queue<FrameBuffer *> availableBuffers_;
/*
* List of frame buffers that are to be queued into the device from a Request.
* A nullptr indicates any internal buffer can be used (from availableBuffers_),
* whereas a valid pointer indicates an external buffer to be queued.
*
* Ordering buffers to be queued is important here as it must match the
* requests coming from the application.
*/
std::queue<FrameBuffer *> requestBuffers_;
/*
* This is a list of buffers exported internally. Need to keep this around
* as the stream needs to maintain ownership of these buffers.
*/
std::vector<std::unique_ptr<FrameBuffer>> internalBuffers_;
};
/*
* The following class is just a convenient (and typesafe) array of device
* streams indexed with an enum class.
*/
template<typename E, std::size_t N>
class Device : public std::array<class Stream, N>
{
private:
constexpr auto index(E e) const noexcept
{
return static_cast<std::underlying_type_t<E>>(e);
}
public:
Stream &operator[](E e)
{
return std::array<class Stream, N>::operator[](index(e));
}
const Stream &operator[](E e) const
{
return std::array<class Stream, N>::operator[](index(e));
}
};
} /* namespace RPi */
} /* namespace libcamera */
|
