Camera & Imaging¶

DVP camera interface, ISP, and hardware MJPEG encoding and decoding.

hal_cam.h¶

#include "hal_cam.h" (Source)

Camera capture driver without the ISP: DVP or SPI camera input written to memory, with output crop, frame-rate control and ping-pong buffers.

The driver feeds the camera input (DVP_AS or SPI2DVP) directly to the DVP-to-AXI writers, without the image signal processor. Use hal_isp.h instead when scaling, colour conversion or several output channels are needed.

Typical sequence: configure the sensor, fill a cam_hal_cfg_t, cam_init(), then cam_start(). Each written frame is reported through cam_hal_cfg_t::out_callback from the capture interrupt. cam_deinit() removes the callback.

cam_init¶

int cam_init(cam_hal_cfg_t *cam_hal_cfg);

Initialize camera capture.

Configures the input path and the DVP-to-AXI writers and installs the capture interrupt. Capture starts with cam_start().

Returns: Always 0. An invalid crop window (reported on the console) is replaced by no cropping, and an invalid frame-rate setting by the full frame rate.

cam_start¶

int cam_start(void);

Enable the configured input source so that frames are received.

Returns: Always 0.

cam_deinit¶

int cam_deinit(void);

Disable the capture interrupt and remove the frame callback.

The input source and the writers are not disabled.

Returns: Always 0.

cam_fps_cfg¶

int cam_fps_cfg(cam_hal_frame_rate_t frc);

Change the output frame rate at run time.

cam_hal_src_e¶

Camera input source.

cam_hal_out_format_e¶

Output format.

Anonymous enum¶

Events reported in cam_out_frame_info_t::event.

cam_hal_spi2dvp_data_order_e¶

SPI2DVP data order.

cam_hal_spi2dvp_data_format_e¶

SPI2DVP input format.

cam_hal_spi2dvp_mode_e¶

SPI2DVP SPI mode (clock phase and polarity).

cam_hal_spi2dvp_data_endian_e¶

SPI2DVP bit order.

cam_hal_dvp_active_type_e¶

DVP HSYNC/VSYNC active level.

cam_hal_dvp_data_byte_t¶

DVP input byte order.

cam_hal_spi2dvp_input_t¶

SPI2DVP input configuration.

cam_hal_dvp_input_t¶

DVP input configuration.

cam_hal_src_cfg_t¶

Source-specific input configuration; the member is selected by cam_hal_cfg_t::cam_src.

cam_hal_size_t¶

Image size.

cam_hal_crop_t¶

Crop window.

cam_hal_frame_rate_t¶

Output frame-rate control.

Of every src_fps input frames, dst_fps are written; for example 30/15 writes every other frame.

cam_out_frame_info_t¶

Frame information passed to cam_hal_cfg_t::out_callback.

cam_hal_out_t¶

Output configuration.

cam_hal_cfg_t¶

Complete camera configuration for cam_init().

Macros¶

hal_isp.h¶

#include "hal_isp.h" (Source)

Image signal processor (ISP) driver: camera or memory input, global crop, two scaler output channels plus an extended channel, frame-rate control, digital zoom and ping-pong output buffers.

The ISP takes its input from a DVP camera, an SPI camera or a test source that reads frames from memory. Output channel 0 writes YUV or Y-only images, output channel 1 writes RGB or ARGB images, and the extended channel taps the image at a selectable point of the pipeline.

Typical sequence: configure the sensor, fill an isp_hal_cfg_t, isp_init(), then isp_start(). Each written frame is reported through isp_hal_cfg_t::out_callback from the capture interrupt. Zoom, frame rate and channel settings can be changed while running. isp_deinit() removes the callbacks and disables the input.

isp_init¶

int isp_init(isp_hal_cfg_t *isp_hal_cfg);

Initialize the ISP.

Configures the input path, the global crop, the YUV adjustment stage and every enabled output channel, and installs the capture interrupts. Processing starts with isp_start(). If the extended channel cannot be used because of the channel 0 format, it is skipped with a console message.

isp_start¶

int isp_start(void);

Enable the configured input source so that frames are processed.

Returns: Always 0.

isp_deinit¶

int isp_deinit(void);

Remove the channel callbacks and interrupts and disable the input source.

Returns: Always 0.

isp_tsrc_trigger¶

int isp_tsrc_trigger(void);

Make the test source send one frame.

Use with ISP_HAL_SRC_TSRC when isp_hal_tsrc_input_t::tsrc_conti is false.

Returns: Always 0.

isp_zoom_cfg¶

int isp_zoom_cfg(uint8_t channel, isp_hal_crop_t scaler_in);

Change the digital zoom (scaler input window) of a channel at run time.

The new window is applied when the ISP next reaches the middle line of a frame.

isp_fps_cfg¶

int isp_fps_cfg(uint8_t channel, isp_hal_frame_rate_t frc);

Change the output frame rate of a channel at run time.

isp_update_chn0_cfg¶

int isp_update_chn0_cfg(isp_hal_out_chnl_0_t chn0_cfg);

Change the configuration of output channel 0 at run time.

Reprograms the channel's scaler and writers and enables its interrupt if needed. Call it shortly after the start of a frame so that the change does not land in the middle of a frame. With enable set to 0 the channel is only marked as disabled; its hardware is not stopped.

Returns: Always 0.

isp_update_chn1_cfg¶

int isp_update_chn1_cfg(isp_hal_out_chnl_1_t chn1_cfg);

Change the configuration of output channel 1 at run time.

Reprograms the channel's scaler and writer and enables its interrupt if needed. Call it shortly after the start of a frame so that the change does not land in the middle of a frame. With enable set to 0 the channel is only marked as disabled; its hardware is not stopped.

Returns: Always 0.

isp_get_input_resolution¶

void isp_get_input_resolution(uint16_t *width, uint16_t *height);

Get the input image size passed to the last successful isp_init().

Anonymous enum¶

ISP output channel index.

isp_hal_src_e¶

ISP input source.

isp_hal_out_format0_e¶

Output formats of channel 0.

isp_hal_out_format1_e¶

Output formats of channel 1.

isp_hal_ext_src_e¶

Tap point of the extended channel.

isp_hal_out_format_ext_e¶

Output formats of the extended channel.

Anonymous enum¶

Events reported in isp_out_frame_info_t::event.

isp_hal_spi2dvp_sel_e¶

SPI port used by the SPI-to-DVP bridge.

isp_hal_spi2dvp_data_order_e¶

SPI2DVP data order.

isp_hal_spi2dvp_data_format_e¶

SPI2DVP input format.

isp_hal_spi2dvp_mode_e¶

SPI2DVP SPI mode (clock phase and polarity).

isp_hal_spi2dvp_data_endian_e¶

SPI2DVP bit order.

isp_hal_dvp_active_type_e¶

DVP HSYNC/VSYNC active level.

isp_hal_dvp_data_byte_t¶

DVP input byte order.

isp_hal_spi2dvp_input_t¶

SPI2DVP input configuration.

isp_hal_dvp_input_t¶

DVP input configuration.

isp_hal_tsrc_input_t¶

Test-source (memory input) configuration.

isp_hal_src_cfg_t¶

Source-specific input configuration; the member is selected by isp_hal_cfg_t::isp_src.

isp_hal_size_t¶

Image size.

isp_hal_crop_t¶

Crop window.

isp_hal_scaler_cfg_t¶

Scaler input and output of an output channel.

isp_hal_frame_rate_t¶

Output-channel frame-rate control.

Of every src_fps input frames, dst_fps are written; for example 30/15 writes every other frame.

isp_out_frame_info_t¶

Frame information passed to isp_hal_cfg_t::out_callback.

isp_hal_out_chn_comm_t¶

Settings common to all output channels.

isp_hal_out_chnl_0_t¶

Output channel 0 configuration.

isp_hal_out_chnl_1_t¶

Output channel 1 configuration.

isp_hal_out_chnl_ext_t¶

Extended output channel configuration.

isp_hal_cfg_t¶

Complete ISP configuration for isp_init().

Macros¶

hal_mjpeg.h¶

#include "hal_mjpeg.h" (Source)

Hardware JPEG encoder driver: encode YUV 4:2:2, YUV 4:2:0 or grey-scale frames to baseline JPEG in software-triggered or hardware auto mode.

The encoder shares the JPEG hardware block with the decoder (hal_mjdec.h); only one of them can be initialized at a time. Encoded frames are kept in a queue: mjpeg_get_one_frame() returns the oldest one and mjpeg_drop_one_frame() releases it.

Software-triggered sequence: mjpeg_init(); build a header with mjpeg_headerCreate() and load it with mjpeg_fill_header_tail(); for each frame, clean the data cache over the input, set the input planes with mjpeg_set_input_addr(), then for the first frame call mjpeg_set_mode(1, 1, 1) and mjpeg_start(1), and for later frames mjpeg_sw_run_next(); wait for MJENC_HAL_INT_NORMAL in the callback, fetch the frame, invalidate the data cache over it, use it and drop it. Finish with mjpeg_stop() and mjpeg_deinit().

In hardware auto mode (mjpeg_start(0)) the encoder reads the frames that the camera or ISP writes into the input buffer (a full frame or a ring of mjpeg_hal_cfg_t::rows lines) and encodes them continuously.

mjpeg_init¶

int mjpeg_init(struct mjpeg_hal_cfg_t *mjpeg_hal_cfg);

Initialize the encoder.

Claims the JPEG hardware for encoding, programs the format, image size, buffers and quantization tables, and installs and enables the encoder interrupt. The frame-done and error events stay masked until mjpeg_start(); the swap event is enabled when swap mode is selected.

mjpeg_deinit¶

int mjpeg_deinit(void);

Release the JPEG hardware from encoding.

mjpeg_start¶

void mjpeg_start(int is_sw_mode);

Start encoding.

Enables the frame-done and error events, then either triggers a software-mode run as configured by mjpeg_set_mode() or starts hardware auto mode.

mjpeg_stop¶

void mjpeg_stop(void);

Disable the encoder.

mjpeg_get_one_frame¶

uint8_t mjpeg_get_one_frame(uint32_t *addr, uint32_t *len);

Get the oldest encoded frame without removing it.

The frame (header included) stays valid until mjpeg_drop_one_frame() is called. Invalidate the data cache over it before reading it.

mjpeg_drop_one_frame¶

void mjpeg_drop_one_frame(void);

Release the oldest encoded frame so that its space can be reused.

mjpeg_fill_header_tail¶

void mjpeg_fill_header_tail(uint8_t *header, uint32_t header_len);

Load the JPEG header that the encoder writes in front of each frame.

mjpeg_headerCreate¶

uint32_t mjpeg_headerCreate(uint8_t type, uint8_t q, int width, int height, uint8_t *out);

Build a baseline JPEG header.

Writes the start-of-image marker, the luminance and chrominance quantization tables for quality q, the frame header, the standard Huffman tables and the start-of-scan header.

Returns: Header length in bytes: 605 for YUV_MODE_420 and YUV_MODE_422, 595 for YUV_MODE_400.

mjpeg_set_mode¶

void mjpeg_set_mode(int is_sw_mode, int is_frame_mode, int frm_cnt);

Configure software-triggered mode.

mjpeg_sw_run_next¶

void mjpeg_sw_run_next(void);

Trigger the next software-mode run.

mjpeg_sw_run_abort¶

void mjpeg_sw_run_abort(void);

Abort the current software-mode run.

mjpeg_sw_kick_block¶

void mjpeg_sw_kick_block(uint16_t kick_count);

Set the number of block rows encoded per kick in software kick mode.

mjpeg_sw_kick_stop¶

void mjpeg_sw_kick_stop(void);

Leave software kick mode.

mjpeg_sw_kick¶

void mjpeg_sw_kick(void);

Encode the next group of block rows in software kick mode.

mjpeg_set_input_addr¶

void mjpeg_set_input_addr(int type, uint32_t addr);

Set an input plane address.

mjpeg_get_swap_occur_cnt¶

uint32_t mjpeg_get_swap_occur_cnt(void);

Get the number of swap events in the current frame.

Counts MJENC_HAL_INT_SWAP events since mjpeg_init(), restarting from 0 when a swap event marks the end of a frame.

Returns: Number of swap events.

mjpeg_free_swap_memory¶

void mjpeg_free_swap_memory(void);

In swap mode, mark the output buffer halves as consumed so that the encoder can reuse them.

Anonymous enum¶

Input formats for mjpeg_hal_cfg_t::format.

Anonymous enum¶

Events passed to mjpeg_hal_cfg_t::callback.

Anonymous enum¶

Input plane selector for mjpeg_set_input_addr().

mjpeg_hal_cfg_t¶

Encoder configuration for mjpeg_init().

Macros¶

hal_mjdec.h¶

#include "hal_mjdec.h" (Source)

Hardware JPEG decoder driver: decode a baseline JPEG into semi-planar YUV or grey-scale frames.

The decoder shares the JPEG hardware block with the encoder (hal_mjpeg.h); only one of them can be initialized at a time. Typical sequence: mjdec_init(), mjdec_set_callback(), clean the data cache over the JPEG data, then mjdec_start_decoder(). Decoding runs in the background; the callback reports the decoded frame from the decoder interrupt, after which the decoder is disabled. Invalidate the data cache over the output planes before reading them, and call mjdec_deinit() to hand the hardware back.

mjdec_init¶

int mjdec_init(mjdec_config_t *config);

Initialize the decoder.

Claims the JPEG hardware for decoding, parses the JPEG header when mjdec_config_t::is_skip_header is 1, programs the output format and buffers, and installs and enables the decoder interrupt.

mjdec_deinit¶

int mjdec_deinit(void);

Release the JPEG hardware from decoding.

mjdec_disable¶

void mjdec_disable(void);

Disable the decoder.

mjdec_start_decoder¶

int mjdec_start_decoder(uint8_t *jpeg_buf_addr);

Start decoding one JPEG frame.

Enables the decoder and queues the JPEG data; returns without waiting. Clean the data cache over the JPEG data first.

Returns: Always 0.

mjdec_set_callback¶

int mjdec_set_callback(mjdec_frame_cb frame_cb, void *usrdata);

Install the frame callback.

Returns: Always 0.

mjdec_irq_handler¶

void mjdec_irq_handler(void);

Decoder interrupt handler.

Installed by mjdec_init(); applications do not call it.

Anonymous enum¶

Interrupt types reported in mjdec_frame_desc_t::ucIntType.

Anonymous enum¶

Output formats for mjdec_config_t::yuv_mode.

mjdec_config_t¶

Decoder configuration for mjdec_init().

mjdec_frame_desc_t¶

Decoded frame description passed to the frame callback.

Typedefs¶