libs/ardour/disk_writer.cc

   1 /*
   2     Copyright (C) 2009-2016 Paul Davis
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18 */
  19
  20 #include "pbd/i18n.h"
  21
  22 #include "ardour/analyser.h"
  23 #include "ardour/audioengine.h"
  24 #include "ardour/audiofilesource.h"
  25 #include "ardour/audio_buffer.h"
  26 #include "ardour/audioplaylist.h"
  27 #include "ardour/audioregion.h"
  28 #include "ardour/butler.h"
  29 #include "ardour/debug.h"
  30 #include "ardour/disk_writer.h"
  31 #include "ardour/midi_playlist.h"
  32 #include "ardour/midi_source.h"
  33 #include "ardour/midi_track.h"
  34 #include "ardour/port.h"
  35 #include "ardour/region_factory.h"
  36 #include "ardour/session.h"
  37 #include "ardour/smf_source.h"
  38
  39 using namespace ARDOUR;
  40 using namespace PBD;
  41 using namespace std;
  42
  43 ARDOUR::framecnt_t DiskWriter::_chunk_frames = DiskWriter::default_chunk_frames ();
  44 PBD::Signal0<void> DiskWriter::Overrun;
  45
  46 DiskWriter::DiskWriter (Session& s, string const & str, DiskIOProcessor::Flag f)
  47         : DiskIOProcessor (s, str, f)
  48         , capture_start_frame (0)
  49         , capture_captured (0)
  50         , was_recording (false)
  51         , adjust_capture_position (0)
  52         , _capture_offset (0)
  53         , first_recordable_frame (max_framepos)
  54         , last_recordable_frame (max_framepos)
  55         , last_possibly_recording (0)
  56         , _alignment_style (ExistingMaterial)
  57         , _alignment_choice (Automatic)
  58         , _num_captured_loops (0)
  59         , _accumulated_capture_offset (0)
  60         , _gui_feed_buffer(AudioEngine::instance()->raw_buffer_size (DataType::MIDI))
  61 {
  62         DiskIOProcessor::init ();
  63 }
  64
  65 framecnt_t
  66 DiskWriter::default_chunk_frames ()
  67 {
  68         return 65536;
  69 }
  70
  71 bool
  72 DiskWriter::set_write_source_name (string const & str)
  73 {
  74         _write_source_name = str;
  75         return true;
  76 }
  77
  78 void
  79 DiskWriter::check_record_status (framepos_t transport_frame, bool can_record)
  80 {
  81         int possibly_recording;
  82         int rolling;
  83         int change;
  84         const int transport_rolling = 0x4;
  85         const int track_rec_enabled = 0x2;
  86         const int global_rec_enabled = 0x1;
  87         const int fully_rec_enabled = (transport_rolling|track_rec_enabled|global_rec_enabled);
  88
  89         /* merge together the 3 factors that affect record status, and compute
  90          * what has changed.
  91          */
  92
  93         rolling = _session.transport_speed() != 0.0f;
  94         possibly_recording = (rolling << 2) | ((int)record_enabled() << 1) | (int)can_record;
  95         change = possibly_recording ^ last_possibly_recording;
  96
  97         if (possibly_recording == last_possibly_recording) {
  98                 return;
  99         }
 100
 101         const framecnt_t existing_material_offset = _session.worst_playback_latency();
 102
 103         if (possibly_recording == fully_rec_enabled) {
 104
 105                 if (last_possibly_recording == fully_rec_enabled) {
 106                         return;
 107                 }
 108
 109                 capture_start_frame = _session.transport_frame();
 110                 first_recordable_frame = capture_start_frame + _capture_offset;
 111                 last_recordable_frame = max_framepos;
 112
 113                 DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose ("%1: @ %7 (%9) FRF = %2 CSF = %4 CO = %5, EMO = %6 RD = %8 WOL %10 WTL %11\n",
 114                                                                       name(), first_recordable_frame, last_recordable_frame, capture_start_frame,
 115                                                                       _capture_offset,
 116                                                                       existing_material_offset,
 117                                                                       transport_frame,
 118                                                                       _session.transport_frame(),
 119                                                                       _session.worst_output_latency(),
 120                                                                       _session.worst_track_latency()));
 121
 122
 123                 if (_alignment_style == ExistingMaterial) {
 124                         first_recordable_frame += existing_material_offset;
 125                         DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose ("\tshift FRF by EMO %1\n",
 126                                                                               first_recordable_frame));
 127                 }
 128
 129                 prepare_record_status (capture_start_frame);
 130
 131         } else {
 132
 133                 if (last_possibly_recording == fully_rec_enabled) {
 134
 135                         /* we were recording last time */
 136
 137                         if (change & transport_rolling) {
 138
 139                                 /* transport-change (stopped rolling): last_recordable_frame was set in ::prepare_to_stop(). We
 140                                  * had to set it there because we likely rolled past the stopping point to declick out,
 141                                  * and then backed up.
 142                                  */
 143
 144                         } else {
 145                                 /* punch out */
 146
 147                                 last_recordable_frame = _session.transport_frame() + _capture_offset;
 148
 149                                 if (_alignment_style == ExistingMaterial) {
 150                                         last_recordable_frame += existing_material_offset;
 151                                 }
 152                         }
 153                 }
 154         }
 155
 156         last_possibly_recording = possibly_recording;
 157 }
 158
 159 void
 160 DiskWriter::calculate_record_range (Evoral::OverlapType ot, framepos_t transport_frame, framecnt_t nframes,
 161                                     framecnt_t & rec_nframes, framecnt_t & rec_offset)
 162 {
 163         switch (ot) {
 164         case Evoral::OverlapNone:
 165                 rec_nframes = 0;
 166                 break;
 167
 168         case Evoral::OverlapInternal:
 169                 /*     ----------    recrange
 170                  *       |---|       transrange
 171                  */
 172                 rec_nframes = nframes;
 173                 rec_offset = 0;
 174                 break;
 175
 176         case Evoral::OverlapStart:
 177                 /*    |--------|    recrange
 178                  *  -----|          transrange
 179                  */
 180                 rec_nframes = transport_frame + nframes - first_recordable_frame;
 181                 if (rec_nframes) {
 182                         rec_offset = first_recordable_frame - transport_frame;
 183                 }
 184                 break;
 185
 186         case Evoral::OverlapEnd:
 187                 /*    |--------|    recrange
 188                  *       |--------  transrange
 189                  */
 190                 rec_nframes = last_recordable_frame - transport_frame;
 191                 rec_offset = 0;
 192                 break;
 193
 194         case Evoral::OverlapExternal:
 195                 /*    |--------|    recrange
 196                  *  --------------  transrange
 197                  */
 198                 rec_nframes = last_recordable_frame - first_recordable_frame;
 199                 rec_offset = first_recordable_frame - transport_frame;
 200                 break;
 201         }
 202
 203         DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose ("%1 rec? %2 @ %3 (for %4) FRF %5 LRF %6 : rf %7 @ %8\n",
 204                                                               _name, enum_2_string (ot), transport_frame, nframes,
 205                                                               first_recordable_frame, last_recordable_frame, rec_nframes, rec_offset));
 206 }
 207
 208 void
 209 DiskWriter::prepare_to_stop (framepos_t transport_frame, framepos_t audible_frame)
 210 {
 211         switch (_alignment_style) {
 212         case ExistingMaterial:
 213                 last_recordable_frame = transport_frame + _capture_offset;
 214                 DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose("%1: prepare to stop sets last recordable frame to %2 + %3 = %4\n", _name, transport_frame, _capture_offset, last_recordable_frame));
 215                 break;
 216
 217         case CaptureTime:
 218                 last_recordable_frame = audible_frame; // note that capture_offset is zero
 219                 /* we may already have captured audio before the last_recordable_frame (audible frame),
 220                    so deal with this.
 221                 */
 222                 if (last_recordable_frame > capture_start_frame) {
 223                         capture_captured = min (capture_captured, last_recordable_frame - capture_start_frame);
 224                 }
 225                 DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose("%1: prepare to stop sets last recordable frame to audible frame @ %2\n", _name, audible_frame));
 226                 break;
 227         }
 228
 229 }
 230
 231 void
 232 DiskWriter::engage_record_enable ()
 233 {
 234         g_atomic_int_set (&_record_enabled, 1);
 235 }
 236
 237 void
 238 DiskWriter::disengage_record_enable ()
 239 {
 240         g_atomic_int_set (&_record_enabled, 0);
 241 }
 242
 243 void
 244 DiskWriter::engage_record_safe ()
 245 {
 246         g_atomic_int_set (&_record_safe, 1);
 247 }
 248
 249 void
 250 DiskWriter::disengage_record_safe ()
 251 {
 252         g_atomic_int_set (&_record_safe, 0);
 253 }
 254
 255 /** Get the start position (in session frames) of the nth capture in the current pass */
 256 ARDOUR::framepos_t
 257 DiskWriter::get_capture_start_frame (uint32_t n) const
 258 {
 259         Glib::Threads::Mutex::Lock lm (capture_info_lock);
 260
 261         if (capture_info.size() > n) {
 262                 /* this is a completed capture */
 263                 return capture_info[n]->start;
 264         } else {
 265                 /* this is the currently in-progress capture */
 266                 return capture_start_frame;
 267         }
 268 }
 269
 270 ARDOUR::framecnt_t
 271 DiskWriter::get_captured_frames (uint32_t n) const
 272 {
 273         Glib::Threads::Mutex::Lock lm (capture_info_lock);
 274
 275         if (capture_info.size() > n) {
 276                 /* this is a completed capture */
 277                 return capture_info[n]->frames;
 278         } else {
 279                 /* this is the currently in-progress capture */
 280                 return capture_captured;
 281         }
 282 }
 283
 284 void
 285 DiskWriter::set_input_latency (framecnt_t l)
 286 {
 287         _input_latency = l;
 288 }
 289
 290 void
 291 DiskWriter::set_capture_offset ()
 292 {
 293         switch (_alignment_style) {
 294         case ExistingMaterial:
 295                 _capture_offset = _input_latency;
 296                 break;
 297
 298         case CaptureTime:
 299         default:
 300                 _capture_offset = 0;
 301                 break;
 302         }
 303
 304         DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose ("%1: using IO latency, capture offset set to %2 with style = %3\n", name(), _capture_offset, enum_2_string (_alignment_style)));
 305 }
 306
 307
 308 void
 309 DiskWriter::set_align_style (AlignStyle a, bool force)
 310 {
 311         if (record_enabled() && _session.actively_recording()) {
 312                 return;
 313         }
 314
 315         if ((a != _alignment_style) || force) {
 316                 _alignment_style = a;
 317                 set_capture_offset ();
 318                 AlignmentStyleChanged ();
 319         }
 320 }
 321
 322 void
 323 DiskWriter::set_align_style_from_io ()
 324 {
 325         bool have_physical = false;
 326
 327         if (_alignment_choice != Automatic) {
 328                 return;
 329         }
 330
 331         if (!_route) {
 332                 return;
 333         }
 334
 335         boost::shared_ptr<IO> input = _route->input ();
 336
 337         if (input) {
 338                 uint32_t n = 0;
 339                 vector<string> connections;
 340                 boost::shared_ptr<ChannelList> c = channels.reader();
 341
 342                 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan, ++n) {
 343
 344                         if ((input->nth (n).get()) && (input->nth (n)->get_connections (connections) == 0)) {
 345                                 if (AudioEngine::instance()->port_is_physical (connections[0])) {
 346                                         have_physical = true;
 347                                         break;
 348                                 }
 349                         }
 350
 351                         connections.clear ();
 352                 }
 353         }
 354
 355 #ifdef MIXBUS
 356         // compensate for latency when bouncing from master or mixbus.
 357         // we need to use "ExistingMaterial" to pick up the master bus' latency
 358         // see also Route::direct_feeds_according_to_reality
 359         IOVector ios;
 360         ios.push_back (_io);
 361         if (_session.master_out() && ios.fed_by (_session.master_out()->output())) {
 362                 have_physical = true;
 363         }
 364         for (uint32_t n = 0; n < NUM_MIXBUSES && !have_physical; ++n) {
 365                 if (_session.get_mixbus (n) && ios.fed_by (_session.get_mixbus(n)->output())) {
 366                         have_physical = true;
 367                 }
 368         }
 369 #endif
 370
 371         if (have_physical) {
 372                 set_align_style (ExistingMaterial);
 373         } else {
 374                 set_align_style (CaptureTime);
 375         }
 376 }
 377
 378 void
 379 DiskWriter::set_align_choice (AlignChoice a, bool force)
 380 {
 381         if (record_enabled() && _session.actively_recording()) {
 382                 return;
 383         }
 384
 385         if ((a != _alignment_choice) || force) {
 386                 _alignment_choice = a;
 387
 388                 switch (_alignment_choice) {
 389                         case Automatic:
 390                                 set_align_style_from_io ();
 391                                 break;
 392                         case UseExistingMaterial:
 393                                 set_align_style (ExistingMaterial);
 394                                 break;
 395                         case UseCaptureTime:
 396                                 set_align_style (CaptureTime);
 397                                 break;
 398                 }
 399         }
 400 }
 401
 402 XMLNode&
 403 DiskWriter::state (bool full)
 404 {
 405         XMLNode& node (DiskIOProcessor::state (full));
 406         node.set_property(X_("type"), X_("diskwriter"));
 407         node.set_property (X_("capture-alignment"), enum_2_string (_alignment_choice));
 408         node.set_property (X_("record-safe"), (_record_safe ? X_("yes" : "no")));
 409         return node;
 410 }
 411
 412 int
 413 DiskWriter::set_state (const XMLNode& node, int version)
 414 {
 415         XMLProperty const * prop;
 416
 417         if (DiskIOProcessor::set_state (node, version)) {
 418                 return -1;
 419         }
 420 #if 0 // XXX DISK
 421         if (!node.property (X_("capture-alignment"))) != 0) {
 422                 set_align_choice (AlignChoice (string_2_enum (prop->value(), _alignment_choice)), true);
 423         } else {
 424                 set_align_choice (Automatic, true);
 425         }
 426 #endif
 427
 428         if (!node.get_property (X_("record-safe"), _record_safe)) {
 429                 _record_safe = false;
 430         }
 431
 432         reset_write_sources (false, true);
 433
 434         return 0;
 435 }
 436
 437 void
 438 DiskWriter::non_realtime_locate (framepos_t position)
 439 {
 440         if (_midi_write_source) {
 441                 _midi_write_source->set_timeline_position (position);
 442         }
 443
 444         DiskIOProcessor::non_realtime_locate (position);
 445 }
 446
 447
 448 void
 449 DiskWriter::prepare_record_status(framepos_t capture_start_frame)
 450 {
 451         if (recordable() && destructive()) {
 452                 boost::shared_ptr<ChannelList> c = channels.reader();
 453                 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
 454
 455                         RingBufferNPT<CaptureTransition>::rw_vector transitions;
 456                         (*chan)->capture_transition_buf->get_write_vector (&transitions);
 457
 458                         if (transitions.len[0] > 0) {
 459                                 transitions.buf[0]->type = CaptureStart;
 460                                 transitions.buf[0]->capture_val = capture_start_frame;
 461                                 (*chan)->capture_transition_buf->increment_write_ptr(1);
 462                         } else {
 463                                 // bad!
 464                                 fatal << X_("programming error: capture_transition_buf is full on rec start!  inconceivable!")
 465                                         << endmsg;
 466                         }
 467                 }
 468         }
 469 }
 470
 471
 472 /** Do some record stuff [not described in this comment!]
 473  *
 474  *  Also:
 475  *    - Setup playback_distance with the nframes, or nframes adjusted
 476  *      for current varispeed, if appropriate.
 477  *    - Setup current_playback_buffer in each ChannelInfo to point to data
 478  *      that someone can read playback_distance worth of data from.
 479  */
 480 void
 481 DiskWriter::run (BufferSet& bufs, framepos_t start_frame, framepos_t end_frame,
 482                  double speed, pframes_t nframes, bool result_required)
 483 {
 484         uint32_t n;
 485         boost::shared_ptr<ChannelList> c = channels.reader();
 486         ChannelList::iterator chan;
 487         framecnt_t rec_offset = 0;
 488         framecnt_t rec_nframes = 0;
 489         bool nominally_recording;
 490         bool re = record_enabled ();
 491         bool can_record = _session.actively_recording ();
 492
 493         _need_butler = false;
 494
 495         check_record_status (start_frame, can_record);
 496
 497         if (nframes == 0) {
 498                 return;
 499         }
 500
 501         nominally_recording = (can_record && re);
 502
 503         // Safeguard against situations where process() goes haywire when autopunching
 504         // and last_recordable_frame < first_recordable_frame
 505
 506         if (last_recordable_frame < first_recordable_frame) {
 507                 last_recordable_frame = max_framepos;
 508         }
 509
 510         const Location* const loop_loc    = loop_location;
 511         framepos_t            loop_start  = 0;
 512         framepos_t            loop_end    = 0;
 513         framepos_t            loop_length = 0;
 514
 515         if (loop_loc) {
 516                 get_location_times (loop_loc, &loop_start, &loop_end, &loop_length);
 517         }
 518
 519         adjust_capture_position = 0;
 520
 521         if (nominally_recording || (re && was_recording && _session.get_record_enabled() && (_session.config.get_punch_in() || _session.preroll_record_punch_enabled()))) {
 522
 523                 Evoral::OverlapType ot = Evoral::coverage (first_recordable_frame, last_recordable_frame, start_frame, end_frame);
 524                 // XXX should this be transport_frame + nframes - 1 ? coverage() expects its parameter ranges to include their end points
 525                 // XXX also, first_recordable_frame & last_recordable_frame may both be == max_framepos: coverage() will return OverlapNone in that case. Is thak OK?
 526                 calculate_record_range (ot, start_frame, nframes, rec_nframes, rec_offset);
 527
 528                 DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose ("%1: this time record %2 of %3 frames, offset %4\n", _name, rec_nframes, nframes, rec_offset));
 529
 530                 if (rec_nframes && !was_recording) {
 531                         capture_captured = 0;
 532
 533                         if (loop_loc) {
 534                                 /* Loop recording, so pretend the capture started at the loop
 535                                    start rgardless of what time it is now, so the source starts
 536                                    at the loop start and can handle time wrapping around.
 537                                    Otherwise, start the source right now as usual.
 538                                 */
 539                                 capture_captured    = start_frame - loop_start;
 540                                 capture_start_frame = loop_start;
 541                         }
 542
 543                         if (_midi_write_source) {
 544                                 _midi_write_source->mark_write_starting_now (capture_start_frame, capture_captured, loop_length);
 545                         }
 546
 547                         g_atomic_int_set(const_cast<gint*> (&_frames_pending_write), 0);
 548                         g_atomic_int_set(const_cast<gint*> (&_num_captured_loops), 0);
 549
 550                         was_recording = true;
 551
 552                 }
 553
 554                 /* For audio: not writing frames to the capture ringbuffer offsets
 555                  * the recording. For midi: we need to keep track of the record range
 556                  * and subtract the accumulated difference from the event time.
 557                  */
 558                 if (rec_nframes) {
 559                         _accumulated_capture_offset += rec_offset;
 560                 } else {
 561                         _accumulated_capture_offset += nframes;
 562                 }
 563
 564         }
 565
 566         if (can_record && !_last_capture_sources.empty()) {
 567                 _last_capture_sources.clear ();
 568         }
 569
 570         if (rec_nframes) {
 571
 572                 /* AUDIO */
 573
 574                 const size_t n_buffers = bufs.count().n_audio();
 575
 576                 for (n = 0; chan != c->end(); ++chan, ++n) {
 577
 578                         ChannelInfo* chaninfo (*chan);
 579                         AudioBuffer& buf (bufs.get_audio (n%n_buffers));
 580
 581                         chaninfo->buf->get_write_vector (&chaninfo->rw_vector);
 582
 583                         if (rec_nframes <= (framecnt_t) chaninfo->rw_vector.len[0]) {
 584
 585                                 Sample *incoming = buf.data (rec_offset);
 586                                 memcpy (chaninfo->rw_vector.buf[0], incoming, sizeof (Sample) * rec_nframes);
 587
 588                         } else {
 589
 590                                 framecnt_t total = chaninfo->rw_vector.len[0] + chaninfo->rw_vector.len[1];
 591
 592                                 if (rec_nframes > total) {
 593                                         DEBUG_TRACE (DEBUG::Butler, string_compose ("%1 overrun in %2, rec_nframes = %3 total space = %4\n",
 594                                                                                     DEBUG_THREAD_SELF, name(), rec_nframes, total));
 595                                         Overrun ();
 596                                         return;
 597                                 }
 598
 599                                 Sample *incoming = buf.data (rec_offset);
 600                                 framecnt_t first = chaninfo->rw_vector.len[0];
 601
 602                                 memcpy (chaninfo->rw_vector.buf[0], incoming, sizeof (Sample) * first);
 603                                 memcpy (chaninfo->rw_vector.buf[1], incoming + first, sizeof (Sample) * (rec_nframes - first));
 604                         }
 605
 606                         chaninfo->buf->increment_write_ptr (rec_nframes);
 607
 608                 }
 609
 610                 /* MIDI */
 611
 612                 // Pump entire port buffer into the ring buffer (TODO: split cycles?)
 613                 MidiBuffer& buf    = bufs.get_midi (0);
 614                 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack>(_route);
 615                 MidiChannelFilter* filter = mt ? &mt->capture_filter() : 0;
 616
 617                 for (MidiBuffer::iterator i = buf.begin(); i != buf.end(); ++i) {
 618                         Evoral::Event<MidiBuffer::TimeType> ev(*i, false);
 619                         if (ev.time() + rec_offset > rec_nframes) {
 620                                 break;
 621                         }
 622 #ifndef NDEBUG
 623                         if (DEBUG_ENABLED(DEBUG::MidiIO)) {
 624                                 const uint8_t* __data = ev.buffer();
 625                                 DEBUG_STR_DECL(a);
 626                                 DEBUG_STR_APPEND(a, string_compose ("mididiskstream %1 capture event @ %2 + %3 sz %4 ", this, ev.time(), start_frame, ev.size()));
 627                                 for (size_t i=0; i < ev.size(); ++i) {
 628                                         DEBUG_STR_APPEND(a,hex);
 629                                         DEBUG_STR_APPEND(a,"0x");
 630                                         DEBUG_STR_APPEND(a,(int)__data[i]);
 631                                         DEBUG_STR_APPEND(a,' ');
 632                                 }
 633                                 DEBUG_STR_APPEND(a,'\n');
 634                                 DEBUG_TRACE (DEBUG::MidiIO, DEBUG_STR(a).str());
 635                         }
 636 #endif
 637                         /* Write events to the capture buffer in frames from session start,
 638                            but ignoring looping so event time progresses monotonically.
 639                            The source knows the loop length so it knows exactly where the
 640                            event occurs in the series of recorded loops and can implement
 641                            any desirable behaviour.  We don't want to send event with
 642                            transport time here since that way the source can not
 643                            reconstruct their actual time; future clever MIDI looping should
 644                            probably be implemented in the source instead of here.
 645                         */
 646                         const framecnt_t loop_offset = _num_captured_loops * loop_length;
 647                         const framepos_t event_time = start_frame + loop_offset - _accumulated_capture_offset + ev.time();
 648                         if (event_time < 0 || event_time < first_recordable_frame) {
 649                                 /* Event out of range, skip */
 650                                 continue;
 651                         }
 652
 653                         if (!filter || !filter->filter(ev.buffer(), ev.size())) {
 654                                 _midi_buf->write (event_time, ev.event_type(), ev.size(), ev.buffer());
 655                         }
 656                 }
 657                 g_atomic_int_add(const_cast<gint*>(&_frames_pending_write), nframes);
 658
 659                 if (buf.size() != 0) {
 660                         Glib::Threads::Mutex::Lock lm (_gui_feed_buffer_mutex, Glib::Threads::TRY_LOCK);
 661
 662                         if (lm.locked ()) {
 663                                 /* Copy this data into our GUI feed buffer and tell the GUI
 664                                    that it can read it if it likes.
 665                                 */
 666                                 _gui_feed_buffer.clear ();
 667
 668                                 for (MidiBuffer::iterator i = buf.begin(); i != buf.end(); ++i) {
 669                                         /* This may fail if buf is larger than _gui_feed_buffer, but it's not really
 670                                            the end of the world if it does.
 671                                         */
 672                                         _gui_feed_buffer.push_back ((*i).time() + start_frame, (*i).size(), (*i).buffer());
 673                                 }
 674                         }
 675
 676                         DataRecorded (_midi_write_source); /* EMIT SIGNAL */
 677                 }
 678
 679                 capture_captured += rec_nframes;
 680                 DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose ("%1 now captured %2 (by %3)\n", name(), capture_captured, rec_nframes));
 681
 682         } else {
 683
 684                 /* not recording this time, but perhaps we were before .. */
 685
 686                 if (was_recording) {
 687                         finish_capture (c);
 688                         _accumulated_capture_offset = 0;
 689                 }
 690         }
 691
 692         /* AUDIO BUTLER REQUIRED CODE */
 693
 694         if (_playlists[DataType::AUDIO] && !c->empty()) {
 695                 if (((framecnt_t) c->front()->buf->read_space() >= _chunk_frames)) {
 696                         _need_butler = true;
 697                 }
 698         }
 699
 700         /* MIDI BUTLER REQUIRED CODE */
 701
 702         if (_playlists[DataType::MIDI] && (_midi_buf->read_space() < _midi_buf->bufsize() / 2)) {
 703                 _need_butler = true;
 704         }
 705
 706         DEBUG_TRACE (DEBUG::Butler, string_compose ("%1 writer run, needs butler = %2\n", name(), _need_butler));
 707 }
 708
 709 void
 710 DiskWriter::finish_capture (boost::shared_ptr<ChannelList> c)
 711 {
 712         was_recording = false;
 713         first_recordable_frame = max_framepos;
 714         last_recordable_frame = max_framepos;
 715
 716         if (capture_captured == 0) {
 717                 return;
 718         }
 719
 720         if (recordable() && destructive()) {
 721                 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
 722
 723                         RingBufferNPT<CaptureTransition>::rw_vector transvec;
 724                         (*chan)->capture_transition_buf->get_write_vector(&transvec);
 725
 726                         if (transvec.len[0] > 0) {
 727                                 transvec.buf[0]->type = CaptureEnd;
 728                                 transvec.buf[0]->capture_val = capture_captured;
 729                                 (*chan)->capture_transition_buf->increment_write_ptr(1);
 730                         }
 731                         else {
 732                                 // bad!
 733                                 fatal << string_compose (_("programmer error: %1"), X_("capture_transition_buf is full when stopping record!  inconceivable!")) << endmsg;
 734                         }
 735                 }
 736         }
 737
 738
 739         CaptureInfo* ci = new CaptureInfo;
 740
 741         ci->start =  capture_start_frame;
 742         ci->frames = capture_captured;
 743
 744         /* XXX theoretical race condition here. Need atomic exchange ?
 745            However, the circumstances when this is called right
 746            now (either on record-disable or transport_stopped)
 747            mean that no actual race exists. I think ...
 748            We now have a capture_info_lock, but it is only to be used
 749            to synchronize in the transport_stop and the capture info
 750            accessors, so that invalidation will not occur (both non-realtime).
 751         */
 752
 753         DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose ("Finish capture, add new CI, %1 + %2\n", ci->start, ci->frames));
 754
 755         capture_info.push_back (ci);
 756         capture_captured = 0;
 757
 758         /* now we've finished a capture, reset first_recordable_frame for next time */
 759         first_recordable_frame = max_framepos;
 760 }
 761
 762 void
 763 DiskWriter::set_record_enabled (bool yn)
 764 {
 765         if (!recordable() || !_session.record_enabling_legal() || record_safe ()) {
 766                 return;
 767         }
 768
 769         /* can't rec-enable in destructive mode if transport is before start */
 770
 771         if (destructive() && yn && _session.transport_frame() < _session.current_start_frame()) {
 772                 return;
 773         }
 774
 775         /* yes, i know that this not proof against race conditions, but its
 776            good enough. i think.
 777         */
 778
 779         if (record_enabled() != yn) {
 780                 if (yn) {
 781                         engage_record_enable ();
 782                 } else {
 783                         disengage_record_enable ();
 784                 }
 785
 786                 RecordEnableChanged (); /* EMIT SIGNAL */
 787         }
 788 }
 789
 790 void
 791 DiskWriter::set_record_safe (bool yn)
 792 {
 793         if (!recordable() || !_session.record_enabling_legal() || channels.reader()->empty()) {
 794                 return;
 795         }
 796
 797         /* can't rec-safe in destructive mode if transport is before start ????
 798          REQUIRES REVIEW */
 799
 800         if (destructive() && yn && _session.transport_frame() < _session.current_start_frame()) {
 801                 return;
 802         }
 803
 804         /* yes, i know that this not proof against race conditions, but its
 805          good enough. i think.
 806          */
 807
 808         if (record_safe () != yn) {
 809                 if (yn) {
 810                         engage_record_safe ();
 811                 } else {
 812                         disengage_record_safe ();
 813                 }
 814
 815                 RecordSafeChanged (); /* EMIT SIGNAL */
 816         }
 817 }
 818
 819 bool
 820 DiskWriter::prep_record_enable ()
 821 {
 822         if (!recordable() || !_session.record_enabling_legal() || channels.reader()->empty() || record_safe ()) { // REQUIRES REVIEW "|| record_safe ()"
 823                 return false;
 824         }
 825
 826         /* can't rec-enable in destructive mode if transport is before start */
 827
 828         if (destructive() && _session.transport_frame() < _session.current_start_frame()) {
 829                 return false;
 830         }
 831
 832         boost::shared_ptr<ChannelList> c = channels.reader();
 833
 834         capturing_sources.clear ();
 835
 836         for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
 837                 capturing_sources.push_back ((*chan)->write_source);
 838                 Source::Lock lock((*chan)->write_source->mutex());
 839                 (*chan)->write_source->mark_streaming_write_started (lock);
 840         }
 841
 842         return true;
 843 }
 844
 845 bool
 846 DiskWriter::prep_record_disable ()
 847 {
 848         capturing_sources.clear ();
 849         return true;
 850 }
 851
 852 float
 853 DiskWriter::buffer_load () const
 854 {
 855         boost::shared_ptr<ChannelList> c = channels.reader();
 856
 857         if (c->empty ()) {
 858                 return 1.0;
 859         }
 860
 861         return (float) ((double) c->front()->buf->write_space()/
 862                         (double) c->front()->buf->bufsize());
 863 }
 864
 865 void
 866 DiskWriter::set_note_mode (NoteMode m)
 867 {
 868         _note_mode = m;
 869
 870         boost::shared_ptr<MidiPlaylist> mp = boost::dynamic_pointer_cast<MidiPlaylist> (_playlists[DataType::MIDI]);
 871
 872         if (mp) {
 873                 mp->set_note_mode (m);
 874         }
 875
 876         if (_midi_write_source && _midi_write_source->model())
 877                 _midi_write_source->model()->set_note_mode(m);
 878 }
 879
 880 int
 881 DiskWriter::seek (framepos_t frame, bool complete_refill)
 882 {
 883         uint32_t n;
 884         ChannelList::iterator chan;
 885         boost::shared_ptr<ChannelList> c = channels.reader();
 886
 887         for (n = 0, chan = c->begin(); chan != c->end(); ++chan, ++n) {
 888                 (*chan)->buf->reset ();
 889         }
 890
 891         _midi_buf->reset ();
 892         g_atomic_int_set(&_frames_read_from_ringbuffer, 0);
 893         g_atomic_int_set(&_frames_written_to_ringbuffer, 0);
 894
 895         /* can't rec-enable in destructive mode if transport is before start */
 896
 897         if (destructive() && record_enabled() && frame < _session.current_start_frame()) {
 898                 disengage_record_enable ();
 899         }
 900
 901         playback_sample = frame;
 902         file_frame = frame;
 903
 904         return 0;
 905 }
 906
 907 int
 908 DiskWriter::do_flush (RunContext ctxt, bool force_flush)
 909 {
 910         uint32_t to_write;
 911         int32_t ret = 0;
 912         RingBufferNPT<Sample>::rw_vector vector;
 913         RingBufferNPT<CaptureTransition>::rw_vector transvec;
 914         framecnt_t total;
 915
 916         transvec.buf[0] = 0;
 917         transvec.buf[1] = 0;
 918         vector.buf[0] = 0;
 919         vector.buf[1] = 0;
 920
 921         boost::shared_ptr<ChannelList> c = channels.reader();
 922         for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
 923
 924                 (*chan)->buf->get_read_vector (&vector);
 925
 926                 total = vector.len[0] + vector.len[1];
 927
 928                 if (total == 0 || (total < _chunk_frames && !force_flush && was_recording)) {
 929                         goto out;
 930                 }
 931
 932                 /* if there are 2+ chunks of disk i/o possible for
 933                    this track, let the caller know so that it can arrange
 934                    for us to be called again, ASAP.
 935
 936                    if we are forcing a flush, then if there is* any* extra
 937                    work, let the caller know.
 938
 939                    if we are no longer recording and there is any extra work,
 940                    let the caller know too.
 941                 */
 942
 943                 if (total >= 2 * _chunk_frames || ((force_flush || !was_recording) && total > _chunk_frames)) {
 944                         ret = 1;
 945                 }
 946
 947                 to_write = min (_chunk_frames, (framecnt_t) vector.len[0]);
 948
 949                 // check the transition buffer when recording destructive
 950                 // important that we get this after the capture buf
 951
 952                 if (destructive()) {
 953                         (*chan)->capture_transition_buf->get_read_vector(&transvec);
 954                         size_t transcount = transvec.len[0] + transvec.len[1];
 955                         size_t ti;
 956
 957                         for (ti=0; ti < transcount; ++ti) {
 958                                 CaptureTransition & captrans = (ti < transvec.len[0]) ? transvec.buf[0][ti] : transvec.buf[1][ti-transvec.len[0]];
 959
 960                                 if (captrans.type == CaptureStart) {
 961                                         // by definition, the first data we got above represents the given capture pos
 962
 963                                         (*chan)->write_source->mark_capture_start (captrans.capture_val);
 964                                         (*chan)->curr_capture_cnt = 0;
 965
 966                                 } else if (captrans.type == CaptureEnd) {
 967
 968                                         // capture end, the capture_val represents total frames in capture
 969
 970                                         if (captrans.capture_val <= (*chan)->curr_capture_cnt + to_write) {
 971
 972                                                 // shorten to make the write a perfect fit
 973                                                 uint32_t nto_write = (captrans.capture_val - (*chan)->curr_capture_cnt);
 974
 975                                                 if (nto_write < to_write) {
 976                                                         ret = 1; // should we?
 977                                                 }
 978                                                 to_write = nto_write;
 979
 980                                                 (*chan)->write_source->mark_capture_end ();
 981
 982                                                 // increment past this transition, but go no further
 983                                                 ++ti;
 984                                                 break;
 985                                         }
 986                                         else {
 987                                                 // actually ends just beyond this chunk, so force more work
 988                                                 ret = 1;
 989                                                 break;
 990                                         }
 991                                 }
 992                         }
 993
 994                         if (ti > 0) {
 995                                 (*chan)->capture_transition_buf->increment_read_ptr(ti);
 996                         }
 997                 }
 998
 999                 if ((!(*chan)->write_source) || (*chan)->write_source->write (vector.buf[0], to_write) != to_write) {
1000                         error << string_compose(_("AudioDiskstream %1: cannot write to disk"), id()) << endmsg;
1001                         return -1;
1002                 }
1003
1004                 (*chan)->buf->increment_read_ptr (to_write);
1005                 (*chan)->curr_capture_cnt += to_write;
1006
1007                 if ((to_write == vector.len[0]) && (total > to_write) && (to_write < _chunk_frames) && !destructive()) {
1008
1009                         /* we wrote all of vector.len[0] but it wasn't an entire
1010                            disk_write_chunk_frames of data, so arrange for some part
1011                            of vector.len[1] to be flushed to disk as well.
1012                         */
1013
1014                         to_write = min ((framecnt_t)(_chunk_frames - to_write), (framecnt_t) vector.len[1]);
1015
1016                         DEBUG_TRACE (DEBUG::Butler, string_compose ("%1 additional write of %2\n", name(), to_write));
1017
1018                         if ((*chan)->write_source->write (vector.buf[1], to_write) != to_write) {
1019                                 error << string_compose(_("AudioDiskstream %1: cannot write to disk"), id()) << endmsg;
1020                                 return -1;
1021                         }
1022
1023                         (*chan)->buf->increment_read_ptr (to_write);
1024                         (*chan)->curr_capture_cnt += to_write;
1025                 }
1026         }
1027
1028         /* MIDI*/
1029
1030   out:
1031         return ret;
1032
1033 }
1034
1035 void
1036 DiskWriter::reset_write_sources (bool mark_write_complete, bool /*force*/)
1037 {
1038         ChannelList::iterator chan;
1039         boost::shared_ptr<ChannelList> c = channels.reader();
1040         uint32_t n;
1041
1042         if (!_session.writable() || !recordable()) {
1043                 return;
1044         }
1045
1046         capturing_sources.clear ();
1047
1048         for (chan = c->begin(), n = 0; chan != c->end(); ++chan, ++n) {
1049
1050                 if (!destructive()) {
1051
1052                         if ((*chan)->write_source) {
1053
1054                                 if (mark_write_complete) {
1055                                         Source::Lock lock((*chan)->write_source->mutex());
1056                                         (*chan)->write_source->mark_streaming_write_completed (lock);
1057                                         (*chan)->write_source->done_with_peakfile_writes ();
1058                                 }
1059
1060                                 if ((*chan)->write_source->removable()) {
1061                                         (*chan)->write_source->mark_for_remove ();
1062                                         (*chan)->write_source->drop_references ();
1063                                 }
1064
1065                                 (*chan)->write_source.reset ();
1066                         }
1067
1068                         use_new_write_source (DataType::AUDIO, n);
1069
1070                         if (record_enabled()) {
1071                                 capturing_sources.push_back ((*chan)->write_source);
1072                         }
1073
1074                 } else {
1075
1076                         if ((*chan)->write_source == 0) {
1077                                 use_new_write_source (DataType::AUDIO, n);
1078                         }
1079                 }
1080         }
1081
1082         if (_midi_write_source) {
1083                 if (mark_write_complete) {
1084                         Source::Lock lm(_midi_write_source->mutex());
1085                         _midi_write_source->mark_streaming_write_completed (lm);
1086                 }
1087
1088                 use_new_write_source (DataType::MIDI);
1089
1090                 if (destructive() && !c->empty ()) {
1091
1092                         /* we now have all our write sources set up, so create the
1093                            playlist's single region.
1094                         */
1095
1096                         if (_playlists[DataType::MIDI]->empty()) {
1097                                 setup_destructive_playlist ();
1098                         }
1099                 }
1100         }
1101 }
1102
1103 int
1104 DiskWriter::use_new_write_source (DataType dt, uint32_t n)
1105 {
1106         if (dt == DataType::MIDI) {
1107
1108                 _accumulated_capture_offset = 0;
1109                 _midi_write_source.reset();
1110
1111                 try {
1112                         _midi_write_source = boost::dynamic_pointer_cast<SMFSource>(
1113                                 _session.create_midi_source_for_session (write_source_name ()));
1114
1115                         if (!_midi_write_source) {
1116                                 throw failed_constructor();
1117                         }
1118                 }
1119
1120                 catch (failed_constructor &err) {
1121                         error << string_compose (_("%1:%2 new capture file not initialized correctly"), _name, n) << endmsg;
1122                         _midi_write_source.reset();
1123                         return -1;
1124                 }
1125         } else {
1126                 boost::shared_ptr<ChannelList> c = channels.reader();
1127
1128                 if (!recordable()) {
1129                         return 1;
1130                 }
1131
1132                 if (n >= c->size()) {
1133                         error << string_compose (_("AudioDiskstream: channel %1 out of range"), n) << endmsg;
1134                         return -1;
1135                 }
1136
1137                 ChannelInfo* chan = (*c)[n];
1138
1139                 try {
1140                         if ((chan->write_source = _session.create_audio_source_for_session (
1141                                      c->size(), write_source_name(), n, destructive())) == 0) {
1142                                 throw failed_constructor();
1143                         }
1144                 }
1145
1146                 catch (failed_constructor &err) {
1147                         error << string_compose (_("%1:%2 new capture file not initialized correctly"), _name, n) << endmsg;
1148                         chan->write_source.reset ();
1149                         return -1;
1150                 }
1151
1152                 /* do not remove destructive files even if they are empty */
1153
1154                 chan->write_source->set_allow_remove_if_empty (!destructive());
1155         }
1156
1157         return 0;
1158 }
1159
1160 void
1161 DiskWriter::transport_stopped_wallclock (struct tm& when, time_t twhen, bool abort_capture)
1162 {
1163         uint32_t buffer_position;
1164         bool more_work = true;
1165         int err = 0;
1166         boost::shared_ptr<AudioRegion> region;
1167         framecnt_t total_capture;
1168         SourceList srcs;
1169         SourceList::iterator src;
1170         ChannelList::iterator chan;
1171         vector<CaptureInfo*>::iterator ci;
1172         boost::shared_ptr<ChannelList> c = channels.reader();
1173         uint32_t n = 0;
1174         bool mark_write_completed = false;
1175
1176         finish_capture (c);
1177
1178         boost::shared_ptr<AudioPlaylist> pl = boost::dynamic_pointer_cast<AudioPlaylist> (_playlists[DataType::AUDIO]);
1179
1180         /* butler is already stopped, but there may be work to do
1181            to flush remaining data to disk.
1182         */
1183
1184         while (more_work && !err) {
1185                 switch (do_flush (TransportContext, true)) {
1186                 case 0:
1187                         more_work = false;
1188                         break;
1189                 case 1:
1190                         break;
1191                 case -1:
1192                         error << string_compose(_("AudioDiskstream \"%1\": cannot flush captured data to disk!"), _name) << endmsg;
1193                         err++;
1194                 }
1195         }
1196
1197         /* XXX is there anything we can do if err != 0 ? */
1198         Glib::Threads::Mutex::Lock lm (capture_info_lock);
1199
1200         if (capture_info.empty()) {
1201                 return;
1202         }
1203
1204         if (abort_capture) {
1205
1206                 if (destructive()) {
1207                         goto outout;
1208                 }
1209
1210                 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1211
1212                         if ((*chan)->write_source) {
1213
1214                                 (*chan)->write_source->mark_for_remove ();
1215                                 (*chan)->write_source->drop_references ();
1216                                 (*chan)->write_source.reset ();
1217                         }
1218
1219                         /* new source set up in "out" below */
1220                 }
1221
1222                 goto out;
1223         }
1224
1225         for (total_capture = 0, ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1226                 total_capture += (*ci)->frames;
1227         }
1228
1229         /* figure out the name for this take */
1230
1231         for (n = 0, chan = c->begin(); chan != c->end(); ++chan, ++n) {
1232
1233                 boost::shared_ptr<AudioFileSource> s = (*chan)->write_source;
1234
1235                 if (s) {
1236                         srcs.push_back (s);
1237                         s->update_header (capture_info.front()->start, when, twhen);
1238                         s->set_captured_for (_name.val());
1239                         s->mark_immutable ();
1240
1241                         if (Config->get_auto_analyse_audio()) {
1242                                 Analyser::queue_source_for_analysis (s, true);
1243                         }
1244
1245                         DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose ("newly captured source %1 length %2\n", s->path(), s->length (0)));
1246                 }
1247         }
1248
1249         if (!pl) {
1250                 goto midi;
1251         }
1252
1253         /* destructive tracks have a single, never changing region */
1254
1255         if (destructive()) {
1256
1257                 /* send a signal that any UI can pick up to do the right thing. there is
1258                    a small problem here in that a UI may need the peak data to be ready
1259                    for the data that was recorded and this isn't interlocked with that
1260                    process. this problem is deferred to the UI.
1261                  */
1262
1263                 pl->LayeringChanged(); // XXX this may not get the UI to do the right thing
1264
1265         } else {
1266
1267                 string whole_file_region_name;
1268                 whole_file_region_name = region_name_from_path (c->front()->write_source->name(), true);
1269
1270                 /* Register a new region with the Session that
1271                    describes the entire source. Do this first
1272                    so that any sub-regions will obviously be
1273                    children of this one (later!)
1274                 */
1275
1276                 try {
1277                         PropertyList plist;
1278
1279                         plist.add (Properties::start, c->front()->write_source->last_capture_start_frame());
1280                         plist.add (Properties::length, total_capture);
1281                         plist.add (Properties::name, whole_file_region_name);
1282                         boost::shared_ptr<Region> rx (RegionFactory::create (srcs, plist));
1283                         rx->set_automatic (true);
1284                         rx->set_whole_file (true);
1285
1286                         region = boost::dynamic_pointer_cast<AudioRegion> (rx);
1287                         region->special_set_position (capture_info.front()->start);
1288                 }
1289
1290
1291                 catch (failed_constructor& err) {
1292                         error << string_compose(_("%1: could not create region for complete audio file"), _name) << endmsg;
1293                         /* XXX what now? */
1294                 }
1295
1296                 _last_capture_sources.insert (_last_capture_sources.end(), srcs.begin(), srcs.end());
1297
1298                 pl->clear_changes ();
1299                 pl->set_capture_insertion_in_progress (true);
1300                 pl->freeze ();
1301
1302                 const framepos_t preroll_off = _session.preroll_record_trim_len ();
1303                 for (buffer_position = c->front()->write_source->last_capture_start_frame(), ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1304
1305                         string region_name;
1306
1307                         RegionFactory::region_name (region_name, whole_file_region_name, false);
1308
1309                         DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose ("%1 capture bufpos %5 start @ %2 length %3 add new region %4\n",
1310                                                                               _name, (*ci)->start, (*ci)->frames, region_name, buffer_position));
1311
1312                         try {
1313
1314                                 PropertyList plist;
1315
1316                                 plist.add (Properties::start, buffer_position);
1317                                 plist.add (Properties::length, (*ci)->frames);
1318                                 plist.add (Properties::name, region_name);
1319
1320                                 boost::shared_ptr<Region> rx (RegionFactory::create (srcs, plist));
1321                                 region = boost::dynamic_pointer_cast<AudioRegion> (rx);
1322                                 if (preroll_off > 0) {
1323                                         region->trim_front (buffer_position + preroll_off);
1324                                 }
1325                         }
1326
1327                         catch (failed_constructor& err) {
1328                                 error << _("AudioDiskstream: could not create region for captured audio!") << endmsg;
1329                                 continue; /* XXX is this OK? */
1330                         }
1331
1332                         i_am_the_modifier++;
1333
1334                         pl->add_region (region, (*ci)->start + preroll_off, 1, non_layered());
1335                         pl->set_layer (region, DBL_MAX);
1336                         i_am_the_modifier--;
1337
1338                         buffer_position += (*ci)->frames;
1339                 }
1340
1341                 pl->thaw ();
1342                 pl->set_capture_insertion_in_progress (false);
1343                 _session.add_command (new StatefulDiffCommand (pl));
1344         }
1345
1346         mark_write_completed = true;
1347
1348   out:
1349         reset_write_sources (mark_write_completed);
1350
1351   outout:
1352
1353         for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1354                 delete *ci;
1355         }
1356
1357         capture_info.clear ();
1358         capture_start_frame = 0;
1359
1360   midi:
1361         return;
1362 }
1363
1364 #if 0 // MIDI PART
1365 void
1366 DiskWriter::transport_stopped_wallclock (struct tm& /*when*/, time_t /*twhen*/, bool abort_capture)
1367 {
1368         bool more_work = true;
1369         int err = 0;
1370         boost::shared_ptr<MidiRegion> region;
1371         MidiRegion::SourceList srcs;
1372         MidiRegion::SourceList::iterator src;
1373         vector<CaptureInfo*>::iterator ci;
1374
1375         finish_capture ();
1376
1377         /* butler is already stopped, but there may be work to do
1378            to flush remaining data to disk.
1379            */
1380
1381         while (more_work && !err) {
1382                 switch (do_flush (TransportContext, true)) {
1383                 case 0:
1384                         more_work = false;
1385                         break;
1386                 case 1:
1387                         break;
1388                 case -1:
1389                         error << string_compose(_("MidiDiskstream \"%1\": cannot flush captured data to disk!"), _name) << endmsg;
1390                         err++;
1391                 }
1392         }
1393
1394         /* XXX is there anything we can do if err != 0 ? */
1395         Glib::Threads::Mutex::Lock lm (capture_info_lock);
1396
1397         if (capture_info.empty()) {
1398                 goto no_capture_stuff_to_do;
1399         }
1400
1401         if (abort_capture) {
1402
1403                 if (_write_source) {
1404                         _write_source->mark_for_remove ();
1405                         _write_source->drop_references ();
1406                         _write_source.reset();
1407                 }
1408
1409                 /* new source set up in "out" below */
1410
1411         } else {
1412
1413                 framecnt_t total_capture = 0;
1414                 for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1415                         total_capture += (*ci)->frames;
1416                 }
1417
1418                 if (_write_source->length (capture_info.front()->start) != 0) {
1419
1420                         /* phew, we have data */
1421
1422                         Source::Lock source_lock(_write_source->mutex());
1423
1424                         /* figure out the name for this take */
1425
1426                         srcs.push_back (_write_source);
1427
1428                         _write_source->set_timeline_position (capture_info.front()->start);
1429                         _write_source->set_captured_for (_name);
1430
1431                         /* set length in beats to entire capture length */
1432
1433                         BeatsFramesConverter converter (_session.tempo_map(), capture_info.front()->start);
1434                         const Evoral::Beats total_capture_beats = converter.from (total_capture);
1435                         _write_source->set_length_beats (total_capture_beats);
1436
1437                         /* flush to disk: this step differs from the audio path,
1438                            where all the data is already on disk.
1439                         */
1440
1441                         _write_source->mark_midi_streaming_write_completed (source_lock, Evoral::Sequence<Evoral::Beats>::ResolveStuckNotes, total_capture_beats);
1442
1443                         /* we will want to be able to keep (over)writing the source
1444                            but we don't want it to be removable. this also differs
1445                            from the audio situation, where the source at this point
1446                            must be considered immutable. luckily, we can rely on
1447                            MidiSource::mark_streaming_write_completed() to have
1448                            already done the necessary work for that.
1449                         */
1450
1451                         string whole_file_region_name;
1452                         whole_file_region_name = region_name_from_path (_write_source->name(), true);
1453
1454                         /* Register a new region with the Session that
1455                            describes the entire source. Do this first
1456                            so that any sub-regions will obviously be
1457                            children of this one (later!)
1458                         */
1459
1460                         try {
1461                                 PropertyList plist;
1462
1463                                 plist.add (Properties::name, whole_file_region_name);
1464                                 plist.add (Properties::whole_file, true);
1465                                 plist.add (Properties::automatic, true);
1466                                 plist.add (Properties::start, 0);
1467                                 plist.add (Properties::length, total_capture);
1468                                 plist.add (Properties::layer, 0);
1469
1470                                 boost::shared_ptr<Region> rx (RegionFactory::create (srcs, plist));
1471
1472                                 region = boost::dynamic_pointer_cast<MidiRegion> (rx);
1473                                 region->special_set_position (capture_info.front()->start);
1474                         }
1475
1476
1477                         catch (failed_constructor& err) {
1478                                 error << string_compose(_("%1: could not create region for complete midi file"), _name) << endmsg;
1479                                 /* XXX what now? */
1480                         }
1481
1482                         _last_capture_sources.insert (_last_capture_sources.end(), srcs.begin(), srcs.end());
1483
1484                         _playlist->clear_changes ();
1485                         _playlist->freeze ();
1486
1487                         /* Session frame time of the initial capture in this pass, which is where the source starts */
1488                         framepos_t initial_capture = 0;
1489                         if (!capture_info.empty()) {
1490                                 initial_capture = capture_info.front()->start;
1491                         }
1492
1493                         const framepos_t preroll_off = _session.preroll_record_trim_len ();
1494                         for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1495
1496                                 string region_name;
1497
1498                                 RegionFactory::region_name (region_name, _write_source->name(), false);
1499
1500                                 DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose ("%1 capture start @ %2 length %3 add new region %4\n",
1501                                                         _name, (*ci)->start, (*ci)->frames, region_name));
1502
1503
1504                                 // cerr << _name << ": based on ci of " << (*ci)->start << " for " << (*ci)->frames << " add a region\n";
1505
1506                                 try {
1507                                         PropertyList plist;
1508
1509                                         /* start of this region is the offset between the start of its capture and the start of the whole pass */
1510                                         plist.add (Properties::start, (*ci)->start - initial_capture);
1511                                         plist.add (Properties::length, (*ci)->frames);
1512                                         plist.add (Properties::length_beats, converter.from((*ci)->frames).to_double());
1513                                         plist.add (Properties::name, region_name);
1514
1515                                         boost::shared_ptr<Region> rx (RegionFactory::create (srcs, plist));
1516                                         region = boost::dynamic_pointer_cast<MidiRegion> (rx);
1517                                         if (preroll_off > 0) {
1518                                                 region->trim_front ((*ci)->start - initial_capture + preroll_off);
1519                                         }
1520                                 }
1521
1522                                 catch (failed_constructor& err) {
1523                                         error << _("MidiDiskstream: could not create region for captured midi!") << endmsg;
1524                                         continue; /* XXX is this OK? */
1525                                 }
1526
1527                                 // cerr << "add new region, buffer position = " << buffer_position << " @ " << (*ci)->start << endl;
1528
1529                                 i_am_the_modifier++;
1530                                 _playlist->add_region (region, (*ci)->start + preroll_off);
1531                                 i_am_the_modifier--;
1532                         }
1533
1534                         _playlist->thaw ();
1535                         _session.add_command (new StatefulDiffCommand(_playlist));
1536
1537                 } else {
1538
1539                         /* No data was recorded, so this capture will
1540                            effectively be aborted; do the same as we
1541                            do for an explicit abort.
1542                         */
1543
1544                         if (_write_source) {
1545                                 _write_source->mark_for_remove ();
1546                                 _write_source->drop_references ();
1547                                 _write_source.reset();
1548                         }
1549                 }
1550
1551         }
1552
1553         use_new_write_source (0);
1554
1555         for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1556                 delete *ci;
1557         }
1558
1559         capture_info.clear ();
1560         capture_start_frame = 0;
1561
1562   no_capture_stuff_to_do:
1563
1564         reset_tracker ();
1565 }
1566 #endif
1567
1568 void
1569 DiskWriter::transport_looped (framepos_t transport_frame)
1570 {
1571         if (was_recording) {
1572                 // all we need to do is finish this capture, with modified capture length
1573                 boost::shared_ptr<ChannelList> c = channels.reader();
1574
1575                 finish_capture (c);
1576
1577                 // the next region will start recording via the normal mechanism
1578                 // we'll set the start position to the current transport pos
1579                 // no latency adjustment or capture offset needs to be made, as that already happened the first time
1580                 capture_start_frame = transport_frame;
1581                 first_recordable_frame = transport_frame; // mild lie
1582                 last_recordable_frame = max_framepos;
1583                 was_recording = true;
1584
1585                 if (recordable() && destructive()) {
1586                         for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1587
1588                                 RingBufferNPT<CaptureTransition>::rw_vector transvec;
1589                                 (*chan)->capture_transition_buf->get_write_vector(&transvec);
1590
1591                                 if (transvec.len[0] > 0) {
1592                                         transvec.buf[0]->type = CaptureStart;
1593                                         transvec.buf[0]->capture_val = capture_start_frame;
1594                                         (*chan)->capture_transition_buf->increment_write_ptr(1);
1595                                 }
1596                                 else {
1597                                         // bad!
1598                                         fatal << X_("programming error: capture_transition_buf is full on rec loop!  inconceivable!")
1599                                               << endmsg;
1600                                 }
1601                         }
1602                 }
1603
1604         }
1605
1606         /* Here we only keep track of the number of captured loops so monotonic
1607            event times can be delivered to the write source in process().  Trying
1608            to be clever here is a world of trouble, it is better to simply record
1609            the input in a straightforward non-destructive way.  In the future when
1610            we want to implement more clever MIDI looping modes it should be done in
1611            the Source and/or entirely after the capture is finished.
1612         */
1613         if (was_recording) {
1614                 g_atomic_int_add(const_cast<gint*> (&_num_captured_loops), 1);
1615         }
1616 }
1617
1618 void
1619 DiskWriter::setup_destructive_playlist ()
1620 {
1621         SourceList srcs;
1622         boost::shared_ptr<ChannelList> c = channels.reader();
1623
1624         for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1625                 srcs.push_back ((*chan)->write_source);
1626         }
1627
1628         /* a single full-sized region */
1629
1630         assert (!srcs.empty ());
1631
1632         PropertyList plist;
1633         plist.add (Properties::name, _name.val());
1634         plist.add (Properties::start, 0);
1635         plist.add (Properties::length, max_framepos - srcs.front()->natural_position());
1636
1637         boost::shared_ptr<Region> region (RegionFactory::create (srcs, plist));
1638         _playlists[DataType::AUDIO]->add_region (region, srcs.front()->natural_position());
1639
1640         /* apply region properties and update write sources */
1641         use_destructive_playlist();
1642 }
1643
1644 void
1645 DiskWriter::use_destructive_playlist ()
1646 {
1647         /* this is called from the XML-based constructor or ::set_destructive. when called,
1648            we already have a playlist and a region, but we need to
1649            set up our sources for write. we use the sources associated
1650            with the (presumed single, full-extent) region.
1651         */
1652
1653         boost::shared_ptr<Region> rp;
1654         {
1655                 const RegionList& rl (_playlists[DataType::AUDIO]->region_list_property().rlist());
1656                 if (rl.size() > 0) {
1657                         /* this can happen when dragging a region onto a tape track */
1658                         assert((rl.size() == 1));
1659                         rp = rl.front();
1660                 }
1661         }
1662
1663         if (!rp) {
1664                 reset_write_sources (false, true);
1665                 return;
1666         }
1667
1668         boost::shared_ptr<AudioRegion> region = boost::dynamic_pointer_cast<AudioRegion> (rp);
1669
1670         if (region == 0) {
1671                 throw failed_constructor();
1672         }
1673
1674         /* be sure to stretch the region out to the maximum length (non-musical)*/
1675
1676         region->set_length (max_framepos - region->position(), 0);
1677
1678         uint32_t n;
1679         ChannelList::iterator chan;
1680         boost::shared_ptr<ChannelList> c = channels.reader();
1681
1682         for (n = 0, chan = c->begin(); chan != c->end(); ++chan, ++n) {
1683                 (*chan)->write_source = boost::dynamic_pointer_cast<AudioFileSource>(region->source (n));
1684                 assert((*chan)->write_source);
1685                 (*chan)->write_source->set_allow_remove_if_empty (false);
1686
1687                 /* this might be false if we switched modes, so force it */
1688
1689 #ifdef XXX_OLD_DESTRUCTIVE_API_XXX
1690                 (*chan)->write_source->set_destructive (true);
1691 #else
1692                 // should be set when creating the source or loading the state
1693                 assert ((*chan)->write_source->destructive());
1694 #endif
1695         }
1696
1697         /* the source list will never be reset for a destructive track */
1698 }
1699
1700 void
1701 DiskWriter::adjust_buffering ()
1702 {
1703         boost::shared_ptr<ChannelList> c = channels.reader();
1704
1705         for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1706                 (*chan)->resize (_session.butler()->audio_diskstream_capture_buffer_size());
1707         }
1708 }
1709
1710 void
1711 DiskWriter::realtime_handle_transport_stopped ()
1712 {
1713         realtime_speed_change ();
1714 }