|
**Pipeline**
|
Builds, links, and manages the full lifecycle of a GStreamer pipeline. Supports both programmatic (C++ fluent API) and declarative (YAML) pipeline definition. Key methods: `add()`, `link()`, `add_stream_filter()`, `execute()`, `prepare()`, `start()`, `stop()`, `get()`.
|
```cpp theme={null}
Pipeline p("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.
|
```cpp theme={null}
Element sink("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()`.
|
```cpp theme={null}
sink.setBufferConsumer([](Buffer buf) {
auto* data = buf.data();
auto pts = buf.pts();
});
```
|
|
**AppSrc**
|
App-facing source. Feeds buffers from application code into the pipeline using lambda callbacks or a push API.
|
```cpp theme={null}
AppSrc src(pipeline.get("src"));
src.setBufferProducer([](Buffer& buf) {
// fill buf.data()
return true;
});
```
|
|
**AppSink**
|
App-facing sink. Delivers pipeline output buffers to application code with zero-copy.
|
```cpp theme={null}
AppSink sink(pipeline.get("sink"));
sink.setBufferConsumer([](Buffer buf) {
// consume buf.data()
});
```
|
|
**CamSrc**
|
Built-in ISP camera source. Exposes an API for runtime image capture and snapshots.
|
```cpp theme={null}
CamSrc cam(pipeline.get("source"));
cam.captureImage("snapshot.jpg");
```
|
|
**MLPreProcess**
|
Attaches a custom C++ lambda for pre-processing input frames before ML inference.
|
```cpp theme={null}
MLPreProcess pre(pipeline.get("preproc"));
pre.set_handler([](Buffer& buf) {
// transform input frame
});
```
|
|
**MLPostProcess**
|
Attaches a custom C++ lambda for post-processing raw inference tensor output.
|
```cpp theme={null}
MLPostProcess pp(pipeline.get("postproc"));
pp.set_handler([](Buffer& buf) {
// parse inference output
});
```
|
|
**MLVideoTFLiteBin** / **MLVideoQNNBin** / **MLVideoSNPEBin** / **MLVideoONNXBin**
|
All-in-one preprocess + inference + postprocess bins. Supports TFLite, QNN, SNPE, and ONNX models.
|
```cpp 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.
|
```cpp 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 compile-time dependency on GStreamer headers.
* **Fast pipeline development** — a functional camera-to-display pipeline can be written in just a few lines of C++.
* **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 C++ 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
