cinelerra-5.1/cinelerra/recordaudio.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 "asset.h"
  23 #include "audiodevice.h"
  24 #include "batch.h"
  25 #include "bcsignals.h"
  26 #include "clip.h"
  27 #include "condition.h"
  28 #include "edl.h"
  29 #include "edlsession.h"
  30 #include "errorbox.h"
  31 #include "file.h"
  32 #include "filethread.h"
  33 #include "language.h"
  34 #include "meterpanel.h"
  35 #include "mutex.h"
  36 #include "mwindow.h"
  37 #include "mwindowgui.h"
  38 #include "preferences.h"
  39 #include "record.h"
  40 #include "recordaudio.h"
  41 #include "recordconfig.h"
  42 #include "recordgui.h"
  43 #include "recordmonitor.h"
  44 #include "renderengine.h"
  45 #include "samples.h"
  46
  47
  48 RecordAudio::RecordAudio(MWindow *mwindow, Record *record)
  49  : Thread(1, 0, 0)
  50 {
  51         this->mwindow = mwindow;
  52         this->record = record;
  53         this->gui = record->record_gui;
  54         trigger_lock = new Condition(0, "RecordAudio::trigger_lock");
  55         pause_record_lock = new Condition(0, "RecordAudio::pause_record_lock");
  56         record_paused_lock = new Condition(0, "RecordAudio::record_paused_lock");
  57         reset_parameters();
  58 }
  59
  60 RecordAudio::~RecordAudio()
  61 {
  62         delete_buffer();
  63         delete trigger_lock;
  64         delete pause_record_lock;
  65         delete record_paused_lock;
  66 }
  67
  68 void RecordAudio::reset_parameters()
  69 {
  70         buffer_channels = 0;
  71         write_result = 0;
  72         grab_result = 0;
  73         buffer = 0;
  74         input = 0;
  75         channels = 0;
  76         fragment_samples = 0;
  77         fragment_position = 0;
  78         buffer_samples = 0;
  79         writing_file = 0;
  80         write_buffer_samples = 0;
  81         recording_paused = 0;
  82         pause_record_lock->reset();
  83         record_paused_lock->reset();
  84         trigger_lock->reset();
  85 }
  86
  87
  88 void RecordAudio::arm_recording()
  89 {
  90         reset_parameters();
  91         Thread::start();
  92 }
  93
  94 void RecordAudio::start_recording()
  95 {
  96         trigger_lock->unlock();
  97 }
  98
  99 void RecordAudio::set_monitoring(int mode)
 100 {
 101         if( record->adevice )
 102                 record->adevice->set_monitoring(mode);
 103 }
 104
 105 int RecordAudio::stop_recording()
 106 {
 107         done = 1;
 108         if( record->adevice )
 109                 record->adevice->interrupt_crash();
 110         Thread::join();
 111         return 0;
 112 }
 113
 114 void RecordAudio::delete_buffer()
 115 {
 116         if( buffer ) {
 117                 for( int i=0; i<buffer_channels; ++i )
 118                         delete buffer[i];
 119                 delete [] buffer;
 120                 buffer = 0;
 121                 buffer_channels = 0;
 122         }
 123         input = 0;
 124         fragment_position = 0;
 125 }
 126
 127 void RecordAudio::set_write_buffer_samples(int samples)
 128 {
 129         write_buffer_samples = samples;
 130 }
 131
 132 Samples **RecordAudio::get_buffer()
 133 {
 134         Samples **result = 0;
 135         fragment_position = 0;
 136         record->file_lock->lock();
 137         writing_file = record->writing_file > 0 && record->do_audio ? 1 : 0;
 138         if( writing_file ) {
 139                 channels = record->file->asset->channels;
 140                 result = record->file->get_audio_buffer();
 141         }
 142         record->file_lock->unlock();
 143         if( !result ) {
 144                 // when not writing, buffer is only one fragment
 145                 int new_fragment_samples = record->get_fragment_samples();
 146                 if( new_fragment_samples != buffer_samples )
 147                         delete_buffer();
 148                 int record_channels = record->default_asset->channels;
 149                 if( !buffer || buffer_channels != record_channels ) {
 150                         int i = 0;
 151                         Samples **new_buffer = new Samples *[record_channels];
 152                         if( buffer_channels < record_channels ) {
 153                                 for( ; i<buffer_channels; ++i )
 154                                         new_buffer[i] = buffer[i];
 155                                 while( i < record_channels ) // more channels
 156                                         new_buffer[i++] = new Samples(new_fragment_samples);
 157                         }
 158                         else {
 159                                 for( ; i<record_channels; ++i )
 160                                         new_buffer[i] = buffer[i];
 161                                 while( i < buffer_channels ) // fewer channels
 162                                         delete buffer[i++];
 163                         }
 164                         delete buffer;
 165                         buffer = new_buffer;
 166                         buffer_channels = record_channels;
 167                         fragment_samples = new_fragment_samples;
 168                         buffer_samples = new_fragment_samples;
 169                 }
 170                 set_write_buffer_samples(0);
 171                 channels = record->default_asset->channels;
 172                 result = buffer;
 173         }
 174         return result;
 175 }
 176
 177
 178 void RecordAudio::config_update()
 179 {
 180         AudioDevice *adevice = record->adevice;
 181         adevice->stop_audio(0);
 182         adevice->config_update();
 183         int channels = adevice->get_ichannels();
 184         int sample_rate = adevice->get_irate();
 185         int bits = adevice->get_ibits();
 186         Asset *rf_asset = SESSION->recording_format;
 187         Asset *df_asset = record->default_asset;
 188         rf_asset->channels    = df_asset->channels    = channels;
 189         rf_asset->sample_rate = df_asset->sample_rate = sample_rate;
 190         rf_asset->bits        = df_asset->bits        = bits;
 191         adevice->start_recording();
 192 }
 193
 194 void RecordAudio::run()
 195 {
 196         gui->reset_audio();
 197         done = 0;
 198
 199         trigger_lock->lock("RecordAudio::run");
 200
 201         while( !done && !write_result ) {
 202                 if( recording_paused ) {
 203                         set_monitoring(0);
 204                         flush_buffer();
 205                         delete_buffer();
 206                         pause_record_lock->unlock();
 207                         record_paused_lock->lock();
 208                         set_monitoring(record->monitor_audio);
 209                 }
 210                 if( done ) break;
 211                 AudioDevice *adevice = record->adevice;
 212                 if( !input )
 213                         input = get_buffer();
 214                 if( !input || !channels ) {
 215                         printf("RecordAudio::run: no input/channels\n");
 216                         Timer::delay(250);
 217                         continue;
 218                 }
 219                 int over[channels];  double max[channels];
 220                 grab_result = !input ? 1 :
 221                         adevice->read_buffer(input, channels,
 222                                 fragment_samples, over, max, fragment_position);
 223                 if( done ) break;
 224                 if( adevice->config_updated() ) {
 225                         flush_buffer();
 226                         delete_buffer();
 227                         config_update();
 228                         record->update_position();
 229                         set_monitoring(record->monitor_audio);
 230                         record->record_monitor->redraw();
 231                         gui->reset_audio();
 232                         continue;
 233                 }
 234                 if( grab_result ) {
 235                         int samplerate = record->default_asset->sample_rate;
 236                         int delay = samplerate ? (1000 * fragment_samples) / samplerate : 250;
 237                         if( delay > 250 ) delay = 250;
 238                         Timer::delay(delay);
 239                         continue;
 240                 }
 241                 write_buffer(fragment_samples);
 242                 record->current_sample += fragment_samples;
 243                 record->total_samples += fragment_samples;
 244                 if( !record->writing_file || !record->is_behind() )
 245                         gui->update_audio(channels,max,over);
 246                 record->check_batch_complete();
 247         }
 248
 249         if( write_result && !record->default_asset->video_data ) {
 250                 ErrorBox error_box(_(PROGRAM_NAME ": Error"),
 251                         mwindow->gui->get_abs_cursor_x(1),
 252                         mwindow->gui->get_abs_cursor_y(1));
 253                 error_box.create_objects(_("No space left on disk."));
 254                 error_box.run_window();
 255                 done = 1;
 256         }
 257
 258         flush_buffer(); // write last buffer
 259         delete_buffer();
 260 }
 261
 262 int RecordAudio::flush_buffer()
 263 {
 264         record->file_lock->lock();
 265         if( record->writing_file ) {
 266                 record->written_samples += fragment_position;
 267                 if( writing_file ) {
 268                         write_result = (record->file->write_audio_buffer(fragment_position), 0); // HACK
 269                         // defeat audio errors if recording video
 270                         if( record->default_asset->video_data ) write_result = 0;
 271                 }
 272         }
 273         record->file_lock->unlock();
 274         input = 0;
 275         fragment_position = 0;
 276         return write_result;
 277 }
 278
 279 int RecordAudio::write_buffer(int samples)
 280 {
 281         int result = 0;
 282         fragment_position += samples;
 283         if( fragment_position >= write_buffer_samples )
 284                 result = flush_buffer();
 285         return result;
 286 }
 287
 288
 289 void RecordAudio::pause_recording()
 290 {
 291         recording_paused = 1;
 292         record->adevice->interrupt_recording();
 293         pause_record_lock->lock();
 294 }
 295
 296 void RecordAudio::resume_recording()
 297 {
 298         recording_paused = 0;
 299         record->adevice->resume_recording();
 300         record_paused_lock->unlock();
 301 }
 302
 303