minor improvements from Andrew
[goodguy/cinelerra.git] / cinelerra-5.1 / cinelerra / recordengine.C
1
2 /*
3  * CINELERRA
4  * Copyright (C) 2008 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 "assets.h"
23 #include "audioconfig.h"
24 #include "audiodevice.h"
25 #include "file.h"
26 #include "filexml.h"
27 #include "mwindow.h"
28 #include "patchbay.h"
29 #include "playbackengine.h"
30 #include "preferences.h"
31 #include "recconfirmdelete.h"
32 #include "record.h"
33 #include "recordengine.h"
34 #include "recordgui.h"
35 #include "recordlabel.h"
36 #include "recordpreview.h"
37 #include "recordthread.h"
38 #include "recordmonitor.h"
39 #include "units.h"
40 #include "videodevice.h"
41
42 #include <ctype.h>
43
44 #include <libintl.h>
45 #define _(String) gettext(String)
46 #define gettext_noop(String) String
47 #define N_(String) gettext_noop (String)
48
49 RecordEngine::RecordEngine(MWindow *mwindow, Record *record)
50 {
51         this->mwindow = mwindow;
52         this->record = record;
53 }
54
55
56
57
58
59 RecordEngine::RecordEngine(MWindow *mwindow,
60                         Record *record,
61                         File *file,
62                         Asset *asset,
63                         RecordLabels *labels)
64 {
65         this->mwindow = mwindow;
66         this->record = record;
67         this->file = file;
68         this->labels = labels;
69         this->asset = asset;
70         is_saving = 0;
71         is_previewing = 0;
72         is_duplexing = 0;
73         is_monitoring = 0;
74         prev_label = -1;
75         next_label = -1;
76
77         if(record->do_audio)
78                 adevice = new AudioDevice;
79         else
80                 adevice = 0;
81
82         if(record->do_video)
83                 vdevice = new VideoDevice(mwindow);
84         else
85                 vdevice = 0;
86 }
87
88 RecordEngine::~RecordEngine()
89 {
90         delete monitor_thread;
91         delete record_thread;
92         delete preview_thread;
93         if(adevice) delete adevice;
94         if(vdevice) delete vdevice;
95 }
96
97 int RecordEngine::initialize()
98 {
99 //      monitor_thread = new RecordThread(mwindow, record, this);
100         monitor_thread->create_objects();
101
102 //      record_thread = new RecordThread(mwindow, record, this);
103         record_thread->create_objects();
104
105         preview_thread = new RecordPreview(record, this);
106         preview_thread->initialize();
107
108 // put at end of file
109         total_length = -1;
110         if(record->do_audio) current_position = file->get_audio_length();
111         else
112         if(record->do_video) current_position = Units::tosamples((float)(file->get_video_length(record->get_framerate())), record->get_samplerate(), record->get_framerate());
113
114         file->seek_end();
115
116         duplex_thread = mwindow->playback_engine;
117
118 // initialize seek buttons
119         jump_delay[0] = 100;
120         jump_delay[1] = 50;
121         jump_delay[2] = 25;
122         jump_delay[3] = 10;
123         jump_delay[4] = 5;
124
125         current_jump_jumps[0] = 20;
126         current_jump_jumps[1] = 40;
127         current_jump_jumps[2] = 60;
128         current_jump_jumps[3] = 80;
129         current_jump_jumps[4] = 100;
130 }
131
132 int RecordEngine::run_script(FileXML *script)
133 {
134         int result = 0, script_result = 0;
135         char string[1024];
136
137         while(!result && !script_result)
138         {
139                 result = script->read_tag();
140
141                 if(!result)
142                 {
143                         if(script->tag.title_is("set_mode"))
144                         {
145                                 set_record_mode(script->tag.get_property_text(0));
146                                 mode_to_text(string, get_record_mode());
147                                 gui->rec_mode_menu->set_text(string);
148                         }
149                         else
150                         if(script->tag.title_is("set_duration"))
151                         {
152                                 record->set_loop_duration((long)record->get_samplerate() * script->tag.get_property_int(0));
153                                 gui->update_duration_boxes();
154                         }
155                         else
156                         if(script->tag.title_is("start_recording"))
157                         {
158                                 gui->unlock_window();
159                                 start_saving();
160                                 gui->lock_window();
161                         }
162                         else
163                         if(script->tag.title_is("set_monitor_video"))
164                         {
165                                 set_monitor_video(script->tag.get_property_int(0));
166                                 if(!script->tag.get_property_int(0) && record->video_window_open)
167                                 {
168                                         record->video_window_open = 0;
169                                         gui->monitor_video_window->window->hide_window();
170                                 }
171                         }
172                         else
173                         if(script->tag.title_is("set_monitor_audio"))
174                         {
175                                 set_monitor_audio(script->tag.get_property_int(0));
176                         }
177                         else
178                         if(script->tag.title_is("quit_when_completed"))
179                         {
180                                 record_thread->quit_when_completed = 1;
181                         }
182                         else
183                         if(script->tag.title_is("ok"))
184                         {
185                                 script_result = 1;
186                         }
187                 }
188         }
189         return script_result;
190 }
191
192 // ============================================= accounting
193
194 long RecordEngine::get_dc_offset(int offset)
195 {
196         return record->dc_offset[offset];
197 }
198
199 int RecordEngine::set_dc_offset(long new_offset, int number)
200 {
201         adevice->set_dc_offset(new_offset, number);
202 }
203
204 long int RecordEngine::get_dc_offset(long *dc_offset, RecordGUIDCOffsetText **dc_offset_text)
205 {
206         return adevice->get_dc_offset(dc_offset, dc_offset_text);
207 }
208
209 int RecordEngine::set_gui(RecordGUI *gui)
210 {
211         this->gui = gui;
212         update_position(current_position);
213 }
214
215 int RecordEngine::get_duplex_enable()
216 {
217         return record->enable_duplex();
218 }
219
220
221
222 // ================================================ operations
223
224 int RecordEngine::open_input_devices(int duplex)
225 {
226         int audio_opened = 0;
227         int video_opened = 0;
228         AudioConfig *aconfig /* = mwindow->preferences->aconfig */;
229
230 // Initialize sharing
231         if(record->do_audio && record->do_video)
232         {
233                 vdevice->set_adevice(adevice);
234                 adevice->set_vdevice(vdevice);
235         }
236
237 // Initialize audio
238         if(record->do_audio)
239         {
240                 if(record->get_software_positioning())
241                         adevice->set_software_positioning();
242
243                 for(int i = 0; i < asset->channels; i++)
244                 {
245                         adevice->set_dc_offset(record->dc_offset[i], i);
246                 }
247         }
248
249
250 // Duplex is only needed if the timeline and the recording have audio
251         if(duplex &&
252                 record->do_audio &&
253                 mwindow->patches->total_playable_atracks())
254         {
255 // duplex device is identical to input device
256                 if(aconfig->audio_in_driver == aconfig->audio_duplex_driver &&
257                         !strcmp(aconfig->oss_in_device, aconfig->oss_duplex_device) &&
258                         aconfig->oss_in_bits == aconfig->oss_duplex_bits &&
259                         aconfig->oss_in_channels == aconfig->oss_duplex_channels)
260                 {
261 //                      adevice->open_duplex(mwindow->preferences->aconfig,
262 //                                              record->get_samplerate(),
263 //                                              get_in_length());
264                         audio_opened = 1;
265                 }
266                 else
267 // two separate devices
268                 {
269 //                      adevice->open_output(mwindow->preferences->aconfig,
270 //                                      record->get_samplerate(),
271 //                                      record->get_out_length());
272                 }
273         }
274
275         if(record->do_audio && !audio_opened)
276         {
277 //              adevice->open_input(mwindow->preferences->aconfig,
278 //                              record->get_samplerate(),
279 //                              get_in_length());
280         }
281
282 // Initialize video
283         if(record->do_video)
284         {
285 //              vdevice->open_input(mwindow->preferences->vconfig,
286 //                      record->frame_w,
287 //                      record->frame_h,
288 //                      record->video_x,
289 //                      record->video_y,
290 //                      record->video_zoom,
291 //                      get_frame_rate());
292 //              vdevice->set_field_order(record->reverse_interlace);
293 //              if(record->get_current_channel())
294 //                      vdevice->set_channel(record->get_current_channel());
295 //              set_video_picture();
296         }
297
298         return 0;
299 }
300
301
302 int RecordEngine::close_input_devices()
303 {
304         if(record->do_audio)
305                 adevice->close_all();
306         if(record->do_video)
307                 vdevice->close_all();
308
309         return 0;
310 }
311
312 int RecordEngine::start_monitor()
313 {
314         monitor_timer.update();
315         open_input_devices(0);
316         monitor_thread->start_recording(0, 0);
317         is_monitoring = 1;
318         return 0;
319 }
320
321 int RecordEngine::stop_monitor()
322 {
323 //      if(is_monitoring)
324 //      {
325 //              is_monitoring = 0;
326 //              monitor_thread->stop_recording();
327 //      }
328         return 0;
329 }
330
331 int RecordEngine::pause_monitor()
332 {
333         if(is_monitoring)
334         {
335                 is_monitoring = 0;
336                 monitor_thread->pause_recording();
337         }
338         return 0;
339 }
340
341 int RecordEngine::resume_monitor()
342 {
343         if(!is_monitoring)
344         {
345                 is_monitoring = 1;
346                 monitor_timer.update();
347                 open_input_devices(0);
348                 monitor_thread->resume_recording();
349         }
350         return 0;
351 }
352
353 int RecordEngine::start_saving(int duplex)
354 {
355         if(!is_saving)
356         {
357                 pause_monitor();
358                 record_timer.update();
359                 open_input_devices(duplex);
360
361                 duplex = record->enable_duplex() && duplex;
362
363 // start the duplex engine if necessary
364 // OSS < 3.9 crashes if recording starts before playback
365 // OSS >= 3.9 crashes if playback starts before recording
366                 if(duplex)
367                 {
368                         long start, end;
369                         record->get_duplex_range(&start, &end);
370                         duplex_thread->reset_parameters();
371                         duplex_thread->arm_playback(0, 0, 1, adevice);
372                         duplex_thread->start_playback();
373                         is_duplexing = 1;
374                 }
375
376 //              record_thread->start_recording();
377
378                 is_saving = 1;
379         }
380         return 0;
381 }
382
383 int RecordEngine::save_frame()
384 {
385         if(!is_saving)
386         {
387                 pause_monitor();
388                 record_timer.update();
389                 record->do_audio = 0;
390                 open_input_devices(0);
391
392 // start the duplex engine if necessary
393                 record_thread->start_recording(0, 0);
394                 is_saving = 1;
395         }
396         return 0;
397 }
398
399 int RecordEngine::stop_saving(int no_monitor)
400 {
401         if(is_saving)
402         {
403 // automatically stops duplex here and resumes monitor
404                 record_thread->stop_recording(no_monitor);
405         }
406         return 0;
407 }
408
409 int RecordEngine::stop_duplex()
410 {
411         if(is_duplexing)
412         {
413                 is_duplexing = 0;
414                 duplex_thread->stop_playback(0);
415 // OSS can't resume recording if buffers underrun
416 // so stop playback first
417         }
418         return 0;
419 }
420
421 int RecordEngine::start_preview()
422 {
423         if(!is_previewing)
424         {
425                 stop_operation();
426                 pause_monitor();
427
428                 preview_timer.update();
429                 open_output_devices();
430                 preview_thread->start_preview(current_position, file);
431
432                 is_previewing = 1;
433         }
434         return 0;
435 }
436
437 int RecordEngine::stop_preview(int no_monitor)
438 {
439         if(is_previewing)
440         {
441                 preview_thread->stop_preview(no_monitor);
442 // preview engine automatically triggers monitor when finished
443         }
444         return 0;
445 }
446
447 int RecordEngine::stop_operation(int no_monitor)
448 {
449 // Resumes monitoring after stopping
450         if(is_saving) stop_saving(no_monitor);
451         else
452         if(is_previewing) stop_preview(no_monitor);
453         return 0;
454 }
455
456 int RecordEngine::set_video_picture()
457 {
458         if(record->do_video && vdevice)
459                 vdevice->set_picture(record->video_brightness,
460                         record->video_hue,
461                         record->video_color,
462                         record->video_contrast,
463                         record->video_whiteness);
464         return 0;
465 }
466
467 int RecordEngine::open_output_devices()
468 {
469         if(record->do_audio)
470         {
471 //              adevice->open_output(mwindow->preferences->aconfig,
472 //                              record->get_samplerate(),
473 //                              record->get_out_length());
474                 if(record->get_software_positioning()) adevice->set_software_positioning();
475         }
476
477 // Video is already open for monitoring
478         return 0;
479 }
480
481 int RecordEngine::close_output_devices()
482 {
483         if(record->do_audio)
484                 adevice->close_all();
485 // Video is already open for monitoring
486         return 0;
487 }
488
489
490
491 int RecordEngine::lock_window()
492 {
493         gui->lock_window();
494 }
495
496 int RecordEngine::unlock_window()
497 {
498         gui->unlock_window();
499 }
500
501 int RecordEngine::update_position(long new_position)
502 {
503         if(new_position < 0) new_position = 0;      // fread error in filepcm
504         current_position = new_position;
505
506         gui->update_position(new_position);
507
508         if(new_position > total_length)
509         {
510                 total_length = new_position;
511 //              gui->update_total_length(new_position);
512         }
513
514         if(prev_label != labels->get_prev_label(new_position))
515         {
516                 prev_label = labels->get_prev_label(new_position);
517                 gui->update_prev_label(prev_label);
518         }
519
520         if(next_label != labels->get_next_label(new_position))
521         {
522                 next_label = labels->get_next_label(new_position);
523
524                 gui->update_next_label(next_label);
525         }
526 }
527
528 int RecordEngine::goto_prev_label()
529 {
530         if(!is_saving)
531         {
532                 stop_operation();
533                 long new_position;
534
535                 new_position = labels->goto_prev_label(current_position);
536                 if(new_position != -1)
537                 {
538 //                      if(record->do_audio) file->set_audio_position(new_position);
539                         if(record->do_video) file->set_video_position(Units::toframes(new_position, record->get_samplerate(), record->get_framerate()), record->get_framerate());
540                         update_position(new_position);
541                 }
542         }
543 }
544
545 int RecordEngine::goto_next_label()
546 {
547         if(!is_saving)
548         {
549                 stop_operation();
550                 long new_position;
551
552                 new_position = labels->goto_next_label(current_position);
553                 if(new_position != -1 && new_position <= total_length)
554                 {
555 //                      if(record->do_audio) file->set_audio_position(new_position);
556                         if(record->do_video) file->set_video_position(Units::toframes(new_position, record->get_samplerate(), record->get_framerate()), record->get_framerate());
557                         update_position(new_position);
558                 }
559         }
560         return 0;
561 }
562
563 int RecordEngine::toggle_label()
564 {
565         labels->toggle_label(current_position);
566         update_position(current_position);
567         return 0;
568 }
569
570 int RecordEngine::calibrate_dc_offset()
571 {
572         if(record->do_audio)
573         {
574                 get_dc_offset(record->dc_offset, gui->dc_offset_text);
575         }
576         return 0;
577 }
578
579 int RecordEngine::calibrate_dc_offset(long new_value, int channel)
580 {
581         if(record->do_audio)
582         {
583                 set_dc_offset(new_value, channel);
584                 record->dc_offset[channel] = new_value;
585         }
586         return 0;
587 }
588
589 int RecordEngine::reset_over()
590 {
591 }
592
593 int RecordEngine::set_done(int value)
594 {
595         stop_operation(1);
596         stop_monitor();
597         gui->set_done(value);
598 }
599
600 int RecordEngine::start_over()
601 {
602         if((record->do_audio && file->get_audio_length() > 0) ||
603                 (record->do_video && file->get_video_length(record->get_framerate()) > 0))
604         {
605                 RecConfirmDelete dialog(mwindow);
606                 dialog.create_objects(_("start over"));
607                 int result = dialog.run_window();
608                 if(!result)
609                 {
610                         stop_operation();
611 // remove file
612                         file->close_file();
613                         remove(asset->path);
614
615
616 // start the engine over
617                         labels->delete_new_labels();
618                         update_position(0);
619                         total_length = 0;
620 //                      gui->update_total_length(0);
621
622                         record->startsource_sample = 0;
623                         record->startsource_frame = 0;
624                 }
625         }
626 }
627
628 int RecordEngine::change_channel(Channel *channel)
629 {
630         if(record->do_video && vdevice)
631                 return vdevice->set_channel(channel);
632         else
633                 return 0;
634 }
635
636 ArrayList<char*>* RecordEngine::get_video_inputs()
637 {
638         if(record->do_video && vdevice)
639                 return vdevice->get_inputs();
640         else
641                 return 0;
642 }
643
644 int RecordEngine::get_vu_format() { return record->get_vu_format(); }
645 int RecordEngine::get_dither() { return record->default_asset->dither * record->default_asset->bits; }
646 int RecordEngine::get_input_channels() { return asset->channels; }
647 int RecordEngine::get_format(char *string)
648 {
649         File file;
650         strcpy(string, file.formattostr(mwindow->plugindb, asset->format));
651 }
652 int RecordEngine::get_samplerate() { return asset->rate; }
653 int RecordEngine::get_bits() { return asset->bits; }
654 int RecordEngine::get_time_format() { return record->get_time_format(); }
655 float RecordEngine::get_frame_rate() { return record->get_frame_rate(); }
656 int RecordEngine::get_loop_hr() { return record->loop_duration / asset->rate / 3600; }
657 int RecordEngine::get_loop_min() { return record->loop_duration / asset->rate / 60 - (long)get_loop_hr() * 60; }
658 int RecordEngine::get_loop_sec() { return record->loop_duration / asset->rate - (long)get_loop_hr() * 3600 - (long)get_loop_min() * 60; }
659 long RecordEngine::get_loop_duration() { return record->loop_duration; }
660 float RecordEngine::get_min_db() { return record->get_min_db(); }
661 int RecordEngine::get_meter_over_hold(int divisions) { return divisions * 15; }
662 int RecordEngine::get_meter_peak_hold(int divisions) { return divisions * 2; }
663 int RecordEngine::get_meter_speed() { return record->get_meter_speed(); }
664 float RecordEngine::get_frames_per_foot() { /* return mwindow->preferences->frames_per_foot; */ }
665
666 int RecordEngine::set_monitor_video(int value)
667 {
668 }
669
670 int RecordEngine::set_monitor_audio(int value)
671 {
672 }
673
674 int RecordEngine::set_record_mode(char *text)
675 {
676         record->record_mode = text_to_mode(text);
677 }
678
679 int RecordEngine::get_record_mode(char *text)
680 {
681         mode_to_text(text, record->record_mode);
682 }
683
684 int RecordEngine::get_record_mode()
685 {
686         return record->record_mode;
687 }
688
689 int RecordEngine::mode_to_text(char *string, int mode)
690 {
691         switch(mode)
692         {
693                 case 0:        sprintf(string, _("Untimed"));       break;
694                 case 1:        sprintf(string, _("Timed"));         break;
695                 case 2:        sprintf(string, _("Loop"));          break;
696         }
697 }
698
699 int RecordEngine::text_to_mode(char *string)
700 {
701         if(!strcasecmp(string, _("Untimed"))) return 0;
702         if(!strcasecmp(string, _("Timed")))   return 1;
703         if(!strcasecmp(string, _("Loop")))    return 2;
704 }
705
706 long RecordEngine::get_current_delay()
707 {
708         if(current_jump_jump > 0) current_jump_jump--;
709         if(current_jump_jump == 0 && current_jump_delay < /*JUMP_DELAYS*/ 1)
710         {
711                 current_jump_delay++;
712                 current_jump_jump = current_jump_jumps[current_jump_delay];
713         }
714         return jump_delay[current_jump_delay];
715 }
716
717 int RecordEngine::reset_current_delay()
718 {
719         current_jump_delay = 0;
720         current_jump_jump = current_jump_jumps[current_jump_delay];
721 }
722
723 int RecordEngine::set_loop_duration()
724 {
725         record->set_loop_duration((long)record->get_samplerate() * (atol(gui->loop_sec->get_text()) + atol(gui->loop_min->get_text()) * 60 + atol(gui->loop_hr->get_text()) * 3600));
726 }
727
728
729 // Remember to change meters if you change this.
730 // Return the size of the fragments to read from the audio device.
731 int RecordEngine::get_in_length()
732 {
733         long fragment_size = 1;
734         while(fragment_size < asset->rate / record->get_meter_speed()) fragment_size *= 2;
735         fragment_size /= 2;
736         return fragment_size;
737 }
738
739 // Different absolute positions are defined for each operation so threads
740 // can end at different times without screwing up the frame synchronization.
741 long RecordEngine::absolute_monitor_position()
742 {
743         if(is_monitoring)
744         {
745                 if(record->do_audio)
746                 {
747 //                      return monitor_thread->absolute_position();
748                 }
749                 else
750                 {
751                         return (long)((float)monitor_timer.get_difference() / 1000 * record->get_samplerate());
752                 }
753         }
754         else
755         return -1;
756 }
757
758 long RecordEngine::absolute_preview_position()
759 {
760         if(is_previewing)
761         {
762                 if(record->do_audio)
763                 {
764                         return preview_thread->absolute_position();
765                 }
766                 else
767                 {
768                         return (long)((float)preview_timer.get_difference() / 1000 * record->get_samplerate());
769                 }
770         }
771         else
772         return -1;
773 }
774
775 long RecordEngine::absolute_record_position()
776 {
777         if(is_saving)
778         {
779                 if(record->do_audio)
780                 {
781 //                      return record_thread->absolute_position();
782                 }
783                 else
784                 {
785                         return (long)((float)record_timer.get_difference() / 1000 * record->get_samplerate());
786                 }
787         }
788         else
789         return -1;
790 }
791