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.add_property (X_("capture-alignment"), enum_2_string (_alignment_choice));
 407         node.add_property (X_("record-safe"), (_record_safe ? X_("yes" : "no")));
 408         return node;
 409 }
 410
 411 int
 412 DiskWriter::set_state (const XMLNode& node, int version)
 413 {
 414         XMLProperty const * prop;
 415
 416         if (DiskIOProcessor::set_state (node, version)) {
 417                 return -1;
 418         }
 419
 420         if ((prop = node.property (X_("capture-alignment"))) != 0) {
 421                 set_align_choice (AlignChoice (string_2_enum (prop->value(), _alignment_choice)), true);
 422         } else {
 423                 set_align_choice (Automatic, true);
 424         }
 425
 426
 427         if ((prop = node.property ("record-safe")) != 0) {
 428             _record_safe = PBD::string_is_affirmative (prop->value()) ? 1 : 0;
 429         }
 430
 431         return 0;
 432 }
 433
 434 void
 435 DiskWriter::non_realtime_locate (framepos_t position)
 436 {
 437         if (_midi_write_source) {
 438                 _midi_write_source->set_timeline_position (position);
 439         }
 440
 441         DiskIOProcessor::non_realtime_locate (position);
 442 }
 443
 444
 445 void
 446 DiskWriter::prepare_record_status(framepos_t capture_start_frame)
 447 {
 448         if (recordable() && destructive()) {
 449                 boost::shared_ptr<ChannelList> c = channels.reader();
 450                 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
 451
 452                         RingBufferNPT<CaptureTransition>::rw_vector transitions;
 453                         (*chan)->capture_transition_buf->get_write_vector (&transitions);
 454
 455                         if (transitions.len[0] > 0) {
 456                                 transitions.buf[0]->type = CaptureStart;
 457                                 transitions.buf[0]->capture_val = capture_start_frame;
 458                                 (*chan)->capture_transition_buf->increment_write_ptr(1);
 459                         } else {
 460                                 // bad!
 461                                 fatal << X_("programming error: capture_transition_buf is full on rec start!  inconceivable!")
 462                                         << endmsg;
 463                         }
 464                 }
 465         }
 466 }
 467
 468
 469 /** Do some record stuff [not described in this comment!]
 470  *
 471  *  Also:
 472  *    - Setup playback_distance with the nframes, or nframes adjusted
 473  *      for current varispeed, if appropriate.
 474  *    - Setup current_playback_buffer in each ChannelInfo to point to data
 475  *      that someone can read playback_distance worth of data from.
 476  */
 477 void
 478 DiskWriter::run (BufferSet& bufs, framepos_t start_frame, framepos_t end_frame,
 479                  double speed, pframes_t nframes, bool result_required)
 480
 481 /*      (BufferSet& bufs, framepos_t transport_frame, pframes_t nframes, framecnt_t& playback_distance, bool need_disk_signal)
 482  */
 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         check_record_status (start_frame, can_record);
 494
 495         if (nframes == 0) {
 496                 return;
 497         }
 498
 499         nominally_recording = (can_record && re);
 500
 501         // Safeguard against situations where process() goes haywire when autopunching
 502         // and last_recordable_frame < first_recordable_frame
 503
 504         if (last_recordable_frame < first_recordable_frame) {
 505                 last_recordable_frame = max_framepos;
 506         }
 507
 508         const Location* const loop_loc    = loop_location;
 509         framepos_t            loop_start  = 0;
 510         framepos_t            loop_end    = 0;
 511         framepos_t            loop_length = 0;
 512
 513         if (loop_loc) {
 514                 get_location_times (loop_loc, &loop_start, &loop_end, &loop_length);
 515         }
 516
 517         adjust_capture_position = 0;
 518
 519         if (nominally_recording || (re && was_recording && _session.get_record_enabled() && (_session.config.get_punch_in() || _session.preroll_record_punch_enabled()))) {
 520
 521                 Evoral::OverlapType ot = Evoral::coverage (first_recordable_frame, last_recordable_frame, start_frame, end_frame);
 522                 // XXX should this be transport_frame + nframes - 1 ? coverage() expects its parameter ranges to include their end points
 523                 // XXX also, first_recordable_frame & last_recordable_frame may both be == max_framepos: coverage() will return OverlapNone in that case. Is thak OK?
 524                 calculate_record_range (ot, start_frame, nframes, rec_nframes, rec_offset);
 525
 526                 DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose ("%1: this time record %2 of %3 frames, offset %4\n", _name, rec_nframes, nframes, rec_offset));
 527
 528                 if (rec_nframes && !was_recording) {
 529                         capture_captured = 0;
 530
 531                         if (loop_loc) {
 532                                 /* Loop recording, so pretend the capture started at the loop
 533                                    start rgardless of what time it is now, so the source starts
 534                                    at the loop start and can handle time wrapping around.
 535                                    Otherwise, start the source right now as usual.
 536                                 */
 537                                 capture_captured    = start_frame - loop_start;
 538                                 capture_start_frame = loop_start;
 539                         }
 540
 541                         _midi_write_source->mark_write_starting_now (capture_start_frame, capture_captured, loop_length);
 542
 543                         g_atomic_int_set(const_cast<gint*> (&_frames_pending_write), 0);
 544                         g_atomic_int_set(const_cast<gint*> (&_num_captured_loops), 0);
 545
 546                         was_recording = true;
 547
 548                 }
 549
 550                 /* For audio: not writing frames to the capture ringbuffer offsets
 551                  * the recording. For midi: we need to keep track of the record range
 552                  * and subtract the accumulated difference from the event time.
 553                  */
 554                 if (rec_nframes) {
 555                         _accumulated_capture_offset += rec_offset;
 556                 } else {
 557                         _accumulated_capture_offset += nframes;
 558                 }
 559
 560         }
 561
 562         if (can_record && !_last_capture_sources.empty()) {
 563                 _last_capture_sources.clear ();
 564         }
 565
 566         if (rec_nframes) {
 567
 568                 /* AUDIO */
 569
 570                 const size_t n_buffers = bufs.count().n_audio();
 571
 572                 for (n = 0; chan != c->end(); ++chan, ++n) {
 573
 574                         ChannelInfo* chaninfo (*chan);
 575                         AudioBuffer& buf (bufs.get_audio (n%n_buffers));
 576
 577                         chaninfo->buf->get_write_vector (&chaninfo->rw_vector);
 578
 579                         if (rec_nframes <= (framecnt_t) chaninfo->rw_vector.len[0]) {
 580
 581                                 Sample *incoming = buf.data (rec_offset);
 582                                 memcpy (chaninfo->rw_vector.buf[0], incoming, sizeof (Sample) * rec_nframes);
 583
 584                         } else {
 585
 586                                 framecnt_t total = chaninfo->rw_vector.len[0] + chaninfo->rw_vector.len[1];
 587
 588                                 if (rec_nframes > total) {
 589                                         DEBUG_TRACE (DEBUG::Butler, string_compose ("%1 overrun in %2, rec_nframes = %3 total space = %4\n",
 590                                                                                     DEBUG_THREAD_SELF, name(), rec_nframes, total));
 591                                         Overrun ();
 592                                         return;
 593                                 }
 594
 595                                 Sample *incoming = buf.data (rec_offset);
 596                                 framecnt_t first = chaninfo->rw_vector.len[0];
 597
 598                                 memcpy (chaninfo->rw_vector.buf[0], incoming, sizeof (Sample) * first);
 599                                 memcpy (chaninfo->rw_vector.buf[1], incoming + first, sizeof (Sample) * (rec_nframes - first));
 600                         }
 601
 602                         chaninfo->buf->increment_write_ptr (rec_nframes);
 603
 604                 }
 605
 606                 /* MIDI */
 607
 608                 // Pump entire port buffer into the ring buffer (TODO: split cycles?)
 609                 MidiBuffer& buf    = bufs.get_midi (0);
 610                 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack>(_route);
 611                 MidiChannelFilter* filter = mt ? &mt->capture_filter() : 0;
 612
 613                 for (MidiBuffer::iterator i = buf.begin(); i != buf.end(); ++i) {
 614                         Evoral::Event<MidiBuffer::TimeType> ev(*i, false);
 615                         if (ev.time() + rec_offset > rec_nframes) {
 616                                 break;
 617                         }
 618 #ifndef NDEBUG
 619                         if (DEBUG_ENABLED(DEBUG::MidiIO)) {
 620                                 const uint8_t* __data = ev.buffer();
 621                                 DEBUG_STR_DECL(a);
 622                                 DEBUG_STR_APPEND(a, string_compose ("mididiskstream %1 capture event @ %2 + %3 sz %4 ", this, ev.time(), start_frame, ev.size()));
 623                                 for (size_t i=0; i < ev.size(); ++i) {
 624                                         DEBUG_STR_APPEND(a,hex);
 625                                         DEBUG_STR_APPEND(a,"0x");
 626                                         DEBUG_STR_APPEND(a,(int)__data[i]);
 627                                         DEBUG_STR_APPEND(a,' ');
 628                                 }
 629                                 DEBUG_STR_APPEND(a,'\n');
 630                                 DEBUG_TRACE (DEBUG::MidiIO, DEBUG_STR(a).str());
 631                         }
 632 #endif
 633                         /* Write events to the capture buffer in frames from session start,
 634                            but ignoring looping so event time progresses monotonically.
 635                            The source knows the loop length so it knows exactly where the
 636                            event occurs in the series of recorded loops and can implement
 637                            any desirable behaviour.  We don't want to send event with
 638                            transport time here since that way the source can not
 639                            reconstruct their actual time; future clever MIDI looping should
 640                            probably be implemented in the source instead of here.
 641                         */
 642                         const framecnt_t loop_offset = _num_captured_loops * loop_length;
 643                         const framepos_t event_time = start_frame + loop_offset - _accumulated_capture_offset + ev.time();
 644                         if (event_time < 0 || event_time < first_recordable_frame) {
 645                                 /* Event out of range, skip */
 646                                 continue;
 647                         }
 648
 649                         if (!filter || !filter->filter(ev.buffer(), ev.size())) {
 650                                 _midi_buf->write (event_time, ev.event_type(), ev.size(), ev.buffer());
 651                         }
 652                 }
 653                 g_atomic_int_add(const_cast<gint*>(&_frames_pending_write), nframes);
 654
 655                 if (buf.size() != 0) {
 656                         Glib::Threads::Mutex::Lock lm (_gui_feed_buffer_mutex, Glib::Threads::TRY_LOCK);
 657
 658                         if (lm.locked ()) {
 659                                 /* Copy this data into our GUI feed buffer and tell the GUI
 660                                    that it can read it if it likes.
 661                                 */
 662                                 _gui_feed_buffer.clear ();
 663
 664                                 for (MidiBuffer::iterator i = buf.begin(); i != buf.end(); ++i) {
 665                                         /* This may fail if buf is larger than _gui_feed_buffer, but it's not really
 666                                            the end of the world if it does.
 667                                         */
 668                                         _gui_feed_buffer.push_back ((*i).time() + start_frame, (*i).size(), (*i).buffer());
 669                                 }
 670                         }
 671
 672                         DataRecorded (_midi_write_source); /* EMIT SIGNAL */
 673                 }
 674
 675                 capture_captured += rec_nframes;
 676                 DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose ("%1 now captured %2 (by %3)\n", name(), capture_captured, rec_nframes));
 677
 678         } else {
 679
 680                 /* not recording this time, but perhaps we were before .. */
 681
 682                 if (was_recording) {
 683                         finish_capture (c);
 684                         _accumulated_capture_offset = 0;
 685                 }
 686         }
 687
 688         /* AUDIO BUTLER REQUIRED CODE */
 689
 690         if (!c->empty()) {
 691                 if (((framecnt_t) c->front()->buf->read_space() >= _chunk_frames)) {
 692                         _need_butler = true;
 693                 }
 694         }
 695
 696         /* MIDI BUTLER REQUIRED CODE */
 697
 698         if (_midi_buf->read_space() < _midi_buf->bufsize() / 2) {
 699                 _need_butler = true;
 700         }
 701 }
 702
 703 void
 704 DiskWriter::finish_capture (boost::shared_ptr<ChannelList> c)
 705 {
 706         was_recording = false;
 707         first_recordable_frame = max_framepos;
 708         last_recordable_frame = max_framepos;
 709
 710         if (capture_captured == 0) {
 711                 return;
 712         }
 713
 714         if (recordable() && destructive()) {
 715                 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
 716
 717                         RingBufferNPT<CaptureTransition>::rw_vector transvec;
 718                         (*chan)->capture_transition_buf->get_write_vector(&transvec);
 719
 720                         if (transvec.len[0] > 0) {
 721                                 transvec.buf[0]->type = CaptureEnd;
 722                                 transvec.buf[0]->capture_val = capture_captured;
 723                                 (*chan)->capture_transition_buf->increment_write_ptr(1);
 724                         }
 725                         else {
 726                                 // bad!
 727                                 fatal << string_compose (_("programmer error: %1"), X_("capture_transition_buf is full when stopping record!  inconceivable!")) << endmsg;
 728                         }
 729                 }
 730         }
 731
 732
 733         CaptureInfo* ci = new CaptureInfo;
 734
 735         ci->start =  capture_start_frame;
 736         ci->frames = capture_captured;
 737
 738         /* XXX theoretical race condition here. Need atomic exchange ?
 739            However, the circumstances when this is called right
 740            now (either on record-disable or transport_stopped)
 741            mean that no actual race exists. I think ...
 742            We now have a capture_info_lock, but it is only to be used
 743            to synchronize in the transport_stop and the capture info
 744            accessors, so that invalidation will not occur (both non-realtime).
 745         */
 746
 747         DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose ("Finish capture, add new CI, %1 + %2\n", ci->start, ci->frames));
 748
 749         capture_info.push_back (ci);
 750         capture_captured = 0;
 751
 752         /* now we've finished a capture, reset first_recordable_frame for next time */
 753         first_recordable_frame = max_framepos;
 754 }
 755
 756 void
 757 DiskWriter::set_record_enabled (bool yn)
 758 {
 759         if (!recordable() || !_session.record_enabling_legal() || record_safe ()) {
 760                 return;
 761         }
 762
 763         /* can't rec-enable in destructive mode if transport is before start */
 764
 765         if (destructive() && yn && _session.transport_frame() < _session.current_start_frame()) {
 766                 return;
 767         }
 768
 769         /* yes, i know that this not proof against race conditions, but its
 770            good enough. i think.
 771         */
 772
 773         if (record_enabled() != yn) {
 774                 if (yn) {
 775                         engage_record_enable ();
 776                 } else {
 777                         disengage_record_enable ();
 778                 }
 779
 780                 RecordEnableChanged (); /* EMIT SIGNAL */
 781         }
 782 }
 783
 784 void
 785 DiskWriter::set_record_safe (bool yn)
 786 {
 787         if (!recordable() || !_session.record_enabling_legal() || channels.reader()->empty()) {
 788                 return;
 789         }
 790
 791         /* can't rec-safe in destructive mode if transport is before start ????
 792          REQUIRES REVIEW */
 793
 794         if (destructive() && yn && _session.transport_frame() < _session.current_start_frame()) {
 795                 return;
 796         }
 797
 798         /* yes, i know that this not proof against race conditions, but its
 799          good enough. i think.
 800          */
 801
 802         if (record_safe () != yn) {
 803                 if (yn) {
 804                         engage_record_safe ();
 805                 } else {
 806                         disengage_record_safe ();
 807                 }
 808
 809                 RecordSafeChanged (); /* EMIT SIGNAL */
 810         }
 811 }
 812
 813 bool
 814 DiskWriter::prep_record_enable ()
 815 {
 816         if (!recordable() || !_session.record_enabling_legal() || channels.reader()->empty() || record_safe ()) { // REQUIRES REVIEW "|| record_safe ()"
 817                 return false;
 818         }
 819
 820         /* can't rec-enable in destructive mode if transport is before start */
 821
 822         if (destructive() && _session.transport_frame() < _session.current_start_frame()) {
 823                 return false;
 824         }
 825
 826         boost::shared_ptr<ChannelList> c = channels.reader();
 827
 828         capturing_sources.clear ();
 829
 830         for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
 831                 capturing_sources.push_back ((*chan)->write_source);
 832                 Source::Lock lock((*chan)->write_source->mutex());
 833                 (*chan)->write_source->mark_streaming_write_started (lock);
 834         }
 835
 836         return true;
 837 }
 838
 839 bool
 840 DiskWriter::prep_record_disable ()
 841 {
 842         capturing_sources.clear ();
 843         return true;
 844 }
 845
 846 float
 847 DiskWriter::buffer_load () const
 848 {
 849         boost::shared_ptr<ChannelList> c = channels.reader();
 850
 851         if (c->empty ()) {
 852                 return 1.0;
 853         }
 854
 855         return (float) ((double) c->front()->buf->write_space()/
 856                         (double) c->front()->buf->bufsize());
 857 }
 858
 859 void
 860 DiskWriter::set_note_mode (NoteMode m)
 861 {
 862         _note_mode = m;
 863
 864         boost::shared_ptr<MidiPlaylist> mp = boost::dynamic_pointer_cast<MidiPlaylist> (_playlists[DataType::MIDI]);
 865
 866         if (mp) {
 867                 mp->set_note_mode (m);
 868         }
 869
 870         if (_midi_write_source && _midi_write_source->model())
 871                 _midi_write_source->model()->set_note_mode(m);
 872 }
 873
 874 int
 875 DiskWriter::seek (framepos_t frame, bool complete_refill)
 876 {
 877         uint32_t n;
 878         ChannelList::iterator chan;
 879         boost::shared_ptr<ChannelList> c = channels.reader();
 880
 881         for (n = 0, chan = c->begin(); chan != c->end(); ++chan, ++n) {
 882                 (*chan)->buf->reset ();
 883         }
 884
 885         _midi_buf->reset ();
 886         g_atomic_int_set(&_frames_read_from_ringbuffer, 0);
 887         g_atomic_int_set(&_frames_written_to_ringbuffer, 0);
 888
 889         /* can't rec-enable in destructive mode if transport is before start */
 890
 891         if (destructive() && record_enabled() && frame < _session.current_start_frame()) {
 892                 disengage_record_enable ();
 893         }
 894
 895         playback_sample = frame;
 896         file_frame = frame;
 897
 898         return 0;
 899 }
 900
 901 int
 902 DiskWriter::do_flush (RunContext ctxt, bool force_flush)
 903 {
 904         uint32_t to_write;
 905         int32_t ret = 0;
 906         RingBufferNPT<Sample>::rw_vector vector;
 907         RingBufferNPT<CaptureTransition>::rw_vector transvec;
 908         framecnt_t total;
 909
 910         transvec.buf[0] = 0;
 911         transvec.buf[1] = 0;
 912         vector.buf[0] = 0;
 913         vector.buf[1] = 0;
 914
 915         boost::shared_ptr<ChannelList> c = channels.reader();
 916         for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
 917
 918                 (*chan)->buf->get_read_vector (&vector);
 919
 920                 total = vector.len[0] + vector.len[1];
 921
 922                 if (total == 0 || (total < _chunk_frames && !force_flush && was_recording)) {
 923                         goto out;
 924                 }
 925
 926                 /* if there are 2+ chunks of disk i/o possible for
 927                    this track, let the caller know so that it can arrange
 928                    for us to be called again, ASAP.
 929
 930                    if we are forcing a flush, then if there is* any* extra
 931                    work, let the caller know.
 932
 933                    if we are no longer recording and there is any extra work,
 934                    let the caller know too.
 935                 */
 936
 937                 if (total >= 2 * _chunk_frames || ((force_flush || !was_recording) && total > _chunk_frames)) {
 938                         ret = 1;
 939                 }
 940
 941                 to_write = min (_chunk_frames, (framecnt_t) vector.len[0]);
 942
 943                 // check the transition buffer when recording destructive
 944                 // important that we get this after the capture buf
 945
 946                 if (destructive()) {
 947                         (*chan)->capture_transition_buf->get_read_vector(&transvec);
 948                         size_t transcount = transvec.len[0] + transvec.len[1];
 949                         size_t ti;
 950
 951                         for (ti=0; ti < transcount; ++ti) {
 952                                 CaptureTransition & captrans = (ti < transvec.len[0]) ? transvec.buf[0][ti] : transvec.buf[1][ti-transvec.len[0]];
 953
 954                                 if (captrans.type == CaptureStart) {
 955                                         // by definition, the first data we got above represents the given capture pos
 956
 957                                         (*chan)->write_source->mark_capture_start (captrans.capture_val);
 958                                         (*chan)->curr_capture_cnt = 0;
 959
 960                                 } else if (captrans.type == CaptureEnd) {
 961
 962                                         // capture end, the capture_val represents total frames in capture
 963
 964                                         if (captrans.capture_val <= (*chan)->curr_capture_cnt + to_write) {
 965
 966                                                 // shorten to make the write a perfect fit
 967                                                 uint32_t nto_write = (captrans.capture_val - (*chan)->curr_capture_cnt);
 968
 969                                                 if (nto_write < to_write) {
 970                                                         ret = 1; // should we?
 971                                                 }
 972                                                 to_write = nto_write;
 973
 974                                                 (*chan)->write_source->mark_capture_end ();
 975
 976                                                 // increment past this transition, but go no further
 977                                                 ++ti;
 978                                                 break;
 979                                         }
 980                                         else {
 981                                                 // actually ends just beyond this chunk, so force more work
 982                                                 ret = 1;
 983                                                 break;
 984                                         }
 985                                 }
 986                         }
 987
 988                         if (ti > 0) {
 989                                 (*chan)->capture_transition_buf->increment_read_ptr(ti);
 990                         }
 991                 }
 992
 993                 if ((!(*chan)->write_source) || (*chan)->write_source->write (vector.buf[0], to_write) != to_write) {
 994                         error << string_compose(_("AudioDiskstream %1: cannot write to disk"), id()) << endmsg;
 995                         return -1;
 996                 }
 997
 998                 (*chan)->buf->increment_read_ptr (to_write);
 999                 (*chan)->curr_capture_cnt += to_write;
1000
1001                 if ((to_write == vector.len[0]) && (total > to_write) && (to_write < _chunk_frames) && !destructive()) {
1002
1003                         /* we wrote all of vector.len[0] but it wasn't an entire
1004                            disk_write_chunk_frames of data, so arrange for some part
1005                            of vector.len[1] to be flushed to disk as well.
1006                         */
1007
1008                         to_write = min ((framecnt_t)(_chunk_frames - to_write), (framecnt_t) vector.len[1]);
1009
1010                         DEBUG_TRACE (DEBUG::Butler, string_compose ("%1 additional write of %2\n", name(), to_write));
1011
1012                         if ((*chan)->write_source->write (vector.buf[1], to_write) != to_write) {
1013                                 error << string_compose(_("AudioDiskstream %1: cannot write to disk"), id()) << endmsg;
1014                                 return -1;
1015                         }
1016
1017                         (*chan)->buf->increment_read_ptr (to_write);
1018                         (*chan)->curr_capture_cnt += to_write;
1019                 }
1020         }
1021
1022         /* MIDI*/
1023
1024   out:
1025         return ret;
1026
1027 }
1028
1029 void
1030 DiskWriter::reset_write_sources (bool mark_write_complete, bool /*force*/)
1031 {
1032         ChannelList::iterator chan;
1033         boost::shared_ptr<ChannelList> c = channels.reader();
1034         uint32_t n;
1035
1036         if (!_session.writable() || !recordable()) {
1037                 return;
1038         }
1039
1040         capturing_sources.clear ();
1041
1042         for (chan = c->begin(), n = 0; chan != c->end(); ++chan, ++n) {
1043
1044                 if (!destructive()) {
1045
1046                         if ((*chan)->write_source) {
1047
1048                                 if (mark_write_complete) {
1049                                         Source::Lock lock((*chan)->write_source->mutex());
1050                                         (*chan)->write_source->mark_streaming_write_completed (lock);
1051                                         (*chan)->write_source->done_with_peakfile_writes ();
1052                                 }
1053
1054                                 if ((*chan)->write_source->removable()) {
1055                                         (*chan)->write_source->mark_for_remove ();
1056                                         (*chan)->write_source->drop_references ();
1057                                 }
1058
1059                                 (*chan)->write_source.reset ();
1060                         }
1061
1062                         use_new_write_source (DataType::AUDIO, n);
1063
1064                         if (record_enabled()) {
1065                                 capturing_sources.push_back ((*chan)->write_source);
1066                         }
1067
1068                 } else {
1069
1070                         if ((*chan)->write_source == 0) {
1071                                 use_new_write_source (DataType::AUDIO, n);
1072                         }
1073                 }
1074         }
1075
1076         if (_midi_write_source) {
1077                 if (mark_write_complete) {
1078                         Source::Lock lm(_midi_write_source->mutex());
1079                         _midi_write_source->mark_streaming_write_completed (lm);
1080                 }
1081
1082                 use_new_write_source (DataType::MIDI);
1083
1084                 if (destructive() && !c->empty ()) {
1085
1086                         /* we now have all our write sources set up, so create the
1087                            playlist's single region.
1088                         */
1089
1090                         if (_playlists[DataType::MIDI]->empty()) {
1091                                 setup_destructive_playlist ();
1092                         }
1093                 }
1094         }
1095 }
1096
1097 int
1098 DiskWriter::use_new_write_source (DataType dt, uint32_t n)
1099 {
1100         if (dt == DataType::MIDI) {
1101
1102                 _accumulated_capture_offset = 0;
1103                 _midi_write_source.reset();
1104
1105                 try {
1106                         _midi_write_source = boost::dynamic_pointer_cast<SMFSource>(
1107                                 _session.create_midi_source_for_session (write_source_name ()));
1108
1109                         if (!_midi_write_source) {
1110                                 throw failed_constructor();
1111                         }
1112                 }
1113
1114                 catch (failed_constructor &err) {
1115                         error << string_compose (_("%1:%2 new capture file not initialized correctly"), _name, n) << endmsg;
1116                         _midi_write_source.reset();
1117                         return -1;
1118                 }
1119         } else {
1120                 boost::shared_ptr<ChannelList> c = channels.reader();
1121
1122                 if (!recordable()) {
1123                         return 1;
1124                 }
1125
1126                 if (n >= c->size()) {
1127                         error << string_compose (_("AudioDiskstream: channel %1 out of range"), n) << endmsg;
1128                         return -1;
1129                 }
1130
1131                 ChannelInfo* chan = (*c)[n];
1132
1133                 try {
1134                         if ((chan->write_source = _session.create_audio_source_for_session (
1135                                      c->size(), write_source_name(), n, destructive())) == 0) {
1136                                 throw failed_constructor();
1137                         }
1138                 }
1139
1140                 catch (failed_constructor &err) {
1141                         error << string_compose (_("%1:%2 new capture file not initialized correctly"), _name, n) << endmsg;
1142                         chan->write_source.reset ();
1143                         return -1;
1144                 }
1145
1146                 /* do not remove destructive files even if they are empty */
1147
1148                 chan->write_source->set_allow_remove_if_empty (!destructive());
1149         }
1150
1151         return 0;
1152 }
1153
1154 void
1155 DiskWriter::transport_stopped_wallclock (struct tm& when, time_t twhen, bool abort_capture)
1156 {
1157         uint32_t buffer_position;
1158         bool more_work = true;
1159         int err = 0;
1160         boost::shared_ptr<AudioRegion> region;
1161         framecnt_t total_capture;
1162         SourceList srcs;
1163         SourceList::iterator src;
1164         ChannelList::iterator chan;
1165         vector<CaptureInfo*>::iterator ci;
1166         boost::shared_ptr<ChannelList> c = channels.reader();
1167         uint32_t n = 0;
1168         bool mark_write_completed = false;
1169
1170         finish_capture (c);
1171
1172         boost::shared_ptr<AudioPlaylist> pl = boost::dynamic_pointer_cast<AudioPlaylist> (_playlists[DataType::AUDIO]);
1173
1174         /* butler is already stopped, but there may be work to do
1175            to flush remaining data to disk.
1176         */
1177
1178         while (more_work && !err) {
1179                 switch (do_flush (TransportContext, true)) {
1180                 case 0:
1181                         more_work = false;
1182                         break;
1183                 case 1:
1184                         break;
1185                 case -1:
1186                         error << string_compose(_("AudioDiskstream \"%1\": cannot flush captured data to disk!"), _name) << endmsg;
1187                         err++;
1188                 }
1189         }
1190
1191         /* XXX is there anything we can do if err != 0 ? */
1192         Glib::Threads::Mutex::Lock lm (capture_info_lock);
1193
1194         if (capture_info.empty()) {
1195                 return;
1196         }
1197
1198         if (abort_capture) {
1199
1200                 if (destructive()) {
1201                         goto outout;
1202                 }
1203
1204                 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1205
1206                         if ((*chan)->write_source) {
1207
1208                                 (*chan)->write_source->mark_for_remove ();
1209                                 (*chan)->write_source->drop_references ();
1210                                 (*chan)->write_source.reset ();
1211                         }
1212
1213                         /* new source set up in "out" below */
1214                 }
1215
1216                 goto out;
1217         }
1218
1219         for (total_capture = 0, ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1220                 total_capture += (*ci)->frames;
1221         }
1222
1223         /* figure out the name for this take */
1224
1225         for (n = 0, chan = c->begin(); chan != c->end(); ++chan, ++n) {
1226
1227                 boost::shared_ptr<AudioFileSource> s = (*chan)->write_source;
1228
1229                 if (s) {
1230                         srcs.push_back (s);
1231                         s->update_header (capture_info.front()->start, when, twhen);
1232                         s->set_captured_for (_name.val());
1233                         s->mark_immutable ();
1234
1235                         if (Config->get_auto_analyse_audio()) {
1236                                 Analyser::queue_source_for_analysis (s, true);
1237                         }
1238
1239                         DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose ("newly captured source %1 length %2\n", s->path(), s->length (0)));
1240                 }
1241         }
1242
1243         if (!pl) {
1244                 goto midi;
1245         }
1246
1247         /* destructive tracks have a single, never changing region */
1248
1249         if (destructive()) {
1250
1251                 /* send a signal that any UI can pick up to do the right thing. there is
1252                    a small problem here in that a UI may need the peak data to be ready
1253                    for the data that was recorded and this isn't interlocked with that
1254                    process. this problem is deferred to the UI.
1255                  */
1256
1257                 pl->LayeringChanged(); // XXX this may not get the UI to do the right thing
1258
1259         } else {
1260
1261                 string whole_file_region_name;
1262                 whole_file_region_name = region_name_from_path (c->front()->write_source->name(), true);
1263
1264                 /* Register a new region with the Session that
1265                    describes the entire source. Do this first
1266                    so that any sub-regions will obviously be
1267                    children of this one (later!)
1268                 */
1269
1270                 try {
1271                         PropertyList plist;
1272
1273                         plist.add (Properties::start, c->front()->write_source->last_capture_start_frame());
1274                         plist.add (Properties::length, total_capture);
1275                         plist.add (Properties::name, whole_file_region_name);
1276                         boost::shared_ptr<Region> rx (RegionFactory::create (srcs, plist));
1277                         rx->set_automatic (true);
1278                         rx->set_whole_file (true);
1279
1280                         region = boost::dynamic_pointer_cast<AudioRegion> (rx);
1281                         region->special_set_position (capture_info.front()->start);
1282                 }
1283
1284
1285                 catch (failed_constructor& err) {
1286                         error << string_compose(_("%1: could not create region for complete audio file"), _name) << endmsg;
1287                         /* XXX what now? */
1288                 }
1289
1290                 _last_capture_sources.insert (_last_capture_sources.end(), srcs.begin(), srcs.end());
1291
1292                 pl->clear_changes ();
1293                 pl->set_capture_insertion_in_progress (true);
1294                 pl->freeze ();
1295
1296                 const framepos_t preroll_off = _session.preroll_record_trim_len ();
1297                 for (buffer_position = c->front()->write_source->last_capture_start_frame(), ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1298
1299                         string region_name;
1300
1301                         RegionFactory::region_name (region_name, whole_file_region_name, false);
1302
1303                         DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose ("%1 capture bufpos %5 start @ %2 length %3 add new region %4\n",
1304                                                                               _name, (*ci)->start, (*ci)->frames, region_name, buffer_position));
1305
1306                         try {
1307
1308                                 PropertyList plist;
1309
1310                                 plist.add (Properties::start, buffer_position);
1311                                 plist.add (Properties::length, (*ci)->frames);
1312                                 plist.add (Properties::name, region_name);
1313
1314                                 boost::shared_ptr<Region> rx (RegionFactory::create (srcs, plist));
1315                                 region = boost::dynamic_pointer_cast<AudioRegion> (rx);
1316                                 if (preroll_off > 0) {
1317                                         region->trim_front (buffer_position + preroll_off);
1318                                 }
1319                         }
1320
1321                         catch (failed_constructor& err) {
1322                                 error << _("AudioDiskstream: could not create region for captured audio!") << endmsg;
1323                                 continue; /* XXX is this OK? */
1324                         }
1325
1326                         i_am_the_modifier++;
1327
1328                         pl->add_region (region, (*ci)->start + preroll_off, 1, non_layered());
1329                         pl->set_layer (region, DBL_MAX);
1330                         i_am_the_modifier--;
1331
1332                         buffer_position += (*ci)->frames;
1333                 }
1334
1335                 pl->thaw ();
1336                 pl->set_capture_insertion_in_progress (false);
1337                 _session.add_command (new StatefulDiffCommand (pl));
1338         }
1339
1340         mark_write_completed = true;
1341
1342   out:
1343         reset_write_sources (mark_write_completed);
1344
1345   outout:
1346
1347         for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1348                 delete *ci;
1349         }
1350
1351         capture_info.clear ();
1352         capture_start_frame = 0;
1353
1354   midi:
1355         return;
1356 }
1357
1358 #if 0 // MIDI PART
1359 void
1360 DiskWriter::transport_stopped_wallclock (struct tm& /*when*/, time_t /*twhen*/, bool abort_capture)
1361 {
1362         bool more_work = true;
1363         int err = 0;
1364         boost::shared_ptr<MidiRegion> region;
1365         MidiRegion::SourceList srcs;
1366         MidiRegion::SourceList::iterator src;
1367         vector<CaptureInfo*>::iterator ci;
1368
1369         finish_capture ();
1370
1371         /* butler is already stopped, but there may be work to do
1372            to flush remaining data to disk.
1373            */
1374
1375         while (more_work && !err) {
1376                 switch (do_flush (TransportContext, true)) {
1377                 case 0:
1378                         more_work = false;
1379                         break;
1380                 case 1:
1381                         break;
1382                 case -1:
1383                         error << string_compose(_("MidiDiskstream \"%1\": cannot flush captured data to disk!"), _name) << endmsg;
1384                         err++;
1385                 }
1386         }
1387
1388         /* XXX is there anything we can do if err != 0 ? */
1389         Glib::Threads::Mutex::Lock lm (capture_info_lock);
1390
1391         if (capture_info.empty()) {
1392                 goto no_capture_stuff_to_do;
1393         }
1394
1395         if (abort_capture) {
1396
1397                 if (_write_source) {
1398                         _write_source->mark_for_remove ();
1399                         _write_source->drop_references ();
1400                         _write_source.reset();
1401                 }
1402
1403                 /* new source set up in "out" below */
1404
1405         } else {
1406
1407                 framecnt_t total_capture = 0;
1408                 for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1409                         total_capture += (*ci)->frames;
1410                 }
1411
1412                 if (_write_source->length (capture_info.front()->start) != 0) {
1413
1414                         /* phew, we have data */
1415
1416                         Source::Lock source_lock(_write_source->mutex());
1417
1418                         /* figure out the name for this take */
1419
1420                         srcs.push_back (_write_source);
1421
1422                         _write_source->set_timeline_position (capture_info.front()->start);
1423                         _write_source->set_captured_for (_name);
1424
1425                         /* set length in beats to entire capture length */
1426
1427                         BeatsFramesConverter converter (_session.tempo_map(), capture_info.front()->start);
1428                         const Evoral::Beats total_capture_beats = converter.from (total_capture);
1429                         _write_source->set_length_beats (total_capture_beats);
1430
1431                         /* flush to disk: this step differs from the audio path,
1432                            where all the data is already on disk.
1433                         */
1434
1435                         _write_source->mark_midi_streaming_write_completed (source_lock, Evoral::Sequence<Evoral::Beats>::ResolveStuckNotes, total_capture_beats);
1436
1437                         /* we will want to be able to keep (over)writing the source
1438                            but we don't want it to be removable. this also differs
1439                            from the audio situation, where the source at this point
1440                            must be considered immutable. luckily, we can rely on
1441                            MidiSource::mark_streaming_write_completed() to have
1442                            already done the necessary work for that.
1443                         */
1444
1445                         string whole_file_region_name;
1446                         whole_file_region_name = region_name_from_path (_write_source->name(), true);
1447
1448                         /* Register a new region with the Session that
1449                            describes the entire source. Do this first
1450                            so that any sub-regions will obviously be
1451                            children of this one (later!)
1452                         */
1453
1454                         try {
1455                                 PropertyList plist;
1456
1457                                 plist.add (Properties::name, whole_file_region_name);
1458                                 plist.add (Properties::whole_file, true);
1459                                 plist.add (Properties::automatic, true);
1460                                 plist.add (Properties::start, 0);
1461                                 plist.add (Properties::length, total_capture);
1462                                 plist.add (Properties::layer, 0);
1463
1464                                 boost::shared_ptr<Region> rx (RegionFactory::create (srcs, plist));
1465
1466                                 region = boost::dynamic_pointer_cast<MidiRegion> (rx);
1467                                 region->special_set_position (capture_info.front()->start);
1468                         }
1469
1470
1471                         catch (failed_constructor& err) {
1472                                 error << string_compose(_("%1: could not create region for complete midi file"), _name) << endmsg;
1473                                 /* XXX what now? */
1474                         }
1475
1476                         _last_capture_sources.insert (_last_capture_sources.end(), srcs.begin(), srcs.end());
1477
1478                         _playlist->clear_changes ();
1479                         _playlist->freeze ();
1480
1481                         /* Session frame time of the initial capture in this pass, which is where the source starts */
1482                         framepos_t initial_capture = 0;
1483                         if (!capture_info.empty()) {
1484                                 initial_capture = capture_info.front()->start;
1485                         }
1486
1487                         const framepos_t preroll_off = _session.preroll_record_trim_len ();
1488                         for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1489
1490                                 string region_name;
1491
1492                                 RegionFactory::region_name (region_name, _write_source->name(), false);
1493
1494                                 DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose ("%1 capture start @ %2 length %3 add new region %4\n",
1495                                                         _name, (*ci)->start, (*ci)->frames, region_name));
1496
1497
1498                                 // cerr << _name << ": based on ci of " << (*ci)->start << " for " << (*ci)->frames << " add a region\n";
1499
1500                                 try {
1501                                         PropertyList plist;
1502
1503                                         /* start of this region is the offset between the start of its capture and the start of the whole pass */
1504                                         plist.add (Properties::start, (*ci)->start - initial_capture);
1505                                         plist.add (Properties::length, (*ci)->frames);
1506                                         plist.add (Properties::length_beats, converter.from((*ci)->frames).to_double());
1507                                         plist.add (Properties::name, region_name);
1508
1509                                         boost::shared_ptr<Region> rx (RegionFactory::create (srcs, plist));
1510                                         region = boost::dynamic_pointer_cast<MidiRegion> (rx);
1511                                         if (preroll_off > 0) {
1512                                                 region->trim_front ((*ci)->start - initial_capture + preroll_off);
1513                                         }
1514                                 }
1515
1516                                 catch (failed_constructor& err) {
1517                                         error << _("MidiDiskstream: could not create region for captured midi!") << endmsg;
1518                                         continue; /* XXX is this OK? */
1519                                 }
1520
1521                                 // cerr << "add new region, buffer position = " << buffer_position << " @ " << (*ci)->start << endl;
1522
1523                                 i_am_the_modifier++;
1524                                 _playlist->add_region (region, (*ci)->start + preroll_off);
1525                                 i_am_the_modifier--;
1526                         }
1527
1528                         _playlist->thaw ();
1529                         _session.add_command (new StatefulDiffCommand(_playlist));
1530
1531                 } else {
1532
1533                         /* No data was recorded, so this capture will
1534                            effectively be aborted; do the same as we
1535                            do for an explicit abort.
1536                         */
1537
1538                         if (_write_source) {
1539                                 _write_source->mark_for_remove ();
1540                                 _write_source->drop_references ();
1541                                 _write_source.reset();
1542                         }
1543                 }
1544
1545         }
1546
1547         use_new_write_source (0);
1548
1549         for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1550                 delete *ci;
1551         }
1552
1553         capture_info.clear ();
1554         capture_start_frame = 0;
1555
1556   no_capture_stuff_to_do:
1557
1558         reset_tracker ();
1559 }
1560 #endif
1561
1562 void
1563 DiskWriter::transport_looped (framepos_t transport_frame)
1564 {
1565         if (was_recording) {
1566                 // all we need to do is finish this capture, with modified capture length
1567                 boost::shared_ptr<ChannelList> c = channels.reader();
1568
1569                 finish_capture (c);
1570
1571                 // the next region will start recording via the normal mechanism
1572                 // we'll set the start position to the current transport pos
1573                 // no latency adjustment or capture offset needs to be made, as that already happened the first time
1574                 capture_start_frame = transport_frame;
1575                 first_recordable_frame = transport_frame; // mild lie
1576                 last_recordable_frame = max_framepos;
1577                 was_recording = true;
1578
1579                 if (recordable() && destructive()) {
1580                         for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1581
1582                                 RingBufferNPT<CaptureTransition>::rw_vector transvec;
1583                                 (*chan)->capture_transition_buf->get_write_vector(&transvec);
1584
1585                                 if (transvec.len[0] > 0) {
1586                                         transvec.buf[0]->type = CaptureStart;
1587                                         transvec.buf[0]->capture_val = capture_start_frame;
1588                                         (*chan)->capture_transition_buf->increment_write_ptr(1);
1589                                 }
1590                                 else {
1591                                         // bad!
1592                                         fatal << X_("programming error: capture_transition_buf is full on rec loop!  inconceivable!")
1593                                               << endmsg;
1594                                 }
1595                         }
1596                 }
1597
1598         }
1599
1600         /* Here we only keep track of the number of captured loops so monotonic
1601            event times can be delivered to the write source in process().  Trying
1602            to be clever here is a world of trouble, it is better to simply record
1603            the input in a straightforward non-destructive way.  In the future when
1604            we want to implement more clever MIDI looping modes it should be done in
1605            the Source and/or entirely after the capture is finished.
1606         */
1607         if (was_recording) {
1608                 g_atomic_int_add(const_cast<gint*> (&_num_captured_loops), 1);
1609         }
1610 }
1611
1612 void
1613 DiskWriter::setup_destructive_playlist ()
1614 {
1615         SourceList srcs;
1616         boost::shared_ptr<ChannelList> c = channels.reader();
1617
1618         for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1619                 srcs.push_back ((*chan)->write_source);
1620         }
1621
1622         /* a single full-sized region */
1623
1624         assert (!srcs.empty ());
1625
1626         PropertyList plist;
1627         plist.add (Properties::name, _name.val());
1628         plist.add (Properties::start, 0);
1629         plist.add (Properties::length, max_framepos - srcs.front()->natural_position());
1630
1631         boost::shared_ptr<Region> region (RegionFactory::create (srcs, plist));
1632         _playlists[DataType::AUDIO]->add_region (region, srcs.front()->natural_position());
1633
1634         /* apply region properties and update write sources */
1635         use_destructive_playlist();
1636 }
1637
1638 void
1639 DiskWriter::use_destructive_playlist ()
1640 {
1641         /* this is called from the XML-based constructor or ::set_destructive. when called,
1642            we already have a playlist and a region, but we need to
1643            set up our sources for write. we use the sources associated
1644            with the (presumed single, full-extent) region.
1645         */
1646
1647         boost::shared_ptr<Region> rp;
1648         {
1649                 const RegionList& rl (_playlists[DataType::AUDIO]->region_list_property().rlist());
1650                 if (rl.size() > 0) {
1651                         /* this can happen when dragging a region onto a tape track */
1652                         assert((rl.size() == 1));
1653                         rp = rl.front();
1654                 }
1655         }
1656
1657         if (!rp) {
1658                 reset_write_sources (false, true);
1659                 return;
1660         }
1661
1662         boost::shared_ptr<AudioRegion> region = boost::dynamic_pointer_cast<AudioRegion> (rp);
1663
1664         if (region == 0) {
1665                 throw failed_constructor();
1666         }
1667
1668         /* be sure to stretch the region out to the maximum length (non-musical)*/
1669
1670         region->set_length (max_framepos - region->position(), 0);
1671
1672         uint32_t n;
1673         ChannelList::iterator chan;
1674         boost::shared_ptr<ChannelList> c = channels.reader();
1675
1676         for (n = 0, chan = c->begin(); chan != c->end(); ++chan, ++n) {
1677                 (*chan)->write_source = boost::dynamic_pointer_cast<AudioFileSource>(region->source (n));
1678                 assert((*chan)->write_source);
1679                 (*chan)->write_source->set_allow_remove_if_empty (false);
1680
1681                 /* this might be false if we switched modes, so force it */
1682
1683 #ifdef XXX_OLD_DESTRUCTIVE_API_XXX
1684                 (*chan)->write_source->set_destructive (true);
1685 #else
1686                 // should be set when creating the source or loading the state
1687                 assert ((*chan)->write_source->destructive());
1688 #endif
1689         }
1690
1691         /* the source list will never be reset for a destructive track */
1692 }
1693
1694 void
1695 DiskWriter::adjust_buffering ()
1696 {
1697         boost::shared_ptr<ChannelList> c = channels.reader();
1698
1699         for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1700                 (*chan)->resize (_session.butler()->audio_diskstream_capture_buffer_size());
1701         }
1702 }