← Back to branch summary

~ubuntu-branches/ubuntu/trusty/blender/trusty

« back to all changes in this revision

Viewing changes to source/blender/blenkernel/BKE_sequencer.h

  • Committer: Package Import Robot
  • Author(s): Jeremy Bicha
  • Date: 2013-03-06 12:08:47 UTC
  • mfrom: (1.5.1) (14.1.8 experimental)
  • Revision ID: package-import@ubuntu.com-20130306120847-frjfaryb2zrotwcg
Tags: 2.66a-1ubuntu1
https://launchpad.net/bugs/1076930
https://launchpad.net/bugs/1089256
https://launchpad.net/bugs/1052743
https://launchpad.net/bugs/999024
* Resynchronize with Debian (LP: #1076930, #1089256, #1052743, #999024,
  #1122888, #1147084)
* debian/control:
  - Lower build-depends on libavcodec-dev since we're not
    doing the libav9 transition in Ubuntu yet

Show diffs side-by-side

added added

removed removed

Lines of Context:
source/blender/blenkernel/BKE_sequencer.h
31
31
 */
32
32
 
33
33
struct bContext;
 
34
struct StripColorBalance;
34
35
struct Editing;
35
36
struct ImBuf;
36
37
struct Main;
 
38
struct Mask;
 
39
struct MovieClip;
37
40
struct Scene;
38
41
struct Sequence;
 
42
struct SequenceModifierData;
39
43
struct Strip;
40
44
struct StripElem;
41
45
struct bSound;
46
50
#define BUILD_SEQAR_COUNT_CURRENT  1
47
51
#define BUILD_SEQAR_COUNT_CHILDREN 2
48
52
 
49
 
#define EARLY_NO_INPUT          -1
50
 
#define EARLY_DO_EFFECT         0
51
 
#define EARLY_USE_INPUT_1       1
52
 
#define EARLY_USE_INPUT_2       2
 
53
#define EARLY_NO_INPUT      -1
 
54
#define EARLY_DO_EFFECT     0
 
55
#define EARLY_USE_INPUT_1   1
 
56
#define EARLY_USE_INPUT_2   2
53
57
 
54
58
/* sequence iterator */
55
59
 
61
65
        int valid;
62
66
} SeqIterator;
63
67
 
64
 
void seq_begin(struct Editing *ed, SeqIterator *iter, int use_pointer);
65
 
void seq_next(SeqIterator *iter);
66
 
void seq_end(SeqIterator *iter);
67
 
void seq_array(struct Editing *ed, struct Sequence ***seqarray, int *tot, int use_pointer);
68
 
 
69
 
#define SEQP_BEGIN(ed, _seq)                                                  \
70
 
{                                                                             \
71
 
        SeqIterator iter;                                                         \
72
 
                for (seq_begin(ed, &iter, 1); iter.valid; seq_next(&iter)) {          \
73
 
                        _seq = iter.seq;
74
 
                        
 
68
void BKE_sequence_iterator_begin(struct Editing *ed, SeqIterator *iter, int use_pointer);
 
69
void BKE_sequence_iterator_next(SeqIterator *iter);
 
70
void BKE_sequence_iterator_end(SeqIterator *iter);
 
71
 
 
72
#define SEQP_BEGIN(_ed, _seq)                                                 \
 
73
        {                                                                         \
 
74
                SeqIterator iter_macro;                                               \
 
75
                for (BKE_sequence_iterator_begin(_ed, &iter_macro, 1);                \
 
76
                     iter_macro.valid;                                                \
 
77
                     BKE_sequence_iterator_next(&iter_macro))                         \
 
78
                {                                                                     \
 
79
                        _seq = iter_macro.seq;
 
80
 
75
81
#define SEQ_BEGIN(ed, _seq)                                                   \
76
82
        {                                                                         \
77
 
                SeqIterator iter;                                                     \
78
 
                for (seq_begin(ed, &iter, 0); iter.valid; seq_next(&iter)) {          \
79
 
                        _seq = iter.seq;
 
83
                SeqIterator iter_macro;                                               \
 
84
                for (BKE_sequence_iterator_begin(ed, &iter_macro, 0);                 \
 
85
                     iter_macro.valid;                                                \
 
86
                     BKE_sequence_iterator_next(&iter_macro))                         \
 
87
                {                                                                     \
 
88
                        _seq = iter_macro.seq;
80
89
 
81
90
#define SEQ_END                                                               \
82
91
                }                                                                     \
83
 
                seq_end(&iter);                                                       \
 
92
                BKE_sequence_iterator_end(&iter_macro);                               \
84
93
        }
85
94
 
86
95
typedef struct SeqRenderData {
93
102
        float motion_blur_shutter;
94
103
} SeqRenderData;
95
104
 
96
 
SeqRenderData seq_new_render_data(
97
 
        struct Main * bmain, struct Scene * scene,
98
 
        int rectx, int recty, int preview_render_size);
99
 
 
100
 
int seq_cmp_render_data(const SeqRenderData * a, const SeqRenderData * b);
101
 
unsigned int seq_hash_render_data(const SeqRenderData * a);
 
105
SeqRenderData BKE_sequencer_new_render_data(struct Main *bmain, struct Scene *scene, int rectx, int recty,
 
106
                                            int preview_render_size);
102
107
 
103
108
/* Wipe effect */
104
109
enum {
110
115
        DO_CLOCK_WIPE
111
116
};
112
117
 
113
 
 
114
118
struct SeqEffectHandle {
 
119
        short multithreaded;
 
120
        short supports_mask;
 
121
 
115
122
        /* constructors & destructor */
116
 
        /* init & init_plugin are _only_ called on first creation */
 
123
        /* init is _only_ called on first creation */
117
124
        void (*init)(struct Sequence *seq);
118
 
        void (*init_plugin)(struct Sequence *seq, const char *fname);
119
125
        
120
126
        /* number of input strips needed 
121
127
         * (called directly after construction) */
138
144
        int (*early_out)(struct Sequence *seq, float facf0, float facf1); 
139
145
        
140
146
        /* stores the y-range of the effect IPO */
141
 
        void (*store_icu_yrange)(struct Sequence * seq, short adrcode, float *ymin, float *ymax);
 
147
        void (*store_icu_yrange)(struct Sequence *seq, short adrcode, float *ymin, float *ymax);
142
148
        
143
149
        /* stores the default facf0 and facf1 if no IPO is present */
144
 
        void (*get_default_fac)(struct Sequence *seq, float cfra, float * facf0, float * facf1);
 
150
        void (*get_default_fac)(struct Sequence *seq, float cfra, float *facf0, float *facf1);
145
151
        
146
152
        /* execute the effect
147
153
         * sequence effects are only required to either support
148
154
         * float-rects or byte-rects
149
155
         * (mixed cases are handled one layer up...) */
150
156
        
151
 
        struct ImBuf* (*execute)(
152
 
                SeqRenderData context,
153
 
                struct Sequence *seq, float cfra,
154
 
                float facf0, float facf1,
155
 
                struct ImBuf *ibuf1, struct ImBuf *ibuf2,
156
 
                struct ImBuf *ibuf3);
 
157
        struct ImBuf * (*execute)(SeqRenderData context, struct Sequence *seq, float cfra, float facf0, float facf1,
 
158
                                  struct ImBuf *ibuf1, struct ImBuf *ibuf2, struct ImBuf *ibuf3);
 
159
 
 
160
        struct ImBuf * (*init_execution)(SeqRenderData context, struct ImBuf *ibuf1, struct ImBuf *ibuf2,
 
161
                                         struct ImBuf *ibuf3);
 
162
 
 
163
        void (*execute_slice)(SeqRenderData context, struct Sequence *seq, float cfra, float facf0, float facf1,
 
164
                              struct ImBuf *ibuf1, struct ImBuf *ibuf2, struct ImBuf *ibuf3,
 
165
                              int start_line, int total_lines, struct ImBuf *out);
157
166
};
158
167
 
159
168
/* ********************* prototypes *************** */
160
169
 
161
170
/* **********************************************************************
162
 
 * sequence.c
 
171
 * sequencer.c
163
172
 *
164
173
 * sequencer render functions
165
174
 * ********************************************************************** */
166
175
 
167
 
struct ImBuf *give_ibuf_seq(SeqRenderData context, float cfra, int chanshown);
168
 
struct ImBuf *give_ibuf_seq_threaded(SeqRenderData context, float cfra, int chanshown);
169
 
struct ImBuf *give_ibuf_seq_direct(SeqRenderData context, float cfra, struct Sequence *seq);
170
 
struct ImBuf *give_ibuf_seqbase(SeqRenderData context, float cfra, int chan_shown, struct ListBase *seqbasep);
171
 
void give_ibuf_prefetch_request(SeqRenderData context, float cfra, int chan_shown);
 
176
struct ImBuf *BKE_sequencer_give_ibuf(SeqRenderData context, float cfra, int chanshown);
 
177
struct ImBuf *BKE_sequencer_give_ibuf_threaded(SeqRenderData context, float cfra, int chanshown);
 
178
struct ImBuf *BKE_sequencer_give_ibuf_direct(SeqRenderData context, float cfra, struct Sequence *seq);
 
179
struct ImBuf *BKE_sequencer_give_ibuf_seqbase(SeqRenderData context, float cfra, int chan_shown, struct ListBase *seqbasep);
 
180
void BKE_sequencer_give_ibuf_prefetch_request(SeqRenderData context, float cfra, int chan_shown);
 
181
 
 
182
/* **********************************************************************
 
183
 * sequencer.c
 
184
 *
 
185
 * sequencer color space functions
 
186
 * ********************************************************************** */
 
187
 
 
188
void BKE_sequencer_imbuf_to_sequencer_space(struct Scene *scene, struct ImBuf *ibuf, int make_float);
 
189
void BKE_sequencer_imbuf_from_sequencer_space(struct Scene *scene, struct ImBuf *ibuf);
 
190
void BKE_sequencer_pixel_from_sequencer_space_v4(struct Scene *scene, float pixel[4]);
 
191
 
 
192
/* **********************************************************************
 
193
 * sequencer scene functions
 
194
 * ********************************************************************** */
 
195
struct Editing  *BKE_sequencer_editing_get(struct Scene *scene, int alloc);
 
196
struct Editing  *BKE_sequencer_editing_ensure(struct Scene *scene);
 
197
void             BKE_sequencer_editing_free(struct Scene *scene);
 
198
 
 
199
void             BKE_sequencer_sort(struct Scene *scene);
 
200
 
 
201
struct Sequence *BKE_sequencer_active_get(struct Scene *scene);
 
202
int              BKE_sequencer_active_get_pair(struct Scene *scene, struct Sequence **seq_act, struct Sequence **seq_other);
 
203
void             BKE_sequencer_active_set(struct Scene *scene, struct Sequence *seq);
 
204
struct Mask     *BKE_sequencer_mask_get(struct Scene *scene);
172
205
 
173
206
/* apply functions recursively */
174
 
int seqbase_recursive_apply(struct ListBase *seqbase, int (*apply_func)(struct Sequence *seq, void *), void *arg);
175
 
int seq_recursive_apply(struct Sequence *seq, int (*apply_func)(struct Sequence *, void *), void *arg);
 
207
int BKE_sequencer_base_recursive_apply(struct ListBase *seqbase, int (*apply_func)(struct Sequence *seq, void *), void *arg);
 
208
int BKE_sequencer_recursive_apply(struct Sequence *seq, int (*apply_func)(struct Sequence *, void *), void *arg);
176
209
 
177
210
/* maintenance functions, mostly for RNA */
178
 
// extern 
179
 
void seq_free_sequence(struct Scene *scene, struct Sequence *seq);
180
 
void seq_free_sequence_recurse(struct Scene *scene, struct Sequence *seq);
181
 
void seq_free_strip(struct Strip *strip);
182
 
void seq_free_editing(struct Scene *scene);
183
 
void seq_free_clipboard(void);
184
 
struct Editing *seq_give_editing(struct Scene *scene, int alloc);
185
 
const char *give_seqname(struct Sequence *seq);
186
 
void calc_sequence(struct Scene *scene, struct Sequence *seq);
187
 
void calc_sequence_disp(struct Scene *scene, struct Sequence *seq);
188
 
void reload_sequence_new_file(struct Scene *scene, struct Sequence * seq, int lock_range);
189
 
void sort_seq(struct Scene *scene);
190
 
void build_seqar_cb(struct ListBase *seqbase, struct Sequence  ***seqar, int *totseq,
191
 
                                        int (*test_func)(struct Sequence * seq));
192
 
int evaluate_seq_frame(struct Scene *scene, int cfra);
193
 
struct StripElem *give_stripelem(struct Sequence *seq, int cfra);
194
 
 
195
 
// intern
196
 
void printf_strip(struct Sequence *seq); // debugging function (unused)
197
 
void update_changed_seq_and_deps(struct Scene *scene, struct Sequence *changed_seq, int len_change, int ibuf_change);
198
 
 
199
 
int input_have_to_preprocess(
200
 
        SeqRenderData context, struct Sequence * seq, float cfra);
201
 
 
202
 
struct SeqIndexBuildContext *seq_proxy_rebuild_context(struct Main *bmain, struct Scene *scene, struct Sequence *seq);
203
 
void seq_proxy_rebuild(struct SeqIndexBuildContext *context,
204
 
                       short *stop, short *do_update, float *progress);
205
 
void seq_proxy_rebuild_finish(struct SeqIndexBuildContext *context, short stop);
206
 
 
 
211
/* extern  */
 
212
 
 
213
void BKE_sequencer_free_clipboard(void);
 
214
 
 
215
void BKE_sequence_free(struct Scene *scene, struct Sequence *seq);
 
216
const char *BKE_sequence_give_name(struct Sequence *seq);
 
217
void BKE_sequence_calc(struct Scene *scene, struct Sequence *seq);
 
218
void BKE_sequence_calc_disp(struct Scene *scene, struct Sequence *seq);
 
219
void BKE_sequence_reload_new_file(struct Scene *scene, struct Sequence *seq, int lock_range);
 
220
int BKE_sequencer_evaluate_frame(struct Scene *scene, int cfra);
 
221
 
 
222
struct StripElem *BKE_sequencer_give_stripelem(struct Sequence *seq, int cfra);
 
223
 
 
224
/* intern */
 
225
void BKE_sequencer_update_changed_seq_and_deps(struct Scene *scene, struct Sequence *changed_seq, int len_change, int ibuf_change);
 
226
int BKE_sequencer_input_have_to_preprocess(SeqRenderData context, struct Sequence *seq, float cfra);
 
227
 
 
228
struct SeqIndexBuildContext *BKE_sequencer_proxy_rebuild_context(struct Main *bmain, struct Scene *scene, struct Sequence *seq);
 
229
void BKE_sequencer_proxy_rebuild(struct SeqIndexBuildContext *context, short *stop, short *do_update, float *progress);
 
230
void BKE_sequencer_proxy_rebuild_finish(struct SeqIndexBuildContext *context, short stop);
207
231
 
208
232
/* **********************************************************************
209
233
 * seqcache.c
218
242
        SEQ_STRIPELEM_IBUF_ENDSTILL
219
243
} seq_stripelem_ibuf_t;
220
244
 
221
 
void seq_stripelem_cache_destruct(void);
222
 
void seq_stripelem_cache_cleanup(void);
 
245
void BKE_sequencer_cache_destruct(void);
 
246
void BKE_sequencer_cache_cleanup(void);
223
247
 
224
248
/* returned ImBuf is properly refed and has to be freed */
225
 
struct ImBuf * seq_stripelem_cache_get(
226
 
        SeqRenderData context, struct Sequence * seq, 
227
 
        float cfra, seq_stripelem_ibuf_t type);
 
249
struct ImBuf *BKE_sequencer_cache_get(SeqRenderData context, struct Sequence *seq, float cfra, seq_stripelem_ibuf_t type);
228
250
 
229
251
/* passed ImBuf is properly refed, so ownership is *not* 
230
 
 * transfered to the cache.
 
252
 * transferred to the cache.
231
253
 * you can pass the same ImBuf multiple times to the cache without problems.
232
254
 */
233
 
   
234
 
void seq_stripelem_cache_put(
235
 
        SeqRenderData context, struct Sequence * seq, 
236
 
        float cfra, seq_stripelem_ibuf_t type, struct ImBuf * nval);
 
255
 
 
256
void BKE_sequencer_cache_put(SeqRenderData context, struct Sequence *seq, float cfra, seq_stripelem_ibuf_t type, struct ImBuf *nval);
 
257
 
 
258
void BKE_sequencer_cache_cleanup_sequence(struct Sequence *seq);
 
259
 
 
260
struct ImBuf *BKE_sequencer_preprocessed_cache_get(SeqRenderData context, struct Sequence *seq, float cfra, seq_stripelem_ibuf_t type);
 
261
void BKE_sequencer_preprocessed_cache_put(SeqRenderData context, struct Sequence *seq, float cfra, seq_stripelem_ibuf_t type, struct ImBuf *ibuf);
 
262
void BKE_sequencer_preprocessed_cache_cleanup(void);
 
263
void BKE_sequencer_preprocessed_cache_cleanup_sequence(struct Sequence *seq);
237
264
 
238
265
/* **********************************************************************
239
266
 * seqeffects.c
243
270
 */
244
271
 
245
272
/* intern */
246
 
struct SeqEffectHandle get_sequence_blend(struct Sequence *seq);
247
 
void sequence_effect_speed_rebuild_map(struct Scene *scene, struct Sequence *seq, int force);
 
273
struct SeqEffectHandle BKE_sequence_get_blend(struct Sequence *seq);
 
274
void BKE_sequence_effect_speed_rebuild_map(struct Scene *scene, struct Sequence *seq, int force);
248
275
 
249
276
/* extern */
250
 
struct SeqEffectHandle get_sequence_effect(struct Sequence *seq);
251
 
int get_sequence_effect_num_inputs(int seq_type);
252
 
 
 
277
struct SeqEffectHandle BKE_sequence_get_effect(struct Sequence *seq);
 
278
int BKE_sequence_effect_get_num_inputs(int seq_type);
 
279
int BKE_sequence_effect_get_supports_mask(int seq_type);
253
280
 
254
281
/* **********************************************************************
255
282
 * Sequencer editing functions
257
284
 */
258
285
   
259
286
/* for transform but also could use elsewhere */
260
 
int seq_tx_get_start(struct Sequence *seq);
261
 
int seq_tx_get_end(struct Sequence *seq);
262
 
int seq_tx_get_final_left(struct Sequence *seq, int metaclip);
263
 
int seq_tx_get_final_right(struct Sequence *seq, int metaclip);
264
 
void seq_tx_set_final_left(struct Sequence *seq, int val);
265
 
void seq_tx_set_final_right(struct Sequence *seq, int val);
266
 
void seq_tx_handle_xlimits(struct Sequence *seq, int leftflag, int rightflag);
267
 
int seq_tx_test(struct Sequence * seq);
268
 
int seq_single_check(struct Sequence *seq);
269
 
void seq_single_fix(struct Sequence *seq);
270
 
int seq_test_overlap(struct ListBase * seqbasep, struct Sequence *test);
271
 
void seq_translate(struct Scene *scene, struct Sequence *seq, int delta);
272
 
void seq_sound_init(struct Scene *scene, struct Sequence *seq);
273
 
struct Sequence *seq_foreground_frame_get(struct Scene *scene, int frame);
274
 
struct ListBase *seq_seqbase(struct ListBase *seqbase, struct Sequence *seq);
275
 
struct Sequence *seq_metastrip(
276
 
        ListBase * seqbase /* = ed->seqbase */, 
277
 
        struct Sequence * meta /* = NULL */, struct Sequence *seq);
278
 
 
279
 
void seq_offset_animdata(struct Scene *scene, struct Sequence *seq, int ofs);
280
 
void seq_dupe_animdata(struct Scene *scene, const char *name_src, const char *name_dst);
281
 
int shuffle_seq(struct ListBase * seqbasep, struct Sequence *test, struct Scene *evil_scene);
282
 
int shuffle_seq_time(ListBase * seqbasep, struct Scene *evil_scene);
283
 
int seqbase_isolated_sel_check(struct ListBase *seqbase);
284
 
void free_imbuf_seq(struct Scene *scene, struct ListBase * seqbasep, int check_mem_usage, int keep_file_handles);
285
 
struct Sequence *seq_dupli_recursive(struct Scene *scene, struct Scene *scene_to, struct Sequence * seq, int dupe_flag);
286
 
int seq_swap(struct Sequence *seq_a, struct Sequence *seq_b, const char **error_str);
287
 
 
288
 
void seq_update_sound_bounds_all(struct Scene *scene);
289
 
void seq_update_sound_bounds(struct Scene* scene, struct Sequence *seq);
290
 
void seq_update_muting(struct Editing *ed);
291
 
void seq_update_sound(struct Scene *scene, struct bSound *sound);
292
 
void seqbase_unique_name_recursive(ListBase *seqbasep, struct Sequence *seq);
293
 
void seqbase_dupli_recursive(struct Scene *scene, struct Scene *scene_to, ListBase *nseqbase, ListBase *seqbase, int dupe_flag);
294
 
 
295
 
void clear_scene_in_allseqs(struct Main *bmain, struct Scene *sce);
296
 
 
297
 
struct Sequence *get_seq_by_name(struct ListBase *seqbase, const char *name, int recursive);
298
 
 
299
 
struct Sequence *seq_active_get(struct Scene *scene);
300
 
void seq_active_set(struct Scene *scene, struct Sequence *seq);
301
 
int seq_active_pair_get(struct Scene *scene, struct Sequence **seq_act, struct Sequence **seq_other);
 
287
int BKE_sequence_tx_get_final_left(struct Sequence *seq, int metaclip);
 
288
int BKE_sequence_tx_get_final_right(struct Sequence *seq, int metaclip);
 
289
void BKE_sequence_tx_set_final_left(struct Sequence *seq, int val);
 
290
void BKE_sequence_tx_set_final_right(struct Sequence *seq, int val);
 
291
void BKE_sequence_tx_handle_xlimits(struct Sequence *seq, int leftflag, int rightflag);
 
292
int BKE_sequence_tx_test(struct Sequence *seq);
 
293
int BKE_sequence_single_check(struct Sequence *seq);
 
294
void BKE_sequence_single_fix(struct Sequence *seq);
 
295
int BKE_sequence_test_overlap(struct ListBase *seqbasep, struct Sequence *test);
 
296
void BKE_sequence_translate(struct Scene *scene, struct Sequence *seq, int delta);
 
297
void BKE_sequence_sound_init(struct Scene *scene, struct Sequence *seq);
 
298
struct Sequence *BKE_sequencer_foreground_frame_get(struct Scene *scene, int frame);
 
299
struct ListBase *BKE_sequence_seqbase(struct ListBase *seqbase, struct Sequence *seq);
 
300
struct Sequence *BKE_sequence_metastrip(ListBase *seqbase /* = ed->seqbase */, struct Sequence *meta /* = NULL */, struct Sequence *seq);
 
301
 
 
302
void BKE_sequencer_offset_animdata(struct Scene *scene, struct Sequence *seq, int ofs);
 
303
void BKE_sequencer_dupe_animdata(struct Scene *scene, const char *name_src, const char *name_dst);
 
304
int BKE_sequence_base_shuffle(struct ListBase *seqbasep, struct Sequence *test, struct Scene *evil_scene);
 
305
int BKE_sequence_base_shuffle_time(ListBase *seqbasep, struct Scene *evil_scene);
 
306
int BKE_sequence_base_isolated_sel_check(struct ListBase *seqbase);
 
307
void BKE_sequencer_free_imbuf(struct Scene *scene, struct ListBase *seqbasep, int for_render);
 
308
struct Sequence *BKE_sequence_dupli_recursive(struct Scene *scene, struct Scene *scene_to, struct Sequence *seq, int dupe_flag);
 
309
int BKE_sequence_swap(struct Sequence *seq_a, struct Sequence *seq_b, const char **error_str);
 
310
 
 
311
int BKE_sequence_check_depend(struct Sequence *seq, struct Sequence *cur);
 
312
void BKE_sequence_invalidate_cache(struct Scene *scene, struct Sequence *seq);
 
313
void BKE_sequence_invalidate_dependent(struct Scene *scene, struct Sequence *seq);
 
314
void BKE_sequence_invalidate_cache_for_modifier(struct Scene *scene, struct Sequence *seq);
 
315
 
 
316
void BKE_sequencer_update_sound_bounds_all(struct Scene *scene);
 
317
void BKE_sequencer_update_sound_bounds(struct Scene *scene, struct Sequence *seq);
 
318
void BKE_sequencer_update_muting(struct Editing *ed);
 
319
void BKE_sequencer_update_sound(struct Scene *scene, struct bSound *sound);
 
320
 
 
321
void BKE_sequence_base_unique_name_recursive(ListBase *seqbasep, struct Sequence *seq);
 
322
void BKE_sequence_base_dupli_recursive(struct Scene *scene, struct Scene *scene_to, ListBase *nseqbase, ListBase *seqbase, int dupe_flag);
 
323
int  BKE_sequence_is_valid_check(struct Sequence *seq);
 
324
 
 
325
void BKE_sequencer_clear_scene_in_allseqs(struct Main *bmain, struct Scene *sce);
 
326
void BKE_sequencer_clear_movieclip_in_clipboard(struct MovieClip *clip);
 
327
void BKE_sequencer_clear_mask_in_clipboard(struct Mask *mask);
 
328
 
 
329
struct Sequence *BKE_sequence_get_by_name(struct ListBase *seqbase, const char *name, int recursive);
302
330
 
303
331
/* api for adding new sequence strips */
304
332
typedef struct SeqLoadInfo {
305
333
        int start_frame;
306
334
        int end_frame;
307
335
        int channel;
308
 
        int flag;       /* use sound, replace sel */
 
336
        int flag;   /* use sound, replace sel */
309
337
        int type;
310
338
        int tot_success;
311
339
        int tot_error;
312
 
        int len;                /* only for image strips */
 
340
        int len;        /* only for image strips */
313
341
        char path[512];
314
342
        char name[64];
315
343
} SeqLoadInfo;
316
344
 
317
345
/* SeqLoadInfo.flag */
318
 
#define SEQ_LOAD_REPLACE_SEL    (1<<0)
319
 
#define SEQ_LOAD_FRAME_ADVANCE  (1<<1)
320
 
#define SEQ_LOAD_MOVIE_SOUND    (1<<2)
321
 
#define SEQ_LOAD_SOUND_CACHE    (1<<3)
 
346
#define SEQ_LOAD_REPLACE_SEL    (1 << 0)
 
347
#define SEQ_LOAD_FRAME_ADVANCE  (1 << 1)
 
348
#define SEQ_LOAD_MOVIE_SOUND    (1 << 2)
 
349
#define SEQ_LOAD_SOUND_CACHE    (1 << 3)
322
350
 
323
351
 
324
352
/* seq_dupli' flags */
325
 
#define SEQ_DUPE_UNIQUE_NAME    (1<<0)
326
 
#define SEQ_DUPE_CONTEXT                (1<<1)
327
 
#define SEQ_DUPE_ANIM                   (1<<2)
328
 
#define SEQ_DUPE_ALL                    (1<<3) /* otherwise only selected are copied */
 
353
#define SEQ_DUPE_UNIQUE_NAME    (1 << 0)
 
354
#define SEQ_DUPE_CONTEXT        (1 << 1)
 
355
#define SEQ_DUPE_ANIM           (1 << 2)
 
356
#define SEQ_DUPE_ALL            (1 << 3) /* otherwise only selected are copied */
329
357
 
330
358
/* use as an api function */
331
359
typedef struct Sequence *(*SeqLoadFunc)(struct bContext *, ListBase *, struct SeqLoadInfo *);
332
360
 
333
 
struct Sequence *alloc_sequence(ListBase *lb, int cfra, int machine);
334
 
 
335
 
void seq_load_apply(struct Scene *scene, struct Sequence *seq, struct SeqLoadInfo *seq_load);
336
 
 
337
 
struct Sequence *sequencer_add_image_strip(struct bContext *C, ListBase *seqbasep, struct SeqLoadInfo *seq_load);
338
 
struct Sequence *sequencer_add_sound_strip(struct bContext *C, ListBase *seqbasep, struct SeqLoadInfo *seq_load);
339
 
struct Sequence *sequencer_add_movie_strip(struct bContext *C, ListBase *seqbasep, struct SeqLoadInfo *seq_load);
 
361
struct Sequence *BKE_sequence_alloc(ListBase *lb, int cfra, int machine);
 
362
 
 
363
void BKE_sequence_alpha_mode_from_extension(struct Sequence *seq);
 
364
void BKE_sequence_init_colorspace(struct Sequence *seq);
 
365
 
 
366
struct Sequence *BKE_sequencer_add_image_strip(struct bContext *C, ListBase *seqbasep, struct SeqLoadInfo *seq_load);
 
367
struct Sequence *BKE_sequencer_add_sound_strip(struct bContext *C, ListBase *seqbasep, struct SeqLoadInfo *seq_load);
 
368
struct Sequence *BKE_sequencer_add_movie_strip(struct bContext *C, ListBase *seqbasep, struct SeqLoadInfo *seq_load);
340
369
 
341
370
/* view3d draw callback, run when not in background view */
342
 
typedef struct ImBuf *(*SequencerDrawView)(struct Scene *, struct Object *, int, int, unsigned int, int, int, char[256]);
 
371
typedef struct ImBuf *(*SequencerDrawView)(struct Scene *, struct Object *, int, int, unsigned int, int, int, int, int, char[256]);
343
372
extern SequencerDrawView sequencer_view3d_cb;
344
373
 
345
374
/* copy/paste */
346
375
extern ListBase seqbase_clipboard;
347
376
extern int seqbase_clipboard_frame;
348
377
 
349
 
#endif // __BKE_SEQUENCER_H__
 
378
/* modifiers */
 
379
typedef struct SequenceModifierTypeInfo {
 
380
        /* default name for the modifier */
 
381
        char name[64];  /* MAX_NAME */
 
382
 
 
383
        /* DNA structure name used on load/save filed */
 
384
        char struct_name[64];  /* MAX_NAME */
 
385
 
 
386
        /* size of modifier data structure, used by allocation */
 
387
        int struct_size;
 
388
 
 
389
        /* data initialization */
 
390
        void (*init_data) (struct SequenceModifierData *smd);
 
391
 
 
392
        /* free data used by modifier,
 
393
         * only modifier-specific data should be freed, modifier descriptor would
 
394
         * be freed outside of this callback
 
395
         */
 
396
        void (*free_data) (struct SequenceModifierData *smd);
 
397
 
 
398
        /* copy data from one modifier to another */
 
399
        void (*copy_data) (struct SequenceModifierData *smd, struct SequenceModifierData *target);
 
400
 
 
401
        /* apply modifier on a given image buffer */
 
402
        void (*apply) (struct SequenceModifierData *smd, struct ImBuf *ibuf, struct ImBuf *mask);
 
403
} SequenceModifierTypeInfo;
 
404
 
 
405
struct SequenceModifierTypeInfo *BKE_sequence_modifier_type_info_get(int type);
 
406
 
 
407
struct SequenceModifierData *BKE_sequence_modifier_new(struct Sequence *seq, const char *name, int type);
 
408
int BKE_sequence_modifier_remove(struct Sequence *seq, struct SequenceModifierData *smd);
 
409
void BKE_sequence_modifier_clear(struct Sequence *seq);
 
410
void BKE_sequence_modifier_free(struct SequenceModifierData *smd);
 
411
void BKE_sequence_modifier_unique_name(struct Sequence *seq, struct SequenceModifierData *smd);
 
412
struct SequenceModifierData *BKE_sequence_modifier_find_by_name(struct Sequence *seq, char *name);
 
413
struct ImBuf *BKE_sequence_modifier_apply_stack(SeqRenderData context, struct Sequence *seq, struct ImBuf *ibuf, int cfra);
 
414
void BKE_sequence_modifier_list_copy(struct Sequence *seqn, struct Sequence *seq);
 
415
 
 
416
int BKE_sequence_supports_modifiers(struct Sequence *seq);
 
417
 
 
418
/* internal filters */
 
419
struct ImBuf *BKE_sequencer_render_mask_input(SeqRenderData context, int mask_input_type, struct Sequence *mask_sequence, struct Mask *mask_id, int cfra, int make_float);
 
420
void BKE_sequencer_color_balance_apply(struct StripColorBalance *cb, struct ImBuf *ibuf, float mul, short make_float, struct ImBuf *mask_input);
 
421
 
 
422
#endif /* __BKE_SEQUENCER_H__ */