diff options
author | Ton Roosendaal <ton@blender.org> | 2009-01-12 22:02:08 +0300 |
---|---|---|
committer | Ton Roosendaal <ton@blender.org> | 2009-01-12 22:02:08 +0300 |
commit | 03fc5696dc154259dea599b805c94c82b58e70b6 (patch) | |
tree | 18839fb1ba9f76fdd271022db310be7b2f8d3485 /source/blender/editors | |
parent | ca45efba287a1758e1fa46c6316b397956dbe586 (diff) |
2.5
12k lines of sequencer back! Only seqaudio.c skipped for now.
Notes:
- it only draws now, nothing refreshes or edits.
- fixed bug in view2d.c with vertical grid step being 0.0f
- render code and fileselect code is #ifdeffed out
- sequence evaluation code moved to blenkernel, so it can
be used for render without bad level calls
General note; sequencer code is very untidy, mixing styles too
much. Tried to clean it some, but it would be nice if formatting
is kept consistant from now on.
Diffstat (limited to 'source/blender/editors')
-rw-r--r-- | source/blender/editors/interface/view2d.c | 8 | ||||
-rw-r--r-- | source/blender/editors/space_sequencer/Makefile | 2 | ||||
-rw-r--r-- | source/blender/editors/space_sequencer/SConscript | 1 | ||||
-rw-r--r-- | source/blender/editors/space_sequencer/editseq.c | 3985 | ||||
-rw-r--r-- | source/blender/editors/space_sequencer/sequencer_draw.c | 1135 | ||||
-rw-r--r-- | source/blender/editors/space_sequencer/sequencer_intern.h | 28 | ||||
-rw-r--r-- | source/blender/editors/space_sequencer/sequencer_scopes.c | 701 | ||||
-rw-r--r-- | source/blender/editors/space_sequencer/space_sequencer.c | 27 |
8 files changed, 5856 insertions, 31 deletions
diff --git a/source/blender/editors/interface/view2d.c b/source/blender/editors/interface/view2d.c index b412641284d..daca401ab50 100644 --- a/source/blender/editors/interface/view2d.c +++ b/source/blender/editors/interface/view2d.c @@ -1522,9 +1522,11 @@ void UI_view2d_scrollers_draw(const bContext *C, View2D *v2d, View2DScrollers *v fac += 0.5f * dfac; /* draw vertical steps */ - for (; fac < vert.ymax; fac+= dfac, val += grid->dy) { - scroll_printstr(vs, scene, (float)(vert.xmax)-14.0f, fac, val, grid->powery, vs->yunits, 'v'); - } + if (dfac != 0.0f) { + for (; fac < vert.ymax; fac+= dfac, val += grid->dy) { + scroll_printstr(vs, scene, (float)(vert.xmax)-14.0f, fac, val, grid->powery, vs->yunits, 'v'); + } + } } /* decoration outer bevel line */ diff --git a/source/blender/editors/space_sequencer/Makefile b/source/blender/editors/space_sequencer/Makefile index f6f837a107a..052e191cb7d 100644 --- a/source/blender/editors/space_sequencer/Makefile +++ b/source/blender/editors/space_sequencer/Makefile @@ -38,6 +38,8 @@ CFLAGS += $(LEVEL_1_C_WARNINGS) CPPFLAGS += -I$(NAN_GLEW)/include CPPFLAGS += -I$(OPENGL_HEADERS) +CPPFLAGS += -I$(NAN_BMFONT)/include + # not very neat.... CPPFLAGS += -I../../windowmanager CPPFLAGS += -I../../blenloader diff --git a/source/blender/editors/space_sequencer/SConscript b/source/blender/editors/space_sequencer/SConscript index e6c40474d25..29781202e05 100644 --- a/source/blender/editors/space_sequencer/SConscript +++ b/source/blender/editors/space_sequencer/SConscript @@ -5,5 +5,6 @@ sources = env.Glob('*.c') incs = '../include ../../blenlib ../../blenkernel ../../makesdna ../../imbuf' incs += ' ../../windowmanager #/intern/guardedalloc #/extern/glew/include' +incs += ' #intern/bmfont' env.BlenderLib ( 'bf_editors_space_sequencer', sources, Split(incs), [], libtype=['core'], priority=[100] ) diff --git a/source/blender/editors/space_sequencer/editseq.c b/source/blender/editors/space_sequencer/editseq.c new file mode 100644 index 00000000000..d9a0f4817e2 --- /dev/null +++ b/source/blender/editors/space_sequencer/editseq.c @@ -0,0 +1,3985 @@ +/** + * $Id$ + * + * ***** BEGIN GPL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * Contributor(s): Blender Foundation, 2003-2009 + * + * ***** END GPL LICENSE BLOCK ***** + */ + +#include <stdlib.h> +#include <math.h> +#include <string.h> + +#ifndef WIN32 +#include <unistd.h> +#else +#include <io.h> +#endif +#include <sys/types.h> + +#include "MEM_guardedalloc.h" + +#include "BLI_blenlib.h" +#include "BLI_arithb.h" +#include "BLI_storage_types.h" + +#include "IMB_imbuf_types.h" +#include "IMB_imbuf.h" + +#include "DNA_ipo_types.h" +#include "DNA_curve_types.h" +#include "DNA_scene_types.h" +#include "DNA_screen_types.h" +#include "DNA_space_types.h" +#include "DNA_sequence_types.h" +#include "DNA_view2d_types.h" +#include "DNA_userdef_types.h" +#include "DNA_sound_types.h" + +#include "BKE_context.h" +#include "BKE_global.h" +#include "BKE_image.h" +#include "BKE_library.h" +#include "BKE_main.h" +#include "BKE_plugin_types.h" +#include "BKE_sequence.h" +#include "BKE_scene.h" +#include "BKE_utildefines.h" + +#include "BIF_gl.h" +#include "BIF_glutil.h" + +#include "WM_types.h" + +#include "ED_anim_api.h" +#include "ED_space_api.h" +#include "ED_types.h" + +#include "UI_interface.h" +#include "UI_resources.h" +#include "UI_view2d.h" + +/* own include */ +#include "sequencer_intern.h" + +/* XXX */ +static Sequence *_last_seq=0; +static int _last_seq_init=0; +/* XXX */ +static void BIF_undo_push() {} +static void error() {} +static void waitcursor() {} +static void activate_fileselect() {} +static void std_rmouse_transform() {} +static int get_mbut() {return 0;} +static int pupmenu() {return 0;} +static int pupmenu_col() {return 0;} +static int okee() {return 0;} +static void *find_nearest_marker() {return NULL;} +static void deselect_markers() {} +static void transform_markers() {} +static void transform_seq_nomarker() {} +#define SCE_MARKERS 0 +/* XXX */ + + +#ifdef WIN32 +char last_imagename[FILE_MAXDIR+FILE_MAXFILE]= "c:\\"; +#else +char last_imagename[FILE_MAXDIR+FILE_MAXFILE]= "/"; +#endif + +char last_sounddir[FILE_MAXDIR+FILE_MAXFILE]= ""; + +#define SEQ_DESEL ~(SELECT+SEQ_LEFTSEL+SEQ_RIGHTSEL) + +typedef struct TransSeq { + int start, machine; + int startstill, endstill; + int startdisp, enddisp; + int startofs, endofs; + int final_left, final_right; + int len; +} TransSeq; + +Sequence *get_last_seq(Scene *scene) +{ + if(!_last_seq_init) { + Editing *ed; + Sequence *seq; + Sequence *l_sel = NULL; + Sequence *l_act = NULL; + + ed= scene->ed; + if(!ed) return NULL; + + for(seq= ed->seqbasep->first; seq; seq=seq->next) { + if(seq->flag & SEQ_ACTIVE) + l_act = seq; + if(seq->flag & SELECT) + l_sel = seq; + } + + if (l_act) { + _last_seq = l_act; + } else { + _last_seq = l_sel; + } + + if (_last_seq) { + _last_seq->flag |= SEQ_ACTIVE; + } + + _last_seq_init = 1; + } + + return _last_seq; +} + +void set_last_seq(Sequence *seq) +{ + if (_last_seq_init && _last_seq) { + _last_seq->flag &= ~SEQ_ACTIVE; + } + + _last_seq = seq; + _last_seq_init = 1; + + if (_last_seq) { + _last_seq->flag |= SEQ_ACTIVE; + } +} + +void clear_last_seq() +{ + if (_last_seq_init && _last_seq) { + _last_seq->flag &= ~SEQ_ACTIVE; + } + _last_seq = NULL; + _last_seq_init = 0; +} + +Sequence *get_forground_frame_seq(Scene *scene, int frame) +{ + Editing *ed; + Sequence *seq, *best_seq=NULL; + int best_machine = -1; + ed= scene->ed; + if(!ed) return NULL; + + for (seq=ed->seqbasep->first; seq; seq= seq->next) { + if(seq->startdisp > frame || seq->enddisp <= frame) + continue; + /* only use elements you can see - not */ + if (ELEM6(seq->type, SEQ_IMAGE, SEQ_META, SEQ_SCENE, SEQ_MOVIE, SEQ_MOVIE_AND_HD_SOUND, SEQ_COLOR)) { + if (seq->machine > best_machine) { + best_seq = seq; + best_machine = seq->machine; + } + } + } + return best_seq; +} + +/* seq funcs's for transforming internally + notice the difference between start/end and left/right. + + left and right are the bounds at which the sequence is rendered, +start and end are from the start and fixed length of the sequence. +*/ +int seq_tx_get_start(Sequence *seq) { + return seq->start; +} +int seq_tx_get_end(Sequence *seq) +{ + return seq->start+seq->len; +} + +int seq_tx_get_final_left(Sequence *seq, int metaclip) +{ + if (metaclip && seq->tmp) { + /* return the range clipped by the parents range */ + return MAX2( seq_tx_get_final_left(seq, 0), seq_tx_get_final_left((Sequence *)seq->tmp, 1) ); + } else { + return (seq->start - seq->startstill) + seq->startofs; + } + +} +int seq_tx_get_final_right(Sequence *seq, int metaclip) +{ + if (metaclip && seq->tmp) { + /* return the range clipped by the parents range */ + return MIN2( seq_tx_get_final_right(seq, 0), seq_tx_get_final_right((Sequence *)seq->tmp, 1) ); + } else { + return ((seq->start+seq->len) + seq->endstill) - seq->endofs; + } +} + +void seq_tx_set_final_left(Sequence *seq, int val) +{ + if (val < (seq)->start) { + seq->startstill = abs(val - (seq)->start); + (seq)->startofs = 0; + } else { + seq->startofs = abs(val - (seq)->start); + seq->startstill = 0; + } +} + +void seq_tx_set_final_right(Sequence *seq, int val) +{ + if (val > (seq)->start + (seq)->len) { + seq->endstill = abs(val - (seq->start + (seq)->len)); + (seq)->endofs = 0; + } else { + seq->endofs = abs(val - ((seq)->start + (seq)->len)); + seq->endstill = 0; + } +} + +/* check if one side can be transformed */ +int seq_tx_check_left(Sequence *seq) +{ + if (seq->flag & SELECT) { + if (seq->flag & SEQ_LEFTSEL) + return 1; + else if (seq->flag & SEQ_RIGHTSEL) + return 0; + + return 1; /* selected and neither left or right handles are, so let us move both */ + } + return 0; +} + +int seq_tx_check_right(Sequence *seq) +{ + if (seq->flag & SELECT) { + if (seq->flag & SEQ_RIGHTSEL) + return 1; + else if (seq->flag & SEQ_LEFTSEL) + return 0; + + return 1; /* selected and neither left or right handles are, so let us move both */ + } + return 0; +} + +/* used so we can do a quick check for single image seq + since they work a bit differently to normal image seq's (during transform) */ +int check_single_seq(Sequence *seq) +{ + if ( seq->len==1 && (seq->type == SEQ_IMAGE || seq->type == SEQ_COLOR)) + return 1; + else + return 0; +} + +static void fix_single_image_seq(Sequence *seq) +{ + int left, start, offset; + if (!check_single_seq(seq)) + return; + + /* make sure the image is always at the start since there is only one, + adjusting its start should be ok */ + left = seq_tx_get_final_left(seq, 0); + start = seq->start; + if (start != left) { + offset = left - start; + seq_tx_set_final_left( seq, seq_tx_get_final_left(seq, 0) - offset ); + seq_tx_set_final_right( seq, seq_tx_get_final_right(seq, 0) - offset ); + seq->start += offset; + } +} + +int test_overlap_seq(Scene *scene, Sequence *test) +{ + Sequence *seq; + Editing *ed; + + ed= scene->ed; + if(ed==NULL) return 0; + + seq= ed->seqbasep->first; + while(seq) { + if(seq!=test) { + if(test->machine==seq->machine) { + if(test->depth==seq->depth) { + if( (test->enddisp <= seq->startdisp) || (test->startdisp >= seq->enddisp) ); + else return 1; + } + } + } + seq= seq->next; + } + return 0; +} + +void shuffle_seq(Scene *scene, Sequence *test) +{ + Editing *ed; + Sequence *seq; + int a, start; + + ed= scene->ed; + if(ed==NULL) return; + + /* is there more than 1 select: only shuffle y */ + a=0; + seq= ed->seqbasep->first; + while(seq) { + if(seq->flag & SELECT) a++; + seq= seq->next; + } + + if(a<2 && test->type==SEQ_IMAGE) { + start= test->start; + + for(a= 1; a<50; a++) { + test->start= start+a; + calc_sequence(test); + if( test_overlap_seq(scene, test)==0) return; + test->start= start-a; + calc_sequence(test); + if( test_overlap_seq(scene, test)==0) return; + } + test->start= start; + } + + test->machine++; + calc_sequence(test); + while( test_overlap_seq(scene, test) ) { + if(test->machine >= MAXSEQ) { + error("There is no more space to add a sequence strip"); + + BLI_remlink(ed->seqbasep, test); + seq_free_sequence(test); + return; + } + test->machine++; + calc_sequence(test); + } +} + +static void change_plugin_seq(Scene *scene, char *str) /* called from fileselect */ +{ + struct SeqEffectHandle sh; + Sequence *last_seq= get_last_seq(scene); + + if(last_seq && last_seq->type != SEQ_PLUGIN) return; + + sh = get_sequence_effect(last_seq); + sh.free(last_seq); + sh.init_plugin(last_seq, str); + + last_seq->machine = MAX3(last_seq->seq1->machine, + last_seq->seq2->machine, + last_seq->seq3->machine); + + if( test_overlap_seq(scene, last_seq) ) shuffle_seq(scene, last_seq); + + BIF_undo_push("Load/Change Plugin, Sequencer"); +} + + +void boundbox_seq(Scene *scene, rctf *rect) +{ + Sequence *seq; + Editing *ed; + float min[2], max[2]; + + ed= scene->ed; + if(ed==NULL) return; + + min[0]= 0.0; + max[0]= EFRA+1; + min[1]= 0.0; + max[1]= 8.0; + + seq= ed->seqbasep->first; + while(seq) { + + if( min[0] > seq->startdisp-1) min[0]= seq->startdisp-1; + if( max[0] < seq->enddisp+1) max[0]= seq->enddisp+1; + if( max[1] < seq->machine+2.0) max[1]= seq->machine+2.0; + + seq= seq->next; + } + + rect->xmin= min[0]; + rect->xmax= max[0]; + rect->ymin= min[1]; + rect->ymax= max[1]; + +} + +int sequence_is_free_transformable(Sequence * seq) +{ + return seq->type < SEQ_EFFECT + || (get_sequence_effect_num_inputs(seq->type) == 0); +} + +char mouse_cfra_side(View2D *v2d, int frame ) +{ + short mval[2]; + float xmouse, ymouse; +// getmouseco_areawin(mval); + + /* choose the side based on which side of the playhead the mouse is on */ + UI_view2d_region_to_view(v2d, mval[0], mval[1], &xmouse, &ymouse); + return (xmouse > frame) ? 'R' : 'L'; +} + +Sequence *find_neighboring_sequence(Scene *scene, Sequence *test, int lr, int sel) +{ +/* looks to the left on lr==1, to the right on lr==2 + sel - 0==unselected, 1==selected, -1==done care*/ + Sequence *seq; + Editing *ed; + + ed= scene->ed; + if(ed==NULL) return 0; + + if (sel>0) sel = SELECT; + + seq= ed->seqbasep->first; + while(seq) { + if( (seq!=test) && + (test->machine==seq->machine) && + (test->depth==seq->depth) && + ((sel == -1) || (sel && (seq->flag & SELECT)) || (sel==0 && (seq->flag & SELECT)==0) )) + { + switch (lr) { + case 1: + if (test->startdisp == (seq->enddisp)) { + return seq; + } + break; + case 2: + if (test->enddisp == (seq->startdisp)) { + return seq; + } + break; + } + } + seq= seq->next; + } + return NULL; +} + +Sequence *find_next_prev_sequence(Scene *scene, Sequence *test, int lr, int sel) +{ +/* looks to the left on lr==1, to the right on lr==2 + sel - 0==unselected, 1==selected, -1==done care*/ + Sequence *seq,*best_seq = NULL; + Editing *ed; + + int dist, best_dist; + best_dist = MAXFRAME*2; + + ed= scene->ed; + if(ed==NULL) return 0; + + if (sel) sel = SELECT; + + seq= ed->seqbasep->first; + while(seq) { + if( (seq!=test) && + (test->machine==seq->machine) && + (test->depth==seq->depth) && + ((sel == -1) || (sel==(seq->flag & SELECT)))) + { + dist = MAXFRAME*2; + + switch (lr) { + case 1: + if (seq->enddisp <= test->startdisp) { + dist = test->enddisp - seq->startdisp; + } + break; + case 2: + if (seq->startdisp >= test->enddisp) { + dist = seq->startdisp - test->enddisp; + } + break; + } + + if (dist==0) { + best_seq = seq; + break; + } else if (dist < best_dist) { + best_dist = dist; + best_seq = seq; + } + } + seq= seq->next; + } + return best_seq; /* can be null */ +} + + +Sequence *find_nearest_seq(Scene *scene, View2D *v2d, int *hand) +{ + Sequence *seq; + Editing *ed; + float x, y; + short mval[2]; + float pixelx; + float handsize; + float displen; + *hand= 0; + + ed= scene->ed; + if(ed==NULL) return 0; + + pixelx = (v2d->cur.xmax - v2d->cur.xmin)/(v2d->mask.xmax - v2d->mask.xmin); + +// getmouseco_areawin(mval); + UI_view2d_region_to_view(v2d, mval[0], mval[1], &x, &y); + + seq= ed->seqbasep->first; + + while(seq) { + if(seq->machine == (int)y) { + /* check for both normal strips, and strips that have been flipped horizontally */ + if( ((seq->startdisp < seq->enddisp) && (seq->startdisp<=x && seq->enddisp>=x)) || + ((seq->startdisp > seq->enddisp) && (seq->startdisp>=x && seq->enddisp<=x)) ) + { + if(sequence_is_free_transformable(seq)) { + + /* clamp handles to defined size in pixel space */ + + handsize = seq->handsize; + displen = (float)abs(seq->startdisp - seq->enddisp); + + if (displen / pixelx > 16) { /* dont even try to grab the handles of small strips */ + /* Set the max value to handle to 1/3 of the total len when its less then 28. + * This is important because otherwise selecting handles happens even when you click in the middle */ + + if ((displen/3) < 30*pixelx) { + handsize = displen/3; + } else { + CLAMP(handsize, 7*pixelx, 30*pixelx); + } + + if( handsize+seq->startdisp >=x ) + *hand= 1; + else if( -handsize+seq->enddisp <=x ) + *hand= 2; + } + } + return seq; + } + } + seq= seq->next; + } + return 0; +} + +void update_seq_ipo_rect(Scene *scene, View2D *v2d, Sequence *seq) +{ + float start; + float end; + + if (!seq || !seq->ipo) { + return; + } + start = -5.0; + end = 105.0; + + + /* Adjust IPO window to sequence and + avoid annoying snap-back to startframe + when Lock Time is on */ + if (0) { // XXX v2d->flag & V2D_VIEWLOCK) { + if ((seq->flag & SEQ_IPO_FRAME_LOCKED) != 0) { + start = -5.0 + seq->startdisp; + end = 5.0 + seq->enddisp; + } else { + start = (float)scene->r.sfra - 0.1; + end = scene->r.efra; + } + } + + seq->ipo->cur.xmin= start; + seq->ipo->cur.xmax= end; +} + +void update_seq_icu_rects(Sequence * seq) +{ + IpoCurve *icu= NULL; + struct SeqEffectHandle sh; + + if (!seq || !seq->ipo) { + return; + } + + if(!(seq->type & SEQ_EFFECT)) { + return; + } + + sh = get_sequence_effect(seq); + + for(icu= seq->ipo->curve.first; icu; icu= icu->next) { + sh.store_icu_yrange(seq, icu->adrcode, &icu->ymin, &icu->ymax); + } +} + + +static int seq_is_parent(Sequence *par, Sequence *seq) +{ + return ((par->seq1 == seq) || (par->seq2 == seq) || (par->seq3 == seq)); +} + +static int seq_is_predecessor(Sequence *pred, Sequence *seq) +{ + if (!pred) return 0; + if(pred == seq) return 0; + else if(seq_is_parent(pred, seq)) return 1; + else if(pred->seq1 && seq_is_predecessor(pred->seq1, seq)) return 1; + else if(pred->seq2 && seq_is_predecessor(pred->seq2, seq)) return 1; + else if(pred->seq3 && seq_is_predecessor(pred->seq3, seq)) return 1; + + return 0; +} + +static void deselect_all_seq(Scene *scene) +{ + Sequence *seq; + Editing *ed; + + ed= scene->ed; + if(ed==NULL) return; + + SEQP_BEGIN(ed, seq) { + seq->flag &= SEQ_DESEL; + } + SEQ_END + + BIF_undo_push("(De)select all Strips, Sequencer"); +} + +static void recurs_sel_seq(Sequence *seqm) +{ + Sequence *seq; + + seq= seqm->seqbase.first; + while(seq) { + + if(seqm->flag & (SEQ_LEFTSEL+SEQ_RIGHTSEL)) seq->flag &= SEQ_DESEL; + else if(seqm->flag & SELECT) seq->flag |= SELECT; + else seq->flag &= SEQ_DESEL; + + if(seq->seqbase.first) recurs_sel_seq(seq); + + seq= seq->next; + } +} + +void select_single_seq(Scene *scene, Sequence *seq, int deselect_all) +{ + if(deselect_all) + deselect_all_seq(scene); + set_last_seq(seq); + + if((seq->type==SEQ_IMAGE) || (seq->type==SEQ_MOVIE)) { + if(seq->strip) + strncpy(last_imagename, seq->strip->dir, FILE_MAXDIR-1); + } + else if((seq->type==SEQ_HD_SOUND) || (seq->type==SEQ_RAM_SOUND)) { + if(seq->strip) + strncpy(last_sounddir, seq->strip->dir, FILE_MAXDIR-1); + } + seq->flag|= SELECT; + recurs_sel_seq(seq); +} + +void swap_select_seq(Scene *scene) +{ + Sequence *seq; + Editing *ed; + int sel=0; + + ed= scene->ed; + if(ed==NULL) return; + + SEQP_BEGIN(ed, seq) { + if(seq->flag & SELECT) sel= 1; + } + SEQ_END + + SEQP_BEGIN(ed, seq) { + /* always deselect all to be sure */ + seq->flag &= SEQ_DESEL; + if(sel==0) seq->flag |= SELECT; + } + SEQ_END + + BIF_undo_push("Swap Selected Strips, Sequencer"); + +} + +void select_channel_direction(Scene *scene, Sequence *test,int lr) { +/* selects all strips in a channel to one direction of the passed strip */ + Sequence *seq; + Editing *ed; + + ed= scene->ed; + if(ed==NULL) return; + + seq= ed->seqbasep->first; + while(seq) { + if(seq!=test) { + if (test->machine==seq->machine) { + if(test->depth==seq->depth) { + if (((lr==1)&&(test->startdisp > (seq->startdisp)))||((lr==2)&&(test->startdisp < (seq->startdisp)))) { + seq->flag |= SELECT; + recurs_sel_seq(seq); + } + } + } + } + seq= seq->next; + } + test->flag |= SELECT; + recurs_sel_seq(test); +} + +void select_dir_from_last(Scene *scene, int lr) +{ + Sequence *seq=get_last_seq(scene); + if (seq==NULL) + return; + + select_channel_direction(scene, seq,lr); + + if (lr==1) BIF_undo_push("Select Strips to the Left, Sequencer"); + else BIF_undo_push("Select Strips to the Right, Sequencer"); +} + +void select_surrounding_handles(Scene *scene, Sequence *test) +{ + Sequence *neighbor; + + neighbor=find_neighboring_sequence(scene, test, 1, -1); + if (neighbor) { + neighbor->flag |= SELECT; + recurs_sel_seq(neighbor); + neighbor->flag |= SEQ_RIGHTSEL; + } + neighbor=find_neighboring_sequence(scene, test, 2, -1); + if (neighbor) { + neighbor->flag |= SELECT; + recurs_sel_seq(neighbor); + neighbor->flag |= SEQ_LEFTSEL; + } + test->flag |= SELECT; +} + +void select_surround_from_last(Scene *scene) +{ + Sequence *seq=get_last_seq(scene); + + if (seq==NULL) + return; + + select_surrounding_handles(scene, seq); + BIF_undo_push("Select Surrounding Handles, Sequencer"); +} + +void select_neighbor_from_last(Scene *scene, int lr) +{ + Sequence *seq=get_last_seq(scene); + Sequence *neighbor; + int change = 0; + if (seq) { + neighbor=find_neighboring_sequence(scene, seq, lr, -1); + if (neighbor) { + switch (lr) { + case 1: + neighbor->flag |= SELECT; + recurs_sel_seq(neighbor); + neighbor->flag |= SEQ_RIGHTSEL; + seq->flag |= SEQ_LEFTSEL; + break; + case 2: + neighbor->flag |= SELECT; + recurs_sel_seq(neighbor); + neighbor->flag |= SEQ_LEFTSEL; + seq->flag |= SEQ_RIGHTSEL; + break; + } + seq->flag |= SELECT; + change = 1; + } + } + if (change) { + + if (lr==1) BIF_undo_push("Select Left Handles, Sequencer"); + else BIF_undo_push("Select Right Handles, Sequencer"); + } +} + +void mouse_select_seq(Scene *scene, View2D *v2d) +{ + Sequence *seq,*neighbor; + int hand,seldir, shift= 0; // XXX + TimeMarker *marker; + + marker=find_nearest_marker(SCE_MARKERS, 1); + + if (marker) { + int oldflag; + /* select timeline marker */ + if (shift) { + oldflag= marker->flag; + if (oldflag & SELECT) + marker->flag &= ~SELECT; + else + marker->flag |= SELECT; + } + else { + deselect_markers(0, 0); + marker->flag |= SELECT; + } + + BIF_undo_push("Select Strips, Sequencer"); + + } else { + + seq= find_nearest_seq(scene, v2d, &hand); + if(0) // !(G.qual & LR_SHIFTKEY)&&!(G.qual & LR_ALTKEY)&&!(G.qual & LR_CTRLKEY)) + deselect_all_seq(scene); + + if(seq) { + set_last_seq(seq); + + if ((seq->type == SEQ_IMAGE) || (seq->type == SEQ_MOVIE)) { + if(seq->strip) { + strncpy(last_imagename, seq->strip->dir, FILE_MAXDIR-1); + } + } else + if (seq->type == SEQ_HD_SOUND || seq->type == SEQ_RAM_SOUND) { + if(seq->strip) { + strncpy(last_sounddir, seq->strip->dir, FILE_MAXDIR-1); + } + } + + if(0) { // XXX (G.qual & LR_SHIFTKEY) && (seq->flag & SELECT)) { + if(hand==0) seq->flag &= SEQ_DESEL; + else if(hand==1) { + if(seq->flag & SEQ_LEFTSEL) + seq->flag &= ~SEQ_LEFTSEL; + else seq->flag |= SEQ_LEFTSEL; + } + else if(hand==2) { + if(seq->flag & SEQ_RIGHTSEL) + seq->flag &= ~SEQ_RIGHTSEL; + else seq->flag |= SEQ_RIGHTSEL; + } + } + else { + seq->flag |= SELECT; + if(hand==1) seq->flag |= SEQ_LEFTSEL; + if(hand==2) seq->flag |= SEQ_RIGHTSEL; + } + + /* On Ctrl-Alt selection, select the strip and bordering handles */ + if (0) { // XXX (G.qual & LR_CTRLKEY) && (G.qual & LR_ALTKEY)) { + // XXX if (!(G.qual & LR_SHIFTKEY)) deselect_all_seq(scene); + seq->flag |= SELECT; + select_surrounding_handles(scene, seq); + + /* Ctrl signals Left, Alt signals Right + First click selects adjacent handles on that side. + Second click selects all strips in that direction. + If there are no adjacent strips, it just selects all in that direction. */ + } else if (0) { // XXX ((G.qual & LR_CTRLKEY) || (G.qual & LR_ALTKEY)) && (seq->flag & SELECT)) { + + if (0); // G.qual & LR_CTRLKEY) seldir=1; + else seldir=2; + neighbor=find_neighboring_sequence(scene, seq, seldir, -1); + if (neighbor) { + switch (seldir) { + case 1: + if ((seq->flag & SEQ_LEFTSEL)&&(neighbor->flag & SEQ_RIGHTSEL)) { +// XXX if (!(G.qual & LR_SHIFTKEY)) deselect_all_seq(scene); + select_channel_direction(scene, seq,1); + } else { + neighbor->flag |= SELECT; + recurs_sel_seq(neighbor); + neighbor->flag |= SEQ_RIGHTSEL; + seq->flag |= SEQ_LEFTSEL; + } + break; + case 2: + if ((seq->flag & SEQ_RIGHTSEL)&&(neighbor->flag & SEQ_LEFTSEL)) { +// XXX if (!(G.qual & LR_SHIFTKEY)) deselect_all_seq(scene); + select_channel_direction(scene, seq,2); + } else { + neighbor->flag |= SELECT; + recurs_sel_seq(neighbor); + neighbor->flag |= SEQ_LEFTSEL; + seq->flag |= SEQ_RIGHTSEL; + } + break; + } + } else { +// XXX if (!(G.qual & LR_SHIFTKEY)) deselect_all_seq(scene); + select_channel_direction(scene, seq,seldir); + } + } + + recurs_sel_seq(seq); + } + + + BIF_undo_push("Select Strips, Sequencer"); + + std_rmouse_transform(transform_seq_nomarker); + } + + /* marker transform */ + if (marker) { + short mval[2], xo, yo; +// getmouseco_areawin(mval); + xo= mval[0]; + yo= mval[1]; + + while(get_mbut()) { +// getmouseco_areawin(mval); + if(abs(mval[0]-xo)+abs(mval[1]-yo) > 4) { + transform_markers('g', 0); + return; + } + } + } +} + + +Sequence *alloc_sequence(ListBase *lb, int cfra, int machine) +{ + Sequence *seq; + + /*ed= scene->ed;*/ + + seq= MEM_callocN( sizeof(Sequence), "addseq"); + BLI_addtail(lb, seq); + + set_last_seq(seq); + + *( (short *)seq->name )= ID_SEQ; + seq->name[2]= 0; + + seq->flag= SELECT; + seq->start= cfra; + seq->machine= machine; + seq->mul= 1.0; + seq->blend_opacity = 100.0; + + return seq; +} + +static Sequence *sfile_to_sequence(Scene *scene, SpaceFile *sfile, int cfra, int machine, int last) +{ +#if 0 + /* XXX sfile recoded... */ + Sequence *seq; + Strip *strip; + StripElem *se; + int totsel, a; + char name[160]; + + /* are there selected files? */ + totsel= 0; + for(a=0; a<sfile->totfile; a++) { + if(sfile->filelist[a].flags & ACTIVE) { + if( (sfile->filelist[a].type & S_IFDIR)==0 ) { + totsel++; + } + } + } + + if(last) { + /* if not, a file handed to us? */ + if(totsel==0 && sfile->file[0]) totsel= 1; + } + + if(totsel==0) return 0; + + /* make seq */ + seq= alloc_sequence(((Editing *)scene->ed)->seqbasep, cfra, machine); + seq->len= totsel; + + if(totsel==1) { + seq->startstill= 25; + seq->endstill= 24; + } + + calc_sequence(seq); + + if(sfile->flag & FILE_STRINGCODE) { + strcpy(name, sfile->dir); + BLI_makestringcode(G.sce, name); + } else { + strcpy(name, sfile->dir); + } + + /* strip and stripdata */ + seq->strip= strip= MEM_callocN(sizeof(Strip), "strip"); + strip->len= totsel; + strip->us= 1; + strncpy(strip->dir, name, FILE_MAXDIR-1); + strip->stripdata= se= MEM_callocN(totsel*sizeof(StripElem), "stripelem"); + + for(a=0; a<sfile->totfile; a++) { + if(sfile->filelist[a].flags & ACTIVE) { + if( (sfile->filelist[a].type & S_IFDIR)==0 ) { + strncpy(se->name, sfile->filelist[a].relname, FILE_MAXFILE-1); + se++; + } + } + } + /* no selected file: */ + if(totsel==1 && se==strip->stripdata) { + strncpy(se->name, sfile->file, FILE_MAXFILE-1); + } + + /* last active name */ + strncpy(last_imagename, seq->strip->dir, FILE_MAXDIR-1); + + return seq; +#endif + return NULL; +} + + +#if 0 +static int sfile_to_mv_sequence_load(Scene *scene, SpaceFile *sfile, int cfra, + int machine, int index ) +{ + /* XXX sfile recoded... */ + Sequence *seq; + struct anim *anim; + Strip *strip; + StripElem *se; + int totframe; + char name[160]; + char str[FILE_MAXDIR+FILE_MAXFILE]; + + totframe= 0; + + strncpy(str, sfile->dir, FILE_MAXDIR-1); + if(index<0) + strncat(str, sfile->file, FILE_MAXDIR-1); + else + strncat(str, sfile->filelist[index].relname, FILE_MAXDIR-1); + + /* is it a movie? */ + anim = openanim(str, IB_rect); + if(anim==0) { + error("The selected file is not a movie or " + "FFMPEG-support not compiled in!"); + return(cfra); + } + + totframe= IMB_anim_get_duration(anim); + + /* make seq */ + seq= alloc_sequence(((Editing *)scene->ed)->seqbasep, cfra, machine); + seq->len= totframe; + seq->type= SEQ_MOVIE; + seq->anim= anim; + seq->anim_preseek = IMB_anim_get_preseek(anim); + + calc_sequence(seq); + + if(sfile->flag & FILE_STRINGCODE) { + strcpy(name, sfile->dir); + BLI_makestringcode(G.sce, name); + } else { + strcpy(name, sfile->dir); + } + + /* strip and stripdata */ + seq->strip= strip= MEM_callocN(sizeof(Strip), "strip"); + strip->len= totframe; + strip->us= 1; + strncpy(strip->dir, name, FILE_MAXDIR-1); + strip->stripdata= se= MEM_callocN(sizeof(StripElem), "stripelem"); + + /* name movie in first strip */ + if(index<0) + strncpy(se->name, sfile->file, FILE_MAXFILE-1); + else + strncpy(se->name, sfile->filelist[index].relname, FILE_MAXFILE-1); + + /* last active name */ + strncpy(last_imagename, seq->strip->dir, FILE_MAXDIR-1); + return(cfra+totframe); +} +#endif + +static void sfile_to_mv_sequence(SpaceFile *sfile, int cfra, int machine) +{ +#if 0 + /* XXX sfile recoded... */ + int a, totsel; + + totsel= 0; + for(a= 0; a<sfile->totfile; a++) { + if(sfile->filelist[a].flags & ACTIVE) { + if ((sfile->filelist[a].type & S_IFDIR)==0) { + totsel++; + } + } + } + + if((totsel==0) && (sfile->file[0])) { + cfra= sfile_to_mv_sequence_load(sfile, cfra, machine, -1); + return; + } + + if(totsel==0) return; + + /* ok. check all the select file, and load it. */ + for(a= 0; a<sfile->totfile; a++) { + if(sfile->filelist[a].flags & ACTIVE) { + if ((sfile->filelist[a].type & S_IFDIR)==0) { + /* load and update current frame. */ + cfra= sfile_to_mv_sequence_load(sfile, cfra, machine, a); + } + } + } +#endif +} + +static Sequence *sfile_to_ramsnd_sequence(Scene *scene, SpaceFile *sfile, int cfra, int machine) +{ +#if 0 + /* XXX sfile recoded... */ + Sequence *seq; + bSound *sound; + Strip *strip; + StripElem *se; + double totframe; + char name[160]; + char str[256]; + + totframe= 0.0; + + strncpy(str, sfile->dir, FILE_MAXDIR-1); + strncat(str, sfile->file, FILE_MAXFILE-1); + + sound= sound_new_sound(str); + if (!sound || sound->sample->type == SAMPLE_INVALID) { + error("Unsupported audio format"); + return 0; + } + if (sound->sample->bits != 16) { + error("Only 16 bit audio is supported"); + return 0; + } + sound->id.us=1; + sound->flags |= SOUND_FLAGS_SEQUENCE; + audio_makestream(sound); + + totframe= (int) ( ((float)(sound->streamlen-1)/ + ( (float)scene->r.audio.mixrate*4.0 ))* FPS); + + /* make seq */ + seq= alloc_sequence(((Editing *)scene->ed)->seqbasep, cfra, machine); + seq->len= totframe; + seq->type= SEQ_RAM_SOUND; + seq->sound = sound; + + calc_sequence(seq); + + if(sfile->flag & FILE_STRINGCODE) { + strcpy(name, sfile->dir); + BLI_makestringcode(G.sce, name); + } else { + strcpy(name, sfile->dir); + } + + /* strip and stripdata */ + seq->strip= strip= MEM_callocN(sizeof(Strip), "strip"); + strip->len= totframe; + strip->us= 1; + strncpy(strip->dir, name, FILE_MAXDIR-1); + strip->stripdata= se= MEM_callocN(sizeof(StripElem), "stripelem"); + + /* name sound in first strip */ + strncpy(se->name, sfile->file, FILE_MAXFILE-1); + + /* last active name */ + strncpy(last_sounddir, seq->strip->dir, FILE_MAXDIR-1); + + return seq; +#endif + return NULL; +} + +#if 0 +static int sfile_to_hdsnd_sequence_load(SpaceFile *sfile, int cfra, + int machine, int index) +{ + /* XXX sfile recoded... */ + Sequence *seq; + struct hdaudio *hdaudio; + Strip *strip; + StripElem *se; + int totframe; + char name[160]; + char str[FILE_MAXDIR+FILE_MAXFILE]; + + totframe= 0; + + strncpy(str, sfile->dir, FILE_MAXDIR-1); + if(index<0) + strncat(str, sfile->file, FILE_MAXDIR-1); + else + strncat(str, sfile->filelist[index].relname, FILE_MAXDIR-1); + + /* is it a sound file? */ + hdaudio = sound_open_hdaudio(str); + if(hdaudio==0) { + error("The selected file is not a sound file or " + "FFMPEG-support not compiled in!"); + return(cfra); + } + + totframe= sound_hdaudio_get_duration(hdaudio, FPS); + + /* make seq */ + seq= alloc_sequence(((Editing *)scene->ed)->seqbasep, cfra, machine); + seq->len= totframe; + seq->type= SEQ_HD_SOUND; + seq->hdaudio= hdaudio; + + calc_sequence(seq); + + if(sfile->flag & FILE_STRINGCODE) { + strcpy(name, sfile->dir); + BLI_makestringcode(G.sce, name); + } else { + strcpy(name, sfile->dir); + } + + /* strip and stripdata */ + seq->strip= strip= MEM_callocN(sizeof(Strip), "strip"); + strip->len= totframe; + strip->us= 1; + strncpy(strip->dir, name, FILE_MAXDIR-1); + strip->stripdata= se= MEM_callocN(sizeof(StripElem), "stripelem"); + + /* name movie in first strip */ + if(index<0) + strncpy(se->name, sfile->file, FILE_MAXFILE-1); + else + strncpy(se->name, sfile->filelist[index].relname, FILE_MAXFILE-1); + + /* last active name */ + strncpy(last_sounddir, seq->strip->dir, FILE_MAXDIR-1); + return(cfra+totframe); +} +#endif + +static void sfile_to_hdsnd_sequence(SpaceFile *sfile, int cfra, int machine) +{ +#if 0 + /* XXX sfile recoded... */ + int totsel, a; + + totsel= 0; + for(a= 0; a<sfile->totfile; a++) { + if(sfile->filelist[a].flags & ACTIVE) { + if((sfile->filelist[a].type & S_IFDIR)==0) { + totsel++; + } + } + } + + if((totsel==0) && (sfile->file[0])) { + cfra= sfile_to_hdsnd_sequence_load(sfile, cfra, machine, -1); + return; + } + + if(totsel==0) return; + + /* ok, check all the select file, and load it. */ + for(a= 0; a<sfile->totfile; a++) { + if(sfile->filelist[a].flags & ACTIVE) { + if((sfile->filelist[a].type & S_IFDIR)==0) { + /* load and update current frame. */ + cfra= sfile_to_hdsnd_sequence_load(sfile, cfra, machine, a); + } + } + } +#endif +} + + +static void add_image_strips(Scene *scene, char *name) +{ +#if 0 + /* XXX sfile recoded... */ + + SpaceFile *sfile; + struct direntry *files; + float x, y; + int a, totfile, cfra, machine; + short mval[2]; + + deselect_all_seq(scene); + + /* restore windowmatrices */ +// XXX drawseqspace(curarea, curarea->spacedata.first); + + /* search sfile */ +// sfile= scrarea_find_space_of_type(curarea, SPACE_FILE); + if(sfile==0) return; + + /* where will it be */ +// getmouseco_areawin(mval); + UI_view2d_region_to_view(v2d, mval[0], mval[1], &x, &y); + cfra= (int)(x+0.5); + machine= (int)(y+0.5); + + waitcursor(1); + + /* also read contents of directories */ + files= sfile->filelist; + totfile= sfile->totfile; + sfile->filelist= 0; + sfile->totfile= 0; + + for(a=0; a<totfile; a++) { + if(files[a].flags & ACTIVE) { + if( (files[a].type & S_IFDIR) ) { + strncat(sfile->dir, files[a].relname, FILE_MAXFILE-1); + strcat(sfile->dir,"/"); + read_dir(sfile); + + /* select all */ + swapselect_file(sfile); + + if ( sfile_to_sequence(scene, sfile, cfra, machine, 0) ) machine++; + + parent(sfile); + } + } + } + + sfile->filelist= files; + sfile->totfile= totfile; + + /* read directory itself */ + sfile_to_sequence(scene, sfile, cfra, machine, 1); + + waitcursor(0); + + BIF_undo_push("Add Image Strip, Sequencer"); + transform_seq_nomarker('g', 0); +#endif +} + +static void add_movie_strip(Scene *scene, View2D *v2d, char *name) +{ + + /* XXX sfile recoded... */ + SpaceFile *sfile; + float x, y; + int cfra, machine; + short mval[2]; + + deselect_all_seq(scene); + + /* restore windowmatrices */ +// drawseqspace(curarea, curarea->spacedata.first); + + /* search sfile */ +// sfile= scrarea_find_space_of_type(curarea, SPACE_FILE); + if(sfile==0) return; + + /* where will it be */ +// getmouseco_areawin(mval); + UI_view2d_region_to_view(v2d, mval[0], mval[1], &x, &y); + cfra= (int)(x+0.5); + machine= (int)(y+0.5); + + waitcursor(1); + + /* read directory itself */ + sfile_to_mv_sequence(sfile, cfra, machine); + + waitcursor(0); + + BIF_undo_push("Add Movie Strip, Sequencer"); + transform_seq_nomarker('g', 0); + +} + +static void add_movie_and_hdaudio_strip(Scene *scene, View2D *v2d, char *name) +{ + SpaceFile *sfile; + float x, y; + int cfra, machine; + short mval[2]; + + deselect_all_seq(scene); + + /* restore windowmatrices */ +// areawinset(curarea->win); +// drawseqspace(curarea, curarea->spacedata.first); + + /* search sfile */ +// sfile= scrarea_find_space_of_type(curarea, SPACE_FILE); + if(sfile==0) return; + + /* where will it be */ +// getmouseco_areawin(mval); + UI_view2d_region_to_view(v2d, mval[0], mval[1], &x, &y); + cfra= (int)(x+0.5); + machine= (int)(y+0.5); + + waitcursor(1); + + /* read directory itself */ + sfile_to_hdsnd_sequence(sfile, cfra, machine); + sfile_to_mv_sequence(sfile, cfra, machine); + + waitcursor(0); + + BIF_undo_push("Add Movie and HD-Audio Strip, Sequencer"); + transform_seq_nomarker('g', 0); + +} + +static void add_sound_strip_ram(Scene *scene, View2D *v2d, char *name) +{ + SpaceFile *sfile; + float x, y; + int cfra, machine; + short mval[2]; + + deselect_all_seq(scene); + +// sfile= scrarea_find_space_of_type(curarea, SPACE_FILE); + if (sfile==0) return; + + /* where will it be */ +// getmouseco_areawin(mval); + UI_view2d_region_to_view(v2d, mval[0], mval[1], &x, &y); + cfra= (int)(x+0.5); + machine= (int)(y+0.5); + + waitcursor(1); + + sfile_to_ramsnd_sequence(scene, sfile, cfra, machine); + + waitcursor(0); + + BIF_undo_push("Add Sound (RAM) Strip, Sequencer"); + transform_seq_nomarker('g', 0); +} + +static void add_sound_strip_hd(Scene *scene, View2D *v2d, char *name) +{ + SpaceFile *sfile; + float x, y; + int cfra, machine; + short mval[2]; + + deselect_all_seq(scene); + +// sfile= scrarea_find_space_of_type(curarea, SPACE_FILE); + if (sfile==0) return; + + /* where will it be */ +// getmouseco_areawin(mval); + UI_view2d_region_to_view(v2d, mval[0], mval[1], &x, &y); + cfra= (int)(x+0.5); + machine= (int)(y+0.5); + + waitcursor(1); + + sfile_to_hdsnd_sequence(sfile, cfra, machine); + + waitcursor(0); + + BIF_undo_push("Add Sound (HD) Strip, Sequencer"); + transform_seq_nomarker('g', 0); +} + +static void add_scene_strip(Scene *scene, View2D *v2d, short event) +{ + Sequence *seq; + Strip *strip; + float x, y; + int cfra, machine; + short mval[2]; + + if(event> -1) { + int nr= 1; + Scene * sce= G.main->scene.first; + while(sce) { + if( event==nr) break; + nr++; + sce= sce->id.next; + } + if(sce) { + + deselect_all_seq(scene); + + /* where ? */ +// getmouseco_areawin(mval); + UI_view2d_region_to_view(v2d, mval[0], mval[1], &x, &y); + cfra= (int)(x+0.5); + machine= (int)(y+0.5); + + seq= alloc_sequence(((Editing *)scene->ed)->seqbasep, cfra, machine); + seq->type= SEQ_SCENE; + seq->scene= sce; + seq->sfra= sce->r.sfra; + seq->len= sce->r.efra - sce->r.sfra + 1; + + seq->strip= strip= MEM_callocN(sizeof(Strip), "strip"); + strncpy(seq->name + 2, sce->id.name + 2, + sizeof(seq->name) - 2); + strip->len= seq->len; + strip->us= 1; + + BIF_undo_push("Add Scene Strip, Sequencer"); + transform_seq_nomarker('g', 0); + } + } +} + +#if 0 +static void reload_sound_strip(Scene *scene, char *name) +{ + Editing *ed; + Sequence *seq, *seqact; + SpaceFile *sfile; + Sequence *last_seq= get_last_seq(scene); + + ed= scene->ed; + + if(last_seq==0 || last_seq->type!=SEQ_SOUND) return; + seqact= last_seq; /* last_seq changes in alloc_sequence */ + + /* search sfile */ +// sfile= scrarea_find_space_of_type(curarea, SPACE_FILE); + if(sfile==0) return; + + waitcursor(1); + + seq = sfile_to_snd_sequence(sfile, seqact->start, seqact->machine); + printf("seq->type: %i\n", seq->type); + if(seq && seq!=seqact) { + /* i'm not sure about this one, seems to work without it -- sgefant */ + seq_free_strip(seqact->strip); + + seqact->strip= seq->strip; + + seqact->len= seq->len; + calc_sequence(seqact); + + seq->strip= 0; + seq_free_sequence(seq); + BLI_remlink(ed->seqbasep, seq); + + seq= ed->seqbasep->first; + + } + + waitcursor(0); + +} +#endif + +static void reload_image_strip(Scene *scene, char *name) +{ + Editing *ed; + Sequence *seq, *seqact; + SpaceFile *sfile; + Sequence *last_seq= get_last_seq(scene); + + ed= scene->ed; + + if(last_seq==0 || last_seq->type!=SEQ_IMAGE) return; + seqact= last_seq; /* last_seq changes in alloc_sequence */ + + /* search sfile */ +// sfile= scrarea_find_space_of_type(curarea, SPACE_FILE); + if(sfile==0) return; + + waitcursor(1); + + seq= sfile_to_sequence(scene, sfile, seqact->start, seqact->machine, 1); + if(seq && seq!=seqact) { + seq_free_strip(seqact->strip); + + seqact->strip= seq->strip; + + seqact->len= seq->len; + calc_sequence(seqact); + + seq->strip= 0; + seq_free_sequence(seq); + BLI_remlink(ed->seqbasep, seq); + + update_changed_seq_and_deps(scene, seqact, 1, 1); + } + waitcursor(0); + +} + +static int event_to_efftype(int event) +{ + if(event==2) return SEQ_CROSS; + if(event==3) return SEQ_GAMCROSS; + if(event==4) return SEQ_ADD; + if(event==5) return SEQ_SUB; + if(event==6) return SEQ_MUL; + if(event==7) return SEQ_ALPHAOVER; + if(event==8) return SEQ_ALPHAUNDER; + if(event==9) return SEQ_OVERDROP; + if(event==10) return SEQ_PLUGIN; + if(event==13) return SEQ_WIPE; + if(event==14) return SEQ_GLOW; + if(event==15) return SEQ_TRANSFORM; + if(event==16) return SEQ_COLOR; + if(event==17) return SEQ_SPEED; + return 0; +} + +static int seq_effect_find_selected(Scene *scene, Sequence *activeseq, int type, Sequence **selseq1, Sequence **selseq2, Sequence **selseq3) +{ + Editing *ed = scene->ed; + Sequence *seq1= 0, *seq2= 0, *seq3= 0, *seq; + + if (!activeseq) + seq2= get_last_seq(scene); + + for(seq=ed->seqbasep->first; seq; seq=seq->next) { + if(seq->flag & SELECT) { + if (seq->type == SEQ_RAM_SOUND + || seq->type == SEQ_HD_SOUND) { + error("Can't apply effects to " + "audio sequence strips"); + return 0; + } + if((seq != activeseq) && (seq != seq2)) { + if(seq2==0) seq2= seq; + else if(seq1==0) seq1= seq; + else if(seq3==0) seq3= seq; + else { + error("Can't apply effect to more than 3 sequence strips"); + return 0; + } + } + } + } + + /* make sequence selection a little bit more intuitive + for 3 strips: the last-strip should be sequence3 */ + if (seq3 != 0 && seq2 != 0) { + Sequence *tmp = seq2; + seq2 = seq3; + seq3 = tmp; + } + + + switch(get_sequence_effect_num_inputs(type)) { + case 0: + *selseq1 = *selseq2 = *selseq3 = 0; + return 1; + case 1: + if(seq2==0) { + error("Need at least one selected sequence strip"); + return 0; + } + if(seq1==0) seq1= seq2; + if(seq3==0) seq3= seq2; + case 2: + if(seq1==0 || seq2==0) { + error("Need 2 selected sequence strips"); + return 0; + } + if(seq3==0) seq3= seq2; + } + + if (seq1==NULL && seq2==NULL && seq3==NULL) return 0; + + *selseq1= seq1; + *selseq2= seq2; + *selseq3= seq3; + + return 1; +} + +static int add_seq_effect(Scene *scene, View2D *v2d, int type, char *str) +{ + Editing *ed; + Sequence *newseq, *seq1, *seq2, *seq3; + Strip *strip; + float x, y; + int cfra, machine; + short mval[2]; + struct SeqEffectHandle sh; + + if(scene->ed==NULL) return 0; + ed= scene->ed; + + if(!seq_effect_find_selected(scene, NULL, event_to_efftype(type), &seq1, &seq2, &seq3)) + return 0; + + deselect_all_seq(scene); + + /* where will it be (cfra is not realy needed) */ +// getmouseco_areawin(mval); + UI_view2d_region_to_view(v2d, mval[0], mval[1], &x, &y); + cfra= (int)(x+0.5); + machine= (int)(y+0.5); + + /* allocate and initialize */ + newseq= alloc_sequence(((Editing *)scene->ed)->seqbasep, cfra, machine); + newseq->type= event_to_efftype(type); + + sh = get_sequence_effect(newseq); + + newseq->seq1= seq1; + newseq->seq2= seq2; + newseq->seq3= seq3; + + sh.init(newseq); + + if (!seq1) { + newseq->len= 1; + newseq->startstill= 25; + newseq->endstill= 24; + } + + calc_sequence(newseq); + + newseq->strip= strip= MEM_callocN(sizeof(Strip), "strip"); + strip->len= newseq->len; + strip->us= 1; + if(newseq->len>0) + strip->stripdata= MEM_callocN(newseq->len*sizeof(StripElem), "stripelem"); + + /* initialize plugin */ + if(newseq->type == SEQ_PLUGIN) { + sh.init_plugin(newseq, str); + + if(newseq->plugin==0) { + BLI_remlink(ed->seqbasep, newseq); + seq_free_sequence(newseq); + set_last_seq(NULL); + return 0; + } + } + + /* set find a free spot to but the strip */ + if (newseq->seq1) { + newseq->machine= MAX3(newseq->seq1->machine, + newseq->seq2->machine, + newseq->seq3->machine); + } + if(test_overlap_seq(scene, newseq)) shuffle_seq(scene, newseq); + + update_changed_seq_and_deps(scene, newseq, 1, 1); + + /* push undo and go into grab mode */ + if(newseq->type == SEQ_PLUGIN) { + BIF_undo_push("Add Plugin Strip, Sequencer"); + } else { + BIF_undo_push("Add Effect Strip, Sequencer"); + } + + transform_seq_nomarker('g', 0); + + return 1; +} + +static void load_plugin_seq(Scene *scene, View2D *v2d, char *str) /* called from fileselect */ +{ + add_seq_effect(scene, v2d, 10, str); +} + +void add_sequence(Scene *scene, View2D *v2d, int type) +{ + Editing *ed; + short event; + char *str; + + if (type >= 0){ + /* bypass pupmenu for calls from menus (aphex) */ + switch(type){ + case SEQ_SCENE: + event = 101; + break; + case SEQ_IMAGE: + event = 1; + break; + case SEQ_MOVIE: + event = 102; + break; + case SEQ_RAM_SOUND: + event = 103; + break; + case SEQ_HD_SOUND: + event = 104; + break; + case SEQ_MOVIE_AND_HD_SOUND: + event = 105; + break; + case SEQ_PLUGIN: + event = 10; + break; + case SEQ_CROSS: + event = 2; + break; + case SEQ_ADD: + event = 4; + break; + case SEQ_SUB: + event = 5; + break; + case SEQ_ALPHAOVER: + event = 7; + break; + case SEQ_ALPHAUNDER: + event = 8; + break; + case SEQ_GAMCROSS: + event = 3; + break; + case SEQ_MUL: + event = 6; + break; + case SEQ_OVERDROP: + event = 9; + break; + case SEQ_WIPE: + event = 13; + break; + case SEQ_GLOW: + event = 14; + break; + case SEQ_TRANSFORM: + event = 15; + break; + case SEQ_COLOR: + event = 16; + break; + case SEQ_SPEED: + event = 17; + break; + default: + event = 0; + break; + } + } + else { + event= pupmenu("Add Sequence Strip%t" + "|Image Sequence%x1" + "|Movie%x102" +#ifdef WITH_FFMPEG + "|Movie + Audio (HD)%x105" + "|Audio (RAM)%x103" + "|Audio (HD)%x104" +#else + "|Audio (Wav)%x103" +#endif + "|Scene%x101" + "|Plugin%x10" + "|Cross%x2" + "|Gamma Cross%x3" + "|Add%x4" + "|Sub%x5" + "|Mul%x6" + "|Alpha Over%x7" + "|Alpha Under%x8" + "|Alpha Over Drop%x9" + "|Wipe%x13" + "|Glow%x14" + "|Transforms%x15" + "|Color Generator%x16" + "|Speed Control%x17"); + } + + if(event<1) return; + + if(scene->ed==NULL) { + ed= scene->ed= MEM_callocN( sizeof(Editing), "addseq"); + ed->seqbasep= &ed->seqbase; + } + else ed= scene->ed; + + switch(event) { + case 1: + /* Image Dosnt work at the moment - TODO */ + //if(G.qual & LR_CTRLKEY) + // activate_imageselect(FILE_SPECIAL, "Select Images", last_imagename, add_image_strips); + //else + activate_fileselect(FILE_SPECIAL, "Select Images", last_imagename, add_image_strips); + break; + case 105: + activate_fileselect(FILE_SPECIAL, "Select Movie+Audio", last_imagename, add_movie_and_hdaudio_strip); + break; + case 102: + + activate_fileselect(FILE_SPECIAL, "Select Movie", last_imagename, add_movie_strip); + break; + case 101: + /* new menu: */ + IDnames_to_pupstring(&str, NULL, NULL, &G.main->scene, (ID *)scene, NULL); + + add_scene_strip(scene, v2d, pupmenu_col(str, 20)); + + MEM_freeN(str); + + break; + case 2: + case 3: + case 4: + case 5: + case 6: + case 7: + case 8: + case 9: + case 10: + case 13: + case 14: + case 15: + case 16: + case 17: + if(get_last_seq(scene)==0 && + get_sequence_effect_num_inputs( event_to_efftype(event))> 0) + error("Need at least one active sequence strip"); + else if(event==10) + activate_fileselect(FILE_SPECIAL, "Select Plugin", U.plugseqdir, load_plugin_seq); + else + add_seq_effect(scene, v2d, event, NULL); + + break; + case 103: + if (!last_sounddir[0]) strncpy(last_sounddir, U.sounddir, FILE_MAXDIR-1); + activate_fileselect(FILE_SPECIAL, "Select Audio (RAM)", last_sounddir, add_sound_strip_ram); + break; + case 104: + if (!last_sounddir[0]) strncpy(last_sounddir, U.sounddir, FILE_MAXDIR-1); + activate_fileselect(FILE_SPECIAL, "Select Audio (HD)", last_sounddir, add_sound_strip_hd); + break; + } +} + +void change_sequence(Scene *scene) +{ + Sequence *last_seq= get_last_seq(scene); + Scene *sce; + short event; + + if(last_seq==0) return; + + if(last_seq->type & SEQ_EFFECT) { + event = pupmenu("Change Effect%t" + "|Switch A <-> B %x1" + "|Switch B <-> C %x10" + "|Plugin%x11" + "|Recalculate%x12" + "|Cross%x2" + "|Gamma Cross%x3" + "|Add%x4" + "|Sub%x5" + "|Mul%x6" + "|Alpha Over%x7" + "|Alpha Under%x8" + "|Alpha Over Drop%x9" + "|Wipe%x13" + "|Glow%x14" + "|Transform%x15" + "|Color Generator%x16" + "|Speed Control%x17"); + if(event > 0) { + if(event==1) { + SWAP(Sequence *,last_seq->seq1,last_seq->seq2); + } + else if(event==10) { + SWAP(Sequence *,last_seq->seq2,last_seq->seq3); + } + else if(event==11) { + activate_fileselect( + FILE_SPECIAL, "Select Plugin", + U.plugseqdir, change_plugin_seq); + } + else if(event==12); + /* recalculate: only new_stripdata */ + else { + /* free previous effect and init new effect */ + struct SeqEffectHandle sh; + + if (get_sequence_effect_num_inputs( + last_seq->type) + < get_sequence_effect_num_inputs( + event_to_efftype(event))) { + error("New effect needs more " + "input strips!"); + } else { + sh = get_sequence_effect(last_seq); + sh.free(last_seq); + + last_seq->type + = event_to_efftype(event); + + sh = get_sequence_effect(last_seq); + sh.init(last_seq); + } + } + + update_changed_seq_and_deps(scene, last_seq, 0, 1); + BIF_undo_push("Change Strip Effect, Sequencer"); + } + } + else if(last_seq->type == SEQ_IMAGE) { + if(okee("Change images")) { + activate_fileselect(FILE_SPECIAL, + "Select Images", + last_imagename, + reload_image_strip); + } + } + else if(last_seq->type == SEQ_MOVIE) { + ; + } + else if(last_seq->type == SEQ_SCENE) { + event= pupmenu("Change Scene%t|Update Start and End"); + + if(event==1) { + sce= last_seq->scene; + + last_seq->len= sce->r.efra - sce->r.sfra + 1; + last_seq->sfra= sce->r.sfra; + + /* bad code to change seq->len? update_changed_seq_and_deps() expects the strip->len to be OK */ + new_tstripdata(last_seq); + + update_changed_seq_and_deps(scene, last_seq, 1, 1); + + } + } + +} + +void reload_sequence(Scene *scene) +{ + Editing *ed= scene->ed; + Sequence *seq; + + SEQP_BEGIN(ed, seq) { + if(seq->flag & SELECT) { + update_changed_seq_and_deps(scene, seq, 0, 1); + } + } + SEQ_END +} + +void reassign_inputs_seq_effect(Scene *scene) +{ + Editing *ed= scene->ed; + Sequence *seq1, *seq2, *seq3, *last_seq = get_last_seq(scene); + + if(last_seq==0 || !(last_seq->type & SEQ_EFFECT)) return; + if(ed==NULL) return; + + if(!seq_effect_find_selected(scene, last_seq, last_seq->type, &seq1, &seq2, &seq3)) + return; + + /* see reassigning would create a cycle */ + if(seq_is_predecessor(seq1, last_seq) || seq_is_predecessor(seq2, last_seq) || + seq_is_predecessor(seq3, last_seq)) { + error("Can't reassign inputs: no cycles allowed"); + return; + } + + last_seq->seq1 = seq1; + last_seq->seq2 = seq2; + last_seq->seq3 = seq3; + + update_changed_seq_and_deps(scene, last_seq, 1, 1); + +} + +static Sequence *del_seq_find_replace_recurs(Scene *scene, Sequence *seq) +{ + Sequence *seq1, *seq2, *seq3; + + /* try to find a replacement input sequence, and flag for later deletion if + no replacement can be found */ + + if(!seq) + return NULL; + else if(!(seq->type & SEQ_EFFECT)) + return ((seq->flag & SELECT)? NULL: seq); + else if(!(seq->flag & SELECT)) { + /* try to find replacement for effect inputs */ + seq1= del_seq_find_replace_recurs(scene, seq->seq1); + seq2= del_seq_find_replace_recurs(scene, seq->seq2); + seq3= del_seq_find_replace_recurs(scene, seq->seq3); + + if(seq1==seq->seq1 && seq2==seq->seq2 && seq3==seq->seq3); + else if(seq1 || seq2 || seq3) { + seq->seq1= (seq1)? seq1: (seq2)? seq2: seq3; + seq->seq2= (seq2)? seq2: (seq1)? seq1: seq3; + seq->seq3= (seq3)? seq3: (seq1)? seq1: seq2; + + update_changed_seq_and_deps(scene, seq, 1, 1); + } + else + seq->flag |= SELECT; /* mark for delete */ + } + + if (seq->flag & SELECT) { + if((seq1 = del_seq_find_replace_recurs(scene, seq->seq1))) return seq1; + if((seq2 = del_seq_find_replace_recurs(scene, seq->seq2))) return seq2; + if((seq3 = del_seq_find_replace_recurs(scene, seq->seq3))) return seq3; + else return NULL; + } + else + return seq; +} + +static void recurs_del_seq_flag(Scene *scene, ListBase *lb, short flag, short deleteall) +{ + Sequence *seq, *seqn; + Sequence *last_seq = get_last_seq(scene); + + seq= lb->first; + while(seq) { + seqn= seq->next; + if((seq->flag & flag) || deleteall) { + if(seq->type==SEQ_RAM_SOUND && seq->sound) + seq->sound->id.us--; + + BLI_remlink(lb, seq); + if(seq==last_seq) set_last_seq(0); + if(seq->type==SEQ_META) recurs_del_seq_flag(scene, &seq->seqbase, flag, 1); + if(seq->ipo) seq->ipo->id.us--; + seq_free_sequence(seq); + } + seq= seqn; + } +} + +void del_seq(Scene *scene) +{ + Sequence *seq; + MetaStack *ms; + Editing *ed; + int nothingSelected = TRUE; + + ed= scene->ed; + if(ed==NULL) return; + + seq=get_last_seq(scene); + if (seq && seq->flag & SELECT) { /* avoid a loop since this is likely to be selected */ + nothingSelected = FALSE; + } else { + for (seq = ed->seqbasep->first; seq; seq = seq->next) { + if (seq->flag & SELECT) { + nothingSelected = FALSE; + break; + } + } + } + + if(nothingSelected || okee("Erase selected")==0) return; + + /* free imbufs of all dependent strips */ + for(seq=ed->seqbasep->first; seq; seq=seq->next) + if(seq->flag & SELECT) + update_changed_seq_and_deps(scene, seq, 1, 0); + + /* for effects, try to find a replacement input */ + for(seq=ed->seqbasep->first; seq; seq=seq->next) + if((seq->type & SEQ_EFFECT) && !(seq->flag & SELECT)) + del_seq_find_replace_recurs(scene, seq); + + /* delete all selected strips */ + recurs_del_seq_flag(scene, ed->seqbasep, SELECT, 0); + + /* updates lengths etc */ + seq= ed->seqbasep->first; + while(seq) { + calc_sequence(seq); + seq= seq->next; + } + + /* free parent metas */ + ms= ed->metastack.last; + while(ms) { + ms->parseq->strip->len= 0; /* force new alloc */ + calc_sequence(ms->parseq); + ms= ms->prev; + } + + BIF_undo_push("Delete Strip(s), Sequencer"); +} + +static Sequence *dupli_seq(Sequence *seq) +{ + Sequence *seqn = MEM_dupallocN(seq); + + seq->tmp = seqn; + + seqn->strip= MEM_dupallocN(seq->strip); + + if(seqn->ipo) seqn->ipo->id.us++; + + seqn->strip->tstripdata = 0; + seqn->strip->tstripdata_startstill = 0; + seqn->strip->tstripdata_endstill = 0; + seqn->strip->ibuf_startstill = 0; + seqn->strip->ibuf_endstill = 0; + + if (seq->strip->crop) { + seqn->strip->crop = MEM_dupallocN(seq->strip->crop); + } + + if (seq->strip->transform) { + seqn->strip->transform = MEM_dupallocN(seq->strip->transform); + } + + if (seq->strip->proxy) { + seqn->strip->proxy = MEM_dupallocN(seq->strip->proxy); + } + + if (seq->strip->color_balance) { + seqn->strip->color_balance + = MEM_dupallocN(seq->strip->color_balance); + } + + if(seq->type==SEQ_META) { + seqn->strip->stripdata = 0; + + seqn->seqbase.first= seqn->seqbase.last= 0; + /* WATCH OUT!!! - This metastrip is not recursively duplicated here - do this after!!! */ + /* - recurs_dupli_seq(&seq->seqbase,&seqn->seqbase);*/ + } else if(seq->type == SEQ_SCENE) { + seqn->strip->stripdata = 0; + } else if(seq->type == SEQ_MOVIE) { + seqn->strip->stripdata = + MEM_dupallocN(seq->strip->stripdata); + seqn->anim= 0; + } else if(seq->type == SEQ_RAM_SOUND) { + seqn->strip->stripdata = + MEM_dupallocN(seq->strip->stripdata); + seqn->sound->id.us++; + } else if(seq->type == SEQ_HD_SOUND) { + seqn->strip->stripdata = + MEM_dupallocN(seq->strip->stripdata); + seqn->hdaudio = 0; + } else if(seq->type == SEQ_IMAGE) { + seqn->strip->stripdata = + MEM_dupallocN(seq->strip->stripdata); + } else if(seq->type >= SEQ_EFFECT) { + if(seq->seq1 && seq->seq1->tmp) seqn->seq1= seq->seq1->tmp; + if(seq->seq2 && seq->seq2->tmp) seqn->seq2= seq->seq2->tmp; + if(seq->seq3 && seq->seq3->tmp) seqn->seq3= seq->seq3->tmp; + + if (seq->type & SEQ_EFFECT) { + struct SeqEffectHandle sh; + sh = get_sequence_effect(seq); + if(sh.copy) + sh.copy(seq, seqn); + } + + seqn->strip->stripdata = 0; + + } else { + fprintf(stderr, "Aiiiiekkk! sequence type not " + "handled in duplicate!\nExpect a crash" + " now...\n"); + } + + seqn->flag &= ~SEQ_ACTIVE; + + return seqn; +} + +static Sequence * deep_dupli_seq(Sequence * seq) +{ + Sequence * seqn = dupli_seq(seq); + if (seq->type == SEQ_META) { + Sequence * s; + for(s= seq->seqbase.first; s; s = s->next) { + Sequence * n = deep_dupli_seq(s); + if (n) { + BLI_addtail(&seqn->seqbase, n); + } + } + } + return seqn; +} + + +static void recurs_dupli_seq(Scene *scene, ListBase *old, ListBase *new) +{ + Sequence *seq; + Sequence *seqn = 0; + Sequence *last_seq = get_last_seq(scene); + + for(seq= old->first; seq; seq= seq->next) { + seq->tmp= NULL; + if(seq->flag & SELECT) { + seqn = dupli_seq(seq); + if (seqn) { /*should never fail */ + seq->flag &= SEQ_DESEL; + seqn->flag &= ~(SEQ_LEFTSEL+SEQ_RIGHTSEL+SEQ_LOCK); + + BLI_addtail(new, seqn); + if(seq->type==SEQ_META) + recurs_dupli_seq(scene, &seq->seqbase,&seqn->seqbase); + + if (seq == last_seq) { + set_last_seq(seqn); + } + } + } + } +} + +static Sequence *cut_seq_hard(Scene *scene, Sequence * seq, int cutframe) +{ + TransSeq ts; + Sequence *seqn = 0; + int skip_dup = FALSE; + + /* backup values */ + ts.start= seq->start; + ts.machine= seq->machine; + ts.startstill= seq->startstill; + ts.endstill= seq->endstill; + ts.startdisp= seq->startdisp; + ts.enddisp= seq->enddisp; + ts.startofs= seq->anim_startofs; + ts.endofs= seq->anim_endofs; + ts.len= seq->len; + + /* First Strip! */ + /* strips with extended stillfames before */ + + if ((seq->startstill) && (cutframe <seq->start)) { + /* don't do funny things with METAs ... */ + if (seq->type == SEQ_META) { + skip_dup = TRUE; + seq->startstill = seq->start - cutframe; + } else { + seq->start= cutframe -1; + seq->startstill= cutframe -seq->startdisp -1; + seq->anim_endofs += seq->len - 1; + seq->endstill= 0; + } + } + /* normal strip */ + else if ((cutframe >=seq->start)&&(cutframe <=(seq->start+seq->len))) { + seq->endofs = 0; + seq->endstill = 0; + seq->anim_endofs += (seq->start+seq->len) - cutframe; + } + /* strips with extended stillframes after */ + else if (((seq->start+seq->len) < cutframe) && (seq->endstill)) { + seq->endstill -= seq->enddisp - cutframe; + /* don't do funny things with METAs ... */ + if (seq->type == SEQ_META) { + skip_dup = TRUE; + } + } + + reload_sequence_new_file(scene, seq); + calc_sequence(seq); + + if (!skip_dup) { + /* Duplicate AFTER the first change */ + seqn = deep_dupli_seq(seq); + } + + if (seqn) { + seqn->flag |= SELECT; + + /* Second Strip! */ + /* strips with extended stillframes before */ + if ((seqn->startstill) && (cutframe == seqn->start + 1)) { + seqn->start = ts.start; + seqn->startstill= ts.start- cutframe; + seqn->anim_endofs = ts.endofs; + seqn->endstill = ts.endstill; + } + + /* normal strip */ + else if ((cutframe>=seqn->start)&&(cutframe<=(seqn->start+seqn->len))) { + seqn->start = cutframe; + seqn->startstill = 0; + seqn->startofs = 0; + seqn->anim_startofs += cutframe - ts.start; + seqn->anim_endofs = ts.endofs; + seqn->endstill = ts.endstill; + } + + /* strips with extended stillframes after */ + else if (((seqn->start+seqn->len) < cutframe) && (seqn->endstill)) { + seqn->start = cutframe; + seqn->startofs = 0; + seqn->anim_startofs += ts.len-1; + seqn->endstill = ts.enddisp - cutframe -1; + seqn->startstill = 0; + } + + reload_sequence_new_file(scene, seqn); + calc_sequence(seqn); + } + return seqn; +} + +static Sequence *cut_seq_soft(Scene *scene, Sequence * seq, int cutframe) +{ + TransSeq ts; + Sequence *seqn = 0; + int skip_dup = FALSE; + + /* backup values */ + ts.start= seq->start; + ts.machine= seq->machine; + ts.startstill= seq->startstill; + ts.endstill= seq->endstill; + ts.startdisp= seq->startdisp; + ts.enddisp= seq->enddisp; + ts.startofs= seq->startofs; + ts.endofs= seq->endofs; + ts.len= seq->len; + + /* First Strip! */ + /* strips with extended stillfames before */ + + if ((seq->startstill) && (cutframe <seq->start)) { + /* don't do funny things with METAs ... */ + if (seq->type == SEQ_META) { + skip_dup = TRUE; + seq->startstill = seq->start - cutframe; + } else { + seq->start= cutframe -1; + seq->startstill= cutframe -seq->startdisp -1; + seq->endofs = seq->len - 1; + seq->endstill= 0; + } + } + /* normal strip */ + else if ((cutframe >=seq->start)&&(cutframe <=(seq->start+seq->len))) { + seq->endofs = (seq->start+seq->len) - cutframe; + } + /* strips with extended stillframes after */ + else if (((seq->start+seq->len) < cutframe) && (seq->endstill)) { + seq->endstill -= seq->enddisp - cutframe; + /* don't do funny things with METAs ... */ + if (seq->type == SEQ_META) { + skip_dup = TRUE; + } + } + + calc_sequence(seq); + + if (!skip_dup) { + /* Duplicate AFTER the first change */ + seqn = deep_dupli_seq(seq); + } + + if (seqn) { + seqn->flag |= SELECT; + + /* Second Strip! */ + /* strips with extended stillframes before */ + if ((seqn->startstill) && (cutframe == seqn->start + 1)) { + seqn->start = ts.start; + seqn->startstill= ts.start- cutframe; + seqn->endofs = ts.endofs; + seqn->endstill = ts.endstill; + } + + /* normal strip */ + else if ((cutframe>=seqn->start)&&(cutframe<=(seqn->start+seqn->len))) { + seqn->startstill = 0; + seqn->startofs = cutframe - ts.start; + seqn->endofs = ts.endofs; + seqn->endstill = ts.endstill; + } + + /* strips with extended stillframes after */ + else if (((seqn->start+seqn->len) < cutframe) && (seqn->endstill)) { + seqn->start = cutframe - ts.len +1; + seqn->startofs = ts.len-1; + seqn->endstill = ts.enddisp - cutframe -1; + seqn->startstill = 0; + } + + calc_sequence(seqn); + } + return seqn; +} + + +/* like duplicate, but only duplicate and cut overlapping strips, + * strips to the left of the cutframe are ignored and strips to the right are moved into the new list */ +static int cut_seq_list(Scene *scene, ListBase *old, ListBase *new, int cutframe, + Sequence * (*cut_seq)(Scene *, Sequence *, int)) +{ + int did_something = FALSE; + Sequence *seq, *seq_next; + + seq= old->first; + + while(seq) { + seq_next = seq->next; /* we need this because we may remove seq */ + + seq->tmp= NULL; + if(seq->flag & SELECT) { + if(cutframe > seq->startdisp && + cutframe < seq->enddisp) { + Sequence * seqn = cut_seq(scene, seq, cutframe); + if (seqn) { + BLI_addtail(new, seqn); + } + did_something = TRUE; + } else if (seq->enddisp <= cutframe) { + /* do nothing */ + } else if (seq->startdisp >= cutframe) { + /* move into new list */ + BLI_remlink(old, seq); + BLI_addtail(new, seq); + } + } + seq = seq_next; + } + return did_something; +} + +void seq_cut(Scene *scene, View2D *v2d, int cutframe, int hard_cut) +{ + Editing *ed; + ListBase newlist; + char side; + int did_something; + + ed= scene->ed; + if(ed==NULL) return; + + newlist.first= newlist.last= NULL; + + if (hard_cut) { + did_something = cut_seq_list(scene, + ed->seqbasep, &newlist, cutframe, cut_seq_hard); + } else { + did_something = cut_seq_list(scene, + ed->seqbasep, &newlist, cutframe, cut_seq_soft); + } + + if (newlist.first) { /* got new strips ? */ + Sequence *seq; + addlisttolist(ed->seqbasep, &newlist); + + + /* change the selection, not strictly needed but nice */ + side = mouse_cfra_side(v2d, cutframe); + + SEQP_BEGIN(ed, seq) { + if (side=='L') { + if ( seq->startdisp >= cutframe ) { + seq->flag &= ~SELECT; + } + } else { + if ( seq->enddisp <= cutframe ) { + seq->flag &= ~SELECT; + } + } + } + SEQ_END; + + /* as last: */ + sort_seq(scene); + } + if (did_something) { + BIF_undo_push("Cut Strips, Sequencer"); + } +} + +void add_duplicate_seq(Scene *scene) +{ + Editing *ed; + ListBase new; + + ed= scene->ed; + if(ed==NULL) return; + + new.first= new.last= 0; + + recurs_dupli_seq(scene, ed->seqbasep, &new); + addlisttolist(ed->seqbasep, &new); + + BIF_undo_push("Add Duplicate, Sequencer"); + transform_seq_nomarker('g', 0); +} + +int insert_gap(Scene *scene, int gap, int cfra) +{ + Sequence *seq; + Editing *ed; + int done=0; + + /* all strips >= cfra are shifted */ + ed= scene->ed; + if(ed==NULL) return 0; + + SEQP_BEGIN(ed, seq) { + if(seq->startdisp >= cfra) { + seq->start+= gap; + calc_sequence(seq); + done= 1; + } + } + SEQ_END + + return done; +} + +void touch_seq_files(Scene *scene) +{ + Sequence *seq; + Editing *ed; + char str[256]; + + /* touch all strips with movies */ + ed= scene->ed; + if(ed==NULL) return; + + if(okee("Touch and print selected movies")==0) return; + + waitcursor(1); + + SEQP_BEGIN(ed, seq) { + if(seq->flag & SELECT) { + if(seq->type==SEQ_MOVIE) { + if(seq->strip && seq->strip->stripdata) { + BLI_make_file_string(G.sce, str, seq->strip->dir, seq->strip->stripdata->name); + BLI_touch(seq->name); + } + } + + } + } + SEQ_END + + waitcursor(0); +} + +void set_filter_seq(Scene *scene) +{ + Sequence *seq; + Editing *ed; + + ed= scene->ed; + if(ed==NULL) return; + + if(okee("Set Deinterlace")==0) return; + + SEQP_BEGIN(ed, seq) { + if(seq->flag & SELECT) { + if(seq->type==SEQ_MOVIE) { + seq->flag |= SEQ_FILTERY; + reload_sequence_new_file(scene, seq); + } + + } + } + SEQ_END + +} + +void seq_remap_paths(Scene *scene) +{ + Sequence *seq, *last_seq = get_last_seq(scene); + Editing *ed; + char from[FILE_MAX], to[FILE_MAX], stripped[FILE_MAX]; + + ed= scene->ed; + if(ed==NULL || last_seq==NULL) + return; + + BLI_strncpy(from, last_seq->strip->dir, FILE_MAX); +// XXX if (0==sbutton(from, 0, sizeof(from)-1, "From: ")) +// return; + + strcpy(to, from); +// XXX if (0==sbutton(to, 0, sizeof(to)-1, "To: ")) +// return; + + if (strcmp(to, from)==0) + return; + + SEQP_BEGIN(ed, seq) { + if(seq->flag & SELECT) { + if(strncmp(seq->strip->dir, from, strlen(from))==0) { + printf("found %s\n", seq->strip->dir); + + /* strip off the beginning */ + stripped[0]= 0; + BLI_strncpy(stripped, seq->strip->dir + strlen(from), FILE_MAX); + + /* new path */ + BLI_strncpy(seq->strip->dir, to, FILE_MAX); + strcat(seq->strip->dir, stripped); + printf("new %s\n", seq->strip->dir); + } + } + } + SEQ_END + + BIF_undo_push("Remap Paths, Sequencer"); +} + + +void no_gaps(Scene *scene) +{ + Editing *ed; + int cfra, first= 0, done; + + ed= scene->ed; + if(ed==NULL) return; + + for(cfra= CFRA; cfra<=EFRA; cfra++) { + if(first==0) { + if( evaluate_seq_frame(scene, cfra) ) first= 1; + } + else { + done= 1; + while( evaluate_seq_frame(scene, cfra) == 0) { + done= insert_gap(scene, -1, cfra); + if(done==0) break; + } + if(done==0) break; + } + } + + BIF_undo_push("No Gaps, Sequencer"); +} + + +/* ****************** META ************************* */ + +void make_meta(Scene *scene) +{ + Sequence *seq, *seqm, *next; + Editing *ed; + int tot; + + ed= scene->ed; + if(ed==NULL) return; + + /* is there more than 1 select */ + tot= 0; + seq= ed->seqbasep->first; + while(seq) { + if(seq->flag & SELECT) { + tot++; + if (seq->type == SEQ_RAM_SOUND) { + error("Can't make Meta Strip from audio"); + return; + } + } + seq= seq->next; + } + if(tot < 1) return; + + if(okee("Make Meta Strip")==0) return; + + /* test relationships */ + seq= ed->seqbasep->first; + while(seq) { + if(seq->flag & SELECT) { + if(seq->type & SEQ_EFFECT) { + if(seq->seq1 && + (seq->seq1->flag & SELECT)==0) tot= 0; + if(seq->seq2 && + (seq->seq2->flag & SELECT)==0) tot= 0; + if(seq->seq3 && + (seq->seq3->flag & SELECT)==0) tot= 0; + } + } + else if(seq->type & SEQ_EFFECT) { + if(seq->seq1 && + (seq->seq1->flag & SELECT)) tot= 0; + if(seq->seq2 && + (seq->seq2->flag & SELECT)) tot= 0; + if(seq->seq3 && + (seq->seq3->flag & SELECT)) tot= 0; + } + if(tot==0) break; + seq= seq->next; + } + if(tot==0) { + error("Please select all related strips"); + return; + } + + /* remove all selected from main list, and put in meta */ + + seqm= alloc_sequence(((Editing *)scene->ed)->seqbasep, 1, 1); + seqm->type= SEQ_META; + seqm->flag= SELECT; + + seq= ed->seqbasep->first; + while(seq) { + next= seq->next; + if(seq!=seqm && (seq->flag & SELECT)) { + BLI_remlink(ed->seqbasep, seq); + BLI_addtail(&seqm->seqbase, seq); + } + seq= next; + } + calc_sequence(seqm); + + seqm->strip= MEM_callocN(sizeof(Strip), "metastrip"); + seqm->strip->len= seqm->len; + seqm->strip->us= 1; + + if( test_overlap_seq(scene, seqm) ) shuffle_seq(scene, seqm); + + BIF_undo_push("Make Meta Strip, Sequencer"); +} + +static int seq_depends_on_meta(Sequence *seq, Sequence *seqm) +{ + if (seq == seqm) return 1; + else if (seq->seq1 && seq_depends_on_meta(seq->seq1, seqm)) return 1; + else if (seq->seq2 && seq_depends_on_meta(seq->seq2, seqm)) return 1; + else if (seq->seq3 && seq_depends_on_meta(seq->seq3, seqm)) return 1; + else return 0; +} + +void un_meta(Scene *scene) +{ + Editing *ed; + Sequence *seq, *last_seq = get_last_seq(scene); + + ed= scene->ed; + if(ed==NULL) return; + + if(last_seq==0 || last_seq->type!=SEQ_META) return; + + if(okee("Un Meta Strip")==0) return; + + addlisttolist(ed->seqbasep, &last_seq->seqbase); + + last_seq->seqbase.first= 0; + last_seq->seqbase.last= 0; + + BLI_remlink(ed->seqbasep, last_seq); + seq_free_sequence(last_seq); + + /* emtpy meta strip, delete all effects depending on it */ + for(seq=ed->seqbasep->first; seq; seq=seq->next) + if((seq->type & SEQ_EFFECT) && seq_depends_on_meta(seq, last_seq)) + seq->flag |= SEQ_FLAG_DELETE; + + recurs_del_seq_flag(scene, ed->seqbasep, SEQ_FLAG_DELETE, 0); + + /* test for effects and overlap */ + SEQP_BEGIN(ed, seq) { + if(seq->flag & SELECT) { + seq->flag &= ~SEQ_OVERLAP; + if( test_overlap_seq(scene, seq) ) { + shuffle_seq(scene, seq); + } + } + } + SEQ_END; + + sort_seq(scene); + + BIF_undo_push("Un-Make Meta Strip, Sequencer"); +} + +void exit_meta(Scene *scene) +{ + Sequence *seq; + MetaStack *ms; + Editing *ed; + + ed= scene->ed; + if(ed==NULL) return; + + if(ed->metastack.first==0) return; + + ms= ed->metastack.last; + BLI_remlink(&ed->metastack, ms); + + ed->seqbasep= ms->oldbasep; + + /* recalc all: the meta can have effects connected to it */ + seq= ed->seqbasep->first; + while(seq) { + calc_sequence(seq); + seq= seq->next; + } + + set_last_seq(ms->parseq); + + ms->parseq->flag |= SELECT; + recurs_sel_seq(ms->parseq); + + MEM_freeN(ms); + + BIF_undo_push("Exit Meta Strip, Sequence"); +} + + +void enter_meta(Scene *scene) +{ + MetaStack *ms; + Editing *ed; + Sequence *last_seq= get_last_seq(scene); + + ed= scene->ed; + if(ed==NULL) return; + + if(last_seq==0 || last_seq->type!=SEQ_META || (last_seq->flag & SELECT)==0) { + exit_meta(scene); + return; + } + + ms= MEM_mallocN(sizeof(MetaStack), "metastack"); + BLI_addtail(&ed->metastack, ms); + ms->parseq= last_seq; + ms->oldbasep= ed->seqbasep; + + ed->seqbasep= &last_seq->seqbase; + + set_last_seq(NULL); + BIF_undo_push("Enter Meta Strip, Sequence"); +} + + +/* ****************** END META ************************* */ + +static int seq_get_snaplimit(View2D *v2d) +{ + /* fake mouse coords to get the snap value + a bit lazy but its only done once pre transform */ + float xmouse, ymouse, x; + short mval[2] = {24, 0}; /* 24 screen px snap */ + + UI_view2d_region_to_view(v2d, mval[0], mval[1], &xmouse, &ymouse); + x = xmouse; + mval[0] = 0; + UI_view2d_region_to_view(v2d, mval[0], mval[1], &xmouse, &ymouse); + return (int)(x - xmouse); +} + +/* use to impose limits when dragging/extending - so impossible situations dont happen */ +static void transform_grab_xlimits(Sequence *seq, int leftflag, int rightflag) +{ + if(leftflag) { + if (seq_tx_get_final_left(seq, 0) >= seq_tx_get_final_right(seq, 0)) { + seq_tx_set_final_left(seq, seq_tx_get_final_right(seq, 0)-1); + } + + if (check_single_seq(seq)==0) { + if (seq_tx_get_final_left(seq, 0) >= seq_tx_get_end(seq)) { + seq_tx_set_final_left(seq, seq_tx_get_end(seq)-1); + } + + /* dosnt work now - TODO */ + /* + if (seq_tx_get_start(seq) >= seq_tx_get_final_right(seq, 0)) { + int ofs; + ofs = seq_tx_get_start(seq) - seq_tx_get_final_right(seq, 0); + seq->start -= ofs; + seq_tx_set_final_left(seq, seq_tx_get_final_left(seq, 0) + ofs ); + }*/ + + } + } + + if(rightflag) { + if (seq_tx_get_final_right(seq, 0) <= seq_tx_get_final_left(seq, 0)) { + seq_tx_set_final_right(seq, seq_tx_get_final_left(seq, 0)+1); + } + + if (check_single_seq(seq)==0) { + if (seq_tx_get_final_right(seq, 0) <= seq_tx_get_start(seq)) { + seq_tx_set_final_right(seq, seq_tx_get_start(seq)+1); + } + } + } + + /* sounds cannot be extended past their endpoints */ + if (seq->type == SEQ_RAM_SOUND || seq->type == SEQ_HD_SOUND) { + seq->startstill= 0; + seq->endstill= 0; + } +} + +static int can_transform_seq_test_func(Sequence * seq) +{ + if((seq->flag & SELECT) && !(seq->depth==0 && seq->flag & SEQ_LOCK)) { + return BUILD_SEQAR_COUNT_CURRENT | BUILD_SEQAR_COUNT_CHILDREN; + } + if ((seq->depth==0 && seq->flag & SEQ_LOCK) && !(seq->type & SEQ_EFFECT)) { + if (seq->type != SEQ_META) { + return BUILD_SEQAR_COUNT_NOTHING; + } else { + return BUILD_SEQAR_COUNT_CURRENT; + } + } + return BUILD_SEQAR_COUNT_CURRENT | BUILD_SEQAR_COUNT_CHILDREN; +} + +void transform_seq(Scene *scene, SpaceSeq *sseq, View2D *v2d, int mode, int context) +{ + Sequence *seq, *last_seq; + Editing *ed; + float dx, dy, dvec[2], div; + TransSeq *transmain, *ts; + int totstrip=0, firsttime=1, afbreek=0, midtog= 0, proj= 0; + int ix, iy; /* these values are used for storing the mouses offset from its original location */ + int ix_old = 0; + unsigned short event = 0; + short mval[2], xo, yo, xn, yn; + char str[32]; + char side= 'L'; /* for extend mode only - use to know which side to extend on */ + char marker_moved=0; /* if we mvoed a marker, redraw all marker views */ + /* used for extend in a number of places */ + int cfra = CFRA; + + /* for snapping */ + char snapskip = 0, snap, snap_old= 0; + int snapdist_max = seq_get_snaplimit(v2d); + /* at the moment there are only 4 possible snap points, + - last_seq (start,end) + - selected bounds (start/end) + - last_seq (next/prev) + - current frame */ + int snap_points[4], snap_point_num = 0; + int j; /* loop on snap_points */ + + /* for markers */ + int *oldframe = NULL, totmark=0, a; + TimeMarker *marker; + + /* looping on sequences, WHILE_SEQ macro allocates memory each time */ + int totseq_index, seq_index; + Sequence **seqar = 0; + + if(mode!='g' && mode!='e') return; /* from gesture */ + + /* which seqs are involved */ + ed= scene->ed; + if(ed==NULL) return; + + /* Build the sequence array once, be sure to free it */ + build_seqar_cb( ed->seqbasep, &seqar, &totseq_index, + can_transform_seq_test_func ); + + if (seqar) { + for(seq_index=0, seq=seqar[0]; seq_index < totseq_index; seq=seqar[++seq_index]) { + if((seq->flag & SELECT) && !(seq->depth==0 && seq->flag & SEQ_LOCK)) + totstrip++; + /* only needed for extend but can set here anyway since were alredy looping */ + seq->tmp= NULL; + } + } + + /* for extending we need the metastrip clipped left/right values, set the metastrips as parents in seq->tmp */ + if (mode=='e') { + Sequence *meta_seq; + for(seq_index=0, seq=seqar[0]; seq_index < totseq_index; seq=seqar[++seq_index]) { + if (seq->type == SEQ_META) { + for (meta_seq = seq->seqbase.first; meta_seq; meta_seq= meta_seq->next){ + meta_seq->tmp= (void *)seq; + } + } + } + } + + + if (sseq->flag & SEQ_MARKER_TRANS) { + for(marker= scene->markers.first; marker; marker= marker->next) { + if(marker->flag & SELECT) totmark++; + } + } + + if(totstrip==0 && totmark==0) { + if(seqar) MEM_freeN(seqar); + return; + } + + G.moving= 1; + + last_seq = get_last_seq(scene); + + ts=transmain= MEM_callocN(totstrip*sizeof(TransSeq), "transseq"); + + for(seq_index=0, seq=seqar[0]; seq_index < totseq_index; seq=seqar[++seq_index]) { + if((seq->flag & SELECT) && !(seq->depth==0 && seq->flag & SEQ_LOCK)) { + ts->start= seq->start; + ts->machine= seq->machine; + ts->startstill= seq->startstill; + ts->endstill= seq->endstill; + ts->startofs= seq->startofs; + ts->endofs= seq->endofs; + + /* for extend only */ + if (mode=='e') { + ts->final_left = seq_tx_get_final_left(seq, 1); + ts->final_right = seq_tx_get_final_right(seq, 1); + } + ts++; + } + } + +// getmouseco_areawin(mval); + + /* choose the side based on which side of the playhead the mouse is on */ + if (mode=='e') + side = mouse_cfra_side(v2d, cfra); + + /* Markers */ + if (sseq->flag & SEQ_MARKER_TRANS && totmark) { + oldframe= MEM_mallocN(totmark*sizeof(int), "marker array"); + for(a=0, marker= scene->markers.first; marker; marker= marker->next) { + if(marker->flag & SELECT) { + if (mode=='e') { + + /* when extending, invalidate markers on the other side by using an invalid frame value */ + if ((side == 'L' && marker->frame > cfra) || (side == 'R' && marker->frame < cfra)) { + oldframe[a] = MAXFRAME+1; + } else { + oldframe[a]= marker->frame; + } + } else { + oldframe[a]= marker->frame; + } + a++; + } + } + } + + xo=xn= mval[0]; + yo=yn= mval[1]; + dvec[0]= dvec[1]= 0.0; + + while(afbreek==0) { +// getmouseco_areawin(mval); + // XXX G.qual = get_qual(); + // snap = (G.qual & LR_CTRLKEY) ? 1 : 0; + + if(mval[0]!=xo || mval[1]!=yo || firsttime || snap != snap_old) { + if (firsttime) { + snap_old = snap; + firsttime= 0; + } + + /* run for either grab or extend */ + dx= mval[0]- xo; + dy= mval[1]- yo; + + div= v2d->mask.xmax-v2d->mask.xmin; + dx= (v2d->cur.xmax-v2d->cur.xmin)*(dx)/div; + + div= v2d->mask.ymax-v2d->mask.ymin; + dy= (v2d->cur.ymax-v2d->cur.ymin)*(dy)/div; + + if(0) { // XXX G.qual & LR_SHIFTKEY) { + if(dx>1.0) dx= 1.0; else if(dx<-1.0) dx= -1.0; + } + + dvec[0]+= dx; + dvec[1]+= dy; + + if(midtog) dvec[proj]= 0.0; + ix= floor(dvec[0]+0.5); + iy= floor(dvec[1]+0.5); + + ts= transmain; + + /* SNAP! use the active Seq */ + // XXX snap = G.qual & LR_CTRLKEY ? 1 : 0; + + if (!snap) { + snapskip = 0; + } else { + int dist; + int snap_ofs= 0; + int snap_dist= snapdist_max; + + /* Get sequence points to snap to the markers */ + + snap_point_num=0; + if (last_seq && (last_seq->flag & SELECT)) { /* active seq bounds */ + if(seq_tx_check_left(last_seq)) + snap_points[snap_point_num++] = seq_tx_get_final_left(last_seq, 0); + if(seq_tx_check_right(last_seq)) + snap_points[snap_point_num++] = seq_tx_get_final_right(last_seq, 0); + + } + if (totstrip > 1) { /* selection bounds */ + int bounds_left = MAXFRAME*2; + int bounds_right = -(MAXFRAME*2); + + for(seq_index=0, seq=seqar[0]; seq_index < totseq_index; seq=seqar[++seq_index]) { + if(seq->flag & SELECT) { + if(seq_tx_check_left(seq)) + bounds_left = MIN2(bounds_left, seq_tx_get_final_left(seq, 0)); + if(seq_tx_check_right(seq)) + bounds_right = MAX2(bounds_right,seq_tx_get_final_right(seq, 0)); + } + } + + /* its possible there were no points to set on either side */ + if (bounds_left != MAXFRAME*2) + snap_points[snap_point_num++] = bounds_left; + if (bounds_right != -(MAXFRAME*2)) + snap_points[snap_point_num++] = bounds_right; + } + + + /* Define so we can snap to other points without hassle */ + +#define TESTSNAP(test_frame)\ + for(j=0; j<snap_point_num; j++) {\ + /* see if this beats the current best snap point */\ + dist = abs(snap_points[j] - test_frame);\ + if (dist < snap_dist) {\ + snap_ofs = test_frame - snap_points[j];\ + snap_dist = dist;\ + }\ + } + + + /* Detect the best marker to snap to! */ + for(a=0, marker= scene->markers.first; marker; a++, marker= marker->next) { + + /* dont snap to a marker on the wrong extend side */ + if (mode=='e' && ((side == 'L' && marker->frame > cfra) || (side == 'R' && marker->frame < cfra))) + continue; + + /* when we are moving markers, dont snap to selected markers, durr */ + if ((sseq->flag & SEQ_MARKER_TRANS)==0 || (marker->flag & SELECT)==0) { + + /* loop over the sticky points - max 4 */ + TESTSNAP(marker->frame); + if (snap_dist == 0) break; /* alredy snapped? - stop looking */ + } + } + + if (snap_dist) { + TESTSNAP(cfra); + } + + /* check seq's next to the active also - nice for quick snapping */ + if (snap_dist && last_seq && seq_tx_check_left(last_seq)) { + seq = find_next_prev_sequence(scene, last_seq, 1, 0); /* left */ + if(seq && !seq_tx_check_right(seq)) + TESTSNAP(seq_tx_get_final_right(seq, 0)); + } + + if (snap_dist && last_seq && seq_tx_check_right(last_seq)) { + seq = find_next_prev_sequence(scene, last_seq, 2, 0); /* right */ + if(seq && !seq_tx_check_left(seq)) + TESTSNAP(seq_tx_get_final_left(seq, 0)); + } + +#undef TESTSNAP + + if (abs(ix_old-ix) >= snapdist_max) { + /* mouse has moved out of snap range */ + snapskip = 0; + } else if (snap_dist==0) { + /* nowhere to move, dont do anything */ + snapskip = 1; + } else if (snap_dist < snapdist_max) { + /* do the snapping by adjusting the mouse offset value */ + ix = ix_old + snap_ofs; + } + } + + if (mode=='g' && !snapskip) { + /* Grab */ + for(seq_index=0, seq=seqar[0]; seq_index < totseq_index; seq=seqar[++seq_index]) { + if(seq->flag & SELECT && !(seq->depth==0 && seq->flag & SEQ_LOCK)) { + int myofs; + /* flag, ignores lefsel/rightsel for nested strips */ + int sel_flag = (seq->depth==0) ? seq->flag : seq->flag & ~(SEQ_LEFTSEL+SEQ_RIGHTSEL); + + // SEQ_DEBUG_INFO(seq); + + /* X Transformation */ + if((seq->depth==0) && (sel_flag & SEQ_LEFTSEL)) { + myofs = (ts->startofs - ts->startstill); + seq_tx_set_final_left(seq, ts->start + (myofs + ix)); + } + if((seq->depth==0) && (sel_flag & SEQ_RIGHTSEL)) { + myofs = (ts->endstill - ts->endofs); + seq_tx_set_final_right(seq, ts->start + seq->len + (myofs + ix)); + } + transform_grab_xlimits(seq, sel_flag & SEQ_LEFTSEL, sel_flag & SEQ_RIGHTSEL); + + if( (sel_flag & (SEQ_LEFTSEL+SEQ_RIGHTSEL))==0 ) { + if(sequence_is_free_transformable(seq)) seq->start= ts->start+ ix; + + /* Y Transformation */ + if(seq->depth==0) seq->machine= ts->machine+ iy; + + if(seq->machine<1) seq->machine= 1; + else if(seq->machine>= MAXSEQ) seq->machine= MAXSEQ; + } + calc_sequence(seq); + ts++; + } + } + + /* Markers */ + if (sseq->flag & SEQ_MARKER_TRANS) { + for(a=0, marker= scene->markers.first; marker; marker= marker->next) { + if(marker->flag & SELECT) { + marker->frame= oldframe[a] + ix; + marker_moved=1; + a++; + } + } + } + + /* Extend, grabs one side of the current frame */ + } else if (mode=='e' && !snapskip) { + int myofs; /* offset from start of the seq clip */ + int xnew, final_left, final_right; /* just to store results from seq_tx_get_final_left/right */ + + /* we dont use seq side selection flags for this, + instead we need to calculate which sides to move + based on its initial position from the cursor */ + int move_left, move_right; + + /* Extend, Similar to grab but operate on one side of the cursor */ + for(seq_index=0, seq=seqar[0]; seq_index < totseq_index; seq=seqar[++seq_index]) { + if(seq->flag & SELECT && !(seq->depth==0 && seq->flag & SEQ_LOCK)) { + /* only move the contents of the metastrip otherwise the transformation is applied twice */ + if (sequence_is_free_transformable(seq) && seq->type != SEQ_META) { + + move_left = move_right = 0; + + //SEQ_DEBUG_INFO(seq); + + final_left = seq_tx_get_final_left(seq, 1); + final_right = seq_tx_get_final_right(seq, 1); + + /* Only X Axis moving */ + + /* work out which sides to move first */ + if (side=='L') { + if (final_left <= cfra || ts->final_left <= cfra) move_left = 1; + if (final_right <= cfra || ts->final_right <= cfra) move_right = 1; + } else { + if (final_left >= cfra || ts->final_left >= cfra) move_left = 1; + if (final_right >= cfra || ts->final_right >= cfra) move_right = 1; + } + + if (move_left && move_right) { + /* simple move - dont need to do anything complicated */ + seq->start= ts->start+ ix; + } else { + if (side=='L') { + if (move_left) { + + /* Similar to other funcs */ + myofs = (ts->startofs - ts->startstill); + xnew = ts->start + (ix + myofs); + + /* make sure the we dont resize down to 0 or less in size + also include the startstill so the contense dosnt go outside the bounds, + if the seq->startofs is 0 then its ignored */ + + /* TODO remove, add check to transform_grab_xlimits, works ok for now */ + if (xnew + seq->startstill > final_right-1) { + xnew = (final_right-1) - seq->startstill; + } + /* Note, this is the only case where the start needs to be adjusted + since its not needed when modifying the end or when moving the entire sequence */ + //seq->start = ts->start+ix; // This works when xnew is not clamped, line below takes clamping into account + seq->start= xnew - myofs; /* TODO see above */ + /* done with unique stuff */ + + seq_tx_set_final_left(seq, xnew); + transform_grab_xlimits(seq, 1, 0); + + /* Special case again - setting the end back to what it was */ + seq_tx_set_final_right(seq, final_right); + } + if (move_right) { + myofs = (ts->endstill - ts->endofs); + xnew = ts->start + seq->len + (myofs + ix); + seq_tx_set_final_right(seq, xnew); + transform_grab_xlimits(seq, 0, 1); + } + } else { /* R */ + if (move_left) { + myofs = (ts->startofs - ts->startstill); + xnew = ts->start + (myofs + ix); + seq_tx_set_final_left(seq, xnew); + transform_grab_xlimits(seq, 1, 0); + } + if (move_right) { + myofs = (ts->endstill - ts->endofs); + xnew = ts->start + seq->len + (myofs + ix); + seq_tx_set_final_right(seq, xnew); + transform_grab_xlimits(seq, 0, 1); + } + } + } + } + calc_sequence(seq); + ts++; + } + } + + /* markers */ + if (sseq->flag & SEQ_MARKER_TRANS) { + for(a=0, marker= scene->markers.first; marker; marker= marker->next) {\ + if (marker->flag & SELECT) { + if(oldframe[a] != MAXFRAME+1) { + marker->frame= oldframe[a] + ix; + marker_moved=1; + } + a++; + } + } + } + } + + sprintf(str, "X: %d Y: %d ", ix, iy); +// headerprint(str); + + /* remember the last value for snapping, + only set if we are not currently snapped, + prevents locking on a keyframe */ + if (!snapskip) + ix_old = ix; + + /* just to tell if ctrl was pressed, this means we get a recalc when pressing ctrl */ + snap_old = snap; + + /* rememver last mouse values so we can skip transform when nothing happens */ + xo= mval[0]; + yo= mval[1]; + + /* test for effect and overlap */ + for(seq_index=0, seq=seqar[0]; seq_index < totseq_index; seq=seqar[++seq_index]) { + if((seq->depth==0) && (seq->flag & SELECT) && !(seq->depth==0 && seq->flag & SEQ_LOCK)) { + seq->flag &= ~SEQ_OVERLAP; + if( test_overlap_seq(scene, seq) ) { + seq->flag |= SEQ_OVERLAP; + } + } + else if(seq->type & SEQ_EFFECT) { + if(seq->seq1 && seq->seq1->flag & SELECT) calc_sequence(seq); + else if(seq->seq2 && seq->seq2->flag & SELECT) calc_sequence(seq); + else if(seq->seq3 && seq->seq3->flag & SELECT) calc_sequence(seq); + } + } + /* warning, drawing should NEVER use WHILE_SEQ, + if it does the seq->depth value will be messed up and + overlap checks with metastrips will give incorrect results */ +// XXX force_draw_plus(SPACE_BUTS, 0); + + } + +#if 0 + while(qtest()) { + event= extern_qread(&val); + if(val) { + switch(event) { + case ESCKEY: + case LEFTMOUSE: + case RIGHTMOUSE: + case SPACEKEY: + case RETKEY: + afbreek= 1; + break; + case XKEY: + if(!(midtog && (proj == 0))) { + midtog= ~midtog; + } + if(midtog) { + proj= 1; + firsttime= 1; + } + break; + case YKEY: + if(!(midtog && (proj == 1))) { + midtog= ~midtog; + } + if(midtog) { + proj= 0; + firsttime= 1; + } + break; + case MIDDLEMOUSE: + midtog= ~midtog; + if(midtog) { + if( abs(mval[0]-xn) > abs(mval[1]-yn)) proj= 1; + else proj= 0; + firsttime= 1; + } + break; + default: + arrows_move_cursor(event); + } + } + if(afbreek) break; + } +#endif + } + + if((event==ESCKEY) || (event==RIGHTMOUSE)) { + + ts= transmain; + for(seq_index=0, seq=seqar[0]; seq_index < totseq_index; seq=seqar[++seq_index]) { + if(seq->flag & SELECT && !(seq->depth==0 && seq->flag & SEQ_LOCK)) { + seq->start= ts->start; + seq->machine= ts->machine; + seq->startstill= ts->startstill; + seq->endstill= ts->endstill; + seq->startofs= ts->startofs; + seq->endofs= ts->endofs; + + calc_sequence(seq); + seq->flag &= ~SEQ_OVERLAP; + + ts++; + } else if(seq->type & SEQ_EFFECT) { + if(seq->seq1 && seq->seq1->flag & SELECT) calc_sequence(seq); + else if(seq->seq2 && seq->seq2->flag & SELECT) calc_sequence(seq); + else if(seq->seq3 && seq->seq3->flag & SELECT) calc_sequence(seq); + } + } + + /* Markers */ + if (sseq->flag & SEQ_MARKER_TRANS) { + for(a=0, marker= scene->markers.first; marker; marker= marker->next) { + if (marker->flag & SELECT) { + if(oldframe[a] != MAXFRAME+1) { + marker->frame= oldframe[a]; + } + a++; + } + } + marker_moved = 0; + } + } else { + + /* images, effects and overlap */ + for(seq_index=0, seq=seqar[0]; seq_index < totseq_index; seq=seqar[++seq_index]) { + + /* fixes single image strips - makes sure their start is not out of bounds + ideally this would be done during transform since data is rendered at that time + however it ends up being a lot messier! - Campbell */ + fix_single_image_seq(seq); + + if(seq->type == SEQ_META) { + calc_sequence(seq); + seq->flag &= ~SEQ_OVERLAP; + if( test_overlap_seq(scene, seq) ) shuffle_seq(scene, seq); + } + else if(seq->flag & SELECT) { + calc_sequence(seq); + seq->flag &= ~SEQ_OVERLAP; + if( test_overlap_seq(scene, seq) ) shuffle_seq(scene, seq); + } + else if(seq->type & SEQ_EFFECT) calc_sequence(seq); + } + + /* as last: */ + sort_seq(scene); + } + + /* free sequence array */ + if(seqar) MEM_freeN(seqar); + + G.moving= 0; + MEM_freeN(transmain); + + if (sseq->flag & SEQ_MARKER_TRANS && totmark) + MEM_freeN(oldframe); + + if (mode=='g') + BIF_undo_push("Transform Grab, Sequencer"); + else if (mode=='e') + BIF_undo_push("Transform Extend, Sequencer"); + +} + +/* since grab can move markers, we must turn this off before adding a new sequence + I am not so happy with this, but the baddness in contained here - Campbell */ + +/* XXX temp disabled, will work differently anyway */ +void _transform_seq_nomarker_(Scene *scene, SpaceSeq *sseq, View2D *v2d, int mode, int context) +{ + int flag_back; + if (!sseq) return; /* should never happen */ + + flag_back = sseq->flag; + sseq->flag &= ~SEQ_MARKER_TRANS; + + transform_seq(scene, sseq, v2d, mode, context); + + sseq->flag = flag_back; +} + +void seq_separate_images(Scene *scene) +{ + Editing *ed; + Sequence *seq, *seq_new, *seq_next; + Strip *strip_new; + StripElem *se, *se_new; + int start_ofs, cfra, frame_end; + static int step= 1; + +// add_numbut(0, NUM|INT, "Image Duration:", 1, 256, &step, NULL); +// if (!do_clever_numbuts("Separate Images", 1, REDRAW)) +// return; + + ed= scene->ed; + if(ed==NULL) return; + + seq= ed->seqbasep->first; + + while (seq) { + if((seq->flag & SELECT) && (seq->type == SEQ_IMAGE) && (seq->len > 1)) { + /* remove seq so overlap tests dont conflict, + see seq_free_sequence below for the real free'ing */ + seq_next = seq->next; + BLI_remlink(ed->seqbasep, seq); + if(seq->ipo) seq->ipo->id.us--; + + start_ofs = cfra = seq_tx_get_final_left(seq, 0); + frame_end = seq_tx_get_final_right(seq, 0); + + while (cfra < frame_end) { + /* new seq */ + se = give_stripelem(seq, cfra); + + seq_new= alloc_sequence(((Editing *)scene->ed)->seqbasep, start_ofs, seq->machine); + seq_new->type= SEQ_IMAGE; + seq_new->len = 1; + seq_new->endstill = step-1; + + /* new strip */ + seq_new->strip= strip_new= MEM_callocN(sizeof(Strip)*1, "strip"); + strip_new->len= 1; + strip_new->us= 1; + strncpy(strip_new->dir, seq->strip->dir, FILE_MAXDIR-1); + + /* new stripdata */ + strip_new->stripdata= se_new= MEM_callocN(sizeof(StripElem)*1, "stripelem"); + strncpy(se_new->name, se->name, FILE_MAXFILE-1); + calc_sequence(seq_new); + seq_new->flag &= ~SEQ_OVERLAP; + if (test_overlap_seq(scene, seq_new)) { + shuffle_seq(scene, seq_new); + } + + cfra++; + start_ofs += step; + } + + seq_free_sequence(seq); + seq = seq->next; + } else { + seq = seq->next; + } + } + + /* as last: */ + sort_seq(scene); + BIF_undo_push("Separate Image Strips, Sequencer"); +} + +/* run recursivly to select linked */ +static int select_more_less_seq__internal(Scene *scene, int sel, int linked) { + Editing *ed; + Sequence *seq, *neighbor; + int change=0; + int isel; + + ed= scene->ed; + if(ed==NULL) return 0; + + if (sel) { + sel = SELECT; + isel = 0; + } else { + sel = 0; + isel = SELECT; + } + + if (!linked) { + /* if not linked we only want to touch each seq once, newseq */ + for(seq= ed->seqbasep->first; seq; seq= seq->next) { + seq->tmp = NULL; + } + } + + for(seq= ed->seqbasep->first; seq; seq= seq->next) { + if((int)(seq->flag & SELECT) == sel) { + if ((linked==0 && seq->tmp)==0) { + /* only get unselected nabours */ + neighbor = find_neighboring_sequence(scene, seq, 1, isel); + if (neighbor) { + if (sel) {neighbor->flag |= SELECT; recurs_sel_seq(neighbor);} + else neighbor->flag &= ~SELECT; + if (linked==0) neighbor->tmp = (Sequence *)1; + change = 1; + } + neighbor = find_neighboring_sequence(scene, seq, 2, isel); + if (neighbor) { + if (sel) {neighbor->flag |= SELECT; recurs_sel_seq(neighbor);} + else neighbor->flag &= ~SELECT; + if (linked==0) neighbor->tmp = (void *)1; + change = 1; + } + } + } + } + + return change; +} + +void select_less_seq(Scene *scene) +{ + if (select_more_less_seq__internal(scene, 0, 0)) { + BIF_undo_push("Select Less, Sequencer"); + } +} + +void select_more_seq(Scene *scene) +{ + if (select_more_less_seq__internal(scene, 1, 0)) { + BIF_undo_push("Select More, Sequencer"); + } +} + +/* TODO not all modes supported - if you feel like being picky, add them! ;) */ +void select_linked_seq(Scene *scene, View2D *v2d, int mode) +{ + Editing *ed; + Sequence *seq, *mouse_seq; + int selected, hand; + + ed= scene->ed; + if(ed==NULL) return; + + /* replace current selection */ + if (mode==0 || mode==2) { + /* this works like UV, not mesh */ + if (mode==0) { + mouse_seq= find_nearest_seq(scene, v2d, &hand); + if (!mouse_seq) + return; /* user error as with mesh?? */ + + for(seq= ed->seqbasep->first; seq; seq= seq->next) { + seq->flag &= ~SELECT; + } + mouse_seq->flag |= SELECT; + recurs_sel_seq(mouse_seq); + } + + selected = 1; + while (selected) { + selected = select_more_less_seq__internal(scene, 1, 1); + } + BIF_undo_push("Select Linked, Sequencer"); + } + /* TODO - more modes... */ +} + +void seq_snap(Scene *scene, short event) +{ + Editing *ed; + Sequence *seq; + + ed= scene->ed; + if(ed==NULL) return; + + /* problem: contents of meta's are all shifted to the same position... */ + + /* also check metas */ + SEQP_BEGIN(ed, seq) { + if (seq->flag & SELECT && !(seq->depth==0 && seq->flag & SEQ_LOCK) && + sequence_is_free_transformable(seq)) { + if((seq->flag & (SEQ_LEFTSEL+SEQ_RIGHTSEL))==0) { + seq->start= CFRA-seq->startofs+seq->startstill; + } else { + if(seq->flag & SEQ_LEFTSEL) { + seq_tx_set_final_left(seq, CFRA); + } else { /* SEQ_RIGHTSEL */ + seq_tx_set_final_right(seq, CFRA); + } + transform_grab_xlimits(seq, seq->flag & SEQ_LEFTSEL, seq->flag & SEQ_RIGHTSEL); + } + calc_sequence(seq); + } + } + SEQ_END + + /* test for effects and overlap */ + SEQP_BEGIN(ed, seq) { + if(seq->flag & SELECT && !(seq->depth==0 && seq->flag & SEQ_LOCK)) { + seq->flag &= ~SEQ_OVERLAP; + if( test_overlap_seq(scene, seq) ) { + shuffle_seq(scene, seq); + } + } + else if(seq->type & SEQ_EFFECT) { + if(seq->seq1 && (seq->seq1->flag & SELECT)) + calc_sequence(seq); + else if(seq->seq2 && (seq->seq2->flag & SELECT)) + calc_sequence(seq); + else if(seq->seq3 && (seq->seq3->flag & SELECT)) + calc_sequence(seq); + } + } + SEQ_END; + + /* as last: */ + sort_seq(scene); + + BIF_undo_push("Snap Strips, Sequencer"); +} + +void seq_snap_menu(Scene *scene) +{ + short event; + + event= pupmenu("Snap %t|To Current Frame%x1"); + if(event < 1) return; + + seq_snap(scene, event); +} + + +void seq_mute_sel(Scene *scene, int mute) { + Editing *ed; + Sequence *seq; + + ed= scene->ed; + if(!ed) return; + + for(seq= ed->seqbasep->first; seq; seq= seq->next) { + if ((seq->flag & SEQ_LOCK)==0) { + if (mute==-1) { /* hide unselected */ + if ((seq->flag & SELECT)==0) { + seq->flag |= SEQ_MUTE; + } + } else if (seq->flag & SELECT) { + if (mute) seq->flag |= SEQ_MUTE; + else seq->flag &= ~SEQ_MUTE; + } + } + } + BIF_undo_push(mute?"Mute Strips, Sequencer":"UnMute Strips, Sequencer"); +} + +void seq_lock_sel(Scene *scene, int lock) +{ + Editing *ed; + Sequence *seq; + + ed= scene->ed; + if(!ed) return; + + for(seq= ed->seqbasep->first; seq; seq= seq->next) { + if ((seq->flag & SELECT)) { + if (lock) seq->flag |= SEQ_LOCK; + else seq->flag &= ~SEQ_LOCK; + } + } + BIF_undo_push(lock?"Lock Strips, Sequencer":"Unlock Strips, Sequencer"); +} + +void borderselect_seq(Scene *scene, View2D *v2d) +{ + Sequence *seq; + Editing *ed; + rcti rect; + rctf rectf, rq; + int val; + short mval[2]; + + ed= scene->ed; + if(ed==NULL) return; + +// XXX val= get_border(&rect, 3); + + if(val) { + mval[0]= rect.xmin; + mval[1]= rect.ymin; + UI_view2d_region_to_view(v2d, mval[0], mval[1], &rectf.xmin, &rectf.ymin); + mval[0]= rect.xmax; + mval[1]= rect.ymax; + UI_view2d_region_to_view(v2d, mval[0], mval[1], &rectf.xmax, &rectf.ymax); + + seq= ed->seqbasep->first; + while(seq) { + + if(seq->startstill) rq.xmin= seq->start; + else rq.xmin= seq->startdisp; + rq.ymin= seq->machine+0.2; + if(seq->endstill) rq.xmax= seq->start+seq->len; + else rq.xmax= seq->enddisp; + rq.ymax= seq->machine+0.8; + + if(BLI_isect_rctf(&rq, &rectf, 0)) { + if(val==LEFTMOUSE) { + seq->flag |= SELECT; + } + else { + seq->flag &= ~SELECT; + } + recurs_sel_seq(seq); + } + + seq= seq->next; + } + + BIF_undo_push("Border Select, Sequencer"); + } +} diff --git a/source/blender/editors/space_sequencer/sequencer_draw.c b/source/blender/editors/space_sequencer/sequencer_draw.c new file mode 100644 index 00000000000..b8b8f4af36c --- /dev/null +++ b/source/blender/editors/space_sequencer/sequencer_draw.c @@ -0,0 +1,1135 @@ +/** + * $Id$ + * + * ***** BEGIN GPL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * Contributor(s): Blender Foundation, 2003-2009 + * + * ***** END GPL LICENSE BLOCK ***** + */ + +#include <string.h> +#include <math.h> + +#include "MEM_guardedalloc.h" + +#include "BMF_Api.h" + +#include "BLI_blenlib.h" +#include "BLI_arithb.h" + +#include "IMB_imbuf_types.h" + +#include "DNA_gpencil_types.h" +#include "DNA_sequence_types.h" +#include "DNA_scene_types.h" +#include "DNA_screen_types.h" +#include "DNA_space_types.h" +#include "DNA_view2d_types.h" +#include "DNA_userdef_types.h" + +#include "BKE_context.h" +#include "BKE_global.h" +#include "BKE_plugin_types.h" +#include "BKE_sequence.h" +#include "BKE_scene.h" +#include "BKE_utildefines.h" + +#include "IMB_imbuf_types.h" +#include "IMB_imbuf.h" + +#include "BIF_gl.h" +#include "BIF_glutil.h" + +#include "ED_anim_api.h" +#include "ED_space_api.h" +#include "ED_types.h" + +#include "UI_interface.h" +#include "UI_resources.h" +#include "UI_view2d.h" + +/* own include */ +#include "sequencer_intern.h" + +#define SEQ_LEFTHANDLE 1 +#define SEQ_RIGHTHANDLE 2 + +#define SEQ_STRIP_OFSBOTTOM 0.2 +#define SEQ_STRIP_OFSTOP 0.8 + +/* Note, Dont use WHILE_SEQ while drawing! - it messes up transform, - Campbell */ + +int no_rightbox=0, no_leftbox= 0; +static void draw_shadedstrip(Sequence *seq, char *col, float x1, float y1, float x2, float y2); + + +static void draw_cfra_seq(View2D *v2d, int cfra) +{ + glColor3ub(0x30, 0x90, 0x50); + glLineWidth(2.0); + glBegin(GL_LINES); + glVertex2f(cfra, v2d->cur.ymin); + glVertex2f(cfra, v2d->cur.ymax); + glEnd(); + glLineWidth(1.0); +} + +static void get_seq_color3ubv(Scene *curscene, Sequence *seq, char *col) +{ + char blendcol[3]; + float hsv[3], rgb[3]; + SolidColorVars *colvars = (SolidColorVars *)seq->effectdata; + + switch(seq->type) { + case SEQ_IMAGE: + UI_GetThemeColor3ubv(TH_SEQ_IMAGE, col); + break; + case SEQ_META: + UI_GetThemeColor3ubv(TH_SEQ_META, col); + break; + case SEQ_MOVIE: + UI_GetThemeColor3ubv(TH_SEQ_MOVIE, col); + break; + case SEQ_SCENE: + UI_GetThemeColor3ubv(TH_SEQ_SCENE, col); + + if(seq->scene==curscene) { + UI_GetColorPtrBlendShade3ubv(col, col, col, 1.0, 20); + } + break; + + /* transitions */ + case SEQ_CROSS: + case SEQ_GAMCROSS: + case SEQ_WIPE: + /* slightly offset hue to distinguish different effects */ + UI_GetThemeColor3ubv(TH_SEQ_TRANSITION, col); + + rgb[0] = col[0]/255.0; rgb[1] = col[1]/255.0; rgb[2] = col[2]/255.0; + rgb_to_hsv(rgb[0], rgb[1], rgb[2], hsv, hsv+1, hsv+2); + + if (seq->type == SEQ_CROSS) hsv[0]+= 0.04; + if (seq->type == SEQ_GAMCROSS) hsv[0]+= 0.08; + if (seq->type == SEQ_WIPE) hsv[0]+= 0.12; + + if(hsv[0]>1.0) hsv[0]-=1.0; else if(hsv[0]<0.0) hsv[0]+= 1.0; + hsv_to_rgb(hsv[0], hsv[1], hsv[2], rgb, rgb+1, rgb+2); + col[0] = (char)(rgb[0]*255); col[1] = (char)(rgb[1]*255); col[2] = (char)(rgb[2]*255); + break; + + /* effects */ + case SEQ_TRANSFORM: + case SEQ_SPEED: + case SEQ_ADD: + case SEQ_SUB: + case SEQ_MUL: + case SEQ_ALPHAOVER: + case SEQ_ALPHAUNDER: + case SEQ_OVERDROP: + case SEQ_GLOW: + /* slightly offset hue to distinguish different effects */ + UI_GetThemeColor3ubv(TH_SEQ_EFFECT, col); + + rgb[0] = col[0]/255.0; rgb[1] = col[1]/255.0; rgb[2] = col[2]/255.0; + rgb_to_hsv(rgb[0], rgb[1], rgb[2], hsv, hsv+1, hsv+2); + + if (seq->type == SEQ_ADD) hsv[0]+= 0.04; + if (seq->type == SEQ_SUB) hsv[0]+= 0.08; + if (seq->type == SEQ_MUL) hsv[0]+= 0.12; + if (seq->type == SEQ_ALPHAOVER) hsv[0]+= 0.16; + if (seq->type == SEQ_ALPHAUNDER) hsv[0]+= 0.20; + if (seq->type == SEQ_OVERDROP) hsv[0]+= 0.24; + if (seq->type == SEQ_GLOW) hsv[0]+= 0.28; + if (seq->type == SEQ_TRANSFORM) hsv[0]+= 0.36; + + if(hsv[0]>1.0) hsv[0]-=1.0; else if(hsv[0]<0.0) hsv[0]+= 1.0; + hsv_to_rgb(hsv[0], hsv[1], hsv[2], rgb, rgb+1, rgb+2); + col[0] = (char)(rgb[0]*255); col[1] = (char)(rgb[1]*255); col[2] = (char)(rgb[2]*255); + break; + case SEQ_COLOR: + if (colvars->col) { + col[0]= (char)(colvars->col[0]*255); + col[1]= (char)(colvars->col[1]*255); + col[2]= (char)(colvars->col[2]*255); + } else { + col[0] = col[1] = col[2] = 128; + } + break; + case SEQ_PLUGIN: + UI_GetThemeColor3ubv(TH_SEQ_PLUGIN, col); + break; + case SEQ_HD_SOUND: + case SEQ_RAM_SOUND: + UI_GetThemeColor3ubv(TH_SEQ_AUDIO, col); + blendcol[0] = blendcol[1] = blendcol[2] = 128; + if(seq->flag & SEQ_MUTE) UI_GetColorPtrBlendShade3ubv(col, blendcol, col, 0.5, 20); + break; + default: + col[0] = 10; col[1] = 255; col[2] = 40; + } +} + +static void drawmeta_contents(Scene *scene, Sequence *seqm, float x1, float y1, float x2, float y2) +{ + /* Note, this used to use WHILE_SEQ, but it messes up the seq->depth value, (needed by transform when doing overlap checks) + * so for now, just use the meta's immediate children, could be fixed but its only drawing - Campbell */ + Sequence *seq; + float dx; + int nr; + char col[3]; + + nr= BLI_countlist(&seqm->seqbase); + + dx= (x2-x1)/nr; + + if (seqm->flag & SEQ_MUTE) { + glEnable(GL_POLYGON_STIPPLE); + glPolygonStipple(stipple_halftone); + + glEnable(GL_LINE_STIPPLE); + glLineStipple(1, 0x8888); + } + + for (seq= seqm->seqbase.first; seq; seq= seq->next) { + get_seq_color3ubv(scene, seq, col); + + glColor3ubv((GLubyte *)col); + + glRectf(x1, y1, x1+0.9*dx, y2); + + UI_GetColorPtrBlendShade3ubv(col, col, col, 0.0, -30); + glColor3ubv((GLubyte *)col); + + fdrawbox(x1, y1, x1+0.9*dx, y2); + + x1+= dx; + } + + if (seqm->flag & SEQ_MUTE) { + glDisable(GL_POLYGON_STIPPLE); + glDisable(GL_LINE_STIPPLE); + } +} + +static void drawseqwave(Scene *scene, View2D *v2d, Sequence *seq, float x1, float y1, float x2, float y2, int winx) +{ + /* + x1 is the starting x value to draw the wave, + x2 the end x value, same for y1 and y2 + winx is the zoom level. + */ + + float + f, /* floating point value used to store the X draw location for the wave lines when openGL drawing*/ + midy, /* fast access to the middle location (y1+y2)/2 */ + clipxmin, /* the minimum X value, clip this with the window */ + clipxmax, /* the maximum X value, clip this with the window */ + sample_step, /* steps to move per sample, floating value must later translate into an int */ + fsofs, /* steps to move per sample, floating value must later translate into an int */ + feofs_sofs, /* */ + sound_width, /* convenience: x2-x1 */ + wavemulti; /* scale the samples by this value when GL_LINE drawing so it renders the right height */ + + int + offset, /* initial offset value for the wave drawing */ + offset_next, /* when in the wave drawing loop this value is the samples intil the next vert */ + sofs, /* Constrained offset value (~3) for the wave, start */ + eofs, /* ditto, end */ + wavesample, /* inner loop storage if the current wave sample value, used to make the 2 values below */ + wavesamplemin, /* used for finding the min and max wave peaks */ + wavesamplemax, /* ditto */ + subsample_step=4; /* when the sample step is 4 every sample of + the wave is evaluated for min and max values used to draw the wave, + however this is slow ehrn zoomed out so when the sample step is above + 1 (the larger the further out the zoom is) so not evaluate all samples, only some. */ + + signed short* s; + bSound *sound; + uint8_t *stream; + +// XXX audio_makestream(seq->sound); +// if(seq->sound==NULL || seq->sound->stream==NULL) return; + + if (seq->flag & SEQ_MUTE) glColor3ub(0x70, 0x80, 0x80); else glColor3ub(0x70, 0xc0, 0xc0); + + sofs = ((int)( FRA2TIME(seq->startdisp-seq->start+seq->anim_startofs)*(float)scene->r.audio.mixrate*4.0 )) & (~3); + eofs = ((int)( FRA2TIME(seq->enddisp-seq->start+seq->anim_startofs)*(float)scene->r.audio.mixrate*4.0 )) & (~3); + + /* clip the drawing area to the screen bounds to save time */ + sample_step= (v2d->cur.xmax - v2d->cur.xmin)/winx; + clipxmin= MAX2(x1, v2d->cur.xmin); + clipxmax= MIN2(x2, v2d->cur.xmax); + + if (sample_step > 1) + subsample_step= ((int)(subsample_step*sample_step*8)) & (~3); + + /* for speedy access */ + midy = (y1+y2)/2; + fsofs= (float)sofs; + feofs_sofs= (float)(eofs-sofs); + sound_width= x2-x1; + sound = seq->sound; + stream = sound->stream; + wavemulti = (y2-y1)/196605; /*y2-y1 is the height*/ + wavesample=0; + + /* we need to get the starting offset value, excuse the duplicate code */ + f=clipxmin; + offset= (int) (fsofs + ((f-x1)/sound_width) * feofs_sofs) & (~3); + + /* start the loop, draw a line per sample_step -sample_step is about 1 line drawn per pixel */ + glBegin(GL_LINES); + for (f=x1+sample_step; f<=clipxmax; f+=sample_step) { + + offset_next = (int) (fsofs + ((f-x1)/sound_width) * feofs_sofs) & (~3); + if (f > v2d->cur.xmin) { + /* if this is close to the last sample just exit */ + if (offset_next >= sound->streamlen) break; + + wavesamplemin = 131070; + wavesamplemax = -131070; + + /*find with high and low of the waveform for this draw, + evaluate small samples to find this range */ + while (offset < offset_next) { + s = (signed short*)(stream+offset); + + wavesample = s[0]*2 + s[1]; + if (wavesamplemin>wavesample) + wavesamplemin=wavesample; + if (wavesamplemax<wavesample) + wavesamplemax=wavesample; + offset+=subsample_step; + } + /* draw the wave line, looks good up close and zoomed out */ + glVertex2f(f, midy-(wavemulti*wavesamplemin) ); + glVertex2f(f, midy-(wavemulti*wavesamplemax) ); + } else { + while (offset < offset_next) offset+=subsample_step; + } + + offset=offset_next; + } + glEnd(); +} + +/* draw a handle, for each end of a sequence strip */ +static void draw_seq_handle(SpaceSeq *sseq, Sequence *seq, float pixelx, short direction) +{ + float v1[2], v2[2], v3[2], rx1=0, rx2=0; //for triangles and rect + float x1, x2, y1, y2; + float handsize; + float minhandle, maxhandle; + char str[32]; + unsigned int whichsel=0; + View2D *v2d; + + x1= seq->startdisp; + x2= seq->enddisp; + + y1= seq->machine+SEQ_STRIP_OFSBOTTOM; + y2= seq->machine+SEQ_STRIP_OFSTOP; + + v2d = &sseq->v2d; + + /* clamp handles to defined size in pixel space */ + handsize = seq->handsize; + minhandle = 7; + maxhandle = 40; + CLAMP(handsize, minhandle*pixelx, maxhandle*pixelx); + + /* set up co-ordinates/dimensions for either left or right handle */ + if (direction == SEQ_LEFTHANDLE) { + rx1 = x1; + rx2 = x1+handsize*0.75; + + v1[0]= x1+handsize/4; v1[1]= y1+( ((y1+y2)/2.0 - y1)/2); + v2[0]= x1+handsize/4; v2[1]= y2-( ((y1+y2)/2.0 - y1)/2); + v3[0]= v2[0] + handsize/4; v3[1]= (y1+y2)/2.0; + + whichsel = SEQ_LEFTSEL; + } else if (direction == SEQ_RIGHTHANDLE) { + rx1 = x2-handsize*0.75; + rx2 = x2; + + v1[0]= x2-handsize/4; v1[1]= y1+( ((y1+y2)/2.0 - y1)/2); + v2[0]= x2-handsize/4; v2[1]= y2-( ((y1+y2)/2.0 - y1)/2); + v3[0]= v2[0] - handsize/4; v3[1]= (y1+y2)/2.0; + + whichsel = SEQ_RIGHTSEL; + } + + /* draw! */ + if(seq->type < SEQ_EFFECT || + get_sequence_effect_num_inputs(seq->type) == 0) { + glEnable( GL_BLEND ); + + glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + + if(seq->flag & whichsel) glColor4ub(0, 0, 0, 80); + else if (seq->flag & SELECT) glColor4ub(255, 255, 255, 30); + else glColor4ub(0, 0, 0, 22); + + glRectf(rx1, y1, rx2, y2); + + if(seq->flag & whichsel) glColor4ub(255, 255, 255, 200); + else glColor4ub(0, 0, 0, 50); + + glEnable( GL_POLYGON_SMOOTH ); + glBegin(GL_TRIANGLES); + glVertex2fv(v1); glVertex2fv(v2); glVertex2fv(v3); + glEnd(); + + glDisable( GL_POLYGON_SMOOTH ); + glDisable( GL_BLEND ); + } + + if(G.moving || (seq->flag & whichsel)) { + cpack(0xFFFFFF); + if (direction == SEQ_LEFTHANDLE) { + sprintf(str, "%d", seq->startdisp); + glRasterPos3f(rx1, y1-0.15, 0.0); + } else { + sprintf(str, "%d", seq->enddisp - 1); + glRasterPos3f((x2-BMF_GetStringWidth(G.fonts, str)*pixelx), y2+0.05, 0.0); + } + BMF_DrawString(G.fonts, str); + } +} + +static void draw_seq_extensions(Scene *scene, SpaceSeq *sseq, Sequence *seq) +{ + float x1, x2, y1, y2, pixely, a; + char col[3], blendcol[3]; + View2D *v2d; + + if(seq->type >= SEQ_EFFECT) return; + + x1= seq->startdisp; + x2= seq->enddisp; + + y1= seq->machine+SEQ_STRIP_OFSBOTTOM; + y2= seq->machine+SEQ_STRIP_OFSTOP; + + v2d = &sseq->v2d; + pixely = (v2d->cur.ymax - v2d->cur.ymin)/(v2d->mask.ymax - v2d->mask.ymin); + + blendcol[0] = blendcol[1] = blendcol[2] = 120; + + if(seq->startofs) { + glEnable( GL_BLEND ); + glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + + get_seq_color3ubv(scene, seq, col); + + if (seq->flag & SELECT) { + UI_GetColorPtrBlendShade3ubv(col, blendcol, col, 0.3, -40); + glColor4ub(col[0], col[1], col[2], 170); + } else { + UI_GetColorPtrBlendShade3ubv(col, blendcol, col, 0.6, 0); + glColor4ub(col[0], col[1], col[2], 110); + } + + glRectf((float)(seq->start), y1-SEQ_STRIP_OFSBOTTOM, x1, y1); + + if (seq->flag & SELECT) glColor4ub(col[0], col[1], col[2], 255); + else glColor4ub(col[0], col[1], col[2], 160); + + fdrawbox((float)(seq->start), y1-SEQ_STRIP_OFSBOTTOM, x1, y1); //outline + + glDisable( GL_BLEND ); + } + if(seq->endofs) { + glEnable( GL_BLEND ); + glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + + get_seq_color3ubv(scene, seq, col); + + if (seq->flag & SELECT) { + UI_GetColorPtrBlendShade3ubv(col, blendcol, col, 0.3, -40); + glColor4ub(col[0], col[1], col[2], 170); + } else { + UI_GetColorPtrBlendShade3ubv(col, blendcol, col, 0.6, 0); + glColor4ub(col[0], col[1], col[2], 110); + } + + glRectf(x2, y2, (float)(seq->start+seq->len), y2+SEQ_STRIP_OFSBOTTOM); + + if (seq->flag & SELECT) glColor4ub(col[0], col[1], col[2], 255); + else glColor4ub(col[0], col[1], col[2], 160); + + fdrawbox(x2, y2, (float)(seq->start+seq->len), y2+SEQ_STRIP_OFSBOTTOM); //outline + + glDisable( GL_BLEND ); + } + if(seq->startstill) { + get_seq_color3ubv(scene, seq, col); + UI_GetColorPtrBlendShade3ubv(col, blendcol, col, 0.75, 40); + glColor3ubv((GLubyte *)col); + + draw_shadedstrip(seq, col, x1, y1, (float)(seq->start), y2); + + /* feint pinstripes, helps see exactly which is extended and which isn't, + * especially when the extension is very small */ + if (seq->flag & SELECT) UI_GetColorPtrBlendShade3ubv(col, col, col, 0.0, 24); + else UI_GetColorPtrBlendShade3ubv(col, col, col, 0.0, -16); + + glColor3ubv((GLubyte *)col); + + for(a=y1; a< y2; a+= pixely*2.0 ) { + fdrawline(x1, a, (float)(seq->start), a); + } + } + if(seq->endstill) { + get_seq_color3ubv(scene, seq, col); + UI_GetColorPtrBlendShade3ubv(col, blendcol, col, 0.75, 40); + glColor3ubv((GLubyte *)col); + + draw_shadedstrip(seq, col, (float)(seq->start+seq->len), y1, x2, y2); + + /* feint pinstripes, helps see exactly which is extended and which isn't, + * especially when the extension is very small */ + if (seq->flag & SELECT) UI_GetColorPtrBlendShade3ubv(col, col, col, 0.0, 24); + else UI_GetColorPtrBlendShade3ubv(col, col, col, 0.0, -16); + + glColor3ubv((GLubyte *)col); + + for(a=y1; a< y2; a+= pixely*2.0 ) { + fdrawline((float)(seq->start+seq->len), a, x2, a); + } + } +} + +/* draw info text on a sequence strip */ +static void draw_seq_text(View2D *v2d, Sequence *seq, float x1, float x2, float y1, float y2, char *background_col) +{ + float v1[2], v2[2]; + int len, size; + char str[32 + FILE_MAXDIR+FILE_MAXFILE], *strp; + short mval[2]; + + v1[1]= y1; + v2[1]= y2; + + v1[0]= x1; + UI_view2d_to_region_no_clip(v2d, v1[0], v1[1], mval, mval+1); + x1= mval[0]; + v2[0]= x2; + UI_view2d_to_region_no_clip(v2d, v2[0], v2[1], mval, mval+1); + x2= mval[0]; + size= x2-x1; + + if(seq->name[2]) { + sprintf(str, "%d | %s: %s", seq->len, give_seqname(seq), seq->name+2); + }else{ + if(seq->type == SEQ_META) { + sprintf(str, "%d | %s", seq->len, give_seqname(seq)); + } + else if(seq->type == SEQ_SCENE) { + if(seq->scene) sprintf(str, "%d | %s: %s", seq->len, give_seqname(seq), seq->scene->id.name+2); + else sprintf(str, "%d | %s", seq->len, give_seqname(seq)); + + } + else if(seq->type == SEQ_IMAGE) { + sprintf(str, "%d | %s%s", seq->len, seq->strip->dir, seq->strip->stripdata->name); + } + else if(seq->type & SEQ_EFFECT) { + int can_float = (seq->type != SEQ_PLUGIN) + || (seq->plugin && seq->plugin->version >= 4); + + if(seq->seq3!=seq->seq2 && seq->seq1!=seq->seq3) + sprintf(str, "%d | %s: %d>%d (use %d)%s", seq->len, give_seqname(seq), seq->seq1->machine, seq->seq2->machine, seq->seq3->machine, can_float ? "" : " No float, upgrade plugin!"); + else if (seq->seq1 && seq->seq2) + sprintf(str, "%d | %s: %d>%d%s", seq->len, give_seqname(seq), seq->seq1->machine, seq->seq2->machine, can_float ? "" : " No float, upgrade plugin!"); + else + sprintf(str, "%d | %s", seq->len, give_seqname(seq)); + } + else if (seq->type == SEQ_RAM_SOUND) { + sprintf(str, "%d | %s", seq->len, seq->strip->stripdata->name); + } + else if (seq->type == SEQ_HD_SOUND) { + sprintf(str, "%d | %s", seq->len, seq->strip->stripdata->name); + } + else if (seq->type == SEQ_MOVIE) { + sprintf(str, "%d | %s%s", seq->len, seq->strip->dir, seq->strip->stripdata->name); + } + } + + strp= str; + + while( (len= BMF_GetStringWidth(G.font, strp)) > size) { + if(len < 10) break; + if(strp[1]==0) break; + strp++; + } + + mval[0]= (x1+x2-len+1)/2; + mval[1]= 1; + UI_view2d_region_to_view(v2d, mval[0], mval[1], &x1, &x2); + + if(seq->flag & SELECT){ + cpack(0xFFFFFF); + }else if ((((int)background_col[0] + (int)background_col[1] + (int)background_col[2]) / 3) < 50){ + cpack(0x505050); /* use lighter text colour for dark background */ + }else{ + cpack(0); + } + glRasterPos3f(x1, y1+SEQ_STRIP_OFSBOTTOM, 0.0); + BMF_DrawString(G.font, strp); +} + +/* draws a shaded strip, made from gradient + flat color + gradient */ +static void draw_shadedstrip(Sequence *seq, char *col, float x1, float y1, float x2, float y2) +{ + float ymid1, ymid2; + + if (seq->flag & SEQ_MUTE) { + glEnable(GL_POLYGON_STIPPLE); + glPolygonStipple(stipple_halftone); + } + + ymid1 = (y2-y1)*0.25 + y1; + ymid2 = (y2-y1)*0.65 + y1; + + glShadeModel(GL_SMOOTH); + glBegin(GL_QUADS); + + if(seq->flag & SELECT) UI_GetColorPtrBlendShade3ubv(col, col, col, 0.0, -50); + else UI_GetColorPtrBlendShade3ubv(col, col, col, 0.0, 0); + + glColor3ubv((GLubyte *)col); + + glVertex2f(x1,y1); + glVertex2f(x2,y1); + + if(seq->flag & SELECT) UI_GetColorPtrBlendShade3ubv(col, col, col, 0.0, 5); + else UI_GetColorPtrBlendShade3ubv(col, col, col, 0.0, -5); + + glColor3ubv((GLubyte *)col); + + glVertex2f(x2,ymid1); + glVertex2f(x1,ymid1); + + glEnd(); + + glRectf(x1, ymid1, x2, ymid2); + + glBegin(GL_QUADS); + + glVertex2f(x1,ymid2); + glVertex2f(x2,ymid2); + + if(seq->flag & SELECT) UI_GetColorPtrBlendShade3ubv(col, col, col, 0.0, -15); + else UI_GetColorPtrBlendShade3ubv(col, col, col, 0.0, 25); + + glColor3ubv((GLubyte *)col); + + glVertex2f(x2,y2); + glVertex2f(x1,y2); + + glEnd(); + + if (seq->flag & SEQ_MUTE) { + glDisable(GL_POLYGON_STIPPLE); + } +} + +/* +Draw a sequence strip, bounds check alredy made +ARegion is currently only used to get the windows width in pixels +so wave file sample drawing precission is zoom adjusted +*/ +static void draw_seq_strip(Scene *scene, ARegion *ar, SpaceSeq *sseq, Sequence *seq, int outline_tint, float pixelx) +{ + // XXX + extern void gl_round_box_shade(int mode, float minx, float miny, float maxx, float maxy, float rad, float shadetop, float shadedown); + View2D *v2d= &ar->v2d; + float x1, x2, y1, y2; + char col[3], background_col[3], is_single_image; + + /* we need to know if this is a single image/color or not for drawing */ + is_single_image = (char)check_single_seq(seq); + + /* body */ + if(seq->startstill) x1= seq->start; + else x1= seq->startdisp; + y1= seq->machine+SEQ_STRIP_OFSBOTTOM; + if(seq->endstill) x2= seq->start+seq->len; + else x2= seq->enddisp; + y2= seq->machine+SEQ_STRIP_OFSTOP; + + + /* get the correct color per strip type*/ + //get_seq_color3ubv(scene, seq, col); + get_seq_color3ubv(scene, seq, background_col); + + /* draw the main strip body */ + if (is_single_image) /* single image */ + draw_shadedstrip(seq, background_col, seq_tx_get_final_left(seq, 0), y1, seq_tx_get_final_right(seq, 0), y2); + else /* normal operation */ + draw_shadedstrip(seq, background_col, x1, y1, x2, y2); + + /* draw additional info and controls */ + if (seq->type == SEQ_RAM_SOUND) + drawseqwave(scene, v2d, seq, x1, y1, x2, y2, ar->winx); + + if (!is_single_image) + draw_seq_extensions(scene, sseq, seq); + + draw_seq_handle(sseq, seq, pixelx, SEQ_LEFTHANDLE); + draw_seq_handle(sseq, seq, pixelx, SEQ_RIGHTHANDLE); + + /* draw the strip outline */ + x1= seq->startdisp; + x2= seq->enddisp; + + get_seq_color3ubv(scene, seq, col); + if (G.moving && (seq->flag & SELECT)) { + if(seq->flag & SEQ_OVERLAP) { + col[0]= 255; col[1]= col[2]= 40; + } else UI_GetColorPtrBlendShade3ubv(col, col, col, 0.0, 120); + } + + UI_GetColorPtrBlendShade3ubv(col, col, col, 0.0, outline_tint); + + glColor3ubv((GLubyte *)col); + + if (seq->flag & SEQ_MUTE) { + glEnable(GL_LINE_STIPPLE); + glLineStipple(1, 0x8888); + } + + gl_round_box_shade(GL_LINE_LOOP, x1, y1, x2, y2, 0.0, 0.1, 0.0); + + if (seq->flag & SEQ_MUTE) { + glDisable(GL_LINE_STIPPLE); + } + + /* calculate if seq is long enough to print a name */ + x1= seq->startdisp+seq->handsize; + x2= seq->enddisp-seq->handsize; + + /* but first the contents of a meta */ + if(seq->type==SEQ_META) drawmeta_contents(scene, seq, x1, y1+0.15, x2, y2-0.15); + + /* info text on the strip */ + if(x1<v2d->cur.xmin) x1= v2d->cur.xmin; + else if(x1>v2d->cur.xmax) x1= v2d->cur.xmax; + if(x2<v2d->cur.xmin) x2= v2d->cur.xmin; + else if(x2>v2d->cur.xmax) x2= v2d->cur.xmax; + + /* nice text here would require changing the view matrix for texture text */ + if( (x2-x1) / pixelx > 32) { + draw_seq_text(v2d, seq, x1, x2, y1, y2, background_col); + } +} + +static Sequence *special_seq_update= 0; + +void set_special_seq_update(int val) +{ +// int x; + + /* if mouse over a sequence && LEFTMOUSE */ + if(val) { +// XXX special_seq_update= find_nearest_seq(&x); + } + else special_seq_update= 0; +} + + +static void draw_image_seq(Scene *scene, ARegion *ar, SpaceSeq *sseq) +{ + extern void gl_round_box(int mode, float minx, float miny, float maxx, float maxy, float rad); + struct ImBuf *ibuf; + int x1, y1, rectx, recty; + int free_ibuf = 0; + static int recursive= 0; + float zoom; + float zoomx, zoomy; + + glClearColor(0.0, 0.0, 0.0, 0.0); + glClear(GL_COLOR_BUFFER_BIT); + + rectx= (scene->r.size*scene->r.xsch)/100; + recty= (scene->r.size*scene->r.ysch)/100; + + /* BIG PROBLEM: the give_ibuf_seq() can call a rendering, which in turn calls redraws... + this shouldn't belong in a window drawing.... + So: solve this once event based. + Now we check for recursion, space type and active area again (ton) */ + + if(recursive) + return; + else { + recursive= 1; + if (special_seq_update) { + ibuf= give_ibuf_seq_direct(scene, rectx, recty, (scene->r.cfra), special_seq_update); + } + else if (!U.prefetchframes) { // XXX || (G.f & G_PLAYANIM) == 0) { + ibuf= (ImBuf *)give_ibuf_seq(scene, rectx, recty, (scene->r.cfra), sseq->chanshown); + } + else { + ibuf= (ImBuf *)give_ibuf_seq_threaded(scene, rectx, recty, (scene->r.cfra), sseq->chanshown); + } + recursive= 0; + + /* XXX HURMF! the give_ibuf_seq can call image display in this window */ +// if(sa->spacetype!=SPACE_SEQ) +// return; +// if(sa!=curarea) { +// areawinset(sa->win); +// } + } + + if(ibuf==NULL) + return; + + if(ibuf->rect==NULL && ibuf->rect_float == NULL) + return; + + switch(sseq->mainb) { + case SEQ_DRAW_IMG_IMBUF: + if (sseq->zebra != 0) { + ibuf = make_zebra_view_from_ibuf(ibuf, sseq->zebra); + free_ibuf = 1; + } + break; + case SEQ_DRAW_IMG_WAVEFORM: + if ((sseq->flag & SEQ_DRAW_COLOR_SEPERATED) != 0) { + ibuf = make_sep_waveform_view_from_ibuf(ibuf); + } else { + ibuf = make_waveform_view_from_ibuf(ibuf); + } + free_ibuf = 1; + break; + case SEQ_DRAW_IMG_VECTORSCOPE: + ibuf = make_vectorscope_view_from_ibuf(ibuf); + free_ibuf = 1; + break; + case SEQ_DRAW_IMG_HISTOGRAM: + ibuf = make_histogram_view_from_ibuf(ibuf); + free_ibuf = 1; + break; + } + + if(ibuf->rect_float && ibuf->rect==NULL) + IMB_rect_from_float(ibuf); + + /* needed for gla draw */ + glaDefine2DArea(&ar->winrct); + + zoom= SEQ_ZOOM_FAC(sseq->zoom); + if (sseq->mainb == SEQ_DRAW_IMG_IMBUF) { + zoomx = zoom * ((float)scene->r.xasp / (float)scene->r.yasp); + zoomy = zoom; + } else { + zoomx = zoomy = zoom; + } + + /* calc location */ + x1= (ar->winx-zoomx*ibuf->x)/2 + sseq->xof; + y1= (ar->winy-zoomy*ibuf->y)/2 + sseq->yof; + + glPixelZoom(zoomx, zoomy); + + glaDrawPixelsSafe(x1, y1, ibuf->x, ibuf->y, ibuf->x, GL_RGBA, GL_UNSIGNED_BYTE, ibuf->rect); + + glPixelZoom(1.0, 1.0); + + /* safety border */ + if (sseq->mainb == SEQ_DRAW_IMG_IMBUF && + (sseq->flag & SEQ_DRAW_SAFE_MARGINS) != 0) { + float fac= 0.1; + float x2 = x1 + ibuf->x * zoomx; + float y2 = y1 + ibuf->y * zoomy; + + float a= fac*(x2-x1); + x1+= a; + x2-= a; + + a= fac*(y2-y1); + y1+= a; + y2-= a; + + glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); + setlinestyle(3); + + UI_ThemeColorBlendShade(TH_WIRE, TH_BACK, 1.0, 0); + + uiSetRoundBox(15); + gl_round_box(GL_LINE_LOOP, x1, y1, x2, y2, 12.0); + + setlinestyle(0); + glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); + } + + /* draw grease-pencil (image aligned) */ +// if (sseq->flag & SEQ_DRAW_GPENCIL) +// XXX draw_gpencil_2dimage(sa, ibuf); + + if (free_ibuf) { + IMB_freeImBuf(ibuf); + } + + /* draw grease-pencil (screen aligned) */ +// if (sseq->flag & SEQ_DRAW_GPENCIL) +// XXX draw_gpencil_2dview(sa, 0); + + /* ortho at pixel level sa */ +// XXX myortho2(-0.375, sa->winx-0.375, -0.375, sa->winy-0.375); + +} + +void seq_reset_imageofs(SpaceSeq *sseq) +{ + sseq->xof = sseq->yof = sseq->zoom = 0; +} + +void seq_home(Scene *scene, ARegion *ar, SpaceSeq *sseq) +{ + View2D *v2d= &ar->v2d; + + if (!sseq->mainb) { + v2d->cur= v2d->tot; +// test_view2d(v2d, ar->winx, ar->winy); +// view2d_do_locks(ar, V2D_LOCK_COPY); + } else { + float zoomX, zoomY; + int width, height, imgwidth, imgheight; + + width = ar->winx; + height = ar->winy; + + seq_reset_imageofs(sseq); + + imgwidth= (scene->r.size*scene->r.xsch)/100; + imgheight= (scene->r.size*scene->r.ysch)/100; + + /* Apply aspect, dosnt need to be that accurate */ + imgwidth= (int)(imgwidth * ((float)scene->r.xasp / (float)scene->r.yasp)); + + if (((imgwidth >= width) || (imgheight >= height)) && + ((width > 0) && (height > 0))) { + + /* Find the zoom value that will fit the image in the image space */ + zoomX = ((float)width) / ((float)imgwidth); + zoomY = ((float)height) / ((float)imgheight); + sseq->zoom= (zoomX < zoomY) ? zoomX : zoomY; + + sseq->zoom = 1.0f / power_of_2(1/ MIN2(zoomX, zoomY) ); + } + else { + sseq->zoom= 1.0f; + } + } +} + +#if 0 +/* XXX */ +void seq_viewzoom(SpaceSeq *sseq, unsigned short event, int invert) +{ + + if(event==PAD1) + sseq->zoom= 1.0; + else if(event==PAD2) + sseq->zoom= (invert)? 2.0: 0.5; + else if(event==PAD4) + sseq->zoom= (invert)? 4.0: 0.25; + else if(event==PAD8) + sseq->zoom= (invert)? 8.0: 0.125; + + /* ensure pixel exact locations for draw */ + sseq->xof= (int)sseq->xof; + sseq->yof= (int)sseq->yof; +} + +void seq_viewmove(Scene *scene, ARegion *ar, SpaceSeq *sseq) +{ + short mval[2], mvalo[2]; + short rectx, recty, xmin, xmax, ymin, ymax, pad; + int oldcursor; + Window *win; + + sa = sseq->area; + rectx= (scene->r.size*scene->r.xsch)/100; + recty= (scene->r.size*scene->r.ysch)/100; + + pad = 10; + xmin = -(ar->winx/2) - rectx/2 + pad; + xmax = ar->winx/2 + rectx/2 - pad; + ymin = -(ar->winy/2) - recty/2 + pad; + ymax = ar->winy/2 + recty/2 - pad; + + getmouseco_sc(mvalo); + + oldcursor=get_cursor(); + win=winlay_get_active_window(); + + SetBlenderCursor(BC_NSEW_SCROLLCURSOR); + + while(get_mbut()&(L_MOUSE|M_MOUSE)) { + + getmouseco_sc(mval); + + if(mvalo[0]!=mval[0] || mvalo[1]!=mval[1]) { + + sseq->xof -= (mvalo[0]-mval[0]); + sseq->yof -= (mvalo[1]-mval[1]); + + /* prevent dragging image outside of the window and losing it! */ + CLAMP(sseq->xof, xmin, xmax); + CLAMP(sseq->yof, ymin, ymax); + + mvalo[0]= mval[0]; + mvalo[1]= mval[1]; + + } + } +} +#endif + +void drawprefetchseqspace(Scene *scene, ARegion *ar, SpaceSeq *sseq) +{ + int rectx, recty; + + rectx= (scene->r.size*scene->r.xsch)/100; + recty= (scene->r.size*scene->r.ysch)/100; + + if(sseq->mainb) { + give_ibuf_prefetch_request( + rectx, recty, (scene->r.cfra), sseq->chanshown); + } +} + +void drawseqspace(const bContext *C, ARegion *ar) +{ + ScrArea *sa= CTX_wm_area(C); + SpaceSeq *sseq= sa->spacedata.first; + Scene *scene= CTX_data_scene(C); + View2D *v2d= &ar->v2d; + View2DScrollers *scrollers; + Editing *ed; + Sequence *seq; + float col[3]; + int i; + + ed= scene->ed; + + if(sseq->mainb) { + draw_image_seq(scene, ar, sseq); + return; + } + + UI_GetThemeColor3fv(TH_BACK, col); + if(ed && ed->metastack.first) glClearColor(col[0], col[1], col[2]-0.1, 0.0); + else glClearColor(col[0], col[1], col[2], 0.0); + + glClear(GL_COLOR_BUFFER_BIT); + + UI_view2d_view_ortho(C, v2d); + + UI_ThemeColorShade(TH_BACK, -20); + glRectf(v2d->cur.xmin, 0.0, v2d->cur.xmax, 1.0); + + boundbox_seq(scene, &v2d->tot); + + /* Alternating horizontal stripes */ + i= MAX2(1, ((int)v2d->cur.ymin)-1); + + glBegin(GL_QUADS); + while (i<v2d->cur.ymax) { + if (((int)i) & 1) + UI_ThemeColorShade(TH_BACK, -15); + else + UI_ThemeColorShade(TH_BACK, -25); + + glVertex2f(v2d->cur.xmax, i); + glVertex2f(v2d->cur.xmin, i); + glVertex2f(v2d->cur.xmin, i+1); + glVertex2f(v2d->cur.xmax, i+1); + i+=1.0; + } + glEnd(); + + /* Force grid lines */ + i= MAX2(1, ((int)v2d->cur.ymin)-1); + glBegin(GL_LINES); + + while (i<v2d->cur.ymax) { + UI_ThemeColor(TH_GRID); + glVertex2f(v2d->cur.xmax, i); + glVertex2f(v2d->cur.xmin, i); + i+=1.0; + } + glEnd(); + + UI_view2d_constant_grid_draw(C, v2d); + + draw_cfra_seq(v2d, scene->r.cfra); + + /* sequences: first deselect */ + if(ed) { + Sequence *last_seq = get_last_seq(scene); + int sel = 0, j; + int outline_tint; + float pixelx = (v2d->cur.xmax - v2d->cur.xmin)/(v2d->mask.xmax - v2d->mask.xmin); + /* loop through twice, first unselected, then selected */ + for (j=0; j<2; j++) { + seq= ed->seqbasep->first; + if (j==0) outline_tint = -150; + else outline_tint = -60; + + while(seq) { /* bound box test, dont draw outside the view */ + if ( ((seq->flag & SELECT) == sel) || + seq == last_seq || + MIN2(seq->startdisp, seq->start) > v2d->cur.xmax || + MAX2(seq->enddisp, seq->start+seq->len) < v2d->cur.xmin || + seq->machine+1.0 < v2d->cur.ymin || + seq->machine > v2d->cur.ymax) + { + /* dont draw */ + } else { + draw_seq_strip(scene, ar, sseq, seq, outline_tint, pixelx); + } + seq= seq->next; + } + sel= SELECT; /* draw selected next time round */ + } + /* draw the last selected last, removes some overlapping error */ + if (last_seq) { + draw_seq_strip(scene, ar, sseq, last_seq, 120, pixelx); + } + } + + /* Draw markers */ +// draw_markers_timespace(SCE_MARKERS, DRAW_MARKERS_LINES); + + /* reset view matrix */ + UI_view2d_view_restore(C); + + /* scrollers */ + scrollers= UI_view2d_scrollers_calc(C, v2d, 10, V2D_GRID_CLAMP, V2D_ARG_DUMMY, V2D_ARG_DUMMY); + UI_view2d_scrollers_draw(C, v2d, scrollers); + UI_view2d_scrollers_free(scrollers); +} + + diff --git a/source/blender/editors/space_sequencer/sequencer_intern.h b/source/blender/editors/space_sequencer/sequencer_intern.h index d3eb681686b..47d2ae6ee9b 100644 --- a/source/blender/editors/space_sequencer/sequencer_intern.h +++ b/source/blender/editors/space_sequencer/sequencer_intern.h @@ -28,14 +28,36 @@ #ifndef ED_SEQUENCER_INTERN_H #define ED_SEQUENCER_INTERN_H -#define MAXSEQ 32 - /* internal exports only */ +struct Sequence; +struct bContext; +struct rctf; +struct SpaceSeq; +struct ARegion; +struct Scene; + +#define SEQ_ZOOM_FAC(szoom) (szoom > 0)? (szoom) : (szoom == 0)? (1.0) : (-1.0/szoom) /* sequencer_header.c */ -void sequencer_header_buttons(const bContext *C, ARegion *ar); +void sequencer_header_buttons(const struct bContext *C, struct ARegion *ar); + +/* sequencer_draw.c */ +void drawseqspace(const struct bContext *C, struct ARegion *ar); + +/* sequencer_edit.c */ +int check_single_seq(struct Sequence *seq); +int seq_tx_get_final_left(struct Sequence *seq, int metaclip); +int seq_tx_get_final_right(struct Sequence *seq, int metaclip); +void boundbox_seq(struct Scene *scene, struct rctf *rect); +struct Sequence *get_last_seq(struct Scene *scene); +/* sequencer_scope.c */ +struct ImBuf *make_waveform_view_from_ibuf(struct ImBuf * ibuf); +struct ImBuf *make_sep_waveform_view_from_ibuf(struct ImBuf * ibuf); +struct ImBuf *make_vectorscope_view_from_ibuf(struct ImBuf * ibuf); +struct ImBuf *make_zebra_view_from_ibuf(struct ImBuf * ibuf, float perc); +struct ImBuf *make_histogram_view_from_ibuf(struct ImBuf * ibuf); #endif /* ED_SEQUENCER_INTERN_H */ diff --git a/source/blender/editors/space_sequencer/sequencer_scopes.c b/source/blender/editors/space_sequencer/sequencer_scopes.c new file mode 100644 index 00000000000..e26f445ae44 --- /dev/null +++ b/source/blender/editors/space_sequencer/sequencer_scopes.c @@ -0,0 +1,701 @@ +/** + * $Id$ + * + * ***** BEGIN GPL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * Author: Peter Schlaile < peter [at] schlaile [dot] de > + * + * ***** END GPL LICENSE BLOCK ***** + * + */ + +#include <math.h> +#include <string.h> + +#include "BKE_utildefines.h" + +#include "IMB_imbuf_types.h" +#include "IMB_imbuf.h" + +#include "sequencer_intern.h" + +static void rgb_to_yuv(float rgb[3], float yuv[3]) +{ + yuv[0]= 0.299*rgb[0] + 0.587*rgb[1] + 0.114*rgb[2]; + yuv[1]= 0.492*(rgb[2] - yuv[0]); + yuv[2]= 0.877*(rgb[0] - yuv[0]); + + /* Normalize */ + yuv[1]*= 255.0/(122*2.0); + yuv[1]+= 0.5; + + yuv[2]*= 255.0/(157*2.0); + yuv[2]+= 0.5; +} + +static void scope_put_pixel(unsigned char* table, unsigned char * pos) +{ + char newval = table[*pos]; + pos[0] = pos[1] = pos[2] = newval; + pos[3] = 255; +} + +static void scope_put_pixel_single(unsigned char* table, unsigned char * pos, + int col) +{ + char newval = table[pos[col]]; + pos[col] = newval; + pos[3] = 255; +} + +static void wform_put_line(int w, + unsigned char * last_pos, unsigned char * new_pos) +{ + if (last_pos > new_pos) { + unsigned char* temp = new_pos; + new_pos = last_pos; + last_pos = temp; + } + + while (last_pos < new_pos) { + if (last_pos[0] == 0) { + last_pos[0] = last_pos[1] = last_pos[2] = 32; + last_pos[3] = 255; + } + last_pos += 4*w; + } +} + +static void wform_put_line_single( + int w, unsigned char * last_pos, unsigned char * new_pos, int col) +{ + if (last_pos > new_pos) { + unsigned char* temp = new_pos; + new_pos = last_pos; + last_pos = temp; + } + + while (last_pos < new_pos) { + if (last_pos[col] == 0) { + last_pos[col] = 32; + last_pos[3] = 255; + } + last_pos += 4*w; + } +} + +static void wform_put_border(unsigned char * tgt, int w, int h) +{ + int x, y; + + for (x = 0; x < w; x++) { + unsigned char * p = tgt + 4 * x; + p[1] = p[3] = 255.0; + p[4 * w + 1] = p[4 * w + 3] = 255.0; + p = tgt + 4 * (w * (h - 1) + x); + p[1] = p[3] = 255.0; + p[-4 * w + 1] = p[-4 * w + 3] = 255.0; + } + + for (y = 0; y < h; y++) { + unsigned char * p = tgt + 4 * w * y; + p[1] = p[3] = 255.0; + p[4 + 1] = p[4 + 3] = 255.0; + p = tgt + 4 * (w * y + w - 1); + p[1] = p[3] = 255.0; + p[-4 + 1] = p[-4 + 3] = 255.0; + } +} + +static void wform_put_gridrow(unsigned char * tgt, float perc, int w, int h) +{ + int i; + + tgt += (int) (perc/100.0 * h) * w * 4; + + for (i = 0; i < w*2; i++) { + tgt[0] = 255; + + tgt += 4; + } +} + +static void wform_put_grid(unsigned char * tgt, int w, int h) +{ + wform_put_gridrow(tgt, 90.0, w, h); + wform_put_gridrow(tgt, 70.0, w, h); + wform_put_gridrow(tgt, 10.0, w, h); +} + +static struct ImBuf *make_waveform_view_from_ibuf_byte(struct ImBuf * ibuf) +{ + struct ImBuf * rval = IMB_allocImBuf(ibuf->x + 3, 515, 32, IB_rect, 0); + int x,y; + unsigned char* src = (unsigned char*) ibuf->rect; + unsigned char* tgt = (unsigned char*) rval->rect; + int w = ibuf->x + 3; + int h = 515; + float waveform_gamma = 0.2; + unsigned char wtable[256]; + + wform_put_grid(tgt, w, h); + + for (x = 0; x < 256; x++) { + wtable[x] = (unsigned char) (pow(((float) x + 1)/256, + waveform_gamma)*255); + } + + for (y = 0; y < ibuf->y; y++) { + unsigned char * last_p = 0; + + for (x = 0; x < ibuf->x; x++) { + unsigned char * rgb = src + 4 * (ibuf->x * y + x); + float v = 1.0 * + ( 0.299*rgb[0] + + 0.587*rgb[1] + + 0.114*rgb[2]) / 255.0; + unsigned char * p = tgt; + p += 4 * (w * ((int) (v * (h - 3)) + 1) + x + 1); + + scope_put_pixel(wtable, p); + p += 4 * w; + scope_put_pixel(wtable, p); + + if (last_p != 0) { + wform_put_line(w, last_p, p); + } + last_p = p; + } + } + + wform_put_border(tgt, w, h); + + return rval; +} + +static struct ImBuf *make_waveform_view_from_ibuf_float(struct ImBuf * ibuf) +{ + struct ImBuf * rval = IMB_allocImBuf(ibuf->x + 3, 515, 32, IB_rect, 0); + int x,y; + float* src = ibuf->rect_float; + unsigned char* tgt = (unsigned char*) rval->rect; + int w = ibuf->x + 3; + int h = 515; + float waveform_gamma = 0.2; + unsigned char wtable[256]; + + wform_put_grid(tgt, w, h); + + for (x = 0; x < 256; x++) { + wtable[x] = (unsigned char) (pow(((float) x + 1)/256, + waveform_gamma)*255); + } + + for (y = 0; y < ibuf->y; y++) { + unsigned char * last_p = 0; + + for (x = 0; x < ibuf->x; x++) { + float * rgb = src + 4 * (ibuf->x * y + x); + float v = 1.0 * + ( 0.299*rgb[0] + + 0.587*rgb[1] + + 0.114*rgb[2]); + unsigned char * p = tgt; + + CLAMP(v, 0.0, 1.0); + + p += 4 * (w * ((int) (v * (h - 3)) + 1) + x + 1); + + scope_put_pixel(wtable, p); + p += 4 * w; + scope_put_pixel(wtable, p); + + if (last_p != 0) { + wform_put_line(w, last_p, p); + } + last_p = p; + } + } + + wform_put_border(tgt, w, h); + + return rval; +} + +struct ImBuf *make_waveform_view_from_ibuf(struct ImBuf * ibuf) +{ + if (ibuf->rect_float) { + return make_waveform_view_from_ibuf_float(ibuf); + } else { + return make_waveform_view_from_ibuf_byte(ibuf); + } +} + + +static struct ImBuf *make_sep_waveform_view_from_ibuf_byte(struct ImBuf * ibuf) +{ + struct ImBuf * rval = IMB_allocImBuf( + ibuf->x + 3, 515, 32, IB_rect, 0); + int x,y; + unsigned char* src = (unsigned char*) ibuf->rect; + unsigned char* tgt = (unsigned char*) rval->rect; + int w = ibuf->x + 3; + int sw = ibuf->x/3; + int h = 515; + float waveform_gamma = 0.2; + unsigned char wtable[256]; + + wform_put_grid(tgt, w, h); + + for (x = 0; x < 256; x++) { + wtable[x] = (unsigned char) (pow(((float) x + 1)/256, + waveform_gamma)*255); + } + + for (y = 0; y < ibuf->y; y++) { + unsigned char * last_p[3] = {0,0,0}; + + for (x = 0; x < ibuf->x; x++) { + int c; + unsigned char * rgb = src + 4 * (ibuf->x * y + x); + for (c = 0; c < 3; c++) { + unsigned char * p = tgt; + p += 4 * (w * ((rgb[c] * (h - 3))/255 + 1) + + c * sw + x/3 + 1); + + scope_put_pixel_single(wtable, p, c); + p += 4 * w; + scope_put_pixel_single(wtable, p, c); + + if (last_p[c] != 0) { + wform_put_line_single( + w, last_p[c], p, c); + } + last_p[c] = p; + } + } + } + + wform_put_border(tgt, w, h); + + return rval; +} + +static struct ImBuf *make_sep_waveform_view_from_ibuf_float( + struct ImBuf * ibuf) +{ + struct ImBuf * rval = IMB_allocImBuf( + ibuf->x + 3, 515, 32, IB_rect, 0); + int x,y; + float* src = ibuf->rect_float; + unsigned char* tgt = (unsigned char*) rval->rect; + int w = ibuf->x + 3; + int sw = ibuf->x/3; + int h = 515; + float waveform_gamma = 0.2; + unsigned char wtable[256]; + + wform_put_grid(tgt, w, h); + + for (x = 0; x < 256; x++) { + wtable[x] = (unsigned char) (pow(((float) x + 1)/256, + waveform_gamma)*255); + } + + for (y = 0; y < ibuf->y; y++) { + unsigned char * last_p[3] = {0, 0, 0}; + + for (x = 0; x < ibuf->x; x++) { + int c; + float * rgb = src + 4 * (ibuf->x * y + x); + for (c = 0; c < 3; c++) { + unsigned char * p = tgt; + float v = rgb[c]; + + CLAMP(v, 0.0, 1.0); + + p += 4 * (w * ((int) (v * (h - 3)) + 1) + + c * sw + x/3 + 1); + + scope_put_pixel_single(wtable, p, c); + p += 4 * w; + scope_put_pixel_single(wtable, p, c); + + if (last_p[c] != 0) { + wform_put_line_single( + w, last_p[c], p, c); + } + last_p[c] = p; + } + } + } + + wform_put_border(tgt, w, h); + + return rval; +} + +struct ImBuf *make_sep_waveform_view_from_ibuf(struct ImBuf * ibuf) +{ + if (ibuf->rect_float) { + return make_sep_waveform_view_from_ibuf_float(ibuf); + } else { + return make_sep_waveform_view_from_ibuf_byte(ibuf); + } +} + +static void draw_zebra_byte(struct ImBuf * src,struct ImBuf * ibuf, float perc) +{ + unsigned int limit = 255 * perc / 100.0; + unsigned char * p = (unsigned char*) src->rect; + unsigned char * o = (unsigned char*) ibuf->rect; + int x; + int y; + + for (y = 0; y < ibuf->y; y++) { + for (x = 0; x < ibuf->x; x++) { + unsigned char r = *p++; + unsigned char g = *p++; + unsigned char b = *p++; + unsigned char a = *p++; + + if (r >= limit || g >= limit || b >= limit) { + if (((x + y) & 0x08) != 0) { + r = 255 - r; + g = 255 - g; + b = 255 - b; + } + } + *o++ = r; + *o++ = g; + *o++ = b; + *o++ = a; + } + } +} + + +static void draw_zebra_float(struct ImBuf * src,struct ImBuf * ibuf,float perc) +{ + float limit = perc / 100.0; + float * p = src->rect_float; + unsigned char * o = (unsigned char*) ibuf->rect; + int x; + int y; + + for (y = 0; y < ibuf->y; y++) { + for (x = 0; x < ibuf->x; x++) { + float r = *p++; + float g = *p++; + float b = *p++; + float a = *p++; + + if (r >= limit || g >= limit || b >= limit) { + if (((x + y) & 0x08) != 0) { + r = -r; + g = -g; + b = -b; + } + } + + *o++ = FTOCHAR(r); + *o++ = FTOCHAR(g); + *o++ = FTOCHAR(b); + *o++ = FTOCHAR(a); + } + } +} + +struct ImBuf * make_zebra_view_from_ibuf(struct ImBuf * src, float perc) +{ + struct ImBuf * ibuf = IMB_allocImBuf(src->x, src->y, 32, IB_rect, 0); + + if (src->rect_float) { + draw_zebra_float(src, ibuf, perc); + } else { + draw_zebra_byte(src, ibuf, perc); + } + return ibuf; +} + +static void draw_histogram_marker(struct ImBuf * ibuf, int x) +{ + unsigned char * p = (unsigned char*) ibuf->rect; + int barh = ibuf->y * 0.1; + int i; + + p += 4 * (x + ibuf->x * (ibuf->y - barh + 1)); + + for (i = 0; i < barh-1; i++) { + p[0] = p[1] = p[2] = 255; + p += ibuf->x * 4; + } +} + +static void draw_histogram_bar(struct ImBuf * ibuf, int x,float val, int col) +{ + unsigned char * p = (unsigned char*) ibuf->rect; + int barh = ibuf->y * val * 0.9; + int i; + + p += 4 * (x + ibuf->x); + + for (i = 0; i < barh; i++) { + p[col] = 255; + p += ibuf->x * 4; + } +} + +static struct ImBuf *make_histogram_view_from_ibuf_byte( + struct ImBuf * ibuf) +{ + struct ImBuf * rval = IMB_allocImBuf(515, 128, 32, IB_rect, 0); + int n,c,x,y; + unsigned char* src = (unsigned char*) ibuf->rect; + + unsigned int bins[3][256]; + + memset(bins, 0, 3 * 256* sizeof(unsigned int)); + + for (y = 0; y < ibuf->y; y++) { + for (x = 0; x < ibuf->x; x++) { + bins[0][*src++]++; + bins[1][*src++]++; + bins[2][*src++]++; + src++; + } + } + + n = 0; + for (c = 0; c < 3; c++) { + for (x = 0; x < 256; x++) { + if (bins[c][x] > n) { + n = bins[c][x]; + } + } + } + + for (c = 0; c < 3; c++) { + for (x = 0; x < 256; x++) { + draw_histogram_bar(rval, x*2+1, + ((float) bins[c][x])/n, c); + draw_histogram_bar(rval, x*2+2, + ((float) bins[c][x])/n, c); + } + } + + wform_put_border((unsigned char*) rval->rect, rval->x, rval->y); + + return rval; +} + +static int get_bin_float(float f) +{ + if (f < -0.25) { + f = -0.25; + } else if (f > 1.25) { + f = 1.25; + } + + return (int) (((f + 0.25) / 1.5) * 512); +} + +static struct ImBuf *make_histogram_view_from_ibuf_float( + struct ImBuf * ibuf) +{ + struct ImBuf * rval = IMB_allocImBuf(515, 128, 32, IB_rect, 0); + int n,c,x,y; + float* src = ibuf->rect_float; + + unsigned int bins[3][512]; + + memset(bins, 0, 3 * 256* sizeof(unsigned int)); + + for (y = 0; y < ibuf->y; y++) { + for (x = 0; x < ibuf->x; x++) { + bins[0][get_bin_float(*src++)]++; + bins[1][get_bin_float(*src++)]++; + bins[2][get_bin_float(*src++)]++; + src++; + } + } + + draw_histogram_marker(rval, get_bin_float(0.0)); + draw_histogram_marker(rval, get_bin_float(1.0)); + + n = 0; + for (c = 0; c < 3; c++) { + for (x = 0; x < 512; x++) { + if (bins[c][x] > n) { + n = bins[c][x]; + } + } + } + for (c = 0; c < 3; c++) { + for (x = 0; x < 512; x++) { + draw_histogram_bar(rval, x+1, (float) bins[c][x]/n, c); + } + } + + wform_put_border((unsigned char*) rval->rect, rval->x, rval->y); + + return rval; +} + +struct ImBuf *make_histogram_view_from_ibuf(struct ImBuf * ibuf) +{ + if (ibuf->rect_float) { + return make_histogram_view_from_ibuf_float(ibuf); + } else { + return make_histogram_view_from_ibuf_byte(ibuf); + } +} + +static void vectorscope_put_cross(unsigned char r, unsigned char g, + unsigned char b, + char * tgt, int w, int h, int size) +{ + float rgb[3], yuv[3]; + char * p; + int x = 0; + int y = 0; + + rgb[0]= (float)r/255.0; + rgb[1]= (float)g/255.0; + rgb[2]= (float)b/255.0; + rgb_to_yuv(rgb, yuv); + + p = tgt + 4 * (w * (int) ((yuv[2] * (h - 3) + 1)) + + (int) ((yuv[1] * (w - 3) + 1))); + + if (r == 0 && g == 0 && b == 0) { + r = 255; + } + + for (y = -size; y <= size; y++) { + for (x = -size; x <= size; x++) { + char * q = p + 4 * (y * w + x); + q[0] = r; q[1] = g; q[2] = b; q[3] = 255; + } + } +} + +static struct ImBuf *make_vectorscope_view_from_ibuf_byte(struct ImBuf * ibuf) +{ + struct ImBuf * rval = IMB_allocImBuf(515, 515, 32, IB_rect, 0); + int x,y; + char* src = (char*) ibuf->rect; + char* tgt = (char*) rval->rect; + float rgb[3], yuv[3]; + int w = 515; + int h = 515; + float scope_gamma = 0.2; + unsigned char wtable[256]; + + for (x = 0; x < 256; x++) { + wtable[x] = (unsigned char) (pow(((float) x + 1)/256, + scope_gamma)*255); + } + + for (x = 0; x <= 255; x++) { + vectorscope_put_cross(255 , 0,255 - x, tgt, w, h, 1); + vectorscope_put_cross(255 , x, 0, tgt, w, h, 1); + vectorscope_put_cross(255- x, 255, 0, tgt, w, h, 1); + vectorscope_put_cross(0, 255, x, tgt, w, h, 1); + vectorscope_put_cross(0, 255 - x, 255, tgt, w, h, 1); + vectorscope_put_cross(x, 0, 255, tgt, w, h, 1); + } + + for (y = 0; y < ibuf->y; y++) { + for (x = 0; x < ibuf->x; x++) { + char * src1 = src + 4 * (ibuf->x * y + x); + char * p; + + rgb[0]= (float)src1[0]/255.0; + rgb[1]= (float)src1[1]/255.0; + rgb[2]= (float)src1[2]/255.0; + rgb_to_yuv(rgb, yuv); + + p = tgt + 4 * (w * (int) ((yuv[2] * (h - 3) + 1)) + + (int) ((yuv[1] * (w - 3) + 1))); + scope_put_pixel(wtable, (unsigned char*)p); + } + } + + vectorscope_put_cross(0, 0, 0, tgt, w, h, 3); + + return rval; +} + +static struct ImBuf *make_vectorscope_view_from_ibuf_float(struct ImBuf * ibuf) +{ + struct ImBuf * rval = IMB_allocImBuf(515, 515, 32, IB_rect, 0); + int x,y; + float* src = ibuf->rect_float; + char* tgt = (char*) rval->rect; + float rgb[3], yuv[3]; + int w = 515; + int h = 515; + float scope_gamma = 0.2; + unsigned char wtable[256]; + + for (x = 0; x < 256; x++) { + wtable[x] = (unsigned char) (pow(((float) x + 1)/256, + scope_gamma)*255); + } + + for (x = 0; x <= 255; x++) { + vectorscope_put_cross(255 , 0,255 - x, tgt, w, h, 1); + vectorscope_put_cross(255 , x, 0, tgt, w, h, 1); + vectorscope_put_cross(255- x, 255, 0, tgt, w, h, 1); + vectorscope_put_cross(0, 255, x, tgt, w, h, 1); + vectorscope_put_cross(0, 255 - x, 255, tgt, w, h, 1); + vectorscope_put_cross(x, 0, 255, tgt, w, h, 1); + } + + for (y = 0; y < ibuf->y; y++) { + for (x = 0; x < ibuf->x; x++) { + float * src1 = src + 4 * (ibuf->x * y + x); + char * p; + + memcpy(rgb, src1, 3 * sizeof(float)); + + CLAMP(rgb[0], 0.0, 1.0); + CLAMP(rgb[1], 0.0, 1.0); + CLAMP(rgb[2], 0.0, 1.0); + + rgb_to_yuv(rgb, yuv); + + p = tgt + 4 * (w * (int) ((yuv[2] * (h - 3) + 1)) + + (int) ((yuv[1] * (w - 3) + 1))); + scope_put_pixel(wtable, (unsigned char*)p); + } + } + + vectorscope_put_cross(0, 0, 0, tgt, w, h, 3); + + return rval; +} + +struct ImBuf *make_vectorscope_view_from_ibuf(struct ImBuf * ibuf) +{ + if (ibuf->rect_float) { + return make_vectorscope_view_from_ibuf_float(ibuf); + } else { + return make_vectorscope_view_from_ibuf_byte(ibuf); + } +} diff --git a/source/blender/editors/space_sequencer/space_sequencer.c b/source/blender/editors/space_sequencer/space_sequencer.c index 08f700d1cf9..7adf042d13a 100644 --- a/source/blender/editors/space_sequencer/space_sequencer.c +++ b/source/blender/editors/space_sequencer/space_sequencer.c @@ -43,6 +43,7 @@ #include "BKE_colortools.h" #include "BKE_context.h" #include "BKE_screen.h" +#include "BKE_sequence.h" #include "ED_space_api.h" #include "ED_screen.h" @@ -111,8 +112,6 @@ static SpaceLink *sequencer_new(const bContext *C) ar->v2d.keepzoom= 0; ar->v2d.keeptot= 0; - - return (SpaceLink *)sseq; } @@ -156,28 +155,6 @@ static void sequencer_main_area_init(wmWindowManager *wm, ARegion *ar) WM_event_add_keymap_handler_bb(&ar->handlers, keymap, &ar->v2d.mask, &ar->winrct); } -static void sequencer_main_area_draw(const bContext *C, ARegion *ar) -{ - /* draw entirely, view changes should be handled here */ - // SpaceSeq *sseq= (SpaceSeq*)CTX_wm_space_data(C); - View2D *v2d= &ar->v2d; - float col[3]; - - /* clear and setup matrix */ - UI_GetThemeColor3fv(TH_BACK, col); - glClearColor(col[0], col[1], col[2], 0.0); - glClear(GL_COLOR_BUFFER_BIT); - - UI_view2d_view_ortho(C, v2d); - - /* data... */ - - - /* reset view matrix */ - UI_view2d_view_restore(C); - - /* scrollers? */ -} void sequencer_operatortypes(void) { @@ -241,7 +218,7 @@ void ED_spacetype_sequencer(void) art= MEM_callocN(sizeof(ARegionType), "spacetype sequencer region"); art->regionid = RGN_TYPE_WINDOW; art->init= sequencer_main_area_init; - art->draw= sequencer_main_area_draw; + art->draw= drawseqspace; art->listener= sequencer_main_area_listener; art->keymapflag= ED_KEYMAP_VIEW2D; |