mixer undo fix, new ffmpeg opts, docs
[goodguy/history.git] / cinelerra-5.1 / cinelerra / automation.C
1
2 /*
3  * CINELERRA
4  * Copyright (C) 2008-2013 Adam Williams <broadcast at earthling dot net>
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19  *
20  */
21
22 #include "autoconf.h"
23 #include "automation.h"
24 #include "autos.h"
25 #include "atrack.inc"
26 #include "bcsignals.h"
27 #include "bccolors.h"
28 #include "edl.h"
29 #include "edlsession.h"
30 #include "filexml.h"
31 #include "floatautos.h"
32 #include "intautos.h"
33 #include "track.h"
34 #include "transportque.inc"
35
36
37 int Automation::autogrouptypes_fixedrange[] =
38 {
39         0,
40         0,
41         0,
42         0,
43         0,
44         0,
45         1
46 };
47
48
49
50 Automation::Automation(EDL *edl, Track *track)
51 {
52         this->edl = edl;
53         this->track = track;
54         bzero(autos, sizeof(Autos*) * AUTOMATION_TOTAL);
55 }
56
57 Automation::~Automation()
58 {
59         for(int i = 0; i < AUTOMATION_TOTAL; i++)
60         {
61                 delete autos[i];
62         }
63 }
64
65 int Automation::autogrouptype(int autoidx, Track *track)
66 {
67         int autogrouptype = -1;
68         switch (autoidx)
69         {
70                 case AUTOMATION_CAMERA_X:
71                 case AUTOMATION_PROJECTOR_X:
72                         autogrouptype = AUTOGROUPTYPE_X;
73                         break;
74                 case AUTOMATION_CAMERA_Y:
75                 case AUTOMATION_PROJECTOR_Y:
76                         autogrouptype = AUTOGROUPTYPE_Y;
77                         break;
78                 case AUTOMATION_CAMERA_Z:
79                 case AUTOMATION_PROJECTOR_Z:
80                         autogrouptype = AUTOGROUPTYPE_ZOOM;
81                         break;
82                 case AUTOMATION_SPEED:
83                         autogrouptype = AUTOGROUPTYPE_SPEED;
84                         break;
85                 case AUTOMATION_FADE:
86                         if (track->data_type == TRACK_AUDIO)
87                                 autogrouptype = AUTOGROUPTYPE_AUDIO_FADE;
88                         else
89                                 autogrouptype = AUTOGROUPTYPE_VIDEO_FADE;
90                         break;
91                 case AUTOMATION_MUTE:
92                         autogrouptype = AUTOGROUPTYPE_INT255;
93                         break;
94         }
95         return (autogrouptype);
96 }
97
98 void Automation::create_objects()
99 {
100         autos[AUTOMATION_MUTE] = new IntAutos(edl, track, 0);
101         autos[AUTOMATION_MUTE]->create_objects();
102         autos[AUTOMATION_MUTE]->autoidx = AUTOMATION_MUTE;
103         autos[AUTOMATION_MUTE]->autogrouptype = AUTOGROUPTYPE_INT255;
104 }
105
106 Automation& Automation::operator=(Automation& automation)
107 {
108 //printf("Automation::operator= 1\n");
109         copy_from(&automation);
110         return *this;
111 }
112
113 void Automation::equivalent_output(Automation *automation, int64_t *result)
114 {
115         for(int i = 0; i < AUTOMATION_TOTAL; i++)
116         {
117                 if(autos[i] && automation->autos[i])
118                         autos[i]->equivalent_output(automation->autos[i], 0, result);
119         }
120 }
121
122 void Automation::copy_from(Automation *automation)
123 {
124         for(int i = 0; i < AUTOMATION_TOTAL; i++)
125         {
126                 if(autos[i] && automation->autos[i])
127                         autos[i]->copy_from(automation->autos[i]);
128         }
129 }
130
131 // These must match the enumerations
132 static const char *xml_titles[] =
133 {
134         "MUTEAUTOS",
135         "CAMERA_X",
136         "CAMERA_Y",
137         "CAMERA_Z",
138         "PROJECTOR_X",
139         "PROJECTOR_Y",
140         "PROJECTOR_Z",
141         "FADEAUTOS",
142         "PANAUTOS",
143         "MODEAUTOS",
144         "MASKAUTOS",
145         "SPEEDAUTOS",
146 };
147
148 int Automation::load(FileXML *file)
149 {
150         for(int i = 0; i < AUTOMATION_TOTAL; i++)
151         {
152                 if(file->tag.title_is(xml_titles[i]) && autos[i])
153                 {
154                         autos[i]->load(file);
155                         return 1;
156                 }
157         }
158         return 0;
159 }
160
161 int Automation::paste(int64_t start,
162         int64_t length,
163         double scale,
164         FileXML *file,
165         int default_only,
166         int active_only,
167         AutoConf *autoconf)
168 {
169         if(!autoconf) autoconf = edl->session->auto_conf;
170
171         for(int i = 0; i < AUTOMATION_TOTAL; i++)
172         {
173                 if(file->tag.title_is(xml_titles[i]) && autos[i] && autoconf->autos[i])
174                 {
175                         autos[i]->paste(start,
176                                 length,
177                                 scale,
178                                 file,
179                                 default_only,
180                                 active_only);
181                         return 1;
182                 }
183         }
184         return 0;
185 }
186
187 int Automation::copy(int64_t start,
188         int64_t end,
189         FileXML *file,
190         int default_only,
191         int active_only)
192 {
193 // Copy regardless of what's visible.
194         for(int i = 0; i < AUTOMATION_TOTAL; i++)
195         {
196                 if(autos[i])
197                 {
198                         file->tag.set_title(xml_titles[i]);
199                         file->append_tag();
200                         file->append_newline();
201                         autos[i]->copy(start,
202                                                         end,
203                                                         file,
204                                                         default_only,
205                                                         active_only);
206                         char string[BCTEXTLEN];
207                         sprintf(string, "/%s", xml_titles[i]);
208                         file->tag.set_title(string);
209                         file->append_tag();
210                         file->append_newline();
211                 }
212         }
213
214         return 0;
215 }
216
217
218 void Automation::clear(int64_t start,
219         int64_t end,
220         AutoConf *autoconf,
221         int shift_autos)
222 {
223         AutoConf *temp_autoconf = 0;
224
225         if(!autoconf)
226         {
227                 temp_autoconf = new AutoConf;
228                 temp_autoconf->set_all(1);
229                 autoconf = temp_autoconf;
230         }
231
232         for(int i = 0; i < AUTOMATION_TOTAL; i++)
233         {
234                 if(autos[i] && autoconf->autos[i])
235                 {
236                         autos[i]->clear(start, end, shift_autos);
237                 }
238         }
239
240         if(temp_autoconf) delete temp_autoconf;
241 }
242
243 void Automation::set_automation_mode(int64_t start,
244         int64_t end,
245         int mode,
246         AutoConf *autoconf)
247 {
248         AutoConf *temp_autoconf = 0;
249
250         if(!autoconf)
251         {
252                 temp_autoconf = new AutoConf;
253                 temp_autoconf->set_all(1);
254                 autoconf = temp_autoconf;
255         }
256
257         for(int i = 0; i < AUTOMATION_TOTAL; i++)
258         {
259                 if(autos[i] && autoconf->autos[i])
260                 {
261                         autos[i]->set_automation_mode(start, end, mode);
262                 }
263         }
264
265         if(temp_autoconf) delete temp_autoconf;
266 }
267
268
269 void Automation::paste_silence(int64_t start, int64_t end)
270 {
271 // Unit conversion done in calling routine
272         for(int i = 0; i < AUTOMATION_TOTAL; i++)
273         {
274                 if(autos[i])
275                         autos[i]->paste_silence(start, end);
276         }
277 }
278
279 // We don't replace it in pasting but
280 // when inserting the first EDL of a load operation we need to replace
281 // the default keyframe.
282 void Automation::insert_track(Automation *automation,
283         int64_t start_unit,
284         int64_t length_units,
285         int replace_default)
286 {
287         for(int i = 0; i < AUTOMATION_TOTAL; i++)
288         {
289                 if(autos[i] && automation->autos[i])
290                 {
291                         autos[i]->insert_track(automation->autos[i],
292                                 start_unit,
293                                 length_units,
294                                 replace_default);
295                 }
296         }
297
298
299 }
300
301 void Automation::resample(double old_rate, double new_rate)
302 {
303 // Run resample for all the autos structures and all the keyframes
304         for(int i = 0; i < AUTOMATION_TOTAL; i++)
305         {
306                 if(autos[i]) autos[i]->resample(old_rate, new_rate);
307         }
308 }
309
310
311
312 int Automation::direct_copy_possible(int64_t start, int direction)
313 {
314         return 1;
315 }
316
317
318
319
320 void Automation::get_projector(float *x,
321         float *y,
322         float *z,
323         int64_t position,
324         int direction)
325 {
326 }
327
328 void Automation::get_camera(float *x,
329         float *y,
330         float *z,
331         int64_t position,
332         int direction)
333 {
334 }
335
336
337
338
339 int64_t Automation::get_length()
340 {
341         int64_t length = 0;
342         int64_t total_length = 0;
343
344         for(int i = 0; i < AUTOMATION_TOTAL; i++)
345         {
346                 if(autos[i])
347                 {
348                         length = autos[i]->get_length();
349                         if(length > total_length) total_length = length;
350                 }
351         }
352
353
354         return total_length;
355 }
356
357 void Automation::get_extents(float *min,
358         float *max,
359         int *coords_undefined,
360         int64_t unit_start,
361         int64_t unit_end,
362         int autogrouptype)
363 {
364         for(int i = 0; i < AUTOMATION_TOTAL; i++)
365         {
366                 if(autos[i] && edl->session->auto_conf->autos[i])
367                 {
368                         if (autos[i]->autogrouptype == autogrouptype)
369                                 autos[i]->get_extents(min, max, coords_undefined, unit_start, unit_end);
370                 }
371         }
372 }
373
374
375 void Automation::dump(FILE *fp)
376 {
377         fprintf(fp,"   Automation: %p\n", this);
378
379
380         for(int i = 0; i < AUTOMATION_TOTAL; i++)
381         {
382                 if(autos[i])
383                 {
384                         fprintf(fp,"    %s %p\n", xml_titles[i], autos[i]);
385                         autos[i]->dump(fp);
386                 }
387         }
388
389 }