add bluray dv, misc fixes
[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 "colors.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         1
45 };
46
47
48
49 Automation::Automation(EDL *edl, Track *track)
50 {
51         this->edl = edl;
52         this->track = track;
53         bzero(autos, sizeof(Autos*) * AUTOMATION_TOTAL);
54 }
55
56 Automation::~Automation()
57 {
58         for(int i = 0; i < AUTOMATION_TOTAL; i++)
59         {
60                 delete autos[i];
61         }
62 }
63
64 int Automation::autogrouptype(int autoidx, Track *track)
65 {
66         int autogrouptype = -1;
67         switch (autoidx)
68         {
69                 case AUTOMATION_CAMERA_X:
70                 case AUTOMATION_PROJECTOR_X:
71                         autogrouptype = AUTOGROUPTYPE_X;
72                         break;
73                 case AUTOMATION_CAMERA_Y:
74                 case AUTOMATION_PROJECTOR_Y:
75                         autogrouptype = AUTOGROUPTYPE_Y;
76                         break;
77                 case AUTOMATION_CAMERA_Z:
78                 case AUTOMATION_PROJECTOR_Z:
79                         autogrouptype = AUTOGROUPTYPE_ZOOM;
80                         break;
81                 case AUTOMATION_SPEED:
82                         autogrouptype = AUTOGROUPTYPE_SPEED;
83                         break;
84                 case AUTOMATION_FADE:
85                         if (track->data_type == TRACK_AUDIO)
86                                 autogrouptype = AUTOGROUPTYPE_AUDIO_FADE;
87                         else
88                                 autogrouptype = AUTOGROUPTYPE_VIDEO_FADE;
89                         break;
90                 case AUTOMATION_MUTE:
91                         autogrouptype = AUTOGROUPTYPE_INT255;
92                         break;
93         }
94         return (autogrouptype);
95 }
96
97 void Automation::create_objects()
98 {
99         autos[AUTOMATION_MUTE] = new IntAutos(edl, track, 0);
100         autos[AUTOMATION_MUTE]->create_objects();
101         autos[AUTOMATION_MUTE]->autoidx = AUTOMATION_MUTE;
102         autos[AUTOMATION_MUTE]->autogrouptype = AUTOGROUPTYPE_INT255;
103 }
104
105 Automation& Automation::operator=(Automation& automation)
106 {
107 //printf("Automation::operator= 1\n");
108         copy_from(&automation);
109         return *this;
110 }
111
112 void Automation::equivalent_output(Automation *automation, int64_t *result)
113 {
114         for(int i = 0; i < AUTOMATION_TOTAL; i++)
115         {
116                 if(autos[i] && automation->autos[i])
117                         autos[i]->equivalent_output(automation->autos[i], 0, result);
118         }
119 }
120
121 void Automation::copy_from(Automation *automation)
122 {
123         for(int i = 0; i < AUTOMATION_TOTAL; i++)
124         {
125                 if(autos[i] && automation->autos[i])
126                         autos[i]->copy_from(automation->autos[i]);
127         }
128 }
129
130 // These must match the enumerations
131 static const char *xml_titles[] =
132 {
133         "MUTEAUTOS",
134         "CAMERA_X",
135         "CAMERA_Y",
136         "CAMERA_Z",
137         "PROJECTOR_X",
138         "PROJECTOR_Y",
139         "PROJECTOR_Z",
140         "FADEAUTOS",
141         "PANAUTOS",
142         "MODEAUTOS",
143         "MASKAUTOS",
144         "SPEEDAUTOS",
145 };
146
147 int Automation::load(FileXML *file)
148 {
149         for(int i = 0; i < AUTOMATION_TOTAL; i++)
150         {
151                 if(file->tag.title_is(xml_titles[i]) && autos[i])
152                 {
153                         autos[i]->load(file);
154                         return 1;
155                 }
156         }
157         return 0;
158 }
159
160 int Automation::paste(int64_t start,
161         int64_t length,
162         double scale,
163         FileXML *file,
164         int default_only,
165         int active_only,
166         AutoConf *autoconf)
167 {
168         if(!autoconf) autoconf = edl->session->auto_conf;
169
170         for(int i = 0; i < AUTOMATION_TOTAL; i++)
171         {
172                 if(file->tag.title_is(xml_titles[i]) && autos[i] && autoconf->autos[i])
173                 {
174                         autos[i]->paste(start,
175                                 length,
176                                 scale,
177                                 file,
178                                 default_only,
179                                 active_only);
180                         return 1;
181                 }
182         }
183         return 0;
184 }
185
186 int Automation::copy(int64_t start,
187         int64_t end,
188         FileXML *file,
189         int default_only,
190         int active_only)
191 {
192 // Copy regardless of what's visible.
193         for(int i = 0; i < AUTOMATION_TOTAL; i++)
194         {
195                 if(autos[i])
196                 {
197                         file->tag.set_title(xml_titles[i]);
198                         file->append_tag();
199                         file->append_newline();
200                         autos[i]->copy(start,
201                                                         end,
202                                                         file,
203                                                         default_only,
204                                                         active_only);
205                         char string[BCTEXTLEN];
206                         sprintf(string, "/%s", xml_titles[i]);
207                         file->tag.set_title(string);
208                         file->append_tag();
209                         file->append_newline();
210                 }
211         }
212
213         return 0;
214 }
215
216
217 void Automation::clear(int64_t start,
218         int64_t end,
219         AutoConf *autoconf,
220         int shift_autos)
221 {
222         AutoConf *temp_autoconf = 0;
223
224         if(!autoconf)
225         {
226                 temp_autoconf = new AutoConf;
227                 temp_autoconf->set_all(1);
228                 autoconf = temp_autoconf;
229         }
230
231         for(int i = 0; i < AUTOMATION_TOTAL; i++)
232         {
233                 if(autos[i] && autoconf->autos[i])
234                 {
235                         autos[i]->clear(start, end, shift_autos);
236                 }
237         }
238
239         if(temp_autoconf) delete temp_autoconf;
240 }
241
242 void Automation::set_automation_mode(int64_t start,
243         int64_t end,
244         int mode,
245         AutoConf *autoconf)
246 {
247         AutoConf *temp_autoconf = 0;
248
249         if(!autoconf)
250         {
251                 temp_autoconf = new AutoConf;
252                 temp_autoconf->set_all(1);
253                 autoconf = temp_autoconf;
254         }
255
256         for(int i = 0; i < AUTOMATION_TOTAL; i++)
257         {
258                 if(autos[i] && autoconf->autos[i])
259                 {
260                         autos[i]->set_automation_mode(start, end, mode);
261                 }
262         }
263
264         if(temp_autoconf) delete temp_autoconf;
265 }
266
267
268 void Automation::paste_silence(int64_t start, int64_t end)
269 {
270 // Unit conversion done in calling routine
271         for(int i = 0; i < AUTOMATION_TOTAL; i++)
272         {
273                 if(autos[i])
274                         autos[i]->paste_silence(start, end);
275         }
276 }
277
278 // We don't replace it in pasting but
279 // when inserting the first EDL of a load operation we need to replace
280 // the default keyframe.
281 void Automation::insert_track(Automation *automation,
282         int64_t start_unit,
283         int64_t length_units,
284         int replace_default)
285 {
286         for(int i = 0; i < AUTOMATION_TOTAL; i++)
287         {
288                 if(autos[i] && automation->autos[i])
289                 {
290                         autos[i]->insert_track(automation->autos[i],
291                                 start_unit,
292                                 length_units,
293                                 replace_default);
294                 }
295         }
296
297
298 }
299
300 void Automation::resample(double old_rate, double new_rate)
301 {
302 // Run resample for all the autos structures and all the keyframes
303         for(int i = 0; i < AUTOMATION_TOTAL; i++)
304         {
305                 if(autos[i]) autos[i]->resample(old_rate, new_rate);
306         }
307 }
308
309
310
311 int Automation::direct_copy_possible(int64_t start, int direction)
312 {
313         return 1;
314 }
315
316
317
318
319 void Automation::get_projector(float *x,
320         float *y,
321         float *z,
322         int64_t position,
323         int direction)
324 {
325 }
326
327 void Automation::get_camera(float *x,
328         float *y,
329         float *z,
330         int64_t position,
331         int direction)
332 {
333 }
334
335
336
337
338 int64_t Automation::get_length()
339 {
340         int64_t length = 0;
341         int64_t total_length = 0;
342
343         for(int i = 0; i < AUTOMATION_TOTAL; i++)
344         {
345                 if(autos[i])
346                 {
347                         length = autos[i]->get_length();
348                         if(length > total_length) total_length = length;
349                 }
350         }
351
352
353         return total_length;
354 }
355
356 void Automation::get_extents(float *min,
357         float *max,
358         int *coords_undefined,
359         int64_t unit_start,
360         int64_t unit_end,
361         int autogrouptype)
362 {
363         for(int i = 0; i < AUTOMATION_TOTAL; i++)
364         {
365                 if(autos[i] && edl->session->auto_conf->autos[i])
366                 {
367                         if (autos[i]->autogrouptype == autogrouptype)
368                                 autos[i]->get_extents(min, max, coords_undefined, unit_start, unit_end);
369                 }
370         }
371 }
372
373
374 void Automation::dump(FILE *fp)
375 {
376         fprintf(fp,"   Automation: %p\n", this);
377
378
379         for(int i = 0; i < AUTOMATION_TOTAL; i++)
380         {
381                 if(autos[i])
382                 {
383                         fprintf(fp,"    %s %p\n", xml_titles[i], autos[i]);
384                         autos[i]->dump(fp);
385                 }
386         }
387
388 }