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