|
**Pipeline**
|
Builds, links, and manages the full lifecycle of a GStreamer pipeline. Supports both programmatic (Python fluent API) and declarative (YAML) pipeline definition. Key methods: `add()`, `link()`, `add_stream_filter()`, `execute()`, `prepare()`, `start()`, `stop()`, `get()`.
|
```python theme={null}
p = Pipeline("cam-pipeline")
p.add("qtiqmmfsrc", "src").add("waylandsink", "sink").execute()
```
|
|
**Element**
|
Generic wrapper around a GStreamer element. Supports fluent property setting at create time or at runtime to update a live pipeline.
|
```python theme={null}
sink = Element("waylandsink", "display")
sink.set("fullscreen", True)
sink.set("sync", False)
```
|
|
**Buffer**
|
Unified buffer abstraction over native GStreamer memory. Provides read/write access, timestamp metadata, and zero-copy transfer paths. Key methods: `data()`, `size()`, `resize()`, `pts()`, `dts()`, `duration()`.
|
```python theme={null}
def consume_buffer(buf):
data = buf.data()
pts = buf.pts()
sink.set_buffer_consumer(consume_buffer)
```
|
|
**AppSrc**
|
App-facing source. Feeds buffers from application code into the pipeline using callbacks or a push API.
|
```python theme={null}
def produce_buffer(buf):
# fill buf.data()
return True
src = AppSrc(pipeline.get("src"))
src.set_buffer_producer(produce_buffer)
```
|
|
**AppSink**
|
App-facing sink. Delivers pipeline output buffers to application code with zero-copy.
|
```python theme={null}
def consume_buffer(buf):
# consume buf.data()
pass
sink = AppSink(pipeline.get("sink"))
sink.set_buffer_consumer(consume_buffer)
```
|
|
**CamSrc**
|
Built-in ISP camera source. Exposes an API for runtime image capture and snapshots.
|
```python theme={null}
cam = CamSrc(pipeline.get("source"))
cam.capture_image("snapshot.jpg")
```
|
|
**MLPreProcess**
|
Attaches a custom Python handler for pre-processing input frames before ML inference.
|
```python theme={null}
def preprocess(buf):
# transform input frame
pass
pre = MLPreProcess(pipeline.get("preproc"))
pre.set_handler(preprocess)
```
|
|
**MLPostProcess**
|
Attaches a custom Python handler for post-processing raw inference tensor output.
|
```python theme={null}
def postprocess(buf):
# parse inference output
pass
pp = MLPostProcess(pipeline.get("postproc"))
pp.set_handler(postprocess)
```
|
|
**MLVideoTFLiteBin** / **MLVideoQNNBin** / **MLVideoSNPEBin** / **MLVideoONNXBin**
|
All-in-one preprocess + inference + postprocess bins. Supports TFLite, QNN, SNPE, and ONNX models.
|
```python theme={null}
pipeline.add("MLVideoTFLiteBin", "ml", "model", "/models/model.tflite", "delegate", "htp")
```
|
|
**VideoFilter** / **AudioFilter** / **ImageFilter** / **H264Filter** / **TensorFilter** / **TextFilter**
|
Fluent caps builders for `add_stream_filter()`. Describes stream characteristics for caps negotiation between pipeline stages.
|
```python theme={null}
pipeline.add_stream_filter("vf", VideoFilter().format("NV12").resolution(1920, 1080).framerate(30))
```
|
### Key Capabilities
* **No GStreamer expertise required** — the SDK manages all underlying GStreamer mechanics internally, with no dependency on GStreamer Python bindings.
* **Fast pipeline development** — a functional camera-to-display pipeline can be written in just a few lines of Python.
* **AI inference support** — built-in ML bins for TFLite, QNN, SNPE, and ONNX models, with support for custom pre/post-processing.
* **Two pipeline definition styles** — pipelines can be defined programmatically using the Python fluent API (`add()` / `link()` calls), or declaratively using a YAML configuration file passed to the `Pipeline` constructor.
* **Broad multimedia support** — video capture, signal processing, ML inference, overlay rendering, and display output.
### API Reference
