pipeline: rkisp1: Support raw Bayer capture configuration

Implement support for raw Bayer capture during configuration generation,
validation and camera configuration.

While at it, fix a typo in a comment.

Signed-off-by: Florian Sylvestre <fsylvestre@baylibre.com>
Signed-off-by: Paul Elder <paul.elder@ideasonboard.com>
Signed-off-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
Reviewed-by: Paul Elder <paul.elder@ideasonboard.com>
Reviewed-by: Jacopo Mondi <jacopo@jmondi.org>
This commit is contained in:
Florian Sylvestre 2022-10-03 16:36:38 +02:00 committed by Laurent Pinchart
parent c8f63760e5
commit 87f5d12718
3 changed files with 275 additions and 56 deletions

View file

@ -410,6 +410,30 @@ void RkISP1CameraData::metadataReady(unsigned int frame, const ControlList &meta
pipe()->tryCompleteRequest(info);
}
/* -----------------------------------------------------------------------------
* Camera Configuration
*/
namespace {
/* Keep in sync with the supported raw formats in rkisp1_path.cpp. */
const std::map<PixelFormat, uint32_t> rawFormats = {
{ formats::SBGGR8, MEDIA_BUS_FMT_SBGGR8_1X8 },
{ formats::SGBRG8, MEDIA_BUS_FMT_SGBRG8_1X8 },
{ formats::SGRBG8, MEDIA_BUS_FMT_SGRBG8_1X8 },
{ formats::SRGGB8, MEDIA_BUS_FMT_SRGGB8_1X8 },
{ formats::SBGGR10, MEDIA_BUS_FMT_SBGGR10_1X10 },
{ formats::SGBRG10, MEDIA_BUS_FMT_SGBRG10_1X10 },
{ formats::SGRBG10, MEDIA_BUS_FMT_SGRBG10_1X10 },
{ formats::SRGGB10, MEDIA_BUS_FMT_SRGGB10_1X10 },
{ formats::SBGGR12, MEDIA_BUS_FMT_SBGGR12_1X12 },
{ formats::SGBRG12, MEDIA_BUS_FMT_SGBRG12_1X12 },
{ formats::SGRBG12, MEDIA_BUS_FMT_SGRBG12_1X12 },
{ formats::SRGGB12, MEDIA_BUS_FMT_SRGGB12_1X12 },
};
} /* namespace */
RkISP1CameraConfiguration::RkISP1CameraConfiguration(Camera *camera,
RkISP1CameraData *data)
: CameraConfiguration()
@ -456,6 +480,21 @@ CameraConfiguration::Status RkISP1CameraConfiguration::validate()
status = Adjusted;
}
/*
* Simultaneous capture of raw and processed streams isn't possible. If
* there is any raw stream, cap the number of streams to one.
*/
if (config_.size() > 1) {
for (const auto &cfg : config_) {
if (PixelFormatInfo::info(cfg.pixelFormat).colourEncoding ==
PixelFormatInfo::ColourEncodingRAW) {
config_.resize(1);
status = Adjusted;
break;
}
}
}
/*
* If there are more than one stream in the configuration figure out the
* order to evaluate the streams. The first stream has the highest
@ -517,45 +556,51 @@ CameraConfiguration::Status RkISP1CameraConfiguration::validate()
}
}
/* All paths rejected configuraiton. */
/* All paths rejected configuration. */
LOG(RkISP1, Debug) << "Camera configuration not supported "
<< cfg.toString();
return Invalid;
}
/* Select the sensor format. */
PixelFormat rawFormat;
Size maxSize;
for (const StreamConfiguration &cfg : config_)
maxSize = std::max(maxSize, cfg.size);
sensorFormat_ = sensor->getFormat({ MEDIA_BUS_FMT_SBGGR12_1X12,
MEDIA_BUS_FMT_SGBRG12_1X12,
MEDIA_BUS_FMT_SGRBG12_1X12,
MEDIA_BUS_FMT_SRGGB12_1X12,
MEDIA_BUS_FMT_SBGGR10_1X10,
MEDIA_BUS_FMT_SGBRG10_1X10,
MEDIA_BUS_FMT_SGRBG10_1X10,
MEDIA_BUS_FMT_SRGGB10_1X10,
MEDIA_BUS_FMT_SBGGR8_1X8,
MEDIA_BUS_FMT_SGBRG8_1X8,
MEDIA_BUS_FMT_SGRBG8_1X8,
MEDIA_BUS_FMT_SRGGB8_1X8 },
maxSize);
for (const StreamConfiguration &cfg : config_) {
const PixelFormatInfo &info = PixelFormatInfo::info(cfg.pixelFormat);
if (info.colourEncoding == PixelFormatInfo::ColourEncodingRAW)
rawFormat = cfg.pixelFormat;
maxSize = std::max(maxSize, cfg.size);
}
std::vector<unsigned int> mbusCodes;
if (rawFormat.isValid()) {
mbusCodes = { rawFormats.at(rawFormat) };
} else {
std::transform(rawFormats.begin(), rawFormats.end(),
std::back_inserter(mbusCodes),
[](const auto &value) { return value.second; });
}
sensorFormat_ = sensor->getFormat(mbusCodes, maxSize);
if (sensorFormat_.size.isNull())
sensorFormat_.size = sensor->resolution();
return status;
}
/* -----------------------------------------------------------------------------
* Pipeline Operations
*/
PipelineHandlerRkISP1::PipelineHandlerRkISP1(CameraManager *manager)
: PipelineHandler(manager), hasSelfPath_(true)
{
}
/* -----------------------------------------------------------------------------
* Pipeline Operations
*/
std::unique_ptr<CameraConfiguration>
PipelineHandlerRkISP1::generateConfiguration(Camera *camera,
const StreamRoles &roles)
@ -611,23 +656,38 @@ PipelineHandlerRkISP1::generateConfiguration(Camera *camera,
colorSpace = ColorSpace::Rec709;
break;
case StreamRole::Raw:
if (roles.size() > 1) {
LOG(RkISP1, Error)
<< "Can't capture both raw and processed streams";
return nullptr;
}
useMainPath = true;
colorSpace = ColorSpace::Raw;
break;
default:
LOG(RkISP1, Warning)
<< "Requested stream role not supported: " << role;
return nullptr;
}
StreamConfiguration cfg;
RkISP1Path *path;
if (useMainPath) {
cfg = data->mainPath_->generateConfiguration(
data->sensor_.get());
path = data->mainPath_;
mainPathAvailable = false;
} else {
cfg = data->selfPath_->generateConfiguration(
data->sensor_.get());
path = data->selfPath_;
selfPathAvailable = false;
}
StreamConfiguration cfg =
path->generateConfiguration(data->sensor_.get(), role);
if (!cfg.pixelFormat.isValid())
return nullptr;
cfg.colorSpace = colorSpace;
config->addConfiguration(cfg);
}
@ -681,10 +741,14 @@ int PipelineHandlerRkISP1::configure(Camera *camera, CameraConfiguration *c)
<< "ISP input pad configured with " << format
<< " crop " << rect;
isRaw_ = false;
const PixelFormat &streamFormat = config->at(0).pixelFormat;
const PixelFormatInfo &info = PixelFormatInfo::info(streamFormat);
isRaw_ = info.colourEncoding == PixelFormatInfo::ColourEncodingRAW;
/* YUYV8_2X8 is required on the ISP source path pad for YUV output. */
if (!isRaw_)
format.mbus_code = MEDIA_BUS_FMT_YUYV8_2X8;
LOG(RkISP1, Debug)
<< "Configuring ISP output pad with " << format
<< " crop " << rect;

View file

@ -21,6 +21,39 @@ namespace libcamera {
LOG_DECLARE_CATEGORY(RkISP1)
namespace {
/* Keep in sync with the supported raw formats in rkisp1.cpp. */
const std::map<PixelFormat, uint32_t> formatToMediaBus = {
{ formats::UYVY, MEDIA_BUS_FMT_YUYV8_2X8 },
{ formats::YUYV, MEDIA_BUS_FMT_YUYV8_2X8 },
{ formats::NV12, MEDIA_BUS_FMT_YUYV8_1_5X8 },
{ formats::NV21, MEDIA_BUS_FMT_YUYV8_1_5X8 },
{ formats::NV16, MEDIA_BUS_FMT_YUYV8_2X8 },
{ formats::NV61, MEDIA_BUS_FMT_YUYV8_2X8 },
{ formats::YUV420, MEDIA_BUS_FMT_YUYV8_1_5X8 },
{ formats::YVU420, MEDIA_BUS_FMT_YUYV8_1_5X8 },
{ formats::YUV422, MEDIA_BUS_FMT_YUYV8_2X8 },
{ formats::YVU422, MEDIA_BUS_FMT_YUYV8_2X8 },
{ formats::R8, MEDIA_BUS_FMT_YUYV8_2X8 },
{ formats::RGB565, MEDIA_BUS_FMT_YUYV8_2X8 },
{ formats::XRGB8888, MEDIA_BUS_FMT_YUYV8_2X8 },
{ formats::SBGGR8, MEDIA_BUS_FMT_SBGGR8_1X8 },
{ formats::SGBRG8, MEDIA_BUS_FMT_SGBRG8_1X8 },
{ formats::SGRBG8, MEDIA_BUS_FMT_SGRBG8_1X8 },
{ formats::SRGGB8, MEDIA_BUS_FMT_SRGGB8_1X8 },
{ formats::SBGGR10, MEDIA_BUS_FMT_SBGGR10_1X10 },
{ formats::SGBRG10, MEDIA_BUS_FMT_SGBRG10_1X10 },
{ formats::SGRBG10, MEDIA_BUS_FMT_SGRBG10_1X10 },
{ formats::SRGGB10, MEDIA_BUS_FMT_SRGGB10_1X10 },
{ formats::SBGGR12, MEDIA_BUS_FMT_SBGGR12_1X12 },
{ formats::SGBRG12, MEDIA_BUS_FMT_SGBRG12_1X12 },
{ formats::SGRBG12, MEDIA_BUS_FMT_SGRBG12_1X12 },
{ formats::SRGGB12, MEDIA_BUS_FMT_SRGGB12_1X12 },
};
} /* namespace */
RkISP1Path::RkISP1Path(const char *name, const Span<const PixelFormat> &formats,
const Size &minResolution, const Size &maxResolution)
: name_(name), running_(false), formats_(formats),
@ -69,11 +102,18 @@ void RkISP1Path::populateFormats()
std::vector<PixelFormat> formats;
for (const auto &[format, sizes] : v4l2Formats) {
const PixelFormat pixelFormat = format.toPixelFormat();
const PixelFormatInfo &info = PixelFormatInfo::info(pixelFormat);
/* \todo Add support for RAW formats. */
if (info.colourEncoding == PixelFormatInfo::ColourEncodingRAW)
/*
* As a defensive measure, skip any pixel format exposed by the
* driver that we don't know about. This ensures that looking up
* formats in formatToMediaBus using a key from streamFormats_
* will never fail in any of the other functions.
*/
if (!formatToMediaBus.count(pixelFormat)) {
LOG(RkISP1, Warning)
<< "Unsupported pixel format " << pixelFormat;
continue;
}
streamFormats_.insert(pixelFormat);
@ -86,21 +126,69 @@ void RkISP1Path::populateFormats()
}
}
StreamConfiguration RkISP1Path::generateConfiguration(const CameraSensor *sensor)
StreamConfiguration
RkISP1Path::generateConfiguration(const CameraSensor *sensor, StreamRole role)
{
const std::vector<unsigned int> &mbusCodes = sensor->mbusCodes();
const Size &resolution = sensor->resolution();
Size maxResolution = maxResolution_.boundedToAspectRatio(resolution)
.boundedTo(resolution);
Size minResolution = minResolution_.expandedToAspectRatio(resolution);
/* Create the list of supported stream formats. */
std::map<PixelFormat, std::vector<SizeRange>> streamFormats;
for (const auto &format : streamFormats_)
unsigned int rawBitsPerPixel = 0;
PixelFormat rawFormat;
for (const auto &format : streamFormats_) {
const PixelFormatInfo &info = PixelFormatInfo::info(format);
if (info.colourEncoding != PixelFormatInfo::ColourEncodingRAW) {
streamFormats[format] = { { minResolution, maxResolution } };
continue;
}
/* Skip raw formats not supported by the sensor. */
uint32_t mbusCode = formatToMediaBus.at(format);
if (std::find(mbusCodes.begin(), mbusCodes.end(), mbusCode) ==
mbusCodes.end())
continue;
streamFormats[format] = { { resolution, resolution } };
/*
* Store the raw format with the highest bits per pixel for
* later usage.
*/
if (info.bitsPerPixel > rawBitsPerPixel) {
rawBitsPerPixel = info.bitsPerPixel;
rawFormat = format;
}
}
/*
* Pick a suitable pixel format for the role. Raw streams need to use a
* raw format, processed streams use NV12 by default.
*/
PixelFormat format;
if (role == StreamRole::Raw) {
if (!rawFormat.isValid()) {
LOG(RkISP1, Error)
<< "Sensor " << sensor->model()
<< " doesn't support raw capture";
return {};
}
format = rawFormat;
} else {
format = formats::NV12;
}
StreamFormats formats(streamFormats);
StreamConfiguration cfg(formats);
cfg.pixelFormat = formats::NV12;
cfg.pixelFormat = format;
cfg.size = maxResolution;
cfg.bufferCount = RKISP1_BUFFER_COUNT;
@ -110,26 +198,85 @@ StreamConfiguration RkISP1Path::generateConfiguration(const CameraSensor *sensor
CameraConfiguration::Status RkISP1Path::validate(const CameraSensor *sensor,
StreamConfiguration *cfg)
{
const std::vector<unsigned int> &mbusCodes = sensor->mbusCodes();
const Size &resolution = sensor->resolution();
const StreamConfiguration reqCfg = *cfg;
CameraConfiguration::Status status = CameraConfiguration::Valid;
/*
* Default to NV12 if the requested format is not supported. All
* versions of the ISP are guaranteed to support NV12 on both the main
* and self paths.
* Validate the pixel format. If the requested format isn't supported,
* default to either NV12 (all versions of the ISP are guaranteed to
* support NV12 on both the main and self paths) if the requested format
* is not a raw format, or to the supported raw format with the highest
* bits per pixel otherwise.
*/
if (!streamFormats_.count(cfg->pixelFormat))
cfg->pixelFormat = formats::NV12;
unsigned int rawBitsPerPixel = 0;
PixelFormat rawFormat;
bool found = false;
for (const auto &format : streamFormats_) {
const PixelFormatInfo &info = PixelFormatInfo::info(format);
if (info.colourEncoding == PixelFormatInfo::ColourEncodingRAW) {
/* Skip raw formats not supported by the sensor. */
uint32_t mbusCode = formatToMediaBus.at(format);
if (std::find(mbusCodes.begin(), mbusCodes.end(), mbusCode) ==
mbusCodes.end())
continue;
/*
* Adjust the size based on the sensor resolution and absolute limits
* of the ISP.
* Store the raw format with the highest bits per pixel
* for later usage.
*/
Size maxResolution = maxResolution_.boundedToAspectRatio(resolution)
if (info.bitsPerPixel > rawBitsPerPixel) {
rawBitsPerPixel = info.bitsPerPixel;
rawFormat = format;
}
}
if (cfg->pixelFormat == format) {
found = true;
break;
}
}
bool isRaw = PixelFormatInfo::info(cfg->pixelFormat).colourEncoding ==
PixelFormatInfo::ColourEncodingRAW;
/*
* If no raw format supported by the sensor has been found, use a
* processed format.
*/
if (!rawFormat.isValid())
isRaw = false;
if (!found)
cfg->pixelFormat = isRaw ? rawFormat : formats::NV12;
Size minResolution;
Size maxResolution;
if (isRaw) {
/*
* Use the sensor output size closest to the requested stream
* size.
*/
uint32_t mbusCode = formatToMediaBus.at(cfg->pixelFormat);
V4L2SubdeviceFormat sensorFormat =
sensor->getFormat({ mbusCode }, cfg->size);
minResolution = sensorFormat.size;
maxResolution = sensorFormat.size;
} else {
/*
* Adjust the size based on the sensor resolution and absolute
* limits of the ISP.
*/
minResolution = minResolution_.expandedToAspectRatio(resolution);
maxResolution = maxResolution_.boundedToAspectRatio(resolution)
.boundedTo(resolution);
Size minResolution = minResolution_.expandedToAspectRatio(resolution);
}
cfg->size.boundTo(maxResolution);
cfg->size.expandTo(minResolution);
@ -182,15 +329,11 @@ int RkISP1Path::configure(const StreamConfiguration &config,
<< "Configuring " << name_ << " resizer output pad with "
<< ispFormat;
switch (config.pixelFormat) {
case formats::NV12:
case formats::NV21:
ispFormat.mbus_code = MEDIA_BUS_FMT_YUYV8_1_5X8;
break;
default:
ispFormat.mbus_code = MEDIA_BUS_FMT_YUYV8_2X8;
break;
}
/*
* The configuration has been validated, the pixel format is guaranteed
* to be supported and thus found in formatToMediaBus.
*/
ispFormat.mbus_code = formatToMediaBus.at(config.pixelFormat);
ret = resizer_->setFormat(1, &ispFormat);
if (ret < 0)
@ -266,14 +409,25 @@ void RkISP1Path::stop()
namespace {
constexpr Size RKISP1_RSZ_MP_SRC_MIN{ 32, 16 };
constexpr Size RKISP1_RSZ_MP_SRC_MAX{ 4416, 3312 };
constexpr std::array<PixelFormat, 6> RKISP1_RSZ_MP_FORMATS{
constexpr std::array<PixelFormat, 18> RKISP1_RSZ_MP_FORMATS{
formats::YUYV,
formats::NV16,
formats::NV61,
formats::NV21,
formats::NV12,
formats::R8,
/* \todo Add support for RAW formats. */
formats::SBGGR8,
formats::SGBRG8,
formats::SGRBG8,
formats::SRGGB8,
formats::SBGGR10,
formats::SGBRG10,
formats::SGRBG10,
formats::SRGGB10,
formats::SBGGR12,
formats::SGBRG12,
formats::SGRBG12,
formats::SRGGB12,
};
constexpr Size RKISP1_RSZ_SP_SRC_MIN{ 32, 16 };

View file

@ -40,7 +40,8 @@ public:
int setEnabled(bool enable) { return link_->setEnabled(enable); }
bool isEnabled() const { return link_->flags() & MEDIA_LNK_FL_ENABLED; }
StreamConfiguration generateConfiguration(const CameraSensor *sensor);
StreamConfiguration generateConfiguration(const CameraSensor *sensor,
StreamRole role);
CameraConfiguration::Status validate(const CameraSensor *sensor,
StreamConfiguration *cfg);