Blender  V3.3
utils.c
Go to the documentation of this file.
1 /* SPDX-License-Identifier: GPL-2.0-or-later
2  * Copyright 2001-2002 NaN Holding BV. All rights reserved.
3  * 2003-2009 Blender Foundation.
4  * 2005-2006 Peter Schlaile <peter [at] schlaile [dot] de> */
5 
10 #include <stdlib.h>
11 #include <string.h>
12 
13 #include "MEM_guardedalloc.h"
14 
15 #include "DNA_mask_types.h"
16 #include "DNA_scene_types.h"
17 #include "DNA_sequence_types.h"
18 
19 #include "BLI_blenlib.h"
20 
21 #include "BKE_animsys.h"
22 #include "BKE_image.h"
23 #include "BKE_main.h"
24 #include "BKE_scene.h"
25 
26 #include "SEQ_animation.h"
27 #include "SEQ_channels.h"
28 #include "SEQ_edit.h"
29 #include "SEQ_iterator.h"
30 #include "SEQ_relations.h"
31 #include "SEQ_render.h"
32 #include "SEQ_select.h"
33 #include "SEQ_sequencer.h"
34 #include "SEQ_time.h"
35 #include "SEQ_utils.h"
36 
37 #include "IMB_imbuf.h"
38 #include "IMB_imbuf_types.h"
39 
40 #include "multiview.h"
41 #include "proxy.h"
42 #include "sequencer.h"
43 #include "utils.h"
44 
45 typedef struct SeqUniqueInfo {
49  int count;
50  int match;
52 
53 static void seqbase_unique_name(ListBase *seqbasep, SeqUniqueInfo *sui)
54 {
55  Sequence *seq;
56  for (seq = seqbasep->first; seq; seq = seq->next) {
57  if ((sui->seq != seq) && STREQ(sui->name_dest, seq->name + 2)) {
58  /* SEQ_NAME_MAXSTR -4 for the number, -1 for \0, - 2 for r_prefix */
60  sizeof(sui->name_dest),
61  "%.*s.%03d",
62  SEQ_NAME_MAXSTR - 4 - 1 - 2,
63  sui->name_src,
64  sui->count++);
65  sui->match = 1; /* be sure to re-scan */
66  }
67  }
68 }
69 
70 static bool seqbase_unique_name_recursive_fn(Sequence *seq, void *arg_pt)
71 {
72  if (seq->seqbase.first) {
73  seqbase_unique_name(&seq->seqbase, (SeqUniqueInfo *)arg_pt);
74  }
75  return true;
76 }
77 
79  ListBase *seqbasep,
80  Sequence *seq)
81 {
82  SeqUniqueInfo sui;
83  char *dot;
84  sui.seq = seq;
85  BLI_strncpy(sui.name_src, seq->name + 2, sizeof(sui.name_src));
86  BLI_strncpy(sui.name_dest, seq->name + 2, sizeof(sui.name_dest));
87 
88  sui.count = 1;
89  sui.match = 1; /* assume the worst to start the loop */
90 
91  /* Strip off the suffix */
92  if ((dot = strrchr(sui.name_src, '.'))) {
93  *dot = '\0';
94  dot++;
95 
96  if (*dot) {
97  sui.count = atoi(dot) + 1;
98  }
99  }
100 
101  while (sui.match) {
102  sui.match = 0;
103  seqbase_unique_name(seqbasep, &sui);
105  }
106 
108 }
109 
110 static const char *give_seqname_by_type(int type)
111 {
112  switch (type) {
113  case SEQ_TYPE_META:
114  return "Meta";
115  case SEQ_TYPE_IMAGE:
116  return "Image";
117  case SEQ_TYPE_SCENE:
118  return "Scene";
119  case SEQ_TYPE_MOVIE:
120  return "Movie";
121  case SEQ_TYPE_MOVIECLIP:
122  return "Clip";
123  case SEQ_TYPE_MASK:
124  return "Mask";
125  case SEQ_TYPE_SOUND_RAM:
126  return "Audio";
127  case SEQ_TYPE_CROSS:
128  return "Cross";
129  case SEQ_TYPE_GAMCROSS:
130  return "Gamma Cross";
131  case SEQ_TYPE_ADD:
132  return "Add";
133  case SEQ_TYPE_SUB:
134  return "Sub";
135  case SEQ_TYPE_MUL:
136  return "Mul";
137  case SEQ_TYPE_ALPHAOVER:
138  return "Alpha Over";
139  case SEQ_TYPE_ALPHAUNDER:
140  return "Alpha Under";
141  case SEQ_TYPE_OVERDROP:
142  return "Over Drop";
143  case SEQ_TYPE_COLORMIX:
144  return "Color Mix";
145  case SEQ_TYPE_WIPE:
146  return "Wipe";
147  case SEQ_TYPE_GLOW:
148  return "Glow";
149  case SEQ_TYPE_TRANSFORM:
150  return "Transform";
151  case SEQ_TYPE_COLOR:
152  return "Color";
153  case SEQ_TYPE_MULTICAM:
154  return "Multicam";
155  case SEQ_TYPE_ADJUSTMENT:
156  return "Adjustment";
157  case SEQ_TYPE_SPEED:
158  return "Speed";
160  return "Gaussian Blur";
161  case SEQ_TYPE_TEXT:
162  return "Text";
163  default:
164  return NULL;
165  }
166 }
167 
169 {
170  const char *name = give_seqname_by_type(seq->type);
171 
172  if (!name) {
173  if (!(seq->type & SEQ_TYPE_EFFECT)) {
174  return seq->strip->dir;
175  }
176 
177  return "Effect";
178  }
179  return name;
180 }
181 
182 ListBase *SEQ_get_seqbase_from_sequence(Sequence *seq, ListBase **r_channels, int *r_offset)
183 {
184  ListBase *seqbase = NULL;
185 
186  switch (seq->type) {
187  case SEQ_TYPE_META: {
188  seqbase = &seq->seqbase;
189  *r_channels = &seq->channels;
190  *r_offset = SEQ_time_start_frame_get(seq);
191  break;
192  }
193  case SEQ_TYPE_SCENE: {
194  if (seq->flag & SEQ_SCENE_STRIPS && seq->scene) {
195  Editing *ed = SEQ_editing_get(seq->scene);
196  if (ed) {
197  seqbase = &ed->seqbase;
198  *r_channels = &ed->channels;
199  *r_offset = seq->scene->r.sfra;
200  }
201  }
202  break;
203  }
204  }
205 
206  return seqbase;
207 }
208 
209 void seq_open_anim_file(Scene *scene, Sequence *seq, bool openfile)
210 {
211  char dir[FILE_MAX];
212  char name[FILE_MAX];
213  StripProxy *proxy;
214  bool use_proxy;
215  bool is_multiview_loaded = false;
216  Editing *ed = scene->ed;
217  const bool is_multiview = (seq->flag & SEQ_USE_VIEWS) != 0 &&
218  (scene->r.scemode & R_MULTIVIEW) != 0;
219 
220  if ((seq->anims.first != NULL) && (((StripAnim *)seq->anims.first)->anim != NULL) && !openfile) {
221  return;
222  }
223 
224  /* reset all the previously created anims */
226 
227  BLI_join_dirfile(name, sizeof(name), seq->strip->dir, seq->strip->stripdata->name);
229 
230  proxy = seq->strip->proxy;
231 
232  use_proxy = proxy && ((proxy->storage & SEQ_STORAGE_PROXY_CUSTOM_DIR) != 0 ||
234 
235  if (use_proxy) {
237  if (ed->proxy_dir[0] == 0) {
238  BLI_strncpy(dir, "//BL_proxy", sizeof(dir));
239  }
240  else {
241  BLI_strncpy(dir, ed->proxy_dir, sizeof(dir));
242  }
243  }
244  else {
245  BLI_strncpy(dir, seq->strip->proxy->dir, sizeof(dir));
246  }
248  }
249 
250  if (is_multiview && seq->views_format == R_IMF_VIEWS_INDIVIDUAL) {
251  int totfiles = seq_num_files(scene, seq->views_format, true);
252  char prefix[FILE_MAX];
253  const char *ext = NULL;
254  int i;
255 
256  BKE_scene_multiview_view_prefix_get(scene, name, prefix, &ext);
257 
258  if (prefix[0] != '\0') {
259  for (i = 0; i < totfiles; i++) {
260  const char *suffix = BKE_scene_multiview_view_id_suffix_get(&scene->r, i);
261  char str[FILE_MAX];
262  StripAnim *sanim = MEM_mallocN(sizeof(StripAnim), "Strip Anim");
263 
264  BLI_addtail(&seq->anims, sanim);
265 
266  BLI_snprintf(str, sizeof(str), "%s%s%s", prefix, suffix, ext);
267 
268  if (openfile) {
269  sanim->anim = openanim(str,
270  IB_rect | ((seq->flag & SEQ_FILTERY) ? IB_animdeinterlace : 0),
271  seq->streamindex,
273  }
274  else {
275  sanim->anim = openanim_noload(str,
276  IB_rect |
277  ((seq->flag & SEQ_FILTERY) ? IB_animdeinterlace : 0),
278  seq->streamindex,
280  }
281 
282  if (sanim->anim) {
283  /* we already have the suffix */
284  IMB_suffix_anim(sanim->anim, suffix);
285  }
286  else {
287  if (openfile) {
288  sanim->anim = openanim(name,
289  IB_rect | ((seq->flag & SEQ_FILTERY) ? IB_animdeinterlace : 0),
290  seq->streamindex,
292  }
293  else {
294  sanim->anim = openanim_noload(name,
295  IB_rect |
296  ((seq->flag & SEQ_FILTERY) ? IB_animdeinterlace : 0),
297  seq->streamindex,
299  }
300 
301  /* No individual view files - monoscopic, stereo 3d or EXR multi-view. */
302  totfiles = 1;
303  }
304 
305  if (sanim->anim && use_proxy) {
306  seq_proxy_index_dir_set(sanim->anim, dir);
307  }
308  }
309  is_multiview_loaded = true;
310  }
311  }
312 
313  if (is_multiview_loaded == false) {
314  StripAnim *sanim;
315 
316  sanim = MEM_mallocN(sizeof(StripAnim), "Strip Anim");
317  BLI_addtail(&seq->anims, sanim);
318 
319  if (openfile) {
320  sanim->anim = openanim(name,
321  IB_rect | ((seq->flag & SEQ_FILTERY) ? IB_animdeinterlace : 0),
322  seq->streamindex,
324  }
325  else {
326  sanim->anim = openanim_noload(name,
327  IB_rect | ((seq->flag & SEQ_FILTERY) ? IB_animdeinterlace : 0),
328  seq->streamindex,
330  }
331 
332  if (sanim->anim && use_proxy) {
333  seq_proxy_index_dir_set(sanim->anim, dir);
334  }
335  }
336 }
337 
338 const Sequence *SEQ_get_topmost_sequence(const Scene *scene, int frame)
339 {
340  Editing *ed = scene->ed;
341 
342  if (!ed) {
343  return NULL;
344  }
345 
347  const Sequence *seq, *best_seq = NULL;
348  int best_machine = -1;
349 
350  for (seq = ed->seqbasep->first; seq; seq = seq->next) {
351  if (SEQ_render_is_muted(channels, seq) ||
352  !SEQ_time_strip_intersects_frame(scene, seq, frame)) {
353  continue;
354  }
355  /* Only use strips that generate an image, not ones that combine
356  * other strips or apply some effect. */
357  if (ELEM(seq->type,
363  SEQ_TYPE_TEXT)) {
364  if (seq->machine > best_machine) {
365  best_seq = seq;
366  best_machine = seq->machine;
367  }
368  }
369  }
370  return best_seq;
371 }
372 
374 {
376  ListBase *main_seqbase = &ed->seqbase;
378 
379  if (seq_meta != NULL) {
380  return &seq_meta->seqbase;
381  }
382  if (BLI_findindex(main_seqbase, seq) >= 0) {
383  return main_seqbase;
384  }
385  return NULL;
386 }
387 
388 Sequence *SEQ_get_meta_by_seqbase(ListBase *seqbase_main, ListBase *meta_seqbase)
389 {
390  SeqCollection *strips = SEQ_query_all_strips_recursive(seqbase_main);
391 
392  Sequence *seq = NULL;
393  SEQ_ITERATOR_FOREACH (seq, strips) {
394  if (seq->type == SEQ_TYPE_META && &seq->seqbase == meta_seqbase) {
395  break;
396  }
397  }
398 
399  SEQ_collection_free(strips);
400  return seq;
401 }
402 
404 {
405  Sequence *iseq;
406 
407  for (iseq = seqbase->first; iseq; iseq = iseq->next) {
408  Sequence *seq_found;
409  if ((iseq->strip && iseq->strip->stripdata) &&
410  (ARRAY_HAS_ITEM(se, iseq->strip->stripdata, iseq->len))) {
411  break;
412  }
413  if ((seq_found = SEQ_sequence_from_strip_elem(&iseq->seqbase, se))) {
414  iseq = seq_found;
415  break;
416  }
417  }
418 
419  return iseq;
420 }
421 
422 Sequence *SEQ_get_sequence_by_name(ListBase *seqbase, const char *name, bool recursive)
423 {
424  Sequence *iseq = NULL;
425  Sequence *rseq = NULL;
426 
427  for (iseq = seqbase->first; iseq; iseq = iseq->next) {
428  if (STREQ(name, iseq->name + 2)) {
429  return iseq;
430  }
431  if (recursive && (iseq->seqbase.first) &&
432  (rseq = SEQ_get_sequence_by_name(&iseq->seqbase, name, 1))) {
433  return rseq;
434  }
435  }
436 
437  return NULL;
438 }
439 
441 {
443 
444  if (seq_act && seq_act->type == SEQ_TYPE_MASK) {
445  return seq_act->mask;
446  }
447 
448  return NULL;
449 }
450 
452 {
453  if (seq->strip && seq->strip->stripdata) {
454  const char *filename = seq->strip->stripdata->name;
456  }
457 }
458 
460 {
461  /* Called on draw, needs to be fast,
462  * we could cache and use a flag if we want to make checks for file paths resolving for eg. */
463  switch (seq->type) {
464  case SEQ_TYPE_MASK:
465  return (seq->mask != NULL);
466  case SEQ_TYPE_MOVIECLIP:
467  return (seq->clip != NULL);
468  case SEQ_TYPE_SCENE:
469  return (seq->scene != NULL);
470  case SEQ_TYPE_SOUND_RAM:
471  return (seq->sound != NULL);
472  }
473 
474  return true;
475 }
476 
478 {
479  switch (seq->type) {
480  case SEQ_TYPE_IMAGE:
481  case SEQ_TYPE_SCENE:
482  case SEQ_TYPE_MOVIE:
483  case SEQ_TYPE_MOVIECLIP:
484  case SEQ_TYPE_MASK:
485  case SEQ_TYPE_COLOR:
486  case SEQ_TYPE_TEXT:
487  return true;
488  }
489  return false;
490 }
491 
493  const int image_width,
494  const int image_height,
495  const int preview_width,
496  const int preview_height,
497  const eSeqImageFitMethod fit_method)
498 {
500 
501  switch (fit_method) {
502  case SEQ_SCALE_TO_FIT:
503  transform->scale_x = transform->scale_y = MIN2((float)preview_width / (float)image_width,
504  (float)preview_height / (float)image_height);
505 
506  break;
507  case SEQ_SCALE_TO_FILL:
508 
509  transform->scale_x = transform->scale_y = MAX2((float)preview_width / (float)image_width,
510  (float)preview_height / (float)image_height);
511  break;
512  case SEQ_STRETCH_TO_FILL:
513  transform->scale_x = (float)preview_width / (float)image_width;
514  transform->scale_y = (float)preview_height / (float)image_height;
515  break;
517  transform->scale_x = 1.0f;
518  transform->scale_y = 1.0f;
519  break;
520  }
521 }
522 
524 {
525  char name[SEQ_NAME_MAXSTR];
526 
527  BLI_strncpy_utf8(name, seq->name + 2, sizeof(name));
530  &scene->id, scene->adt, NULL, "sequence_editor.sequences_all", name, seq->name + 2, 0, 0, 0);
531 
532  if (seq->type == SEQ_TYPE_META) {
533  LISTBASE_FOREACH (Sequence *, seq_child, &seq->seqbase) {
534  SEQ_ensure_unique_name(seq_child, scene);
535  }
536  }
537 }
typedef float(TangentPoint)[2]
void BKE_animdata_fix_paths_rename(struct ID *owner_id, struct AnimData *adt, struct ID *ref_id, const char *prefix, const char *oldName, const char *newName, int oldSubscript, int newSubscript, bool verify_paths)
Definition: anim_data.c:958
struct anim * openanim_noload(const char *name, int flags, int streamindex, char colorspace[IMA_MAX_SPACE])
struct anim * openanim(const char *name, int flags, int streamindex, char colorspace[IMA_MAX_SPACE])
char BKE_image_alpha_mode_from_extension_ex(const char *filepath)
const char * BKE_main_blendfile_path_from_global(void)
Definition: main.c:562
void BKE_scene_multiview_view_prefix_get(struct Scene *scene, const char *name, char *r_prefix, const char **r_ext)
Definition: scene.cc:3233
const char * BKE_scene_multiview_view_id_suffix_get(const struct RenderData *rd, int view_id)
#define LISTBASE_FOREACH(type, var, list)
Definition: BLI_listbase.h:336
void BLI_addtail(struct ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition: listbase.c:80
int BLI_findindex(const struct ListBase *listbase, const void *vlink) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
#define FILE_MAX
bool BLI_path_abs(char *path, const char *basepath) ATTR_NONNULL()
Definition: path_util.c:897
void BLI_join_dirfile(char *__restrict dst, size_t maxlen, const char *__restrict dir, const char *__restrict file) ATTR_NONNULL()
Definition: path_util.c:1531
char * BLI_strncpy(char *__restrict dst, const char *__restrict src, size_t maxncpy) ATTR_NONNULL()
Definition: string.c:64
size_t BLI_snprintf(char *__restrict dst, size_t maxncpy, const char *__restrict format,...) ATTR_NONNULL(1
char * BLI_strncpy_utf8(char *__restrict dst, const char *__restrict src, size_t maxncpy) ATTR_NONNULL(1
#define ARRAY_HAS_ITEM(arr_item, arr_start, arr_len)
#define MAX2(a, b)
#define ELEM(...)
#define MIN2(a, b)
#define STREQ(a, b)
#define R_MULTIVIEW
@ R_IMF_VIEWS_INDIVIDUAL
eSeqImageFitMethod
@ SEQ_SCALE_TO_FILL
@ SEQ_STRETCH_TO_FILL
@ SEQ_USE_ORIGINAL_SIZE
@ SEQ_SCALE_TO_FIT
@ SEQ_TYPE_TRANSFORM
@ SEQ_TYPE_SOUND_RAM
@ SEQ_TYPE_CROSS
@ SEQ_TYPE_GLOW
@ SEQ_TYPE_COLORMIX
@ SEQ_TYPE_WIPE
@ SEQ_TYPE_META
@ SEQ_TYPE_OVERDROP
@ SEQ_TYPE_ALPHAUNDER
@ SEQ_TYPE_SCENE
@ SEQ_TYPE_GAMCROSS
@ SEQ_TYPE_MULTICAM
@ SEQ_TYPE_MOVIECLIP
@ SEQ_TYPE_MUL
@ SEQ_TYPE_GAUSSIAN_BLUR
@ SEQ_TYPE_ADD
@ SEQ_TYPE_ALPHAOVER
@ SEQ_TYPE_TEXT
@ SEQ_TYPE_IMAGE
@ SEQ_TYPE_SUB
@ SEQ_TYPE_SPEED
@ SEQ_TYPE_COLOR
@ SEQ_TYPE_EFFECT
@ SEQ_TYPE_MOVIE
@ SEQ_TYPE_MASK
@ SEQ_TYPE_ADJUSTMENT
#define SEQ_NAME_MAXSTR
@ SEQ_STORAGE_PROXY_CUSTOM_DIR
@ SEQ_FILTERY
@ SEQ_SCENE_STRIPS
@ SEQ_USE_VIEWS
#define SEQ_EDIT_PROXY_DIR_STORAGE
_GL_VOID GLfloat value _GL_VOID_RET _GL_VOID const GLuint GLboolean *residences _GL_BOOL_RET _GL_VOID GLsizei GLfloat GLfloat GLfloat GLfloat const GLubyte *bitmap _GL_VOID_RET _GL_VOID GLenum type
void IMB_suffix_anim(struct anim *anim, const char *suffix)
Definition: anim_movie.c:314
Contains defines and structs used throughout the imbuf module.
@ IB_animdeinterlace
@ IB_rect
Read Guarded memory(de)allocation.
Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum Vector Perform vector math operation Invert a producing a negative Combine Generate a color from its and blue channels(Deprecated)") DefNode(ShaderNode
#define SEQ_ITERATOR_FOREACH(var, collection)
Definition: SEQ_iterator.h:35
SIMD_FORCE_INLINE btVector3 transform(const btVector3 &point) const
ListBase * SEQ_channels_displayed_get(Editing *ed)
Definition: channels.c:23
Scene scene
#define str(s)
SeqCollection * SEQ_query_all_strips_recursive(ListBase *seqbase)
Definition: iterator.c:194
void SEQ_collection_free(SeqCollection *collection)
Definition: iterator.c:81
void SEQ_for_each_callback(ListBase *seqbase, SeqForEachFunc callback, void *user_data)
Definition: iterator.c:76
void *(* MEM_mallocN)(size_t len, const char *str)
Definition: mallocn.c:33
int seq_num_files(Scene *scene, char views_format, const bool is_multiview)
Definition: multiview.c:26
T dot(const vec_base< T, Size > &a, const vec_base< T, Size > &b)
void seq_proxy_index_dir_set(struct anim *anim, const char *base_dir)
Definition: proxy.c:584
bool SEQ_render_is_muted(const ListBase *channels, const Sequence *seq)
Definition: render.c:2199
Sequence * seq_sequence_lookup_meta_by_seq(const Scene *scene, const Sequence *key)
Editing * SEQ_editing_get(const Scene *scene)
Definition: sequencer.c:241
void SEQ_edit_sequence_name_set(Scene *scene, Sequence *seq, const char *new_name)
Definition: strip_edit.c:516
void SEQ_relations_sequence_free_anim(Sequence *seq)
Sequence * SEQ_select_active_get(Scene *scene)
Definition: strip_select.c:18
bool SEQ_time_strip_intersects_frame(const Scene *scene, const Sequence *seq, const int timeline_frame)
Definition: strip_time.c:437
float SEQ_time_start_frame_get(const Sequence *seq)
Definition: strip_time.c:494
ListBase seqbase
ListBase * seqbasep
ListBase channels
char proxy_dir[1024]
void * first
Definition: DNA_listBase.h:31
struct Editing * ed
struct RenderData r
struct AnimData * adt
char name_dest[SEQ_NAME_MAXSTR]
Definition: utils.c:48
int match
Definition: utils.c:50
char name_src[SEQ_NAME_MAXSTR]
Definition: utils.c:47
Sequence * seq
Definition: utils.c:46
int count
Definition: utils.c:49
struct MovieClip * clip
struct Scene * scene
ListBase anims
struct Mask * mask
ListBase channels
ListBase seqbase
struct bSound * sound
struct Sequence * next
struct anim * anim
char name[256]
ColorManagedColorspaceSettings colorspace_settings
StripProxy * proxy
StripTransform * transform
StripElem * stripdata
char dir[768]
bool sequencer_seq_generates_image(Sequence *seq)
Definition: utils.c:477
Sequence * SEQ_get_meta_by_seqbase(ListBase *seqbase_main, ListBase *meta_seqbase)
Definition: utils.c:388
const Sequence * SEQ_get_topmost_sequence(const Scene *scene, int frame)
Definition: utils.c:338
const char * SEQ_sequence_give_name(Sequence *seq)
Definition: utils.c:168
Mask * SEQ_active_mask_get(Scene *scene)
Definition: utils.c:440
ListBase * SEQ_get_seqbase_from_sequence(Sequence *seq, ListBase **r_channels, int *r_offset)
Definition: utils.c:182
bool SEQ_sequence_has_source(const Sequence *seq)
Definition: utils.c:459
static void seqbase_unique_name(ListBase *seqbasep, SeqUniqueInfo *sui)
Definition: utils.c:53
ListBase * SEQ_get_seqbase_by_seq(const Scene *scene, Sequence *seq)
Definition: utils.c:373
void seq_open_anim_file(Scene *scene, Sequence *seq, bool openfile)
Definition: utils.c:209
void SEQ_alpha_mode_from_file_extension(Sequence *seq)
Definition: utils.c:451
struct SeqUniqueInfo SeqUniqueInfo
void SEQ_set_scale_to_fit(const Sequence *seq, const int image_width, const int image_height, const int preview_width, const int preview_height, const eSeqImageFitMethod fit_method)
Definition: utils.c:492
void SEQ_sequence_base_unique_name_recursive(struct Scene *scene, ListBase *seqbasep, Sequence *seq)
Definition: utils.c:78
static bool seqbase_unique_name_recursive_fn(Sequence *seq, void *arg_pt)
Definition: utils.c:70
void SEQ_ensure_unique_name(Sequence *seq, Scene *scene)
Definition: utils.c:523
Sequence * SEQ_get_sequence_by_name(ListBase *seqbase, const char *name, bool recursive)
Definition: utils.c:422
static const char * give_seqname_by_type(int type)
Definition: utils.c:110
Sequence * SEQ_sequence_from_strip_elem(ListBase *seqbase, StripElem *se)
Definition: utils.c:403