Add Chromium-only Blender WebEngine parity work

blender-5.2.0/source/blender/blenkernel/BKE_movieclip.hh

@@ -0,0 +1,143 @@
+/* SPDX-FileCopyrightText: 2011 Blender Authors
+ *
+ * SPDX-License-Identifier: GPL-2.0-or-later */
+
+#pragma once
+
+/** \file
+ * \ingroup bke
+ */
+
+#include "BLI_enum_flags.hh"
+#include "DNA_movieclip_types.h"
+
+namespace blender {
+
+struct Depsgraph;
+struct ImBuf;
+struct Main;
+struct MovieDistortion;
+
+namespace gpu {
+class Texture;
+}  // namespace gpu
+
+enum class MovieClipCacheFlag {
+  None = 0,
+  SkipCache = 1 << 0,
+};
+ENUM_OPERATORS(MovieClipCacheFlag);
+
+/* Note: do not change values; DNA data #SpaceClip.postproc_flag uses this. */
+enum class MovieClipPostprocFlag {
+  None = 0,
+  DisableRed = (1 << 0),
+  DisableGreen = (1 << 1),
+  DisableBlue = (1 << 2),
+  PreviewGray = (1 << 3),
+};
+ENUM_OPERATORS(MovieClipPostprocFlag);
+
+/**
+ * Checks if image was already loaded, then returns same image otherwise creates new.
+ * does not load ibuf itself pass on optional frame for `filepath` images.
+ */
+MovieClip *BKE_movieclip_file_add(Main *bmain, const char *filepath);
+MovieClip *BKE_movieclip_file_add_exists_ex(Main *bmain, const char *filepath, bool *r_exists);
+MovieClip *BKE_movieclip_file_add_exists(Main *bmain, const char *filepath);
+void BKE_movieclip_reload(Main *bmain, MovieClip *clip);
+void BKE_movieclip_clear_cache(MovieClip *clip);
+void BKE_movieclip_clear_proxy_cache(MovieClip *clip);
+
+/**
+ * Will try to make image buffer usable when originating from the multi-layer source.
+ * Internally finds a first combined pass and uses that as a buffer.
+ * Not ideal, but is better than a complete empty buffer.
+ */
+void BKE_movieclip_convert_multilayer_ibuf(ImBuf *ibuf);
+
+ImBuf *BKE_movieclip_get_ibuf(MovieClip *clip, const MovieClipUser *user);
+ImBuf *BKE_movieclip_get_postprocessed_ibuf(MovieClip *clip,
+                                            const MovieClipUser *user,
+                                            MovieClipPostprocFlag postprocess_flag);
+ImBuf *BKE_movieclip_get_stable_ibuf(MovieClip *clip,
+                                     const MovieClipUser *user,
+                                     MovieClipPostprocFlag postprocess_flag,
+                                     float r_loc[2],
+                                     float *r_scale,
+                                     float *r_angle);
+ImBuf *BKE_movieclip_get_ibuf_flag(MovieClip *clip,
+                                   const MovieClipUser *user,
+                                   MovieClipFlag flag,
+                                   MovieClipCacheFlag cache_flag);
+void BKE_movieclip_get_size(MovieClip *clip,
+                            const MovieClipUser *user,
+                            int *r_width,
+                            int *r_height);
+void BKE_movieclip_get_size_fl(MovieClip *clip, const MovieClipUser *user, float r_size[2]);
+int BKE_movieclip_get_duration(MovieClip *clip);
+float BKE_movieclip_get_fps(MovieClip *clip);
+void BKE_movieclip_get_aspect(MovieClip *clip, float *aspx, float *aspy);
+bool BKE_movieclip_has_frame(MovieClip *clip, const MovieClipUser *user);
+void BKE_movieclip_user_set_frame(MovieClipUser *user, int framenr);
+
+void BKE_movieclip_update_scopes(MovieClip *clip,
+                                 const MovieClipUser *user,
+                                 MovieClipScopes *scopes);
+
+/**
+ * Get segments of cached frames. useful for debugging cache policies.
+ */
+void BKE_movieclip_get_cache_segments(MovieClip *clip,
+                                      const MovieClipUser *user,
+                                      int *r_totseg,
+                                      int **r_points);
+
+/**
+ * \note currently used by proxy job for movies, threading happens within single frame
+ * (meaning scaling shall be threaded).
+ */
+void BKE_movieclip_build_proxy_frame(MovieClip *clip,
+                                     MovieClipFlag clip_flag,
+                                     MovieDistortion *distortion,
+                                     int cfra,
+                                     const int *build_sizes,
+                                     int build_count,
+                                     bool undistorted);
+
+/**
+ * \note currently used by proxy job for sequences, threading happens within sequence
+ * (different threads handles different frames, no threading within frame is needed)
+ */
+void BKE_movieclip_build_proxy_frame_for_ibuf(MovieClip *clip,
+                                              ImBuf *ibuf,
+                                              MovieDistortion *distortion,
+                                              int cfra,
+                                              const int *build_sizes,
+                                              int build_count,
+                                              bool undistorted);
+bool BKE_movieclip_proxy_enabled(MovieClip *clip);
+
+float BKE_movieclip_remap_scene_to_clip_frame(const MovieClip *clip, float framenr);
+float BKE_movieclip_remap_clip_to_scene_frame(const MovieClip *clip, float framenr);
+
+void BKE_movieclip_filepath_for_frame(MovieClip *clip, const MovieClipUser *user, char *filepath);
+
+/**
+ * Read image buffer from the given movie clip without acquiring the #LOCK_MOVIECLIP lock.
+ * Used by a prefetch job which takes care of creating a local copy of the clip.
+ */
+ImBuf *BKE_movieclip_anim_ibuf_for_frame_no_lock(MovieClip *clip, const MovieClipUser *user);
+
+bool BKE_movieclip_has_cached_frame(MovieClip *clip, const MovieClipUser *user);
+bool BKE_movieclip_put_frame_if_possible(MovieClip *clip, const MovieClipUser *user, ImBuf *ibuf);
+
+gpu::Texture *BKE_movieclip_get_gpu_texture(MovieClip *clip, MovieClipUser *cuser);
+
+void BKE_movieclip_free_gputexture(MovieClip *clip);
+
+/* Dependency graph evaluation. */
+
+void BKE_movieclip_eval_update(Depsgraph *depsgraph, Main *bmain, MovieClip *clip);
+
+}  // namespace blender