cinelerra/floatauto.C

   1 #include "autos.h"
   2 #include "clip.h"
   3 #include "edl.h"
   4 #include "filexml.h"
   5 #include "floatauto.h"
   6 #include "localsession.h"
   7
   8 FloatAuto::FloatAuto(EDL *edl, FloatAutos *autos)
   9  : Auto(edl, (Autos*)autos)
  10 {
  11         value = 0;
  12         control_in_value = 0;
  13         control_out_value = 0;
  14         control_in_position = 0;
  15         control_out_position = 0;
  16 }
  17
  18 FloatAuto::~FloatAuto()
  19 {
  20 }
  21
  22 int FloatAuto::operator==(Auto &that)
  23 {
  24         return identical((FloatAuto*)&that);
  25 }
  26
  27
  28 int FloatAuto::operator==(FloatAuto &that)
  29 {
  30         return identical((FloatAuto*)&that);
  31 }
  32
  33
  34 int FloatAuto::identical(FloatAuto *src)
  35 {
  36         return EQUIV(value, src->value) &&
  37                 EQUIV(control_in_value, src->control_in_value) &&
  38                 EQUIV(control_out_value, src->control_out_value) &&
  39                 control_in_position == src->control_in_position &&
  40                 control_out_position == src->control_out_position;
  41 }
  42
  43 float FloatAuto::value_to_percentage()
  44 {
  45         if(!edl) return 0;
  46         float automation_min = edl->local_session->automation_min;
  47         float automation_max = edl->local_session->automation_max;
  48         float automation_range = automation_max - automation_min;
  49         return (value - automation_min) / automation_range;
  50 }
  51
  52 float FloatAuto::invalue_to_percentage()
  53 {
  54         if(!edl) return 0;
  55         float automation_min = edl->local_session->automation_min;
  56         float automation_max = edl->local_session->automation_max;
  57         float automation_range = automation_max - automation_min;
  58         return (value + control_in_value - automation_min) /
  59                 automation_range;
  60 }
  61
  62 float FloatAuto::outvalue_to_percentage()
  63 {
  64         if(!edl) return 0;
  65         float automation_min = edl->local_session->automation_min;
  66         float automation_max = edl->local_session->automation_max;
  67         float automation_range = automation_max - automation_min;
  68         return (value + control_out_value - automation_min) /
  69                 automation_range;
  70 }
  71
  72 // float FloatAuto::percentage_to_value(float percentage)
  73 // {
  74 //      return percentage * (autos->max - autos->min) + autos->min;
  75 // }
  76 //
  77 // float FloatAuto::percentage_to_invalue(float percentage)
  78 // {
  79 //      return percentage * (autos->max - autos->min) + autos->min - value;
  80 // }
  81 //
  82 // float FloatAuto::percentage_to_outvalue(float percentage)
  83 // {
  84 //      return percentage * (autos->max - autos->min) + autos->min - value;
  85 // }
  86
  87 void FloatAuto::copy_from(Auto *that)
  88 {
  89         copy_from((FloatAuto*)that);
  90 }
  91
  92 void FloatAuto::copy_from(FloatAuto *that)
  93 {
  94         Auto::copy_from(that);
  95         this->value = that->value;
  96         this->control_in_value = that->control_in_value;
  97         this->control_out_value = that->control_out_value;
  98         this->control_in_position = that->control_in_position;
  99         this->control_out_position = that->control_out_position;
 100 }
 101
 102 int FloatAuto::value_to_str(char *string, float value)
 103 {
 104         int j = 0, i = 0;
 105         if(value > 0)
 106                 sprintf(string, "+%.2f", value);
 107         else
 108                 sprintf(string, "%.2f", value);
 109
 110 // fix number
 111         if(value == 0)
 112         {
 113                 j = 0;
 114                 string[1] = 0;
 115         }
 116         else
 117         if(value < 1 && value > -1)
 118         {
 119                 j = 1;
 120                 string[j] = string[0];
 121         }
 122         else
 123         {
 124                 j = 0;
 125                 string[3] = 0;
 126         }
 127
 128         while(string[j] != 0) string[i++] = string[j++];
 129         string[i] = 0;
 130
 131         return 0;
 132 }
 133
 134 void FloatAuto::copy(int64_t start, int64_t end, FileXML *file, int default_auto)
 135 {
 136         file->tag.set_title("AUTO");
 137         if(default_auto)
 138                 file->tag.set_property("POSITION", 0);
 139         else
 140                 file->tag.set_property("POSITION", position - start);
 141         file->tag.set_property("VALUE", value);
 142         file->tag.set_property("CONTROL_IN_VALUE", control_in_value);
 143         file->tag.set_property("CONTROL_OUT_VALUE", control_out_value);
 144         file->tag.set_property("CONTROL_IN_POSITION", control_in_position);
 145         file->tag.set_property("CONTROL_OUT_POSITION", control_out_position);
 146         file->append_tag();
 147         file->tag.set_title("/AUTO");
 148         file->append_tag();
 149         file->append_newline();
 150 }
 151
 152 void FloatAuto::load(FileXML *file)
 153 {
 154         value = file->tag.get_property("VALUE", value);
 155         control_in_value = file->tag.get_property("CONTROL_IN_VALUE", control_in_value);
 156         control_out_value = file->tag.get_property("CONTROL_OUT_VALUE", control_out_value);
 157         control_in_position = file->tag.get_property("CONTROL_IN_POSITION", control_in_position);
 158         control_out_position = file->tag.get_property("CONTROL_OUT_POSITION", control_out_position);
 159 }