void CompressorEffect::save_data(KeyFrame *keyframe)
{
FileXML output;
output.set_shared_string(keyframe->get_data(), MESSAGESIZE);
output.tag.set_title("COMPRESSOR");
output.tag.set_property("TRIGGER", config.trigger);
output.tag.set_property("REACTION_LEN", config.reaction_len);
output.tag.set_property("DECAY_LEN", config.decay_len);
output.tag.set_property("SMOOTHING_ONLY", config.smoothing_only);
output.tag.set_property("INPUT", config.input);
output.append_tag();
output.append_newline();
for(int i = 0; i < config.levels.total; i++)
{
output.tag.set_title("LEVEL");
output.tag.set_property("X", config.levels.values[i].x);
output.tag.set_property("Y", config.levels.values[i].y);
output.append_tag();
output.append_newline();
}
output.terminate_string();
}
void SvgMain::read_data(KeyFrame *keyframe)
{
FileXML input;
input.set_shared_string(keyframe->get_data(), strlen(keyframe->get_data()));
int result = 0;
while(!result)
{
result = input.read_tag();
if(!result)
{
if(input.tag.title_is("SVG"))
{
config.in_x = input.tag.get_property("IN_X", config.in_x);
config.in_y = input.tag.get_property("IN_Y", config.in_y);
config.in_w = input.tag.get_property("IN_W", config.in_w);
config.in_h = input.tag.get_property("IN_H", config.in_h);
config.out_x = input.tag.get_property("OUT_X", config.out_x);
config.out_y = input.tag.get_property("OUT_Y", config.out_y);
config.out_w = input.tag.get_property("OUT_W", config.out_w);
config.out_h = input.tag.get_property("OUT_H", config.out_h);
input.tag.get_property("SVG_FILE", config.svg_file);
}
}
}
}
void IVTCMain::read_data(KeyFrame *keyframe)
{
FileXML input;
input.set_shared_string(keyframe->get_data(), strlen(keyframe->get_data()));
int result = 0;
float new_threshold;
while(!result)
{
result = input.read_tag();
if(!result)
{
if(input.tag.title_is("IVTC"))
{
config.frame_offset = input.tag.get_property("FRAME_OFFSET", config.frame_offset);
config.first_field = input.tag.get_property("FIRST_FIELD", config.first_field);
config.automatic = input.tag.get_property("AUTOMATIC", config.automatic);
new_threshold = input.tag.get_property("AUTO_THRESHOLD", config.auto_threshold);
config.pattern = input.tag.get_property("PATTERN", config.pattern);
}
}
}
}
void ParametricEQ::save_data(KeyFrame *keyframe)
{
FileXML output;
output.set_shared_string(keyframe->get_data(), MESSAGESIZE);
output.tag.set_title("PARAMETRICEQ");
output.tag.set_property("WETNESS", config.wetness);
output.tag.set_property("WINDOW_SIZE", config.window_size);
output.append_tag();
output.append_newline();
for(int i = 0; i < BANDS; i++)
{
output.tag.set_title("BAND");
output.tag.set_property("NUMBER", i);
output.tag.set_property("FREQ", config.band[i].freq);
output.tag.set_property("QUALITY", config.band[i].quality);
output.tag.set_property("MAGNITUDE", config.band[i].magnitude);
output.tag.set_property("MODE", config.band[i].mode);
output.append_tag();
output.append_newline();
}
output.terminate_string();
}
void CompressorEffect::read_data(KeyFrame *keyframe)
{
FileXML input;
input.set_shared_string(keyframe->get_data(), strlen(keyframe->get_data()));
int result = 0;
config.levels.remove_all();
while(!result)
{
result = input.read_tag();
if(!result)
{
if(input.tag.title_is("COMPRESSOR"))
{
config.reaction_len = input.tag.get_property("REACTION_LEN", config.reaction_len);
config.decay_len = input.tag.get_property("DECAY_LEN", config.decay_len);
config.trigger = input.tag.get_property("TRIGGER", config.trigger);
config.smoothing_only = input.tag.get_property("SMOOTHING_ONLY", config.smoothing_only);
config.input = input.tag.get_property("INPUT", config.input);
}
else
if(input.tag.title_is("LEVEL"))
{
double x = input.tag.get_property("X", (double)0);
double y = input.tag.get_property("Y", (double)0);
compressor_point_t point = { x, y };
config.levels.append(point);
}
}
}
}
void FreezeFrameMain::read_data(KeyFrame *keyframe)
{
FileXML input;
input.set_shared_string(keyframe->get_data(), strlen(keyframe->get_data()));
int result = 0;
config.enabled = 0;
config.line_double = 0;
while(!result)
{
result = input.read_tag();
if(!result)
{
if(input.tag.title_is("ENABLED"))
{
config.enabled = 1;
}
if(input.tag.title_is("LINE_DOUBLE"))
{
config.line_double = 1;
}
}
}
}
void ParametricEQ::read_data(KeyFrame *keyframe)
{
FileXML input;
input.set_shared_string(keyframe->get_data(), strlen(keyframe->get_data()));
int result = 0;
while(!result)
{
result = input.read_tag();
if(!result)
{
if(input.tag.title_is("PARAMETRICEQ"))
{
config.wetness = input.tag.get_property("WETNESS", config.wetness);
config.window_size = input.tag.get_property("WINDOW_SIZE", config.window_size);
}
else if(input.tag.title_is("BAND"))
{
int band = input.tag.get_property("NUMBER", 0);
config.band[band].freq = input.tag.get_property("FREQ", config.band[band].freq);
config.band[band].quality = input.tag.get_property("QUALITY", config.band[band].quality);
config.band[band].magnitude = input.tag.get_property("MAGNITUDE", config.band[band].magnitude);
config.band[band].mode = input.tag.get_property("MODE", config.band[band].mode);
}
}
}
}
void Color3WayMain::save_data(KeyFrame *keyframe)
{
FileXML output;
// cause data to be stored directly in text
output.set_shared_string(keyframe->get_data(), MESSAGESIZE);
output.tag.set_title("COLOR3WAY");
for(int i = 0; i < SECTIONS; i++)
{
char string[BCTEXTLEN];
sprintf(string, "HUE_X_%d", i);
output.tag.set_property(string, config.hue_x[i]);
sprintf(string, "HUE_Y_%d", i);
output.tag.set_property(string, config.hue_y[i]);
sprintf(string, "VALUE_%d", i);
output.tag.set_property(string, config.value[i]);
sprintf(string, "SATURATION_%d", i);
output.tag.set_property(string, config.saturation[i]);
if(is_defaults())
{
sprintf(string, "COPY_TO_ALL_%d", i);
output.tag.set_property(string, copy_to_all[i]);
}
}
if(is_defaults())
{
output.tag.set_property("W", w);
output.tag.set_property("H", h);
}
output.append_tag();
output.terminate_string();
}
void FlipMain::save_data(KeyFrame *keyframe)
{
FileXML output;
// cause data to be stored directly in text
output.set_shared_string(keyframe->data, MESSAGESIZE);
output.tag.set_title("FLIP");
output.append_tag();
if(config.flip_vertical)
{
output.tag.set_title("VERTICAL");
output.append_tag();
output.tag.set_title("/VERTICAL");
output.append_tag();
}
if(config.flip_horizontal)
{
output.tag.set_title("HORIZONTAL");
output.append_tag();
output.tag.set_title("/HORIZONTAL");
output.append_tag();
}
output.tag.set_title("/FLIP");
output.append_tag();
output.terminate_string();
// data is now in *text
}
void FlipMain::read_data(KeyFrame *keyframe)
{
FileXML input;
input.set_shared_string(keyframe->data, strlen(keyframe->data));
int result = 0;
config.flip_vertical = config.flip_horizontal = 0;
while(!result)
{
result = input.read_tag();
if(!result)
{
if(input.tag.title_is("VERTICAL"))
{
config.flip_vertical = 1;
}
else
if(input.tag.title_is("HORIZONTAL"))
{
config.flip_horizontal = 1;
}
}
}
}
void SelTempAvgMain::save_data(KeyFrame *keyframe)
{
FileXML output;
// cause data to be stored directly in text
output.set_shared_string(keyframe->get_data(), MESSAGESIZE);
output.tag.set_title("SELECTIVE_TEMPORAL_AVERAGE");
output.tag.set_property("FRAMES", config.frames);
output.tag.set_property("METHOD", config.method);
output.tag.set_property("OFFSETMODE", config.offsetmode);
output.tag.set_property("PARANOID", config.paranoid);
output.tag.set_property("NOSUBTRACT", config.nosubtract);
output.tag.set_property("OFFSETMODE_RESTARTMODE_KEYFRAME", config.offset_restartmarker_keyframe);
output.tag.set_property("OFFSETMODE_FIXED_VALUE", config.offset_fixed_value);
output.tag.set_property("GAIN", config.gain);
output.tag.set_property("AVG_THRESHOLD_RY", config.avg_threshold_RY);
output.tag.set_property("AVG_THRESHOLD_GU", config.avg_threshold_GU);
output.tag.set_property("AVG_THRESHOLD_BV", config.avg_threshold_BV);
output.tag.set_property("STD_THRESHOLD_RY", config.std_threshold_RY);
output.tag.set_property("STD_THRESHOLD_GU", config.std_threshold_GU);
output.tag.set_property("STD_THRESHOLD_BV", config.std_threshold_BV);
output.tag.set_property("MASK_RY", config.mask_RY);
output.tag.set_property("MASK_GU", config.mask_GU);
output.tag.set_property("MASK_BV", config.mask_BV);
output.append_tag();
output.terminate_string();
}
void SelTempAvgMain::read_data(KeyFrame *keyframe)
{
FileXML input;
input.set_shared_string(keyframe->get_data(), strlen(keyframe->get_data()));
int result = 0;
while(!input.read_tag())
{
if(input.tag.title_is("SELECTIVE_TEMPORAL_AVERAGE"))
{
config.frames = input.tag.get_property("FRAMES", config.frames);
config.method = input.tag.get_property("METHOD", config.method);
config.offsetmode = input.tag.get_property("OFFSETMODE", config.offsetmode);
config.paranoid = input.tag.get_property("PARANOID", config.paranoid);
config.nosubtract = input.tag.get_property("NOSUBTRACT", config.nosubtract);
config.offset_restartmarker_keyframe = input.tag.get_property("OFFSETMODE_RESTARTMODE_KEYFRAME", config.offset_restartmarker_keyframe);
config.offset_fixed_value = input.tag.get_property("OFFSETMODE_FIXED_VALUE", config.offset_fixed_value);
config.gain = input.tag.get_property("gain", config.gain);
config.avg_threshold_RY = input.tag.get_property("AVG_THRESHOLD_RY", config.avg_threshold_RY);
config.avg_threshold_GU = input.tag.get_property("AVG_THRESHOLD_GU", config.avg_threshold_GU);
config.avg_threshold_BV = input.tag.get_property("AVG_THRESHOLD_BV", config.avg_threshold_BV);
config.std_threshold_RY = input.tag.get_property("STD_THRESHOLD_RY", config.std_threshold_RY);
config.std_threshold_GU = input.tag.get_property("STD_THRESHOLD_GU", config.std_threshold_GU);
config.std_threshold_BV = input.tag.get_property("STD_THRESHOLD_BV", config.std_threshold_BV);
config.mask_RY = input.tag.get_property("MASK_RY", config.mask_RY);
config.mask_GU = input.tag.get_property("MASK_GU", config.mask_GU);
config.mask_BV = input.tag.get_property("MASK_BV", config.mask_BV);
}
}
}
void FindObjectMain::save_data(KeyFrame *keyframe)
{
FileXML output;
// cause data to be stored directly in text
output.set_shared_string(keyframe->get_data(), MESSAGESIZE);
output.tag.set_title("FINDOBJECT");
output.tag.set_property("GLOBAL_BLOCK_W", config.global_block_w);
output.tag.set_property("GLOBAL_BLOCK_H", config.global_block_h);
output.tag.set_property("BLOCK_X", config.block_x);
output.tag.set_property("BLOCK_Y", config.block_y);
output.tag.set_property("GLOBAL_RANGE_W", config.global_range_w);
output.tag.set_property("GLOBAL_RANGE_H", config.global_range_h);
output.tag.set_property("DRAW_KEYPOINTS", config.draw_keypoints);
output.tag.set_property("DRAW_BORDER", config.draw_border);
output.tag.set_property("REPLACE_OBJECT", config.replace_object);
output.tag.set_property("DRAW_OBJECT_BORDER", config.draw_object_border);
output.tag.set_property("OBJECT_LAYER", config.object_layer);
output.tag.set_property("REPLACE_LAYER", config.replace_layer);
output.tag.set_property("SCENE_LAYER", config.scene_layer);
output.tag.set_property("ALGORITHM", config.algorithm);
output.tag.set_property("VMIN", config.vmin);
output.tag.set_property("VMAX", config.vmax);
output.tag.set_property("SMIN", config.smin);
output.tag.set_property("BLEND", config.blend);
output.append_tag();
output.terminate_string();
}
void LensMain::read_data(KeyFrame *keyframe)
{
FileXML input;
char string[BCTEXTLEN];
input.set_shared_string(keyframe->get_data(), strlen(keyframe->get_data()));
int result = 0;
while(!result)
{
result = input.read_tag();
if(!result)
{
if(input.tag.title_is("LENS"))
{
for(int i = 0; i < FOV_CHANNELS; i++)
{
sprintf(string, "FOCAL_LENGTH%d", i);
config.fov[i] = input.tag.get_property(string, config.fov[i]);
}
config.aspect = input.tag.get_property("ASPECT", config.aspect);
config.radius = input.tag.get_property("RADIUS", config.radius);
config.mode = input.tag.get_property("MODE", config.mode);
config.center_x = input.tag.get_property("CENTER_X", config.center_x);
config.center_y = input.tag.get_property("CENTER_Y", config.center_y);
config.draw_guides = input.tag.get_property("DRAW_GUIDES", config.draw_guides);
}
}
}
}
void LensMain::save_data(KeyFrame *keyframe)
{
FileXML output;
char string[BCTEXTLEN];
// cause data to be stored directly in text
output.set_shared_string(keyframe->get_data(), MESSAGESIZE);
output.tag.set_title("LENS");
for(int i = 0; i < FOV_CHANNELS; i++)
{
sprintf(string, "FOCAL_LENGTH%d", i);
output.tag.set_property(string, config.fov[i]);
}
output.tag.set_property("ASPECT", config.aspect);
output.tag.set_property("RADIUS", config.radius);
output.tag.set_property("MODE", config.mode);
output.tag.set_property("CENTER_X", config.center_x);
output.tag.set_property("CENTER_Y", config.center_y);
output.tag.set_property("DRAW_GUIDES", config.draw_guides);
output.append_tag();
output.terminate_string();
}
void _720to480Main::save_data(KeyFrame *keyframe)
{
FileXML output;
output.set_shared_string(keyframe->get_data(), MESSAGESIZE);
output.tag.set_title("720TO480");
output.tag.set_property("FIRST_FIELD", config.first_field);
output.tag.set_property("DIRECTION", config.direction);
output.append_tag();
output.terminate_string();
}
void BandWipeMain::save_data(KeyFrame *keyframe)
{
FileXML output;
output.set_shared_string(keyframe->get_data(), MESSAGESIZE);
output.tag.set_title("BANDWIPE");
output.tag.set_property("BANDS", bands);
output.tag.set_property("DIRECTION", direction);
output.append_tag();
output.terminate_string();
}
void SlideMain::save_data(KeyFrame *keyframe)
{
FileXML output;
output.set_shared_string(keyframe->get_data(), MESSAGESIZE);
output.tag.set_title("SLIDE");
output.tag.set_property("MOTION_DIRECTION", motion_direction);
output.tag.set_property("DIRECTION", direction);
output.append_tag();
output.terminate_string();
}
void ThresholdMain::save_data(KeyFrame *keyframe)
{
FileXML file;
file.set_shared_string(keyframe->get_data(), MESSAGESIZE);
file.tag.set_title("THRESHOLD");
file.tag.set_property("MIN", config.min);
file.tag.set_property("MAX", config.max);
file.tag.set_property("PLOT", config.plot);
file.append_tag();
file.terminate_string();
}
void DelayAudio::save_data(KeyFrame *keyframe)
{
FileXML output;
output.set_shared_string(keyframe->get_data(), MESSAGESIZE);
output.tag.set_title("DELAYAUDIO");
output.tag.set_property("LENGTH", (double)config.length);
output.append_tag();
output.append_newline();
output.terminate_string();
}
void OilEffect::save_data(KeyFrame *keyframe)
{
FileXML output;
// cause data to be stored directly in text
output.set_shared_string(keyframe->get_data(), MESSAGESIZE);
output.tag.set_title("OIL_PAINTING");
output.tag.set_property("RADIUS", config.radius);
output.tag.set_property("USE_INTENSITY", config.use_intensity);
output.append_tag();
output.terminate_string();
}
void OverlayAudio::save_data(KeyFrame *keyframe)
{
FileXML output;
output.set_shared_string(keyframe->get_data(), MESSAGESIZE);
output.tag.set_title("OVERLAY");
output.tag.set_property("OUTPUT", config.output_track);
output.tag.set_property("MODE", config.mode);
output.append_tag();
output.append_newline();
output.terminate_string();
}
void BrightnessMain::save_data(KeyFrame *keyframe)
{
FileXML output;
// cause data to be stored directly in text
output.set_shared_string(keyframe->get_data(), MESSAGESIZE);
output.tag.set_title("BRIGHTNESS");
output.tag.set_property("BRIGHTNESS", config.brightness);
output.tag.set_property("CONTRAST", config.contrast);
output.tag.set_property("LUMA", config.luma);
output.append_tag();
output.terminate_string();
}
void SoundLevelEffect::save_data(KeyFrame *keyframe)
{
FileXML output;
output.set_shared_string(keyframe->data, MESSAGESIZE);
output.tag.set_title("SOUNDLEVEL");
output.tag.set_property("DURATION", config.duration);
output.append_tag();
output.tag.set_title("/SOUNDLEVEL");
output.append_tag();
output.append_newline();
output.terminate_string();
}
void ChromaKey::save_data(KeyFrame *keyframe)
{
FileXML output;
output.set_shared_string(keyframe->get_data(), MESSAGESIZE);
output.tag.set_title("CHROMAKEY");
output.tag.set_property("RED", config.red);
output.tag.set_property("GREEN", config.green);
output.tag.set_property("BLUE", config.blue);
output.tag.set_property("THRESHOLD", config.threshold);
output.tag.set_property("SLOPE", config.slope);
output.tag.set_property("USE_VALUE", config.use_value);
output.append_tag();
output.terminate_string();
}
void _720to480Main::read_data(KeyFrame *keyframe)
{
FileXML input;
input.set_shared_string(keyframe->get_data(), strlen(keyframe->get_data()));
while(!input.read_tag())
{
if(input.tag.title_is("720TO480"))
{
config.first_field = input.tag.get_property("FIRST_FIELD", config.first_field);
config.direction = input.tag.get_property("DIRECTION", config.direction);
}
}
}
void ShapeWipeMain::save_data(KeyFrame *keyframe)
{
FileXML output;
output.set_shared_string(keyframe->get_data(), MESSAGESIZE);
output.tag.set_title("SHAPEWIPE");
output.tag.set_property("DIRECTION", direction);
output.tag.set_property("ANTIALIAS", antialias);
output.tag.set_property("PRESERVE_ASPECT", preserve_aspect);
output.tag.set_property("FILENAME", filename);
output.tag.set_property("SHAPE_NAME", shape_name);
output.append_tag();
output.tag.set_title("/SHAPEWIPE");
output.append_tag();
output.terminate_string();
}
void IVTCMain::save_data(KeyFrame *keyframe)
{
FileXML output;
// cause data to be stored directly in text
output.set_shared_string(keyframe->get_data(), MESSAGESIZE);
output.tag.set_title("IVTC");
output.tag.set_property("FRAME_OFFSET", config.frame_offset);
output.tag.set_property("FIRST_FIELD", config.first_field);
output.tag.set_property("AUTOMATIC", config.automatic);
output.tag.set_property("AUTO_THRESHOLD", config.auto_threshold);
output.tag.set_property("PATTERN", config.pattern);
output.append_tag();
output.terminate_string();
}
void BandWipeMain::read_data(KeyFrame *keyframe)
{
FileXML input;
input.set_shared_string(keyframe->get_data(), strlen(keyframe->get_data()));
while(!input.read_tag())
{
if(input.tag.title_is("BANDWIPE"))
{
bands = input.tag.get_property("BANDS", bands);
direction = input.tag.get_property("DIRECTION", direction);
}
}
}
void SlideMain::read_data(KeyFrame *keyframe)
{
FileXML input;
input.set_shared_string(keyframe->get_data(), strlen(keyframe->get_data()));
while(!input.read_tag())
{
if(input.tag.title_is("SLIDE"))
{
motion_direction = input.tag.get_property("MOTION_DIRECTION", motion_direction);
direction = input.tag.get_property("DIRECTION", direction);
}
}
}
