: Track(edl, tracks)
{
data_type = TRACK_AUDIO;
+ data_h = edl->local_session->zoom_atrack;
}
ATrack::~ATrack()
{
public:
ATrack(EDL *edl, Tracks *tracks);
- ATrack() { };
~ATrack();
void create_objects();
w = nested_edl->session->output_w;
h = nested_edl->session->output_h;
}
- return w>0 && h>0 ? ((double)edl->local_session->zoom_track*w)/h : 0;
+ return w>0 && h>0 ? ((double)track->data_h*w)/h : 0;
}
int Edit::picon_h()
{
- return edl->local_session->zoom_track;
+ return track->data_h;
}
#define MAX_ZOOM_TIME 0x100000
#define DEFAULT_ZOOM_TIME 1024
#define MIN_AMP_ZOOM 8
-#define MAX_AMP_ZOOM 262144
-#define MIN_TRACK_ZOOM 32
-#define MAX_TRACK_ZOOM 1024
+#define MAX_AMP_ZOOM 8192
+#define MIN_TRACK_ZOOM 8
+#define MAX_TRACK_ZOOM 8192
#define MAX_PAN 1.0
#define PAN_RADIUS 50
// Start and length of fragment to read from file in bytes.
float *buffer = 0;
int buffer_shared = 0;
- int rect_audio = mwindow->preferences->rectify_audio;;
- int center_pixel = !rect_audio ?
- mwindow->edl->local_session->zoom_track / 2 :
- mwindow->edl->local_session->zoom_track;
+ int rect_audio = mwindow->preferences->rectify_audio;
+ int data_h = edit->track->data_h;
+ int center_pixel = !rect_audio ? data_h/2 : data_h;
if( edit->track->show_titles() )
center_pixel += mwindow->theme->get_image("title_bg_data")->get_h();
int prev_y1 = center_pixel;
int prev_y2 = center_pixel;
int first_frame = 1;
- int zoom_y = !rect_audio ?
- mwindow->edl->local_session->zoom_y / 2 :
- mwindow->edl->local_session->zoom_y;
+ int zoom_y = mwindow->edl->local_session->zoom_y * data_h /
+ mwindow->edl->local_session->zoom_atrack;
+ if( !rect_audio ) zoom_y /= 2;
int max_y = center_pixel + zoom_y - 1;
edit_position = (x + pixmap->pixmap_x - virtual_edit_x) * project_zoom;
int64_t speed_position = edit->startsource;
preview_start = 0; preview_end = -1;
zoom_sample = DEFAULT_ZOOM_TIME;
zoom_y = 0;
- zoom_track = 0;
+ zoom_atrack = 0;
+ zoom_vtrack = 0;
x_pane = y_pane = -1;
for(int i = 0; i < TOTAL_PANES; i++) {
zoom_sample = that->zoom_sample;
zoom_y = that->zoom_y;
- zoom_track = that->zoom_track;
+ zoom_atrack = that->zoom_atrack;
+ zoom_vtrack = that->zoom_vtrack;
preview_start = that->preview_start;
preview_end = that->preview_end;
red = that->red;
file->tag.set_property("ZOOM_SAMPLE", zoom_sample);
//printf("EDLSession::save_session 1\n");
file->tag.set_property("ZOOMY", zoom_y);
-//printf("EDLSession::save_session 1 %d\n", zoom_track);
- file->tag.set_property("ZOOM_TRACK", zoom_track);
+ file->tag.set_property("ZOOM_ATRACK", zoom_atrack);
+ file->tag.set_property("ZOOM_VTRACK", zoom_vtrack);
double preview_start = this->preview_start - start;
if( preview_start < 0 ) preview_start = 0;
zoom_sample = file->tag.get_property("ZOOM_SAMPLE", zoom_sample);
zoom_y = file->tag.get_property("ZOOMY", zoom_y);
- zoom_track = file->tag.get_property("ZOOM_TRACK", zoom_track);
+ int64_t zoom_track = file->tag.get_property("ZOOM_TRACK", 0);
+ if( zoom_track > 0 ) zoom_atrack = zoom_vtrack = zoom_track;
+ zoom_atrack = file->tag.get_property("ZOOM_ATRACK", zoom_atrack);
+ zoom_vtrack = file->tag.get_property("ZOOM_VTRACK", zoom_vtrack);
preview_start = file->tag.get_property("PREVIEW_START", preview_start);
preview_end = file->tag.get_property("PREVIEW_END", preview_end);
red = file->tag.get_property("RED", red);
// view_start = defaults->get("VIEW_START", 0);
zoom_sample = defaults->get("ZOOM_SAMPLE", DEFAULT_ZOOM_TIME);
zoom_y = defaults->get("ZOOMY", 64);
- zoom_track = defaults->get("ZOOM_TRACK", 64);
+ int64_t zoom_track = defaults->get("ZOOM_TRACK", 0);
+ if( zoom_track == 0 ) zoom_track = 64;
+ zoom_atrack = defaults->get("ZOOM_ATRACK", zoom_track);
+ zoom_vtrack = defaults->get("ZOOM_VTRACK", zoom_track);
red = defaults->get("RED", 0.0);
green = defaults->get("GREEN", 0.0);
blue = defaults->get("BLUE", 0.0);
// defaults->update("VIEW_START", view_start);
defaults->update("ZOOM_SAMPLE", zoom_sample);
defaults->update("ZOOMY", zoom_y);
- defaults->update("ZOOM_TRACK", zoom_track);
+ defaults->update("ZOOM_ATRACK", zoom_atrack);
+ defaults->update("ZOOM_VTRACK", zoom_vtrack);
defaults->update("RED", red);
defaults->update("GREEN", green);
defaults->update("BLUE", blue);
// Amplitude zoom
int64_t zoom_y;
// Track zoom
- int64_t zoom_track;
+ int64_t zoom_atrack;
+ int64_t zoom_vtrack;
// Vertical automation scale
float automation_mins[AUTOGROUPTYPE_COUNT];
int zoom_sample(int64_t zoom_sample);
void zoom_autos(float min, float max);
void zoom_amp(int64_t zoom_amp);
- void zoom_track(int64_t zoom_track);
+ void zoom_atrack(int64_t zoom);
+ void zoom_vtrack(int64_t zoom);
int fit_sample();
int move_left(int64_t distance = 0);
int move_right(int64_t distance = 0);
gui->flush();
}
-void MWindow::zoom_track(int64_t zoom_track)
+void MWindow::zoom_atrack(int64_t zoom)
{
+ int64_t old_zoom = edl->local_session->zoom_atrack;
// scale waveforms
edl->local_session->zoom_y = (int64_t)((float)edl->local_session->zoom_y *
- zoom_track /
- edl->local_session->zoom_track);
+ zoom / old_zoom);
CLAMP(edl->local_session->zoom_y, MIN_AMP_ZOOM, MAX_AMP_ZOOM);
// scale tracks
- double scale = (double)zoom_track / edl->local_session->zoom_track;
- edl->local_session->zoom_track = zoom_track;
-
+ edl->local_session->zoom_atrack = zoom;
+ for( Track *track= edl->tracks->first; track; track=track->next ) {
+ if( track->data_type != TRACK_AUDIO ) continue;
+ track->data_h = track->data_h * zoom / old_zoom;
+ bclamp(track->data_h, MIN_TRACK_ZOOM, MAX_TRACK_ZOOM);
+ }
// shift row position
- for(int i = 0; i < TOTAL_PANES; i++)
- {
- edl->local_session->track_start[i] *= scale;
+ for( int i=0; i<TOTAL_PANES; ++i ) edl->local_session->track_start[i] =
+ (edl->local_session->track_start[i] * zoom) / old_zoom;
+ edl->tracks->update_y_pixels(theme);
+ gui->draw_trackmovement();
+}
+
+void MWindow::zoom_vtrack(int64_t zoom)
+{
+ int64_t old_zoom = edl->local_session->zoom_vtrack;
+// scale tracks
+ edl->local_session->zoom_vtrack = zoom;
+ for( Track *track= edl->tracks->first; track; track=track->next ) {
+ if( track->data_type != TRACK_VIDEO ) continue;
+ track->data_h = track->data_h * zoom / old_zoom;
+ bclamp(track->data_h, MIN_TRACK_ZOOM, MAX_TRACK_ZOOM);
}
+// shift row position
+ for( int i=0; i<TOTAL_PANES; ++i ) edl->local_session->track_start[i] =
+ (edl->local_session->track_start[i] * zoom) / old_zoom;
edl->tracks->update_y_pixels(theme);
gui->draw_trackmovement();
-//printf("MWindow::zoom_track %d %d\n", edl->local_session->zoom_y, edl->local_session->zoom_track);
}
void MWindow::trackmovement(int offset, int pane_number)
void MWindow::move_up(int64_t distance)
{
TimelinePane *pane = gui->get_focused_pane();
- if(distance == 0) distance = edl->local_session->zoom_track;
-
+ if(distance == 0) distance = pane->canvas->get_h() / 10;
trackmovement(-distance, pane->number);
}
void MWindow::move_down(int64_t distance)
{
TimelinePane *pane = gui->get_focused_pane();
- if(distance == 0) distance = edl->local_session->zoom_track;
-
+ if(distance == 0) distance = pane->canvas->get_h() / 10;
trackmovement(distance, pane->number);
}
TimelinePane *pane = gui->get_focused_pane();
int64_t old_view_start = edl->local_session->view_start[pane->number];
- if(edl->tracks->total_length() > (double)pane->canvas->get_w() *
- edl->local_session->zoom_sample /
- edl->session->sample_rate)
- {
+ if( edl->tracks->total_length() > (double)pane->canvas->get_w() *
+ edl->local_session->zoom_sample / edl->session->sample_rate ) {
edl->local_session->view_start[pane->number] =
Units::round(edl->tracks->total_length() *
edl->session->sample_rate /
int MWindow::expand_t()
{
- int result = edl->local_session->zoom_track * 2;
- result = MIN(result, MAX_TRACK_ZOOM);
- zoom_track(result);
+ int zoom = edl->local_session->zoom_atrack * 2;
+ zoom = MIN(zoom, MAX_TRACK_ZOOM);
+ zoom_atrack(zoom);
+ zoom = edl->local_session->zoom_vtrack * 2;
+ zoom = MIN(zoom, MAX_TRACK_ZOOM);
+ zoom_vtrack(zoom);
gui->zoombar->update();
return 0;
}
int MWindow::zoom_in_t()
{
- int result = edl->local_session->zoom_track / 2;
- result = MAX(result, MIN_TRACK_ZOOM);
- zoom_track(result);
+ int zoom = edl->local_session->zoom_atrack / 2;
+ zoom = MAX(zoom, MIN_TRACK_ZOOM);
+ zoom_atrack(zoom);
+ zoom = edl->local_session->zoom_vtrack / 2;
+ zoom = MAX(zoom, MIN_TRACK_ZOOM);
+ zoom_vtrack(zoom);
gui->zoombar->update();
return 0;
}
gang = 0;
draw = 0;
mute = 0;
+ zoom = 0;
expand = 0;
nudge = 0;
mix = 0;
delete gang;
delete draw;
delete mute;
+ delete zoom;
delete expand;
delete nudge;
delete mix;
x1 += draw->get_w();
mute->reposition_window(mute->get_x(), y1 + y);
x1 += mute->get_w();
+ zoom->reposition_window(zoom->get_x(), y1 + y);
}
y1 += mwindow->theme->play_h;
}
delete gang; gang = 0;
delete draw; draw = 0;
delete mute; mute = 0;
+ delete zoom; zoom = 0;
}
else {
play->update(track->play);
x1 += draw->get_w();
patchbay->add_subwindow(mute = new MutePatch(mwindow, this, x1 + x, y1 + y));
x1 += mute->get_w();
+ patchbay->add_subwindow(zoom = new ZoomPatch(mwindow, this, x1 + x, y1 + y));
}
if( play )
y1 = y2;
}
+ZoomPatch::ZoomPatch(MWindow *mwindow, PatchGUI *patch, int x, int y)
+ : BC_Tumbler(x, y)
+{
+ this->mwindow = mwindow;
+ this->patch = patch;
+ set_tooltip(_("Track Data Height"));
+}
+
+int ZoomPatch::handle_up_event()
+{
+ patch->track->data_h *= 2;
+ bclamp(patch->track->data_h, MIN_TRACK_ZOOM, MAX_TRACK_ZOOM);
+ mwindow->edl->tracks->update_y_pixels(mwindow->theme);
+ mwindow->gui->draw_trackmovement();
+ return 1;
+}
+int ZoomPatch::handle_down_event()
+{
+ patch->track->data_h /= 2;
+ bclamp(patch->track->data_h, MIN_TRACK_ZOOM, MAX_TRACK_ZOOM);
+ mwindow->edl->tracks->update_y_pixels(mwindow->theme);
+ mwindow->gui->draw_trackmovement();
+ return 1;
+}
+
ExpandPatch::ExpandPatch(MWindow *mwindow, PatchGUI *patch, int x, int y)
: BC_Toggle(x,
class GangPatch;
class DrawPatch;
class MutePatch;
+class ZoomPatch;
class ExpandPatch;
class NudgePatch;
class MixPatch;
GangPatch *gang;
DrawPatch *draw;
MutePatch *mute;
+ ZoomPatch *zoom;
ExpandPatch *expand;
NudgePatch *nudge;
MixPatch *mix;
PatchGUI *patch;
};
+class ZoomPatch : public BC_Tumbler
+{
+public:
+ ZoomPatch(MWindow *mwindow, PatchGUI *patch, int x, int y);
+ int handle_up_event();
+ int handle_down_event();
+ MWindow *mwindow;
+ PatchGUI *patch;
+};
+
class ExpandPatch : public BC_Toggle
{
public:
source_framerate = edit->nested_edl->session->frame_rate;
source_samplerate = edit->nested_edl->session->sample_rate;
}
-
+ data_h = edit->track->data_h;
project_framerate = edit->edl->session->frame_rate;
project_samplerate = edit->edl->session->sample_rate;
edit_id = edit->id; pixmap_w = w; pixmap_h = h;
pixmap_w = 0;
pixmap_h = 0;
zoom_sample = 0;
- zoom_track = 0;
- zoom_y = 0;
visible = 1;
}
project_framerate = edit->edl->session->frame_rate;
project_samplerate = edit->edl->session->sample_rate;
zoom_sample = mwindow->edl->local_session->zoom_sample;
- zoom_track = mwindow->edl->local_session->zoom_track;
- zoom_y = mwindow->edl->local_session->zoom_y;
}
void ResourcePixmap::draw_data(TrackCanvas *canvas,
// Redraw everything
refresh_x = 0;
refresh_w = pixmap_w;
+ Track *track = edit->track;
// Draw background image
if( refresh_w > 0 ) {
int x1 = refresh_x, x2 = x1 + refresh_w;
- int y1 = y, y2 = y1 + mwindow->edl->local_session->zoom_track;
+ int y1 = y, y2 = y1 + track->data_h;
int color = mwindow->get_title_color(edit);
mwindow->theme->draw_resource_bg(canvas, this, color,
- edit_x, edit_w, pixmap_x, x1,y1, x2,y2);
+ edit, edit_x, edit_w, pixmap_x, x1,y1, x2,y2);
}
//printf("ResourcePixmap::draw_data 70\n");
// Draw media which already exists
- Track *track = edit->track;
if( track->draw ) {
switch( track->data_type )
{
int ResourcePixmap::calculate_center_pixel(Track *track)
{
+ int data_h = track->data_h;
int rect_audio = mwindow->preferences->rectify_audio;
- int center_pixel = !rect_audio ?
- mwindow->edl->local_session->zoom_track / 2 :
- mwindow->edl->local_session->zoom_track ;
+ int center_pixel = !rect_audio ? data_h/2 : data_h;
if( track->show_titles() )
center_pixel += mwindow->theme->get_image("title_bg_data")->get_h();
return center_pixel;
Indexable *indexable = edit->get_source();
int center_pixel = calculate_center_pixel(edit->track);
int rect_audio = mwindow->preferences->rectify_audio;
- int64_t scale_y = !rect_audio ?
- mwindow->edl->local_session->zoom_y :
- mwindow->edl->local_session->zoom_y * 2;
+ int data_h = edit->track->data_h;
+ int zoom_y = mwindow->edl->local_session->zoom_y * data_h /
+ mwindow->edl->local_session->zoom_atrack;
+ int64_t scale_y = !rect_audio ? zoom_y : zoom_y*2;
int y_max = center_pixel + scale_y / 2 - 1;
double project_zoom = mwindow->edl->local_session->zoom_sample;
}
void ResourcePixmap::draw_wave(TrackCanvas *canvas,
- int x, double high, double low)
+ int x, double high, double low)
{
int rect_audio = mwindow->preferences->rectify_audio;
if( rect_audio ) { low = fabs(low); high = fabs(high); }
int top_pixel = !mwindow->edl->session->show_titles ? 0 :
mwindow->theme->get_image("title_bg_data")->get_h();
- int center_pixel = !rect_audio ?
- mwindow->edl->local_session->zoom_track / 2 + top_pixel :
- mwindow->edl->local_session->zoom_track + top_pixel ;
- int scale_y = !rect_audio ?
- mwindow->edl->local_session->zoom_y / 2 :
- mwindow->edl->local_session->zoom_y ;
- int bottom_pixel = top_pixel + mwindow->edl->local_session->zoom_track;
+ int center_pixel = !rect_audio ? data_h/2 + top_pixel : data_h + top_pixel;
+ int zoom_y = mwindow->edl->local_session->zoom_y * (int64_t)data_h /
+ mwindow->edl->local_session->zoom_atrack;
+ int scale_y = !rect_audio ? zoom_y/2 : zoom_y;
+ int bottom_pixel = top_pixel + data_h;
int y1 = (int)(center_pixel - low * scale_y);
int y2 = (int)(center_pixel - high * scale_y);
CLAMP(y1, top_pixel, bottom_pixel);
SEdit *sedit = (SEdit *)edit;
char *text = sedit->get_text();
if( !*text || w < xS(10) ) return;
- int center_pixel = canvas->resource_h() / 2;
+ int data_h = edit->track->data_h, center_pixel = data_h/2;
if( edit->track->show_titles() )
center_pixel += mwindow->theme->get_image("title_bg_data")->get_h();
- int64_t scale_y = mwindow->edl->local_session->zoom_y;
int x0 = edit_x;
if( x0 < 0 ) x0 = -x0;
int x1 = (int)(pixmap_x - x0 + x);
- int y_max = center_pixel + scale_y / 2 - 1;
- int font = MEDIUMFONT, color = WHITE;
+ int font = data_h >= yS(24) ? MEDIUMFONT : SMALLFONT, color = WHITE;
+ int ascent = canvas->get_text_ascent(font);
+ int y1 = center_pixel + ascent/2;
+ if( y1 < 0 ) y1 = 0;
canvas->set_font(font);
canvas->set_color(color);
- int ch = canvas->get_text_height(font);
- int hh = canvas->get_text_height(font,text) + ch/2;
- int y1 = y_max - hh - yS(10);
- if( y1 < 0 ) y1 = 0;
canvas->draw_text(x1, y1, text, -1, this);
}
MWindowGUI *gui;
// Visible in entire track canvas
int visible;
+ int data_h;
// Section drawn
int64_t edit_id;
int pane_number;
int64_t edit_x, pixmap_x, pixmap_w, pixmap_h;
- int64_t zoom_sample, zoom_track, zoom_y;
+ int64_t zoom_sample;
int64_t startsource;
double source_framerate, project_framerate;
int64_t source_samplerate, project_samplerate;
: Track(edl, tracks)
{
data_type = TRACK_SUBTITLE;
+ data_h = edl->local_session->zoom_atrack;
}
STrack::~STrack()
int STrack::vertical_span(Theme *theme)
{
int track_h = Track::vertical_span(theme);
- int patch_h = 0;
- return track_h + patch_h;
+ int patch_h = theme->title_h;
+ if( expand_view )
+ patch_h += theme->play_h;
+ return MAX(track_h, patch_h);
}
{
public:
STrack(EDL *edl, Tracks *tracks);
- STrack() {};
~STrack();
int load_defaults(BC_Hash *defaults);
#include "clip.h"
#include "bccolors.h"
#include "cwindowgui.h"
+#include "edit.h"
#include "edl.h"
#include "edlsession.h"
#include "keyframegui.h"
#include "resourcepixmap.h"
#include "statusbar.h"
#include "theme.h"
+#include "track.h"
#include "timebar.h"
#include "trackcanvas.h"
#include "vframe.h"
}
-void Theme::draw_resource_bg(TrackCanvas *canvas, ResourcePixmap *pixmap, int color,
- int edit_x, int edit_w, int pixmap_x, int x1, int y1, int x2, int y2)
+void Theme::draw_resource_bg(TrackCanvas *canvas, ResourcePixmap *pixmap,
+ int color, Edit *edit, int edit_x, int edit_w,
+ int pixmap_x, int x1, int y1, int x2, int y2)
{
VFrame *image = 0;
-
- switch(mwindow->edl->local_session->zoom_track) {
+ int data_h = edit->track->data_h;
+ switch( data_h ) {
case 1024: image = get_image("resource1024"); break;
case 512: image = get_image("resource512"); break;
case 256: image = get_image("resource256"); break;
#include "bctheme.h"
#include "compressortools.inc"
#include "cwindowgui.inc"
+#include "edit.inc"
#include "guicast.h"
#include "keyframegui.inc"
#include "levelwindowgui.inc"
virtual void draw_lwindow_bg(LevelWindowGUI *gui);
virtual void draw_mwindow_bg(MWindowGUI *gui);
virtual void draw_vwindow_bg(VWindowGUI *gui);
- virtual void draw_resource_bg(TrackCanvas *canvas, ResourcePixmap *pixmap, int color,
- int edit_x, int edit_w, int pixmap_x, int x1, int y1, int x2, int y2);
+ virtual void draw_resource_bg(TrackCanvas *canvas, ResourcePixmap *pixmap,
+ int color, Edit *edit, int edit_x, int edit_w,
+ int pixmap_x, int x1, int y1, int x2, int y2);
virtual void get_preferences_sizes();
virtual void draw_preferences_bg(PreferencesWindow *gui);
this->edl = edl;
this->tracks = tracks;
y_pixel = 0;
+ data_h = 64;
expand_view = 0;
draw = 1;
gang = 1;
this->nudge = track->nudge;
this->mixer_id = track->mixer_id;
this->play = track->play;
+ this->data_h = track->data_h;
this->track_w = track->track_w;
this->track_h = track->track_h;
this->masks = track->masks;
if( show_titles() )
result += theme->get_image("title_bg_data")->get_h();
if( show_assets() )
- result += edl->local_session->zoom_track;
+ result += data_h;
if( expand_view )
result += plugin_set.total * theme->get_image("plugin_bg_data")->get_h();
result = MAX(result, theme->title_h);
nudge = file->tag.get_property("NUDGE", nudge);
mixer_id = file->tag.get_property("MIXER_ID", mixer_id);
expand_view = file->tag.get_property("EXPAND", expand_view);
+ data_h = file->tag.get_property("DATA_H", data_h);
track_w = file->tag.get_property("TRACK_W", track_w);
track_h = file->tag.get_property("TRACK_H", track_h);
masks = file->tag.get_property("MASKS", masks);
return 0;
}
-
-Track::Track() : ListItem<Track>()
-{
- y_pixel = 0;
-}
-
// ======================================== accounting
int Track::number_of()
-
-
-
-
-
-
-
-
-
-
// ================================================= editing
int Track::select_auto(AutoConf *auto_conf, int cursor_x, int cursor_y)
file->tag.set_property("GANG", gang);
file->tag.set_property("DRAW", draw);
file->tag.set_property("EXPAND", expand_view);
+ file->tag.set_property("DATA_H", data_h);
file->tag.set_property("TRACK_W", track_w);
file->tag.set_property("TRACK_H", track_h);
file->tag.set_property("MASKS", masks);
{
public:
Track(EDL *edl, Tracks *tracks);
- Track();
virtual ~Track();
void create_objects();
// Vertical offset from top of timeline
int y_pixel;
+// Vertical height of the track asset
+ int data_h;
int expand_view;
int draw;
// There is some debate on whether to expand gang from faders to
// }
// }
- pixmap_h = mwindow->edl->local_session->zoom_track;
Track *track = edit->edits->track;
+ pixmap_h = track->data_h;
if( track->show_titles() )
pixmap_h += mwindow->theme->get_image("title_bg_data")->get_h();
//printf("get_pixmap_size %d %d %d %d\n", edit_x, edit_w, pixmap_x, pixmap_w);
if( edit->track->show_titles() )
edit_h += mwindow->theme->get_image("title_bg_data")->get_h();
if( edit->track->show_assets() )
- edit_h += resource_h();
+ edit_h += edit->track->data_h;
h = edit_h;
}
if( plugin->track->show_titles() )
y += mwindow->theme->get_image("title_bg_data")->get_h();
if( plugin->track->show_assets() )
- y += resource_h();
+ y += plugin->track->data_h;
y += plugin->plugin_set->get_number() *
mwindow->theme->get_image("plugin_bg_data")->get_h();
h = mwindow->theme->get_image("plugin_bg_data")->get_h();
}
-int TrackCanvas::resource_h()
-{
- return mwindow->edl->local_session->zoom_track;
-}
void TrackCanvas::draw_highlight_rectangle(int x, int y, int w, int h)
{
int has_titles = edit->track->show_titles();
int has_assets = edit->track->show_assets();
double title_bg_h = mwindow->theme->get_image("title_bg_data")->get_h();
- double asset_h = resource_h();
- double ys = has_assets ? asset_h : has_titles ? title_bg_h : 0;
+ int data_h = edit->track->data_h;
+ double ys = has_assets ? data_h : has_titles ? title_bg_h : 0;
double dy = has_titles ?
- ( has_assets ? title_bg_h + asset_h/2 : title_bg_h/2 ) :
- ( has_assets ? asset_h/2 : 0) ;
+ ( has_assets ? title_bg_h + data_h/2 : title_bg_h/2 ) :
+ ( has_assets ? data_h/2 : 0) ;
double title_h = mwindow->theme->title_h;
if( dy < title_h / 2 ) { ys = title_h; dy = ys / 2; }
y += dy;
if( track->show_titles() )
y1 += mwindow->theme->get_image("title_bg_data")->get_h();
if( track->show_assets() )
- y1 += resource_h();
+ y1 += track->data_h;
if( y1 == y )
y1 += mwindow->theme->title_h;
if( edit->hard_left ) {
}
}
-void TrackCanvas::draw_auto(Auto *current,
- int x,
- int y,
- int center_pixel,
- int zoom_track)
+void TrackCanvas::draw_auto(Auto *current, int x, int y,
+ int center_pixel, int data_h)
{
int x1, y1, x2, y2;
y1 = center_pixel + y - HANDLE_W / 2;
y2 = center_pixel + y + HANDLE_W / 2;
- if(y1 < center_pixel + -zoom_track / 2) y1 = center_pixel + -zoom_track / 2;
- if(y2 > center_pixel + zoom_track / 2) y2 = center_pixel + zoom_track / 2;
+ if( y1 < center_pixel - data_h/2 ) y1 = center_pixel - data_h/2;
+ if( y2 > center_pixel + data_h/2 ) y2 = center_pixel + data_h/2;
draw_box(x1, y1, x2 - x1, y2 - y1);
}
}
-void TrackCanvas::draw_floatauto(FloatAuto *current,
- int x,
- int y,
- int in_x,
- int in_y,
- int out_x,
- int out_y,
- int center_pixel,
- int zoom_track,
- int color)
+void TrackCanvas::draw_floatauto(FloatAuto *current, int x, int y,
+ int in_x, int in_y, int out_x, int out_y,
+ int center_pixel, int data_h, int color)
{
int x1 = x - HANDLE_W / 2; // Center
int x2 = x + HANDLE_W / 2;
int y1 = center_pixel + y - HANDLE_H / 2;
int y2 = center_pixel + y + HANDLE_H / 2;
- int ymin = center_pixel - zoom_track / 2;
- int ymax = center_pixel + zoom_track / 2;
+ int ymin = center_pixel - data_h / 2;
+ int ymax = center_pixel + data_h / 2;
CLAMP(y1, ymin, ymax);
CLAMP(y2, ymin, ymax);
return;
if(in_x != x)
- draw_floatauto_ctrlpoint(x, y, in_x, in_y, center_pixel, zoom_track, color);
+ draw_floatauto_ctrlpoint(x, y, in_x, in_y, center_pixel, data_h, color);
if(out_x != x)
- draw_floatauto_ctrlpoint(x, y, out_x, out_y, center_pixel, zoom_track, color);
+ draw_floatauto_ctrlpoint(x, y, out_x, out_y, center_pixel, data_h, color);
}
inline int quantize(float f) { return (int)floor(f + 0.5); }
inline void TrackCanvas::draw_floatauto_ctrlpoint(
- int x, int y, int cp_x, int cp_y, int center_pixel,
- int zoom_track, int color)
+ int x, int y, int cp_x, int cp_y, int center_pixel,
+ int data_h, int color)
// draw the tangent and a handle for given bézier ctrl point
{
- bool handle_visible = (abs(cp_y) <= zoom_track / 2);
+ bool handle_visible = (abs(cp_y) <= data_h/2);
float slope = (float)(cp_y - y)/(cp_x - x);
- CLAMP(cp_y, -zoom_track / 2, zoom_track / 2);
+ CLAMP(cp_y, -data_h/2, data_h/2);
if(slope != 0)
cp_x = x + quantize((cp_y - y) / slope);
int TrackCanvas::test_auto(Auto *current,
- int x, int y, int center_pixel, int zoom_track,
+ int x, int y, int center_pixel, int data_h,
int cursor_x, int cursor_y, int buttonpress)
{
int x1, y1, x2, y2;
x2 = x + HANDLE_W / 2;
y1 = center_pixel + y - HANDLE_H / 2;
y2 = center_pixel + y + HANDLE_H / 2;
- int ymin = center_pixel - zoom_track / 2;
- int ymax = center_pixel + zoom_track / 2;
+ int ymin = center_pixel - data_h/2;
+ int ymax = center_pixel + data_h/2;
CLAMP(y1, ymin, ymax);
CLAMP(y2, ymin, ymax);
int TrackCanvas::test_floatauto(FloatAuto *current, int x, int y, int in_x,
- int in_y, int out_x, int out_y, int center_pixel, int zoom_track,
+ int in_y, int out_x, int out_y, int center_pixel, int data_h,
int cursor_x, int cursor_y, int buttonpress, int autogrouptype)
{
int result = 0;
int x2 = x + HANDLE_W / 2;
int y1 = center_pixel + y - HANDLE_W / 2;
int y2 = center_pixel + y + HANDLE_W / 2;
- int ymin = center_pixel - zoom_track / 2;
- int ymax = center_pixel + zoom_track / 2;
+ int ymin = center_pixel - data_h/2;
+ int ymax = center_pixel + data_h/2;
CLAMP(y1, ymin, ymax);
CLAMP(y2, ymin, ymax);
int has_titles = track->show_titles();
int has_assets = track->show_assets();
double title_bg_h = mwindow->theme->get_image("title_bg_data")->get_h();
- double asset_h = resource_h();
double title_h = mwindow->theme->title_h;
- double ys = has_assets ? asset_h : has_titles ? title_bg_h : 0;
+ double data_h = track->data_h;
+ double ys = has_assets ? data_h : has_titles ? title_bg_h : 0;
double dy = has_titles ?
- ( has_assets ? title_bg_h + asset_h/2 : title_bg_h/2) :
- ( has_assets ? asset_h/2 : 0) ;
+ ( has_assets ? title_bg_h + data_h/2 : title_bg_h/2) :
+ ( has_assets ? data_h/2 : 0) ;
if( dy < title_h/2 ) { ys = title_h; dy = ys / 2; }
yscale = ys;
center_pixel = y + dy;
if( track->show_titles() )
center_pixel += mwindow->theme->get_image("title_bg_data")->get_h();
if( track->show_assets() )
- center_pixel += resource_h();
+ center_pixel += track->data_h;
center_pixel += (i + 0.5) * mwindow->theme->get_image("plugin_bg_data")->get_h();
for(Plugin *plugin = (Plugin*)plugin_set->first;
void draw_automation();
void draw_hard_edges();
void draw_inout_points();
- void draw_auto(Auto *current,
- int x,
- int y,
- int center_pixel,
- int zoom_track);
- void draw_floatauto(FloatAuto *current,
- int x,
- int y,
- int in_x,
- int in_y,
- int out_x,
- int out_y,
- int center_pixel,
- int zoom_track,
- int color);
- int test_auto(Auto *current,
- int x,
- int y,
- int center_pixel,
- int zoom_track,
- int cursor_x,
- int cursor_y,
- int buttonpress);
- int test_floatauto(FloatAuto *current,
- int x,
- int y,
- int in_x,
- int in_y,
- int out_x,
- int out_y,
- int center_pixel,
- int zoom_track,
- int cursor_x,
- int cursor_y,
- int buttonpress,
+ void draw_auto(Auto *current, int x, int y,
+ int center_pixel, int data_h);
+ void draw_floatauto(FloatAuto *current, int x, int y,
+ int in_x, int in_y, int out_x, int out_y,
+ int center_pixel, int data_h, int color);
+ int test_auto(Auto *current, int x, int y,
+ int center_pixel, int data_h,
+ int cursor_x, int cursor_y, int buttonpress);
+ int test_floatauto(FloatAuto *current, int x, int y,
+ int in_x, int in_y, int out_x, int out_y,
+ int center_pixel, int data_h,
+ int cursor_x, int cursor_y, int buttonpress,
int autogrouptype);
void draw_floatline(int center_pixel,
FloatAuto *previous,
void update_drag_caption();
int get_title_h();
- int resource_h();
// Display hourglass if timer expired
void test_timer();
int result = 0;
for(Track* current = first; current; current = NEXT)
{
- result += edl->local_session->zoom_track;
+ result += current->data_h;
}
return result;
}
: Track(edl, tracks)
{
data_type = TRACK_VIDEO;
+ data_h = edl->local_session->zoom_vtrack;
draw = 1;
}
double to_doubleunits(double position);
double from_units(int64_t position);
- void calculate_input_transfer(int asset_w,
- int asset_h,
- int64_t position,
- int direction,
- float &in_x,
- float &in_y,
- float &in_w,
- float &in_h,
- float &out_x,
- float &out_y,
- float &out_w,
- float &out_h);
+ void calculate_input_transfer(int asset_w, int asset_h,
+ int64_t position, int direction,
+ float &in_x, float &in_y, float &in_w, float &in_h,
+ float &out_x, float &out_y, float &out_w, float &out_h);
void calculate_output_transfer(int64_t position, int direction,
float &in_x, float &in_y, float &in_w, float &in_h,
// ====================================== initialization
- VTrack() {};
int create_derived_objs(int flash);
{
int i;
edits = new VEdits(mwindow, this);
- camera_autos = new BezierAutos(this,
- WHITE,
- 0,
- 0,
- 1,
- mwindow->track_w,
- mwindow->track_h);
-
- projector_autos = new BezierAutos(this,
- WHITE,
- 0,
- 0,
- 1,
- mwindow->output_w,
- mwindow->output_h);
+ camera_autos = new BezierAutos(this, WHITE,
+ 0, 0, 1, mwindow->track_w, mwindow->track_h);
+
+ projector_autos = new BezierAutos(this, WHITE,
+ 0, 0, 1, mwindow->output_w, mwindow->output_h);
fade_autos = new FloatAutos(this, LTGREY, -100, 100);
fade_autos->create_objects();
if(mwindow->gui)
{
if(mwindow->session->tracks_vertical)
- draw(pixel, mwindow->zoom_track, 0, tracks->canvas->h, flash);
+ draw(pixel, data_h, 0, tracks->canvas->h, flash);
else
- draw(0, tracks->canvas->w, pixel, mwindow->zoom_track, flash);
+ draw(0, tracks->canvas->w, pixel, data_h, flash);
}
}
int VTrack::draw_autos_derived(float view_start, float zoom_units, AutoConf *auto_conf)
{
if(auto_conf->camera)
- camera_autos->draw(tracks->canvas,
- pixel,
- mwindow->zoom_track,
- zoom_units,
- view_start,
- mwindow->session->tracks_vertical);
+ camera_autos->draw(tracks->canvas, pixel, data_h,
+ zoom_units, view_start, mwindow->session->tracks_vertical);
if(auto_conf->projector)
- projector_autos->draw(tracks->canvas,
- pixel,
- mwindow->zoom_track,
- zoom_units,
- view_start,
- mwindow->session->tracks_vertical);
+ projector_autos->draw(tracks->canvas, pixel, data_h,
+ zoom_units, view_start, mwindow->session->tracks_vertical);
}
int VTrack::select_translation(int cursor_x, int cursor_y)
float view_start, view_units, zoom_units;
get_dimensions(view_start, view_units, zoom_units);
- if(cursor_y > pixel && cursor_y < pixel + mwindow->zoom_track)
+ if(cursor_y > pixel && cursor_y < pixel + data_h)
{
for(Edit* current = edits->first; current && !result; current = NEXT)
{
int result = 0;
if(auto_conf->camera)
- result = camera_autos->select_auto(tracks->canvas,
- pixel,
- mwindow->zoom_track,
- zoom_units,
- view_start,
- cursor_x,
- cursor_y,
- tracks->canvas->shift_down(),
- tracks->canvas->ctrl_down(),
- tracks->canvas->get_buttonpress(),
- mwindow->session->tracks_vertical);
+ result = camera_autos->select_auto(tracks->canvas, pixel, data_h,
+ zoom_units, view_start, cursor_x, cursor_y,
+ tracks->canvas->shift_down(), tracks->canvas->ctrl_down(),
+ tracks->canvas->get_buttonpress(), mwindow->session->tracks_vertical);
if(auto_conf->projector && !result)
- result = projector_autos->select_auto(tracks->canvas,
- pixel,
- mwindow->zoom_track,
- zoom_units,
- view_start,
- cursor_x,
- cursor_y,
- tracks->canvas->shift_down(),
- tracks->canvas->ctrl_down(),
- tracks->canvas->get_buttonpress(),
- mwindow->session->tracks_vertical);
+ result = projector_autos->select_auto(tracks->canvas, pixel, data_h,
+ zoom_units, view_start, cursor_x, cursor_y,
+ tracks->canvas->shift_down(), tracks->canvas->ctrl_down(),
+ tracks->canvas->get_buttonpress(), mwindow->session->tracks_vertical);
return result;
}
result = 0;
if(auto_conf->camera)
- result = camera_autos->move_auto(tracks->canvas,
- pixel,
- mwindow->zoom_track,
- zoom_units,
- view_start,
- cursor_x,
- cursor_y,
- shift_down,
- mwindow->session->tracks_vertical);
+ result = camera_autos->move_auto(tracks->canvas, pixel, data_h,
+ zoom_units, view_start, cursor_x, cursor_y,
+ shift_down, mwindow->session->tracks_vertical);
if(auto_conf->projector && !result)
- result = projector_autos->move_auto(tracks->canvas,
- pixel,
- mwindow->zoom_track,
- zoom_units,
- view_start,
- cursor_x,
- cursor_y,
- shift_down,
- mwindow->session->tracks_vertical);
+ result = projector_autos->move_auto(tracks->canvas, pixel, data_h,
+ zoom_units, view_start, cursor_x, cursor_y,
+ shift_down, mwindow->session->tracks_vertical);
if(result)
{
int VTrack::draw_floating_autos_derived(float view_start, float zoom_units, AutoConf *auto_conf, int flash)
{
if(auto_conf->camera)
- camera_autos->draw_floating_autos(tracks->canvas,
- pixel,
- mwindow->zoom_track,
- zoom_units,
- view_start,
- mwindow->session->tracks_vertical, flash);
+ camera_autos->draw_floating_autos(tracks->canvas, pixel, data_h,
+ zoom_units, view_start, mwindow->session->tracks_vertical, flash);
if(auto_conf->projector)
- projector_autos->draw_floating_autos(tracks->canvas,
- pixel,
- mwindow->zoom_track,
- zoom_units,
- view_start,
- mwindow->session->tracks_vertical, flash);
+ projector_autos->draw_floating_autos(tracks->canvas, pixel, data_h,
+ zoom_units, view_start, mwindow->session->tracks_vertical, flash);
}
int VTrack::release_auto_derived()
{
delete sample_zoom;
delete amp_zoom;
- delete track_zoom;
+ delete atrack_zoom;
+ delete vtrack_zoom;
}
void ZoomBar::create_objects()
amp_zoom->create_objects();
amp_zoom->set_tooltip(_("Audio waveform scale"));
x += amp_zoom->get_w();
- track_zoom = new TrackZoomPanel(mwindow, this, x, y);
- track_zoom->create_objects();
- track_zoom->set_tooltip(_("Height of tracks in the timeline"));
- x += track_zoom->get_w() + xs10;
+ atrack_zoom = new ATrackZoomPanel(mwindow, this, x, y);
+ atrack_zoom->create_objects();
+ atrack_zoom->set_tooltip(_("Height of audio tracks in the timeline"));
+ x += atrack_zoom->get_w() + xs10;
+ vtrack_zoom = new VTrackZoomPanel(mwindow, this, x, y);
+ vtrack_zoom->create_objects();
+ vtrack_zoom->set_tooltip(_("Height of video tracks in the timeline"));
+ x += vtrack_zoom->get_w() + xs10;
int wid = xS(120);
for( int i=AUTOGROUPTYPE_AUDIO_FADE; i<=AUTOGROUPTYPE_Y; ++i ) {
#define DEFAULT_TEXT "000.00 to 000.00"
add_subwindow(auto_zoom = new AutoZoom(mwindow, this, x, y, 0));
x += auto_zoom->get_w();
- add_subwindow(auto_zoom_text = new ZoomTextBox(
- mwindow,
- this,
- x,
- y,
- DEFAULT_TEXT));
+ add_subwindow(auto_zoom_text = new ZoomTextBox(mwindow, this, x, y, DEFAULT_TEXT));
x += auto_zoom_text->get_w() + xs5;
add_subwindow(auto_zoom = new AutoZoom(mwindow, this, x, y, 1));
update_autozoom();
{
sample_zoom->update(mwindow->edl->local_session->zoom_sample);
amp_zoom->update(mwindow->edl->local_session->zoom_y);
- track_zoom->update(mwindow->edl->local_session->zoom_track);
+ atrack_zoom->update(mwindow->edl->local_session->zoom_atrack);
+ vtrack_zoom->update(mwindow->edl->local_session->zoom_vtrack);
update_autozoom();
update_clocks();
return 0;
AmpZoomPanel::AmpZoomPanel(MWindow *mwindow, ZoomBar *zoombar, int x, int y)
: ZoomPanel(mwindow, zoombar, mwindow->edl->local_session->zoom_y,
- x, y, xS(100), MIN_AMP_ZOOM, MAX_AMP_ZOOM, ZOOM_LONG)
+ x, y, xS(80), MIN_AMP_ZOOM, MAX_AMP_ZOOM, ZOOM_LONG)
{
this->mwindow = mwindow;
this->zoombar = zoombar;
return 1;
}
-TrackZoomPanel::TrackZoomPanel(MWindow *mwindow, ZoomBar *zoombar, int x, int y)
- : ZoomPanel(mwindow, zoombar, mwindow->edl->local_session->zoom_track,
- x, y, xS(90), MIN_TRACK_ZOOM, MAX_TRACK_ZOOM, ZOOM_LONG)
+ATrackZoomPanel::ATrackZoomPanel(MWindow *mwindow, ZoomBar *zoombar, int x, int y)
+ : ZoomPanel(mwindow, zoombar, mwindow->edl->local_session->zoom_atrack,
+ x, y, xS(64), MIN_TRACK_ZOOM, MAX_TRACK_ZOOM, ZOOM_LONG)
{
this->mwindow = mwindow;
this->zoombar = zoombar;
}
-int TrackZoomPanel::handle_event()
+int ATrackZoomPanel::handle_event()
{
- mwindow->zoom_track((int64_t)get_value());
+ mwindow->zoom_atrack((int64_t)get_value());
zoombar->amp_zoom->update(mwindow->edl->local_session->zoom_y);
return 1;
}
-
+VTrackZoomPanel::VTrackZoomPanel(MWindow *mwindow, ZoomBar *zoombar, int x, int y)
+ : ZoomPanel(mwindow, zoombar, mwindow->edl->local_session->zoom_vtrack,
+ x, y, xS(64), MIN_TRACK_ZOOM, MAX_TRACK_ZOOM, ZOOM_LONG)
+{
+ this->mwindow = mwindow;
+ this->zoombar = zoombar;
+}
+int VTrackZoomPanel::handle_event()
+{
+ mwindow->zoom_vtrack((int64_t)get_value());
+ return 1;
+}
AutoZoom::AutoZoom(MWindow *mwindow, ZoomBar *zoombar, int x, int y, int changemax)
MWindowGUI *gui;
SampleZoomPanel *sample_zoom;
AmpZoomPanel *amp_zoom;
- TrackZoomPanel *track_zoom;
+ ATrackZoomPanel *atrack_zoom;
+ VTrackZoomPanel *vtrack_zoom;
AutoZoom *auto_zoom;
AutoTypeMenu *auto_type;
ZoomTextBox *auto_zoom_text;
ZoomBar *zoombar;
};
-class TrackZoomPanel : public ZoomPanel
+class ATrackZoomPanel : public ZoomPanel
{
public:
- TrackZoomPanel(MWindow *mwindow, ZoomBar *zoombar, int x, int y);
+ ATrackZoomPanel(MWindow *mwindow, ZoomBar *zoombar, int x, int y);
+ int handle_event();
+ MWindow *mwindow;
+ ZoomBar *zoombar;
+};
+
+class VTrackZoomPanel : public ZoomPanel
+{
+public:
+ VTrackZoomPanel(MWindow *mwindow, ZoomBar *zoombar, int x, int y);
int handle_event();
MWindow *mwindow;
ZoomBar *zoombar;
class ZoomBar;
class SampleZoomPanel;
class AmpZoomPanel;
-class TrackZoomPanel;
+class ATrackZoomPanel;
+class VTrackZoomPanel;
class AutoZoom;
class AutoTypeMenu;
class ZoomTextBox;
void ZoomPanel::create_objects()
{
subwindow->add_subwindow(zoom_text = new ZoomPopup(mwindow, this, x, y));
- x += zoom_text->get_w();
+ x += zoom_text->get_w() - xS(3);
subwindow->add_subwindow(zoom_tumbler = new ZoomTumbler(mwindow, this, x, y));
calculate_menu();
}
ZoomPopup::ZoomPopup(MWindow *mwindow, ZoomPanel *panel, int x, int y)
: BC_PopupMenu(x, y, panel->w, panel->value_to_text(panel->value, 0),
- 1, mwindow->theme->get_image_set("zoombar_menu", 0))
+ 1, mwindow->theme->get_image_set("zoombar_menu", 0), 0)
{
this->mwindow = mwindow;
this->panel = panel;
--- /dev/null
+Video Effects
+ - Correction de couleurs
+ Blue Banana
+ Brightness/Contrast
+ C41
+ Color 3 Way
+ Color Balance
+ ColorSpace
+ Gamma
+ Gradient
+ HistEq
+ Histogram
+ Histogram Bezier
+ Hue saturation
+ Interpolate Bayer
+ Invert Video
+ RGBShift
+ RGB - 601
+ Reroute
+ Sketcher
+ Swap channels
+ Threshold
+ VideoScope
+ YUV
+ YUV411
+ YUVShift
+ - FF Correction de couleurs
+ F_chromahold
+ F_colorbalance
+ F_colorchannelmixer
+ F_colorkey
+ F_colorlevels
+ F_colormatrix
+ F_colorspace
+ F_curves
+ F_elbg
+ F_eq
+ F_fftfilt
+ F_floodfill
+ F_greyedge
+ F_haldclutsrc
+ F_histeq
+ F_histogram
+ F_limiter
+ F_lut
+ F_lut1d
+ F_lut3d
+ F_lutrgb
+ F_lutyuv
+ F_negate
+ F_normalize
+ F_pseudocolor
+ F_separatefields
+ F_setparams
+ F_setrange
+ F_shuffleplanes
+ F_swapuv
+ F_tlut2
+ F_vignette
+ F_vibrance
+ - Motion
+ Motion
+ Motion 2 Point
+ Motion51
+ MotionCV
+ MotionHV
+ F_dejudder
+ F_deshake
+ - Flou
+ Blur
+ BoxBlur
+ Edge
+ Linear Blur
+ Motion Blur
+ Radial Blur
+ Sharpen
+ Unsharp
+ Zoom Blur
+ F_avgblur
+ F_boxblur
+ F_deband
+ F_deblock
+ F_edgedetect
+ F_gblur
+ F_sab
+ F_smartblur
+ F_unsharp
+ - Débruitage
+ DeScratch
+ Denoise video
+ DotTV
+ Selective Temporal Averaging
+ Time Average
+ F_atadenoise
+ F_bitplanenoise
+ F_dctdnoiz
+ F_fftdnoiz
+ F_hqdn3d
+ F_nlmeans
+ F_noise
+ F_owdenoise
+ F_removegrain
+ F_vaguedenoiser
+ - Extract Keys
+ Blue Banana
+ Chroma key
+ Chroma key (HSV)
+ CriKey
+ Difference key
+ F_chromakey
+ F_despill
+ F_lumakey
+ - Géométrie
+ Auto Scale
+ Crop & Position
+ Flip
+ Lens
+ Perspective
+ Polar
+ Rotate
+ Rumbler
+ Scale
+ Scale Ratio
+ Sketcher
+ Sphere Cam
+ Translate
+ Whirl
+ Wave
+ F_cropdetect
+ F_crop
+ F_cover_rect
+ F_drawbox
+ F_drawgraph
+ F_drawgrid
+ F_fillborders
+ F_hflip
+ F_lenscorrection
+ F_pad
+ F_perspective
+ F_rotate
+ F_scale
+ F_super2xsai
+ F_swaprect
+ F_tile
+ F_vflip
+ - Échelle
+ Auto Scale
+ Downsample
+ F_hqx
+ F_scale
+ F_super2xsai
+ F_xbr
+ Scale
+ Scale Ratio
+ - Gestion Temporelle
+ Decimate
+ Delay Video
+ Freeze Frame
+ Loop video
+ Interpolate Video
+ ReframeRT
+ Reverse video
+ Time Average
+ TimeFront
+ F_amplify
+ F_deflicker
+ F_framerate
+ F_framestep
+ F_loop
+ F_mpdecimate
+ F_realtime
+ F_tblend
+ F_tinterlace
+ F_tmix
+ F_vfrdet
+ - Test
+ F_bench
+ F_bbox
+ F_ciescope
+ F_color
+ F_datascope
+ F_entropy
+ F_graphmonitor
+ F_mptestsrc
+ F_oscilloscope
+ F_pal100bars
+ F_pal75bars
+ F_pixscope
+ F_rgbtestsrc
+ F_showpalette
+ F_signalstats
+ F_smptebars
+ F_smptehdbars
+ F_testsrc
+ F_testsrc2
+ F_vectorscope
+ F_yuvtestsrc
+ F_waveform
+Audio Effects
+ - Calf
+ - Instruments / Générateurs
+ L2_Calf Organ
+ L2_Calf Monosynth
+ L2_Calf Fluidsynth
+ L2_Calf Wavetable
+ - Effets de modulation
+ L2_Calf Multi Chorus
+ L2_Calf Phaser
+ L2_Calf Flanger
+ L2_Calf Rotary Speaker
+ L2_Calf Pulsator
+ L2_Calf Ring Modulator
+ - Effets de délais
+ L2_Calf Reverb
+ L2_Calf Vintage Delay
+ L2_Calf Compensation Delay Line
+ L2_Calf Reverse Delay
+ - Processeurs dynamiques
+ L2_Calf Compressor
+ L2_Calf Sidechain Compressor
+ L2_Calf Multiband Compressor
+ L2_Calf Mono Compressor
+ L2_Calf Deeser
+ L2_Calf Gate
+ L2_Calf Sidechain Gate
+ L2_Calf Multiband Gate
+ L2_Calf Limiter
+ L2_Calf Multiband Limiter
+ L2_Calf Sidechain Limiter
+ L2_Calf Transient Designer
+ - Filtres et égalisateurs
+ L2_Calf Filter
+ L2_Calf Filterclavier
+ L2_Calf Envelope Filter
+ L2_Calf Emphasis
+ L2_Calf Vocoder
+ L2_Calf 5-Band Equalizer
+ L2_Calf 8-Band Equalizer
+ L2_Calf 12-Band Equalizer
+ L2_Calf 30-Band Equalizer
+ - Effets de distorsion
+ L2_Calf Saturator
+ L2_Calf Exciter
+ L2_Calf Bass Enhancer
+ L2_Calf Tape Simulator
+ L2_Calf Vinyl
+ L2_Calf Crusher
+ - Outils
+ L2_Calf Mono Input
+ L2_Calf Pitch Tools
+ L2_Calf Stereo Tools
+ L2_Calf Haas Stereo Enhancer
+ L2_Calf Multi Spread
+ L2_Calf Multiband Enhancer
+ L2_Calf X-Over 2 Band
+ L2_Calf X-Over 3 Band
+ L2_Calf X-Over 4 Band
+ L2_Calf Analyzer
double v = 1. - u;
this->horz_radius = u*prev.horz_radius + v*next.horz_radius;
this->vert_radius = u*prev.vert_radius + v*next.vert_radius;
- this->power = u*prev.power + v*next.power;
+ this->power = u*prev.power + v*next.power + 1e-6; // avoid truncation jitter
this->drag = prev.drag;
this->box_x = u*prev.box_x + v*next.box_x;
this->box_y = u*prev.box_y + v*next.box_y;
- this->box_w = u*prev.box_w + v*next.box_w;
- this->box_h = u*prev.box_h + v*next.box_h;
+ this->box_w = u*prev.box_w + v*next.box_w + 1e-6;
+ this->box_h = u*prev.box_h + v*next.box_h + 1e-6;
}
projects / goodguy / cinelerra.git / commitdiff