Operator ImageFifo

This operator can be used to buffer a relatively small number of pixels in an FPGA based memory. The operator does not require a VisualApplets resource of type RAM. Instead, the operator uses FPGA internal memory. This can either be the FPGA-internal block RAM or the FPGA distributed RAM (LUT RAM). Which of the two is used can be set manually via Parameter ImplementationType or is selected automatically by the operator depending on the operator's configuration.

The ImageFifo operator is often used to buffer lines or pixels before a synchronization. As the FPGA internal memory is limited, it is unlikely that frames of full resolution can be buffered without exceeding the available resources.

For information on the latency of the operator, see Table 33, 'Individual Latencies of the Operators in Library Memory'.

Parameters EntitiesToStore and EntityType define the maximum available buffer size. The operator is a first input, first output memory (FIFO). Any input data is immediately forward to the output. However, if the output is blocked for example because the following operators cannot process the input bandwidth, the operator will store the data. Thus the memory will only be filled, if the operator cannot output the data.

To measure the fill level of the buffer the operator provides the parameter FillLevel. FillLevel shows the percentage fill level of the Fifo.

Parameter InfiniteSource is used to specify if the operator is directly connected to a camera or is sequenced with other memory operators. If InfiniteSource is disabled, the operator cannot get into an overflow condition. Check 'Infinite Sources / Connecting Cameras' for more information.

Parameter ImplementationType allows to specify the hardware memory that is to be used by the operator.

I/O Properties

Property Value
Operator Type M
Input Link I, image data input
Output Link O, data input

Supported Link Format

Link Parameter Input Link I Output Link O
Bit Width [1, 64]1 as I
Arithmetic {unsigned, signed} as I
Parallelism any as I
Kernel Columns 1 as I
Kernel Rows 1 as I
Img Protocol {VALT_IMAGE2D, VALT_LINE1D, VALT_PIXEL0D} as I
Color Format any as I
Color Flavor any as I
Max. Img Width any as I
Max. Img Height any as I

1

The range of the input bit width is [1, 64] for unsigned inputs. For signed inputs, the range is [2, 64]. For unsigned color inputs, the range is [3, 63] and for signed color, the range is [6, 63].

Parameters

EntitiesToStore
Type static parameter
Default 1
Range any

This parameter defines how many pixels, lines or frames have to be stored at maximum. The entity type is defined using parameter EntityType.

EntityType
Type static parameter
Default FRAME
Range {FRAME, LINE, PIXEL}

This parameter defines the type of the entity to store. The parameter can buffer EntitiesToStore units of EntityType.

FRAME can only be chosen of the input link image protocol is VALT_IMAGE2D. LINE can be selected for protocols VALT_LINE2D and VALT_LINE1D, while PIXEL is always enabled.

FillLevel
Type dynamic read parameter
Default 0
Range [0%, 100%]

This parameter provides the fill level of buffer. The operator uses the FPGA resources efficiently. In some configurations it is possible to store more than 100% in the buffer.

InfiniteSource
Type static parameter
Default Enabled
Range {ENABLED, DISABLED}

This parameter activates support for infinite source operators like Camera operators. See 'Infinite Sources / Connecting Cameras' for more information.

ImplementationType
Type static write parameter
Default AUTO
Range (AUTO, BRAM, LUTRAM)

Parameter ImplementationType influences the implementation strategy of the operator, i.e., which memory elements are used for implementing the operator.

You can select one of the following values:

AUTO: The optimal implementation strategy is selected automatically based on the parametrization of the connected links.

BRAM: The operator uses the Block RAM of the FPGA.

LUTRAM: The operator uses the LUT RAM of the FPGA.

[Note] Use AUTO in General

Normally, the parameter should be set to AUTO. In special cases, i.e., if one kind of FPGA ressource runs short in a design, you can manually influence the FPGA resource management using the values BRAM or LUTRAM.

Examples of Use

The use of operator ImageFifo is shown in the following examples: