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
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
/*
* Copyright (C) 2020, Google Inc.
*
* ipu3.cpp - IPU3 Image Processing Algorithms
*/
#include <algorithm>
#include <array>
#include <cmath>
#include <limits>
#include <map>
#include <memory>
#include <stdint.h>
#include <utility>
#include <vector>
#include <linux/intel-ipu3.h>
#include <linux/v4l2-controls.h>
#include <libcamera/base/log.h>
#include <libcamera/base/utils.h>
#include <libcamera/control_ids.h>
#include <libcamera/framebuffer.h>
#include <libcamera/ipa/ipa_interface.h>
#include <libcamera/ipa/ipa_module_info.h>
#include <libcamera/ipa/ipu3_ipa_interface.h>
#include <libcamera/request.h>
#include "libcamera/internal/mapped_framebuffer.h"
#include "algorithms/agc.h"
#include "algorithms/algorithm.h"
#include "algorithms/awb.h"
#include "algorithms/blc.h"
#include "algorithms/tone_mapping.h"
#include "libipa/camera_sensor_helper.h"
/**
* \file ipa_context.h
* \brief Context and state information shared between the algorithms
*/
/**
* \struct IPASessionConfiguration
* \brief Session configuration for the IPA module
*
* The session configuration contains all IPA configuration parameters that
* remain constant during the capture session, from IPA module start to stop.
* It is typically set during the configure() operation of the IPA module, but
* may also be updated in the start() operation.
*/
/**
* \struct IPAFrameContext
* \brief Per-frame context for algorithms
*
* The frame context stores data specific to a single frame processed by the
* IPA. Each frame processed by the IPA has a context associated with it,
* accessible through the IPAContext structure.
*
* \todo Detail how to access contexts for a particular frame
*
* Each of the fields in the frame context belongs to either a specific
* algorithm, or to the top-level IPA module. A field may be read by any
* algorithm, but should only be written by its owner.
*/
/**
* \struct IPAContext
* \brief Global IPA context data shared between all algorithms
*
* \var IPAContext::configuration
* \brief The IPA session configuration, immutable during the session
*
* \var IPAContext::frameContext
* \brief The frame context for the frame being processed
*
* \todo While the frame context is supposed to be per-frame, this
* single frame context stores data related to both the current frame
* and the previous frames, with fields being updated as the algorithms
* are run. This needs to be turned into real per-frame data storage.
*/
/**
* \struct IPASessionConfiguration::grid
* \brief Grid configuration of the IPA
*
* \var IPASessionConfiguration::grid::bdsGrid
* \brief Bayer Down Scaler grid plane config used by the kernel
*
* \var IPASessionConfiguration::grid::bdsOutputSize
* \brief BDS output size configured by the pipeline handler
*
* \var IPASessionConfiguration::grid::stride
* \brief Number of cells on one line including the ImgU padding
*/
/**
* \struct IPASessionConfiguration::agc
* \brief AGC parameters configuration of the IPA
*
* \var IPASessionConfiguration::agc::minShutterSpeed
* \brief Minimum shutter speed supported with the configured sensor
*
* \var IPASessionConfiguration::grid::maxShutterSpeed
* \brief Maximum shutter speed supported with the configured sensor
*
* \var IPASessionConfiguration::grid::minAnalogueGain
* \brief Minimum analogue gain supported with the configured sensor
*
* \var IPASessionConfiguration::grid::maxAnalogueGain
* \brief Maximum analogue gain supported with the configured sensor
*/
/**
* \struct IPAFrameContext::agc
* \brief Context for the Automatic Gain Control algorithm
*
* The exposure and gain determined are expected to be applied to the sensor
* at the earliest opportunity.
*
* \var IPAFrameContext::agc::exposure
* \brief Exposure time expressed as a number of lines
*
* \var IPAFrameContext::agc::gain
* \brief Analogue gain multiplier
*
* The gain should be adapted to the sensor specific gain code before applying.
*/
/**
* \struct IPAFrameContext::awb
* \brief Context for the Automatic White Balance algorithm
*
* \struct IPAFrameContext::awb::gains
* \brief White balance gains
*
* \var IPAFrameContext::awb::gains::red
* \brief White balance gain for R channel
*
* \var IPAFrameContext::awb::gains::green
* \brief White balance gain for G channel
*
* \var IPAFrameContext::awb::gains::blue
* \brief White balance gain for B channel
*/
/**
* \struct IPAFrameContext::toneMapping
* \brief Context for ToneMapping and Gamma control
*
* \var IPAFrameContext::toneMapping::gammaCorrection
* \brief Per-pixel tone mapping implemented as a LUT
*
* The LUT structure is defined by the IPU3 kernel interface. See
* <linux/intel-ipu3.h> struct ipu3_uapi_gamma_corr_lut for further details.
*/
/* Minimum grid width, expressed as a number of cells */
static constexpr uint32_t kMinGridWidth = 16;
/* Maximum grid width, expressed as a number of cells */
static constexpr uint32_t kMaxGridWidth = 80;
/* Minimum grid height, expressed as a number of cells */
static constexpr uint32_t kMinGridHeight = 16;
/* Maximum grid height, expressed as a number of cells */
static constexpr uint32_t kMaxGridHeight = 60;
/* log2 of the minimum grid cell width and height, in pixels */
static constexpr uint32_t kMinCellSizeLog2 = 3;
/* log2 of the maximum grid cell width and height, in pixels */
static constexpr uint32_t kMaxCellSizeLog2 = 6;
namespace libcamera {
LOG_DEFINE_CATEGORY(IPAIPU3)
using namespace std::literals::chrono_literals;
namespace ipa::ipu3 {
/**
* \brief The IPU3 IPA implementation
*
* The IPU3 Pipeline defines an IPU3-specific interface for communication
* between the PipelineHandler and the IPA module.
*
* We extend the IPAIPU3Interface to implement our algorithms and handle events
* from the IPU3 PipelineHandler to satisfy requests from the application.
*
* At initialisation time, a CameraSensorHelper is instantiated to support
* camera-specific calculations, while the default controls are computed, and
* the algorithms are constructed and placed in an ordered list.
*
* The IPU3 ImgU operates with a grid layout to divide the overall frame into
* rectangular cells of pixels. When the IPA is configured, we determine the
* best grid for the statistics based on the pipeline handler Bayer Down Scaler
* output size.
*
* Two main events are then handled to operate the IPU3 ImgU by populating its
* parameter buffer, and adapting the settings of the sensor attached to the
* IPU3 CIO2 through sensor-specific V4L2 controls.
*
* When the event \a EventFillParams occurs we populate the ImgU parameter
* buffer with settings to configure the device in preparation for handling the
* frame queued in the Request.
*
* When the frame has completed processing, the ImgU will generate a statistics
* buffer which is given to the IPA as part of the \a EventStatReady event. At
* this event we run the algorithms to parse the statistics and cache any
* results for the next \a EventFillParams event.
*
* The individual algorithms are split into modular components that are called
* iteratively to allow them to process statistics from the ImgU in a defined
* order.
*
* The current implementation supports three core algorithms:
* - Automatic white balance (AWB)
* - Automatic gain and exposure control (AGC)
* - Black level correction (BLC)
* - Tone mapping (Gamma)
*
* AWB is implemented using a Greyworld algorithm, and calculates the red and
* blue gains to apply to generate a neutral grey frame overall.
*
* AGC is handled by calculating a histogram of the green channel to estimate an
* analogue gain and shutter time which will provide a well exposed frame. A
* low-pass IIR filter is used to smooth the changes to the sensor to reduce
* perceivable steps.
*
* The tone mapping algorithm provides a gamma correction table to improve the
* contrast of the scene.
*
* The black level compensation algorithm subtracts a hardcoded black level from
* all pixels.
*
* The IPU3 ImgU has further processing blocks to support image quality
* improvements through bayer and temporal noise reductions, however those are
* not supported in the current implementation, and will use default settings as
* provided by the kernel driver.
*
* Demosaicing is operating with the default parameters and could be further
* optimised to provide improved sharpening coefficients, checker artifact
* removal, and false color correction.
*
* Additional image enhancements can be made by providing lens and
* sensor-specific tuning to adapt for Black Level compensation (BLC), Lens
* shading correction (SHD) and Color correction (CCM).
*/
class IPAIPU3 : public IPAIPU3Interface
{
public:
int init(const IPASettings &settings,
const IPACameraSensorInfo &sensorInfo,
const ControlInfoMap &sensorControls,
ControlInfoMap *ipaControls) override;
int start() override;
void stop() override {}
int configure(const IPAConfigInfo &configInfo,
ControlInfoMap *ipaControls) override;
void mapBuffers(const std::vector<IPABuffer> &buffers) override;
void unmapBuffers(const std::vector<unsigned int> &ids) override;
void processEvent(const IPU3Event &event) override;
private:
void updateControls(const IPACameraSensorInfo &sensorInfo,
const ControlInfoMap &sensorControls,
ControlInfoMap *ipaControls);
void updateSessionConfiguration(const IPACameraSensorInfo &sensorInfo,
const ControlInfoMap &sensorControls);
void processControls(unsigned int frame, const ControlList &controls);
void fillParams(unsigned int frame, ipu3_uapi_params *params);
void parseStatistics(unsigned int frame,
int64_t frameTimestamp,
const ipu3_uapi_stats_3a *stats);
void setControls(unsigned int frame);
void calculateBdsGrid(const Size &bdsOutputSize);
std::map<unsigned int, MappedFrameBuffer> buffers_;
ControlInfoMap ctrls_;
IPACameraSensorInfo sensorInfo_;
/* Camera sensor controls. */
uint32_t defVBlank_;
uint32_t exposure_;
uint32_t minExposure_;
uint32_t maxExposure_;
uint32_t gain_;
uint32_t minGain_;
uint32_t maxGain_;
/* Interface to the Camera Helper */
std::unique_ptr<CameraSensorHelper> camHelper_;
/* Maintain the algorithms used by the IPA */
std::list<std::unique_ptr<ipa::ipu3::Algorithm>> algorithms_;
/* Local parameter storage */
struct IPAContext context_;
};
/**
* \brief Compute IPASessionConfiguration using the sensor information and the
* sensor V4L2 controls
*/
void IPAIPU3::updateSessionConfiguration(const IPACameraSensorInfo &sensorInfo,
const ControlInfoMap &sensorControls)
{
const ControlInfo &v4l2Exposure = sensorControls.find(V4L2_CID_EXPOSURE)->second;
int32_t minExposure = v4l2Exposure.min().get<int32_t>();
int32_t maxExposure = v4l2Exposure.max().get<int32_t>();
utils::Duration lineDuration = sensorInfo.lineLength * 1.0s
/ sensorInfo.pixelRate;
const ControlInfo &v4l2Gain = sensorControls.find(V4L2_CID_ANALOGUE_GAIN)->second;
int32_t minGain = v4l2Gain.min().get<int32_t>();
int32_t maxGain = v4l2Gain.max().get<int32_t>();
/*
* When the AGC computes the new exposure values for a frame, it needs
* to know the limits for shutter speed and analogue gain.
* As it depends on the sensor, update it with the controls.
*
* \todo take VBLANK into account for maximum shutter speed
*/
context_.configuration.agc.minShutterSpeed = minExposure * lineDuration;
context_.configuration.agc.maxShutterSpeed = maxExposure * lineDuration;
context_.configuration.agc.minAnalogueGain = camHelper_->gain(minGain);
context_.configuration.agc.maxAnalogueGain = camHelper_->gain(maxGain);
}
/**
* \brief Compute camera controls using the sensor information and the sensor
* V4L2 controls
*
* Some of the camera controls are computed by the pipeline handler, some others
* by the IPA module which is in charge of handling, for example, the exposure
* time and the frame duration.
*
* This function computes:
* - controls::ExposureTime
* - controls::FrameDurationLimits
*/
void IPAIPU3::updateControls(const IPACameraSensorInfo &sensorInfo,
const ControlInfoMap &sensorControls,
ControlInfoMap *ipaControls)
{
ControlInfoMap::Map controls{};
/*
* Compute exposure time limits by using line length and pixel rate
* converted to microseconds. Use the V4L2_CID_EXPOSURE control to get
* exposure min, max and default and convert it from lines to
* microseconds.
*/
double lineDuration = sensorInfo.lineLength / (sensorInfo.pixelRate / 1e6);
const ControlInfo &v4l2Exposure = sensorControls.find(V4L2_CID_EXPOSURE)->second;
int32_t minExposure = v4l2Exposure.min().get<int32_t>() * lineDuration;
int32_t maxExposure = v4l2Exposure.max().get<int32_t>() * lineDuration;
int32_t defExposure = v4l2Exposure.def().get<int32_t>() * lineDuration;
controls[&controls::ExposureTime] = ControlInfo(minExposure, maxExposure,
defExposure);
/*
* Compute the frame duration limits.
*
* The frame length is computed assuming a fixed line length combined
* with the vertical frame sizes.
*/
const ControlInfo &v4l2HBlank = sensorControls.find(V4L2_CID_HBLANK)->second;
uint32_t hblank = v4l2HBlank.def().get<int32_t>();
uint32_t lineLength = sensorInfo.outputSize.width + hblank;
const ControlInfo &v4l2VBlank = sensorControls.find(V4L2_CID_VBLANK)->second;
std::array<uint32_t, 3> frameHeights{
v4l2VBlank.min().get<int32_t>() + sensorInfo.outputSize.height,
v4l2VBlank.max().get<int32_t>() + sensorInfo.outputSize.height,
v4l2VBlank.def().get<int32_t>() + sensorInfo.outputSize.height,
};
std::array<int64_t, 3> frameDurations;
for (unsigned int i = 0; i < frameHeights.size(); ++i) {
uint64_t frameSize = lineLength * frameHeights[i];
frameDurations[i] = frameSize / (sensorInfo.pixelRate / 1000000U);
}
controls[&controls::FrameDurationLimits] = ControlInfo(frameDurations[0],
frameDurations[1],
frameDurations[2]);
*ipaControls = ControlInfoMap(std::move(controls), controls::controls);
}
/**
* \brief Initialize the IPA module and its controls
*
* This function receives the camera sensor information from the pipeline
* handler, computes the limits of the controls it handles and returns
* them in the \a ipaControls output parameter.
*/
int IPAIPU3::init(const IPASettings &settings,
const IPACameraSensorInfo &sensorInfo,
const ControlInfoMap &sensorControls,
ControlInfoMap *ipaControls)
{
camHelper_ = CameraSensorHelperFactory::create(settings.sensorModel);
if (camHelper_ == nullptr) {
LOG(IPAIPU3, Error)
<< "Failed to create camera sensor helper for "
<< settings.sensorModel;
return -ENODEV;
}
/* Construct our Algorithms */
algorithms_.push_back(std::make_unique<algorithms::Agc>());
algorithms_.push_back(std::make_unique<algorithms::Awb>());
algorithms_.push_back(std::make_unique<algorithms::BlackLevelCorrection>());
algorithms_.push_back(std::make_unique<algorithms::ToneMapping>());
/* Initialize controls. */
updateControls(sensorInfo, sensorControls, ipaControls);
return 0;
}
/**
* \brief Perform any processing required before the first frame
*/
int IPAIPU3::start()
{
/*
* Set the sensors V4L2 controls before the first frame to ensure that
* we have an expected and known configuration from the start.
*/
setControls(0);
return 0;
}
/**
* \brief Calculate a grid for the AWB statistics
*
* This function calculates a grid for the AWB algorithm in the IPU3 firmware.
* Its input is the BDS output size calculated in the ImgU.
* It is limited for now to the simplest method: find the lesser error
* with the width/height and respective log2 width/height of the cells.
*
* \todo The frame is divided into cells which can be 8x8 => 64x64.
* As a smaller cell improves the algorithm precision, adapting the
* x_start and y_start parameters of the grid would provoke a loss of
* some pixels but would also result in more accurate algorithms.
*/
void IPAIPU3::calculateBdsGrid(const Size &bdsOutputSize)
{
Size best;
Size bestLog2;
/* Set the BDS output size in the IPAConfiguration structure */
context_.configuration.grid.bdsOutputSize = bdsOutputSize;
uint32_t minError = std::numeric_limits<uint32_t>::max();
for (uint32_t shift = kMinCellSizeLog2; shift <= kMaxCellSizeLog2; ++shift) {
uint32_t width = std::clamp(bdsOutputSize.width >> shift,
kMinGridWidth,
kMaxGridWidth);
width = width << shift;
uint32_t error = std::abs(static_cast<int>(width - bdsOutputSize.width));
if (error >= minError)
continue;
minError = error;
best.width = width;
bestLog2.width = shift;
}
minError = std::numeric_limits<uint32_t>::max();
for (uint32_t shift = kMinCellSizeLog2; shift <= kMaxCellSizeLog2; ++shift) {
uint32_t height = std::clamp(bdsOutputSize.height >> shift,
kMinGridHeight,
kMaxGridHeight);
height = height << shift;
uint32_t error = std::abs(static_cast<int>(height - bdsOutputSize.height));
if (error >= minError)
continue;
minError = error;
best.height = height;
bestLog2.height = shift;
}
struct ipu3_uapi_grid_config &bdsGrid = context_.configuration.grid.bdsGrid;
bdsGrid.x_start = 0;
bdsGrid.y_start = 0;
bdsGrid.width = best.width >> bestLog2.width;
bdsGrid.block_width_log2 = bestLog2.width;
bdsGrid.height = best.height >> bestLog2.height;
bdsGrid.block_height_log2 = bestLog2.height;
/* The ImgU pads the lines to a multiple of 4 cells. */
context_.configuration.grid.stride = utils::alignUp(bdsGrid.width, 4);
LOG(IPAIPU3, Debug) << "Best grid found is: ("
<< (int)bdsGrid.width << " << " << (int)bdsGrid.block_width_log2 << ") x ("
<< (int)bdsGrid.height << " << " << (int)bdsGrid.block_height_log2 << ")";
}
/**
* \brief Configure the IPU3 IPA
* \param[in] configInfo The IPA configuration data, received from the pipeline
* handler
* \param[in] ipaControls The IPA controls to update
*
* Calculate the best grid for the statistics based on the pipeline handler BDS
* output, and parse the minimum and maximum exposure and analogue gain control
* values.
*
* \todo Document what the BDS is, ideally in a block diagram of the ImgU.
*
* All algorithm modules are called to allow them to prepare the
* \a IPASessionConfiguration structure for the \a IPAContext.
*/
int IPAIPU3::configure(const IPAConfigInfo &configInfo,
ControlInfoMap *ipaControls)
{
if (configInfo.sensorControls.empty()) {
LOG(IPAIPU3, Error) << "No sensor controls provided";
return -ENODATA;
}
sensorInfo_ = configInfo.sensorInfo;
/*
* Compute the sensor V4L2 controls to be used by the algorithms and
* to be set on the sensor.
*/
ctrls_ = configInfo.sensorControls;
const auto itExp = ctrls_.find(V4L2_CID_EXPOSURE);
if (itExp == ctrls_.end()) {
|