diff --git a/.gitignore b/.gitignore index be572e358..600535e91 100644 --- a/.gitignore +++ b/.gitignore @@ -109,3 +109,7 @@ act # Local OpenTimelineIO build (see docs/build.md) otio-install/ + +# Rust +**/target/ +tarpaulin-out/ diff --git a/docs/zh/plans/riir/notes.md b/docs/zh/plans/riir/notes.md index c7aefbe40..048c86621 100644 --- a/docs/zh/plans/riir/notes.md +++ b/docs/zh/plans/riir/notes.md @@ -505,12 +505,52 @@ image/ffmpeg-next 全套。 ## 技术债登记（2026-08-09） -- **oaktask 渲染循环同步化**：src/task/rust/src/render.rs 目前是 - "一帧一 ticket、wait 到底"的同步循环（C++ 原版是最多 - hardware_concurrency 个 ticket 并发 + 完成队列 + condvar）。 - 可观察契约不变但导出/预缓存吞吐下降。修复方案：oakrender - ticket arena 本就支持多 ticket 在飞 + 回调，改为 N 并发 + - 按序交付，并发度参数照 C++。待 render crate 落定后立即派代理 - 补上（测试已就绪）。 +- **oaktask 渲染循环同步化 ✅（2026-08-09 修复）**：src/task/rust/src/render.rs + 的同步循环（"一帧一 ticket、wait 到底"）已改为并发循环，与 C++ + 原版一致：最多 `max_inflight`（默认 `available_parallelism`，照 C++ + `max(1, hardware_concurrency)`）个 ticket 在飞，ticket 完成回调 + （`oakrender_ticket_finished_fn`）把完成的 ticket 推进完成队列并唤醒 + 渲染线程（队列 + condvar）；乱序完成经 reorder buffer 按时间戳序 + （音频先、帧按时间升序）交付给 behavior 钩子；取消/钩子错误会 + cancel+wait 全部在飞 ticket（其完成回调仍然恰好触发一次）后再返回。 + 可观察契约不变。配套：tests/common/mod.rs 的 ticket stub 升级为 + 模拟 ticket arena（按提交序分配 id、可脚本化乱序完成 `stub_complete`、 + DEFER 模式、取消原子会完成在飞 ticket）；新增 + tests/render_loop_test.rs（乱序交付、音频优先、取消 drain、进度单调、 + 错误停止派发、窗口化）。bridge/render.rs 的 + `oakrender_ticket_finished_fn` 由 3 参修正为 2 参 + `(ticket, userdata)`，与 include/render/ticket.h 及 oakrender 实现一致 + （原 3 参镜像与实际 ABI 不符）。 + 遗留注意：ticket.h 规定回调收到的 ticket 是"提交者句柄的借用副本， + 提交者持有并释放"，因此渲染循环只释放 submit 函数返回的那一份句柄、 + 不释放队列里的借用副本（C++ 原版对两者都调 free，若真实 oakrender 的 + 句柄副本不各自计数，则 C++ 路径存在双释放风险，Rust 侧按头文件契约 + 规避）；ticket.h 无 poll/try_wait 查询，等待完全走完成回调 + condvar。 - **oaktask 导出缺口**：临时文件重命名（失败不留半成品）与 sidecar 字幕编码器未实现；precache 缺项目深拷贝。 + +## engine/ vs src/ 模块覆盖比对（2026-08-09） + +对照 engine/include/oakengine/*.h（facade 头）与 include//*.h +（模块 C ABI）的缺口： + +**模块侧真实缺口（要补）**： +- oaknode：NodeInputDragger 族（oakengine_dragger_*，6 函数）未迁； + keyframe 辅助 4 个（compute_paste_value/get_valid_bezier_point/ + has_sibling_at_time/opposing_bezier_type）未迁；MultiCam 族 + （oakengine_multicam_*，9 函数）未迁（oakrender 只有 + set_cacher_multicam 一个入口）。 +- oakcodec：格式/编解码器枚举族（oakengine_encoding_format_* / + codec_*，12 函数）未迁——oakcodec 只有 + export_format_get_extension 一个。 +- oaktimeline/oaknode：engine/timeline.h 的 sequence/clip 便捷层 + （add_footage_clip/ripple_delete_*/move_clip/trim 等 ~90 函数） + 大部分是 facade 便捷封装，底层原语（edit 命令族）已齐，facade + 包装时按需下沉或留在 facade。 + +**属于 facade 层（不进模块，属预期）**：viewer/playback/preview/ +display/gizmo/app/worker/ipc/config/disk/lut/events/exporter —— +即 M9 §4 裁决的 liboakengine 装配层职责。 + +**已核对无缺口**：undo（39 vs 26 系 facade 组合函数）、audio、 +group passthrough、keyframe 主体、project/footage 主体。 diff --git a/include/codec/format.h b/include/codec/format.h new file mode 100644 index 000000000..68e62e185 --- /dev/null +++ b/include/codec/format.h @@ -0,0 +1,217 @@ +/*** + + Oak Video Editor - Non-Linear Video Editor + Copyright (C) 2026 Oak Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . + +***/ + +#ifndef OAK_EDITOR_CODEC_FORMAT_H +#define OAK_EDITOR_CODEC_FORMAT_H + +#include "error.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * @file format.h + * @brief C ABI for the oakcodec container-format / codec metadata queries + * (olive::ExportFormat / olive::ExportCodec / olive::Encoder statics). + * + * This family is the module-side mirror of the facade's + * oakengine_encoding_format_* / codec_* surface (oakengine/encoding.h): + * the export dialog queries it to populate its format/codec combo boxes and + * to enable/disable the bit-rate controls. The functions are stateless — + * no handles involved. + * + * Enum int fields carry the engine's own enum values + * (olive::ExportFormat::Format, olive::ExportCodec::Codec, + * olive::core::SampleFormat::Format) — the same values oakengine/encoding.h + * documents. Return-code convention follows include/codec/error.h: 0 + * (OAKCODEC_OK) on success, a negative OAKCODEC_E_* code on failure, and + * string getters return the required buffer size in bytes INCLUDING the + * terminating NUL as a non-negative value (two-stage convention). Note this + * differs from oakcodec_export_format_get_extension() (encoder.h), which + * predates this family and reports unknown formats as the empty string. + */ + +/** + * @brief Container formats (olive::ExportFormat::Format) referenced by name + * in UI code. Only append; the values are serialized in project/preset + * files. The complete list lives in src/codec/src/exportformat.h. + */ +#define OAKCODEC_ENCODING_FORMAT_MATROSKA 1 +#define OAKCODEC_ENCODING_FORMAT_MPEG4_VIDEO 2 +#define OAKCODEC_ENCODING_FORMAT_QUICKTIME 4 +#define OAKCODEC_ENCODING_FORMAT_PNG 5 +#define OAKCODEC_ENCODING_FORMAT_WAV 7 +#define OAKCODEC_ENCODING_FORMAT_SRT 13 + +/** + * @brief Codecs (olive::ExportCodec::Codec) referenced by name in UI code. + * Only append; the values are serialized. The complete list lives in + * src/codec/src/exportcodec.h. + */ +#define OAKCODEC_ENCODING_CODEC_H264 1 +#define OAKCODEC_ENCODING_CODEC_H264RGB 2 +#define OAKCODEC_ENCODING_CODEC_H265 3 +#define OAKCODEC_ENCODING_CODEC_CINEFORM 7 +#define OAKCODEC_ENCODING_CODEC_AAC 12 +#define OAKCODEC_ENCODING_CODEC_PCM 13 +#define OAKCODEC_ENCODING_CODEC_SRT 17 +#define OAKCODEC_ENCODING_CODEC_AV1 18 + +/* ---- Container format / codec metadata ---------------------------------- */ + +/** + * @brief Number of container formats (olive::ExportFormat::k_format_count). + */ +OAKCODEC_API int oakcodec_encoding_format_count(void); + +/** + * @brief Display name of a container format (buf/size, two-stage). + * + * @return The required buffer size (including the NUL), or + * OAKCODEC_E_INVALID when `format` is out of range. + */ +OAKCODEC_API int oakcodec_encoding_format_name(int format, char *buf, + int buf_size); + +/** + * @brief File extension (no dot) of a container format (buf/size, + * two-stage); same return convention as + * oakcodec_encoding_format_name(). + */ +OAKCODEC_API int oakcodec_encoding_format_extension(int format, char *buf, + int buf_size); + +/** + * @brief Number of video codecs a container format supports, or + * OAKCODEC_E_INVALID when the format is invalid. + */ +OAKCODEC_API int oakcodec_encoding_format_video_codec_count(int format); + +/** + * @brief The `index`-th video codec of `format` as an + * olive::ExportCodec::Codec value. + * + * @return OAKCODEC_E_INVALID when the format is invalid, or + * OAKCODEC_E_NOT_FOUND when the index is out of range. + */ +OAKCODEC_API int oakcodec_encoding_format_video_codec_at(int format, + int index); + +/** @brief Audio-codec variant of the two functions above. */ +OAKCODEC_API int oakcodec_encoding_format_audio_codec_count(int format); +OAKCODEC_API int oakcodec_encoding_format_audio_codec_at(int format, + int index); + +/** @brief Subtitle-codec variant of the two functions above. */ +OAKCODEC_API int oakcodec_encoding_format_subtitle_codec_count(int format); +OAKCODEC_API int oakcodec_encoding_format_subtitle_codec_at(int format, + int index); + +/** + * @brief Display name of a codec (buf/size, two-stage). + * + * @return The required buffer size (including the NUL), or + * OAKCODEC_E_INVALID when `codec` is out of range. + */ +OAKCODEC_API int oakcodec_encoding_codec_name(int codec, char *buf, + int buf_size); + +/** @brief 1 when `codec` encodes still images (PNG/TIFF/OpenEXR), else 0 + * (0 also for an invalid codec). */ +OAKCODEC_API int oakcodec_encoding_codec_is_still_image(int codec); + +/** @brief 1 when `codec` is lossless (no bit-rate setting applies), else 0 + * (0 also for an invalid codec). */ +OAKCODEC_API int oakcodec_encoding_codec_is_lossless(int codec); + +/** + * @brief Number of encoded pixel formats (e.g. "yuv420p") usable with + * `codec` inside `format`, or OAKCODEC_E_INVALID when either + * argument is out of range. The list is queried from the format's + * encoder (FFmpeg/OIIO), so codecs without an encoder report 0. + */ +OAKCODEC_API int oakcodec_encoding_pix_fmt_count(int format, int codec); + +/** + * @brief The `index`-th encoded pixel format name (buf/size, two-stage). + * + * @return The required buffer size (including the NUL), or + * OAKCODEC_E_INVALID for bad format/codec, or + * OAKCODEC_E_NOT_FOUND when the index is out of range. + */ +OAKCODEC_API int oakcodec_encoding_pix_fmt_at(int format, int codec, + int index, char *buf, + int buf_size); + +/** + * @brief Index of `pix_fmt` (e.g. "yuv420p") in `codec`'s supported pixel + * format list; 0 (the codec's preferred format) when absent or + * `pix_fmt` is NULL/empty or `codec` is invalid. + */ +OAKCODEC_API int oakcodec_encoding_pix_fmt_index(int codec, + const char *pix_fmt); + +/** + * @brief Number of sample formats usable with `codec` inside `format`, or + * OAKCODEC_E_INVALID when either argument is out of range. + */ +OAKCODEC_API int oakcodec_encoding_sample_format_count(int format, + int codec); + +/** + * @brief The `index`-th sample format as an olive::core::SampleFormat::Format + * value. + * + * @return OAKCODEC_E_INVALID for bad format/codec, or + * OAKCODEC_E_NOT_FOUND when the index is out of range. + */ +OAKCODEC_API int oakcodec_encoding_sample_format_at(int format, int codec, + int index); + +/* ---- Image-sequence filename helpers (olive::Encoder statics) ----------- */ + +/** @brief 1 when `filename` contains a "[#####]" digit placeholder, else 0 + * (0 for NULL). */ +OAKCODEC_API int +oakcodec_encoding_filename_contains_digit_placeholder(const char *filename); + +/** @brief Digit count of the filename's "[#####]" placeholder; 0 when none + * (0 for NULL). */ +OAKCODEC_API int +oakcodec_encoding_image_sequence_digit_count(const char *filename); + +/** + * @brief `filename` with the digit placeholder removed (buf/size, two-stage; + * a leading separator like "_"/"-"/"."/" " before the placeholder is + * removed along with it). + * + * @return The required buffer size (including the NUL), or + * OAKCODEC_E_INVALID when `filename` is NULL. + */ +OAKCODEC_API int +oakcodec_encoding_filename_remove_digit_placeholder(const char *filename, + char *buf, int buf_size); + +#ifdef __cplusplus +} +#endif + +#endif //OAK_EDITOR_CODEC_FORMAT_H diff --git a/include/node/dragger.h b/include/node/dragger.h new file mode 100644 index 000000000..e3f8180c6 --- /dev/null +++ b/include/node/dragger.h @@ -0,0 +1,137 @@ +/*** + + Oak Video Editor - Non-Linear Video Editor + Copyright (C) 2026 Oak Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . + +***/ + +#ifndef OAK_EDITOR_NODE_DRAGGER_H +#define OAK_EDITOR_NODE_DRAGGER_H + +#include + +#include "node/error.h" +#include "node/node.h" +#include "undo/undocommand.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * @file dragger.h + * @brief C ABI for olive::NodeInputDragger (src/node/src/inputdragger.h): + * live drag of an input's value with a single commit command. + * + * A dragger wraps the engine's NodeInputDragger state machine + * (start -> drag* -> end). start() records the drag anchor and, when the + * input is keyframing, creates one keyframe at the drag time (on every + * track when requested); drag() live-sets the dragged component (clamped + * by the input's min/max properties when present); end() returns ONE + * undoable command that commits the whole drag -- undo removes the + * created keyframe(s) (restoring the pre-drag keyframe count), redo + * re-creates them with the final value. + * + * A dragger must be ended before it is freed; freeing a started dragger + * leaks the created keyframe(s) (the same ownership rule as the C++ + * class). + */ + +/** + * @brief Reference-counted handle to an input dragger + * (olive::NodeInputDragger). + * + * The object never leaves the library that created it; every external + * reference is one of these handles. Semantics are shared_ptr-like: + * oaknode_dragger_create() returns a handle with count 1, addref(ctx) + * takes another reference, release(ctx) drops one and the library + * destroys the object when the count reaches zero. + */ +typedef struct OakNodeDragger { + void *ctx; /**< Opaque pointer to the reference-counted object. */ + void (*addref)(void *ctx); /**< Atomically increments the count. */ + void (*release)(void *ctx); /**< Decrements the count, destroys at 0. */ + uint32_t abi_version; /**< OAKNODE_ABI_VERSION. */ +} OakNodeDragger; + +/** + * @brief Create an input dragger for live-drag of an input's value. + * + * `input_id` must name an existing input of `node`; `element` addresses + * an array input's element (-1 for non-array inputs). `track` is the + * create-time default; the track passed to oaknode_dragger_start() + * establishes the actual drag track. + * + * @return Dragger handle with count 1; ctx is NULL on invalid arguments + * or allocation failure. + */ +OakNodeDragger oaknode_dragger_create(OakNodeNode node, const char *input_id, + int element, int track); + +/** + * @brief Start the drag at the given rational time (creates a keyframe + * when the input is keyframing). + * + * `insert_on_all_tracks` != 0 also creates sibling keyframes on every + * other track of the input. OAKNODE_E_STATE when the dragger was already + * started. + */ +int oaknode_dragger_start(OakNodeDragger dragger, int64_t time_num, + int64_t time_den, int track, + int insert_on_all_tracks); + +/** + * @brief Drag to a new per-track component value (live; no undo). + * + * `value` carries the dragged component of the input's declared type: + * scalar types in f[0]/num; for split-track types (VEC2/3/4/COLOR) the + * POD type must match the input's declared type and the dragged + * component sits in f[0] (the facade's dragger convention). The value is + * clamped to the input's min/max properties when present. + * OAKNODE_E_STATE when the dragger was not started. + */ +int oaknode_dragger_drag(OakNodeDragger dragger, const oaknode_value *value); + +/** + * @brief End the drag, returning ONE undoable command for the whole drag. + * + * `*out_command` receives an owned command handle (execute it with + * oakundo_command_redo_now(), push it onto an OakUndoStack, or release + * it with oakundo_command_free()). OAKNODE_E_STATE when the dragger was + * not started. + */ +int oaknode_dragger_end(OakNodeDragger dragger, OakUndoCommand *out_command); + +/** + * @brief 1 if the dragger has been started and not yet ended. + */ +int oaknode_dragger_is_started(OakNodeDragger dragger, int *out_started); + +/** + * @brief Release one reference to a dragger handle. + * + * Convenience wrapper around handle.release(handle.ctx): destroys the + * dragger when the count reaches zero. NULL handle or NULL ctx is a + * no-op; clears `dragger->ctx` after releasing. The dragger must have + * been ended (see the file comment). + */ +void oaknode_dragger_free(OakNodeDragger *dragger); + +#ifdef __cplusplus +} +#endif + +#endif //OAK_EDITOR_NODE_DRAGGER_H diff --git a/include/node/keyframe.h b/include/node/keyframe.h index 09898b663..6b28b9cb0 100644 --- a/include/node/keyframe.h +++ b/include/node/keyframe.h @@ -235,6 +235,59 @@ int oaknode_keyframe_get_input(OakNodeKeyframe keyframe, char *buf, int oaknode_keyframe_get_parent(OakNodeKeyframe keyframe, OakNodeNode *out_node); +/** + * @brief A bezier control point guaranteed valid for animation + * (NodeKeyframe::valid_bezier_control_in()/out()). + * + * Unlike oaknode_keyframe_get_bezier_control(), the returned point is + * clamped so the curve never overlaps: the in-handle's x cannot pass the + * previous keyframe's time and the out-handle's x cannot pass the next + * keyframe's time. `handle` is an oaknode_keyframe_bezier. + */ +int oaknode_keyframe_get_valid_bezier_control(OakNodeKeyframe keyframe, + int handle, double *out_x, + double *out_y); + +/** + * @brief The opposing bezier handle type + * (NodeKeyframe::get_opposing_bezier_type): OAKNODE_KEYFRAME_IN_HANDLE + * (0) <-> OAKNODE_KEYFRAME_OUT_HANDLE (1). + * + * @return The opposing handle type, or OAKNODE_E_INVALID for a type + * outside the two handle values. + */ +int oaknode_keyframe_opposing_bezier_type(int type); + +/** + * @brief Compute the combined node value to use when inserting + * `keyframe` onto `target_node` (the keyframe paste path). + * + * Takes the target node's split value at the keyframe's time, replaces + * the keyframe's own track with the keyframe's value, and combines the + * per-track components into a single normal value (mirrors the facade's + * oakengine_keyframe_compute_paste_value). OAKNODE_E_NOT_FOUND when the + * keyframe's input id does not exist on `target_node`; OAKNODE_E_FAILED + * for input types without a POD representation. + */ +int oaknode_keyframe_compute_paste_value(OakNodeNode target_node, + OakNodeKeyframe keyframe, + oaknode_value *out); + +/** + * @brief 1 if a sibling keyframe exists at the given rational time on + * this keyframe's own track (NodeKeyframe::has_sibling_at_time(): the + * track's key at `time` that is not this keyframe — the move-collision + * check). Unlike the facade, the time is an exact rational rather than a + * whole-second frame timestamp, and no track argument is needed (the + * lookup is relative to this keyframe's track). + * + * An orphaned keyframe (no parent node) has no siblings: `*out_value` + * is set to 0 and OAKNODE_OK is returned. + */ +int oaknode_keyframe_has_sibling_at_time(OakNodeKeyframe keyframe, + int64_t time_num, int64_t time_den, + int *out_value); + #ifdef __cplusplus } #endif diff --git a/include/node/multicam.h b/include/node/multicam.h new file mode 100644 index 000000000..5d5699395 --- /dev/null +++ b/include/node/multicam.h @@ -0,0 +1,119 @@ +/*** + + Oak Video Editor - Non-Linear Video Editor + Copyright (C) 2026 Oak Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . + +***/ + +#ifndef OAK_EDITOR_NODE_MULTICAM_H +#define OAK_EDITOR_NODE_MULTICAM_H + +#include + +#include "node/error.h" +#include "node/node.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * @file multicam.h + * @brief C ABI for olive::MultiCamNode (src/node/src/input/multicam/ + * multicamnode.h): multi-camera source switching and the source-grid + * math used by the multicam viewer. + * + * The input-id getters return static strings (never freed) naming the + * multicam node's inputs: current source (combo), sources (array), + * sequence and sequence type. A node that is not a MultiCamNode (or a + * NULL handle) fails the per-node queries with OAKNODE_E_INVALID. + * + * The grid helpers are static and pure: they only depend on their + * arguments, not on a node. + */ + +/** + * @brief The input id string for the current camera ("current_in"). + */ +const char *oaknode_multicam_input_current(void); + +/** + * @brief The input id string for the sources array ("sources_in"). + */ +const char *oaknode_multicam_input_sources(void); + +/** + * @brief The input id string for the sequence ("sequence_in"). + */ +const char *oaknode_multicam_input_sequence(void); + +/** + * @brief The input id string for the sequence type ("sequence_type_in"). + */ +const char *oaknode_multicam_input_sequence_type(void); + +/** + * @brief Number of connected source cameras (MultiCamNode:: + * get_source_count(); the connected sequence's track count, or the + * sources array size when no sequence is connected). + * + * OAKNODE_E_INVALID when `node` is not a multicam. + */ +int oaknode_multicam_get_source_count(OakNodeNode node, int *out_count); + +/** + * @brief Compute the grid (rows, cols) that holds `source_count` cells. + * + * Mirrors MultiCamNode::get_rows_and_columns(): the grid grows from + * 1x1, widening the smaller dimension, until rows * cols >= source_count + * (0 sources yields 1x1). OAKNODE_E_INVALID for a negative count or + * NULL out pointers. + */ +int oaknode_multicam_get_rows_and_columns(int source_count, int *rows, + int *cols); + +/** + * @brief Convert a flat source index to (row, col) in a rows x cols grid + * (row-major: col = index % cols, row = index / cols). + * + * OAKNODE_E_INVALID for a negative index, degenerate grid or NULL out + * pointers. + */ +int oaknode_multicam_index_to_row_cols(int index, int rows, int cols, + int *out_row, int *out_col); + +/** + * @brief Convert (row, col) to a flat source index (col + row * cols). + * + * @return The flat index (>= 0), or OAKNODE_E_INVALID when the cell is + * out of range or the grid is degenerate. + */ +int oaknode_multicam_rows_cols_to_index(int row, int col, int rows, + int cols); + +/** + * @brief The current source index (MultiCamNode::get_current_source(), + * the "current_in" combo value). + * + * OAKNODE_E_INVALID when `node` is not a multicam. + */ +int oaknode_multicam_get_current_source(OakNodeNode node, int *out_source); + +#ifdef __cplusplus +} +#endif + +#endif //OAK_EDITOR_NODE_MULTICAM_H diff --git a/include/plugin/instance.h b/include/plugin/instance.h index 52cd3a39d..5a25edd63 100644 --- a/include/plugin/instance.h +++ b/include/plugin/instance.h @@ -96,6 +96,74 @@ int oakplugin_instance_cancel(OakPluginInstance instance); /** @brief Alive-count for leak assertions in tests. */ int oakplugin_debug_alive_count(void); +/* + * M11 §4（GL 路径 + render 驱动收编）新增声明。既有签名不变。 + * + * oakrender 的 PluginJob 经本组入口把整帧渲染流程（RoI/RoD、 + * 多输入收集、isIdentity 短路、参数覆盖、CPU/GL 渲染与输出装配） + * 委托给 oakplugin 的 render 驱动（Rust 侧 render_driver 模块， + * 语义对照 src/render/src/plugin/pluginrenderer.cpp）。 + */ + +/** @brief 一帧渲染任务的参数覆盖条目（参数名 → oaknode_value POD； + * 字符串参数走 oakplugin_instance_set_param_string）。 */ +typedef struct oakplugin_job_value { + const char *key; + oaknode_value value; +} oakplugin_job_value; + +/** @brief 一帧渲染任务的输入 clip 纹理条目。纹理为借用句柄 + * （job 内有效）。 */ +typedef struct oakplugin_job_texture { + const char *clip; + OakRenderTexture texture; +} oakplugin_job_texture; + +/** + * @brief beginSequenceRender 括号。oakrender 对同一实例的一批帧先 + * begin 后 end，中间逐帧 oakplugin_instance_render_job + * （OFX：render action 由 begin/end sequence render 括号包围）。 + * `interactive` 为信息性标记（Phase 2 不传入 action）。 + */ +int oakplugin_instance_render_begin_sequence(OakPluginInstance instance, + double start_time, + double end_time, + int interactive); + +/** @brief endSequenceRender 括号（与 render_begin_sequence 配对）。 */ +int oakplugin_instance_render_end_sequence(OakPluginInstance instance, + double start_time, + double end_time, + int interactive); + +/** + * @brief 一帧渲染的单一 C ABI 调用（PluginJob 的载体）。 + * + * @param dst 目标纹理（oakrender 创建）。GL 模式下调用方须先把 + * dst 附着为渲染器输出目标并保持 GL 上下文 current + * （OFX "OpenGL Current Context" 规则；等价 C++ + * PluginRenderer::attach_output_texture）。 + * @param src 主输入纹理（effect_input_id / SimpleSource；可空句柄）。 + * @param effect_input_id job.src 落点的 clip 名（可 NULL）。 + * @param inputs / input_count 其余输入 clip 的纹理表。 + * @param values / value_count 参数覆盖表。 + * @param renderer GL 渲染器（空句柄 → CPU 路径）。 + * @param clear_destination / interactive 信息性标记（Phase 2， + * render 驱动暂不处理；上层渲染器负责目标清空）。 + */ +int oakplugin_instance_render_job(OakPluginInstance instance, + OakRenderTexture dst, + double time_seconds, + int clear_destination, + int interactive, + const char *effect_input_id, + OakRenderTexture src, + const oakplugin_job_texture *inputs, + int input_count, + const oakplugin_job_value *values, + int value_count, + OakRenderRenderer renderer); + #ifdef __cplusplus } #endif diff --git a/src/bindings/oakotio/Cargo.lock b/src/bindings/oakotio/Cargo.lock new file mode 100644 index 000000000..fbfeaeb24 --- /dev/null +++ b/src/bindings/oakotio/Cargo.lock @@ -0,0 +1,135 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "equivalent" +version = "1.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f" + +[[package]] +name = "hashbrown" +version = "0.17.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a" + +[[package]] +name = "indexmap" +version = "2.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d466e9454f08e4a911e14806c24e16fba1b4c121d1ea474396f396069cf949d9" +dependencies = [ + "equivalent", + "hashbrown", +] + +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + +[[package]] +name = "memchr" +version = "2.8.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98" + +[[package]] +name = "oakcore-rs" +version = "0.1.0" + +[[package]] +name = "oakotio" +version = "0.1.0" +dependencies = [ + "oakcore-rs", + "serde", + "serde_json", +] + +[[package]] +name = "proc-macro2" +version = "1.0.107" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "985e7ec9bb745e6ce6535b544d84d6cd6f7ad8bd711c398938ae983b91a766d9" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "quote" +version = "1.0.47" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "serde" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4148590afebada386688f18773da617792bf2ef03ffc1e4cbd2b1d45b023e0ba" +dependencies = [ + "serde_core", + "serde_derive", +] + +[[package]] +name = "serde_core" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "67dca2c9c51e58a4791a4b1ed58308b39c64224d349a935ab5039aa360942a48" +dependencies = [ + "serde_derive", +] + +[[package]] +name = "serde_derive" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7a5d71263a5a7d47b41f6b3f06ba276f10cc18b0931f1799f710578e2309348" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "serde_json" +version = "1.0.151" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c841b55ecdae098c80dcae9cf767f6f8a0c2cdb3416bbef72181df4d0fe73f14" +dependencies = [ + "indexmap", + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + +[[package]] +name = "syn" +version = "3.0.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "53e9bae58849f64dfa4f5d5ae372c8341f7305f82a3868709269343628b659a3" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "unicode-ident" +version = "1.0.24" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75" + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/src/bindings/oakotio/Cargo.toml b/src/bindings/oakotio/Cargo.toml new file mode 100644 index 000000000..b6dd2c73b --- /dev/null +++ b/src/bindings/oakotio/Cargo.toml @@ -0,0 +1,38 @@ +# Oak Video Editor - Non-Linear Video Editor +# Copyright (C) 2026 Oak Team +# +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . + +[package] +name = "oakotio" +version = "0.1.0" +edition = "2021" +description = "Oak Video Editor OpenTimelineIO binding crate: pure-Rust serde model of the OTIO JSON format used by project load/save (src/task/src/project/loadotio, saveotio)" +license = "GPL-3.0-or-later" + +[lib] +crate-type = ["rlib"] + +[dependencies] + +# serde + serde_json: JSON codec for the OTIO JSON format. The +# `preserve_order` feature keeps Map insertion order so metadata and unknown +# fields round-trip in file order, and a custom 4-space pretty formatter +# reproduces the opentimelineio writer byte-for-byte. See README.md for the +# rationale (no maintained pure-Rust OTIO crate exists on crates.io). +serde = { version = "1", features = ["derive"] } +serde_json = { version = "1", features = ["preserve_order"] } + +# Shared value types (Rational). Same path dependency the other bindings use. +oakcore-rs = { path = "../../oakcore-rs" } diff --git a/src/bindings/oakotio/README.md b/src/bindings/oakotio/README.md new file mode 100644 index 000000000..7b6a6a9cb --- /dev/null +++ b/src/bindings/oakotio/README.md @@ -0,0 +1,144 @@ +# oakotio + +Pure-Rust OpenTimelineIO JSON binding for the Oak Video Editor's Rust +rewrite. This crate is a self-contained serde model of the OTIO JSON format, +covering exactly the object graph Oak's project load/save tasks use +(`src/task/src/project/loadotio/loadotio.cpp` and +`src/task/src/project/saveotio/saveotio.cpp`): `RationalTime`, `TimeRange`, +`Clip`, `Gap`, `Transition`, `Track`, `Stack`, `Timeline`, +`ExternalReference`, `MissingReference` and `SerializableCollection`. + +The writer reproduces the opentimelineio C++ writer's output byte for byte +(4-space indentation, `": "` separators, inline empty objects and arrays, +shortest float representation, no trailing newline); the reader tolerates +hand-written files, preserving unknown fields verbatim across a round-trip +and defaulting missing fields. + +Part of the Oak `src/bindings/` family (siblings: `oakaudioout`). +This is an **rlib** — nothing is exported dynamically. + +## Structure + +``` +src/bindings/oakotio/ +├── Cargo.toml # rlib; deps: serde, serde_json (crates.io), oakcore-rs (path) +├── src/ +│ ├── lib.rs # crate docs + module wiring + re-exports + from_json_* entry points +│ ├── error.rs # OtioError (Json | Io) + Result +│ └── model.rs # serde structs for the 10 OTIO schemas + value types + +│ # Rational::from_double port + in-crate unit tests +└── tests/ + ├── data/ # C++-writer golden files (golden_timeline.json, + │ # golden_collection.json, golden_typed_transition.json, + │ # floatfmt.json) + ├── parity.rs # read parity: every golden file parses and round-trips + ├── semantic.rs # semantic checks over golden_timeline.json (what the + │ # C++ load task reads back) + └── save_parity.rs # save parity: a built Timeline serializes byte-identical + # to golden_timeline.json and re-parses identically +``` + +## API summary + +- `from_json_string(&str) -> Result` / + `from_json_file(path) -> Result` — parse a document whose root + is a `Timeline`, a `SerializableCollection`, or an unknown schema kept whole + as `Serializable::Raw`. +- `RationalTime` — `new(value, rate)` (C++ argument order), `value`, `rate`, + `to_seconds`, `is_invalid_time`, `invalid_time`, `rescaled_to`, + `to_rational`, `from_rational`. +- `TimeRange` — `new(start_time, duration)` (C++ argument order), `start_time`, + `duration`. +- `Clip` — `new(name)`, `name`, `source_range`, `set_source_range`, + `media_reference`, `media_references`, `set_media_reference`. +- `Gap` — `new(source_range, name)`, `name`, `source_range`. +- `Transition` — `new(name)`, `name`, `in_offset`, `out_offset`, + `transition_type`, `set_in_offset`, `set_out_offset`. +- `Track` — `new(kind)`, `kind`, `children`, `append_child`. +- `Stack` — `children`, `append_child`. +- `Timeline` — `new(name)`, `name`, `tracks`, `tracks_mut`, + `global_start_time`, `to_json_string`, `to_json_file`. +- `SerializableCollection` — `new(name, children)`, `name`, `children`, + `to_json_string`, `to_json_file`. +- `MediaReference` / `Composable` / `Serializable` enums — downcasts + (`as_clip`, `as_track`, ...) and `schema_name` for dynamic dispatch by + `OTIO_SCHEMA`. + +All fallible operations return `Result`. + +## Backend choice: hand-written serde over the `opentimelineio` crate + +| Option | Verdict | +| --- | --- | +| crates.io `opentimelineio` | Not viable: the crate is unmaintained, binds the C++ library via FFI (large, ABI-fragile), and does not build a pure-Rust model Oak's load/save tasks can read directly. No actively maintained pure-Rust OTIO implementation exists on crates.io. | +| **This crate: `serde` + `serde_json`** | Pure-Rust (no C++ runtime), fully controllable field order and formatting, preserves unknown fields for forward compatibility, and ports the only piece of C++ numeric behavior Oak needs (`Rational::from_double`) on top of `oakcore_rs::Rational`. | + +The C++ side serializes with `opentimelineio::schema::Timeline::to_json_string` +(4-space pretty formatter); this crate reproduces that exact writer with a +`serde_json::PrettyFormatter` (`with_indent(b" ")`), `preserve_order` maps +so insertion order is kept, and ryu float formatting, which is what the C++ +writer (rapidjson) emits. The result is byte-for-byte parity with C++-written +files (verified against the golden files). + +## Dependency registry + +Runtime dependencies (crates.io): + +- `serde` 1 (with `derive`) — (de)serialization for the OTIO schema structs. +- `serde_json` 1 (with `preserve_order`) — JSON codec; `preserve_order` keeps + map insertion order so metadata and unknown fields round-trip in file + order. +- `oakcore-rs` (path: `../../oakcore-rs`) — shared `Rational` value type + (used by the `Rational::from_double` port); same path dependency the other + bindings use. + +Build and test: + +```sh +cd src/bindings/oakotio +cargo build +cargo test +``` + +## C++ parity notes + +The C++ anchors this crate reproduces: + +- **`Rational::from_double`** (`core/src/util/rational.cpp`) — ported in + `model.rs` on top of `oakcore_rs::Rational::new` (which applies the exact + C++ `reduce_fraction(INT_MAX)` reduction). NaN and out-of-range magnitudes + collapse to the null sentinel `Rational::NULL`; the retry pass against + `INT64_MAX` fires for tiny magnitudes and is itself reduced back to 0/1 by + the `INT_MAX` ceiling, matching the C++ result. +- **Writer format** — `opentimelineio::schema::Timeline::to_json_string`: + 4-space indentation, `": "` separators, inline empty `{}`/`[]`, shortest + float representation (ryu = rapidjson), no trailing newline. Golden files + written by the C++ writer round-trip byte-identically. +- **Field order** — struct field order matches the C++ writer's output order + (e.g. `RationalTime`: `rate` then `value`; `TimeRange`: `duration` then + `start_time`; `Track`: `children` then `kind`). +- **`media_references`** — the C++ `Clip` stores a `std::map`; + this crate uses `BTreeMap`, which serializes keys in the same sorted order. +- **Missing-reference serialization** — `MissingReference` writes + `available_range`/`available_image_bounds` as `null` and omits `target_url`, + exactly like the C++ writer. + +## Deviations from the C++ code (deliberate) + +- **Unknown fields are kept, not dropped** — the C++ reader discards + unrecognized JSON fields; this crate preserves them (via `#[serde(flatten)]` + catch-all maps) so a document written by a newer opentimelineio still + round-trips. This is a superset of the C++ behavior. +- **Defaults are lenient** — missing fields deserialize to their type's + default (the C++ `AnyDictionary` fill defaults), so hand-written files + without optional fields parse cleanly. +- **`RationalTime`/`TimeRange` are `Clone`, not `Copy`** — they carry a + `String` schema field, so value accessors (`value()`, `rate()`, + `duration()`, ...) take `&self` and return clones; the C++ value semantics + (`to_seconds`, `rescaled_to`) are unaffected. + +## Scope + +Covers only what `loadotio.cpp` / `saveotio.cpp` touch. No media-resolution, +no `Marker`/`Effect` schemas (kept as raw `Value` for round-tripping), and no +plugin API — `src/plugin/` is intentionally untouched. diff --git a/src/bindings/oakotio/src/error.rs b/src/bindings/oakotio/src/error.rs new file mode 100644 index 000000000..350d2706a --- /dev/null +++ b/src/bindings/oakotio/src/error.rs @@ -0,0 +1,62 @@ +// Oak Video Editor - Non-Linear Video Editor +// Copyright (C) 2026 Oak Team +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +//! Error type for the oakotio binding. + +use std::fmt; + +/// Errors produced by loading or saving OpenTimelineIO JSON. +#[derive(Debug)] +pub enum OtioError { + /// The document could not be parsed (or a value could not be + /// serialized) as JSON. + Json(serde_json::Error), + /// The underlying file could not be read or written. + Io(std::io::Error), +} + +impl fmt::Display for OtioError { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + match self { + OtioError::Json(e) => write!(f, "OpenTimelineIO JSON error: {e}"), + OtioError::Io(e) => write!(f, "OpenTimelineIO file error: {e}"), + } + } +} + +impl std::error::Error for OtioError { + fn source(&self) -> Option<&(dyn std::error::Error + 'static)> { + match self { + OtioError::Json(e) => Some(e), + OtioError::Io(e) => Some(e), + } + } +} + +impl From for OtioError { + fn from(e: serde_json::Error) -> OtioError { + OtioError::Json(e) + } +} + +impl From for OtioError { + fn from(e: std::io::Error) -> OtioError { + OtioError::Io(e) + } +} + +/// Convenience alias used by the binding API. +pub type Result = std::result::Result; diff --git a/src/bindings/oakotio/src/lib.rs b/src/bindings/oakotio/src/lib.rs new file mode 100644 index 000000000..222219937 --- /dev/null +++ b/src/bindings/oakotio/src/lib.rs @@ -0,0 +1,53 @@ +// Oak Video Editor - Non-Linear Video Editor +// Copyright (C) 2026 Oak Team +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +//! Pure-Rust OpenTimelineIO JSON binding for Oak Video Editor. +//! +//! `oakotio` is a self-contained serde model of the OpenTimelineIO JSON +//! format, covering exactly the object graph Oak's project load/save tasks +//! use (`src/task/src/project/loadotio/loadotio.cpp` and +//! `src/task/src/project/saveotio/saveotio.cpp`): `RationalTime`, +//! `TimeRange`, `Clip`, `Gap`, `Transition`, `Track`, `Stack`, `Timeline`, +//! `ExternalReference`, `MissingReference` and `SerializableCollection`. +//! +//! The writer reproduces the opentimelineio C++ writer's output byte for +//! byte (4-space indentation, `": "` separators, inline empty objects and +//! arrays, shortest float representation, no trailing newline); the reader +//! tolerates hand-written files, preserving unknown fields verbatim across a +//! round-trip and defaulting missing fields. See `README.md` for the design +//! rationale and the parity notes against the C++ implementation. + +use std::path::Path; + +pub mod error; +pub mod model; + +pub use error::{OtioError, Result}; +pub use model::*; + +/// Parse an OpenTimelineIO JSON document from a string. +/// +/// The root may be a `Timeline`, a `SerializableCollection`, or any other +/// schema; unrecognized roots are kept whole as `model::Serializable::Raw` +/// so they round-trip untouched. +pub fn from_json_string(text: &str) -> Result { + Ok(serde_json::from_str(text)?) +} + +/// Read and parse an OpenTimelineIO JSON document from a file. +pub fn from_json_file(path: impl AsRef) -> Result { + from_json_string(&std::fs::read_to_string(path)?) +} diff --git a/src/bindings/oakotio/src/model.rs b/src/bindings/oakotio/src/model.rs new file mode 100644 index 000000000..0c00dbbac --- /dev/null +++ b/src/bindings/oakotio/src/model.rs @@ -0,0 +1,1186 @@ +// Oak Video Editor - Non-Linear Video Editor +// Copyright (C) 2026 Oak Team +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +//! A serde model of the OpenTimelineIO JSON format, covering exactly the +//! object graph the C++ load/save tasks use +//! (`src/task/src/project/loadotio/loadotio.cpp` and +//! `src/task/src/project/saveotio/saveotio.cpp`): `RationalTime`, +//! `TimeRange`, `Clip`, `Gap`, `Transition`, `Track`, `Stack`, `Timeline`, +//! `ExternalReference`, `MissingReference` and `SerializableCollection`. +//! +//! Design notes: +//! +//! - Every schema object is a plain struct whose first field is the private +//! `otio_schema` string (serialized as `"OTIO_SCHEMA"`). Declaring it first +//! makes the writer emit it first (the opentimelineio writer's order), and +//! declaring it before the trailing `#[serde(flatten)]` map keeps it out of +//! the unknown-field bucket on the way back in. +//! - Every schema object ends with `#[serde(flatten)] unknown`, so fields +//! this crate does not model are preserved verbatim across a load/save +//! round-trip (high-fidelity parity with the C++ writer, which also keeps +//! unknown fields). +//! - The three polymorphic containers (`Composable`, `Serializable`, +//! `MediaReference`) dispatch on the `OTIO_SCHEMA` string: known schema +//! names decode into their concrete struct, anything else is kept whole as +//! `Raw(serde_json::Value)` so it round-trips untouched. +//! - `#[serde(default)]` on every struct makes all fields optional on input, +//! matching the C++ reader's tolerance for hand-written files. + +use std::collections::BTreeMap; +use std::path::Path; + +use oakcore_rs::Rational; +use serde::de::{self, Deserialize, Deserializer}; +use serde::ser::{Serialize, Serializer}; +use serde_json::Value; + +use crate::error::OtioError; + +pub(crate) type Map = serde_json::Map; + +// Schema name constants (the "OTIO_SCHEMA" values written by opentimelineio). +const SCHEMA_RATIONAL_TIME: &str = "RationalTime.1"; +const SCHEMA_TIME_RANGE: &str = "TimeRange.1"; +const SCHEMA_CLIP: &str = "Clip.2"; +const SCHEMA_GAP: &str = "Gap.1"; +const SCHEMA_TRANSITION: &str = "Transition.1"; +const SCHEMA_TRACK: &str = "Track.1"; +const SCHEMA_STACK: &str = "Stack.1"; +const SCHEMA_TIMELINE: &str = "Timeline.1"; +const SCHEMA_EXTERNAL_REFERENCE: &str = "ExternalReference.1"; +const SCHEMA_MISSING_REFERENCE: &str = "MissingReference.1"; +const SCHEMA_SERIALIZABLE_COLLECTION: &str = "SerializableCollection.1"; + +/// Serialize `value` exactly like the opentimelineio C++ writer: 4-space +/// indentation, `": "` separators, inline `{}`/`[]`, shortest float +/// representation (ryu, identical to the C++ writer), no trailing newline. +pub(crate) fn to_json_string(value: &T) -> Result { + let mut buf = Vec::new(); + let fmt = serde_json::ser::PrettyFormatter::with_indent(b" "); + let mut ser = serde_json::Serializer::with_formatter(&mut buf, fmt); + value.serialize(&mut ser)?; + String::from_utf8(buf).map_err(|e| serde_json::Error::io(std::io::Error::other(e))) +} + +/// Serialize to a file (no trailing newline, matching the C++ writer). +pub(crate) fn to_json_file(value: &T, path: &Path) -> Result<(), OtioError> { + std::fs::write(path, to_json_string(value)?)?; + Ok(()) +} + +/// Schema-name of an unknown (`Raw`) object: the raw `OTIO_SCHEMA` string, +/// or "" if absent. +fn raw_schema_name(v: &Value) -> &str { + v.get("OTIO_SCHEMA").and_then(Value::as_str).unwrap_or("") +} + +// --------------------------------------------------------------------------- +// Value types +// --------------------------------------------------------------------------- + +/// `RationalTime.1` — a time value and its frame rate. +/// +/// Mirrors `opentimelineio::RationalTime`. Field order on disk is `rate` +/// then `value` (the opentimelineio writer's order). +#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)] +#[serde(default)] +pub struct RationalTime { + #[serde(rename = "OTIO_SCHEMA", default)] + otio_schema: String, + rate: f64, + value: f64, +} + +impl RationalTime { + /// Construct `RationalTime(value, rate)` (C++ argument order). + pub fn new(value: f64, rate: f64) -> RationalTime { + RationalTime { + otio_schema: SCHEMA_RATIONAL_TIME.to_string(), + rate, + value, + } + } + + /// The value in the object's own rate. + pub fn value(&self) -> f64 { + self.value + } + + /// The frame rate (ticks per second). + pub fn rate(&self) -> f64 { + self.rate + } + + /// Convert to seconds (`value / rate`; non-finite for a non-positive + /// rate, same as C++). + pub fn to_seconds(self) -> f64 { + self.value / self.rate + } + + /// The invalid-time sentinel (`RationalTime(0, 0)`, C++ `invalid_time`). + pub fn invalid_time() -> RationalTime { + RationalTime::new(0.0, 0.0) + } + + /// True for a rate `<= 0` or a non-finite value/rate + /// (C++ `is_invalid_time`). + pub fn is_invalid_time(self) -> bool { + self.rate <= 0.0 || self.value.is_nan() || self.rate.is_nan() + } + + /// Convert to another rate (`value * (new_rate / rate)`, C++ + /// `rescaled_to`; returns `self` unchanged when the rates already + /// match). + pub fn rescaled_to(self, new_rate: f64) -> RationalTime { + if self.rate == new_rate { + return self; + } + RationalTime::new(self.value * (new_rate / self.rate), new_rate) + } + + /// C++ `Rational::fromRationalTime` — the exact rational that + /// `to_seconds()` yields (`Rational::from_double(value / rate)`). + pub fn to_rational(self) -> Rational { + from_double(self.to_seconds()) + } + + /// C++ `Rational::toRationalTime(framerate)` — `RationalTime(num, den + /// or 1)` rescaled to `framerate`. + pub fn from_rational(r: Rational, framerate: f64) -> RationalTime { + let rate = if r.denominator() == 0 { + 1.0 + } else { + r.denominator() as f64 + }; + RationalTime::new(r.numerator() as f64, rate).rescaled_to(framerate) + } +} + +impl Default for RationalTime { + fn default() -> Self { + RationalTime::new(0.0, 0.0) + } +} + +/// `TimeRange.1` — a duration and its start time. Field order on disk is +/// `duration` then `start_time` (the opentimelineio writer's order). +#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)] +#[serde(default)] +pub struct TimeRange { + #[serde(rename = "OTIO_SCHEMA", default)] + otio_schema: String, + duration: RationalTime, + start_time: RationalTime, +} + +impl TimeRange { + /// Construct `TimeRange(start_time, duration)` (C++ argument order). + pub fn new(start_time: RationalTime, duration: RationalTime) -> TimeRange { + TimeRange { + otio_schema: SCHEMA_TIME_RANGE.to_string(), + duration, + start_time, + } + } + + /// The start of the range. + pub fn start_time(&self) -> RationalTime { + self.start_time.clone() + } + + /// The duration of the range. + pub fn duration(&self) -> RationalTime { + self.duration.clone() + } +} + +impl Default for TimeRange { + fn default() -> Self { + TimeRange::new(RationalTime::invalid_time(), RationalTime::invalid_time()) + } +} + +// --------------------------------------------------------------------------- +// Media references +// --------------------------------------------------------------------------- + +/// `ExternalReference.1` — media referenced by URL. +#[derive(Clone, Debug, PartialEq, Default, serde::Serialize, serde::Deserialize)] +#[serde(default)] +pub struct ExternalReference { + #[serde(rename = "OTIO_SCHEMA", default)] + otio_schema: String, + metadata: Map, + name: String, + available_range: Option, + available_image_bounds: Option, + target_url: String, + #[serde(flatten)] + unknown: Map, +} + +impl ExternalReference { + /// Construct `ExternalReference(target_url, available_range)` (C++ + /// argument order; `None` serializes as `null`). + pub fn new(target_url: impl Into, available_range: Option) -> ExternalReference { + ExternalReference { + otio_schema: SCHEMA_EXTERNAL_REFERENCE.to_string(), + metadata: Map::new(), + name: String::new(), + available_range, + available_image_bounds: None, + target_url: target_url.into(), + unknown: Map::new(), + } + } + + /// The media URL (C++ `target_url`). + pub fn target_url(&self) -> &str { + &self.target_url + } + + /// The range of media available on disk, if any. + pub fn available_range(&self) -> Option { + self.available_range.clone() + } +} + +/// `MissingReference.1` — media referenced but not resolvable. The C++ +/// writer emits `available_range` and `available_image_bounds` as `null` +/// and no `target_url` at all. +#[derive(Clone, Debug, PartialEq, Default, serde::Serialize, serde::Deserialize)] +#[serde(default)] +pub struct MissingReference { + #[serde(rename = "OTIO_SCHEMA", default)] + otio_schema: String, + metadata: Map, + name: String, + available_range: Option, + available_image_bounds: Option, + #[serde(flatten)] + unknown: Map, +} + +impl MissingReference { + /// A bare `MissingReference` (the C++ default constructor). + pub fn new() -> MissingReference { + MissingReference { + otio_schema: SCHEMA_MISSING_REFERENCE.to_string(), + metadata: Map::new(), + name: String::new(), + available_range: None, + available_image_bounds: None, + unknown: Map::new(), + } + } +} + +/// A clip's media reference: `ExternalReference`, `MissingReference`, or +/// anything else the file contains, kept whole as `Raw`. +#[derive(Clone, Debug, PartialEq)] +pub enum MediaReference { + ExternalReference(ExternalReference), + MissingReference(MissingReference), + /// An unrecognized media-reference schema, preserved verbatim. + Raw(Value), +} + +impl MediaReference { + /// The base schema name ("ExternalReference", "MissingReference", or + /// the raw `OTIO_SCHEMA` string for unknown references). + pub fn schema_name(&self) -> &str { + match self { + MediaReference::ExternalReference(_) => "ExternalReference", + MediaReference::MissingReference(_) => "MissingReference", + MediaReference::Raw(v) => raw_schema_name(v), + } + } + + /// Downcast to a concrete `ExternalReference`. + pub fn as_external_reference(&self) -> Option<&ExternalReference> { + match self { + MediaReference::ExternalReference(e) => Some(e), + _ => None, + } + } + + /// Downcast to a concrete `MissingReference`. + pub fn as_missing_reference(&self) -> Option<&MissingReference> { + match self { + MediaReference::MissingReference(m) => Some(m), + _ => None, + } + } +} + +impl Serialize for MediaReference { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + match self { + MediaReference::ExternalReference(e) => e.serialize(serializer), + MediaReference::MissingReference(m) => m.serialize(serializer), + MediaReference::Raw(v) => v.serialize(serializer), + } + } +} + +impl<'de> Deserialize<'de> for MediaReference { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + let value = Value::deserialize(deserializer)?; + let schema = raw_schema_name(&value); + match schema { + SCHEMA_EXTERNAL_REFERENCE => { + serde_json::from_value(value).map(MediaReference::ExternalReference).map_err(de::Error::custom) + } + SCHEMA_MISSING_REFERENCE => { + serde_json::from_value(value).map(MediaReference::MissingReference).map_err(de::Error::custom) + } + _ => Ok(MediaReference::Raw(value)), + } + } +} + +// --------------------------------------------------------------------------- +// Composable objects (blocks and containers) +// --------------------------------------------------------------------------- + +/// `Clip.2` — a reference to a piece of media. +#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)] +#[serde(default)] +pub struct Clip { + #[serde(rename = "OTIO_SCHEMA", default)] + otio_schema: String, + metadata: Map, + name: String, + source_range: Option, + effects: Vec, + markers: Vec, + enabled: bool, + media_references: BTreeMap, + active_media_reference_key: Option, + #[serde(flatten)] + unknown: Map, +} + +impl Clip { + /// Construct a named clip (the C++ `Clip(name)` constructor). All + /// optional fields start unset; `enabled` defaults to true. + pub fn new(name: impl Into) -> Clip { + Clip { + otio_schema: SCHEMA_CLIP.to_string(), + metadata: Map::new(), + name: name.into(), + source_range: None, + effects: Vec::new(), + markers: Vec::new(), + enabled: true, + media_references: BTreeMap::new(), + active_media_reference_key: None, + unknown: Map::new(), + } + } + + /// The clip name (C++ `name`). + pub fn name(&self) -> &str { + &self.name + } + + /// The range of the source media used by this clip, if set + /// (C++ `source_range`; null on disk when unset). + pub fn source_range(&self) -> Option { + self.source_range.clone() + } + + /// The active media reference, resolved by `active_media_reference_key` + /// (falling back to "DEFAULT_MEDIA", the C++ behavior). + pub fn media_reference(&self) -> Option<&MediaReference> { + let key = self.active_media_reference_key.as_deref().unwrap_or("DEFAULT_MEDIA"); + self.media_references.get(key) + } + + /// All media references by key. + pub fn media_references(&self) -> &BTreeMap { + &self.media_references + } + + /// Set the source range (C++ `set_source_range`). + pub fn set_source_range(&mut self, range: TimeRange) { + self.source_range = Some(range); + } + + /// Attach a media reference under "DEFAULT_MEDIA" and make it active + /// (C++ `set_media_reference`). + pub fn set_media_reference(&mut self, reference: MediaReference) { + self.media_references.insert("DEFAULT_MEDIA".to_string(), reference); + self.active_media_reference_key = Some("DEFAULT_MEDIA".to_string()); + } +} + +impl Default for Clip { + fn default() -> Self { + Clip::new("") + } +} + +/// `Gap.1` — an empty span of time on a track. +#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)] +#[serde(default)] +pub struct Gap { + #[serde(rename = "OTIO_SCHEMA", default)] + otio_schema: String, + metadata: Map, + name: String, + source_range: Option, + effects: Vec, + markers: Vec, + enabled: bool, + #[serde(flatten)] + unknown: Map, +} + +impl Gap { + /// Construct `Gap(source_range, name)` (C++ argument order). + pub fn new(source_range: TimeRange, name: impl Into) -> Gap { + Gap { + otio_schema: SCHEMA_GAP.to_string(), + metadata: Map::new(), + name: name.into(), + source_range: Some(source_range), + effects: Vec::new(), + markers: Vec::new(), + enabled: true, + unknown: Map::new(), + } + } + + /// The gap name. + pub fn name(&self) -> &str { + &self.name + } + + /// The gap's source range (always set for gaps written by this crate). + pub fn source_range(&self) -> Option { + self.source_range.clone() + } +} + +impl Default for Gap { + fn default() -> Self { + Gap { + otio_schema: SCHEMA_GAP.to_string(), + metadata: Map::new(), + name: String::new(), + source_range: None, + effects: Vec::new(), + markers: Vec::new(), + enabled: true, + unknown: Map::new(), + } + } +} + +/// `Transition.1` — a transition between two blocks. The C++ writer always +/// writes `transition_type` (empty string when unset). +#[derive(Clone, Debug, PartialEq, Default, serde::Serialize, serde::Deserialize)] +#[serde(default)] +pub struct Transition { + #[serde(rename = "OTIO_SCHEMA", default)] + otio_schema: String, + metadata: Map, + name: String, + in_offset: RationalTime, + out_offset: RationalTime, + transition_type: String, + #[serde(flatten)] + unknown: Map, +} + +impl Transition { + /// Construct a named transition (the C++ `Transition(name)` + /// constructor; offsets default to `RationalTime(0, 1)`). + pub fn new(name: impl Into) -> Transition { + Transition { + otio_schema: SCHEMA_TRANSITION.to_string(), + metadata: Map::new(), + name: name.into(), + in_offset: RationalTime::new(0.0, 1.0), + out_offset: RationalTime::new(0.0, 1.0), + transition_type: String::new(), + unknown: Map::new(), + } + } + + /// The transition name. + pub fn name(&self) -> &str { + &self.name + } + + /// How far into the previous block the transition reaches (C++ + /// `in_offset`). + pub fn in_offset(&self) -> RationalTime { + self.in_offset.clone() + } + + /// How far into the next block the transition reaches (C++ + /// `out_offset`). + pub fn out_offset(&self) -> RationalTime { + self.out_offset.clone() + } + + /// The transition type ("SMPTE_Dissolve", "SMPTE_Wipe", "" ...). + pub fn transition_type(&self) -> &str { + &self.transition_type + } + + /// Set the in offset (C++ `set_in_offset`). + pub fn set_in_offset(&mut self, offset: RationalTime) { + self.in_offset = offset; + } + + /// Set the out offset (C++ `set_out_offset`). + pub fn set_out_offset(&mut self, offset: RationalTime) { + self.out_offset = offset; + } +} + +/// `Stack.1` — an ordered container of composables (used for a timeline's +/// tracks). +#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)] +#[serde(default)] +pub struct Stack { + #[serde(rename = "OTIO_SCHEMA", default)] + otio_schema: String, + metadata: Map, + name: String, + source_range: Option, + effects: Vec, + markers: Vec, + enabled: bool, + children: Vec>, + #[serde(flatten)] + unknown: Map, +} + +impl Default for Stack { + fn default() -> Self { + Stack { + otio_schema: SCHEMA_STACK.to_string(), + metadata: Map::new(), + name: String::new(), + source_range: None, + effects: Vec::new(), + markers: Vec::new(), + enabled: true, + children: Vec::new(), + unknown: Map::new(), + } + } +} + +impl Stack { + /// The stack's children in order (C++ `children`). + pub fn children(&self) -> &[Box] { + &self.children + } + + /// Append a child (C++ `append_child`). + pub fn append_child(&mut self, child: Composable) { + self.children.push(Box::new(child)); + } +} + +/// `Track.1` — a stack with a track kind. Field order on disk is +/// `children` then `kind` (the opentimelineio writer's order). +#[derive(Clone, Debug, PartialEq, Default, serde::Serialize, serde::Deserialize)] +#[serde(default)] +pub struct Track { + #[serde(rename = "OTIO_SCHEMA", default)] + otio_schema: String, + metadata: Map, + name: String, + source_range: Option, + effects: Vec, + markers: Vec, + enabled: bool, + children: Vec>, + kind: String, + #[serde(flatten)] + unknown: Map, +} + +impl Track { + /// Construct a track of the given kind ("Video" or "Audio"). + pub fn new(kind: impl Into) -> Track { + Track { + otio_schema: SCHEMA_TRACK.to_string(), + metadata: Map::new(), + name: String::new(), + source_range: None, + effects: Vec::new(), + markers: Vec::new(), + enabled: true, + children: Vec::new(), + kind: kind.into(), + unknown: Map::new(), + } + } + + /// The track kind ("Video", "Audio", ...). + pub fn kind(&self) -> &str { + &self.kind + } + + /// The track's blocks in order (C++ `children`). + pub fn children(&self) -> &[Box] { + &self.children + } + + /// Append a child (C++ `append_child`). + pub fn append_child(&mut self, child: Composable) { + self.children.push(Box::new(child)); + } +} + +/// A composable in a track or stack: `Clip`, `Gap`, `Transition`, `Track`, +/// `Stack`, or an unrecognized schema kept whole as `Raw`. +#[derive(Clone, Debug, PartialEq)] +pub enum Composable { + Clip(Clip), + Gap(Gap), + Transition(Transition), + Track(Track), + Stack(Stack), + /// An unrecognized composable schema, preserved verbatim. + Raw(Value), +} + +impl Composable { + /// The base schema name ("Clip", "Gap", "Transition", "Track", + /// "Stack", or the raw `OTIO_SCHEMA` string for unknown blocks). + pub fn schema_name(&self) -> &str { + match self { + Composable::Clip(_) => "Clip", + Composable::Gap(_) => "Gap", + Composable::Transition(_) => "Transition", + Composable::Track(_) => "Track", + Composable::Stack(_) => "Stack", + Composable::Raw(v) => raw_schema_name(v), + } + } + + /// The object's name ("" for unknown blocks). + pub fn name(&self) -> &str { + match self { + Composable::Clip(c) => &c.name, + Composable::Gap(g) => &g.name, + Composable::Transition(t) => &t.name, + Composable::Track(t) => &t.name, + Composable::Stack(s) => &s.name, + Composable::Raw(_) => "", + } + } + + /// The source range of items that carry one (Clip and Gap; the C++ + /// `Item::source_range` cast for these two block kinds). + pub fn source_range(&self) -> Option { + match self { + Composable::Clip(c) => c.source_range.clone(), + Composable::Gap(g) => g.source_range.clone(), + _ => None, + } + } + + /// Downcast to a concrete `Clip`. + pub fn as_clip(&self) -> Option<&Clip> { + match self { + Composable::Clip(c) => Some(c), + _ => None, + } + } + + /// Downcast to a concrete `Gap`. + pub fn as_gap(&self) -> Option<&Gap> { + match self { + Composable::Gap(g) => Some(g), + _ => None, + } + } + + /// Downcast to a concrete `Transition`. + pub fn as_transition(&self) -> Option<&Transition> { + match self { + Composable::Transition(t) => Some(t), + _ => None, + } + } + + /// Downcast to a concrete `Track`. + pub fn as_track(&self) -> Option<&Track> { + match self { + Composable::Track(t) => Some(t), + _ => None, + } + } + + /// Downcast to a concrete `Stack`. + pub fn as_stack(&self) -> Option<&Stack> { + match self { + Composable::Stack(s) => Some(s), + _ => None, + } + } +} + +impl Serialize for Composable { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + match self { + Composable::Clip(c) => c.serialize(serializer), + Composable::Gap(g) => g.serialize(serializer), + Composable::Transition(t) => t.serialize(serializer), + Composable::Track(t) => t.serialize(serializer), + Composable::Stack(s) => s.serialize(serializer), + Composable::Raw(v) => v.serialize(serializer), + } + } +} + +impl<'de> Deserialize<'de> for Composable { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + let value = Value::deserialize(deserializer)?; + let schema = raw_schema_name(&value); + match schema { + SCHEMA_CLIP => serde_json::from_value(value).map(Composable::Clip).map_err(de::Error::custom), + SCHEMA_GAP => serde_json::from_value(value).map(Composable::Gap).map_err(de::Error::custom), + SCHEMA_TRANSITION => { + serde_json::from_value(value).map(Composable::Transition).map_err(de::Error::custom) + } + SCHEMA_TRACK => serde_json::from_value(value).map(Composable::Track).map_err(de::Error::custom), + SCHEMA_STACK => serde_json::from_value(value).map(Composable::Stack).map_err(de::Error::custom), + _ => Ok(Composable::Raw(value)), + } + } +} + +// --------------------------------------------------------------------------- +// Root serializable objects +// --------------------------------------------------------------------------- + +/// `Timeline.1` — the root of a single-timeline document. +#[derive(Clone, Debug, PartialEq, Default, serde::Serialize, serde::Deserialize)] +#[serde(default)] +pub struct Timeline { + #[serde(rename = "OTIO_SCHEMA", default)] + otio_schema: String, + metadata: Map, + name: String, + global_start_time: Option, + tracks: Stack, + #[serde(flatten)] + unknown: Map, +} + +impl Timeline { + /// Construct a named timeline whose tracks stack is an empty + /// `Stack` named "tracks" (the C++ `Timeline(name)` constructor). + pub fn new(name: impl Into) -> Timeline { + let mut tracks = Stack::default(); + tracks.name = "tracks".to_string(); + Timeline { + otio_schema: SCHEMA_TIMELINE.to_string(), + metadata: Map::new(), + name: name.into(), + global_start_time: None, + tracks, + unknown: Map::new(), + } + } + + /// The timeline name. + pub fn name(&self) -> &str { + &self.name + } + + /// The tracks stack (C++ `tracks`). + pub fn tracks(&self) -> &Stack { + &self.tracks + } + + /// Mutable access to the tracks stack, for appending tracks. + pub fn tracks_mut(&mut self) -> &mut Stack { + &mut self.tracks + } + + /// The global start time, if set (null on disk when unset). + pub fn global_start_time(&self) -> Option { + self.global_start_time.clone() + } + + /// Serialize to the opentimelineio JSON string format. + pub fn to_json_string(&self) -> Result { + Ok(to_json_string(self)?) + } + + /// Write to a file in the opentimelineio JSON format. + pub fn to_json_file(&self, path: impl AsRef) -> Result<(), OtioError> { + to_json_file(self, path.as_ref()) + } +} + +/// `SerializableCollection.1` — a root that groups multiple timelines. +#[derive(Clone, Debug, PartialEq, Default, serde::Serialize, serde::Deserialize)] +#[serde(default)] +pub struct SerializableCollection { + #[serde(rename = "OTIO_SCHEMA", default)] + otio_schema: String, + metadata: Map, + name: String, + children: Vec>, + #[serde(flatten)] + unknown: Map, +} + +impl SerializableCollection { + /// Construct `SerializableCollection(name, children)` (C++ argument + /// order). + pub fn new(name: impl Into, children: Vec) -> SerializableCollection { + SerializableCollection { + otio_schema: SCHEMA_SERIALIZABLE_COLLECTION.to_string(), + metadata: Map::new(), + name: name.into(), + children: children.into_iter().map(Box::new).collect(), + unknown: Map::new(), + } + } + + /// The collection name. + pub fn name(&self) -> &str { + &self.name + } + + /// The collection's children in order. + pub fn children(&self) -> &[Box] { + &self.children + } +} + +/// The root of an OpenTimelineIO document: `Timeline`, +/// `SerializableCollection`, or an unrecognized schema kept whole as `Raw`. +#[derive(Clone, Debug, PartialEq)] +pub enum Serializable { + Timeline(Timeline), + SerializableCollection(SerializableCollection), + /// An unrecognized root schema, preserved verbatim. + Raw(Value), +} + +impl Serializable { + /// The base schema name ("Timeline", "SerializableCollection", or the + /// raw `OTIO_SCHEMA` string for unknown roots). + pub fn schema_name(&self) -> &str { + match self { + Serializable::Timeline(_) => "Timeline", + Serializable::SerializableCollection(_) => "SerializableCollection", + Serializable::Raw(v) => raw_schema_name(v), + } + } + + /// Downcast to a concrete `Timeline`. + pub fn as_timeline(&self) -> Option<&Timeline> { + match self { + Serializable::Timeline(t) => Some(t), + _ => None, + } + } + + /// Downcast to a concrete `SerializableCollection`. + pub fn as_collection(&self) -> Option<&SerializableCollection> { + match self { + Serializable::SerializableCollection(c) => Some(c), + _ => None, + } + } + + /// Serialize to the opentimelineio JSON string format. + pub fn to_json_string(&self) -> Result { + Ok(to_json_string(self)?) + } + + /// Write to a file in the opentimelineio JSON format. + pub fn to_json_file(&self, path: impl AsRef) -> Result<(), OtioError> { + to_json_file(self, path.as_ref()) + } +} + +impl Serialize for Serializable { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + match self { + Serializable::Timeline(t) => t.serialize(serializer), + Serializable::SerializableCollection(c) => c.serialize(serializer), + Serializable::Raw(v) => v.serialize(serializer), + } + } +} + +impl<'de> Deserialize<'de> for Serializable { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + let value = Value::deserialize(deserializer)?; + let schema = raw_schema_name(&value); + match schema { + SCHEMA_TIMELINE => { + serde_json::from_value(value).map(Serializable::Timeline).map_err(de::Error::custom) + } + SCHEMA_SERIALIZABLE_COLLECTION => { + serde_json::from_value(value).map(Serializable::SerializableCollection).map_err(de::Error::custom) + } + _ => Ok(Serializable::Raw(value)), + } + } +} + +// --------------------------------------------------------------------------- +// Rational::from_double port +// --------------------------------------------------------------------------- + +/// `olive::core::Rational::from_double` (core/src/util/rational.cpp), ported +/// on top of `oakcore_rs::Rational::new`. `Rational::new` applies the exact +/// C++ `reduce_fraction(INT_MAX)` reduction, so the same raw numerator / +/// denominator pairs yield bit-identical rationals. +fn from_double(flt: f64) -> Rational { + // NaN and anything beyond the int32 range collapse to the null sentinel + // (0/0). + if flt.is_nan() || flt.abs() > i32::MAX as f64 + 3.0 { + return Rational::NULL; + } + + // frexp(flt, &exp) with exponent = max(exp - 1, 0); exp - 1 equals the + // IEEE unbiased exponent, so `exponent = max(unbiased, 0)`. + let bits = flt.to_bits(); + let unbiased = ((bits >> 52) & 0x7ff) as i64 - 1023; + let exponent = unbiased.max(0); + + // den = 1 << (62 - exponent); num = floor(flt * den + 0.5). + let den = 1i64 << (62 - exponent); + let num = (flt * den as f64 + 0.5).floor() as i64; + + let mut r = Rational::new(num, den); + + // If the first pass reduced to zero, retry against INT64_MAX + // (C++: `if ((!rnum || !rden) && flt)`). Only triggered by tiny + // non-zero magnitudes; the product is always in int64 range, so the + // float-to-int cast truncates exactly like the C++ one. + if r.is_null() && flt != 0.0 { + r = Rational::new((flt * i64::MAX as f64) as i64, i64::MAX); + } + + if r.is_nan() { + return Rational::NULL; + } + r +} + +#[cfg(test)] +mod tests { + use super::*; + + fn assert_rt(value: f64, num: i64, den: i64) { + let r = from_double(value); + assert_eq!( + (r.numerator(), r.denominator()), + (num, den), + "from_double({value}) != {num}/{den}" + ); + } + + #[test] + fn from_double_basics() { + assert_rt(0.0, 0, 1); + assert_rt(1.0, 1, 1); + assert_rt(24.0, 24, 1); + assert_rt(0.1, 1, 10); + assert_rt(4.8, 24, 5); + assert_rt(-0.1, -1, 10); + assert_rt(1152.0 / 24.0, 48, 1); + assert_rt(123456789.125, 987654313, 8); + } + + #[test] + fn from_double_sentinels() { + assert!(from_double(f64::NAN).is_null()); + assert!(from_double(f64::INFINITY).is_null()); + assert!(from_double(-f64::INFINITY).is_null()); + assert!(from_double(i32::MAX as f64 + 4.0).is_null()); + assert_rt(-0.0, 0, 1); + } + + #[test] + fn from_double_tiny_retry() { + // 2^-63 < flt < 2^-62: the first pass reduces to 0/1; the retry + // against INT64_MAX is itself reduced back to 0/1 by the INT_MAX + // ceiling, matching the C++ behavior exactly. + let tiny = 1.5e-19; + let r = from_double(tiny); + assert_eq!((r.numerator(), r.denominator()), (0, 1)); + // Positive zero of the first pass but nonzero value: retry fires. + assert_rt(0.0, 0, 1); + } + + #[test] + fn to_rational_from_seconds() { + // C++ fromRationalTime: RationalTime(1152, 24).to_seconds() = 48. + assert_eq!(RationalTime::new(1152.0, 24.0).to_rational(), Rational::new(48, 1)); + // RationalTime(12, 1).to_seconds() = 12. + assert_eq!(RationalTime::new(12.0, 1.0).to_rational(), Rational::new(12, 1)); + // RationalTime(576, 24).to_seconds() = 24. + assert_eq!(RationalTime::new(576.0, 24.0).to_rational(), Rational::new(24, 1)); + } + + #[test] + fn from_rational_matches_cpp_to_rational_time() { + // Rational(576, 24).toRationalTime(24) stays {576, 24}. + let rt = RationalTime::from_rational(Rational::new(576, 24), 24.0); + assert_eq!((rt.value(), rt.rate()), (576.0, 24.0)); + // Rational(12, 24).toRationalTime() (default 24) = {12, 24}. + let rt = RationalTime::from_rational(Rational::new(12, 24), 24.0); + assert_eq!((rt.value(), rt.rate()), (12.0, 24.0)); + // Rational(0, 1).toRationalTime(24) = {0, 24}. + let rt = RationalTime::from_rational(Rational::new(0, 1), 24.0); + assert_eq!((rt.value(), rt.rate()), (0.0, 24.0)); + // Rational(1, 25).toRationalTime(25) = {1, 25}. + let rt = RationalTime::from_rational(Rational::new(1, 25), 25.0); + assert_eq!((rt.value(), rt.rate()), (1.0, 25.0)); + } + + #[test] + fn rescaled_to_semantics() { + let rt = RationalTime::new(1.0, 25.0).rescaled_to(50.0); + assert_eq!((rt.value(), rt.rate()), (2.0, 50.0)); + // Same rate: returned unchanged. + let rt = RationalTime::new(1.0, 25.0).rescaled_to(25.0); + assert_eq!((rt.value(), rt.rate()), (1.0, 25.0)); + } + + #[test] + fn invalid_time_semantics() { + assert!(RationalTime::new(0.0, 0.0).is_invalid_time()); + assert!(RationalTime::new(1.0, -1.0).is_invalid_time()); + assert!(RationalTime::new(f64::NAN, 24.0).is_invalid_time()); + assert!(!RationalTime::new(1.0, 24.0).is_invalid_time()); + } + + #[test] + fn schema_names() { + let clip = Composable::Clip(Clip::new("c")); + assert_eq!(clip.schema_name(), "Clip"); + assert_eq!(clip.name(), "c"); + assert_eq!(Composable::Gap(Gap::new(TimeRange::default(), "g")).schema_name(), "Gap"); + assert_eq!(Composable::Transition(Transition::new("t")).schema_name(), "Transition"); + assert_eq!(Composable::Track(Track::new("Video")).schema_name(), "Track"); + assert_eq!(Composable::Stack(Stack::default()).schema_name(), "Stack"); + } + + #[test] + fn unknown_field_round_trip() { + let src = r#"{ + "OTIO_SCHEMA": "Timeline.1", + "metadata": {}, + "name": "T", + "global_start_time": null, + "tracks": { + "OTIO_SCHEMA": "Stack.1", + "metadata": {"custom": 42}, + "name": "tracks", + "source_range": null, + "effects": [], + "markers": [], + "enabled": true, + "children": [], + "future_field": {"nested": [1, 2, 3]} + }, + "some_future_root_field": "kept" + }"#; + let root: Serializable = serde_json::from_str(src).unwrap(); + let out: Value = serde_json::from_str(&to_json_string(&root).unwrap()).unwrap(); + assert_eq!(out["tracks"]["future_field"].clone(), serde_json::json!({"nested": [1, 2, 3]}), "{out}"); + assert_eq!(out["some_future_root_field"].clone(), serde_json::json!("kept"), "{out}"); + assert_eq!(out["tracks"]["metadata"].clone(), serde_json::json!({"custom": 42}), "{out}"); + } + + #[test] + fn unknown_root_and_composable_stay_raw() { + let raw_root = r#"{"OTIO_SCHEMA": "WeirdThing.9", "a": 1}"#; + let root: Serializable = serde_json::from_str(raw_root).unwrap(); + assert_eq!(root.schema_name(), "WeirdThing.9"); + let out: Value = serde_json::from_str(&to_json_string(&root).unwrap()).unwrap(); + assert_eq!(out, serde_json::from_str::(raw_root).unwrap()); + + let raw_block = r#"{"OTIO_SCHEMA": "FancyBlock.3", "b": [true]}"#; + let block: Composable = serde_json::from_str(raw_block).unwrap(); + assert_eq!(block.schema_name(), "FancyBlock.3"); + let out: Value = serde_json::from_str(&to_json_string(&block).unwrap()).unwrap(); + assert_eq!(out, serde_json::from_str::(raw_block).unwrap()); + + let raw_media = r#"{"OTIO_SCHEMA": "FancyReference.2", "c": "x"}"#; + let media: MediaReference = serde_json::from_str(raw_media).unwrap(); + assert_eq!(media.schema_name(), "FancyReference.2"); + let out: Value = serde_json::from_str(&to_json_string(&media).unwrap()).unwrap(); + assert_eq!(out, serde_json::from_str::(raw_media).unwrap()); + } + + #[test] + fn timeline_new_builds_named_tracks_stack() { + let t = Timeline::new("My Sequence"); + assert_eq!(t.name(), "My Sequence"); + assert_eq!(t.tracks().children().len(), 0); + assert!(t.global_start_time().is_none()); + let out = to_json_string(&t).unwrap(); + assert!(out.contains("\"name\": \"tracks\""), "{out}"); + } + + #[test] + fn clip_media_reference_resolution() { + let mut clip = Clip::new("c"); + assert!(clip.media_reference().is_none()); + clip.set_media_reference(MediaReference::ExternalReference(ExternalReference::new( + "file:///x.mp4", + None, + ))); + let mr = clip.media_reference().unwrap(); + assert_eq!(mr.schema_name(), "ExternalReference"); + assert_eq!(mr.as_external_reference().unwrap().target_url(), "file:///x.mp4"); + // An active key that is not in the map yields None (C++ behavior). + let mut clip2 = Clip::new("c2"); + clip2.active_media_reference_key = Some("OTHER".to_string()); + clip2.media_references.insert("OTHER".to_string(), MediaReference::MissingReference(MissingReference::new())); + assert!(clip2.media_reference().is_some()); + } +} diff --git a/src/bindings/oakotio/tests/data/floatfmt.json b/src/bindings/oakotio/tests/data/floatfmt.json new file mode 100644 index 000000000..41e1d4275 --- /dev/null +++ b/src/bindings/oakotio/tests/data/floatfmt.json @@ -0,0 +1,91 @@ +{ + "OTIO_SCHEMA": "Timeline.1", + "metadata": {}, + "name": "F", + "global_start_time": null, + "tracks": { + "OTIO_SCHEMA": "Stack.1", + "metadata": {}, + "name": "tracks", + "source_range": null, + "effects": [], + "markers": [], + "enabled": true, + "children": [ + { + "OTIO_SCHEMA": "Track.1", + "metadata": {}, + "name": "", + "source_range": null, + "effects": [], + "markers": [], + "enabled": true, + "children": [ + { + "OTIO_SCHEMA": "Clip.2", + "metadata": {}, + "name": "c1", + "source_range": { + "OTIO_SCHEMA": "TimeRange.1", + "duration": { + "OTIO_SCHEMA": "RationalTime.1", + "rate": 1.0, + "value": 0.1 + }, + "start_time": { + "OTIO_SCHEMA": "RationalTime.1", + "rate": 3.0, + "value": 1.0 + } + }, + "effects": [], + "markers": [], + "enabled": true, + "media_references": { + "DEFAULT_MEDIA": { + "OTIO_SCHEMA": "MissingReference.1", + "metadata": {}, + "name": "", + "available_range": null, + "available_image_bounds": null + } + }, + "active_media_reference_key": "DEFAULT_MEDIA" + }, + { + "OTIO_SCHEMA": "Clip.2", + "metadata": {}, + "name": "c2", + "source_range": { + "OTIO_SCHEMA": "TimeRange.1", + "duration": { + "OTIO_SCHEMA": "RationalTime.1", + "rate": 1.0, + "value": 123456789.125 + }, + "start_time": { + "OTIO_SCHEMA": "RationalTime.1", + "rate": 24.0, + "value": 4.8 + } + }, + "effects": [], + "markers": [], + "enabled": true, + "media_references": { + "DEFAULT_MEDIA": { + "OTIO_SCHEMA": "MissingReference.1", + "metadata": {}, + "name": "", + "available_range": null, + "available_image_bounds": null + } + }, + "active_media_reference_key": "DEFAULT_MEDIA" + } + ], + "kind": "Video" + } + ] + } +} \ No newline at end of file diff --git a/src/bindings/oakotio/tests/data/golden_collection.json b/src/bindings/oakotio/tests/data/golden_collection.json new file mode 100644 index 000000000..c76f1a295 --- /dev/null +++ b/src/bindings/oakotio/tests/data/golden_collection.json @@ -0,0 +1,360 @@ +{ + "OTIO_SCHEMA": "SerializableCollection.1", + "metadata": {}, + "name": "Sequences", + "children": [ + { + "OTIO_SCHEMA": "Timeline.1", + "metadata": {}, + "name": "Seq One", + "global_start_time": null, + "tracks": { + "OTIO_SCHEMA": "Stack.1", + "metadata": {}, + "name": "tracks", + "source_range": null, + "effects": [], + "markers": [], + "enabled": true, + "children": [ + { + "OTIO_SCHEMA": "Track.1", + "metadata": {}, + "name": "", + "source_range": null, + "effects": [], + "markers": [], + "enabled": true, + "children": [ + { + "OTIO_SCHEMA": "Clip.2", + "metadata": {}, + "name": "Seq One Clip", + "source_range": { + "OTIO_SCHEMA": "TimeRange.1", + "duration": { + "OTIO_SCHEMA": "RationalTime.1", + "rate": 30.0, + "value": 1440.0 + }, + "start_time": { + "OTIO_SCHEMA": "RationalTime.1", + "rate": 30.0, + "value": 0.0 + } + }, + "effects": [], + "markers": [], + "enabled": true, + "media_references": { + "DEFAULT_MEDIA": { + "OTIO_SCHEMA": "ExternalReference.1", + "metadata": {}, + "name": "", + "available_range": { + "OTIO_SCHEMA": "TimeRange.1", + "duration": { + "OTIO_SCHEMA": "RationalTime.1", + "rate": 25.0, + "value": 100.0 + }, + "start_time": { + "OTIO_SCHEMA": "RationalTime.1", + "rate": 25.0, + "value": 0.0 + } + }, + "available_image_bounds": null, + "target_url": "file:///tmp/Seq One.mp4" + } + }, + "active_media_reference_key": "DEFAULT_MEDIA" + }, + { + "OTIO_SCHEMA": "Gap.1", + "metadata": {}, + "name": "Seq One Gap", + "source_range": { + "OTIO_SCHEMA": "TimeRange.1", + "duration": { + "OTIO_SCHEMA": "RationalTime.1", + "rate": 24.0, + "value": 576.0 + }, + "start_time": { + "OTIO_SCHEMA": "RationalTime.1", + "rate": 24.0, + "value": 0.0 + } + }, + "effects": [], + "markers": [], + "enabled": true + }, + { + "OTIO_SCHEMA": "Transition.1", + "metadata": {}, + "name": "Seq One Transition", + "in_offset": { + "OTIO_SCHEMA": "RationalTime.1", + "rate": 24.0, + "value": 12.0 + }, + "out_offset": { + "OTIO_SCHEMA": "RationalTime.1", + "rate": 24.0, + "value": 12.0 + }, + "transition_type": "" + } + ], + "kind": "Video" + }, + { + "OTIO_SCHEMA": "Track.1", + "metadata": {}, + "name": "", + "source_range": null, + "effects": [], + "markers": [], + "enabled": true, + "children": [ + { + "OTIO_SCHEMA": "Clip.2", + "metadata": {}, + "name": "Seq One Audio", + "source_range": { + "OTIO_SCHEMA": "TimeRange.1", + "duration": { + "OTIO_SCHEMA": "RationalTime.1", + "rate": 30.0, + "value": 1440.0 + }, + "start_time": { + "OTIO_SCHEMA": "RationalTime.1", + "rate": 30.0, + "value": 0.0 + } + }, + "effects": [], + "markers": [], + "enabled": true, + "media_references": { + "DEFAULT_MEDIA": { + "OTIO_SCHEMA": "ExternalReference.1", + "metadata": {}, + "name": "", + "available_range": { + "OTIO_SCHEMA": "TimeRange.1", + "duration": { + "OTIO_SCHEMA": "RationalTime.1", + "rate": 48000.0, + "value": 0.0 + }, + "start_time": { + "OTIO_SCHEMA": "RationalTime.1", + "rate": 48000.0, + "value": 0.0 + } + }, + "available_image_bounds": null, + "target_url": "file:///tmp/Seq One.wav" + } + }, + "active_media_reference_key": "DEFAULT_MEDIA" + } + ], + "kind": "Audio" + } + ] + } + }, + { + "OTIO_SCHEMA": "Timeline.1", + "metadata": {}, + "name": "Seq Two", + "global_start_time": null, + "tracks": { + "OTIO_SCHEMA": "Stack.1", + "metadata": {}, + "name": "tracks", + "source_range": null, + "effects": [], + "markers": [], + "enabled": true, + "children": [ + { + "OTIO_SCHEMA": "Track.1", + "metadata": {}, + "name": "", + "source_range": null, + "effects": [], + "markers": [], + "enabled": true, + "children": [ + { + "OTIO_SCHEMA": "Clip.2", + "metadata": {}, + "name": "Seq Two Clip", + "source_range": { + "OTIO_SCHEMA": "TimeRange.1", + "duration": { + "OTIO_SCHEMA": "RationalTime.1", + "rate": 25.0, + "value": 1200.0 + }, + "start_time": { + "OTIO_SCHEMA": "RationalTime.1", + "rate": 25.0, + "value": 0.0 + } + }, + "effects": [], + "markers": [], + "enabled": true, + "media_references": { + "DEFAULT_MEDIA": { + "OTIO_SCHEMA": "ExternalReference.1", + "metadata": {}, + "name": "", + "available_range": { + "OTIO_SCHEMA": "TimeRange.1", + "duration": { + "OTIO_SCHEMA": "RationalTime.1", + "rate": 25.0, + "value": 100.0 + }, + "start_time": { + "OTIO_SCHEMA": "RationalTime.1", + "rate": 25.0, + "value": 0.0 + } + }, + "available_image_bounds": null, + "target_url": "file:///tmp/Seq Two.mp4" + } + }, + "active_media_reference_key": "DEFAULT_MEDIA" + }, + { + "OTIO_SCHEMA": "Gap.1", + "metadata": {}, + "name": "Seq Two Gap", + "source_range": { + "OTIO_SCHEMA": "TimeRange.1", + "duration": { + "OTIO_SCHEMA": "RationalTime.1", + "rate": 24.0, + "value": 576.0 + }, + "start_time": { + "OTIO_SCHEMA": "RationalTime.1", + "rate": 24.0, + "value": 0.0 + } + }, + "effects": [], + "markers": [], + "enabled": true + }, + { + "OTIO_SCHEMA": "Transition.1", + "metadata": {}, + "name": "Seq Two Transition", + "in_offset": { + "OTIO_SCHEMA": "RationalTime.1", + "rate": 24.0, + "value": 12.0 + }, + "out_offset": { + "OTIO_SCHEMA": "RationalTime.1", + "rate": 24.0, + "value": 12.0 + }, + "transition_type": "" + } + ], + "kind": "Video" + }, + { + "OTIO_SCHEMA": "Track.1", + "metadata": {}, + "name": "", + "source_range": null, + "effects": [], + "markers": [], + "enabled": true, + "children": [ + { + "OTIO_SCHEMA": "Clip.2", + "metadata": {}, + "name": "Seq Two Audio", + "source_range": { + "OTIO_SCHEMA": "TimeRange.1", + "duration": { + "OTIO_SCHEMA": "RationalTime.1", + "rate": 25.0, + "value": 1200.0 + }, + "start_time": { + "OTIO_SCHEMA": "RationalTime.1", + "rate": 25.0, + "value": 0.0 + } + }, + "effects": [], + "markers": [], + "enabled": true, + "media_references": { + "DEFAULT_MEDIA": { + "OTIO_SCHEMA": "ExternalReference.1", + "metadata": {}, + "name": "", + "available_range": { + "OTIO_SCHEMA": "TimeRange.1", + "duration": { + "OTIO_SCHEMA": "RationalTime.1", + "rate": 48000.0, + "value": 0.0 + }, + "start_time": { + "OTIO_SCHEMA": "RationalTime.1", + "rate": 48000.0, + "value": 0.0 + } + }, + "available_image_bounds": null, + "target_url": "file:///tmp/Seq Two.wav" + } + }, + "active_media_reference_key": "DEFAULT_MEDIA" + }, + { + "OTIO_SCHEMA": "Gap.1", + "metadata": {}, + "name": "", + "source_range": { + "OTIO_SCHEMA": "TimeRange.1", + "duration": { + "OTIO_SCHEMA": "RationalTime.1", + "rate": 1.0, + "value": 12.0 + }, + "start_time": { + "OTIO_SCHEMA": "RationalTime.1", + "rate": 25.0, + "value": 1200.0 + } + }, + "effects": [], + "markers": [], + "enabled": true + } + ], + "kind": "Audio" + } + ] + } + } + ] +} \ No newline at end of file diff --git a/src/bindings/oakotio/tests/data/golden_timeline.json b/src/bindings/oakotio/tests/data/golden_timeline.json new file mode 100644 index 000000000..9951e425a --- /dev/null +++ b/src/bindings/oakotio/tests/data/golden_timeline.json @@ -0,0 +1,187 @@ +{ + "OTIO_SCHEMA": "Timeline.1", + "metadata": {}, + "name": "My Sequence", + "global_start_time": null, + "tracks": { + "OTIO_SCHEMA": "Stack.1", + "metadata": {}, + "name": "tracks", + "source_range": null, + "effects": [], + "markers": [], + "enabled": true, + "children": [ + { + "OTIO_SCHEMA": "Track.1", + "metadata": {}, + "name": "", + "source_range": null, + "effects": [], + "markers": [], + "enabled": true, + "children": [ + { + "OTIO_SCHEMA": "Clip.2", + "metadata": {}, + "name": "My Sequence Clip", + "source_range": { + "OTIO_SCHEMA": "TimeRange.1", + "duration": { + "OTIO_SCHEMA": "RationalTime.1", + "rate": 24.0, + "value": 1152.0 + }, + "start_time": { + "OTIO_SCHEMA": "RationalTime.1", + "rate": 24.0, + "value": 0.0 + } + }, + "effects": [], + "markers": [], + "enabled": true, + "media_references": { + "DEFAULT_MEDIA": { + "OTIO_SCHEMA": "ExternalReference.1", + "metadata": {}, + "name": "", + "available_range": { + "OTIO_SCHEMA": "TimeRange.1", + "duration": { + "OTIO_SCHEMA": "RationalTime.1", + "rate": 25.0, + "value": 100.0 + }, + "start_time": { + "OTIO_SCHEMA": "RationalTime.1", + "rate": 25.0, + "value": 0.0 + } + }, + "available_image_bounds": null, + "target_url": "file:///tmp/My Sequence.mp4" + } + }, + "active_media_reference_key": "DEFAULT_MEDIA" + }, + { + "OTIO_SCHEMA": "Gap.1", + "metadata": {}, + "name": "My Sequence Gap", + "source_range": { + "OTIO_SCHEMA": "TimeRange.1", + "duration": { + "OTIO_SCHEMA": "RationalTime.1", + "rate": 24.0, + "value": 576.0 + }, + "start_time": { + "OTIO_SCHEMA": "RationalTime.1", + "rate": 24.0, + "value": 0.0 + } + }, + "effects": [], + "markers": [], + "enabled": true + }, + { + "OTIO_SCHEMA": "Transition.1", + "metadata": {}, + "name": "My Sequence Transition", + "in_offset": { + "OTIO_SCHEMA": "RationalTime.1", + "rate": 24.0, + "value": 12.0 + }, + "out_offset": { + "OTIO_SCHEMA": "RationalTime.1", + "rate": 24.0, + "value": 12.0 + }, + "transition_type": "" + } + ], + "kind": "Video" + }, + { + "OTIO_SCHEMA": "Track.1", + "metadata": {}, + "name": "", + "source_range": null, + "effects": [], + "markers": [], + "enabled": true, + "children": [ + { + "OTIO_SCHEMA": "Clip.2", + "metadata": {}, + "name": "My Sequence Audio", + "source_range": { + "OTIO_SCHEMA": "TimeRange.1", + "duration": { + "OTIO_SCHEMA": "RationalTime.1", + "rate": 24.0, + "value": 1152.0 + }, + "start_time": { + "OTIO_SCHEMA": "RationalTime.1", + "rate": 24.0, + "value": 0.0 + } + }, + "effects": [], + "markers": [], + "enabled": true, + "media_references": { + "DEFAULT_MEDIA": { + "OTIO_SCHEMA": "ExternalReference.1", + "metadata": {}, + "name": "", + "available_range": { + "OTIO_SCHEMA": "TimeRange.1", + "duration": { + "OTIO_SCHEMA": "RationalTime.1", + "rate": 48000.0, + "value": 0.0 + }, + "start_time": { + "OTIO_SCHEMA": "RationalTime.1", + "rate": 48000.0, + "value": 0.0 + } + }, + "available_image_bounds": null, + "target_url": "file:///tmp/My Sequence.wav" + } + }, + "active_media_reference_key": "DEFAULT_MEDIA" + }, + { + "OTIO_SCHEMA": "Gap.1", + "metadata": {}, + "name": "", + "source_range": { + "OTIO_SCHEMA": "TimeRange.1", + "duration": { + "OTIO_SCHEMA": "RationalTime.1", + "rate": 1.0, + "value": 12.0 + }, + "start_time": { + "OTIO_SCHEMA": "RationalTime.1", + "rate": 24.0, + "value": 1152.0 + } + }, + "effects": [], + "markers": [], + "enabled": true + } + ], + "kind": "Audio" + } + ] + } +} \ No newline at end of file diff --git a/src/bindings/oakotio/tests/data/golden_typed_transition.json b/src/bindings/oakotio/tests/data/golden_typed_transition.json new file mode 100644 index 000000000..dde1837c1 --- /dev/null +++ b/src/bindings/oakotio/tests/data/golden_typed_transition.json @@ -0,0 +1,187 @@ +{ + "OTIO_SCHEMA": "Timeline.1", + "metadata": {}, + "name": "Typed Transition", + "global_start_time": null, + "tracks": { + "OTIO_SCHEMA": "Stack.1", + "metadata": {}, + "name": "tracks", + "source_range": null, + "effects": [], + "markers": [], + "enabled": true, + "children": [ + { + "OTIO_SCHEMA": "Track.1", + "metadata": {}, + "name": "", + "source_range": null, + "effects": [], + "markers": [], + "enabled": true, + "children": [ + { + "OTIO_SCHEMA": "Clip.2", + "metadata": {}, + "name": "Typed Transition Clip", + "source_range": { + "OTIO_SCHEMA": "TimeRange.1", + "duration": { + "OTIO_SCHEMA": "RationalTime.1", + "rate": 24.0, + "value": 1152.0 + }, + "start_time": { + "OTIO_SCHEMA": "RationalTime.1", + "rate": 24.0, + "value": 0.0 + } + }, + "effects": [], + "markers": [], + "enabled": true, + "media_references": { + "DEFAULT_MEDIA": { + "OTIO_SCHEMA": "ExternalReference.1", + "metadata": {}, + "name": "", + "available_range": { + "OTIO_SCHEMA": "TimeRange.1", + "duration": { + "OTIO_SCHEMA": "RationalTime.1", + "rate": 25.0, + "value": 100.0 + }, + "start_time": { + "OTIO_SCHEMA": "RationalTime.1", + "rate": 25.0, + "value": 0.0 + } + }, + "available_image_bounds": null, + "target_url": "file:///tmp/Typed Transition.mp4" + } + }, + "active_media_reference_key": "DEFAULT_MEDIA" + }, + { + "OTIO_SCHEMA": "Gap.1", + "metadata": {}, + "name": "Typed Transition Gap", + "source_range": { + "OTIO_SCHEMA": "TimeRange.1", + "duration": { + "OTIO_SCHEMA": "RationalTime.1", + "rate": 24.0, + "value": 576.0 + }, + "start_time": { + "OTIO_SCHEMA": "RationalTime.1", + "rate": 24.0, + "value": 0.0 + } + }, + "effects": [], + "markers": [], + "enabled": true + }, + { + "OTIO_SCHEMA": "Transition.1", + "metadata": {}, + "name": "Typed Transition Transition", + "in_offset": { + "OTIO_SCHEMA": "RationalTime.1", + "rate": 24.0, + "value": 12.0 + }, + "out_offset": { + "OTIO_SCHEMA": "RationalTime.1", + "rate": 24.0, + "value": 12.0 + }, + "transition_type": "SMPTE_Dissolve" + } + ], + "kind": "Video" + }, + { + "OTIO_SCHEMA": "Track.1", + "metadata": {}, + "name": "", + "source_range": null, + "effects": [], + "markers": [], + "enabled": true, + "children": [ + { + "OTIO_SCHEMA": "Clip.2", + "metadata": {}, + "name": "Typed Transition Audio", + "source_range": { + "OTIO_SCHEMA": "TimeRange.1", + "duration": { + "OTIO_SCHEMA": "RationalTime.1", + "rate": 24.0, + "value": 1152.0 + }, + "start_time": { + "OTIO_SCHEMA": "RationalTime.1", + "rate": 24.0, + "value": 0.0 + } + }, + "effects": [], + "markers": [], + "enabled": true, + "media_references": { + "DEFAULT_MEDIA": { + "OTIO_SCHEMA": "ExternalReference.1", + "metadata": {}, + "name": "", + "available_range": { + "OTIO_SCHEMA": "TimeRange.1", + "duration": { + "OTIO_SCHEMA": "RationalTime.1", + "rate": 48000.0, + "value": 0.0 + }, + "start_time": { + "OTIO_SCHEMA": "RationalTime.1", + "rate": 48000.0, + "value": 0.0 + } + }, + "available_image_bounds": null, + "target_url": "file:///tmp/Typed Transition.wav" + } + }, + "active_media_reference_key": "DEFAULT_MEDIA" + }, + { + "OTIO_SCHEMA": "Gap.1", + "metadata": {}, + "name": "", + "source_range": { + "OTIO_SCHEMA": "TimeRange.1", + "duration": { + "OTIO_SCHEMA": "RationalTime.1", + "rate": 1.0, + "value": 12.0 + }, + "start_time": { + "OTIO_SCHEMA": "RationalTime.1", + "rate": 24.0, + "value": 1152.0 + } + }, + "effects": [], + "markers": [], + "enabled": true + } + ], + "kind": "Audio" + } + ] + } +} \ No newline at end of file diff --git a/src/bindings/oakotio/tests/parity.rs b/src/bindings/oakotio/tests/parity.rs new file mode 100644 index 000000000..9e01c860b --- /dev/null +++ b/src/bindings/oakotio/tests/parity.rs @@ -0,0 +1,73 @@ +// Oak Video Editor - Non-Linear Video Editor +// Copyright (C) 2026 Oak Team +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +//! Byte-for-byte round-trip tests against the golden files captured from +//! the opentimelineio C++ writer: parse, re-serialize, and require the +//! output to be identical (4-space indent, `": "` separators, inline empty +//! containers, shortest floats, no trailing newline). + +use std::fs; +use std::path::PathBuf; + +fn read_golden(name: &str) -> String { + let path = PathBuf::from(env!("CARGO_MANIFEST_DIR")) + .join("tests/data") + .join(name); + fs::read_to_string(&path).unwrap_or_else(|e| panic!("read {path:?}: {e}")) +} + +fn assert_round_trip(name: &str) { + let text = read_golden(name); + let doc = oakotio::from_json_string(&text).unwrap_or_else(|e| panic!("parse {name}: {e}")); + let out = doc + .to_json_string() + .unwrap_or_else(|e| panic!("serialize {name}: {e}")); + assert_eq!(out, text, "round-trip mismatch for {name}"); +} + +#[test] +fn golden_timeline_round_trips() { + assert_round_trip("golden_timeline.json"); +} + +#[test] +fn golden_collection_round_trips() { + assert_round_trip("golden_collection.json"); +} + +#[test] +fn golden_typed_transition_round_trips() { + assert_round_trip("golden_typed_transition.json"); +} + +#[test] +fn floatfmt_round_trips() { + assert_round_trip("floatfmt.json"); +} + +#[test] +fn golden_timeline_parses_as_timeline_root() { + let doc = oakotio::from_json_string(&read_golden("golden_timeline.json")).unwrap(); + assert_eq!(doc.schema_name(), "Timeline"); + assert!(doc.as_timeline().is_some()); +} + +#[test] +fn golden_collection_parses_as_collection_root() { + let doc = oakotio::from_json_string(&read_golden("golden_collection.json")).unwrap(); + assert_eq!(doc.schema_name(), "SerializableCollection"); + assert!(doc.as_collection().is_some()); +} diff --git a/src/bindings/oakotio/tests/save_parity.rs b/src/bindings/oakotio/tests/save_parity.rs new file mode 100644 index 000000000..c66476148 --- /dev/null +++ b/src/bindings/oakotio/tests/save_parity.rs @@ -0,0 +1,109 @@ +// Oak Video Editor - Non-Linear Video Editor +// Copyright (C) 2026 Oak Team +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +//! Save-side parity: rebuild `golden_timeline.json` through the public +//! builder API and require the serialized bytes to match the golden file +//! byte for byte. This proves the writer (not just the reader) reproduces +//! the opentimelineio C++ output. + +use oakotio::{ + Clip, Composable, ExternalReference, Gap, MediaReference, RationalTime, TimeRange, Timeline, + Track, Transition, +}; + +fn build_golden_timeline() -> Timeline { + let mut timeline = Timeline::new("My Sequence"); + + let mut video = Track::new("Video"); + + let mut clip = Clip::new("My Sequence Clip"); + clip.set_source_range(TimeRange::new( + RationalTime::new(0.0, 24.0), + RationalTime::new(1152.0, 24.0), + )); + clip.set_media_reference(MediaReference::ExternalReference(ExternalReference::new( + "file:///tmp/My Sequence.mp4", + Some(TimeRange::new( + RationalTime::new(0.0, 25.0), + RationalTime::new(100.0, 25.0), + )), + ))); + video.append_child(Composable::Clip(clip)); + + video.append_child(Composable::Gap(Gap::new( + TimeRange::new(RationalTime::new(0.0, 24.0), RationalTime::new(576.0, 24.0)), + "My Sequence Gap", + ))); + + let mut transition = Transition::new("My Sequence Transition"); + transition.set_in_offset(RationalTime::new(12.0, 24.0)); + transition.set_out_offset(RationalTime::new(12.0, 24.0)); + video.append_child(Composable::Transition(transition)); + + let mut audio = Track::new("Audio"); + + let mut audio_clip = Clip::new("My Sequence Audio"); + audio_clip.set_source_range(TimeRange::new( + RationalTime::new(0.0, 24.0), + RationalTime::new(1152.0, 24.0), + )); + audio_clip.set_media_reference(MediaReference::ExternalReference(ExternalReference::new( + "file:///tmp/My Sequence.wav", + Some(TimeRange::new( + RationalTime::new(0.0, 48000.0), + RationalTime::new(0.0, 48000.0), + )), + ))); + audio.append_child(Composable::Clip(audio_clip)); + + audio.append_child(Composable::Gap(Gap::new( + TimeRange::new(RationalTime::new(1152.0, 24.0), RationalTime::new(12.0, 1.0)), + "", + ))); + + timeline.tracks_mut().append_child(Composable::Track(video)); + timeline.tracks_mut().append_child(Composable::Track(audio)); + + timeline +} + +#[test] +fn saved_timeline_matches_golden_bytes() { + let golden = std::fs::read_to_string(concat!( + env!("CARGO_MANIFEST_DIR"), + "/tests/data/golden_timeline.json" + )) + .expect("read golden_timeline.json"); + + let built = build_golden_timeline(); + let out = built.to_json_string().expect("serialize built timeline"); + + assert_eq!(out, golden); +} + +#[test] +fn saved_timeline_reparses_identically() { + // The builder output must also parse back into an equivalent graph. + let built = build_golden_timeline(); + let out = built.to_json_string().unwrap(); + let reparsed = oakotio::from_json_string(&out).unwrap(); + assert_eq!( + reparsed.as_timeline().unwrap().name(), + "My Sequence", + "reparsed timeline keeps the name" + ); + assert_eq!(reparsed.as_timeline().unwrap().tracks().children().len(), 2); +} diff --git a/src/bindings/oakotio/tests/semantic.rs b/src/bindings/oakotio/tests/semantic.rs new file mode 100644 index 000000000..ea271a03d --- /dev/null +++ b/src/bindings/oakotio/tests/semantic.rs @@ -0,0 +1,125 @@ +// Oak Video Editor - Non-Linear Video Editor +// Copyright (C) 2026 Oak Team +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +//! Semantic tests over `golden_timeline.json`: walk the parsed object graph +//! and assert the values Oak's C++ load task depends on. + +use oakotio::{Clip, ExternalReference, MediaReference, Serializable, Timeline}; + +fn golden_timeline() -> Timeline { + let text = std::fs::read_to_string(concat!( + env!("CARGO_MANIFEST_DIR"), + "/tests/data/golden_timeline.json" + )) + .expect("read golden_timeline.json"); + match oakotio::from_json_string(&text).expect("parse golden_timeline.json") { + Serializable::Timeline(t) => t, + other => panic!("expected Timeline root, got {}", other.schema_name()), + } +} + +#[test] +fn root_timeline_fields() { + let tl = golden_timeline(); + assert_eq!(tl.name(), "My Sequence"); + assert_eq!(tl.global_start_time(), None); + assert_eq!(tl.tracks().children().len(), 2); +} + +#[test] +fn video_track_contents() { + let tl = golden_timeline(); + let video = &tl.tracks().children()[0]; + let track = video + .as_track() + .expect("first child of tracks stack is a Track"); + assert_eq!(track.kind(), "Video"); + assert_eq!(track.children().len(), 3); + + // Clip -> Gap -> Transition, in order. + let clip = track.children()[0] + .as_clip() + .expect("video track child 0 is a Clip"); + assert_eq!(clip.name(), "My Sequence Clip"); + let range = clip.source_range().expect("clip has a source_range"); + assert_eq!((range.duration().value(), range.duration().rate()), (1152.0, 24.0)); + assert_eq!((range.start_time().value(), range.start_time().rate()), (0.0, 24.0)); + + let gap = track.children()[1] + .as_gap() + .expect("video track child 1 is a Gap"); + assert_eq!(gap.name(), "My Sequence Gap"); + let grange = gap.source_range().expect("gap has a source_range"); + assert_eq!((grange.duration().value(), grange.duration().rate()), (576.0, 24.0)); + + let trans = track.children()[2] + .as_transition() + .expect("video track child 2 is a Transition"); + assert_eq!(trans.name(), "My Sequence Transition"); + assert_eq!((trans.in_offset().value(), trans.in_offset().rate()), (12.0, 24.0)); + assert_eq!((trans.out_offset().value(), trans.out_offset().rate()), (12.0, 24.0)); + assert_eq!(trans.transition_type(), ""); +} + +#[test] +fn video_clip_media_reference() { + let tl = golden_timeline(); + let clip = &tl.tracks().children()[0].as_track().unwrap().children()[0]; + let clip = clip.as_clip().unwrap(); + + let reference = clip.media_reference().expect("clip resolves a media reference"); + assert_eq!(reference.schema_name(), "ExternalReference"); + let external: &ExternalReference = match reference { + MediaReference::ExternalReference(e) => e, + other => panic!("expected ExternalReference, got {}", other.schema_name()), + }; + assert_eq!(external.target_url(), "file:///tmp/My Sequence.mp4"); + let available = external.available_range().expect("available_range is set"); + assert_eq!((available.duration().value(), available.duration().rate()), (100.0, 25.0)); + assert_eq!((available.start_time().value(), available.start_time().rate()), (0.0, 25.0)); +} + +#[test] +fn audio_track_contents() { + let tl = golden_timeline(); + let audio = &tl.tracks().children()[1]; + let track = audio + .as_track() + .expect("second child of tracks stack is a Track"); + assert_eq!(track.kind(), "Audio"); + assert_eq!(track.children().len(), 2); + + let clip: &Clip = track.children()[0] + .as_clip() + .expect("audio track child 0 is a Clip"); + assert_eq!(clip.name(), "My Sequence Audio"); + let external: &ExternalReference = match clip.media_reference().unwrap() { + MediaReference::ExternalReference(e) => e, + other => panic!("expected ExternalReference, got {}", other.schema_name()), + }; + assert_eq!(external.target_url(), "file:///tmp/My Sequence.wav"); + let available = external.available_range().unwrap(); + assert_eq!((available.duration().value(), available.duration().rate()), (0.0, 48000.0)); + assert_eq!((available.start_time().value(), available.start_time().rate()), (0.0, 48000.0)); + + let gap = track.children()[1] + .as_gap() + .expect("audio track child 1 is a Gap"); + assert_eq!(gap.name(), ""); + let grange = gap.source_range().unwrap(); + assert_eq!((grange.duration().value(), grange.duration().rate()), (12.0, 1.0)); + assert_eq!((grange.start_time().value(), grange.start_time().rate()), (1152.0, 24.0)); +} diff --git a/src/codec/c_api/CMakeLists.txt b/src/codec/c_api/CMakeLists.txt index 8a8e0e272..afab16ccc 100644 --- a/src/codec/c_api/CMakeLists.txt +++ b/src/codec/c_api/CMakeLists.txt @@ -2,6 +2,7 @@ target_sources(oakcodec PRIVATE conform.cpp decoder.cpp encoder.cpp + format.cpp frame.cpp proxy.cpp ) diff --git a/src/codec/c_api/format.cpp b/src/codec/c_api/format.cpp new file mode 100644 index 000000000..655d88662 --- /dev/null +++ b/src/codec/c_api/format.cpp @@ -0,0 +1,279 @@ +/*** + + Oak Video Editor - Non-Linear Video Editor + Copyright (C) 2026 Oak Team + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . + +***/ + +#include "codec/format.h" + +#include +#include +#include +#include + +#include "encoder.h" +#include "ffmpeg/ffmpegencoder.h" + +namespace +{ + +bool valid_format(int format) +{ + return format >= 0 && format < olive::ExportFormat::k_format_count; +} + +bool valid_codec(int codec) +{ + return codec >= 0 && codec < olive::ExportCodec::k_codec_count; +} + +// buf/size convention: returns the would-be length INCLUDING the NUL +// (include/codec/error.h), unlike the facade which excludes it. +int string_out(const std::string &s, char *buf, int buf_size) +{ + int need = static_cast(s.size()) + 1; + if (buf && buf_size > 0) { + int n = std::min(static_cast(s.size()), buf_size - 1); + memcpy(buf, s.data(), n); + buf[n] = '\0'; + } + return need; +} + +} // namespace + +/* ---- Container format / codec metadata ---------------------------------- */ + +int oakcodec_encoding_format_count(void) +{ + return olive::ExportFormat::k_format_count; +} + +int oakcodec_encoding_format_name(int format, char *buf, int buf_size) +{ + if (!valid_format(format)) { + return OAKCODEC_E_INVALID; + } + return string_out( + olive::ExportFormat::get_name(olive::ExportFormat::Format(format)), buf, + buf_size); +} + +int oakcodec_encoding_format_extension(int format, char *buf, int buf_size) +{ + if (!valid_format(format)) { + return OAKCODEC_E_INVALID; + } + return string_out( + olive::ExportFormat::get_extension(olive::ExportFormat::Format(format)), + buf, buf_size); +} + +int oakcodec_encoding_format_video_codec_count(int format) +{ + if (!valid_format(format)) { + return OAKCODEC_E_INVALID; + } + return int(olive::ExportFormat::get_video_codecs( + olive::ExportFormat::Format(format)) + .size()); +} + +int oakcodec_encoding_format_video_codec_at(int format, int index) +{ + if (!valid_format(format)) { + return OAKCODEC_E_INVALID; + } + const auto l = + olive::ExportFormat::get_video_codecs(olive::ExportFormat::Format(format)); + if (index < 0 || index >= int(l.size())) { + return OAKCODEC_E_NOT_FOUND; + } + return int(l[size_t(index)]); +} + +int oakcodec_encoding_format_audio_codec_count(int format) +{ + if (!valid_format(format)) { + return OAKCODEC_E_INVALID; + } + return int(olive::ExportFormat::get_audio_codecs( + olive::ExportFormat::Format(format)) + .size()); +} + +int oakcodec_encoding_format_audio_codec_at(int format, int index) +{ + if (!valid_format(format)) { + return OAKCODEC_E_INVALID; + } + const auto l = + olive::ExportFormat::get_audio_codecs(olive::ExportFormat::Format(format)); + if (index < 0 || index >= int(l.size())) { + return OAKCODEC_E_NOT_FOUND; + } + return int(l[size_t(index)]); +} + +int oakcodec_encoding_format_subtitle_codec_count(int format) +{ + if (!valid_format(format)) { + return OAKCODEC_E_INVALID; + } + return int(olive::ExportFormat::get_subtitle_codecs( + olive::ExportFormat::Format(format)) + .size()); +} + +int oakcodec_encoding_format_subtitle_codec_at(int format, int index) +{ + if (!valid_format(format)) { + return OAKCODEC_E_INVALID; + } + const auto l = olive::ExportFormat::get_subtitle_codecs( + olive::ExportFormat::Format(format)); + if (index < 0 || index >= int(l.size())) { + return OAKCODEC_E_NOT_FOUND; + } + return int(l[size_t(index)]); +} + +int oakcodec_encoding_codec_name(int codec, char *buf, int buf_size) +{ + if (!valid_codec(codec)) { + return OAKCODEC_E_INVALID; + } + return string_out( + olive::ExportCodec::get_codec_name(olive::ExportCodec::Codec(codec)), buf, + buf_size); +} + +int oakcodec_encoding_codec_is_still_image(int codec) +{ + if (!valid_codec(codec)) { + return 0; + } + return olive::ExportCodec::is_codec_a_still_image( + olive::ExportCodec::Codec(codec)) ? + 1 : + 0; +} + +int oakcodec_encoding_codec_is_lossless(int codec) +{ + if (!valid_codec(codec)) { + return 0; + } + return olive::ExportCodec::is_codec_lossless(olive::ExportCodec::Codec(codec)) ? + 1 : + 0; +} + +int oakcodec_encoding_pix_fmt_count(int format, int codec) +{ + if (!valid_format(format) || !valid_codec(codec)) { + return OAKCODEC_E_INVALID; + } + return int(olive::ExportFormat::get_pixel_formats_for_codec( + olive::ExportFormat::Format(format), + olive::ExportCodec::Codec(codec)) + .size()); +} + +int oakcodec_encoding_pix_fmt_at(int format, int codec, int index, char *buf, + int buf_size) +{ + if (!valid_format(format) || !valid_codec(codec)) { + return OAKCODEC_E_INVALID; + } + const auto l = olive::ExportFormat::get_pixel_formats_for_codec( + olive::ExportFormat::Format(format), olive::ExportCodec::Codec(codec)); + if (index < 0 || index >= int(l.size())) { + return OAKCODEC_E_NOT_FOUND; + } + return string_out(l[size_t(index)], buf, buf_size); +} + +int oakcodec_encoding_pix_fmt_index(int codec, const char *pix_fmt) +{ + if (!valid_codec(codec) || !pix_fmt || !pix_fmt[0]) { + return 0; + } + // Mirrors the facade: query the FFmpeg encoder's list directly (the + // pixel-format list depends on the codec alone, not the container). + olive::FFmpegEncoder probe{ olive::EncodingParams() }; + const auto l = + probe.get_pixel_formats_for_codec(olive::ExportCodec::Codec(codec)); + const std::string needle(pix_fmt); + const auto it = std::find(l.begin(), l.end(), needle); + return it != l.end() ? int(it - l.begin()) : 0; +} + +int oakcodec_encoding_sample_format_count(int format, int codec) +{ + if (!valid_format(format) || !valid_codec(codec)) { + return OAKCODEC_E_INVALID; + } + return int(olive::ExportFormat::get_sample_formats_for_codec( + olive::ExportFormat::Format(format), + olive::ExportCodec::Codec(codec)) + .size()); +} + +int oakcodec_encoding_sample_format_at(int format, int codec, int index) +{ + if (!valid_format(format) || !valid_codec(codec)) { + return OAKCODEC_E_INVALID; + } + const auto l = olive::ExportFormat::get_sample_formats_for_codec( + olive::ExportFormat::Format(format), olive::ExportCodec::Codec(codec)); + if (index < 0 || index >= int(l.size())) { + return OAKCODEC_E_NOT_FOUND; + } + return int(l[size_t(index)]); +} + +/* ---- Image-sequence filename helpers ------------------------------------ */ + +int oakcodec_encoding_filename_contains_digit_placeholder(const char *filename) +{ + if (!filename) { + return 0; + } + return olive::Encoder::filename_contains_digit_placeholder(filename) ? 1 : + 0; +} + +int oakcodec_encoding_image_sequence_digit_count(const char *filename) +{ + if (!filename) { + return 0; + } + return olive::Encoder::get_image_sequence_placeholder_digit_count(filename); +} + +int oakcodec_encoding_filename_remove_digit_placeholder(const char *filename, + char *buf, + int buf_size) +{ + if (!filename) { + return OAKCODEC_E_INVALID; + } + return string_out( + olive::Encoder::filename_remove_digit_placeholder(filename), buf, + buf_size); +} diff --git a/src/codec/rust/Cargo.lock b/src/codec/rust/Cargo.lock new file mode 100644 index 000000000..835a210f2 --- /dev/null +++ b/src/codec/rust/Cargo.lock @@ -0,0 +1,290 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "aho-corasick" +version = "1.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c982642fa9e8606056828ee9a8505737230110bb1099153c79efe865c59d12ba" +dependencies = [ + "memchr", +] + +[[package]] +name = "bindgen" +version = "0.72.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "993776b509cfb49c750f11b8f07a46fa23e0a1386ffc01fb1e7d343efc387895" +dependencies = [ + "bitflags", + "cexpr", + "clang-sys", + "itertools", + "proc-macro2", + "quote", + "regex", + "rustc-hash", + "shlex 1.3.0", + "syn", +] + +[[package]] +name = "bitflags" +version = "2.13.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b588b76d00fde79687d7646a9b5bdf3cc0f655e0bbd080335a95d7e96f3587da" + +[[package]] +name = "cc" +version = "1.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5d262e149917187838d5b42777c8253bcb64500067342904e7d429499a6f277e" +dependencies = [ + "find-msvc-tools", + "shlex 2.0.1", +] + +[[package]] +name = "cexpr" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6fac387a98bb7c37292057cffc56d62ecb629900026402633ae9160df93a8766" +dependencies = [ + "nom", +] + +[[package]] +name = "cfg-if" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801" + +[[package]] +name = "clang-sys" +version = "1.9.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "157a8ba7b480713b56f4c09fd13fc3e0a22a5dfab8097ba61cbc5feef950788a" +dependencies = [ + "glob", + "libc", + "libloading", +] + +[[package]] +name = "either" +version = "1.17.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9e5e8f6c15a24b9a3ee5efec809ccd006d3b30e8b3bb63c39af737c7f87daa1d" + +[[package]] +name = "ffmpeg-next" +version = "9.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6380599799e175191eb7ffe82c97f36a2a90a36cbc54c738a903e5287d7f516a" +dependencies = [ + "bitflags", + "ffmpeg-sys-next", + "libc", +] + +[[package]] +name = "ffmpeg-sys-next" +version = "9.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9b939bf79dd5949412a4b81cfe21a07f48ea21b47fcbb5f57816c8c2de5ae30b" +dependencies = [ + "bindgen", + "cc", + "libc", + "num_cpus", + "pkg-config", + "vcpkg", +] + +[[package]] +name = "find-msvc-tools" +version = "0.1.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "26b73573e6edcd2af0cdf47bd6cb58f0b3839491263c314eaad1ccf24430e1de" + +[[package]] +name = "glob" +version = "0.3.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e4eba85ea1d0a966a983acd07deee566e67395d2d96b6fb39e62b5a833f1eb0b" + +[[package]] +name = "hermit-abi" +version = "0.5.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fc0fef456e4baa96da950455cd02c081ca953b141298e41db3fc7e36b1da849c" + +[[package]] +name = "itertools" +version = "0.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "413ee7dfc52ee1a4949ceeb7dbc8a33f2d6c088194d9f922fb8318faf1f01186" +dependencies = [ + "either", +] + +[[package]] +name = "libc" +version = "0.2.189" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3eaf3ede3fee6db1a4c2ee091bf8a8b4dccdc6d17f656fb07896ee72867612f2" + +[[package]] +name = "libloading" +version = "0.8.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d7c4b02199fee7c5d21a5ae7d8cfa79a6ef5bb2fc834d6e9058e89c825efdc55" +dependencies = [ + "cfg-if", + "windows-link", +] + +[[package]] +name = "memchr" +version = "2.8.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98" + +[[package]] +name = "minimal-lexical" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a" + +[[package]] +name = "nom" +version = "7.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d273983c5a657a70a3e8f2a01329822f3b8c8172b73826411a55751e404a0a4a" +dependencies = [ + "memchr", + "minimal-lexical", +] + +[[package]] +name = "num_cpus" +version = "1.17.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "91df4bbde75afed763b708b7eee1e8e7651e02d97f6d5dd763e89367e957b23b" +dependencies = [ + "hermit-abi", + "libc", +] + +[[package]] +name = "oakcodec" +version = "0.1.0" +dependencies = [ + "ffmpeg-next", + "oakcore-rs", +] + +[[package]] +name = "oakcore-rs" +version = "0.1.0" + +[[package]] +name = "pkg-config" +version = "0.3.33" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "19f132c84eca552bf34cab8ec81f1c1dcc229b811638f9d283dceabe58c5569e" + +[[package]] +name = "proc-macro2" +version = "1.0.107" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "985e7ec9bb745e6ce6535b544d84d6cd6f7ad8bd711c398938ae983b91a766d9" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "quote" +version = "1.0.47" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "regex" +version = "1.13.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f020237b6c8eed93db2e2cb53c00c60a8e1bc73da7d073199a1180401450218d" +dependencies = [ + "aho-corasick", + "memchr", + "regex-automata", + "regex-syntax", +] + +[[package]] +name = "regex-automata" +version = "0.4.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ad8553b9b26413251cbf30e620595c7a41b3887f03da04579c0e6b0d6a06b4b2" +dependencies = [ + "aho-corasick", + "memchr", + "regex-syntax", +] + +[[package]] +name = "regex-syntax" +version = "0.8.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d6f6ff9a378485b298a5286656da665ba74413d36db0979633275d2e708145d4" + +[[package]] +name = "rustc-hash" +version = "2.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6b1e7f9a428571be2dc5bc0505c13fb6bf936822b894ec87abf8a08a4e51742d" + +[[package]] +name = "shlex" +version = "1.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64" + +[[package]] +name = "shlex" +version = "2.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba" + +[[package]] +name = "syn" +version = "2.0.119" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "872831b642d1a07999a962a351ed35b955ea2cfc8f3862091e2a240a84f17297" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "unicode-ident" +version = "1.0.24" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75" + +[[package]] +name = "vcpkg" +version = "0.2.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426" + +[[package]] +name = "windows-link" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5" diff --git a/src/codec/rust/Cargo.toml b/src/codec/rust/Cargo.toml new file mode 100644 index 000000000..e098846f9 --- /dev/null +++ b/src/codec/rust/Cargo.toml @@ -0,0 +1,19 @@ +[package] +name = "oakcodec" +version = "0.1.0" +edition = "2021" +description = "Oak Video Editor media codec module (Rust)" +license = "GPL-3.0-or-later" + +[lib] +crate-type = ["staticlib", "rlib"] + +[profile.release] +# FFI discipline: panics must be catchable at every exported entry. +panic = "unwind" + +[dependencies] +oakcore-rs = { path = "../../oakcore-rs" } +# Real media decode/encode. The C++ ffmpeg_bridge library existed only to +# absorb FFmpeg API churn; the Rust crate calls ffmpeg-next directly. +ffmpeg-next = "9" diff --git a/src/codec/rust/README.md b/src/codec/rust/README.md new file mode 100644 index 000000000..305d11d3d --- /dev/null +++ b/src/codec/rust/README.md @@ -0,0 +1,123 @@ +# oakcodec Rust crate + +> Status: **implemented**. Implements `include/codec/*.h` verbatim +> (`src/ffi/`); every export has success + failure-path tests +> (`cargo test`: unit tests in `src/ffi/*.rs`, the contract tests in +> `tests/`, and real-media tests in `src/realmedia_tests.rs`). The FFmpeg +> engine is fully implemented through the [`ffmpeg-next`] crate (decode, +> probe, audio conform, encode); the OIIO engine remains a stub in this +> build. This crate mirrors the `src/node/rust/` template (same FFI +> discipline, same testing layers). + +## Scope + +Replaces the C++ oakcodec module (`src/codec/src`, ~10k lines): CPU +frame buffers (`Frame`), the frame pool (`FrameManager`), media +decoders/encoders with their FFmpeg and OIIO implementations, audio +conform and proxy generation managers, export format/codec tables, +encoding parameters, and the background-task submit hook. + +Public contract: `include/codec/*.h` (7 headers: frame.h, decoder.h, +encoder.h, conform.h, proxy.h, task.h, error.h) — frozen, implemented +verbatim by `src/ffi.rs`. Interim state (pre-M8) is documented in +`src/codec/NOTES.md`: conform/proxy work is delegated to the global +task submit callback and otherwise reports unavailable, never crashes +and never blocks. + +## Key architectural decisions (C++ → Rust mapping) + +1. **`shared_ptr` → refcounted `RefBox` handle.** The C++ `Frame`/ + `Decoder`/`Encoder` objects are heap boxes behind the neutral + by-value handle struct `{ctx, addref, release, abi_version}` (see + `handle.rs`), exactly as oaknode/oakplugin do. Handles are + deliberately duplicated per module: the function pointers always + point into the DLL that created the object. +2. **Inheritance → traits.** The C++ `Decoder`/`Encoder` abstract + bases plus their FFmpeg/OIIO subclasses become a Rust trait with + two implementors. The probe/dispatch (decide which implementation + recognizes a file) stays in `decoder.rs`. `Encoder`'s per-codec + `PixelFormat`/`SampleFormat` support is a trait query, not a + virtual chain. +3. **`Frame` owns its params by value.** `olive::Frame` wraps an + `OakVideoParams` handle (an oakcommon by-value handle, NOT owned by + codec) plus a `Vec` pixel buffer. In Rust the params are held as + the oakcommon handle (refcounted through `bridge::common`) so the + byte-level ABI stays unchanged; the buffer is a plain `Vec`. +4. **No adapter layer.** Codec calls other modules' C ABIs directly + (`bridge/common.rs`, `bridge/render.rs`), keeping the 2026-08 + decision recorded in NOTES.md §6. Only genuinely repeated + conversions survive as small module-local helpers (e.g. + `fill_render_params`, `cancel_atom_is_cancelled`). +5. **XML stays on the C++ side.** `EncodingParams::load/save` use + oakcommon's C++ `XmlStreamWriter/Reader` classes + (`src/common/src/xmlutils.h`), exactly as oaknode/oakrender do — + the one C++-to-C++ coupling the bridge cannot cover (NOTES.md §7). +6. **Threading.** `FrameManager` keeps its background GC thread behind + a `Mutex`; the C++ code's reliance on Qt's event thread is gone. The + threading contract is documented per function. +7. **Enum values are the C contract.** `ExportFormat::Format`, + `ExportCodec::Codec`, `Interlacing`, `VideoScalingMethod`, + `SampleFormat::Format` all stay as the raw int values the C ABI + documents (oakengine/encoding.h), so `ffi.rs` marshals them without + translation. + +## Layout + +``` +src/ + lib.rs crate doc + module map + error.rs error codes (mirrors include/codec/error.h) + handle.rs refcounted-handle scaffolding (same pattern as node) + frame.rs Frame (CPU pixel buffer + OakVideoParams handle) + framemanager.rs FrameManager (buffer pool + background GC thread) + decoder.rs Decoder trait + CodecStream + RenderMode + probe + ffmpeg.rs FFmpegDecoder / FFmpegEncoder (ffmpeg-next) + oiio.rs OIIODecoder / OIIOEncoder (OpenImageIO) + oiioframebridge.rs oiioutils frame<->buffer conversion + encoder.rs Encoder trait (abstract base) + encodingparams.rs EncodingParams (flattened ABI POD + generate_matrix) + exportcodec.rs ExportCodec enum + codec-name table + exportformat.rs ExportFormat enum + extension/format table + conformmanager.rs ConformManager (stateless, task-callback driven) + proxymanager.rs ProxyManager (stateless, task-callback driven) + task.rs OakCodecTaskKind / OakCodecTaskRequest / submit hook + timecodemetadata.rs TimecodeMetadata (SMPTE/BWF parsers) + footagedescription.rs FootageDescription (codec-internal stream desc) + planarfiledevice.rs PlanarFileDevice (stdio plane-channel I/O) + realmedia_tests.rs real-media tests (demo.mp4, H.264 round-trip) + bridge/ C ABI imports: common.rs, render.rs + ffi.rs include/codec/*.h export layer +tests/ contract + golden tests (see test section below) +``` + +## Hard rules for the implementer + +1. Every `extern "C"` body goes through `handle::guard*`; no panic + crosses FFI. +2. The handle is the only way out of the crate; the public API never + hands out raw `&Frame`/`&Decoder` references. +3. Behavior parity with C++ is proven by the unchanged C ABI test + suite (`src/codec/tests`) plus the contract tests in `tests/`. +4. Where C++ behavior is genuinely load-bearing but ugly, port the + behavior, not the aesthetics; leave a `// CPP-PARITY:` comment with + the C++ file:line. + +## Dependency policy + +Prefer mature third-party crates (MIT/Apache-2.0/BSD, GPL-compatible) +over hand-rolling; register each addition (name + reason) here. Large +existing C++ libraries (OTIO, OCIO, OIIO, FFmpeg) are NEVER rewritten +— they are consumed through their C ABI / bridge layers. + +### Dependencies + +- `oakcore-rs` (path) — oakcore value types (Rational, TimeRange, + PixelFormat/SampleFormat) mirrored as Rust enums. +- `ffmpeg-next` 9 — the FFmpeg decode/encode engine. The C++ + `ffmpeg_bridge` library (`liboakffmpeg`) existed only to absorb FFmpeg + API churn; the Rust crate calls `ffmpeg-next` directly (per the 2026-08 + decision that dropped the binding-library plan). `ffmpeg-next` builds + against the system FFmpeg via `ffmpeg-sys-next` (bindgen); the + implementation dips into `ffmpeg-sys-next` (`ffmpeg::ffi`) only for + swscale/swresample details and channel-layout construction that the safe + wrapper does not expose. diff --git a/src/codec/rust/src/bridge/common.rs b/src/codec/rust/src/bridge/common.rs new file mode 100644 index 000000000..a92b34378 --- /dev/null +++ b/src/codec/rust/src/bridge/common.rs @@ -0,0 +1,341 @@ +// Oak Video Editor - Non-Linear Video Editor +// Copyright (C) 2026 Oak Team +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +//! oakcommon / oakcore C ABI imports (videoparams, audioparams, rational, +//! subtitleparams, config, filefunctions, ffmpegutils, oiioutils, +//! colortransform). +//! +//! The by-value handle structs (`OakVideoParams`, `OakAudioParams`, +//! `OakSubtitleParams`, `OakNodeBlock`) mirror the `{ctx, addref, +//! release, abi_version}` layout from `include/common/handle.h`, so the +//! codec module can store them by value and pass them straight across +//! the FFI boundary. Function signatures match the public headers +//! verbatim; symbols resolve at link time. +//! +//! The oakcore audio parameters use a pointer-based C ABI instead of the +//! by-value handle convention: `oakcore_audioparams_*` take and return +//! `OakAudioParams *` / `OakRational *` pointers (`core/include/olive/ +//! core/oakcore/audioparams.h`, `rational.h`). Those are bridged as raw +//! pointers to the crate's handle structs; `oakcore_audioparams_time_base` +//! returns a newly allocated rational the caller must release with +//! `oakcore_rational_free`. + +use std::ffi::{c_char, c_int, c_void}; + +/// `OakVideoParams` — refcounted video-parameter handle. +#[derive(Clone, Debug, PartialEq, Eq)] +#[repr(C)] +pub struct OakVideoParams { + /// Opaque object pointer. + pub ctx: *mut c_void, + /// Atomically increments the reference count. + pub addref: Option, + /// Decrements the count, destroys at zero. + pub release: Option, + /// ABI version (see [`OAKCODEC_ABI_VERSION`]). + pub abi_version: u32, +} + +/// `OakAudioParams` — refcounted audio-parameter handle. +#[derive(Clone, Debug, PartialEq, Eq)] +#[repr(C)] +pub struct OakAudioParams { + /// Opaque object pointer. + pub ctx: *mut c_void, + /// Atomically increments the reference count. + pub addref: Option, + /// Decrements the count, destroys at zero. + pub release: Option, + /// ABI version. + pub abi_version: u32, +} + +/// `OakSubtitleParams` — refcounted subtitle-parameter handle. +#[derive(Clone, Debug, PartialEq, Eq)] +#[repr(C)] +pub struct OakSubtitleParams { + /// Opaque object pointer. + pub ctx: *mut c_void, + /// Atomically increments the reference count. + pub addref: Option, + /// Decrements the count, destroys at zero. + pub release: Option, + /// ABI version. + pub abi_version: u32, +} + +/// `OakNodeBlock` — opaque node-block handle (owned elsewhere; codec +/// only stores and forwards it). +#[derive(Clone, Debug, PartialEq, Eq)] +#[repr(C)] +pub struct OakNodeBlock { + /// Opaque object pointer. + pub ctx: *mut c_void, + /// Atomically increments the reference count. + pub addref: Option, + /// Decrements the count, destroys at zero. + pub release: Option, + /// ABI version. + pub abi_version: u32, +} + +// The handle structs are opaque refcounted handles pointing into a C +// library; the boxed objects are independently synchronized there, so +// moving a handle between threads is sound. +unsafe impl Send for OakVideoParams {} +unsafe impl Sync for OakVideoParams {} +unsafe impl Send for OakAudioParams {} +unsafe impl Sync for OakAudioParams {} +unsafe impl Send for OakSubtitleParams {} +unsafe impl Sync for OakSubtitleParams {} +unsafe impl Send for OakNodeBlock {} +unsafe impl Sync for OakNodeBlock {} + +extern "C" { + /// `oakcommon_videoparams_init`. + pub fn oakcommon_videoparams_init() -> OakVideoParams; + /// `oakcommon_videoparams_init_basic`. + pub fn oakcommon_videoparams_init_basic(width: c_int, height: c_int) -> OakVideoParams; + /// `oakcommon_videoparams_init_with_time_base`. + pub fn oakcommon_videoparams_init_with_time_base( + width: c_int, + height: c_int, + time_base_num: i64, + time_base_den: i64, + ) -> OakVideoParams; + /// `oakcommon_videoparams_free` (NULL/empty no-op). + pub fn oakcommon_videoparams_free(params: *mut OakVideoParams); + /// `oakcommon_videoparams_get_width`. + pub fn oakcommon_videoparams_get_width(params: OakVideoParams) -> c_int; + /// `oakcommon_videoparams_get_height`. + pub fn oakcommon_videoparams_get_height(params: OakVideoParams) -> c_int; + /// `oakcommon_videoparams_get_format`. + pub fn oakcommon_videoparams_get_format(params: OakVideoParams) -> c_int; + /// `oakcommon_videoparams_get_time_base` (num/den out). + pub fn oakcommon_videoparams_get_time_base( + params: OakVideoParams, + out_num: *mut i64, + out_den: *mut i64, + ) -> c_int; + /// `oakcommon_videoparams_set_width`. + pub fn oakcommon_videoparams_set_width(params: OakVideoParams, width: c_int); + /// `oakcommon_videoparams_set_height`. + pub fn oakcommon_videoparams_set_height(params: OakVideoParams, height: c_int); + /// `oakcommon_videoparams_set_format`. + pub fn oakcommon_videoparams_set_format(params: OakVideoParams, format: c_int); + /// `oakcommon_videoparams_get_is_valid`. + pub fn oakcommon_videoparams_get_is_valid(params: OakVideoParams) -> c_int; + /// `oakcommon_videoparams_equals`. + pub fn oakcommon_videoparams_equals(a: OakVideoParams, b: OakVideoParams) -> c_int; + /// `oakcommon_videoparams_set_time_base`. + pub fn oakcommon_videoparams_set_time_base( + params: OakVideoParams, + num: i64, + den: i64, + ); + /// `oakcommon_videoparams_set_frame_rate`. + pub fn oakcommon_videoparams_set_frame_rate( + params: OakVideoParams, + num: i64, + den: i64, + ); + /// `oakcommon_videoparams_set_pixel_aspect_ratio`. + pub fn oakcommon_videoparams_set_pixel_aspect_ratio( + params: OakVideoParams, + num: i64, + den: i64, + ); + /// `oakcommon_videoparams_set_interlacing`. + pub fn oakcommon_videoparams_set_interlacing(params: OakVideoParams, interlacing: c_int); + /// `oakcommon_videoparams_set_duration`. + pub fn oakcommon_videoparams_set_duration(params: OakVideoParams, duration: i64); + /// `oakcommon_videoparams_set_start_time`. + pub fn oakcommon_videoparams_set_start_time(params: OakVideoParams, start_time: i64); + /// `oakcommon_videoparams_set_color_range`. + pub fn oakcommon_videoparams_set_color_range(params: OakVideoParams, color_range: c_int); + /// `oakcommon_videoparams_set_video_type`. + pub fn oakcommon_videoparams_set_video_type(params: OakVideoParams, video_type: c_int); + /// `oakcommon_videoparams_set_channel_count`. + pub fn oakcommon_videoparams_set_channel_count(params: OakVideoParams, channels: c_int); + /// `oakcommon_videoparams_set_color_primaries`. + pub fn oakcommon_videoparams_set_color_primaries(params: OakVideoParams, primaries: c_int); + /// `oakcommon_videoparams_set_color_transfer`. + pub fn oakcommon_videoparams_set_color_transfer(params: OakVideoParams, transfer: c_int); + /// `oakcommon_videoparams_set_premultiplied_alpha`. + pub fn oakcommon_videoparams_set_premultiplied_alpha(params: OakVideoParams, premultiplied: c_int); + /// `oakcommon_videoparams_set_enabled`. + pub fn oakcommon_videoparams_set_enabled(params: OakVideoParams, enabled: c_int); + /// `oakcommon_videoparams_static_get_bytes_per_pixel`. + pub fn oakcommon_videoparams_static_get_bytes_per_pixel(format: c_int) -> c_int; + /// `oakcommon_videoparams_frame_rate_as_time_base`. + pub fn oakcommon_videoparams_frame_rate_as_time_base( + frame_rate_num: i64, + frame_rate_den: i64, + out_num: *mut i64, + out_den: *mut i64, + ); + /// `oakcommon_videoparams_get_stream_index`. + pub fn oakcommon_videoparams_get_stream_index(params: OakVideoParams) -> c_int; + /// `oakcommon_videoparams_set_stream_index`. + pub fn oakcommon_videoparams_set_stream_index(params: OakVideoParams, index: c_int); + /// `oakcommon_videoparams_get_divider`. + pub fn oakcommon_videoparams_get_divider(params: OakVideoParams) -> c_int; + /// `oakcommon_videoparams_set_divider`. + pub fn oakcommon_videoparams_set_divider(params: OakVideoParams, divider: c_int); + // NOTE: the remaining video getters below take the value-style form the + // crate's existing bridge uses (the real oakcommon headers use out-pointer + // args); `get_frame_rate` needs both values so it keeps the out pair. + /// `oakcommon_videoparams_get_frame_rate` (frame-rate num/den out). + pub fn oakcommon_videoparams_get_frame_rate( + params: OakVideoParams, + out_num: *mut c_int, + out_den: *mut c_int, + ) -> c_int; + /// `oakcommon_videoparams_get_duration` (time-base units). + pub fn oakcommon_videoparams_get_duration(params: OakVideoParams) -> i64; + /// `oakcommon_videoparams_get_channel_count`. + pub fn oakcommon_videoparams_get_channel_count(params: OakVideoParams) -> c_int; + /// `oakcommon_videoparams_get_color_primaries`. + pub fn oakcommon_videoparams_get_color_primaries(params: OakVideoParams) -> c_int; + /// `oakcommon_videoparams_get_color_transfer`. + pub fn oakcommon_videoparams_get_color_transfer(params: OakVideoParams) -> c_int; + /// `oakcommon_videoparams_get_interlacing` (`Interlacing` value). + pub fn oakcommon_videoparams_get_interlacing(params: OakVideoParams) -> c_int; + /// `oakcore_audioparams_create` (pointer-based; timebase 1/sample_rate). + pub fn oakcore_audioparams_create( + sample_rate: c_int, + channel_layout: u64, + format: c_int, + ) -> *mut OakAudioParams; + /// `oakcore_audioparams_free` (NULL no-op). + pub fn oakcore_audioparams_free(params: *mut OakAudioParams); + /// `oakcore_audioparams_sample_rate`. + pub fn oakcore_audioparams_sample_rate(params: *const OakAudioParams) -> c_int; + /// `oakcore_audioparams_set_sample_rate`. + pub fn oakcore_audioparams_set_sample_rate(params: *mut OakAudioParams, sample_rate: c_int); + /// `oakcore_audioparams_channel_layout`. + pub fn oakcore_audioparams_channel_layout(params: *const OakAudioParams) -> u64; + /// `oakcore_audioparams_set_channel_layout`. + pub fn oakcore_audioparams_set_channel_layout(params: *mut OakAudioParams, layout: u64); + /// `oakcore_audioparams_set_time_base`. + pub fn oakcore_audioparams_set_time_base( + params: *mut OakAudioParams, + num: c_int, + den: c_int, + ); + /// `oakcore_audioparams_set_format`. + pub fn oakcore_audioparams_set_format(params: *mut OakAudioParams, format: c_int); + /// `oakcore_audioparams_set_stream_index`. + pub fn oakcore_audioparams_set_stream_index(params: *mut OakAudioParams, index: c_int); + /// `oakcore_audioparams_set_duration`. + pub fn oakcore_audioparams_set_duration(params: *mut OakAudioParams, duration: i64); + /// `oakcore_audioparams_channel_count`. + pub fn oakcore_audioparams_channel_count(params: *const OakAudioParams) -> c_int; + /// `oakcore_audioparams_format`. + pub fn oakcore_audioparams_format(params: *const OakAudioParams) -> c_int; + /// `oakcore_audioparams_stream_index`. + pub fn oakcore_audioparams_stream_index(params: *const OakAudioParams) -> c_int; + /// `oakcore_audioparams_duration`. + pub fn oakcore_audioparams_duration(params: *const OakAudioParams) -> i64; + /// `oakcore_audioparams_is_valid`. + pub fn oakcore_audioparams_is_valid(params: *const OakAudioParams) -> c_int; + /// `oakcore_audioparams_time_base` (newly allocated rational; caller + /// releases with `oakcore_rational_free`). + pub fn oakcore_audioparams_time_base(params: *const OakAudioParams) -> *mut c_void; + /// `oakcore_rational_numerator`. + pub fn oakcore_rational_numerator(rational: *const c_void) -> c_int; + /// `oakcore_rational_denominator`. + pub fn oakcore_rational_denominator(rational: *const c_void) -> c_int; + /// `oakcore_rational_free` (NULL no-op). + pub fn oakcore_rational_free(rational: *mut c_void); + /// `oakcommon_subtitleparams_get_stream_index`. + pub fn oakcommon_subtitleparams_get_stream_index(params: OakSubtitleParams) -> c_int; + /// `oakcommon_subtitleparams_generate_ass_header`. + pub fn oakcommon_subtitleparams_generate_ass_header( + params: OakSubtitleParams, + width: c_int, + height: c_int, + ); + /// `oakcommon_subtitleparams_add_subtitle`. + pub fn oakcommon_subtitleparams_add_subtitle(params: OakSubtitleParams, text: *const c_char); + /// `oakcommon_config_get_int`. + pub fn oakcommon_config_get_int(group: *const c_char, key: *const c_char, default: c_int) -> c_int; + /// `oakcommon_config_get_bool`. + pub fn oakcommon_config_get_bool(group: *const c_char, key: *const c_char, default: c_int) -> c_int; + /// `oakcommon_config_get` (two-stage string access). + pub fn oakcommon_config_get( + group: *const c_char, + key: *const c_char, + buf: *mut c_char, + buf_size: c_int, + ) -> c_int; + /// `oakcommon_filefunctions_init`. + pub fn oakcommon_filefunctions_init(); + /// `oakcommon_filefunctions_get_configuration_location` (two-stage). + pub fn oakcommon_filefunctions_get_configuration_location( + buf: *mut c_char, + buf_size: c_int, + ) -> c_int; + /// `oakcommon_filefunctions_get_unique_file_identifier`. + pub fn oakcommon_filefunctions_get_unique_file_identifier(path: *const c_char) -> i64; + /// `oakcommon_filefunctions_get_application_path` (two-stage). + pub fn oakcommon_filefunctions_get_application_path( + buf: *mut c_char, + buf_size: c_int, + ) -> c_int; + /// `oakcommon_filefunctions_free` (frees an internally cached string). + pub fn oakcommon_filefunctions_free(ptr: *mut c_void); + /// `oakcommon_colortransform_init_output`. + pub fn oakcommon_colortransform_init_output( + src_colorspace: c_int, + src_trc: c_int, + dst_colorspace: c_int, + dst_trc: c_int, + premultiplied: c_int, + chroma_coeffs: *const c_void, + ) -> OakVideoParams; + /// `oakcommon_colortransform_get_output`. + pub fn oakcommon_colortransform_get_output(params: OakVideoParams, out: *mut OakVideoParams); + /// `oakcommon_colortransform_free`. + pub fn oakcommon_colortransform_free(params: *mut OakVideoParams); + /// `oakcommon_ffmpegutils_get_native_sample_format`. + pub fn oakcommon_ffmpegutils_get_native_sample_format(sample_format: c_int) -> c_int; + /// `oakcommon_ffmpegutils_get_compatible_pixel_format`. + pub fn oakcommon_ffmpegutils_get_compatible_pixel_format(format: c_int) -> c_int; + /// `oakcommon_ffmpegutils_get_ffmpeg_pixel_format`. + pub fn oakcommon_ffmpegutils_get_ffmpeg_pixel_format(format: c_int) -> c_int; + /// `oakcommon_ffmpegutils_get_ffmpeg_sample_format`. + pub fn oakcommon_ffmpegutils_get_ffmpeg_sample_format(format: c_int) -> c_int; + /// `oakcommon_ffmpegutils_get_compatible_bridge_pixel_format`. + pub fn oakcommon_ffmpegutils_get_compatible_bridge_pixel_format(format: c_int) -> c_int; + /// `oakcommon_ffmpegutils_convert_jpeg_space_to_regular_space`. + pub fn oakcommon_ffmpegutils_convert_jpeg_space_to_regular_space(format: c_int) -> c_int; + /// `oakcommon_oiioutils_init`. + pub fn oakcommon_oiioutils_init(); + /// `oakcommon_oiioutils_get_oiio_base_type_from_format`. + pub fn oakcommon_oiioutils_get_oiio_base_type_from_format(format: c_int) -> c_int; + /// `oakcommon_oiioutils_get_format_from_oiio_basetype`. + pub fn oakcommon_oiioutils_get_format_from_oiio_basetype(basetype: c_int) -> c_int; + /// `oakcommon_oiioutils_get_pixel_aspect_ratio` (num/den out). + pub fn oakcommon_oiioutils_get_pixel_aspect_ratio( + width: c_int, + height: c_int, + out_num: *mut c_int, + out_den: *mut c_int, + ) -> c_int; + /// `oakcommon_oiioutils_free`. + pub fn oakcommon_oiioutils_free(); +} diff --git a/src/codec/rust/src/bridge/mod.rs b/src/codec/rust/src/bridge/mod.rs new file mode 100644 index 000000000..009ce6407 --- /dev/null +++ b/src/codec/rust/src/bridge/mod.rs @@ -0,0 +1,32 @@ +// Oak Video Editor - Non-Linear Video Editor +// Copyright (C) 2026 Oak Team +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +//! C ABI imports from the other oak modules. +//! +//! The codec module links against oakcommon and oakrender at the C ABI. +//! Every signature below mirrors the corresponding public header +//! verbatim and is resolved at link time. The by-value handle structs +//! (`OakVideoParams`, `OakRenderTexture`, …) are `#[repr(C)]` mirrors of +//! the `{ctx, addref, release, abi_version}` layout so the codec crate +//! can hold and hand them across the FFI boundary without translation. + +pub mod common; +pub mod render; + +// In-memory mocks for the oakcommon/oakrender C ABI so the crate links +// and is testable under `cargo test` (where those dylibs are absent). +#[cfg(test)] +pub mod test_stubs; diff --git a/src/codec/rust/src/bridge/render.rs b/src/codec/rust/src/bridge/render.rs new file mode 100644 index 000000000..9352c8eac --- /dev/null +++ b/src/codec/rust/src/bridge/render.rs @@ -0,0 +1,190 @@ +// Oak Video Editor - Non-Linear Video Editor +// Copyright (C) 2026 Oak Team +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +//! oakrender C ABI imports (display textures, renderers, cancel atoms). +//! +//! The OIIO/FFmpeg decoders push frames to a `DisplayTexture` and poll a +//! `CancelAtom`; both are oakrender refcounted handles with the standard +//! `{ctx, addref, release, abi_version}` layout. `oakrender_video_params` +//! is a flattened POD the decoders construct to describe the frame. + +use std::ffi::{c_char, c_int, c_void}; + +/// `OakRenderTexture` — refcounted GPU texture handle. +#[derive(Clone, Debug, PartialEq, Eq)] +#[repr(C)] +pub struct OakRenderTexture { + /// Opaque object pointer. + pub ctx: *mut c_void, + /// Atomically increments the reference count. + pub addref: Option, + /// Decrements the count, destroys at zero. + pub release: Option, + /// ABI version. + pub abi_version: u32, +} + +/// `OakCancelAtom` — refcounted cancellation atom handle. +#[derive(Clone, Debug, PartialEq, Eq)] +#[repr(C)] +pub struct OakCancelAtom { + /// Opaque object pointer. + pub ctx: *mut c_void, + /// Atomically increments the reference count. + pub addref: Option, + /// Decrements the count, destroys at zero. + pub release: Option, + /// ABI version. + pub abi_version: u32, +} + +/// `OakRenderRenderer` — refcounted display-renderer handle. +#[derive(Clone, Debug, PartialEq, Eq)] +#[repr(C)] +pub struct OakRenderRenderer { + /// Opaque object pointer. + pub ctx: *mut c_void, + /// Atomically increments the reference count. + pub addref: Option, + /// Decrements the count, destroys at zero. + pub release: Option, + /// ABI version. + pub abi_version: u32, +} + +/// `OakCodecFrame` — refcounted CPU-frame handle shared with oakrender. +#[derive(Clone, Debug, PartialEq, Eq)] +#[repr(C)] +pub struct OakCodecFrame { + /// Opaque object pointer. + pub ctx: *mut c_void, + /// Atomically increments the reference count. + pub addref: Option, + /// Decrements the count, destroys at zero. + pub release: Option, + /// ABI version. + pub abi_version: u32, +} + +// Refcounted opaque handles; thread-safe in the C library. +unsafe impl Send for OakRenderTexture {} +unsafe impl Sync for OakRenderTexture {} +unsafe impl Send for OakCancelAtom {} +unsafe impl Sync for OakCancelAtom {} +unsafe impl Send for OakRenderRenderer {} +unsafe impl Sync for OakRenderRenderer {} +unsafe impl Send for OakCodecFrame {} +unsafe impl Sync for OakCodecFrame {} + +/// `oakrender_video_params` — flattened POD of `olive::VideoParams` +/// passed into oakrender; see `include/render/renderer.h`. +#[repr(C)] +pub struct oakrender_video_params { + /// Width in pixels. + pub width: c_int, + /// Height in pixels. + pub height: c_int, + /// Frame-duration numerator (e.g. 1001/30000 s). + pub time_base_num: c_int, + /// Frame-duration denominator. + pub time_base_den: c_int, + /// `olive::PixelFormat::Format`. + pub format: c_int, + /// Pixel-aspect numerator. + pub pixel_aspect_num: c_int, + /// Pixel-aspect denominator. + pub pixel_aspect_den: c_int, + /// `olive::VideoParams::Interlacing`. + pub interlacing: c_int, + /// `olive::VideoParams::ColorRange`. + pub color_range: c_int, + /// Preview-resolution divider (1 = full). + pub divider: c_int, + /// `olive::VideoParams::Type` (0 = video). + pub video_type: c_int, + /// 0/1 premultiplied alpha. + pub premultiplied_alpha: c_int, +} + +extern "C" { + /// `oakrender_cancelatom_init`. + pub fn oakrender_cancelatom_init() -> OakCancelAtom; + /// `oakrender_cancelatom_free` (NULL/empty no-op). + pub fn oakrender_cancelatom_free(atom: *mut OakCancelAtom); + /// `oakrender_cancelatom_is_cancelled`. + pub fn oakrender_cancelatom_is_cancelled(atom: OakCancelAtom) -> c_int; + /// `oakrender_cancelatom_heard_cancel`. + pub fn oakrender_cancelatom_heard_cancel(atom: OakCancelAtom) -> c_int; + /// `oakrender_cancelatom_cancel`. + pub fn oakrender_cancelatom_cancel(atom: OakCancelAtom); + /// `oakrender_cancelatom_get_native`. + pub fn oakrender_cancelatom_get_native(atom: OakCancelAtom) -> *mut c_void; + /// `oakrender_display_texture_create`. + pub fn oakrender_display_texture_create( + renderer: OakRenderRenderer, + params: *const oakrender_video_params, + data: *const c_void, + linesize: c_int, + ) -> OakRenderTexture; + /// `oakrender_display_texture_retain`. + pub fn oakrender_display_texture_retain(texture: OakRenderTexture) -> OakRenderTexture; + /// `oakrender_display_texture_free` (NULL/empty no-op). + pub fn oakrender_display_texture_free(texture: *mut OakRenderTexture); + /// `oakrender_display_texture_upload`. + pub fn oakrender_display_texture_upload(texture: OakRenderTexture) -> c_int; + /// `oakrender_display_texture_download`. + pub fn oakrender_display_texture_download( + texture: OakRenderTexture, + pixels: *mut c_void, + linesize: c_int, + ) -> c_int; + /// `oakrender_display_texture_get_params`. + pub fn oakrender_display_texture_get_params( + texture: OakRenderTexture, + out: *mut oakrender_video_params, + ) -> c_int; + /// `oakrender_display_texture_id`. + pub fn oakrender_display_texture_id(texture: OakRenderTexture) -> c_int; + /// `oakrender_display_texture_is_dummy`. + pub fn oakrender_display_texture_is_dummy(texture: OakRenderTexture) -> c_int; + /// `oakrender_display_texture_get_frame` (two-stage frame access). + pub fn oakrender_display_texture_get_frame( + texture: OakRenderTexture, + buf: *mut c_char, + buf_size: c_int, + ) -> c_int; + /// `oakrender_codec_frame_width`. + pub fn oakrender_codec_frame_width(frame: OakCodecFrame) -> c_int; + /// `oakrender_codec_frame_height`. + pub fn oakrender_codec_frame_height(frame: OakCodecFrame) -> c_int; + /// `oakrender_codec_frame_fb_format`. + pub fn oakrender_codec_frame_fb_format(frame: OakCodecFrame) -> c_int; + /// `oakrender_codec_frame_free` (NULL/empty no-op). + pub fn oakrender_codec_frame_free(frame: *mut OakCodecFrame); + /// `oakrender_codec_frame_allocate`. + pub fn oakrender_codec_frame_allocate(frame: OakCodecFrame) -> c_int; + /// `oakrender_codec_frame_linesize_bytes`. + pub fn oakrender_codec_frame_linesize_bytes(frame: OakCodecFrame) -> c_int; + /// `oakrender_codec_frame_is_allocated`. + pub fn oakrender_codec_frame_is_allocated(frame: OakCodecFrame) -> c_int; + /// `oakrender_display_renderer_blit_color_managed`. + pub fn oakrender_display_renderer_blit_color_managed( + renderer: OakRenderRenderer, + job: *const c_void, + dst_texture: OakRenderTexture, + params: *const oakrender_video_params, + ) -> c_int; +} diff --git a/src/codec/rust/src/bridge/test_stubs.rs b/src/codec/rust/src/bridge/test_stubs.rs new file mode 100644 index 000000000..f6c7d0d00 --- /dev/null +++ b/src/codec/rust/src/bridge/test_stubs.rs @@ -0,0 +1,999 @@ +// Oak Video Editor - Non-Linear Video Editor +// Copyright (C) 2026 Oak Team +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +//! `#[cfg(test)]` in-memory mocks for the oakcommon / oakrender C ABI. +//! +//! The real symbols live in `liboakcommon` / `liboakrender` and are only +//! linked when the crate is built against those dylibs (ctest). Under +//! `cargo test` those libraries are not linked, so `extern "C"` call +//! sites in the crate would otherwise fail to resolve. These +//! `#[no_mangle] extern "C"` definitions provide the symbols and back the +//! two stateful pieces the crate actually reads (video params and cancel +//! atoms) with real in-memory state, so `Frame`, `FootageDescription` +//! and friends are meaningfully testable. Everything else returns a +//! deterministic neutral value. +//! +//! Kept strictly under `#[cfg(test)]`; never compiled into a real build. + +#![allow(dead_code, unused_variables)] + +use std::collections::HashMap; +use std::ffi::{c_char, c_int, c_void, CStr}; +use std::sync::atomic::{AtomicU64, Ordering}; +use std::sync::{Mutex, OnceLock}; + +use crate::bridge::common::{ + OakAudioParams, OakNodeBlock, OakSubtitleParams, OakVideoParams, +}; +use crate::bridge::render::{OakCancelAtom, OakCodecFrame, OakRenderRenderer, OakRenderTexture}; +use crate::handle::OAKCODEC_ABI_VERSION; + +/// Per-`OakVideoParams` backing state. +#[derive(Debug, Clone, Default, PartialEq, Eq)] +struct MockParams { + width: i32, + height: i32, + format: i32, + time_base_num: i64, + time_base_den: i64, + stream_index: i32, + divider: i32, + frame_rate_num: i32, + frame_rate_den: i32, + duration: i64, + channel_count: i32, + color_primaries: i32, + color_trc: i32, + interlacing: i32, + pixel_aspect_num: i32, + pixel_aspect_den: i32, + start_time: i64, + color_range: i32, + video_type: i32, + premultiplied_alpha: i32, + enabled: i32, +} + +fn params_store() -> &'static Mutex> { + static S: OnceLock>> = OnceLock::new(); + S.get_or_init(|| Mutex::new(HashMap::new())) +} + +/// Build a handle whose `ctx` owns a leaked `MockParams`; the map entry +/// keeps the storage alive until `free` is called. +fn new_params_handle(p: MockParams) -> OakVideoParams { + let raw = Box::into_raw(Box::new(p.clone())); + params_store().lock().unwrap().insert(raw as usize, p); + OakVideoParams { + ctx: raw as *mut c_void, + addref: None, + release: None, + abi_version: OAKCODEC_ABI_VERSION, + } +} + +fn params_ref(ctx: *mut c_void) -> Option<&'static mut MockParams> { + let store = params_store().lock().unwrap(); + store.get(&(ctx as usize))?; + drop(store); + // SAFETY: entries are only removed by oakcommon_videoparams_free while + // the caller still holds the handle, so the box outlives this borrow. + Some(unsafe { &mut *(ctx as *mut MockParams) }) +} + +fn params_get(ctx: *mut c_void) -> MockParams { + let store = params_store().lock().unwrap(); + store + .get(&(ctx as usize)) + .cloned() + .unwrap_or_default() +} + +fn params_set(ctx: *mut c_void, f: impl FnOnce(&mut MockParams)) { + let mut store = params_store().lock().unwrap(); + if let Some(p) = store.get_mut(&(ctx as usize)) { + f(p); + } +} + +// --------------------------------------------------------------------------- +// oakcommon_videoparams_* +// --------------------------------------------------------------------------- + +#[no_mangle] +pub extern "C" fn oakcommon_videoparams_init() -> OakVideoParams { + new_params_handle(MockParams { + channel_count: 4, // internal RGBA pipeline layout + ..Default::default() + }) +} + +#[no_mangle] +pub extern "C" fn oakcommon_videoparams_init_basic(width: c_int, height: c_int) -> OakVideoParams { + new_params_handle(MockParams { + width, + height, + divider: 1, + channel_count: 4, // internal RGBA pipeline layout + ..Default::default() + }) +} + +#[no_mangle] +pub extern "C" fn oakcommon_videoparams_init_with_time_base( + width: c_int, + height: c_int, + time_base_num: i64, + time_base_den: i64, +) -> OakVideoParams { + new_params_handle(MockParams { + width, + height, + time_base_num, + time_base_den, + divider: 1, + channel_count: 4, // internal RGBA pipeline layout + ..Default::default() + }) +} + +#[no_mangle] +pub extern "C" fn oakcommon_videoparams_free(params: *mut OakVideoParams) { + if params.is_null() { + return; + } + unsafe { + let ctx = (*params).ctx; + params_store().lock().unwrap().remove(&(ctx as usize)); + if !ctx.is_null() { + drop(Box::from_raw(ctx as *mut MockParams)); + } + } +} + +#[no_mangle] +pub extern "C" fn oakcommon_videoparams_get_width(params: OakVideoParams) -> c_int { + params_get(params.ctx).width +} + +#[no_mangle] +pub extern "C" fn oakcommon_videoparams_get_height(params: OakVideoParams) -> c_int { + params_get(params.ctx).height +} + +#[no_mangle] +pub extern "C" fn oakcommon_videoparams_get_format(params: OakVideoParams) -> c_int { + params_get(params.ctx).format +} + +#[no_mangle] +pub extern "C" fn oakcommon_videoparams_get_time_base( + params: OakVideoParams, + out_num: *mut i64, + out_den: *mut i64, +) -> c_int { + let p = params_get(params.ctx); + if !out_num.is_null() { + unsafe { *out_num = p.time_base_num }; + } + if !out_den.is_null() { + unsafe { *out_den = p.time_base_den }; + } + 1 +} + +#[no_mangle] +pub extern "C" fn oakcommon_videoparams_set_width(params: OakVideoParams, width: c_int) { + params_set(params.ctx, |p| p.width = width); +} + +#[no_mangle] +pub extern "C" fn oakcommon_videoparams_set_height(params: OakVideoParams, height: c_int) { + params_set(params.ctx, |p| p.height = height); +} + +#[no_mangle] +pub extern "C" fn oakcommon_videoparams_set_format(params: OakVideoParams, format: c_int) { + params_set(params.ctx, |p| p.format = format); +} + +#[no_mangle] +pub extern "C" fn oakcommon_videoparams_get_is_valid(params: OakVideoParams) -> c_int { + let p = params_get(params.ctx); + ((p.width > 0) && (p.height > 0)) as c_int +} + +#[no_mangle] +pub extern "C" fn oakcommon_videoparams_equals(a: OakVideoParams, b: OakVideoParams) -> c_int { + (params_get(a.ctx) == params_get(b.ctx)) as c_int +} + +#[no_mangle] +pub extern "C" fn oakcommon_videoparams_static_get_bytes_per_pixel(format: c_int) -> c_int { + // U10 packs to 4 bytes; U8 to 1; U16/F16 to 2; F32 to 4. + match format { + 0 => 1, // U8 + 1 => 4, // U10 + 2 => 2, // U16 + 3 => 2, // F16 + 4 => 4, // F32 + _ => 0, + } +} + +#[no_mangle] +pub extern "C" fn oakcommon_videoparams_frame_rate_as_time_base( + frame_rate_num: i64, + frame_rate_den: i64, + out_num: *mut i64, + out_den: *mut i64, +) { + if !out_num.is_null() { + unsafe { *out_num = frame_rate_den }; + } + if !out_den.is_null() { + unsafe { *out_den = frame_rate_num }; + } +} + +#[no_mangle] +pub extern "C" fn oakcommon_videoparams_get_stream_index(params: OakVideoParams) -> c_int { + params_get(params.ctx).stream_index +} + +#[no_mangle] +pub extern "C" fn oakcommon_videoparams_set_stream_index(params: OakVideoParams, index: c_int) { + params_set(params.ctx, |p| p.stream_index = index); +} + +#[no_mangle] +pub extern "C" fn oakcommon_videoparams_get_divider(params: OakVideoParams) -> c_int { + params_get(params.ctx).divider +} + +#[no_mangle] +pub extern "C" fn oakcommon_videoparams_set_divider(params: OakVideoParams, divider: c_int) { + params_set(params.ctx, |p| p.divider = divider); +} + +#[no_mangle] +pub extern "C" fn oakcommon_videoparams_get_frame_rate( + params: OakVideoParams, + out_num: *mut c_int, + out_den: *mut c_int, +) -> c_int { + let p = params_get(params.ctx); + if !out_num.is_null() { + unsafe { *out_num = p.frame_rate_num }; + } + if !out_den.is_null() { + unsafe { *out_den = p.frame_rate_den }; + } + 1 +} + +#[no_mangle] +pub extern "C" fn oakcommon_videoparams_get_duration(params: OakVideoParams) -> i64 { + params_get(params.ctx).duration +} + +#[no_mangle] +pub extern "C" fn oakcommon_videoparams_get_channel_count(params: OakVideoParams) -> c_int { + params_get(params.ctx).channel_count +} + +#[no_mangle] +pub extern "C" fn oakcommon_videoparams_get_color_primaries(params: OakVideoParams) -> c_int { + params_get(params.ctx).color_primaries +} + +#[no_mangle] +pub extern "C" fn oakcommon_videoparams_get_color_transfer(params: OakVideoParams) -> c_int { + params_get(params.ctx).color_trc +} + +#[no_mangle] +pub extern "C" fn oakcommon_videoparams_get_interlacing(params: OakVideoParams) -> c_int { + params_get(params.ctx).interlacing +} + +#[no_mangle] +pub extern "C" fn oakcommon_videoparams_set_time_base( + params: OakVideoParams, + num: i64, + den: i64, +) { + params_set(params.ctx, |p| { + p.time_base_num = num; + p.time_base_den = den; + }); +} + +#[no_mangle] +pub extern "C" fn oakcommon_videoparams_set_frame_rate( + params: OakVideoParams, + num: i64, + den: i64, +) { + params_set(params.ctx, |p| { + p.frame_rate_num = num as i32; + p.frame_rate_den = den as i32; + }); +} + +#[no_mangle] +pub extern "C" fn oakcommon_videoparams_set_pixel_aspect_ratio( + params: OakVideoParams, + num: i64, + den: i64, +) { + params_set(params.ctx, |p| { + p.pixel_aspect_num = num as i32; + p.pixel_aspect_den = den as i32; + }); +} + +#[no_mangle] +pub extern "C" fn oakcommon_videoparams_set_interlacing(params: OakVideoParams, interlacing: c_int) { + params_set(params.ctx, |p| p.interlacing = interlacing); +} + +#[no_mangle] +pub extern "C" fn oakcommon_videoparams_set_duration(params: OakVideoParams, duration: i64) { + params_set(params.ctx, |p| p.duration = duration); +} + +#[no_mangle] +pub extern "C" fn oakcommon_videoparams_set_start_time(params: OakVideoParams, start_time: i64) { + params_set(params.ctx, |p| p.start_time = start_time); +} + +#[no_mangle] +pub extern "C" fn oakcommon_videoparams_set_color_range(params: OakVideoParams, color_range: c_int) { + params_set(params.ctx, |p| p.color_range = color_range); +} + +#[no_mangle] +pub extern "C" fn oakcommon_videoparams_set_video_type(params: OakVideoParams, video_type: c_int) { + params_set(params.ctx, |p| p.video_type = video_type); +} + +#[no_mangle] +pub extern "C" fn oakcommon_videoparams_set_channel_count(params: OakVideoParams, channels: c_int) { + params_set(params.ctx, |p| p.channel_count = channels); +} + +#[no_mangle] +pub extern "C" fn oakcommon_videoparams_set_color_primaries(params: OakVideoParams, primaries: c_int) { + params_set(params.ctx, |p| p.color_primaries = primaries); +} + +#[no_mangle] +pub extern "C" fn oakcommon_videoparams_set_color_transfer(params: OakVideoParams, transfer: c_int) { + params_set(params.ctx, |p| p.color_trc = transfer); +} + +#[no_mangle] +pub extern "C" fn oakcommon_videoparams_set_premultiplied_alpha( + params: OakVideoParams, + premultiplied: c_int, +) { + params_set(params.ctx, |p| p.premultiplied_alpha = premultiplied); +} + +#[no_mangle] +pub extern "C" fn oakcommon_videoparams_set_enabled(params: OakVideoParams, enabled: c_int) { + params_set(params.ctx, |p| p.enabled = enabled); +} + +// --------------------------------------------------------------------------- +// oakcore_audioparams_* / oakcore_rational_* (pointer-based in-memory state) +// --------------------------------------------------------------------------- + +/// Per-`OakAudioParams` backing state. The real oakcore C ABI is +/// pointer-based (`core/include/olive/core/oakcore/audioparams.h`), so +/// these stubs own a boxed struct and return its raw pointer. +#[derive(Debug, Clone, Default, PartialEq, Eq)] +struct MockAudioParams { + sample_rate: i32, + channel_layout: u64, + format: i32, + stream_index: i32, + duration: i64, + time_base_num: i32, + time_base_den: i32, +} + +fn audio_params_store() -> &'static Mutex> { + static S: OnceLock>> = OnceLock::new(); + S.get_or_init(|| Mutex::new(HashMap::new())) +} + +fn audio_params_get(ctx: *const c_void) -> MockAudioParams { + let store = audio_params_store().lock().unwrap(); + store + .get(&(ctx as usize)) + .cloned() + .unwrap_or_default() +} + +/// Per-`OakRational` backing state (an owned `(num, den)` pair). +fn rational_store() -> &'static Mutex> { + static S: OnceLock>> = OnceLock::new(); + S.get_or_init(|| Mutex::new(HashMap::new())) +} + +#[no_mangle] +pub extern "C" fn oakcore_audioparams_create( + sample_rate: c_int, + channel_layout: u64, + format: c_int, +) -> *mut OakAudioParams { + // The timebase starts at 1/sample_rate, mirroring the real header. + let p = MockAudioParams { + sample_rate, + channel_layout, + format, + stream_index: 0, + duration: 0, + time_base_num: 1, + time_base_den: sample_rate, + }; + let raw = Box::into_raw(Box::new(p.clone())); + audio_params_store().lock().unwrap().insert(raw as usize, p); + raw as *mut OakAudioParams +} + +#[no_mangle] +pub extern "C" fn oakcore_audioparams_free(params: *mut OakAudioParams) { + if params.is_null() { + return; + } + audio_params_store() + .lock() + .unwrap() + .remove(&(params as usize)); + // SAFETY: `params` was produced by `oakcore_audioparams_create` as a + // boxed `MockAudioParams`; we hold the only reference after removal. + unsafe { drop(Box::from_raw(params as *mut MockAudioParams)) }; +} + +#[no_mangle] +pub extern "C" fn oakcore_audioparams_sample_rate(params: *const OakAudioParams) -> c_int { + audio_params_get(params as *const c_void).sample_rate +} + +fn audio_params_set(ctx: *mut c_void, f: impl FnOnce(&mut MockAudioParams)) { + let mut store = audio_params_store().lock().unwrap(); + if let Some(p) = store.get_mut(&(ctx as usize)) { + f(p); + } +} + +#[no_mangle] +pub extern "C" fn oakcore_audioparams_set_sample_rate( + params: *mut OakAudioParams, + sample_rate: c_int, +) { + audio_params_set(params as *mut c_void, |p| p.sample_rate = sample_rate); +} + +#[no_mangle] +pub extern "C" fn oakcore_audioparams_channel_layout(params: *const OakAudioParams) -> u64 { + audio_params_get(params as *const c_void).channel_layout +} + +#[no_mangle] +pub extern "C" fn oakcore_audioparams_set_channel_layout( + params: *mut OakAudioParams, + layout: u64, +) { + audio_params_set(params as *mut c_void, |p| p.channel_layout = layout); +} + +#[no_mangle] +pub extern "C" fn oakcore_audioparams_set_time_base( + params: *mut OakAudioParams, + num: c_int, + den: c_int, +) { + audio_params_set(params as *mut c_void, |p| { + p.time_base_num = num; + p.time_base_den = den; + }); +} + +#[no_mangle] +pub extern "C" fn oakcore_audioparams_set_format(params: *mut OakAudioParams, format: c_int) { + audio_params_set(params as *mut c_void, |p| p.format = format); +} + +#[no_mangle] +pub extern "C" fn oakcore_audioparams_set_stream_index( + params: *mut OakAudioParams, + index: c_int, +) { + audio_params_set(params as *mut c_void, |p| p.stream_index = index); +} + +#[no_mangle] +pub extern "C" fn oakcore_audioparams_set_duration(params: *mut OakAudioParams, duration: i64) { + audio_params_set(params as *mut c_void, |p| p.duration = duration); +} + +#[no_mangle] +pub extern "C" fn oakcore_audioparams_channel_count(params: *const OakAudioParams) -> c_int { + audio_params_get(params as *const c_void) + .channel_layout + .count_ones() as c_int +} + +#[no_mangle] +pub extern "C" fn oakcore_audioparams_format(params: *const OakAudioParams) -> c_int { + audio_params_get(params as *const c_void).format +} + +#[no_mangle] +pub extern "C" fn oakcore_audioparams_stream_index(params: *const OakAudioParams) -> c_int { + audio_params_get(params as *const c_void).stream_index +} + +#[no_mangle] +pub extern "C" fn oakcore_audioparams_duration(params: *const OakAudioParams) -> i64 { + audio_params_get(params as *const c_void).duration +} + +#[no_mangle] +pub extern "C" fn oakcore_audioparams_is_valid(params: *const OakAudioParams) -> c_int { + let p = audio_params_get(params as *const c_void); + (p.sample_rate > 0 && p.channel_layout != 0 && p.format >= 0) as c_int +} + +#[no_mangle] +pub extern "C" fn oakcore_audioparams_time_base(params: *const OakAudioParams) -> *mut c_void { + let p = audio_params_get(params as *const c_void); + let r = (p.time_base_num, p.time_base_den); + let raw = Box::into_raw(Box::new(r)); + rational_store().lock().unwrap().insert(raw as usize, r); + raw as *mut c_void +} + +#[no_mangle] +pub extern "C" fn oakcore_rational_numerator(rational: *const c_void) -> c_int { + rational_store() + .lock() + .unwrap() + .get(&(rational as usize)) + .map(|r| r.0) + .unwrap_or(0) +} + +#[no_mangle] +pub extern "C" fn oakcore_rational_denominator(rational: *const c_void) -> c_int { + rational_store() + .lock() + .unwrap() + .get(&(rational as usize)) + .map(|r| r.1) + .unwrap_or(0) +} + +#[no_mangle] +pub extern "C" fn oakcore_rational_free(rational: *mut c_void) { + if rational.is_null() { + return; + } + rational_store().lock().unwrap().remove(&(rational as usize)); + // SAFETY: `rational` was produced by `oakcore_audioparams_time_base` as a + // boxed `(i32, i32)` pair; we hold the only reference after removal. + unsafe { drop(Box::from_raw(rational as *mut (i32, i32))) }; +} + +// --------------------------------------------------------------------------- +// oakcommon_subtitleparams_* +// --------------------------------------------------------------------------- + +#[no_mangle] +pub extern "C" fn oakcommon_subtitleparams_get_stream_index(_params: OakSubtitleParams) -> c_int { + 0 +} + +#[no_mangle] +pub extern "C" fn oakcommon_subtitleparams_generate_ass_header( + _params: OakSubtitleParams, + _width: c_int, + _height: c_int, +) { +} + +#[no_mangle] +pub extern "C" fn oakcommon_subtitleparams_add_subtitle( + _params: OakSubtitleParams, + _text: *const c_char, +) { +} + +// --------------------------------------------------------------------------- +// oakcommon_config_* +// --------------------------------------------------------------------------- + +#[no_mangle] +pub extern "C" fn oakcommon_config_get_int( + _group: *const c_char, + _key: *const c_char, + default: c_int, +) -> c_int { + default +} + +#[no_mangle] +pub extern "C" fn oakcommon_config_get_bool( + _group: *const c_char, + _key: *const c_char, + default: c_int, +) -> c_int { + default +} + +#[no_mangle] +pub extern "C" fn oakcommon_config_get( + _group: *const c_char, + _key: *const c_char, + buf: *mut c_char, + buf_size: c_int, +) -> c_int { + // Empty value: report the size needed (1 for NUL) and write NUL. + if buf_size <= 0 { + return 1; + } + if !buf.is_null() { + unsafe { *buf = 0 }; + } + 1 +} + +// --------------------------------------------------------------------------- +// oakcommon_filefunctions_* +// --------------------------------------------------------------------------- + +static FAKE_PATH: &[u8] = b"/mock/config/oak\0"; + +#[no_mangle] +pub extern "C" fn oakcommon_filefunctions_init() {} + +#[no_mangle] +pub extern "C" fn oakcommon_filefunctions_get_configuration_location( + buf: *mut c_char, + buf_size: c_int, +) -> c_int { + copy_cstr(FAKE_PATH, buf, buf_size) +} + +#[no_mangle] +pub extern "C" fn oakcommon_filefunctions_get_unique_file_identifier(path: *const c_char) -> i64 { + if path.is_null() { + return 0; + } + unsafe { CStr::from_ptr(path) } + .to_bytes() + .iter() + .fold(14695981039346656037u64, |acc, &b| (acc ^ b as u64).wrapping_mul(1099511628211)) + as i64 +} + +#[no_mangle] +pub extern "C" fn oakcommon_filefunctions_get_application_path( + buf: *mut c_char, + buf_size: c_int, +) -> c_int { + copy_cstr(b"/mock/app/oak\0", buf, buf_size) +} + +#[no_mangle] +pub extern "C" fn oakcommon_filefunctions_free(_ptr: *mut c_void) {} + +// --------------------------------------------------------------------------- +// oakcommon_colortransform_* +// --------------------------------------------------------------------------- + +#[no_mangle] +pub extern "C" fn oakcommon_colortransform_init_output( + _src_colorspace: c_int, + _src_trc: c_int, + _dst_colorspace: c_int, + _dst_trc: c_int, + _premultiplied: c_int, + _chroma_coeffs: *const c_void, +) -> OakVideoParams { + oakcommon_videoparams_init() +} + +#[no_mangle] +pub extern "C" fn oakcommon_colortransform_get_output(params: OakVideoParams, out: *mut OakVideoParams) { + if !out.is_null() { + unsafe { *out = params.clone() }; + } +} + +#[no_mangle] +pub extern "C" fn oakcommon_colortransform_free(params: *mut OakVideoParams) { + oakcommon_videoparams_free(params); +} + +// --------------------------------------------------------------------------- +// oakcommon_ffmpegutils_* (pure enum mapping; identity is a safe default) +// --------------------------------------------------------------------------- + +#[no_mangle] +pub extern "C" fn oakcommon_ffmpegutils_get_native_sample_format(sample_format: c_int) -> c_int { + sample_format +} + +#[no_mangle] +pub extern "C" fn oakcommon_ffmpegutils_get_compatible_pixel_format(format: c_int) -> c_int { + format +} + +#[no_mangle] +pub extern "C" fn oakcommon_ffmpegutils_get_ffmpeg_pixel_format(format: c_int) -> c_int { + format +} + +#[no_mangle] +pub extern "C" fn oakcommon_ffmpegutils_get_ffmpeg_sample_format(format: c_int) -> c_int { + format +} + +#[no_mangle] +pub extern "C" fn oakcommon_ffmpegutils_get_compatible_bridge_pixel_format(format: c_int) -> c_int { + format +} + +#[no_mangle] +pub extern "C" fn oakcommon_ffmpegutils_convert_jpeg_space_to_regular_space(format: c_int) -> c_int { + format +} + +// --------------------------------------------------------------------------- +// oakcommon_oiioutils_* +// --------------------------------------------------------------------------- + +#[no_mangle] +pub extern "C" fn oakcommon_oiioutils_init() {} + +#[no_mangle] +pub extern "C" fn oakcommon_oiioutils_get_oiio_base_type_from_format(format: c_int) -> c_int { + format +} + +#[no_mangle] +pub extern "C" fn oakcommon_oiioutils_get_format_from_oiio_basetype(basetype: c_int) -> c_int { + basetype +} + +#[no_mangle] +pub extern "C" fn oakcommon_oiioutils_get_pixel_aspect_ratio( + _width: c_int, + _height: c_int, + out_num: *mut c_int, + out_den: *mut c_int, +) -> c_int { + if !out_num.is_null() { + unsafe { *out_num = 1 }; + } + if !out_den.is_null() { + unsafe { *out_den = 1 }; + } + 1 +} + +#[no_mangle] +pub extern "C" fn oakcommon_oiioutils_free() {} + +// --------------------------------------------------------------------------- +// oakrender_cancelatom_* (real in-memory cancel state) +// --------------------------------------------------------------------------- + +static CANCEL_FLAGS: OnceLock>> = OnceLock::new(); + +fn cancel_flags() -> &'static Mutex> { + CANCEL_FLAGS.get_or_init(|| Mutex::new(HashMap::new())) +} + +#[no_mangle] +pub extern "C" fn oakrender_cancelatom_init() -> OakCancelAtom { + static COUNTER: AtomicU64 = AtomicU64::new(1); + let id = COUNTER.fetch_add(1, Ordering::SeqCst) as usize; + cancel_flags().lock().unwrap().insert(id, false); + OakCancelAtom { + ctx: id as *mut c_void, + addref: None, + release: None, + abi_version: OAKCODEC_ABI_VERSION, + } +} + +#[no_mangle] +pub extern "C" fn oakrender_cancelatom_free(atom: *mut OakCancelAtom) { + if atom.is_null() { + return; + } + unsafe { cancel_flags().lock().unwrap().remove(&((*atom).ctx as usize)) }; +} + +#[no_mangle] +pub extern "C" fn oakrender_cancelatom_is_cancelled(atom: OakCancelAtom) -> c_int { + (*cancel_flags().lock().unwrap().get(&(atom.ctx as usize)).unwrap_or(&false)) as c_int +} + +#[no_mangle] +pub extern "C" fn oakrender_cancelatom_heard_cancel(atom: OakCancelAtom) -> c_int { + oakrender_cancelatom_is_cancelled(atom) +} + +#[no_mangle] +pub extern "C" fn oakrender_cancelatom_cancel(atom: OakCancelAtom) { + if let Some(f) = cancel_flags().lock().unwrap().get_mut(&(atom.ctx as usize)) { + *f = true; + } +} + +#[no_mangle] +pub extern "C" fn oakrender_cancelatom_get_native(atom: OakCancelAtom) -> *mut c_void { + atom.ctx +} + +// --------------------------------------------------------------------------- +// oakrender_display_texture_* / codec_frame_* (neutral) +// --------------------------------------------------------------------------- + +#[no_mangle] +pub extern "C" fn oakrender_display_texture_create( + _renderer: OakRenderRenderer, + _params: *const crate::bridge::render::oakrender_video_params, + _data: *const c_void, + _linesize: c_int, +) -> OakRenderTexture { + OakRenderTexture { + ctx: std::ptr::null_mut(), + addref: None, + release: None, + abi_version: OAKCODEC_ABI_VERSION, + } +} + +#[no_mangle] +pub extern "C" fn oakrender_display_texture_retain(texture: OakRenderTexture) -> OakRenderTexture { + texture +} + +#[no_mangle] +pub extern "C" fn oakrender_display_texture_free(_texture: *mut OakRenderTexture) {} + +#[no_mangle] +pub extern "C" fn oakrender_display_texture_upload(_texture: OakRenderTexture) -> c_int { + 0 +} + +#[no_mangle] +pub extern "C" fn oakrender_display_texture_download( + _texture: OakRenderTexture, + _pixels: *mut c_void, + _linesize: c_int, +) -> c_int { + 0 +} + +#[no_mangle] +pub extern "C" fn oakrender_display_texture_get_params( + _texture: OakRenderTexture, + _out: *mut crate::bridge::render::oakrender_video_params, +) -> c_int { + 0 +} + +#[no_mangle] +pub extern "C" fn oakrender_display_texture_id(_texture: OakRenderTexture) -> c_int { + 0 +} + +#[no_mangle] +pub extern "C" fn oakrender_display_texture_is_dummy(_texture: OakRenderTexture) -> c_int { + 1 +} + +#[no_mangle] +pub extern "C" fn oakrender_display_texture_get_frame( + _texture: OakRenderTexture, + buf: *mut c_char, + buf_size: c_int, +) -> c_int { + if buf_size <= 0 { + return 1; + } + if !buf.is_null() { + unsafe { *buf = 0 }; + } + 1 +} + +#[no_mangle] +pub extern "C" fn oakrender_codec_frame_width(_frame: OakCodecFrame) -> c_int { + 0 +} + +#[no_mangle] +pub extern "C" fn oakrender_codec_frame_height(_frame: OakCodecFrame) -> c_int { + 0 +} + +#[no_mangle] +pub extern "C" fn oakrender_codec_frame_fb_format(_frame: OakCodecFrame) -> c_int { + 0 +} + +#[no_mangle] +pub extern "C" fn oakrender_codec_frame_free(_frame: *mut OakCodecFrame) {} + +#[no_mangle] +pub extern "C" fn oakrender_codec_frame_allocate(_frame: OakCodecFrame) -> c_int { + 1 +} + +#[no_mangle] +pub extern "C" fn oakrender_codec_frame_linesize_bytes(_frame: OakCodecFrame) -> c_int { + 0 +} + +#[no_mangle] +pub extern "C" fn oakrender_codec_frame_is_allocated(_frame: OakCodecFrame) -> c_int { + 1 +} + +#[no_mangle] +pub extern "C" fn oakrender_display_renderer_blit_color_managed( + _renderer: OakRenderRenderer, + _job: *const c_void, + _dst_texture: OakRenderTexture, + _params: *const crate::bridge::render::oakrender_video_params, +) -> c_int { + 0 +} + +// --------------------------------------------------------------------------- +// Helpers +// --------------------------------------------------------------------------- + +/// Two-stage string copy helper used by the mock getters. Returns the +/// total size needed (including the trailing NUL), or truncates the buffer +/// and writes a NUL terminator when the buffer is too small. +fn copy_cstr(src: &[u8], buf: *mut c_char, buf_size: c_int) -> c_int { + let needed = src.len() as c_int; + if buf.is_null() || buf_size < needed { + return needed; + } + unsafe { + for (i, &b) in src.iter().enumerate() { + *buf.add(i) = b as c_char; + } + } + needed +} + +// Silence unused-import warnings when the by-value handle types are not +// referenced by every build; they are part of the mock's public surface. +#[allow(unused)] +fn _keep(_: OakAudioParams, _: OakNodeBlock) {} diff --git a/src/codec/rust/src/conformmanager.rs b/src/codec/rust/src/conformmanager.rs new file mode 100644 index 000000000..50a6cd3b4 --- /dev/null +++ b/src/codec/rust/src/conformmanager.rs @@ -0,0 +1,341 @@ +// Oak Video Editor - Non-Linear Video Editor +// Copyright (C) 2026 Oak Team +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +//! `olive::ConformManager` — pcm waveform cache files for fast scrubbing. +//! +//! Mirrors `src/codec/src/conformmanager.h`. Stateless (NOTES.md): actual +//! conform work is delegated to the global task submit callback +//! ([`crate::task`]); with no registrar the state queries report +//! `Unavailable`. Deterministic per-channel filenames derive from the +//! source + target audio params. + +use std::ffi::CString; +use std::path::Path; + +/// Conform state of one audio stream. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +#[repr(i32)] +pub enum ConformState { + /// Conform files exist. + Exists = 0, + /// Conform is being generated. + Generating = 1, + /// No task registrar; conform unavailable. + Unavailable = 2, +} + +/// `olive::ConformManager` — stateless conform query/produce manager. +pub struct ConformManager; + +impl ConformManager { + /// The process-wide ConformManager singleton. + pub fn instance() -> &'static ConformManager { + static INSTANCE: ConformManager = ConformManager; + &INSTANCE + } + + /// Query (and when possible start) the conform of one audio stream. + /// + /// `wait != 0` treats a post-submit miss as `Unavailable`; `wait == 0` + /// reports it as `Generating`. Without a task registrar the result is + /// always `Unavailable`. + pub fn get_conform_state( + &self, + cache_path: &str, + source_filename: &str, + stream_index: i32, + sample_rate: i32, + channel_layout: u64, + sample_format: i32, + wait: bool, + ) -> crate::error::Result { + let filenames = conform_filenames( + cache_path, + source_filename, + stream_index, + sample_rate, + sample_format, + channel_layout, + ); + + // Return existing conform if it exists. + if all_conforms_exist(&filenames) { + return Ok(ConformState::Exists); + } + + // Interim state (pre-M8): no task system, conform cannot be generated. + if !crate::task::task_submit_is_registered() { + return Ok(ConformState::Unavailable); + } + + // The task owns the ".working" temporary names and the rename to the + // final per-channel filenames on success; output_filename carries the + // first channel's final path and the task derives the siblings. + let req = crate::task::TaskRequest { + kind: crate::task::TaskKind::Conform, + input_filename: source_filename, + output_filename: filenames.first().map(String::as_str).unwrap_or(""), + stream_index, + sample_rate, + channel_layout, + sample_format, + proxy_width: 0, + proxy_height: 0, + }; + + // Interim simplification: submission is synchronous — we always wait + // for the submit to return, regardless of `wait`. + if crate::task::submit_task(&req).is_err() { + return Ok(ConformState::Unavailable); + } + + if all_conforms_exist(&filenames) { + return Ok(ConformState::Exists); + } + + if wait { + // Synchronous wait already happened and the conform still does not + // exist: report the wait as failed. + return Ok(ConformState::Unavailable); + } + + Ok(ConformState::Generating) + } + + /// Number of conform (pcm) files for the given stream/params — one per + /// channel; 0 on invalid arguments. + pub fn get_conform_filename_count( + &self, + _cache_path: &str, + _source_filename: &str, + _stream_index: i32, + _sample_rate: i32, + channel_layout: u64, + _sample_format: i32, + ) -> usize { + channel_layout.count_ones() as usize + } + + /// The `index`-th conform filename. + pub fn get_conform_filename( + &self, + cache_path: &str, + source_filename: &str, + stream_index: i32, + sample_rate: i32, + channel_layout: u64, + sample_format: i32, + index: usize, + ) -> crate::error::Result { + let filenames = conform_filenames( + cache_path, + source_filename, + stream_index, + sample_rate, + sample_format, + channel_layout, + ); + filenames + .get(index) + .cloned() + .ok_or(crate::error::Error::NotFound) + } +} + +/// Deterministic conform base name plus per-channel pcm filenames, mirroring +/// `ConformManager::get_conformed_filename`: one file per channel under +/// `cache_path`, named `-.....pcm`. +fn conform_filenames( + cache_path: &str, + source_filename: &str, + stream_index: i32, + sample_rate: i32, + sample_format: i32, + channel_layout: u64, +) -> Vec { + let count = channel_layout.count_ones() as usize; + let base = format!( + "{}-{}.{}.{}.{}", + unique_file_identifier(source_filename), + stream_index, + sample_rate, + sample_format, + channel_layout, + ); + + let mut out = Vec::with_capacity(count); + for i in 0..count { + let p = Path::new(cache_path).join(format!("{}.{}.pcm", base, i)); + out.push(p.to_string_lossy().into_owned()); + } + out +} + +/// `oakcommon_filefunctions_get_unique_file_identifier` wrapper (the bridge +/// returns a 64-bit id directly). +fn unique_file_identifier(filename: &str) -> String { + let c = match CString::new(filename) { + Ok(c) => c, + Err(_) => return String::new(), + }; + // # Safety: `c` is a valid NUL-terminated C string alive for the call. + let id = unsafe { + crate::bridge::common::oakcommon_filefunctions_get_unique_file_identifier(c.as_ptr()) + }; + format!("{}", id) +} + +/// True when every conform filename already exists on disk. +fn all_conforms_exist(filenames: &[String]) -> bool { + filenames.iter().all(|f| Path::new(f).exists()) +} + +/// Shared test support: serializes access to the global task-submit registry +/// (unit tests run in parallel and would otherwise clear each other's +/// registration) and provides a callback that accepts any task. +#[cfg(test)] +pub(crate) mod test_util { + use crate::error::OAKCODEC_OK; + use crate::task::OakCodecTaskRequest; + + /// Serializes every test that mutates the task-submit registry. + pub static REG_LOCK: std::sync::Mutex<()> = std::sync::Mutex::new(()); + + /// A task-submit callback that accepts every request (no-op). + pub unsafe extern "C" fn accept_cb( + _req: *const OakCodecTaskRequest, + _ud: *mut std::ffi::c_void, + ) -> i32 { + OAKCODEC_OK + } +} + +#[cfg(test)] +mod tests { + use super::*; + + fn temp_subdir(name: &str) -> String { + let dir = std::env::temp_dir().join(format!( + "oakcodec_conform_{}_{}", + name, + std::process::id() + )); + let _ = std::fs::create_dir_all(&dir); + dir.to_string_lossy().into_owned() + } + + fn fnv1a64(bytes: &[u8]) -> u64 { + let mut h: u64 = 14695981039346656037; + for &b in bytes { + h ^= b as u64; + h = h.wrapping_mul(1099511628211); + } + h + } + + #[test] + fn unique_identifier_matches_bridge_hash() { + // The test stub computes an FNV-1a-64 of the path bytes. + let expected = format!("{}", fnv1a64(b"media.mp4") as i64); + assert_eq!(unique_file_identifier("media.mp4"), expected); + // Deterministic: same input, same id. + assert_eq!( + unique_file_identifier("media.mp4"), + unique_file_identifier("media.mp4") + ); + // Different input, different id. + assert_ne!( + unique_file_identifier("media.mp4"), + unique_file_identifier("other.mp4") + ); + } + + #[test] + fn filename_count_from_channel_layout() { + let m = ConformManager::instance(); + assert_eq!(m.get_conform_filename_count("c", "s", 0, 48000, 0x3, 0), 2); // stereo + assert_eq!(m.get_conform_filename_count("c", "s", 0, 48000, 0x4, 0), 1); // mono + assert_eq!(m.get_conform_filename_count("c", "s", 0, 48000, 0, 0), 0); // invalid + assert_eq!( + m.get_conform_filename_count("c", "s", 0, 48000, 0x60F, 0), + 6 + ); // 5.1 + } + + #[test] + fn conform_filename_derivation_and_range() { + let m = ConformManager::instance(); + let cache = temp_subdir("names"); + let id = fnv1a64(b"media.mp4") as i64; + let base = format!("{}-0.48000.0.3", id); + let f0 = m + .get_conform_filename(&cache, "media.mp4", 0, 48000, 0x3, 0, 0) + .unwrap(); + let f1 = m + .get_conform_filename(&cache, "media.mp4", 0, 48000, 0x3, 0, 1) + .unwrap(); + assert_eq!(f0, format!("{}/{}.0.pcm", cache, base)); + assert_eq!(f1, format!("{}/{}.1.pcm", cache, base)); + // Out of range. + assert!(matches!( + m.get_conform_filename(&cache, "media.mp4", 0, 48000, 0x3, 0, 5), + Err(crate::error::Error::NotFound) + )); + } + + #[test] + fn get_conform_state_unavailable_without_registrar() { + let _g = super::test_util::REG_LOCK.lock().unwrap(); + // Ensure no registrar is left over. + crate::task::set_task_submit_cb_extern(None, std::ptr::null_mut()); + let cache = temp_subdir("unavail"); + let s = ConformManager::instance() + .get_conform_state(&cache, "missing.mp4", 0, 48000, 0x3, 0, false) + .unwrap(); + assert_eq!(s, ConformState::Unavailable); + } + + #[test] + fn get_conform_state_exists_when_files_present() { + let cache = temp_subdir("exists"); + let m = ConformManager::instance(); + for i in 0..2 { + let f = m + .get_conform_filename(&cache, "media.mp4", 0, 48000, 0x3, 0, i) + .unwrap(); + std::fs::write(&f, b"pcm").unwrap(); + } + let s = m + .get_conform_state(&cache, "media.mp4", 0, 48000, 0x3, 0, false) + .unwrap(); + assert_eq!(s, ConformState::Exists); + } + + #[test] + fn get_conform_state_generating_when_registered() { + let _g = super::test_util::REG_LOCK.lock().unwrap(); + crate::task::set_task_submit_cb_extern( + Some(super::test_util::accept_cb), + std::ptr::null_mut(), + ); + let cache = temp_subdir("generating"); + let s = ConformManager::instance() + .get_conform_state(&cache, "missing.mp4", 0, 48000, 0x3, 0, false) + .unwrap(); + crate::task::set_task_submit_cb_extern(None, std::ptr::null_mut()); + assert_eq!(s, ConformState::Generating); + } +} diff --git a/src/codec/rust/src/decoder.rs b/src/codec/rust/src/decoder.rs new file mode 100644 index 000000000..84f6bbd3e --- /dev/null +++ b/src/codec/rust/src/decoder.rs @@ -0,0 +1,720 @@ +// Oak Video Editor - Non-Linear Video Editor +// Copyright (C) 2026 Oak Team +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +//! `olive::Decoder` and its supporting types — the media-decoder trait. +//! +//! Mirrors `src/codec/src/decoder.h`. The C++ abstract base plus its +//! FFmpeg/OIIO subclasses become the [`Decoder`] trait (decision 2 in +//! README.md); probe/dispatch lives on the registry functions at the +//! bottom of this module. Audio is handled in raw interleaved-float +//! buffers matching the C ABI, not `oakcore_rs::SampleBuffer` (which the +//! crate does not export). + +use std::path::Path; +use std::sync::{Arc, Mutex, OnceLock}; + +use oakcore_rs::{Rational, TimeRange}; + +use crate::bridge::render::{OakCancelAtom, OakRenderTexture}; +use crate::footagedescription::FootageDescription; +use crate::frame::Frame; + +/// `oakcodec_video_stream_info` — POD probe output describing one video +/// stream; see `include/codec/decoder.h`. +#[repr(C)] +pub struct OakCodecVideoStreamInfo { + /// Stream index. + pub stream_index: i32, + /// Width in pixels. + pub width: i32, + /// Height in pixels. + pub height: i32, + /// Frame-rate numerator. + pub frame_rate_num: i32, + /// Frame-rate denominator. + pub frame_rate_den: i32, + /// Stream length in time-base units. + pub duration_ts: i64, + /// Time-base numerator (seconds per time-base unit). + pub time_base_num: i32, + /// Time-base denominator. + pub time_base_den: i32, + /// Native delivery `OakPixelFormat`. + pub format: i32, + /// Plane channel count. + pub channel_count: i32, + /// ISO/IEC 23001-8 color-primaries code point (0 = unknown). + pub color_primaries: i32, + /// ISO/IEC 23001-8 color-transfer code point (0 = unknown). + pub color_trc: i32, + /// 1 when the stream is interlaced. + pub interlaced: i32, +} + +/// `oakcodec_audio_stream_info` — POD probe output describing one audio +/// stream; see `include/codec/decoder.h`. +#[repr(C)] +pub struct OakCodecAudioStreamInfo { + /// Stream index. + pub stream_index: i32, + /// Sample rate (Hz). + pub sample_rate: i32, + /// ffmpeg-style channel mask (e.g. 0x3 = stereo). + pub channel_layout: u64, + /// Channel count. + pub channel_count: i32, + /// Stream length in time-base units. + pub duration_ts: i64, + /// Time-base numerator. + pub time_base_num: i32, + /// Time-base denominator. + pub time_base_den: i32, +} + +/// Local replacement for `render/rendermodes.h` (oakrender C API has no +/// render-mode counterpart). Values mirror engine/render/rendermodes.h: +/// k_offline = 0, k_online = 1. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +#[repr(i32)] +pub enum RenderMode { + /// Offline / background render. + Offline = 0, + /// Online / real-time render. + Online = 1, +} + +/// "Don't force a color range" sentinel for +/// [`RetrieveVideoParams::force_range`] (the actual ranges are the +/// `OAKCOMMON_COLOR_RANGE_*` values). +pub const K_COLOR_RANGE_DEFAULT: i32 = -1; + +/// `Decoder::RetrieveVideoParams` — what a video retrieve call needs. +pub struct RetrieveVideoParams { + /// Stream to read from. + pub stream: CodecStream, + /// Timestamp, rational seconds. + pub time: Rational, + /// Length of footage before the start (for early-seek semantics). + pub length: TimeRange, + /// Color range override; [`K_COLOR_RANGE_DEFAULT`] means "don't force". + pub force_range: i32, + /// Image sequence: bake the frame number into the filename. + pub is_image_sequence: bool, + /// Image sequence digit count (derived from the filename). + pub image_sequence_digits: i32, + /// Image sequence number to substitute. + pub image_sequence_number: i64, + /// Render mode (drives texture-path choices in the implementations). + pub mode: RenderMode, + /// Frame alpha channel is premultiplied. + pub alpha_is_premultiplied: bool, +} + +/// `Decoder::RetrieveAudioStatus` — outcome of an audio retrieve. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum RetrieveAudioStatus { + /// Data written to the destination buffer. + Success, + /// The requested range is outside the footage. + InvalidRange, + /// The stream does not support audio. + Unsupported, + /// Media requires a conform that could not be produced. + ConformNeeded, + /// A decoder-level error occurred. + Error, +} + +/// `Decoder::RetrieveState`. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum RetrieveState { + /// Ready to decode. + Ready, + /// Failed to open the stream. + FailedToOpen, + /// The stream index could not be located. + IndexUnavailable, +} + +/// `Decoder::CodecStream` — identifies one (filename, stream) pair plus an +/// optional associated timeline block. +/// +/// The block is an opaque `OakNodeBlock` handle that codec only stores and +/// compares, never dereferences or retains (borrowed pointer). +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct CodecStream { + filename: String, + stream: i32, + block: Option, +} + +impl CodecStream { + /// Empty, invalid stream. + pub fn new() -> Self { + CodecStream { + filename: String::new(), + stream: -1, + block: None, + } + } + + /// New stream for `(filename, stream)` with an optional block. + pub fn with_block( + filename: String, + stream: i32, + block: Option, + ) -> Self { + CodecStream { + filename, + stream, + block, + } + } + + /// Non-empty filename and non-negative stream index. + pub fn is_valid(&self) -> bool { + !self.filename.is_empty() && self.stream >= 0 + } + + /// The file exists on disk. + pub fn exists(&self) -> bool { + Path::new(&self.filename).exists() + } + + /// Reset to the empty stream. + pub fn reset(&mut self) { + self.filename.clear(); + self.stream = -1; + self.block = None; + } + + /// Source filename. + pub fn filename(&self) -> &str { + &self.filename + } + + /// Stream index within the source. + pub fn stream(&self) -> i32 { + self.stream + } + + /// Associated timeline block (borrowed; only compared, never used). + pub fn block(&self) -> Option { + self.block.clone() + } +} + +/// `olive::Decoder` — abstraction over external media decoding. +/// +/// Implementations are [`crate::ffmpeg::FFmpegDecoder`] and +/// [`crate::oiio::OIIODecoder`]. The trait surface mirrors the C++ +/// abstract base; the refcounted handle that backs the public API wraps an +/// `Arc`. +pub trait Decoder: Send + Sync { + /// Unique decoder id ("ffmpeg"/"oiio"). + fn id(&self) -> String; + + /// Whether this decoder supports video streams. + fn supports_video(&self) -> bool { + false + } + + /// Whether this decoder supports audio streams. + fn supports_audio(&self) -> bool { + false + } + + /// Whether this decoder can read the given file (static probe). + fn probe( + &self, + filename: &str, + cancelled: Option<&OakCancelAtom>, + ) -> Option; + + /// Open `stream` for decoding. Thread-safe. + fn open(&self, stream: &CodecStream) -> crate::error::Result<()>; + + /// Close the currently open stream (safe when closed). + fn close(&self) -> crate::error::Result<()>; + + /// The currently open stream (locked accessor). + fn stream(&self) -> CodecStream; + + /// Retrieve a video frame into CPU memory. + fn retrieve_video_frame( + &self, + p: &RetrieveVideoParams, + ) -> crate::error::Result>; + + /// Retrieve a video frame as a render texture (owned by caller). + fn retrieve_video(&self, p: &RetrieveVideoParams) -> crate::error::Result; + + /// Retrieve interleaved audio covering `range` into `dest` (floats). + fn retrieve_audio( + &self, + dest: &mut [f32], + range: &TimeRange, + sample_rate: i32, + channel_layout: u64, + ) -> crate::error::Result; + + /// Conform the open stream's audio into per-channel pcm files. + /// + /// `sample_rate` / `channel_layout` / `sample_format` describe the + /// target audio format (`sample_format` is a + /// `olive::core::SampleFormat::Format` value). The C++ side builds its + /// `core::AudioParams` from these three — mirroring the C ABI + /// `oakcodec_decoder_conform_audio` argument list. + fn conform_audio( + &self, + output_filenames: &[String], + sample_rate: i32, + channel_layout: u64, + sample_format: i32, + cancelled: Option<&OakCancelAtom>, + ) -> crate::error::Result<()>; + + /// Offset of the audio start relative to the video (rational seconds). + fn get_audio_start_offset(&self) -> Rational { + // C++ default `virtual Rational get_audio_start_offset() const { return 0; }` + Rational::new(0, 1) + } +} + +/// Placeholder decoder used by the built-in probe registry. +/// +/// Reports the correct id and capability flags so id-based dispatch +/// (`create_from_id`) works, but every media operation is unimplemented +/// and returns `None` / an error. Used for the OIIO entry, whose Rust +/// implementation (`crate::oiio::OIIODecoder`) is still a dylib stub; the +/// FFmpeg entry is the real [`crate::ffmpeg::FFmpegDecoder`]. +struct UnimplementedDecoder { + id: &'static str, + video: bool, + audio: bool, +} + +impl UnimplementedDecoder { + fn new(id: &'static str, video: bool, audio: bool) -> Self { + UnimplementedDecoder { id, video, audio } + } +} + +impl Decoder for UnimplementedDecoder { + fn id(&self) -> String { + self.id.to_string() + } + + fn supports_video(&self) -> bool { + self.video + } + + fn supports_audio(&self) -> bool { + self.audio + } + + fn probe( + &self, + _filename: &str, + _cancelled: Option<&OakCancelAtom>, + ) -> Option { + None + } + + fn open(&self, _stream: &CodecStream) -> crate::error::Result<()> { + Err(crate::error::Error::Failed("decoder not yet implemented".to_string())) + } + + fn close(&self) -> crate::error::Result<()> { + Err(crate::error::Error::Failed("decoder not yet implemented".to_string())) + } + + fn stream(&self) -> CodecStream { + CodecStream::new() + } + + fn retrieve_video_frame( + &self, + _p: &RetrieveVideoParams, + ) -> crate::error::Result> { + Err(crate::error::Error::Failed("decoder not yet implemented".to_string())) + } + + fn retrieve_video( + &self, + _p: &RetrieveVideoParams, + ) -> crate::error::Result { + Err(crate::error::Error::Failed("decoder not yet implemented".to_string())) + } + + fn retrieve_audio( + &self, + _dest: &mut [f32], + _range: &TimeRange, + _sample_rate: i32, + _channel_layout: u64, + ) -> crate::error::Result { + Err(crate::error::Error::Failed("decoder not yet implemented".to_string())) + } + + fn conform_audio( + &self, + _output_filenames: &[String], + _sample_rate: i32, + _channel_layout: u64, + _sample_format: i32, + _cancelled: Option<&OakCancelAtom>, + ) -> crate::error::Result<()> { + Err(crate::error::Error::Failed("decoder not yet implemented".to_string())) + } +} + +/// `Decoder::create_from_id` — instantiate a decoder by id, or `None`. +pub fn create_from_id(id: &str) -> Option> { + if id.is_empty() { + return None; + } + + receive_list_of_all_decoders() + .into_iter() + .find(|d| d.id() == id) +} + +/// Test-injected decoder registry (see [`set_test_decoders`]); empty when +/// not injected, in which case the built-in list below is used. +static TEST_DECODERS: OnceLock>>> = OnceLock::new(); + +/// Serializes every test that reads the built-in decoder registry. The ffi +/// decoder tests inject through `crate::ffi::lock_tests()` (the shared +/// `TEST_LOCK`), so the registry assertions below take that same lock to +/// never race with an injected list. +#[cfg(test)] +fn registry_guard() -> std::sync::MutexGuard<'static, ()> { + crate::ffi::lock_tests() +} + +/// Replace the decoder registry with `list`; pass an empty list to restore +/// the built-in decoders. +/// +/// Test/extension support (the C ABI has no way to register a decoder, so +/// the contract tests drive the probe/dispatch paths through a fake +/// decoder). Hidden from docs; never called by production code. +#[doc(hidden)] +pub fn set_test_decoders(list: Vec>) { + let store = TEST_DECODERS.get_or_init(|| Mutex::new(Vec::new())); + *store.lock().unwrap() = list; +} + +/// `Decoder::receive_list_of_all_decoders` — all registered decoders. +/// +/// Order is probe priority, mirroring C++: OIIO (more specific) before +/// FFmpeg (format-agnostic fallback). The OIIO entry is an +/// [`UnimplementedDecoder`] stub (the OIIO engine is not ported); the +/// FFmpeg entry is the real [`crate::ffmpeg::FFmpegDecoder`]. When tests +/// injected a non-empty list via [`set_test_decoders`], that list takes +/// precedence. +pub fn receive_list_of_all_decoders() -> Vec> { + if let Some(store) = TEST_DECODERS.get() { + let injected = store.lock().unwrap(); + if !injected.is_empty() { + return injected.clone(); + } + } + vec![ + Arc::new(UnimplementedDecoder::new("oiio", false, false)), + Arc::new(crate::ffmpeg::FFmpegDecoder::new()), + ] +} + +/// Image-sequence filename heuristics (static). +/// +/// Replace the trailing digit run of the filename stem with the +/// zero-padded decimal representation of `number` (keeps the same digit +/// count), mirroring `Decoder::transform_image_sequence_file_name`. +pub fn transform_image_sequence_file_name(filename: &str, number: i64) -> String { + let digit_count = get_image_sequence_digit_count(filename) as usize; + + let path = Path::new(filename); + let file_name = path + .file_name() + .and_then(|n| n.to_str()) + .unwrap_or(filename); + + // QFileInfo::completeBaseName(): filename up to the first '.'. + let original_basename = match file_name.find('.') { + Some(dot) => &file_name[..dot], + None => file_name, + }; + + // New stem = original stem minus the trailing digit run, plus the + // zero-padded number (`snprintf("%0*lld", digit_count, number)`). + let cut = original_basename.len().saturating_sub(digit_count); + let new_basename = format!( + "{}{:0width$}", + &original_basename[..cut], + number, + width = digit_count + ); + + // Replace every occurrence of the original stem in the filename. + let mut new_filename = file_name.to_string(); + let mut pos = 0; + while let Some(rel) = new_filename[pos..].find(original_basename) { + let start = pos + rel; + let end = start + original_basename.len(); + new_filename.replace_range(start..end, &new_basename); + pos = start + new_basename.len(); + } + + match path.parent() { + Some(parent) if !parent.as_os_str().is_empty() => { + Path::new(parent).join(&new_filename).to_string_lossy().into_owned() + } + _ => new_filename, + } +} + +/// Number of trailing digits in the filename stem (0 = not a sequence). +pub fn get_image_sequence_digit_count(filename: &str) -> i32 { + let file_name = Path::new(filename) + .file_name() + .and_then(|n| n.to_str()) + .unwrap_or(filename); + + // QFileInfo::completeBaseName(): filename up to the first '.'. + let stem = match file_name.find('.') { + Some(dot) => &file_name[..dot], + None => file_name, + }; + + let mut count: i32 = 0; + for ch in stem.chars().rev() { + if ch.is_ascii_digit() { + count += 1; + } else { + break; + } + } + + count +} + +/// Numeric value of the trailing digits (0 when there are none). +/// +/// Mirrors C++ `Decoder::get_image_sequence_index`, which slices the +/// trailing digit run (`basename.substr(basename.size() - digit_count)`) and +/// passes it to `strtoll`. Because that slice is empty when there are no +/// trailing digits (digit_count == 0) and all-digits otherwise, the value is +/// the parsed number, or `0` for a non-sequence. +pub fn get_image_sequence_index(filename: &str) -> i64 { + let digit_count = get_image_sequence_digit_count(filename) as usize; + + let file_name = Path::new(filename) + .file_name() + .and_then(|n| n.to_str()) + .unwrap_or(filename); + + // QFileInfo::completeBaseName(): filename up to the first '.'. + let stem = match file_name.find('.') { + Some(dot) => &file_name[..dot], + None => file_name, + }; + + // Trailing digit run (empty when the stem has no trailing digits). + let start = stem.len().saturating_sub(digit_count); + let number_only = &stem[start..]; + + // `strtoll(..., base 10)`: the slice is empty-or-digits, so a plain + // decimal parse with 0 on failure reproduces the C++ result. + number_only.parse::().unwrap_or(0) +} + +/// The `k_any_timecode` rational constant. +/// +/// C++ `const Rational Decoder::k_any_timecode = RATIONAL_MIN;`, which the +/// i32 reduction cap normalizes to `-2147483647/1`. +pub fn k_any_timecode() -> Rational { + Rational::new(-2147483647, 1) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn codec_stream_new_is_invalid() { + let s = CodecStream::new(); + assert!(!s.is_valid()); + assert!(s.filename().is_empty()); + assert_eq!(s.stream(), -1); + assert_eq!(s.block(), None); + } + + #[test] + fn codec_stream_with_block_is_valid() { + let s = CodecStream::with_block("video.mov".to_string(), 1, None); + assert!(s.is_valid()); + assert_eq!(s.filename(), "video.mov"); + assert_eq!(s.stream(), 1); + + // Negative stream index is invalid regardless of filename. + let bad = CodecStream::with_block("video.mov".to_string(), -1, None); + assert!(!bad.is_valid()); + } + + #[test] + fn codec_stream_reset_clears() { + let mut s = CodecStream::with_block("video.mov".to_string(), 2, None); + s.reset(); + assert!(!s.is_valid()); + assert!(s.filename().is_empty()); + assert_eq!(s.stream(), -1); + } + + #[test] + fn digit_count_counts_trailing_digits() { + assert_eq!(get_image_sequence_digit_count("frame_0001.png"), 4); + assert_eq!(get_image_sequence_digit_count("frame.png"), 0); + assert_eq!(get_image_sequence_digit_count("img000.jpg"), 3); + // Digits before the final char are not trailing digits. + assert_eq!(get_image_sequence_digit_count("a1b.png"), 0); + } + + #[test] + fn image_sequence_index_parses_number() { + assert_eq!(get_image_sequence_index("frame_0001.png"), 1); + assert_eq!(get_image_sequence_index("img012.jpg"), 12); + assert_eq!(get_image_sequence_index("0009.png"), 9); + // No trailing digits: the sliced run is empty, so the value is 0. + assert_eq!(get_image_sequence_index("frame.png"), 0); + assert_eq!(get_image_sequence_index("12abc.png"), 0); + } + + #[test] + fn transform_image_sequence_substitutes_number() { + assert_eq!( + transform_image_sequence_file_name("frame_0001.png", 5), + "frame_0005.png" + ); + assert_eq!( + transform_image_sequence_file_name("dir/img012.jpg", 7), + "dir/img007.jpg" + ); + // No digit run: number appended with no padding (C++ behavior). + assert_eq!( + transform_image_sequence_file_name("frame.png", 3), + "frame3.png" + ); + // All-digit stem: whole run is replaced. + assert_eq!( + transform_image_sequence_file_name("0001.png", 7), + "0007.png" + ); + } + + #[test] + fn k_any_timecode_is_rational_min() { + let tc = k_any_timecode(); + assert_eq!(tc.numerator(), -2147483647); + assert_eq!(tc.denominator(), 1); + } + + #[test] + fn registry_lists_oiio_then_ffmpeg() { + let _g = registry_guard(); + let list = receive_list_of_all_decoders(); + let ids: Vec = list.iter().map(|d| d.id()).collect(); + // Probe priority: OIIO (specific) first, FFmpeg (fallback) last. + assert_eq!(ids, vec!["oiio".to_string(), "ffmpeg".to_string()]); + } + + #[test] + fn create_from_id_matches_registry() { + let _g = registry_guard(); + assert!(create_from_id("ffmpeg").is_some()); + assert!(create_from_id("oiio").is_some()); + assert_eq!(create_from_id("ffmpeg").unwrap().id(), "ffmpeg"); + assert_eq!(create_from_id("oiio").unwrap().id(), "oiio"); + // Unknown and empty ids return None. + assert!(create_from_id("nope").is_none()); + assert!(create_from_id("").is_none()); + } +} + +#[cfg(test)] +mod tests_unimplemented { + use super::*; + + fn builtin(id: &str) -> Arc { + create_from_id(id).unwrap() + } + + #[test] + fn ffmpeg_builtin_fails_on_missing_media_and_closes() { + let _g = registry_guard(); + let d = builtin("ffmpeg"); + assert!(d.supports_video()); + assert!(d.supports_audio()); + // A nonexistent file cannot be probed or opened. + assert!(d.probe("x.mp4", None).is_none()); + + let s = CodecStream::with_block("x.mp4".to_string(), 0, None); + assert!(d.open(&s).is_err()); + // C++ parity: a failed open leaves the decoder closed. + assert_eq!(d.stream().filename(), ""); + assert!(d.close().is_ok()); + + let p = RetrieveVideoParams { + stream: CodecStream::new(), + time: Rational::new(0, 1), + length: TimeRange::default(), + force_range: K_COLOR_RANGE_DEFAULT, + is_image_sequence: false, + image_sequence_digits: 0, + image_sequence_number: 0, + mode: RenderMode::Offline, + alpha_is_premultiplied: false, + }; + assert!(d.retrieve_video_frame(&p).is_err()); + assert!(d.retrieve_video(&p).is_err()); + let mut dest = [0f32; 4]; + assert!(d + .retrieve_audio( + &mut dest, + &TimeRange::new(Rational::new(0, 1), Rational::new(1, 1)), + 48000, + 0x3 + ) + .is_err()); + assert!(d + .conform_audio(&["a.pcm".to_string()], 48000, 0x3, 10, None) + .is_err()); + + // OIIO reports no media capabilities. + let o = builtin("oiio"); + assert!(!o.supports_video()); + assert!(!o.supports_audio()); + } + + #[test] + fn get_audio_start_offset_defaults_to_zero() { + let _g = registry_guard(); + let d = builtin("ffmpeg"); + let off = d.get_audio_start_offset(); + assert_eq!(off.numerator(), 0); + assert_eq!(off.denominator(), 1); + } +} diff --git a/src/codec/rust/src/encoder.rs b/src/codec/rust/src/encoder.rs new file mode 100644 index 000000000..1ccb08990 --- /dev/null +++ b/src/codec/rust/src/encoder.rs @@ -0,0 +1,341 @@ +// Oak Video Editor - Non-Linear Video Editor +// Copyright (C) 2026 Oak Team +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +//! `olive::Encoder` — abstract base for media encoders. +//! +//! Mirrors `src/codec/src/encoder.h`. Implementations are +//! [`crate::ffmpeg::FFmpegEncoder`] and [`crate::oiio::OIIOEncoder`]. The +//! workflow (C ABI encoder.h) is: fill an `EncodingParams` → init → open → +//! write_video/audio/subtitle → flush. The trait mirrors the C++ virtual +//! surface. + +use std::sync::{Arc, Mutex, OnceLock}; + +use oakcore_rs::{PixelFormat, SampleFormat}; + +use crate::encodingparams::EncodingParams; +use crate::frame::Frame; + +/// `olive::Encoder` — encoder trait. Backs the refcounted encoder handle. +pub trait Encoder: Send + Sync { + /// Unique encoder id. + fn id(&self) -> String; + + /// Whether this encoder writes video. + fn supports_video(&self) -> bool { + false + } + + /// Whether this encoder writes audio. + fn supports_audio(&self) -> bool { + false + } + + /// Whether this encoder writes subtitles. + fn supports_subtitles(&self) -> bool { + false + } + + /// Whether this encoder writes an image sequence. + fn supports_image_sequences(&self) -> bool { + false + } + + /// Whether this encoder is deterministic for a given config + /// (used for cache keys). + fn is_configurable(&self) -> bool { + false + } + + /// Configure the encoder (per-codec options like `crf`). + fn configure(&self, params: &EncodingParams) -> crate::error::Result<()>; + + /// Open the output file and write headers. + fn open(&self) -> crate::error::Result<()>; + + /// Close the output (write trailer); idempotent. + fn close(&self) -> crate::error::Result<()>; + + /// Encode one video frame (converts delivery pixel format internally). + fn write_video(&self, frame: &Frame) -> crate::error::Result<()>; + + /// Encode interleaved float audio samples. + fn write_audio(&self, samples: &[f32], frame_count: i32) -> crate::error::Result<()>; + + /// Encode one subtitle entry (times in seconds). + fn write_subtitle( + &self, + text: &str, + in_seconds: f64, + out_seconds: f64, + ) -> crate::error::Result<()>; + + /// Flush encoders, write the trailer, close the file. + fn flush(&self) -> crate::error::Result<()>; + + /// The pixel format the encoder wants frames in (or `None`). + fn desired_pixel_format(&self) -> Option; + + /// The sample format the encoder wants audio in (or `None`). + fn desired_sample_format(&self) -> Option; + + /// The configured output filename. + fn filename(&self) -> String; + + /// Human-readable detail of the last failed operation (empty when + /// none). Mirrors the C++ `Encoder::get_error()` used by + /// `oakcodec_encoder_last_error`. + fn get_error(&self) -> String { + String::new() + } +} + +/// Test-injected encoder registry (see [`set_test_encoders`]); empty when +/// not injected, in which case [`create_from_params`] falls back to the +/// built-in format mapping. +static TEST_ENCODERS: OnceLock>>> = OnceLock::new(); + +/// Replace the encoder registry with `list`; pass an empty list to restore +/// the built-in behavior. +/// +/// Test/extension support (the C ABI has no way to register an encoder, so +/// the contract tests drive the encode state machine through a fake +/// encoder). Hidden from docs; never called by production code. +#[doc(hidden)] +pub fn set_test_encoders(list: Vec>) { + let store = TEST_ENCODERS.get_or_init(|| Mutex::new(Vec::new())); + *store.lock().unwrap() = list; +} + +/// `Encoder::create_from_params` — instantiate an encoder for `params`. +/// +/// # CPP-PARITY +/// `src/codec/src/encoder.cpp` `create_from_params` → `create_from_format` +/// picks the FFmpeg/OIIO implementation from `params.format` (DNxHD, +/// Matroska, QuickTime, MPEG-4 video/audio, WAV, AIFF, MP3, FLAC, Ogg, +/// WebM, SRT → FFmpeg; OpenEXR, PNG, TIFF → OIIO; anything else → `None`). +/// A non-empty test-injected list (see [`set_test_encoders`]) wins over the +/// built-in mapping. The concrete implementations are dylib stubs whose +/// `open()` fails with a clear message, so an initialized encoder handle is +/// always constructible for a recognized format. +pub fn create_from_params(params: &EncodingParams) -> Option> { + if let Some(store) = TEST_ENCODERS.get() { + let injected = store.lock().unwrap(); + if !injected.is_empty() { + return injected.first().cloned(); + } + } + match encoder_type_from_format(params.format) { + Some(EncoderType::FFmpeg) => { + Some(Arc::new(crate::ffmpeg::FFmpegEncoder::with_params(params.clone()))) + } + Some(EncoderType::OIIO) => { + Some(Arc::new(crate::oiio::OIIOEncoder { params: params.clone() })) + } + None => None, + } +} + +/// `Encoder::Type` mirror (`encoder.cpp` `get_type_from_format`). +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +enum EncoderType { + /// `k_encoder_type_f_fmpeg`. + FFmpeg, + /// `k_encoder_type_oiio`. + OIIO, +} + +/// `Encoder::get_type_from_format` — the implementation family for an +/// `ExportFormat::Format` int; `None` for unknown/`Count`. +fn encoder_type_from_format(format: i32) -> Option { + match format { + // FFmpeg-backed containers. + 0 | 1 | 2 | 4 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 => Some(EncoderType::FFmpeg), + // OIIO-backed still-image formats. + 3 | 5 | 6 => Some(EncoderType::OIIO), + _ => None, + } +} + +/// Range `(start, end)` of a "[#####]" digit placeholder beginning at +/// `pos` (`bytes[pos] == '['`), or `None`. +/// +/// CPP-PARITY: `encoder.cpp` `k_image_sequence_contains_digits` regex +/// `\[[#]+\]` — a `[`, one or more `#`, then `]`. +fn placeholder_range(bytes: &[u8], pos: usize) -> Option<(usize, usize)> { + if bytes.get(pos) != Some(&b'[') { + return None; + } + let mut j = pos + 1; + while bytes.get(j) == Some(&b'#') { + j += 1; + } + if j > pos + 1 && bytes.get(j) == Some(&b']') { + Some((pos, j + 1)) + } else { + None + } +} + +/// `Encoder::filename_contains_digit_placeholder` — whether `filename` +/// contains a "[#####]" digit placeholder. +/// +/// CPP-PARITY: `encoder.cpp:137` (`std::regex_search` on +/// `k_image_sequence_contains_digits`). +pub fn filename_contains_digit_placeholder(filename: &str) -> bool { + let bytes = filename.as_bytes(); + (0..bytes.len()).any(|i| placeholder_range(bytes, i).is_some()) +} + +/// `Encoder::get_image_sequence_placeholder_digit_count` — number of `#` in +/// the filename's "[#####]" placeholder; 0 when none. +/// +/// CPP-PARITY: `encoder.cpp:119` — the C++ finds the first +/// `k_image_sequence_contains_digits` match and counts its `#`s, which is +/// exactly the match length minus the two brackets. +pub fn image_sequence_placeholder_digit_count(filename: &str) -> i32 { + let bytes = filename.as_bytes(); + for i in 0..bytes.len() { + if let Some((start, end)) = placeholder_range(bytes, i) { + return (end - start - 2) as i32; + } + } + 0 +} + +/// `Encoder::filename_remove_digit_placeholder` — `filename` with every +/// "[#####]" placeholder removed; an optional single separator char +/// (`-`, `.`, ` `, `_`) immediately before the placeholder goes with it. +/// +/// CPP-PARITY: `encoder.cpp:142` (`std::regex_replace` on +/// `k_image_sequence_remove_digits` = `[\-\.\ \_]?\[[#]+\]`, empty +/// replacement, all matches). +pub fn filename_remove_digit_placeholder(filename: &str) -> String { + let bytes = filename.as_bytes(); + let mut out = Vec::with_capacity(bytes.len()); + let mut i = 0; + while i < bytes.len() { + // A separator is consumed only when a placeholder follows it. + let ph_start = match bytes[i] { + b'-' | b'.' | b' ' | b'_' if placeholder_range(bytes, i + 1).is_some() => { + i + 1 + } + _ => i, + }; + match placeholder_range(bytes, ph_start) { + Some((_, end)) => i = end, + None => { + out.push(bytes[i]); + i += 1; + } + } + } + String::from_utf8(out).unwrap_or_else(|_| filename.to_string()) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn create_from_params_maps_formats() { + let mut p = EncodingParams::default(); + + // FFmpeg-backed containers. + for fmt in [0, 1, 2, 4, 7, 8, 9, 10, 11, 12, 13, 14] { + p.format = fmt; + let e = create_from_params(&p).expect("format {fmt}"); + assert_eq!(e.id(), "ffmpeg", "format {fmt}"); + } + // OIIO-backed still images. + for fmt in [3, 5, 6] { + p.format = fmt; + let e = create_from_params(&p).expect("format {fmt}"); + assert_eq!(e.id(), "oiio", "format {fmt}"); + } + // Unknown / Count -> None (C++ `k_encoder_type_none`). + p.format = 15; + assert!(create_from_params(&p).is_none()); + p.format = -1; + assert!(create_from_params(&p).is_none()); + } + + #[test] + fn get_error_defaults_to_empty() { + let e = UnimplementedDummy; + assert_eq!(e.get_error(), ""); + } + + #[test] + fn image_sequence_placeholder_helpers() { + // contains: "[#####]" style placeholder only. + assert!(filename_contains_digit_placeholder("/tmp/out_[#####].png")); + assert!(filename_contains_digit_placeholder("out[#].png")); + assert!(!filename_contains_digit_placeholder("/tmp/out.png")); + assert!(!filename_contains_digit_placeholder("out[####.png")); + assert!(!filename_contains_digit_placeholder("out[].png")); + + // digit count: number of '#' in the first placeholder. + assert_eq!(image_sequence_placeholder_digit_count("/tmp/out_[#####].png"), 5); + assert_eq!(image_sequence_placeholder_digit_count("out[#].png"), 1); + assert_eq!(image_sequence_placeholder_digit_count("a[##]b[####]c"), 2); + assert_eq!(image_sequence_placeholder_digit_count("/tmp/out.png"), 0); + + // remove: separator char before the placeholder goes with it. + assert_eq!(filename_remove_digit_placeholder("/tmp/out_[#####].png"), "/tmp/out.png"); + assert_eq!(filename_remove_digit_placeholder("out[###].png"), "out.png"); + assert_eq!(filename_remove_digit_placeholder("a_[#]b_[###]c"), "abc"); + assert_eq!(filename_remove_digit_placeholder("/tmp/out.png"), "/tmp/out.png"); + } + + struct UnimplementedDummy; + + impl Encoder for UnimplementedDummy { + fn id(&self) -> String { + "dummy".to_string() + } + fn configure(&self, _p: &EncodingParams) -> crate::error::Result<()> { + Ok(()) + } + fn open(&self) -> crate::error::Result<()> { + Ok(()) + } + fn close(&self) -> crate::error::Result<()> { + Ok(()) + } + fn write_video(&self, _f: &Frame) -> crate::error::Result<()> { + Ok(()) + } + fn write_audio(&self, _s: &[f32], _c: i32) -> crate::error::Result<()> { + Ok(()) + } + fn write_subtitle(&self, _t: &str, _i: f64, _o: f64) -> crate::error::Result<()> { + Ok(()) + } + fn flush(&self) -> crate::error::Result<()> { + Ok(()) + } + fn desired_pixel_format(&self) -> Option { + None + } + fn desired_sample_format(&self) -> Option { + None + } + fn filename(&self) -> String { + String::new() + } + } +} diff --git a/src/codec/rust/src/encodingparams.rs b/src/codec/rust/src/encodingparams.rs new file mode 100644 index 000000000..985a8df29 --- /dev/null +++ b/src/codec/rust/src/encodingparams.rs @@ -0,0 +1,1133 @@ +// Oak Video Editor - Non-Linear Video Editor +// Copyright (C) 2026 Oak Team +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +//! `olive::EncodingParams` — export encoding parameters. +//! +//! Mirrors the `EncodingParams` class carried in `src/codec/src/encoder.h` +//! and the flattened `oakcodec_encoding_params` POD in +//! `include/codec/encoder.h`. The Rust struct mirrors the POD verbatim so +//! `ffi.rs` can marshal it without translation. + +use oakcore_rs::{PixelFormat, SampleFormat}; + +/// `VideoParams::Interlacing` values. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +#[repr(i32)] +pub enum VideoScalingMethod { + /// Fit the source into the destination, preserving aspect. + Fit = 0, + /// Stretch the source to the destination. + Stretch = 1, + /// Crop the source to the destination. + Crop = 2, +} + +/// `olive::EncodingParams` — flattened mirror of `oakcodec_encoding_params`. +#[derive(Clone, Debug)] +#[repr(C)] +pub struct EncodingParams { + /// Output filename (or image-sequence "[#####]" template). + pub filename: [u8; 1024], + /// `ExportFormat::Format`. + pub format: i32, + + /// Video track enabled (1/0; C `int`). + pub video_enabled: i32, + /// `ExportCodec::Codec`. + pub video_codec: i32, + /// Output width. + pub video_width: i32, + /// Output height. + pub video_height: i32, + /// Frame duration (rational): numerator. + pub video_time_base_num: i32, + /// Frame duration (rational): denominator. + pub video_time_base_den: i32, + /// Delivery `OakPixelFormat`. + pub video_pixel_format: PixelFormat, + /// Interlacing (`Interlacing` value). + pub video_interlacing: i32, + /// Pixel aspect ratio numerator. + pub video_pixel_aspect_num: i32, + /// Pixel aspect ratio denominator. + pub video_pixel_aspect_den: i32, + /// Bit rate (bit/s), 0 = codec default. + pub video_bit_rate: i64, + /// Min bit rate. + pub video_min_bit_rate: i64, + /// Max bit rate. + pub video_max_bit_rate: i64, + /// Buffer size (bytes). + pub video_buffer_size: i64, + /// Encoding threads (0 = auto). + pub video_threads: i32, + /// Encoded pixel format name (e.g. "yuv420p"). + pub video_pix_fmt: [u8; 64], + /// Image sequence output (1/0). + pub video_is_image_sequence: i32, + /// Scaling method (`VideoScalingMethod`). + pub video_scaling_method: VideoScalingMethod, + + /// Audio track enabled (1/0). + pub audio_enabled: i32, + /// `ExportCodec::Codec`. + pub audio_codec: i32, + /// Audio sample rate. + pub audio_sample_rate: i32, + /// ffmpeg-style channel layout mask. + pub audio_channel_layout: u64, + /// `SampleFormat`. + pub audio_sample_format: SampleFormat, + /// Audio bit rate. + pub audio_bit_rate: i64, + + /// Subtitles track enabled (1/0). + pub subtitles_enabled: i32, + /// `ExportCodec::Codec`. + pub subtitles_codec: i32, + /// Subtitles written as a sidecar file (1/0). + pub subtitles_are_sidecar: i32, + /// Sidecar format (`ExportFormat::Format`). + pub subtitles_sidecar_format: i32, + + /// Output OCIO colorspace name; empty = reference space (no transform). + pub color_transform_output: [u8; 256], + + /// Export length in seconds (rational). + pub export_length_num: i32, + /// Export length in seconds (rational). + pub export_length_den: i32, + + /// Custom export range enabled (1/0). + pub has_custom_range: i32, + /// Custom range in, rational seconds. + pub custom_range_in_num: i64, + /// Custom range in denominator. + pub custom_range_in_den: i64, + /// Custom range out, rational seconds. + pub custom_range_out_num: i64, + /// Custom range out denominator. + pub custom_range_out_den: i64, +} + +impl Default for EncodingParams { + fn default() -> Self { + Self { + filename: [0; 1024], + format: -1, + + video_enabled: 0, + video_codec: -1, + video_width: 0, + video_height: 0, + video_time_base_num: 1, + video_time_base_den: 1, + video_pixel_format: PixelFormat::Invalid, + video_interlacing: 0, + video_pixel_aspect_num: 0, + video_pixel_aspect_den: 0, + video_bit_rate: 0, + video_min_bit_rate: 0, + video_max_bit_rate: 0, + video_buffer_size: 0, + video_threads: 0, + video_pix_fmt: [0; 64], + video_is_image_sequence: 0, + video_scaling_method: VideoScalingMethod::Stretch, + + audio_enabled: 0, + audio_codec: -1, + audio_sample_rate: 0, + audio_channel_layout: 0, + audio_sample_format: SampleFormat::Invalid, + audio_bit_rate: 0, + + subtitles_enabled: 0, + subtitles_codec: -1, + subtitles_are_sidecar: 0, + subtitles_sidecar_format: -1, + + color_transform_output: [0; 256], + + export_length_num: 0, + export_length_den: 0, + + has_custom_range: 0, + custom_range_in_num: 0, + custom_range_in_den: 0, + custom_range_out_num: 0, + custom_range_out_den: 0, + } + } +} + +impl EncodingParams { + /// Scaling matrix for a scaling method; row-major 4x4 into `out[16]`. + /// + /// # CPP-PARITY + /// `src/codec/src/encoder.cpp` `EncodingParams::generate_matrix` — + /// returns a row-major `std::array` (formerly QMatrix4x4). + pub fn generate_matrix( + method: VideoScalingMethod, + src_width: i32, + src_height: i32, + dst_width: i32, + dst_height: i32, + out: &mut [f64; 16], + ) { + // Identity (former default-constructed QMatrix4x4), row-major. + *out = [ + 1.0, 0.0, 0.0, 0.0, // + 0.0, 1.0, 0.0, 0.0, // + 0.0, 0.0, 1.0, 0.0, // + 0.0, 0.0, 0.0, 1.0, + ]; + + if method == VideoScalingMethod::Stretch { + return; + } + + // Guard degenerate sizes: the C++ would produce inf/NaN here; an + // identity is the only safe output for the rendering pipeline. + if src_width <= 0 || src_height <= 0 || dst_width <= 0 || dst_height <= 0 { + return; + } + + let export_ar = dst_width as f64 / dst_height as f64; + let source_ar = src_width as f64 / src_height as f64; + + // qFuzzyCompare(export_ar, source_ar): within one part in 100000. + if (export_ar - source_ar).abs() * 100000.0 + <= export_ar.abs().min(source_ar.abs()) + { + return; + } + + if (export_ar > source_ar) == (method == VideoScalingMethod::Fit) { + // scale(source_ar / export_ar, 1) + out[0] = source_ar / export_ar; + } else { + // scale(1, export_ar / source_ar) + out[5] = export_ar / source_ar; + } + } + + /// File extension for this format (e.g. "mp4"). + /// + /// # CPP-PARITY + /// `ExportFormat::get_extension` (`src/codec/src/exportformat.cpp`) keyed + /// on the serialized `Format` discriminant. Unknown / invalid formats + /// return the empty string, matching the C++ default case. + pub fn extension(&self) -> &str { + match self.format { + 0 => "mxf", // DNxHD + 1 => "mkv", // Matroska + 2 => "mp4", // MPEG-4 video + 3 => "exr", // OpenEXR + 4 => "mov", // QuickTime + 5 => "png", // PNG + 6 => "tiff", // TIFF + 7 => "wav", // WAV + 8 => "aiff", // AIFF + 9 => "mp3", // MP3 + 10 => "flac", // FLAC + 11 => "ogg", // Ogg + 12 => "webm", // WebM + 13 => "srt", // SRT + 14 => "m4a", // MPEG-4 audio + _ => "", + } + } + + /// Load from a compact XML preset string (oakcommon C++ XmlStreamReader). + /// + /// # CPP-PARITY + /// `EncodingParams::load` — uses oakcommon's C++ `XmlStreamReader` + /// (`src/common/src/xmlutils.h`), a C++-to-C++ coupling the bridge + /// cannot cover (NOTES.md §7). Preserves the load_v1 bug of not + /// assigning `custom_range`. + pub fn load(&mut self, data: &str) -> crate::error::Result<()> { + let root = parse_preset(data) + .map_err(|e| crate::error::Error::Failed(format!("invalid export preset: {e}")))?; + if root.name != "export" { + return Err(crate::error::Error::Failed( + "not an export preset document".to_string(), + )); + } + + // `range` / `customrangein` / `customrangeout` are parsed for shape + // parity but never assigned — mirroring the C++ `load_v1` bug that + // reads them into locals and forgets to store `custom_range`. + if let Some(e) = child(&root, "range") { + let _ = parse_bool(&text(e)); + } + if let Some(e) = child(&root, "customrangein") { + let _ = &text(e); + } + if let Some(e) = child(&root, "customrangeout") { + let _ = &text(e); + } + + if let Some(e) = child(&root, "filename") { + set_cstr(&mut self.filename, &text(e)); + } + if let Some(e) = child(&root, "format") { + self.format = parse_i32(&text(e)); + } + + if let Some(e) = child(&root, "video") { + if let Some(v) = attr(e, "enabled") { + self.video_enabled = parse_bool(v) as i32; + } + if let Some(e) = child(e, "codec") { + self.video_codec = parse_i32(&text(e)); + } + if let Some(e) = child(e, "width") { + self.video_width = parse_i32(&text(e)); + } + if let Some(e) = child(e, "height") { + self.video_height = parse_i32(&text(e)); + } + if let Some(e) = child(e, "format") { + self.video_pixel_format = match parse_i32(&text(e)) { + -1 => PixelFormat::Invalid, + 0 => PixelFormat::U8, + 1 => PixelFormat::U10, + 2 => PixelFormat::U16, + 3 => PixelFormat::F16, + 4 => PixelFormat::F32, + _ => PixelFormat::Invalid, + }; + } + if let Some(e) = child(e, "timebase") { + let tb = text(e); + if let Some((n, d)) = tb.split_once('/') { + self.video_time_base_num = parse_i32(n); + self.video_time_base_den = parse_i32(d); + } + } + if let Some(e) = child(e, "divider") { + self.video_interlacing = parse_i32(&text(e)); + } + if let Some(e) = child(e, "pixelaspect") { + let par = text(e); + if let Some((n, d)) = par.split_once('/') { + self.video_pixel_aspect_num = parse_i32(n); + self.video_pixel_aspect_den = parse_i32(d); + } + } + if let Some(e) = child(e, "bitrate") { + self.video_bit_rate = parse_i64(&text(e)); + } + if let Some(e) = child(e, "minbitrate") { + self.video_min_bit_rate = parse_i64(&text(e)); + } + if let Some(e) = child(e, "maxbitrate") { + self.video_max_bit_rate = parse_i64(&text(e)); + } + if let Some(e) = child(e, "bufsize") { + self.video_buffer_size = parse_i64(&text(e)); + } + if let Some(e) = child(e, "threads") { + self.video_threads = parse_i32(&text(e)); + } + if let Some(e) = child(e, "pixfmt") { + set_cstr(&mut self.video_pix_fmt, &text(e)); + } + if let Some(e) = child(e, "imgseq") { + self.video_is_image_sequence = parse_bool(&text(e)) as i32; + } + if let Some(e) = child(e, "vscale") { + self.video_scaling_method = scaling_from_i32(parse_i32(&text(e))); + } + } + + if let Some(e) = child(&root, "audio") { + if let Some(v) = attr(e, "enabled") { + self.audio_enabled = parse_bool(v) as i32; + } + if let Some(e) = child(e, "codec") { + self.audio_codec = parse_i32(&text(e)); + } + if let Some(e) = child(e, "samplerate") { + self.audio_sample_rate = parse_i32(&text(e)); + } + if let Some(e) = child(e, "channellayout") { + self.audio_channel_layout = parse_i64(&text(e)) as u64; + } + if let Some(e) = child(e, "format") { + self.audio_sample_format = sample_format_from_i32(parse_i32(&text(e))); + } + if let Some(e) = child(e, "bitrate") { + self.audio_bit_rate = parse_i64(&text(e)); + } + } + + if let Some(e) = child(&root, "subtitles") { + if let Some(v) = attr(e, "enabled") { + self.subtitles_enabled = parse_bool(v) as i32; + } + if let Some(e) = child(e, "sidecar") { + self.subtitles_are_sidecar = parse_bool(&text(e)) as i32; + } + if let Some(e) = child(e, "sidecarformat") { + self.subtitles_sidecar_format = parse_i32(&text(e)); + } + if let Some(e) = child(e, "codec") { + self.subtitles_codec = parse_i32(&text(e)); + } + } + + Ok(()) + } + + /// Serialize to a compact XML string (no declaration, no indentation; + /// element/attribute names and order preserved). + /// + /// # CPP-PARITY + /// The C++ writer also emits per-codec `video_opts_`; those moved out + /// of the byte-exact `EncodingParams` POD (see `encoding_params_c_abi_layout`), + /// so the options are not serialized here. + pub fn save_to_string(&self) -> String { + let mut s = String::new(); + s.push_str(""); + s.push_str(&format!("{}", escape_xml(cstr(&self.filename)))); + s.push_str(&format!("{}", self.format)); + s.push_str(&format!("{}", self.has_custom_range)); + s.push_str(&format!( + "{}/{}", + self.custom_range_in_num, self.custom_range_in_den + )); + s.push_str(&format!( + "{}/{}", + self.custom_range_out_num, self.custom_range_out_den + )); + + s.push_str(&format!( + ""); + + s.push_str(&format!( + ""); + + s.push_str(&format!( + "", + self.subtitles_enabled + )); + if self.subtitles_enabled != 0 { + s.push_str(&format!( + "{}", + self.subtitles_are_sidecar + )); + s.push_str(&format!( + "{}", + self.subtitles_sidecar_format + )); + s.push_str(&format!( + "{}", + self.subtitles_codec + )); + } + s.push_str(""); + + s.push_str(""); + s + } +} + +// --------------------------------------------------------------------------- +// Minimal XML helpers for the round-trip `load`/`save_to_string`. +// +// CPP-PARITY: the C++ `load`/`save_to_string` go through oakcommon's +// `XmlStreamReader`/`XmlStreamWriter` (a C++-to-C++ coupling the Rust bridge +// cannot cover, NOTES.md §7). Rather than returning `Err`, this port keeps a +// minimal but faithful round-trip for the fields representable without the +// videoparams/colortransform/audio bridge. Deviations vs the C++ writer: +// * the `