Blender V5.3
strip_retiming.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2022 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#include <algorithm>
10
11#include "MEM_guardedalloc.h"
12
13#include "DNA_scene_types.h"
14#include "DNA_sequence_types.h"
15
16#include "BLI_bounds.hh"
17#include "BLI_listbase.hh"
18#include "BLI_map.hh"
19#include "BLI_math_geom_c.hh"
20#include "BLI_math_vector_c.hh"
22#include "BLI_span.hh"
23#include "BLI_vector.hh"
24
25#include "BKE_report.hh"
26#include "BKE_scene.hh"
27#include "BKE_sound.hh"
28
29#include "SEQ_iterator.hh"
30#include "SEQ_relations.hh"
31#include "SEQ_retiming.hh"
32#include "SEQ_sequencer.hh"
33#include "SEQ_time.hh"
34#include "SEQ_transform.hh"
35
36#include "sequencer.hh"
37#include "strip_time.hh"
38
39namespace blender::seq {
40
41/* -------------------------------------------------------------------- */
44
46{
47 MutableSpan<SeqRetimingKey> handles(strip->retiming_keys, strip->retiming_keys_num);
48 return handles;
49}
50
51bool retiming_is_last_key(const Strip *strip, const SeqRetimingKey *key)
52{
53 return retiming_key_index_get(strip, key) == strip->retiming_keys_num - 1;
54}
55
57{
58 return strip->retiming_keys + strip->retiming_keys_num - 1;
59}
60
61int left_fake_key_frame_get(const Scene *scene, const Strip *strip)
62{
63 const float scene_fps = float(scene->frames_per_second());
64 const int sound_offset = strip->rounded_sound_offset(scene_fps);
65 const int content_start = strip->content_start() + sound_offset;
66 return max_ii(content_start, strip->left_handle());
67}
68
69int right_fake_key_frame_get(const Scene *scene, const Strip *strip)
70{
71 const float scene_fps = float(scene->frames_per_second());
72 const int sound_offset = strip->rounded_sound_offset(scene_fps);
73 const int content_end = strip->content_end(scene) + sound_offset;
74 return min_ii(content_end, strip->right_handle(scene));
75}
76
77int retiming_key_index_get(const Strip *strip, const SeqRetimingKey *key)
78{
79 return key - strip->retiming_keys;
80}
81
82static int content_frame_index_get(const Scene *scene, const Strip *strip, const int frame)
83{
84 const float scene_fps = float(scene->frames_per_second());
85 const int sound_offset = strip->rounded_sound_offset(scene_fps);
86 return (frame - strip->content_start() - sound_offset) *
87 strip->media_playback_rate_factor(scene_fps);
88}
89
90SeqRetimingKey *retiming_key_get_by_frame(const Scene *scene, const Strip *strip, const int frame)
91{
92 for (auto &key : retiming_keys_get(strip)) {
93 const int key_frame = retiming_key_frame_get(scene, strip, &key);
94 if (key_frame == frame) {
95 return &key;
96 }
97 }
98
99 return nullptr;
100}
101
102SeqRetimingKey *retiming_find_segment_start_key(const Strip *strip, float frame_index)
103{
104 SeqRetimingKey *start_key = nullptr;
105 for (auto &key : retiming_keys_get(strip)) {
106 if (retiming_is_last_key(strip, &key)) {
107 break;
108 }
109 if (key.strip_frame_index > frame_index) {
110 break;
111 }
112
113 start_key = &key;
114 }
115
116 return start_key;
117}
118
119int retiming_keys_count(const Strip *strip)
120{
121 return strip->retiming_keys_num;
122}
123
124bool retiming_show_keys(const Strip *strip)
125{
126 return strip->flag & SEQ_SHOW_RETIMING;
127}
128
130{
131 if (!scene) {
132 return false;
133 }
134
135 Editing *ed = seq::editing_get(scene);
136 if (!ed) {
137 return false;
138 }
139
140 const Map retiming_sel = seq::retiming_selection_get(ed);
141 if (retiming_sel.is_empty()) {
142 return false;
143 }
144
145 for (const Strip *strip : retiming_sel.values()) {
146 if (seq::retiming_show_keys(strip)) {
147 return true;
148 }
149 }
150
151 return false;
152}
153
154bool retiming_is_allowed(const Strip *strip)
155{
156 /* Note that this disallows non-sequence image strips. */
157 if (strip->content_length() <= 1) {
158 return false;
159 }
160
161 return ELEM(strip->type,
169}
170
171bool retiming_has_keys(const Strip *strip)
172{
173 /* Technically all strips must have at least 2 keys, but we can assume none violate this. */
174 return strip->retiming_keys_num > 0;
175}
176
178 const Strip *strip,
179 SeqRetimingKey *key)
180{
181 Bounds<float> max_tml_frame_offset = {MINAFRAMEF, MAXFRAMEF};
182
183 if (key->strip_frame_index != 0) {
184 SeqRetimingKey *prev_key = key - 1;
185 max_tml_frame_offset.min = retiming_key_frame_get(scene, strip, prev_key) -
186 retiming_key_frame_get(scene, strip, key);
187 }
188 if (!retiming_is_last_key(strip, key)) {
189 SeqRetimingKey *next_key = key + 1;
190 max_tml_frame_offset.max = retiming_key_frame_get(scene, strip, next_key) -
191 retiming_key_frame_get(scene, strip, key);
192 }
193 return max_tml_frame_offset;
194}
195
196int retiming_key_frame_get(const Scene *scene, const Strip *strip, const SeqRetimingKey *key)
197{
198 const float scene_fps = float(scene->frames_per_second());
199 const int sound_offset = strip->rounded_sound_offset(scene_fps);
200 return round_fl_to_int(strip->content_start() + sound_offset +
201 key->strip_frame_index / strip->media_playback_rate_factor(scene_fps));
202}
203
204float retiming_key_speed_get(const Strip *strip, const SeqRetimingKey *key)
205{
206 if (key->strip_frame_index == 0) {
207 return 1.0f;
208 }
209
210 BLI_assert(retiming_key_index_get(strip, key) > 0);
211 const SeqRetimingKey *key_prev = key - 1;
212 const int frame_index_max = strip->content_length();
213 const float frame_index_start = round_fl_to_int(key_prev->retiming_factor * frame_index_max);
214 const float frame_index_end = round_fl_to_int(key->retiming_factor * frame_index_max);
215 const float segment_content_frame_count = frame_index_end - frame_index_start;
216 const float segment_length = key->strip_frame_index - key_prev->strip_frame_index;
217 const float speed = segment_content_frame_count / segment_length;
218 return speed;
219}
220
221static std::optional<float> retiming_key_new_frame_from_speed_get(const Scene *scene,
222 Strip *strip,
223 SeqRetimingKey *key,
224 const float speed)
225{
226 if (key->strip_frame_index == 0) {
227 return std::nullopt;
228 }
229
230 const SeqRetimingKey *key_prev = key - 1;
231
232 const int frame_index_max = strip->content_length();
233 const float frame_index_prev = round_fl_to_int(key_prev->retiming_factor * frame_index_max);
234 const float frame_index = round_fl_to_int(key->retiming_factor * frame_index_max);
235
236 const float scene_fps = float(scene->frames_per_second());
237 const float segment_duration = (frame_index - frame_index_prev) /
238 strip->media_playback_rate_factor(scene_fps);
239 const float new_duration = segment_duration / speed;
240
241 return std::round(retiming_key_frame_get(scene, strip, key_prev) + new_duration);
242}
243
245 Strip *strip,
246 SeqRetimingKey *key,
247 const float speed)
248{
249 const std::optional<int> new_frame = retiming_key_new_frame_from_speed_get(
250 scene, strip, key, speed);
251 if (!new_frame) {
252 return;
253 }
254
255 retiming_key_frame_set(scene, strip, key, *new_frame);
256}
257
259
260/* -------------------------------------------------------------------- */
263
265{
266 return (key->flag & SEQ_FREEZE_FRAME_IN) != 0 || (key->flag & SEQ_FREEZE_FRAME_OUT) != 0;
267}
268
269/* Create pair of retiming keys separated by offset. */
270static std::pair<SeqRetimingKey *, SeqRetimingKey *> freeze_key_pair_create(const Scene *scene,
271 Strip *strip,
272 SeqRetimingKey *key,
273 const int offset)
274{
275
276 Bounds<float> max_offset = strip_retiming_clamp_bounds_get(scene, strip, key);
277 const float tml_frame_offset = math::clamp(float(offset), max_offset.min, max_offset.max);
278 const int orig_frame = retiming_key_frame_get(scene, strip, key);
279
280 /* Offset last key first, then add a freeze start key before it, because it is not possible to
281 * add keys after last one. */
282 if (retiming_is_last_key(strip, key)) {
283 const float scene_fps = float(scene->frames_per_second());
284 const float frame_index_offset = tml_frame_offset *
285 strip->media_playback_rate_factor(scene_fps);
286 key->strip_frame_index += frame_index_offset;
287 SeqRetimingKey *freeze_start = retiming_add_key(scene, strip, orig_frame);
288
289 if (freeze_start == nullptr) {
290 key->strip_frame_index -= frame_index_offset;
291 return {nullptr, nullptr};
292 }
293 return {freeze_start, freeze_start + 1};
294 }
295
296 SeqRetimingKey *freeze_end = retiming_add_key(scene, strip, orig_frame + tml_frame_offset);
297
298 if (freeze_end == nullptr) {
299 return {nullptr, nullptr};
300 }
301
302 return {freeze_end - 1, freeze_end};
303}
304
305/* This function tags previous key as freeze frame key. This is only a convenient way to prevent
306 * creating speed transitions. When freeze frame is deleted, this flag should be cleared. */
308 Strip *strip,
309 SeqRetimingKey *key,
310 const int offset)
311{
313 return nullptr;
314 }
315
316 const float orig_retiming_factor = key->retiming_factor;
317 std::pair<SeqRetimingKey *, SeqRetimingKey *> freeze_keys = freeze_key_pair_create(
318 scene, strip, key, offset);
319
320 if (freeze_keys.first == nullptr) {
321 return nullptr;
322 }
323
324 freeze_keys.first->flag |= SEQ_FREEZE_FRAME_IN;
325 freeze_keys.second->flag |= SEQ_FREEZE_FRAME_OUT;
326 freeze_keys.first->retiming_factor = orig_retiming_factor;
327 freeze_keys.second->retiming_factor = orig_retiming_factor;
328 return freeze_keys.second;
329}
330
332{
333 if ((key->flag & SEQ_FREEZE_FRAME_IN) != 0) {
334 SeqRetimingKey *next_key = key + 1;
336 next_key->flag &= ~SEQ_FREEZE_FRAME_OUT;
337 }
338 if ((key->flag & SEQ_FREEZE_FRAME_OUT) != 0) {
339 SeqRetimingKey *previous_key = key - 1;
341 previous_key->flag &= ~SEQ_FREEZE_FRAME_IN;
342 }
343}
344
346
347/* -------------------------------------------------------------------- */
350
352{
353 if (!retiming_is_allowed(strip)) {
354 return;
355 }
356
357 if (retiming_has_keys(strip)) {
358 return;
359 }
360
361 strip->retiming_keys = MEM_new_array<SeqRetimingKey>(2, __func__);
362 SeqRetimingKey *key = strip->retiming_keys + 1;
363 key->strip_frame_index = strip->content_length();
364 key->retiming_factor = 1.0f;
365 strip->retiming_keys_num = 2;
366}
367
369{
371 seq::retiming_add_key(scene, strip, left_fake_key_frame_get(scene, strip));
372 return seq::retiming_add_key(scene, strip, right_fake_key_frame_get(scene, strip));
373}
374
375void realize_fake_keys(const Scene *scene, Strip *strip)
376{
378 seq::retiming_add_key(scene, strip, strip->left_handle());
379 seq::retiming_add_key(scene, strip, strip->right_handle(scene));
380}
381
382SeqRetimingKey fake_retiming_key_init(const Scene *scene, const Strip *strip, int frame)
383{
384 const float scene_fps = float(scene->frames_per_second());
385 const int sound_offset = strip->rounded_sound_offset(scene_fps);
386 SeqRetimingKey fake_key = {0};
387 fake_key.strip_frame_index = (frame - strip->content_start() - sound_offset) *
388 strip->media_playback_rate_factor(scene_fps);
389 fake_key.flag = SEQ_RETIMING_FLAG_NONE;
390 return fake_key;
391}
392
394{
395 if (strip->retiming_keys != nullptr) {
396 MEM_delete(strip->retiming_keys);
397 strip->retiming_keys = nullptr;
398 strip->retiming_keys_num = 0;
399 }
400}
401
402static void retiming_key_overlap(Scene *scene, Strip *strip)
403{
404 ListBaseT<Strip> *seqbase = active_seqbase_get(editing_get(scene));
405 VectorSet<Strip *> strips;
406 VectorSet<Strip *> dependant;
407 dependant.add(strip);
409 strips.add_multiple(dependant);
410 dependant.remove(strip);
411 transform_handle_overlap(scene, seqbase, strips, true, dependant);
412}
413
414void retiming_reset(Scene *scene, Strip *strip)
415{
416 if (!retiming_is_allowed(strip)) {
417 return;
418 }
419
420 retiming_data_clear(strip);
421
422 Span<Strip *> effects = lookup_effects_by_strip(scene->ed, strip);
425
426 retiming_key_overlap(scene, strip);
428}
429
430static SeqRetimingKey *strip_retiming_add_key(Strip *strip, float frame_index)
431{
432 if (!retiming_is_allowed(strip)) {
433 return nullptr;
434 }
435 /* Clamp timeline frame to strip content range. */
436 if (frame_index <= 0) {
437 return &strip->retiming_keys[0];
438 }
439 if (frame_index >= retiming_last_key_get(strip)->strip_frame_index) {
440 return retiming_last_key_get(strip); /* This is expected for strips with no offsets. */
441 }
442
443 SeqRetimingKey *start_key = retiming_find_segment_start_key(strip, frame_index);
444
445 if (start_key->strip_frame_index == frame_index) {
446 return start_key; /* Retiming key already exists. */
447 }
448
449 if ((start_key->flag & SEQ_SPEED_TRANSITION_IN) != 0 ||
450 (start_key->flag & SEQ_FREEZE_FRAME_IN) != 0)
451 {
452 return nullptr;
453 }
454
455 float value = strip_retiming_evaluate(strip, frame_index);
456
457 SeqRetimingKey *keys = strip->retiming_keys;
458 const int keys_count = retiming_keys_count(strip);
459 const int new_key_index = start_key - keys + 1;
460 BLI_assert(new_key_index >= 0);
461 BLI_assert(new_key_index < keys_count);
462
463 SeqRetimingKey *new_keys = MEM_new_array<SeqRetimingKey>(keys_count + 1, __func__);
464 if (new_key_index > 0) {
465 memcpy(new_keys, keys, new_key_index * sizeof(SeqRetimingKey));
466 }
467 if (new_key_index < keys_count) {
468 memcpy(new_keys + new_key_index + 1,
469 keys + new_key_index,
470 (keys_count - new_key_index) * sizeof(SeqRetimingKey));
471 }
472 MEM_delete(keys);
473 strip->retiming_keys = new_keys;
474 strip->retiming_keys_num++;
475 strip->flag |= SEQ_SHOW_RETIMING;
476
477 SeqRetimingKey *added_key = (new_keys + new_key_index);
478 added_key->strip_frame_index = frame_index;
479 added_key->retiming_factor = value;
480
481 return added_key;
482}
483
485 ReportList *reports,
486 Strip *strip,
487 const int frame)
488{
489 const float frame_index = content_frame_index_get(scene, strip, frame);
490 const SeqRetimingKey *key = seq::retiming_find_segment_start_key(strip, frame_index);
491
492 if (key != nullptr && seq::retiming_key_is_transition_start(key)) {
493 BKE_report(reports, RPT_WARNING, "Cannot create key inside of speed transition");
494 return nullptr;
495 }
496
497 const float end_frame = strip->start + strip->length(scene);
498 if (strip->start > frame || end_frame < frame) {
499 return nullptr;
500 }
501
502 ensure_left_and_right_keys(scene, strip);
503 return retiming_add_key(scene, strip, frame);
504}
505
506SeqRetimingKey *retiming_add_key(const Scene *scene, Strip *strip, const int frame)
507{
508 const int frame_index = content_frame_index_get(scene, strip, frame);
509 return strip_retiming_add_key(strip, frame_index);
510}
511
513{
514 /* Transitions need special treatment, so separate these from `keys_to_remove`. */
515 Vector<SeqRetimingKey *> transitions;
516
517 /* Cleanup freeze frames and extract transition keys. */
518 for (SeqRetimingKey *key : keys_to_remove) {
521 }
522 if ((key->flag & SEQ_SPEED_TRANSITION_IN) != 0) {
523 transitions.append_non_duplicates(key);
524 transitions.append_non_duplicates(key + 1);
525 }
526 if ((key->flag & SEQ_SPEED_TRANSITION_OUT) != 0) {
527 transitions.append_non_duplicates(key);
528 transitions.append_non_duplicates(key - 1);
529 }
530 }
531
532 /* Sanitize keys to be removed. */
533 keys_to_remove.remove_if([&](const SeqRetimingKey *key) {
534 return key->strip_frame_index == 0 || retiming_is_last_key(strip, key) ||
536 });
537
538 const size_t keys_count = retiming_keys_count(strip);
539 size_t new_keys_count = keys_count - keys_to_remove.size() - transitions.size() / 2;
540 SeqRetimingKey *new_keys = MEM_new_array<SeqRetimingKey>(new_keys_count, __func__);
541 int keys_copied = 0;
542
543 /* Copy keys to new array. */
544 for (SeqRetimingKey &key : retiming_keys_get(strip)) {
545 /* Create key that was used to make transition in new array. */
546 if (transitions.contains(&key) && retiming_key_is_transition_start(&key)) {
547 SeqRetimingKey *new_key = new_keys + keys_copied;
550 keys_copied++;
551 continue;
552 }
553 if (keys_to_remove.contains(&key) || transitions.contains(&key)) {
554 continue;
555 }
556 memcpy(new_keys + keys_copied, &key, sizeof(SeqRetimingKey));
557 keys_copied++;
558 }
559
560 MEM_delete(strip->retiming_keys);
561 strip->retiming_keys = new_keys;
562 strip->retiming_keys_num = new_keys_count;
563}
564
566{
567 if (key->strip_frame_index == 0 || retiming_is_last_key(strip, key)) {
568 return; /* First and last key can not be removed. */
569 }
570
573 }
574
575 size_t keys_count = retiming_keys_count(strip);
576 SeqRetimingKey *keys = MEM_new_array<SeqRetimingKey>(keys_count - 1, __func__);
577
578 const int key_index = key - strip->retiming_keys;
579 memcpy(keys, strip->retiming_keys, (key_index) * sizeof(SeqRetimingKey));
580 memcpy(keys + key_index,
581 strip->retiming_keys + key_index + 1,
582 (keys_count - key_index - 1) * sizeof(SeqRetimingKey));
583 MEM_delete(strip->retiming_keys);
584 strip->retiming_keys = keys;
585 strip->retiming_keys_num--;
586}
587
588/* This function removes transition segment and creates retiming key where it originally was. */
590{
591 SeqRetimingKey *transition_start = key;
592 if ((key->flag & SEQ_SPEED_TRANSITION_OUT) != 0) {
593 transition_start = key - 1;
594 }
595
596 const float orig_frame_index = transition_start->original_strip_frame_index;
597 const float orig_retiming_factor = transition_start->original_retiming_factor;
598
599 /* Remove both keys defining transition. */
600 int key_index = retiming_key_index_get(strip, transition_start);
601 strip_retiming_remove_key_ex(strip, transition_start);
602 strip_retiming_remove_key_ex(strip, strip->retiming_keys + key_index);
603
604 /* Create original linear key. */
605 SeqRetimingKey *orig_key = strip_retiming_add_key(strip, orig_frame_index);
606 orig_key->retiming_factor = orig_retiming_factor;
607 return orig_key;
608}
609
611{
612
615 return;
616 }
617
619}
620
622
623/* -------------------------------------------------------------------- */
626
628{
629 return (key->flag & SEQ_SPEED_TRANSITION_IN) != 0 || (key->flag & SEQ_SPEED_TRANSITION_OUT) != 0;
630}
631
633{
634 return (key->flag & SEQ_SPEED_TRANSITION_IN) != 0;
635}
636
638{
639 if (key->flag & SEQ_SPEED_TRANSITION_OUT) {
640 return key - 1;
641 }
642 if (key->flag & SEQ_SPEED_TRANSITION_IN) {
643 return key;
644 }
645 return nullptr;
646}
647
648/* Check colinearity of 2 segments allowing for some imprecision.
649 * `isect_seg_seg_v2_lambda_mu_db()` return value does not work well in this case. */
650
651static bool strip_retiming_transition_is_linear(const Strip *strip, const SeqRetimingKey *key)
652{
653 const float prev_speed = retiming_key_speed_get(strip, key);
654 const float next_speed = retiming_key_speed_get(strip, key + 2);
655
656 return std::abs(prev_speed - next_speed) < 0.01f;
657}
658
660{
661 const SeqRetimingKey *end_key = start_key + 1;
662 return end_key->strip_frame_index - start_key->strip_frame_index;
663}
664
666{
667 const SeqRetimingKey *end_key = start_key + 1;
668 const double segment_length = strip_retiming_segment_length_get(start_key);
669 const double segment_fac_diff = end_key->retiming_factor - start_key->retiming_factor;
670 return segment_fac_diff / segment_length;
671}
672
674 double r_v1[2],
675 double r_v2[2])
676{
677 const SeqRetimingKey *end_key = start_key + 1;
678 r_v1[0] = start_key->strip_frame_index;
679 r_v1[1] = start_key->retiming_factor;
680 r_v2[0] = end_key->strip_frame_index;
681 r_v2[1] = end_key->retiming_factor;
682}
683
685 double r_center[2],
686 double *radius)
687{
688 double2 s1_1, s1_2, s2_1, s2_2, p1_2;
689
690 /* Get 2 segments. */
691 strip_retiming_segment_as_line_segment(start_key - 1, s1_1, s1_2);
692 strip_retiming_segment_as_line_segment(start_key + 1, s2_1, s2_2);
693 /* Backup first segment end point - needed to calculate arc radius. */
694 copy_v2_v2_db(p1_2, s1_2);
695 /* Convert segments to vectors. */
696 double2 v1, v2;
697 sub_v2_v2v2_db(v1, s1_1, s1_2);
698 sub_v2_v2v2_db(v2, s2_1, s2_2);
699 /* Rotate segments by 90 degrees around seg. 1 end and seg. 2 start point. */
700 std::swap(v1[0], v1[1]);
701 std::swap(v2[0], v2[1]);
702 v1[0] *= -1;
703 v2[0] *= -1;
704 copy_v2_v2_db(s1_1, s1_2);
705 s1_2 += v1;
706 copy_v2_v2_db(s2_2, s2_1);
707 s2_2 += v2;
708 /* Get center and radius of arc segment between 2 linear segments. */
709 double lambda, mu;
710 isect_seg_seg_v2_lambda_mu_db(s1_1, s1_2, s2_1, s2_2, &lambda, &mu);
711 r_center[0] = s1_1[0] + lambda * (s1_2[0] - s1_1[0]);
712 r_center[1] = s1_1[1] + lambda * (s1_2[1] - s1_1[1]);
713 *radius = len_v2v2_db(p1_2, r_center);
714}
715
717 const float frame_index)
718{
719 double c[2], r;
721 const int side = c[1] > key->retiming_factor ? -1 : 1;
722 const float y = c[1] + side * sqrt(r * r - (frame_index - c[0]) * (frame_index - c[0]));
723 return y;
724}
725
727 const Strip *strip,
728 SeqRetimingKey *key,
729 const int frame)
730{
732 SeqRetimingKey *key_end = key_start + 1;
733 const float start_frame_index = key_start->strip_frame_index;
734 const float midpoint = key_start->original_strip_frame_index;
735 const float new_frame_index = content_frame_index_get(scene, strip, frame);
736 float new_midpoint_offset = new_frame_index - midpoint;
737 const float prev_segment_step = strip_retiming_segment_step_get(key_start - 1);
738 const float next_segment_step = strip_retiming_segment_step_get(key_end);
739
740 /* Prevent keys crossing eachother. */
741 SeqRetimingKey *prev_segment_end = key_start - 1, *next_segment_start = key_end + 1;
742 const float offset_max_left = midpoint - prev_segment_end->strip_frame_index - 1;
743 const float offset_max_right = next_segment_start->strip_frame_index - midpoint - 1;
744 new_midpoint_offset = std::abs(new_midpoint_offset);
745 new_midpoint_offset = std::min({new_midpoint_offset, offset_max_left, offset_max_right});
746 new_midpoint_offset = std::max(new_midpoint_offset, 1.0f);
747
748 key_start->strip_frame_index = midpoint - new_midpoint_offset;
749 key_end->strip_frame_index = midpoint + new_midpoint_offset;
750
751 const float offset = key_start->strip_frame_index - start_frame_index;
752 key_start->retiming_factor += offset * prev_segment_step;
753 key_end->retiming_factor -= offset * next_segment_step;
754}
755
756float strip_retiming_evaluate(const Strip *strip, const float frame_index)
757{
758 const SeqRetimingKey *start_key = retiming_find_segment_start_key(strip, frame_index);
759
760 const int start_key_index = start_key - strip->retiming_keys;
761 BLI_assert(start_key_index < strip->retiming_keys_num);
762
763 const float segment_frame_index = frame_index - start_key->strip_frame_index;
764
765 if (!retiming_key_is_transition_start(start_key)) {
766 const float segment_step = strip_retiming_segment_step_get(start_key);
767 return std::min(1.0f, start_key->retiming_factor + float(segment_step * segment_frame_index));
768 }
769
770 if (strip_retiming_transition_is_linear(strip, start_key)) {
771 const float segment_step = strip_retiming_segment_step_get(start_key - 1);
772 return std::min(1.0f, start_key->retiming_factor + float(segment_step * segment_frame_index));
773 }
774
775 /* Sanity check for transition type. */
776 BLI_assert(start_key_index > 0);
777 BLI_assert(start_key_index < strip->retiming_keys_num - 1);
778 UNUSED_VARS_NDEBUG(start_key_index);
779
780 return std::min(1.0f, strip_retiming_evaluate_arc_segment(start_key, frame_index));
781}
782
784 Strip *strip,
785 SeqRetimingKey *key,
786 float offset)
787{
788 BLI_assert(!retiming_is_last_key(strip, key));
789 BLI_assert(key->strip_frame_index != 0);
790
791 SeqRetimingKey *prev_key = key - 1;
792 if ((key->flag & SEQ_SPEED_TRANSITION_IN) != 0 ||
793 (prev_key->flag & SEQ_SPEED_TRANSITION_IN) != 0)
794 {
795 return nullptr;
796 }
797
798 if ((key->flag & SEQ_FREEZE_FRAME_IN) != 0 || (prev_key->flag & SEQ_FREEZE_FRAME_IN) != 0) {
799 return nullptr;
800 }
801
802 Bounds<float> max_offset = strip_retiming_clamp_bounds_get(scene, strip, key);
803 float clamped_offset = math::clamp(offset, max_offset.min, max_offset.max);
804
805 const int orig_key_index = retiming_key_index_get(strip, key);
806 const float orig_frame_index = key->strip_frame_index;
807 const float orig_retiming_factor = key->retiming_factor;
808
809 SeqRetimingKey *transition_out = strip_retiming_add_key(strip,
810 orig_frame_index + clamped_offset);
811 transition_out->flag |= SEQ_SPEED_TRANSITION_OUT;
812
813 SeqRetimingKey *transition_in = strip_retiming_add_key(strip, orig_frame_index - clamped_offset);
814 transition_in->flag |= SEQ_SPEED_TRANSITION_IN;
815 transition_in->original_strip_frame_index = orig_frame_index;
816 transition_in->original_retiming_factor = orig_retiming_factor;
817
818 strip_retiming_remove_key_ex(strip, strip->retiming_keys + orig_key_index + 1);
819 return strip->retiming_keys + orig_key_index + 1;
820}
821
823 const Strip *strip,
824 SeqRetimingKey *start_key,
825 float media_offset)
826{
827 SeqRetimingKey *end_key = start_key + 1;
828 SeqRetimingKey *prev_key = start_key - 1;
829 SeqRetimingKey *next_key = start_key + 2;
830 const float prev_max_offset = prev_key->strip_frame_index - start_key->strip_frame_index;
831 const float next_max_offset = next_key->strip_frame_index - end_key->strip_frame_index;
832 const float scene_fps = float(scene->frames_per_second());
833 const float min_step = strip->media_playback_rate_factor(scene_fps);
834
835 return std::clamp(media_offset, prev_max_offset + min_step, next_max_offset - min_step);
836}
837
839 Strip *strip,
840 SeqRetimingKey *key,
841 const float media_offset)
842{
843 float clamped_offset = strip_retiming_clamp_transition_offset(scene, strip, key, media_offset);
844 const float scene_fps = float(scene->frames_per_second());
845 const float duration = (key->original_strip_frame_index - key->strip_frame_index) /
846 strip->media_playback_rate_factor(scene_fps);
847 const bool was_selected = retiming_selection_contains(editing_get(scene), key);
848
849 SeqRetimingKey *original_key = strip_retiming_remove_transition(strip, key);
850 original_key->strip_frame_index += clamped_offset;
851
852 SeqRetimingKey *transition_out = retiming_add_transition(scene, strip, original_key, duration);
853
854 if (was_selected) {
855 retiming_selection_append(transition_out);
856 retiming_selection_append(transition_out - 1);
857 }
858}
859
860/* Remove and re-create transition. This way transition won't change length.
861 * Alternative solution is to find where in arc segment the `y` value is closest to key
862 * retiming factor, then trim transition to that point. This would change transition length. */
863
864static void strip_retiming_fix_transition(const Scene *scene, Strip *strip, SeqRetimingKey *key)
865{
866 const int keys_num = strip->retiming_keys_num;
867 const float scene_fps = float(scene->frames_per_second());
868 const float transition_duration = (key->original_strip_frame_index - key->strip_frame_index) /
869 strip->media_playback_rate_factor(scene_fps);
870 SeqRetimingKey *orig_key = strip_retiming_remove_transition(strip, key);
871 retiming_add_transition(scene, strip, orig_key, transition_duration);
872 BLI_assert(keys_num == strip->retiming_keys_num);
873 UNUSED_VARS_NDEBUG(keys_num);
874}
875
876static void strip_retiming_fix_transitions(const Scene *scene, Strip *strip, SeqRetimingKey *key)
877{
878 /* Store value, since handles array will be reallocated. */
879 const int key_index = retiming_key_index_get(strip, key);
880
881 if (key_index > 1) {
882 SeqRetimingKey *prev_key = key - 2;
883 if (retiming_key_is_transition_start(prev_key)) {
884 strip_retiming_fix_transition(scene, strip, prev_key);
885 }
886 }
887
888 if (!retiming_is_last_key(strip, &retiming_keys_get(strip)[key_index])) {
889 SeqRetimingKey *next_key = &retiming_keys_get(strip)[key_index + 1];
890 if (retiming_key_is_transition_start(next_key)) {
891 strip_retiming_fix_transition(scene, strip, next_key);
892 }
893 }
894}
895
896static void strip_retiming_key_offset(const Scene *scene,
897 Strip *strip,
898 SeqRetimingKey *key,
899 const float media_offset)
900{
901 if ((key->flag & SEQ_SPEED_TRANSITION_IN) != 0) {
902 strip_retiming_transition_offset(scene, strip, key, media_offset);
903 }
904 else {
905 /* NOTE: Strip frame indices are in source media frames, not timeline frames. */
906 key->strip_frame_index += media_offset;
907 strip_retiming_fix_transitions(scene, strip, key);
908 }
909}
910
912
913/* -------------------------------------------------------------------- */
916
917static int strip_retiming_clamp_offset(const Scene *scene,
918 Strip *strip,
919 SeqRetimingKey *key,
920 const int offset)
921{
922 /* TODO(john): Note that there is more robust clamping logic in `create_trans_seq_clamp_data()`.
923 * We should eventually move that logic in here and let it be called by that function. */
924 if ((key->flag & SEQ_SPEED_TRANSITION_IN) != 0) {
925 return offset;
926 }
927
928 int key_frame = retiming_key_frame_get(scene, strip, key);
929 int prev_key_frame = -MAXFRAME;
930 int next_key_frame = MAXFRAME;
931
932 /* Ensure key cannot pass its next key. */
933 if (!retiming_is_last_key(strip, key)) {
934 SeqRetimingKey *next_key = key + 1;
935 next_key_frame = retiming_key_frame_get(scene, strip, next_key);
936 }
937
938 /* Ensure key cannot pass its previous key. */
939 if (key->strip_frame_index > 0) {
940 SeqRetimingKey *prev_key = key - 1;
941 prev_key_frame = retiming_key_frame_get(scene, strip, prev_key);
942 }
943
944 return std::clamp(offset, (prev_key_frame + 1) - key_frame, (next_key_frame - 1) - key_frame);
945}
946
947void retiming_key_frame_set(const Scene *scene, Strip *strip, SeqRetimingKey *key, int frame)
948{
949 if ((key->flag & SEQ_SPEED_TRANSITION_OUT) != 0) {
950 return;
951 }
952
953 const int frame_old = retiming_key_frame_get(scene, strip, key);
954 const int timeline_offset = strip_retiming_clamp_offset(scene, strip, key, frame - frame_old);
955
956 const float scene_fps = float(scene->frames_per_second());
957 const float media_offset = timeline_offset * strip->media_playback_rate_factor(scene_fps);
958
959 const int key_count = retiming_keys_get(strip).size();
960 const int key_index = retiming_key_index_get(strip, key);
961
962 if (frame_old == strip->right_handle(scene)) {
963 for (int i = key_index; i < key_count; i++) {
964 SeqRetimingKey *key_iter = &retiming_keys_get(strip)[i];
965 strip_retiming_key_offset(scene, strip, key_iter, media_offset);
966 }
967 }
968 else if (frame_old == strip->left_handle() || key->strip_frame_index == 0) {
969 strip->start += timeline_offset;
970 for (int i = key_index + 1; i < key_count; i++) {
971 SeqRetimingKey *key_iter = &retiming_keys_get(strip)[i];
972 strip_retiming_key_offset(scene, strip, key_iter, -media_offset);
973 }
974 }
975 else {
976 strip_retiming_key_offset(scene, strip, key, media_offset);
977 }
978
979 Span<Strip *> effects = lookup_effects_by_strip(scene->ed, strip);
982}
983
985
986/* -------------------------------------------------------------------- */
989
993};
994
1002
1004 public:
1006 float speed;
1008
1010 RetimingRange(const Strip *strip, int start_frame, int end_frame, float speed, eRangeType type)
1011 : start(start_frame), end(end_frame), speed(speed), type(type)
1012 {
1013 if (type == TRANSITION) {
1014 this->speed = 1.0f;
1016 }
1017 }
1018
1019 RetimingRange(int start_frame, int end_frame, float speed, eRangeType type)
1020 : start(start_frame), end(end_frame), speed(speed), type(type)
1021 {
1022 }
1023
1025 {
1027 for (int i = 0; i < speed_table.size(); i++) {
1028 new_range.speed_table.append(speed_table[i]);
1029 }
1030 return new_range;
1031 }
1032
1033 /* Create new range representing overlap of 2 ranges.
1034 * Returns overlapping range. */
1036 {
1037 RetimingRange new_range = RetimingRange(0, 0, 0, LINEAR);
1038
1039 /* Offsets to merge speed tables. */
1040 int range_offset = 0, rhs_range_offset = 0;
1041 if (intersect_type(rhs_range) == FULL) {
1042 new_range.start = start;
1043 new_range.end = end;
1044 rhs_range_offset = start - rhs_range.start;
1045 }
1046 else if (intersect_type(rhs_range) == PARTIAL_START) {
1047 new_range.start = start;
1048 new_range.end = rhs_range.end;
1049 rhs_range_offset = start - rhs_range.start;
1050 }
1051 else if (intersect_type(rhs_range) == PARTIAL_END) {
1052 new_range.start = rhs_range.start;
1053 new_range.end = end;
1054 range_offset = rhs_range.start - start;
1055 }
1056 else if (intersect_type(rhs_range) == INSIDE) {
1057 new_range.start = rhs_range.start;
1058 new_range.end = rhs_range.end;
1059 range_offset = rhs_range.start - start;
1060 }
1061
1062 if (type != TRANSITION && rhs_range.type != TRANSITION) {
1063 new_range.speed = speed * rhs_range.speed;
1064 return new_range;
1065 }
1066
1067 /* One of ranges is transition type, so speed tables has to be copied. */
1068 new_range.type = TRANSITION;
1069 new_range.speed = 1.0f;
1070 const int new_range_len = new_range.end - new_range.start;
1071
1072 if (type == TRANSITION && rhs_range.type == TRANSITION) {
1073 for (int i = 0; i < new_range_len; i++) {
1074 const float range_speed = speed_table[i + range_offset];
1075 const float rhs_range_speed = rhs_range.speed_table[i + rhs_range_offset];
1076 new_range.speed_table.append(range_speed * rhs_range_speed);
1077 }
1078 }
1079 else if (type == TRANSITION) {
1080 for (int i = 0; i < new_range_len; i++) {
1081 const float range_speed = speed_table[i + range_offset];
1082 new_range.speed_table.append(range_speed * rhs_range.speed);
1083 }
1084 }
1085 else if (rhs_range.type == TRANSITION) {
1086 for (int i = 0; i < new_range_len; i++) {
1087 const float rhs_range_speed = rhs_range.speed_table[i + rhs_range_offset];
1088 new_range.speed_table.append(speed * rhs_range_speed);
1089 }
1090 }
1091
1092 return new_range;
1093 }
1094
1096 {
1097 for (int frame = start; frame <= end; frame++) {
1098 /* We need number actual number of frames here. */
1099 const double normal_step = 1 / double(strip->content_length() - 1);
1100
1101 const int frame_index = frame - strip->content_start();
1102 /* Who needs calculus, when you can have slow code? */
1103 const double val_prev = strip_retiming_evaluate(strip, frame_index - 1);
1104 const double val = strip_retiming_evaluate(strip, frame_index);
1105 const double speed_at_frame = (val - val_prev) / normal_step;
1106 speed_table.append(speed_at_frame);
1107 }
1108 }
1109
1111 {
1112 if (other.start <= start && other.end >= end) {
1113 return FULL;
1114 }
1115 if (other.start > start && other.start < end && other.end > start && other.end < end) {
1116 return INSIDE;
1117 }
1118 if (other.start > start && other.start < end) {
1119 return PARTIAL_END;
1120 }
1121 if (other.end > start && other.end < end) {
1122 return PARTIAL_START;
1123 }
1124 return NONE;
1125 }
1126};
1127
1129 public:
1132 {
1133 for (const SeqRetimingKey &key : retiming_keys_get(strip)) {
1134 if (key.strip_frame_index == 0) {
1135 continue;
1136 }
1137 const SeqRetimingKey *key_prev = &key - 1;
1138 float speed = retiming_key_speed_get(strip, &key);
1139 int frame_start = strip->content_start() + key_prev->strip_frame_index;
1140 int frame_end = strip->content_start() + key.strip_frame_index;
1141
1143 RetimingRange range = RetimingRange(strip, frame_start, frame_end, speed, type);
1144 ranges.append(range);
1145 }
1146 }
1147
1149 {
1150 if (ranges.is_empty()) {
1151 for (const RetimingRange &rhs_range : rhs.ranges) {
1153 rhs_range.start, rhs_range.end, rhs_range.speed, rhs_range.type);
1154 ranges.append(range);
1155 }
1156 return *this;
1157 }
1158
1159 for (int i = 0; i < ranges.size(); i++) {
1160 RetimingRange &range = ranges[i];
1161 for (const RetimingRange &rhs_range : rhs.ranges) {
1162 if (range.intersect_type(rhs_range) == NONE) {
1163 continue;
1164 }
1165 if (range.intersect_type(rhs_range) == FULL) {
1166 RetimingRange isect = range * rhs_range;
1167 ranges.remove(i);
1168 ranges.insert(i, isect);
1169 }
1170 if (range.intersect_type(rhs_range) == PARTIAL_START) {
1171 ranges.insert(i, range * rhs_range);
1172 ranges.insert(i, range * rhs_range);
1173 range.start = rhs_range.end + 1;
1174 }
1175 else if (range.intersect_type(rhs_range) == PARTIAL_END) {
1176 ranges.insert(i, range * rhs_range);
1177 range.end = rhs_range.start;
1178 }
1179 else if (range.intersect_type(rhs_range) == INSIDE) {
1180 RetimingRange left_range = range.duplicate();
1181 left_range.end = rhs_range.start;
1182 range.start = rhs_range.end + 1;
1183
1184 ranges.insert(i, left_range);
1185 ranges.insert(i, range * rhs_range);
1186 }
1187 }
1188 }
1189 return *this;
1190 }
1191};
1192
1194{
1195 RetimingRangeData strip_retiming_data = RetimingRangeData(strip);
1196
1197 const Strip *meta_parent = lookup_meta_by_strip(scene->ed, strip);
1198 if (meta_parent == nullptr) {
1199 return strip_retiming_data;
1200 }
1201
1202 RetimingRangeData meta_retiming_data = RetimingRangeData(meta_parent);
1203 strip_retiming_data *= meta_retiming_data;
1204 return strip_retiming_data;
1205}
1206
1207void retiming_sound_animation_data_set(const Scene *scene, const Strip *strip)
1208{
1209
1210 RetimingRangeData retiming_data = strip_retiming_range_data_get(scene, strip);
1211
1212 /* No need to apply the time-stretch effect if all the retiming range speeds are 1, as the
1213 * effect itself is still expensive while the audio is playing and want to avoid having to use it
1214 * whenever we can. */
1215 bool correct_pitch = (strip->flag & SEQ_AUDIO_PITCH_CORRECTION) && strip->sound != nullptr &&
1216 std::any_of(retiming_data.ranges.begin(),
1217 retiming_data.ranges.end(),
1218 [](const RetimingRange &range) {
1219 return range.type != TRANSITION && range.speed != 1.0;
1220 });
1221#if !defined(WITH_RUBBERBAND)
1222 correct_pitch = false;
1223#endif
1224
1225 AUD_Sound sound_handle = BKE_sound_playback_handle_get(strip->sound);
1226 const float scene_fps = float(scene->frames_per_second());
1227 if (correct_pitch) {
1228 sound_handle = BKE_sound_ensure_time_stretch_effect(strip, scene_fps);
1230 strip->runtime->scene_sound, 0, strip->start + strip->content_length(), 1.0f);
1231 }
1232 else {
1233 strip->runtime->clear_sound_time_stretch();
1234 }
1235
1236 /* Content cut off by `anim_startofs` is as if it does not exist for sequencer. But Audaspace
1237 * seeking relies on having animation buffer initialized for whole sequence. */
1238 if (strip->anim_startofs > 0) {
1239 const int strip_start = strip->content_start();
1241 strip->runtime->scene_sound, strip_start - strip->anim_startofs, strip_start, 1.0f);
1242 }
1243
1244 const int sound_offset = strip->rounded_sound_offset(scene_fps);
1245
1246 for (const RetimingRange &range : retiming_data.ranges) {
1247 if (range.type == TRANSITION) {
1248 const int range_length = range.end - range.start;
1249 for (int i = 0; i <= range_length; i++) {
1250 const int frame = range.start + i;
1251 if (correct_pitch) {
1253 sound_handle, frame - strip->start, 1.0 / range.speed_table[i], true);
1254 }
1255 else {
1257 strip->runtime->scene_sound, frame + sound_offset, range.speed_table[i], true);
1258 }
1259 }
1260 }
1261 else {
1262 if (correct_pitch) {
1263 const float speed = range.speed == 0.0f ? 1.0f : 1.0f / range.speed;
1265 sound_handle, range.start - strip->start, range.end - strip->start, speed);
1266 }
1267 else {
1268 BKE_sound_set_scene_sound_pitch_constant_range(strip->runtime->scene_sound,
1269 range.start + sound_offset,
1270 range.end + sound_offset,
1271 range.speed);
1272 }
1273 }
1274 }
1275
1276 if (correct_pitch) {
1277 BKE_sound_update_sequence_handle(strip->runtime->scene_sound, sound_handle);
1278 }
1279}
1280
1282
1283/* -------------------------------------------------------------------- */
1286
1288{
1289 bool was_empty = true;
1290
1291 for (Strip &strip : *ed->current_strips()) {
1292 for (SeqRetimingKey &key : retiming_keys_get(&strip)) {
1293 was_empty &= (key.flag & SEQ_KEY_SELECTED) == 0;
1294 key.flag &= ~SEQ_KEY_SELECTED;
1295 }
1296 }
1297 return !was_empty;
1298}
1299
1301
1302 SeqRetimingKey *key)
1303{
1304 key->flag |= SEQ_KEY_SELECTED;
1305}
1306
1311
1313{
1315 dst->flag |= (src->flag & SEQ_KEY_SELECTED);
1316}
1317
1319{
1321 if (!ed) {
1322 return selection;
1323 }
1324 for (Strip &strip : *ed->current_strips()) {
1325 for (SeqRetimingKey &key : retiming_keys_get(&strip)) {
1326 if ((key.flag & SEQ_KEY_SELECTED) != 0) {
1327 selection.add(&key, &strip);
1328 }
1329 }
1330 }
1331 return selection;
1332}
1333
1335{
1336 for (Strip &strip : *ed->current_strips()) {
1337 for (const SeqRetimingKey &key_iter : retiming_keys_get(&strip)) {
1338 if ((key_iter.flag & SEQ_KEY_SELECTED) != 0 && &key_iter == key) {
1339 return true;
1340 }
1341 }
1342 }
1343 return false;
1344}
1345
1347{
1349 SeqRetimingKey *key_end = key_start + 1;
1350 bool has_start = false, has_end = false;
1351
1353
1354 for (auto item : selection.items()) {
1355 if (item.key == key_start) {
1356 has_start = true;
1357 }
1358 if (item.key == key_end) {
1359 has_end = true;
1360 }
1361 if (has_start && has_end) {
1362 return true;
1363 }
1364 }
1365 return false;
1366}
1367
1369
1370} // namespace blender::seq
std::shared_ptr< void > AUD_Sound
#define MAXFRAMEF
#define MINAFRAMEF
#define MAXFRAME
Read Blender memory allocation and freeing.
#define UNUSED_VARS_NDEBUG(...)
#define ELEM(...)
ValueIterator values() const &
Definition BLI_map.hh:884
bool add(const Key &key, const Value &value)
Definition BLI_map.hh:295
bool is_empty() const
Definition BLI_map.hh:986
ItemIterator items() const &
Definition BLI_map.hh:902
bool remove(const Key &key)
bool add(const Key &key)
void add_multiple(Span< Key > keys)
int64_t size() const
int64_t remove_if(Predicate &&predicate)
bool contains(const T &value) const
void append(const T &value)
void insert(const int64_t insert_index, const T &value)
void remove(const int64_t index)
bool is_empty() const
void append_non_duplicates(const T &value)
RetimingRangeData & operator*=(const RetimingRangeData &rhs)
RetimingRangeData(const Strip *strip)
Vector< RetimingRange > ranges
RetimingRange(int start_frame, int end_frame, float speed, eRangeType type)
eIntersectType intersect_type(const RetimingRange &other) const
RetimingRange(const Strip *strip, int start_frame, int end_frame, float speed, eRangeType type)
RetimingRange operator*(const RetimingRange &rhs_range)
void calculate_speed_table_from_seq(const Strip *strip)
int midpoint(int a, int b)
T clamp(const T &a, const T &min, const T &max)
SeqRetimingKey * ensure_left_and_right_keys(const Scene *scene, Strip *strip)
int retiming_key_index_get(const Strip *strip, const SeqRetimingKey *key)
SeqRetimingKey * retiming_key_add_new_for_strip(const Scene *scene, ReportList *reports, Strip *strip, const int frame)
Strip * lookup_meta_by_strip(Editing *ed, const Strip *key)
static bool strip_retiming_transition_is_linear(const Strip *strip, const SeqRetimingKey *key)
SeqRetimingKey * retiming_add_transition(const Scene *scene, Strip *strip, SeqRetimingKey *key, float offset)
MutableSpan< SeqRetimingKey > retiming_keys_get(const Strip *strip)
static SeqRetimingKey * strip_retiming_add_key(Strip *strip, float frame_index)
void realize_fake_keys(const Scene *scene, Strip *strip)
void relations_invalidate_cache(Scene *scene, Strip *strip)
bool retiming_key_is_transition_start(const SeqRetimingKey *key)
bool retiming_selection_has_whole_transition(const Editing *ed, SeqRetimingKey *key)
static double strip_retiming_segment_length_get(const SeqRetimingKey *start_key)
static float strip_retiming_clamp_transition_offset(const Scene *scene, const Strip *strip, SeqRetimingKey *start_key, float media_offset)
void retiming_reset(Scene *scene, Strip *strip)
bool retiming_selection_contains(const Editing *ed, const SeqRetimingKey *key)
int retiming_keys_count(const Strip *strip)
ListBaseT< Strip > * active_seqbase_get(const Editing *ed)
Definition sequencer.cc:463
void transform_handle_overlap(Scene *scene, ListBaseT< Strip > *seqbasep, Span< Strip * > source_strips, bool use_sync_markers, Span< Strip * > time_dependent_strips)
SeqRetimingKey * retiming_add_key(const Scene *scene, Strip *strip, const int frame)
SeqRetimingKey * retiming_add_freeze_frame(const Scene *scene, Strip *strip, SeqRetimingKey *key, const int offset)
static int content_frame_index_get(const Scene *scene, const Strip *strip, const int frame)
SeqRetimingKey fake_retiming_key_init(const Scene *scene, const Strip *strip, int frame)
static void strip_retiming_line_segments_tangent_circle(const SeqRetimingKey *start_key, double r_center[2], double *radius)
Editing * editing_get(const Scene *scene)
Definition sequencer.cc:304
static std::optional< float > retiming_key_new_frame_from_speed_get(const Scene *scene, Strip *strip, SeqRetimingKey *key, const float speed)
SeqRetimingKey * retiming_transition_start_get(SeqRetimingKey *key)
void retiming_data_ensure(Strip *strip)
void retiming_remove_key(Strip *strip, SeqRetimingKey *key)
static SeqRetimingKey * strip_retiming_remove_transition(Strip *strip, SeqRetimingKey *key)
int retiming_key_frame_get(const Scene *scene, const Strip *strip, const SeqRetimingKey *key)
SeqRetimingKey * retiming_find_segment_start_key(const Strip *strip, float frame_index)
void expand_strips(Editing *ed, VectorSet< Strip * > &strips, const StripRelation include)
Definition iterator.cc:70
void retiming_selection_remove(SeqRetimingKey *key)
void retiming_data_clear(Strip *strip)
void strip_time_update_effects_strip_range(const Scene *scene, const Span< Strip * > effects)
bool retiming_key_is_transition_type(const SeqRetimingKey *key)
static void strip_retiming_key_offset(const Scene *scene, Strip *strip, SeqRetimingKey *key, const float media_offset)
void time_update_meta_strip_range(const Scene *scene, Strip *strip_meta)
bool retiming_key_is_freeze_frame(const SeqRetimingKey *key)
static void strip_retiming_remove_key_ex(Strip *strip, SeqRetimingKey *key)
int right_fake_key_frame_get(const Scene *scene, const Strip *strip)
void retiming_remove_multiple_keys(Strip *strip, Vector< SeqRetimingKey * > &keys_to_remove)
static Bounds< float > strip_retiming_clamp_bounds_get(const Scene *scene, const Strip *strip, SeqRetimingKey *key)
void retiming_selection_copy(SeqRetimingKey *dst, const SeqRetimingKey *src)
Span< Strip * > lookup_effects_by_strip(Editing *ed, const Strip *key)
static void retiming_key_overlap(Scene *scene, Strip *strip)
bool retiming_has_keys(const Strip *strip)
void retiming_sound_animation_data_set(const Scene *scene, const Strip *strip)
static void strip_retiming_transition_offset(const Scene *scene, Strip *strip, SeqRetimingKey *key, const float media_offset)
bool retiming_selection_clear(const Editing *ed)
float retiming_key_speed_get(const Strip *strip, const SeqRetimingKey *key)
static float strip_retiming_evaluate_arc_segment(const SeqRetimingKey *key, const float frame_index)
void retiming_key_speed_set(const Scene *scene, Strip *strip, SeqRetimingKey *key, const float speed)
bool retiming_is_allowed(const Strip *strip)
bool retiming_show_keys(const Strip *strip)
static void strip_retiming_segment_as_line_segment(const SeqRetimingKey *start_key, double r_v1[2], double r_v2[2])
int left_fake_key_frame_get(const Scene *scene, const Strip *strip)
SeqRetimingKey * retiming_key_get_by_frame(const Scene *scene, const Strip *strip, const int frame)
static float strip_retiming_segment_step_get(const SeqRetimingKey *start_key)
void retiming_transition_key_frame_set(const Scene *scene, const Strip *strip, SeqRetimingKey *key, const int frame)
bool retiming_keys_are_selected(const Scene *scene)
static void strip_retiming_fix_transition(const Scene *scene, Strip *strip, SeqRetimingKey *key)
Map< SeqRetimingKey *, Strip * > retiming_selection_get(const Editing *ed)
SeqRetimingKey * retiming_last_key_get(const Strip *strip)
void retiming_key_frame_set(const Scene *scene, Strip *strip, SeqRetimingKey *key, int frame)
void retiming_selection_append(SeqRetimingKey *key)
bool retiming_is_last_key(const Strip *strip, const SeqRetimingKey *key)
static void strip_retiming_fix_transitions(const Scene *scene, Strip *strip, SeqRetimingKey *key)
float strip_retiming_evaluate(const Strip *strip, const float frame_index)
static RetimingRangeData strip_retiming_range_data_get(const Scene *scene, const Strip *strip)
static int strip_retiming_clamp_offset(const Scene *scene, Strip *strip, SeqRetimingKey *key, const int offset)
static std::pair< SeqRetimingKey *, SeqRetimingKey * > freeze_key_pair_create(const Scene *scene, Strip *strip, SeqRetimingKey *key, const int offset)
static void strip_retiming_cleanup_freeze_frame(SeqRetimingKey *key)
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
MINLINE void sub_v2_v2v2_db(double r[2], const double a[2], const double b[2])
@ RPT_WARNING
Definition BKE_report.hh:40
AUD_Sound BKE_sound_playback_handle_get(const bSound *sound)
MINLINE int round_fl_to_int(float a)
VecBase< double, 2 > double2
MINLINE int max_ii(int a, int b)
void BKE_sound_set_scene_sound_time_stretch_at_frame(AUD_Sound handle, int frame, float time_stretch, bool animated)
void BKE_report(ReportList *reports, eReportType type, const char *message)
Definition report.cc:162
void BKE_sound_set_scene_sound_pitch_constant_range(AUD_SequenceEntry handle, int frame_start, int frame_end, float pitch)
MINLINE void copy_v2_v2_db(double r[2], const double a[2])
sqrt(x)+1/max(0
@ SEQ_AUDIO_PITCH_CORRECTION
int isect_seg_seg_v2_lambda_mu_db(const double v1[2], const double v2[2], const double v3[2], const double v4[2], double *r_lambda, double *r_mu)
MINLINE double len_v2v2_db(const double v1[2], const double v2[2]) ATTR_WARN_UNUSED_RESULT
void BKE_sound_set_scene_sound_time_stretch_constant_range(AUD_Sound handle, int frame_start, int frame_end, float time_stretch)
ATTR_WARN_UNUSED_RESULT const BMVert * v2
void BKE_sound_set_scene_sound_pitch_at_frame(AUD_SequenceEntry handle, int frame, float pitch, bool animated)
MINLINE int min_ii(int a, int b)
AUD_Sound BKE_sound_ensure_time_stretch_effect(const Strip *strip, float fps)
void BKE_sound_update_sequence_handle(AUD_SequenceEntry handle, AUD_Sound sound_handle)
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
struct Editing * ed