Most of the rpicam-apps display a preview image in a window. If there is no active desktop environment, the preview draws directly to the display using the Linux Direct Rendering Manager (DRM). Otherwise, rpicam-apps attempt to use the desktop environment. Both paths use zero-copy GPU buffer sharing: as a result, X forwarding is not supported.

If you run the X window server and want to use X forwarding, pass the qt-preview flag to render the preview window in a Qt window. The Qt preview window uses more resources than the alternatives.

To suppress the preview window entirely, pass the nopreview flag:

The info-text option displays image information on the window title bar using % directives. For example, the following command displays the current red and blue gain values:

For a full list of directives, see the info-text reference.

rpicam-still can save images in multiple formats, including png, bmp, and both RGB and YUV binary pixel dumps. To read these binary dumps, any application reading the files must understand the pixel arrangement.

Use the encoding option to specify an output format. The file name passed to output has no impact on the output file type.

To capture a full resolution PNG image and save it to a file named test.png, run the following command:

For more information about specifying an image format, see the encoding option reference.

Raw images are the images produced directly by the image sensor, before any processing is applied to them either by the Image Signal Processor (ISP) or CPU. Colour image sensors usually use the Bayer format. Use the raw option to capture raw images.

To capture an image, save it to a file named test.jpg, and also save a raw version of the image to a file named test.dng, run the following command:

rpicam-still saves raw images in the DNG (Adobe Digital Negative) format. To determine the filename of the raw images, rpicam-still uses the same name as the output file, with the extension changed to .dng. To work with DNG images, use an application like Dcraw or RawTherapee.

DNG files contain metadata about the image capture, including black levels, white balance information and the colour matrix used by the ISP to produce the JPEG. Use ExifTool to view DNG metadata. The following output shows typical metadata stored in a raw image captured by a Raspberry Pi using the HQ camera:

To find the analogue gain, divide the ISO number by 100. The Auto White Balance (AWB) algorithm determines a single calibrated illuminant, which is always labelled D65.

To capture very long exposure images, disable the Automatic Exposure/Gain Control (AEC/AGC) and Auto White Balance (AWB). These algorithms will otherwise force the user to wait for a number of frames while they converge.

To disable these algorithms, supply explicit values for gain and AWB. Because long exposures take plenty of time already, it often makes sense to skip the preview phase entirely with the immediate option.

To perform a 100 second exposure capture, run the following command:

To find the maximum exposure times of official Raspberry Pi cameras, see the camera hardware specification.

To create a time lapse video, capture a still image at a regular interval, such as once a minute, then use an application to stitch the pictures together into a video.

rpicam-vid supports motion JPEG as well as both uncompressed and unformatted YUV420:

The codec option determines the output format, not the extension of the output file.

The segment option breaks output files up into chunks of the segment size (given in milliseconds). This is handy for breaking a motion JPEG stream up into individual JPEG files by specifying very short (1 millisecond) segments. For example, the following command combines segments of 1 millisecond with a counter in the output file name to generate a new filename for each segment:

To minimise frame drops for high framerate (> 60fps) video, try the following configuration tweaks:

The following command demonstrates how you might achieve 1280×720 120fps video:

rpicam-vid can use the ffmpeg/libav codec backend to encode audio and video streams. You can either save these streams to a file or stream them over the network. libav uses hardware H.264 video encoding when present.

To enable the libav backend, pass libav to the codec option:

Raspberry Pi’s libcamera implementation includes a tuning file for each camera. This file controls algorithms and hardware to produce the best image quality. libcamera can only determine the sensor in use, not the module. As a result, some modules require a tuning file override. Use the tuning-file option to specify an override. You can also copy and alter existing tuning files to customise camera behaviour.

For example, the no-IR-filter (NoIR) versions of sensors use Auto White Balance (AWB) settings different from the standard versions. On a Raspberry Pi 5 or later, you can specify the the NoIR tuning file for the IMX219 sensor with the following command:

libcamera maintains tuning files for a number of cameras, including third-party models. For instance, you can find the tuning file for the Soho Enterprises SE327M12 in se327m12.json.

rpicam-apps depends on library packages named library-name<n>, where <n> is the ABI version. Your package manager should install these automatically.

You can rebuild rpicam-apps without building libcamera and libepoxy from scratch. For more information, see Building rpicam-apps without rebuilding libcamera.

To stream using RTP, run the following command on the server, replacing the <ip-addr> placeholder with the IP address of the client or multicast address and replacing the <port> placeholder with the port you would like to use for streaming:

To receive over RTP, run the following command on the client, replacing the <ip-addr> placeholder with the IP address of the client or multicast address and replacing the <port> placeholder with the port you would like to use for streaming:

If the client is not a Raspberry Pi it may have different GStreamer elements available. On an x86 device running Linux, you might run the following command instead:

libcamera provides a libcamerasrc GStreamer element which can be used directly instead of rpicam-vid. To use this element, run the following command on the server, replacing the <ip-addr> placeholder with the IP address of the client or multicast address and replacing the <port> placeholder with the port you would like to use for streaming:

and on the client we use the same playback pipeline as previously.

Sets image sharpness. Accepts a numeric value along the following spectrum:

Specifies the image contrast. Accepts a numeric value along the following spectrum:

Specifies the image brightness, added as an offset to all pixels in the output image. Accepts a numeric value along the following spectrum:

For many use cases, prefer ev.

Specifies the image colour saturation. Accepts a numeric value along the following spectrum:

Specifies the exposure value (EV) compensation of the image in stops. Accepts a numeric value that controls target values passed to the Automatic Exposure/Gain Control (AEC/AGC) processing algorithm along the following spectrum:

Specifies the exposure time, using the shutter, in microseconds. Gain can still vary when you use this option. If the camera runs at a framerate so fast it does not allow for the specified exposure time (for instance, a framerate of 1fps and an exposure time of 10000 microseconds), the sensor will use the maximum exposure time allowed by the framerate.

For a list of minimum and maximum shutter times for official cameras, see the camera hardware documentation. Values above the maximum result in undefined behaviour.

Alias: --analoggain

Sets the combined analogue and digital gain. When the sensor driver can provide the requested gain, only uses analogue gain. When analogue gain reaches the maximum value, the ISP applies digital gain. Accepts a numeric value.

For a list of analogue gain limits, for official cameras, see the camera hardware documentation.

Sometimes, digital gain can exceed 1.0 even when the analogue gain limit is not exceeded. This can occur in the following situations:

Default value: centre

Sets the metering mode of the Automatic Exposure/Gain Control (AEC/AGC) algorithm. Accepts the following values:

For more information on defining a custom metering mode, and adjusting region weights in existing metering modes, see the Tuning guide for the Raspberry Pi cameras and libcamera.

Sets the exposure profile. Changing the exposure profile should not affect the image exposure. Instead, different modes adjust gain settings to achieve the same net result. Accepts the following values:

You can edit exposure profiles using tuning files. For more information, see the Tuning guide for the Raspberry Pi cameras and libcamera.

Sets the Auto White Balance (AWB) mode. Accepts the following values:

These values are only approximate: values could vary according to the camera tuning.

No mode fully disables AWB. Instead, you can fix colour gains with awbgains.

For more information on AWB modes, including how to define a custom one, see the Tuning guide for the Raspberry Pi cameras and libcamera.

Sets a fixed red and blue gain value to be used instead of an Auto White Balance (AWB) algorithm. Set non-zero values to disable AWB. Accepts comma-separated numeric input in the following format: <red_gain>,<blue_gain>

Default value: auto

Sets the denoising mode. Accepts the following values:

Even fast colour denoise can lower framerates. High quality colour denoise significantly lowers framerates.

Specifies the camera tuning file. The tuning file allows you to control many aspects of image processing, including the Automatic Exposure/Gain Control (AEC/AGC), Auto White Balance (AWB), colour shading correction, colour processing, denoising and more. Accepts a tuning file path as input.

For more information about tuning files, see Tuning Files.

Default value: default

Specifies the autofocus mode. Accepts the following values:

This option is only supported for certain camera modules.

Default value: normal

Specifies the autofocus range. Accepts the following values:

This option is only supported for certain camera modules.

Default value: normal

Specifies the autofocus speed. Accepts the following values:

This option is only supported for certain camera modules.

Specifies the autofocus window within the full field of the sensor. Accepts four decimal values, ranged 0 to 1, in the following format: <x>,<y>,<w>,h>. Each of these values represents a percentage of the available width and heights as a decimal between 0 and 1.

These values define the following proportions:

The default value uses the middle third of the output image in both dimensions (1/9 of the total image area).

Examples:

This option is only supported for certain camera modules.

Default value: default

Moves the lens to a fixed focal distance, normally given in dioptres (units of 1 / distance in metres). Accepts the following spectrum of values:

Lens calibration is imperfect, so different camera modules of the same model may vary.

Alias: -v

Default value: 1

Sets the verbosity level. Accepts the following values:

Alias: -o

Sets the name of the file used to record images or video. Besides plaintext file names, accepts the following special values:

Examples:

Sets a maximum value for the counter used by the output %d directive. The counter resets to zero after reaching this value. Accepts a numeric value.

Flushes output files to disk as soon as a frame finishes writing, instead of waiting for the system to handle it. Does not accept a value.

Specifies a JSON file that configures the post-processing applied by the imaging pipeline. This applies to camera images before they reach the application. This works similarly to the legacy raspicam "image effects". Accepts a file name path as input.

Post-processing is a large topic and admits the use of third-party software like OpenCV and TensorFlowLite to analyse and manipulate images. For more information, see post-processing.

Alias: -q

Default value: 93

Sets the JPEG quality. Accepts a value between 1 and 100.

Saves extra EXIF tags in the JPEG output file. Only applies to JPEG output. Because of limitations in the libexif library, many tags are currently (incorrectly) formatted as ASCII and print a warning in the terminal.

This option is necessary to add certain EXIF tags related to camera settings. You can add tags unrelated to camera settings to the output JPEG after recording with ExifTool.

Example: rpicam-still -o test.jpg --exif IDO0.Artist=Someone

Records images at the specified interval. Accepts an interval in milliseconds. Combine this setting with timeout to capture repeated images over time.

You can specify separate filenames for each output file using string formatting, e.g. --output test%d.jpg.

Example: rpicam-still -t 100000 -o test%d.jpg --timelapse 10000 captures an image every 10 seconds for 100 seconds.

Configures a starting value for the frame counter accessed in output file names as %d. Accepts an integer starting value.

Uses the current date and time in the output file name, in the form MMDDhhmmss.jpg:

Does not accept a value.

Uses the current system Unix time as the output file name. Does not accept a value.

Default value: 0

Configures the restart marker interval for JPEG output. JPEG restart markers can help limit the impact of corruption on JPEG images, and additionally enable the use of multi-threaded JPEG encoding and decoding. Accepts an integer value.

Captures the image immediately when the application runs.

Alias: -k

Captures an image when the timeout expires or on press of the Enter key, whichever comes first. Press the x key, then Enter to exit without capturing. Does not accept a value.

Captures an image when the timeout expires or when SIGUSR1 is received. Use SIGUSR2 to exit without capturing. Does not accept a value.

Default value: 320:240:70

Configure the dimensions and quality of the thumbnail with the following format: <w:h:q> (or none, which omits the thumbnail).

Alias: -e

Default value: jpg

Sets the encoder to use for image output. Accepts the following values:

This option always determines the encoding, overriding the extension passed to output.

When using the datetime and timestamp options, this option determines the output file extension.

Alias: -r

Saves a raw Bayer file in DNG format in addition to the output image. Replaces the output file name extension with .dng. You can process these standard DNG files with tools like dcraw or RawTherapee. Does not accept a value.

The image data in the raw file is exactly what came out of the sensor, with no processing from the ISP or anything else. The EXIF data saved in the file, among other things, includes:

Creates a symbolic link to the most recently saved file. Accepts a symbolic link name as input.

If set, runs an autofocus cycle just before capturing an image. Interacts with the following autofocus_mode values:

Does not require a value, but you can pass 1 to enable and 0 to disable. Not passing a value is equivalent to passing 1.

Only supported by some camera modules (such as the Raspberry Pi Camera Module 3).

Alias: -q

Default value: 50

Accepts an MJPEG quality level between 1 and 100. Only applies to videos encoded in the MJPEG format.

Alias: -b

Controls the target bitrate used by the H.264 encoder in bits per second. Only applies to videos encoded in the H.264 format. Impacts the size of the output video.

Example: rpicam-vid -b 10000000 --width 1920 --height 1080 -o test.h264

Alias: -g

Default value: 60

Sets the frequency of Iframes (intra frames) in the H.264 bitstream. Accepts a number of frames. Only applies to videos encoded in the H.264 format.

Sets the H.264 profile. Accepts the following values:

Only applies to videos encoded in the H.264 format.

Sets the H.264 level. Accepts the following values:

Only applies to videos encoded in the H.264 format.

Sets the encoder to use for video output. Accepts the following values:

Enables frame timestamp output, which allow you to convert the bitstream into a container format using a tool like mkvmerge. Accepts a plaintext file name for the timestamp output file.

Example: rpicam-vid -o test.h264 --save-pts timestamps.txt

You can then use the following command to generate an MKV container file from the bitstream and timestamps file:

Alias: -k

Allows the CLI to enable and disable video output using the Enter key. Always starts in the recording state unless specified otherwise with initial. Type the x key and press Enter to exit. Does not accept a value.

Alias: -s

Allows the CLI to enable and disable video output using SIGUSR1. Use SIGUSR2 to exit. Always starts in the recording state unless specified otherwise with initial. Does not accept a value.

Default value: record

Specifies whether to start the application with video output enabled or disabled. Accepts the following values:

Use this option with either keypress or signal to toggle between the two states.

When toggling recording with keypress or signal, writes the video output from separate recording sessions into separate files. Does not accept a value. Unless combined with output to specify unique names for each file, overwrites each time it writes a file.

Cuts video output into multiple files of the passed duration. Accepts a duration in milliseconds. If passed a very small duration (for instance, 1), records each frame to a separate output file to simulate burst capture.

You can specify separate filenames for each file using string formatting, e.g. --output test%04d.h264.

Default value: 4

Writes video recording into a circular buffer in memory. When the application quits, records the circular buffer to disk. Accepts an optional size in megabytes.

Writes a sequence header in every Iframe (intra frame). This can help clients decode the video sequence from any point in the video, instead of just the beginning. Recommended with segment, split, circular, and streaming options.

Only applies to videos encoded in the H.264 format. Does not accept a value.

Waits for an incoming client connection before encoding video. Intended for network streaming over TCP/IP. Does not accept a value.

Records exactly the specified number of frames. Any non-zero value overrides timeout. Accepts a nonzero integer.

Records exactly the specified framerate. Accepts a nonzero integer.

Sets the libav output format. Accepts the following values:

If you do not provide this option, the file extension passed to the output option determines the file format.

Enables audio recording. When enabled, you must also specify an audio-codec. Does not accept a value.

Default value: aac

Selects an audio codec for output. For a list of available codecs, run ffmpeg -codecs.

Sets the bitrate for audio encoding in bits per second. Accepts numeric input.

Example: rpicam-vid --codec libav -o test.mp4 --audio_codec mp2 --audio-bitrate 16384 (Records audio at 16 kilobits/sec with the mp2 codec)

Default value: 0

Sets the audio sampling rate in Hz. Accepts numeric input. 0 uses the input sample rate.

Select an ALSA input device for audio recording. For a list of available devices, run the following command:

You should see output similar to the following:

Shifts the audio sample timestamp by a value in microseconds. Accepts positive and negative numeric values.

Detects objects with the given name, sourced from the model’s label file. Accepts a plaintext file name as input.

Wait at least this many frames between captures. Accepts numeric values.

This stage turns light pixels dark and dark pixels light.

The negate stage has no user-configurable parameters.

Default negate.json file:

Run the following command to use this stage file with rpicam-hello:

Example output:

This stage emphasises details in images using High Dynamic Range (HDR) and Dynamic Range Compression (DRC). DRC uses a single image, while HDR combines multiple images for a similar result.

Parameters fall into three groups: the LP filter, global tonemapping, and local contrast.

This stage applies a smoothing filter to the fully-processed input images to generate a low pass (LP) image. It then generates the high pass (HP) image from the diff of the original and LP images. Then, it applies a global tonemap to the LP image and adds it back to the HP image. This process helps preserve local contrast.

You can configure this stage with the following parameters:

To control processing strength, changing the global_tonemap_strength and local_tonemap_strength parameters.

Processing a single image takes between two and three seconds for a 12MP image on a Raspberry Pi 4. When accumulating multiple frames, this stage sends only the processed image to the application.

Default drc.json file for DRC:

Example:

Run the following command to use this stage file with rpicam-still:

Default hdr.json file for HDR:

Example:

Run the following command to use this stage file with rpicam-still:

The motion_detect stage analyses frames from the low-resolution image stream. You must configure the low-resolution stream to use this stage. The stage detects motion by comparing a region of interest (ROI) in the frame to the corresponding part of a previous frame. If enough pixels change between frames, this stage indicates the motion in metadata under the motion_detect.result key.

This stage has no dependencies on third-party libraries.

You can configure this stage with the following parameters, passing dimensions as a proportion of the low-resolution image size between 0 and 1:

Default motion_detect.json configuration file:

Adjust the differences and the threshold to make the algorithm more or less sensitive. To improve performance, use the hskip and vskip parameters.

Run the following command to use this stage file with rpicam-hello:

This stage applies a Sobel filter to an image to emphasise edges.

You can configure this stage with the following parameters:

Default sobel_cv.json file:

Example:

This stage uses the OpenCV Haar classifier to detect faces in an image. It returns face location metadata under the key face_detect.results and optionally draws the locations on the image.

You can configure this stage with the following parameters:

The face_detect_cv stage runs only during preview and video capture. It ignores still image capture. It runs on the low resolution stream with a resolution between 320×240 and 640×480 pixels.

Default face_detect_cv.json file:

Example:

This stage writes text into the top corner of images using the same % substitutions as the info-text option.

Interprets info-text directives first, then passes any remaining tokens to strftime.

For example, to achieve a datetime stamp on the video, pass %F %T %z:

This stage does not output any metadata, but it writes metadata found in annotate.text in place of anything in the JSON configuration file. This allows other post-processing stages to write text onto images.

You can configure this stage with the following parameters:

Default annotate_cv.json file:

Example:

Download: https://storage.googleapis.com/download.tensorflow.org/models/mobilenet_v1_2018_08_02/mobilenet_v1_1.0_224_quant.tgz

object_classify_tf uses a Google MobileNet v1 model to classify objects in the camera image. This stage requires a labels.txt file.

You can configure this stage with the following parameters:

Example object_classify_tf.json file:

The stage operates on a low resolution stream image of size 224×224. Run the following command to use this stage file with rpicam-hello:

Download: https://github.com/Qengineering/TensorFlow_Lite_Pose_RPi_32-bits

pose_estimation_tf uses a Google MobileNet v1 model to detect pose information.

You can configure this stage with the following parameters:

Use the separate plot_pose_cv stage to draw the detected pose onto the main image.

You can configure the plot_pose_cv stage with the following parameters:

Example pose_estimation_tf.json file:

The stage operates on a low resolution stream image of size 257×257. Because YUV420 images must have even dimensions, round up to 258×258 for YUV420 images.

Run the following command to use this stage file with rpicam-hello:

Download: https://storage.googleapis.com/download.tensorflow.org/models/tflite/coco_ssd_mobilenet_v1_1.0_quant_2018_06_29.zip

object_detect_tf uses a Google MobileNet v1 SSD (Single Shot Detector) model to detect and label objects.

You can configure this stage with the following parameters:

Use the separate object_detect_draw_cv stage to draw the detected objects onto the main image.

You can configure the object_detect_draw_cv stage with the following parameters:

Example object_detect_tf.json file:

The stage operates on a low resolution stream image of size 300×300. Run the following command, which passes a 300×300 crop to the detector from the centre of the 400×300 low resolution image, to use this stage file with rpicam-hello:

Download: https://tfhub.dev/tensorflow/lite-model/deeplabv3/1/metadata/2?lite-format=tflite

segmentation_tf uses a Google MobileNet v1 model. This stage requires a label file, found at the assets/segmentation_labels.txt.

This stage runs on an image of size 257×257. Because YUV420 images must have even dimensions, the low resolution image should be at least 258 pixels in both width and height. The stage adds a vector of 257×257 values to the image metadata where each value indicates the categories a pixel belongs to. You can optionally draw a representation of the segmentation into the bottom right corner of the image.

You can configure this stage with the following parameters:

Example segmentation_tf.json file:

This example takes a camera image and reduces it to 258×258 pixels in size. This stage even works when squashing a non-square image without cropping. This example enables the segmentation map in the bottom right hand corner.

Run the following command to use this stage file with rpicam-hello:

To create your own post-processing stage, derive a new class from the PostProcessingStage class. All post-processing stages must implement the following member functions:

In any stage implementation, call RegisterStage to register your stage with the system.

Don’t forget to add your stage to meson.build in the post-processing folder. When writing your own stages, keep these tips in mind:

For a basic example, see negate_stage.cpp. This stage negates an image by turning light pixels dark and dark pixels light. This stage is mostly derived class boiler-plate, achieving the negation logic in barely half a dozen lines of code.

For another example, see sobel_cv_stage.cpp, which implements a Sobel filter in just a few lines of OpenCV functions.

For stages that use TensorFlow Lite (TFLite), derive a new class from the TfStage class. This class delegates model execution to a separate thread to prevent camera stuttering.

The TfStage class implements all the PostProcessingStage member functions post-processing stages must normally implement, except for Name. All TfStage-derived stages must implement the Name function, and should implement some or all of the following virtual member functions:

For an example implementation, see the object_classify_tf_stage.cpp and pose_estimation_tf_stage.cpp.

rpicam-hello is the smallest application, and the best place to start understanding rpicam-apps design. It extracts the CompletedRequestPtr, a shared pointer to the CompletedRequest, from the message, and forwards it to the preview window:

Every CompletedRequest must be recycled back to the camera system so that the buffers can be reused. Otherwise, the camera runs out of buffers for new camera frames. This recycling process happens automatically when no references to the CompletedRequest remain using C++'s shared pointer and custom deleter mechanisms.

As a result, rpicam-hello must complete the following actions to recycle the buffer space:

rpicam-vid is similar to rpicam-hello with encoding added to the event loop. Before the event loop starts, rpicam-vid configures the encoder with a callback. The callback handles the buffer containing the encoded image data. In the code below, we send the buffer to the Output object. Output could write it to a file or stream it, depending on the options specified.

Because this code passes the encoder a reference to the CompletedRequest, rpicam-vid can’t recycle buffer data until the event loop, preview window, and encoder all discard their references.

rpicam-raw is similar to rpicam-vid. It also encodes during the event loop. However, rpicam-raw uses a dummy encoder called the NullEncoder. This uses the input image as the output buffer instead of encoding it with a codec. NullEncoder only discards its reference to the buffer once the output callback completes. This guarantees that the buffer isn’t recycled before the callback processes the image.

rpicam-raw doesn’t forward anything to the preview window.

NullEncoder is possibly overkill in rpicam-raw. We could probably send images straight to the Output object, instead. However, rpicam-apps need to limit work in the event loop. NullEncoder demonstrates how you can handle most processes (even holding onto a reference) in other threads.

rpicam-jpeg starts the camera in preview mode in the usual way. When the timer completes, it stops the preview and switches to still capture:

The event loop grabs the first frame returned from still mode and saves this as a JPEG.

Recent Raspberry Pi OS images include Picamera2 with all the GUI (Qt and OpenGL) dependencies. Recent Raspberry Pi OS Lite images include Picamera2 without the GUI dependencies, although preview images can still be displayed using DRM/KMS.

If your image did not include Picamera2, run the following command to install Picamera2 with all of the GUI dependencies:

If you don’t want the GUI dependencies, you can run the following command to install Picamera2 without the GUI dependencies:

To remove the banner from the captured image, use the --no-banner flag:

You should see output similar to the following:

There is a fully open-source kernel driver available for the Unicam block; this kernel module, called bcm2835-unicam, interfaces with V4L2 subdevice drivers to deliver raw frames. This bcm2835-unicam driver controls the sensor and configures the Camera Serial Interface 2 (CSI-2) receiver. Peripherals write raw frames (after Debayer) to SDRAM for V4L2 to deliver to applications. There is no image processing between the camera sensor capturing the image and the bcm2835-unicam driver placing the image data in SDRAM except for Bayer unpacking to 16bits/pixel.

Mainline Linux contains a range of existing drivers. The Raspberry Pi kernel tree has some additional drivers and Device Tree overlays to configure them:

As the subdevice driver is also a kernel driver with a standardised API, third parties are free to write their own for any source of their choosing.

The sensor driver for a camera sensor is responsible for all configuration of the device, usually via I2C or SPI. Rather than writing a driver from scratch, it is often easier to take an existing driver as a basis and modify it as appropriate.

The IMX219 driver is a good starting point. This driver supports both 8bit and 10bit Bayer readout, so enumerating frame formats and frame sizes is slightly more involved.

Sensors generally support V4L2 user controls. Not all these controls need to be implemented in a driver. The IMX219 driver only implements a small subset, listed below, the implementation of which is handled by the imx219_set_ctrl function.

In the case of the IMX219, many of these controls map directly onto register writes to the sensor itself.

Further guidance can be found in the libcamera sensor driver requirements, and in chapter 3 of the Raspberry Pi Camera tuning guide.

These are devices that convert an incoming video stream, for example HDMI or composite, into a CSI-2 stream that can be accepted by the Raspberry Pi CSI-2 receiver.

Handling bridge chips is more complicated. Unlike camera sensors, they have to respond to the incoming signal and report that to the application.

The mechanisms for handling bridge chips can be split into two categories: either analogue or digital.

When using ioctls in the sections below, an S in the ioctl name means it is a set function, while G is a get function and ENUM enumerates a set of permitted values.