libs/ardour/midi_diskstream.cc

   1 /*
   2     Copyright (C) 2000-2003 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 #include <fstream>
  20 #include <cstdio>
  21 #include <unistd.h>
  22 #include <cmath>
  23 #include <cerrno>
  24 #include <string>
  25 #include <climits>
  26 #include <fcntl.h>
  27 #include <cstdlib>
  28 #include <ctime>
  29 #include <sys/stat.h>
  30 #include <sys/mman.h>
  31
  32 #include "pbd/error.h"
  33 #include "pbd/basename.h"
  34 #include <glibmm/thread.h>
  35 #include "pbd/xml++.h"
  36 #include "pbd/memento_command.h"
  37 #include "pbd/enumwriter.h"
  38 #include "pbd/stateful_diff_command.h"
  39 #include "pbd/stacktrace.h"
  40
  41 #include "ardour/ardour.h"
  42 #include "ardour/audioengine.h"
  43 #include "ardour/butler.h"
  44 #include "ardour/configuration.h"
  45 #include "ardour/cycle_timer.h"
  46 #include "ardour/debug.h"
  47 #include "ardour/io.h"
  48 #include "ardour/midi_diskstream.h"
  49 #include "ardour/midi_model.h"
  50 #include "ardour/midi_playlist.h"
  51 #include "ardour/midi_port.h"
  52 #include "ardour/midi_region.h"
  53 #include "ardour/playlist_factory.h"
  54 #include "ardour/region_factory.h"
  55 #include "ardour/route.h"
  56 #include "ardour/send.h"
  57 #include "ardour/session.h"
  58 #include "ardour/session_playlists.h"
  59 #include "ardour/smf_source.h"
  60 #include "ardour/utils.h"
  61
  62 #include "midi++/types.h"
  63
  64 #include "i18n.h"
  65 #include <locale.h>
  66
  67 using namespace std;
  68 using namespace ARDOUR;
  69 using namespace PBD;
  70
  71 framecnt_t MidiDiskstream::midi_readahead = 4096;
  72
  73 MidiDiskstream::MidiDiskstream (Session &sess, const string &name, Diskstream::Flag flag)
  74         : Diskstream(sess, name, flag)
  75         , _playback_buf(0)
  76         , _capture_buf(0)
  77         , _note_mode(Sustained)
  78         , _frames_written_to_ringbuffer(0)
  79         , _frames_read_from_ringbuffer(0)
  80         , _gui_feed_buffer(AudioEngine::instance()->raw_buffer_size (DataType::MIDI))
  81 {
  82         in_set_state = true;
  83
  84         init ();
  85         use_new_playlist ();
  86         use_new_write_source (0);
  87
  88         in_set_state = false;
  89
  90         assert(!destructive());
  91 }
  92
  93 MidiDiskstream::MidiDiskstream (Session& sess, const XMLNode& node)
  94         : Diskstream(sess, node)
  95         , _playback_buf(0)
  96         , _capture_buf(0)
  97         , _note_mode(Sustained)
  98         , _frames_written_to_ringbuffer(0)
  99         , _frames_read_from_ringbuffer(0)
 100         , _gui_feed_buffer(AudioEngine::instance()->raw_buffer_size (DataType::MIDI))
 101 {
 102         in_set_state = true;
 103
 104         init ();
 105
 106         if (set_state (node, Stateful::loading_state_version)) {
 107                 in_set_state = false;
 108                 throw failed_constructor();
 109         }
 110
 111         use_new_write_source (0);
 112
 113         in_set_state = false;
 114 }
 115
 116 void
 117 MidiDiskstream::init ()
 118 {
 119         /* there are no channels at this point, so these
 120            two calls just get speed_buffer_size and wrap_buffer
 121            size setup without duplicating their code.
 122         */
 123
 124         set_block_size (_session.get_block_size());
 125         allocate_temporary_buffers ();
 126
 127         const size_t size = _session.butler()->midi_diskstream_buffer_size();
 128         _playback_buf = new MidiRingBuffer<framepos_t>(size);
 129         _capture_buf = new MidiRingBuffer<framepos_t>(size);
 130
 131         _n_channels = ChanCount(DataType::MIDI, 1);
 132
 133         assert(recordable());
 134 }
 135
 136 MidiDiskstream::~MidiDiskstream ()
 137 {
 138         Glib::Mutex::Lock lm (state_lock);
 139 }
 140
 141
 142 void
 143 MidiDiskstream::non_realtime_locate (framepos_t position)
 144 {
 145         if (_write_source) {
 146                 _write_source->set_timeline_position (position);
 147         }
 148         seek (position, false);
 149 }
 150
 151
 152 void
 153 MidiDiskstream::non_realtime_input_change ()
 154 {
 155         {
 156                 Glib::Mutex::Lock lm (state_lock);
 157
 158                 if (input_change_pending.type == IOChange::NoChange) {
 159                         return;
 160                 }
 161
 162                 if (input_change_pending.type & IOChange::ConfigurationChanged) {
 163                         uint32_t ni = _io->n_ports().n_midi();
 164
 165                         if (ni != _n_channels.n_midi()) {
 166                                 error << string_compose (_("%1: I/O configuration change %4 requested to use %2, but channel setup is %3"),
 167                                                          name(),
 168                                                          _io->n_ports(),
 169                                                          _n_channels, input_change_pending.type)
 170                                       << endmsg;
 171                         }
 172
 173                         if (ni == 0) {
 174                                 _source_port.reset ();
 175                         } else {
 176                                 _source_port = _io->midi(0);
 177                         }
 178                 }
 179
 180                 if (input_change_pending.type & IOChange::ConnectionsChanged) {
 181                         set_capture_offset ();
 182                         set_align_style_from_io ();
 183                 }
 184
 185                 input_change_pending.type = IOChange::NoChange;
 186
 187                 /* implicit unlock */
 188         }
 189
 190         /* unlike with audio, there is never any need to reset write sources
 191            based on input configuration changes because ... a MIDI track
 192            has just 1 MIDI port as input, always.
 193         */
 194
 195         /* now refill channel buffers */
 196
 197         if (speed() != 1.0f || speed() != -1.0f) {
 198                 seek ((framepos_t) (_session.transport_frame() * (double) speed()));
 199         }
 200         else {
 201                 seek (_session.transport_frame());
 202         }
 203
 204         if (_write_source) {
 205                 _write_source->set_last_write_end (_session.transport_frame());
 206         }
 207 }
 208
 209 int
 210 MidiDiskstream::find_and_use_playlist (const string& name)
 211 {
 212         boost::shared_ptr<MidiPlaylist> playlist;
 213
 214         if ((playlist = boost::dynamic_pointer_cast<MidiPlaylist> (_session.playlists->by_name (name))) == 0) {
 215                 playlist = boost::dynamic_pointer_cast<MidiPlaylist> (PlaylistFactory::create (DataType::MIDI, _session, name));
 216         }
 217
 218         if (!playlist) {
 219                 error << string_compose(_("MidiDiskstream: Playlist \"%1\" isn't an midi playlist"), name) << endmsg;
 220                 return -1;
 221         }
 222
 223         return use_playlist (playlist);
 224 }
 225
 226 int
 227 MidiDiskstream::use_playlist (boost::shared_ptr<Playlist> playlist)
 228 {
 229         assert(boost::dynamic_pointer_cast<MidiPlaylist>(playlist));
 230
 231         Diskstream::use_playlist(playlist);
 232
 233         return 0;
 234 }
 235
 236 int
 237 MidiDiskstream::use_new_playlist ()
 238 {
 239         string newname;
 240         boost::shared_ptr<MidiPlaylist> playlist;
 241
 242         if (!in_set_state && destructive()) {
 243                 return 0;
 244         }
 245
 246         if (_playlist) {
 247                 newname = Playlist::bump_name (_playlist->name(), _session);
 248         } else {
 249                 newname = Playlist::bump_name (_name, _session);
 250         }
 251
 252         if ((playlist = boost::dynamic_pointer_cast<MidiPlaylist> (PlaylistFactory::create (
 253                         DataType::MIDI, _session, newname, hidden()))) != 0) {
 254
 255                 return use_playlist (playlist);
 256
 257         } else {
 258                 return -1;
 259         }
 260 }
 261
 262 int
 263 MidiDiskstream::use_copy_playlist ()
 264 {
 265         assert(midi_playlist());
 266
 267         if (destructive()) {
 268                 return 0;
 269         }
 270
 271         if (_playlist == 0) {
 272                 error << string_compose(_("MidiDiskstream %1: there is no existing playlist to make a copy of!"), _name) << endmsg;
 273                 return -1;
 274         }
 275
 276         string newname;
 277         boost::shared_ptr<MidiPlaylist> playlist;
 278
 279         newname = Playlist::bump_name (_playlist->name(), _session);
 280
 281         if ((playlist  = boost::dynamic_pointer_cast<MidiPlaylist>(PlaylistFactory::create (midi_playlist(), newname))) != 0) {
 282                 return use_playlist (playlist);
 283         } else {
 284                 return -1;
 285         }
 286 }
 287
 288 /** Overloaded from parent to die horribly
 289  */
 290 int
 291 MidiDiskstream::set_destructive (bool yn)
 292 {
 293         yn = 0; // stop pedantic gcc complaints about unused parameter
 294         assert( ! destructive());
 295         assert( ! yn);
 296         return -1;
 297 }
 298
 299 void
 300 MidiDiskstream::set_note_mode (NoteMode m)
 301 {
 302         _note_mode = m;
 303         midi_playlist()->set_note_mode(m);
 304         if (_write_source && _write_source->model())
 305                 _write_source->model()->set_note_mode(m);
 306 }
 307
 308 #if 0
 309 static void
 310 trace_midi (ostream& o, MIDI::byte *msg, size_t len)
 311 {
 312         using namespace MIDI;
 313         eventType type;
 314         const char trace_prefix = ':';
 315
 316         type = (eventType) (msg[0]&0xF0);
 317
 318         switch (type) {
 319         case off:
 320                 o << trace_prefix
 321                    << "Channel "
 322                    << (msg[0]&0xF)+1
 323                    << " NoteOff NoteNum "
 324                    << (int) msg[1]
 325                    << " Vel "
 326                    << (int) msg[2]
 327                    << endl;
 328                 break;
 329
 330         case on:
 331                 o << trace_prefix
 332                    << "Channel "
 333                    << (msg[0]&0xF)+1
 334                    << " NoteOn NoteNum "
 335                    << (int) msg[1]
 336                    << " Vel "
 337                    << (int) msg[2]
 338                    << endl;
 339                 break;
 340
 341         case polypress:
 342                 o << trace_prefix
 343                    << "Channel "
 344                    << (msg[0]&0xF)+1
 345                    << " PolyPressure"
 346                    << (int) msg[1]
 347                    << endl;
 348                 break;
 349
 350         case MIDI::controller:
 351                 o << trace_prefix
 352                    << "Channel "
 353                    << (msg[0]&0xF)+1
 354                    << " Controller "
 355                    << (int) msg[1]
 356                    << " Value "
 357                    << (int) msg[2]
 358                    << endl;
 359                 break;
 360
 361         case program:
 362                 o << trace_prefix
 363                    << "Channel "
 364                    << (msg[0]&0xF)+1
 365                    <<  " Program Change ProgNum "
 366                    << (int) msg[1]
 367                    << endl;
 368                 break;
 369
 370         case chanpress:
 371                 o << trace_prefix
 372                    << "Channel "
 373                    << (msg[0]&0xF)+1
 374                    << " Channel Pressure "
 375                    << (int) msg[1]
 376                    << endl;
 377                 break;
 378
 379         case MIDI::pitchbend:
 380                 o << trace_prefix
 381                    << "Channel "
 382                    << (msg[0]&0xF)+1
 383                    << " Pitch Bend "
 384                    << ((msg[2]<<7)|msg[1])
 385                    << endl;
 386                 break;
 387
 388         case MIDI::sysex:
 389                 if (len == 1) {
 390                         switch (msg[0]) {
 391                         case 0xf8:
 392                                 o << trace_prefix
 393                                    << "Clock"
 394                                    << endl;
 395                                 break;
 396                         case 0xfa:
 397                                 o << trace_prefix
 398                                    << "Start"
 399                                    << endl;
 400                                 break;
 401                         case 0xfb:
 402                                 o << trace_prefix
 403                                    << "Continue"
 404                                    << endl;
 405                                 break;
 406                         case 0xfc:
 407                                 o << trace_prefix
 408                                    << "Stop"
 409                                    << endl;
 410                                 break;
 411                         case 0xfe:
 412                                 o << trace_prefix
 413                                    << "Active Sense"
 414                                    << endl;
 415                                 break;
 416                         case 0xff:
 417                                 o << trace_prefix
 418                                    << "System Reset"
 419                                    << endl;
 420                                 break;
 421                         default:
 422                                 o << trace_prefix
 423                                    << "System Exclusive (1 byte : " << hex << (int) *msg << dec << ')'
 424                                    << endl;
 425                                 break;
 426                         }
 427                 } else {
 428                         o << trace_prefix
 429                            << "System Exclusive (" << len << ") = [ " << hex;
 430                         for (unsigned int i = 0; i < len; ++i) {
 431                                 o << (int) msg[i] << ' ';
 432                         }
 433                         o << dec << ']' << endl;
 434
 435                 }
 436                 break;
 437
 438         case MIDI::song:
 439                 o << trace_prefix << "Song" << endl;
 440                 break;
 441
 442         case MIDI::tune:
 443                 o << trace_prefix << "Tune" << endl;
 444                 break;
 445
 446         case MIDI::eox:
 447                 o << trace_prefix << "End-of-System Exclusive" << endl;
 448                 break;
 449
 450         case MIDI::timing:
 451                 o << trace_prefix << "Timing" << endl;
 452                 break;
 453
 454         case MIDI::start:
 455                 o << trace_prefix << "Start" << endl;
 456                 break;
 457
 458         case MIDI::stop:
 459                 o << trace_prefix << "Stop" << endl;
 460                 break;
 461
 462         case MIDI::contineu:
 463                 o << trace_prefix << "Continue" << endl;
 464                 break;
 465
 466         case active:
 467                 o << trace_prefix << "Active Sense" << endl;
 468                 break;
 469
 470         default:
 471                 o << trace_prefix << "Unrecognized MIDI message" << endl;
 472                 break;
 473         }
 474 }
 475 #endif
 476
 477 int
 478 MidiDiskstream::process (framepos_t transport_frame, pframes_t nframes, framecnt_t& playback_distance)
 479 {
 480         framecnt_t rec_offset = 0;
 481         framecnt_t rec_nframes = 0;
 482         bool      nominally_recording;
 483         bool      re = record_enabled ();
 484         bool      can_record = _session.actively_recording ();
 485
 486         playback_distance = 0;
 487
 488         check_record_status (transport_frame, can_record);
 489
 490         nominally_recording = (can_record && re);
 491
 492         if (nframes == 0) {
 493                 return 0;
 494         }
 495
 496         boost::shared_ptr<MidiPort> sp = _source_port.lock ();
 497
 498         if (sp == 0) {
 499                 return 1;
 500         }
 501
 502         Glib::Mutex::Lock sm (state_lock, Glib::TRY_LOCK);
 503
 504         if (!sm.locked()) {
 505                 return 1;
 506         }
 507
 508         adjust_capture_position = 0;
 509
 510         if (nominally_recording || (re && was_recording && _session.get_record_enabled() && _session.config.get_punch_in())) {
 511                 OverlapType ot = coverage (first_recordable_frame, last_recordable_frame, transport_frame, transport_frame + nframes);
 512
 513                 calculate_record_range(ot, transport_frame, nframes, rec_nframes, rec_offset);
 514
 515                 if (rec_nframes && !was_recording) {
 516                         _write_source->mark_write_starting_now ();
 517                         capture_captured = 0;
 518                         was_recording = true;
 519                 }
 520         }
 521
 522         if (can_record && !_last_capture_sources.empty()) {
 523                 _last_capture_sources.clear ();
 524         }
 525
 526         if (nominally_recording || rec_nframes) {
 527
 528                 // Pump entire port buffer into the ring buffer (FIXME: split cycles?)
 529                 MidiBuffer& buf = sp->get_midi_buffer(nframes);
 530                 for (MidiBuffer::iterator i = buf.begin(); i != buf.end(); ++i) {
 531                         const Evoral::MIDIEvent<MidiBuffer::TimeType> ev(*i, false);
 532                         assert(ev.buffer());
 533 #ifndef NDEBUG
 534                         if (DEBUG::MidiIO & PBD::debug_bits) {
 535                                 const uint8_t* __data = ev.buffer();
 536                                 DEBUG_STR_DECL(a);
 537                                 DEBUG_STR_APPEND(a, string_compose ("mididiskstream %1 capture event @ %2 + %3 sz %4 ", this, ev.time(), transport_frame, ev.size()));
 538                                 for (size_t i=0; i < ev.size(); ++i) {
 539                                         DEBUG_STR_APPEND(a,hex);
 540                                         DEBUG_STR_APPEND(a,"0x");
 541                                         DEBUG_STR_APPEND(a,(int)__data[i]);
 542                                         DEBUG_STR_APPEND(a,' ');
 543                                 }
 544                                 DEBUG_STR_APPEND(a,'\n');
 545                                 DEBUG_TRACE (DEBUG::MidiIO, DEBUG_STR(a).str());
 546                         }
 547 #endif
 548                         _capture_buf->write(ev.time() + transport_frame, ev.type(), ev.size(), ev.buffer());
 549                 }
 550
 551                 if (buf.size() != 0) {
 552                         Glib::Mutex::Lock lm (_gui_feed_buffer_mutex, Glib::TRY_LOCK);
 553
 554                         if (lm.locked ()) {
 555                                 /* Copy this data into our GUI feed buffer and tell the GUI
 556                                    that it can read it if it likes.
 557                                 */
 558                                 _gui_feed_buffer.clear ();
 559
 560                                 for (MidiBuffer::iterator i = buf.begin(); i != buf.end(); ++i) {
 561                                         /* This may fail if buf is larger than _gui_feed_buffer, but it's not really
 562                                            the end of the world if it does.
 563                                         */
 564                                         _gui_feed_buffer.push_back ((*i).time() + transport_frame, (*i).size(), (*i).buffer());
 565                                 }
 566                         }
 567
 568                         DataRecorded (_write_source); /* EMIT SIGNAL */
 569                 }
 570
 571         } else {
 572
 573                 if (was_recording) {
 574                         finish_capture ();
 575                 }
 576
 577         }
 578
 579         if (rec_nframes) {
 580
 581                 /* data will be written to disk */
 582
 583                 if (rec_nframes == nframes && rec_offset == 0) {
 584                         playback_distance = nframes;
 585                 }
 586
 587                 adjust_capture_position = rec_nframes;
 588
 589         } else if (nominally_recording) {
 590
 591                 /* XXXX do this for MIDI !!!
 592                    can't do actual capture yet - waiting for latency effects to finish before we start
 593                    */
 594
 595                 playback_distance = nframes;
 596
 597         } else {
 598
 599                 /* XXX: should be doing varispeed stuff here, similar to the code in AudioDiskstream::process */
 600
 601                 playback_distance = nframes;
 602
 603         }
 604
 605         return 0;
 606 }
 607
 608 bool
 609 MidiDiskstream::commit (framecnt_t playback_distance)
 610 {
 611         bool need_butler = false;
 612
 613         if (_actual_speed < 0.0) {
 614                 playback_sample -= playback_distance;
 615         } else {
 616                 playback_sample += playback_distance;
 617         }
 618
 619         if (adjust_capture_position != 0) {
 620                 capture_captured += adjust_capture_position;
 621                 adjust_capture_position = 0;
 622         }
 623
 624         uint32_t frames_read = g_atomic_int_get(&_frames_read_from_ringbuffer);
 625         uint32_t frames_written = g_atomic_int_get(&_frames_written_to_ringbuffer);
 626
 627         assert (frames_read <= frames_written);
 628
 629         if ((frames_written - frames_read) + playback_distance < midi_readahead) {
 630                 need_butler = true;
 631         }
 632
 633         /*cerr << "MDS written: " << frames_written << " - read: " << frames_read <<
 634                 " = " << frames_written - frames_read
 635                 << " + " << nframes << " < " << midi_readahead << " = " << need_butler << ")" << endl;*/
 636
 637         return need_butler;
 638 }
 639
 640 void
 641 MidiDiskstream::set_pending_overwrite (bool yn)
 642 {
 643         /* called from audio thread, so we can use the read ptr and playback sample as we wish */
 644
 645         _pending_overwrite = yn;
 646         overwrite_frame = playback_sample;
 647 }
 648
 649 int
 650 MidiDiskstream::overwrite_existing_buffers ()
 651 {
 652         /* This is safe as long as the butler thread is suspended, which it should be */
 653         _playback_buf->reset ();
 654
 655         g_atomic_int_set (&_frames_read_from_ringbuffer, 0);
 656         g_atomic_int_set (&_frames_written_to_ringbuffer, 0);
 657
 658         read (overwrite_frame, disk_io_chunk_frames, false);
 659         file_frame = overwrite_frame; // it was adjusted by ::read()
 660         overwrite_queued = false;
 661         _pending_overwrite = false;
 662
 663         return 0;
 664 }
 665
 666 int
 667 MidiDiskstream::seek (framepos_t frame, bool complete_refill)
 668 {
 669         Glib::Mutex::Lock lm (state_lock);
 670         int ret = -1;
 671
 672         _playback_buf->reset();
 673         _capture_buf->reset();
 674         g_atomic_int_set(&_frames_read_from_ringbuffer, 0);
 675         g_atomic_int_set(&_frames_written_to_ringbuffer, 0);
 676
 677         playback_sample = frame;
 678         file_frame = frame;
 679
 680         if (complete_refill) {
 681                 while ((ret = do_refill_with_alloc ()) > 0) ;
 682         } else {
 683                 ret = do_refill_with_alloc ();
 684         }
 685
 686         return ret;
 687 }
 688
 689 int
 690 MidiDiskstream::can_internal_playback_seek (framecnt_t distance)
 691 {
 692         uint32_t frames_read    = g_atomic_int_get(&_frames_read_from_ringbuffer);
 693         uint32_t frames_written = g_atomic_int_get(&_frames_written_to_ringbuffer);
 694         return ((frames_written - frames_read) < distance);
 695 }
 696
 697 int
 698 MidiDiskstream::internal_playback_seek (framecnt_t distance)
 699 {
 700         first_recordable_frame += distance;
 701         playback_sample += distance;
 702
 703         return 0;
 704 }
 705
 706 /** @a start is set to the new frame position (TIME) read up to */
 707 int
 708 MidiDiskstream::read (framepos_t& start, framecnt_t dur, bool reversed)
 709 {
 710         framecnt_t this_read = 0;
 711         bool reloop = false;
 712         framepos_t loop_end = 0;
 713         framepos_t loop_start = 0;
 714         Location *loc = 0;
 715
 716         if (!reversed) {
 717
 718                 framecnt_t loop_length = 0;
 719
 720                 /* Make the use of a Location atomic for this read operation.
 721
 722                    Note: Locations don't get deleted, so all we care about
 723                    when I say "atomic" is that we are always pointing to
 724                    the same one and using a start/length values obtained
 725                    just once.
 726                 */
 727
 728                 if ((loc = loop_location) != 0) {
 729                         loop_start = loc->start();
 730                         loop_end = loc->end();
 731                         loop_length = loop_end - loop_start;
 732                 }
 733
 734                 /* if we are looping, ensure that the first frame we read is at the correct
 735                    position within the loop.
 736                 */
 737
 738                 if (loc && (start >= loop_end)) {
 739                         //cerr << "start adjusted from " << start;
 740                         start = loop_start + ((start - loop_start) % loop_length);
 741                         //cerr << "to " << start << endl;
 742                 }
 743                 // cerr << "start is " << start << " end " << start+dur << "  loopstart: " << loop_start << "  loopend: " << loop_end << endl;
 744         }
 745
 746         while (dur) {
 747
 748                 /* take any loop into account. we can't read past the end of the loop. */
 749
 750                 if (loc && (loop_end - start <= dur)) {
 751                         this_read = loop_end - start;
 752                         // cerr << "reloop true: thisread: " << this_read << "  dur: " << dur << endl;
 753                         reloop = true;
 754                 } else {
 755                         reloop = false;
 756                         this_read = dur;
 757                 }
 758
 759                 if (this_read == 0) {
 760                         break;
 761                 }
 762
 763                 this_read = min(dur,this_read);
 764
 765                 if (midi_playlist()->read (*_playback_buf, start, this_read) != this_read) {
 766                         error << string_compose(
 767                                         _("MidiDiskstream %1: cannot read %2 from playlist at frame %3"),
 768                                         id(), this_read, start) << endmsg;
 769                         return -1;
 770                 }
 771
 772                 g_atomic_int_add(&_frames_written_to_ringbuffer, this_read);
 773
 774                 if (reversed) {
 775
 776                         // Swap note ons with note offs here.  etc?
 777                         // Fully reversing MIDI requires look-ahead (well, behind) to find previous
 778                         // CC values etc.  hard.
 779
 780                 } else {
 781
 782                         /* if we read to the end of the loop, go back to the beginning */
 783
 784                         if (reloop) {
 785                                 // Synthesize LoopEvent here, because the next events
 786                                 // written will have non-monotonic timestamps.
 787                                 _playback_buf->write(loop_end - 1, LoopEventType, sizeof (framepos_t), (uint8_t *) &loop_start);
 788                                 start = loop_start;
 789                         } else {
 790                                 start += this_read;
 791                         }
 792                 }
 793
 794                 dur -= this_read;
 795                 //offset += this_read;
 796         }
 797
 798         return 0;
 799 }
 800
 801 int
 802 MidiDiskstream::do_refill_with_alloc ()
 803 {
 804         return do_refill();
 805 }
 806
 807 int
 808 MidiDiskstream::do_refill ()
 809 {
 810         int     ret         = 0;
 811         size_t  write_space = _playback_buf->write_space();
 812         bool    reversed    = (_visible_speed * _session.transport_speed()) < 0.0f;
 813
 814         if (write_space == 0) {
 815                 return 0;
 816         }
 817
 818         if (reversed) {
 819                 return 0;
 820         }
 821
 822         /* at end: nothing to do */
 823         if (file_frame == max_framepos) {
 824                 return 0;
 825         }
 826
 827         // At this point we...
 828         assert(_playback_buf->write_space() > 0); // ... have something to write to, and
 829         assert(file_frame <= max_framepos); // ... something to write
 830
 831         // now calculate how much time is in the ringbuffer.
 832         // and lets write as much as we need to get this to be midi_readahead;
 833         uint32_t frames_read = g_atomic_int_get(&_frames_read_from_ringbuffer);
 834         uint32_t frames_written = g_atomic_int_get(&_frames_written_to_ringbuffer);
 835         if ((frames_written - frames_read) >= midi_readahead) {
 836                 return 0;
 837         }
 838
 839         framecnt_t to_read = midi_readahead - (frames_written - frames_read);
 840
 841         //cout << "MDS read for midi_readahead " << to_read << "  rb_contains: "
 842         //      << frames_written - frames_read << endl;
 843
 844         to_read = (framecnt_t) min ((framecnt_t) to_read, (framecnt_t) (max_framepos - file_frame));
 845
 846         if (read (file_frame, to_read, reversed)) {
 847                 ret = -1;
 848         }
 849
 850         return ret;
 851 }
 852
 853 /** Flush pending data to disk.
 854  *
 855  * Important note: this function will write *AT MOST* disk_io_chunk_frames
 856  * of data to disk. it will never write more than that.  If it writes that
 857  * much and there is more than that waiting to be written, it will return 1,
 858  * otherwise 0 on success or -1 on failure.
 859  *
 860  * If there is less than disk_io_chunk_frames to be written, no data will be
 861  * written at all unless @a force_flush is true.
 862  */
 863 int
 864 MidiDiskstream::do_flush (RunContext /*context*/, bool force_flush)
 865 {
 866         framecnt_t to_write;
 867         framecnt_t total;
 868         int32_t ret = 0;
 869
 870         if (!_write_source) {
 871                 return 0;
 872         }
 873
 874         assert (!destructive());
 875
 876         total = _session.transport_frame() - _write_source->last_write_end();
 877
 878         if (total == 0 ||
 879             _capture_buf->read_space() == 0 ||
 880             (!force_flush && (total < disk_io_chunk_frames) && was_recording)) {
 881                 goto out;
 882         }
 883
 884         /* if there are 2+ chunks of disk i/o possible for
 885            this track, let the caller know so that it can arrange
 886            for us to be called again, ASAP.
 887
 888            if we are forcing a flush, then if there is* any* extra
 889            work, let the caller know.
 890
 891            if we are no longer recording and there is any extra work,
 892            let the caller know too.
 893            */
 894
 895         if (total >= 2 * disk_io_chunk_frames || ((force_flush || !was_recording) && total > disk_io_chunk_frames)) {
 896                 ret = 1;
 897         }
 898
 899         if (force_flush) {
 900                 /* push out everything we have, right now */
 901                 to_write = max_framecnt;
 902         } else {
 903                 to_write = disk_io_chunk_frames;
 904         }
 905
 906         if (record_enabled() && ((total > disk_io_chunk_frames) || force_flush)) {
 907                 if (_write_source->midi_write (*_capture_buf, get_capture_start_frame (0), to_write) != to_write) {
 908                         error << string_compose(_("MidiDiskstream %1: cannot write to disk"), id()) << endmsg;
 909                         return -1;
 910                 }
 911         }
 912
 913 out:
 914         return ret;
 915 }
 916
 917 void
 918 MidiDiskstream::transport_stopped_wallclock (struct tm& /*when*/, time_t /*twhen*/, bool abort_capture)
 919 {
 920         bool more_work = true;
 921         int err = 0;
 922         boost::shared_ptr<MidiRegion> region;
 923         MidiRegion::SourceList srcs;
 924         MidiRegion::SourceList::iterator src;
 925         vector<CaptureInfo*>::iterator ci;
 926
 927         finish_capture ();
 928
 929         /* butler is already stopped, but there may be work to do
 930            to flush remaining data to disk.
 931            */
 932
 933         while (more_work && !err) {
 934                 switch (do_flush (TransportContext, true)) {
 935                 case 0:
 936                         more_work = false;
 937                         break;
 938                 case 1:
 939                         break;
 940                 case -1:
 941                         error << string_compose(_("MidiDiskstream \"%1\": cannot flush captured data to disk!"), _name) << endmsg;
 942                         err++;
 943                 }
 944         }
 945
 946         /* XXX is there anything we can do if err != 0 ? */
 947         Glib::Mutex::Lock lm (capture_info_lock);
 948
 949         if (capture_info.empty()) {
 950                 goto no_capture_stuff_to_do;
 951         }
 952
 953         if (abort_capture) {
 954
 955                 if (_write_source) {
 956                         _write_source->mark_for_remove ();
 957                         _write_source->drop_references ();
 958                         _write_source.reset();
 959                 }
 960
 961                 /* new source set up in "out" below */
 962
 963         } else {
 964
 965                 assert(_write_source);
 966
 967                 framecnt_t total_capture = 0;
 968                 for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
 969                         total_capture += (*ci)->frames;
 970                 }
 971
 972                 if (_write_source->length (capture_info.front()->start) != 0) {
 973
 974                         /* phew, we have data */
 975
 976                         /* figure out the name for this take */
 977
 978                         srcs.push_back (_write_source);
 979
 980                         _write_source->set_timeline_position (capture_info.front()->start);
 981                         _write_source->set_captured_for (_name);
 982
 983                         /* set length in beats to entire capture length */
 984
 985                         BeatsFramesConverter converter (_session.tempo_map(), capture_info.front()->start);
 986                         const double total_capture_beats = converter.from (total_capture);
 987                         _write_source->set_length_beats (total_capture_beats);
 988
 989                         /* flush to disk: this step differs from the audio path,
 990                            where all the data is already on disk.
 991                         */
 992
 993                         _write_source->mark_midi_streaming_write_completed (Evoral::Sequence<Evoral::MusicalTime>::ResolveStuckNotes, total_capture_beats);
 994
 995                         /* we will want to be able to keep (over)writing the source
 996                            but we don't want it to be removable. this also differs
 997                            from the audio situation, where the source at this point
 998                            must be considered immutable. luckily, we can rely on
 999                            MidiSource::mark_streaming_write_completed() to have
1000                            already done the necessary work for that.
1001                         */
1002
1003                         string whole_file_region_name;
1004                         whole_file_region_name = region_name_from_path (_write_source->name(), true);
1005
1006                         /* Register a new region with the Session that
1007                            describes the entire source. Do this first
1008                            so that any sub-regions will obviously be
1009                            children of this one (later!)
1010                         */
1011
1012                         try {
1013                                 PropertyList plist;
1014
1015                                 plist.add (Properties::name, whole_file_region_name);
1016                                 plist.add (Properties::whole_file, true);
1017                                 plist.add (Properties::automatic, true);
1018                                 plist.add (Properties::start, 0);
1019                                 plist.add (Properties::length, total_capture);
1020                                 plist.add (Properties::layer, 0);
1021
1022                                 boost::shared_ptr<Region> rx (RegionFactory::create (srcs, plist));
1023
1024                                 region = boost::dynamic_pointer_cast<MidiRegion> (rx);
1025                                 region->special_set_position (capture_info.front()->start);
1026                         }
1027
1028
1029                         catch (failed_constructor& err) {
1030                                 error << string_compose(_("%1: could not create region for complete midi file"), _name) << endmsg;
1031                                 /* XXX what now? */
1032                         }
1033
1034                         _last_capture_sources.insert (_last_capture_sources.end(), srcs.begin(), srcs.end());
1035
1036                         _playlist->clear_changes ();
1037                         _playlist->freeze ();
1038
1039                         /* Session frame time of the initial capture in this pass, which is where the source starts */
1040                         framepos_t initial_capture = 0;
1041                         if (!capture_info.empty()) {
1042                                 initial_capture = capture_info.front()->start;
1043                         }
1044
1045                         for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1046
1047                                 string region_name;
1048
1049                                 RegionFactory::region_name (region_name, _write_source->name(), false);
1050
1051                                 // cerr << _name << ": based on ci of " << (*ci)->start << " for " << (*ci)->frames << " add a region\n";
1052
1053                                 try {
1054                                         PropertyList plist;
1055
1056                                         /* start of this region is the offset between the start of its capture and the start of the whole pass */
1057                                         plist.add (Properties::start, (*ci)->start - initial_capture);
1058                                         plist.add (Properties::length, (*ci)->frames);
1059                                         plist.add (Properties::length_beats, converter.from((*ci)->frames));
1060                                         plist.add (Properties::name, region_name);
1061
1062                                         boost::shared_ptr<Region> rx (RegionFactory::create (srcs, plist));
1063                                         region = boost::dynamic_pointer_cast<MidiRegion> (rx);
1064                                 }
1065
1066                                 catch (failed_constructor& err) {
1067                                         error << _("MidiDiskstream: could not create region for captured midi!") << endmsg;
1068                                         continue; /* XXX is this OK? */
1069                                 }
1070
1071                                 // cerr << "add new region, buffer position = " << buffer_position << " @ " << (*ci)->start << endl;
1072
1073                                 i_am_the_modifier++;
1074                                 _playlist->add_region (region, (*ci)->start);
1075                                 i_am_the_modifier--;
1076                         }
1077
1078                         _playlist->thaw ();
1079                         _session.add_command (new StatefulDiffCommand(_playlist));
1080
1081                 } else {
1082
1083                         /* No data was recorded, so this capture will
1084                            effectively be aborted; do the same as we
1085                            do for an explicit abort.
1086                         */
1087
1088                         if (_write_source) {
1089                                 _write_source->mark_for_remove ();
1090                                 _write_source->drop_references ();
1091                                 _write_source.reset();
1092                         }
1093                 }
1094
1095         }
1096
1097         use_new_write_source (0);
1098
1099         for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1100                 delete *ci;
1101         }
1102
1103         capture_info.clear ();
1104         capture_start_frame = 0;
1105
1106   no_capture_stuff_to_do:
1107
1108         reset_tracker ();
1109 }
1110
1111 void
1112 MidiDiskstream::transport_looped (framepos_t transport_frame)
1113 {
1114         if (was_recording) {
1115
1116                 // adjust the capture length knowing that the data will be recorded to disk
1117                 // only necessary after the first loop where we're recording
1118                 if (capture_info.size() == 0) {
1119                         capture_captured += _capture_offset;
1120
1121                         if (_alignment_style == ExistingMaterial) {
1122                                 capture_captured += _session.worst_output_latency();
1123                         } else {
1124                                 capture_captured += _roll_delay;
1125                         }
1126                 }
1127
1128                 finish_capture ();
1129
1130                 // the next region will start recording via the normal mechanism
1131                 // we'll set the start position to the current transport pos
1132                 // no latency adjustment or capture offset needs to be made, as that already happened the first time
1133                 capture_start_frame = transport_frame;
1134                 first_recordable_frame = transport_frame; // mild lie
1135                 last_recordable_frame = max_framepos;
1136                 was_recording = true;
1137         }
1138
1139         if (!Config->get_seamless_loop()) {
1140                 reset_tracker ();
1141         }
1142 }
1143
1144 void
1145 MidiDiskstream::finish_capture ()
1146 {
1147         was_recording = false;
1148
1149         if (capture_captured == 0) {
1150                 return;
1151         }
1152
1153         // Why must we destroy?
1154         assert(!destructive());
1155
1156         CaptureInfo* ci = new CaptureInfo;
1157
1158         ci->start  = capture_start_frame;
1159         ci->frames = capture_captured;
1160
1161         /* XXX theoretical race condition here. Need atomic exchange ?
1162            However, the circumstances when this is called right
1163            now (either on record-disable or transport_stopped)
1164            mean that no actual race exists. I think ...
1165            We now have a capture_info_lock, but it is only to be used
1166            to synchronize in the transport_stop and the capture info
1167            accessors, so that invalidation will not occur (both non-realtime).
1168         */
1169
1170         // cerr << "Finish capture, add new CI, " << ci->start << '+' << ci->frames << endl;
1171
1172         capture_info.push_back (ci);
1173         capture_captured = 0;
1174 }
1175
1176 void
1177 MidiDiskstream::set_record_enabled (bool yn)
1178 {
1179         if (!recordable() || !_session.record_enabling_legal()) {
1180                 return;
1181         }
1182
1183         assert(!destructive());
1184
1185         /* yes, i know that this not proof against race conditions, but its
1186            good enough. i think.
1187         */
1188
1189         if (record_enabled() != yn) {
1190                 if (yn) {
1191                         engage_record_enable ();
1192                 } else {
1193                         disengage_record_enable ();
1194                 }
1195         }
1196 }
1197
1198 void
1199 MidiDiskstream::engage_record_enable ()
1200 {
1201         bool const rolling = _session.transport_speed() != 0.0f;
1202
1203         g_atomic_int_set (&_record_enabled, 1);
1204
1205         boost::shared_ptr<MidiPort> sp = _source_port.lock ();
1206
1207         if (sp && Config->get_monitoring_model() == HardwareMonitoring) {
1208                 sp->request_jack_monitors_input (!(_session.config.get_auto_input() && rolling));
1209         }
1210
1211         RecordEnableChanged (); /* EMIT SIGNAL */
1212 }
1213
1214 void
1215 MidiDiskstream::disengage_record_enable ()
1216 {
1217         g_atomic_int_set (&_record_enabled, 0);
1218         RecordEnableChanged (); /* EMIT SIGNAL */
1219 }
1220
1221 XMLNode&
1222 MidiDiskstream::get_state ()
1223 {
1224         XMLNode& node (Diskstream::get_state());
1225         char buf[64];
1226         LocaleGuard lg (X_("POSIX"));
1227
1228         node.add_property("channel-mode", enum_2_string(get_channel_mode()));
1229         snprintf (buf, sizeof(buf), "0x%x", get_channel_mask());
1230         node.add_property("channel-mask", buf);
1231
1232         if (_write_source && _session.get_record_enabled()) {
1233
1234                 XMLNode* cs_child = new XMLNode (X_("CapturingSources"));
1235                 XMLNode* cs_grandchild;
1236
1237                 cs_grandchild = new XMLNode (X_("file"));
1238                 cs_grandchild->add_property (X_("path"), _write_source->path());
1239                 cs_child->add_child_nocopy (*cs_grandchild);
1240
1241                 /* store the location where capture will start */
1242
1243                 Location* pi;
1244
1245                 if (_session.config.get_punch_in() && ((pi = _session.locations()->auto_punch_location()) != 0)) {
1246                         snprintf (buf, sizeof (buf), "%" PRId64, pi->start());
1247                 } else {
1248                         snprintf (buf, sizeof (buf), "%" PRId64, _session.transport_frame());
1249                 }
1250
1251                 cs_child->add_property (X_("at"), buf);
1252                 node.add_child_nocopy (*cs_child);
1253         }
1254
1255         return node;
1256 }
1257
1258 int
1259 MidiDiskstream::set_state (const XMLNode& node, int version)
1260 {
1261         const XMLProperty* prop;
1262         XMLNodeList nlist = node.children();
1263         XMLNodeIterator niter;
1264         XMLNode* capture_pending_node = 0;
1265         LocaleGuard lg (X_("POSIX"));
1266
1267         /* prevent write sources from being created */
1268
1269         in_set_state = true;
1270
1271         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1272                 assert ((*niter)->name() != IO::state_node_name);
1273
1274                 if ((*niter)->name() == X_("CapturingSources")) {
1275                         capture_pending_node = *niter;
1276                 }
1277         }
1278
1279         if (Diskstream::set_state (node, version)) {
1280                 return -1;
1281         }
1282
1283         ChannelMode channel_mode = AllChannels;
1284         if ((prop = node.property ("channel-mode")) != 0) {
1285                 channel_mode = ChannelMode (string_2_enum(prop->value(), channel_mode));
1286         }
1287
1288         unsigned int channel_mask = 0xFFFF;
1289         if ((prop = node.property ("channel-mask")) != 0) {
1290                 sscanf (prop->value().c_str(), "0x%x", &channel_mask);
1291                 if (channel_mask & (~0xFFFF)) {
1292                         warning << _("MidiDiskstream: XML property channel-mask out of range") << endmsg;
1293                 }
1294         }
1295
1296
1297         if (capture_pending_node) {
1298                 use_pending_capture_data (*capture_pending_node);
1299         }
1300
1301         set_channel_mode (channel_mode, channel_mask);
1302
1303         in_set_state = false;
1304
1305         return 0;
1306 }
1307
1308 int
1309 MidiDiskstream::use_new_write_source (uint32_t n)
1310 {
1311         if (!_session.writable() || !recordable()) {
1312                 return 1;
1313         }
1314
1315         assert(n == 0);
1316
1317         _write_source.reset();
1318
1319         try {
1320                 _write_source = boost::dynamic_pointer_cast<SMFSource>(
1321                         _session.create_midi_source_for_session (0, name ()));
1322
1323                 if (!_write_source) {
1324                         throw failed_constructor();
1325                 }
1326         }
1327
1328         catch (failed_constructor &err) {
1329                 error << string_compose (_("%1:%2 new capture file not initialized correctly"), _name, n) << endmsg;
1330                 _write_source.reset();
1331                 return -1;
1332         }
1333
1334         return 0;
1335 }
1336
1337 list<boost::shared_ptr<Source> >
1338 MidiDiskstream::steal_write_sources()
1339 {
1340         list<boost::shared_ptr<Source> > ret;
1341
1342         /* put some data on the disk, even if its just a header for an empty file */
1343         boost::dynamic_pointer_cast<SMFSource> (_write_source)->ensure_disk_file ();
1344
1345         /* never let it go away */
1346         _write_source->mark_nonremovable ();
1347
1348         ret.push_back (_write_source);
1349
1350         /* get a new one */
1351
1352         use_new_write_source (0);
1353
1354         return ret;
1355 }
1356
1357 void
1358 MidiDiskstream::reset_write_sources (bool mark_write_complete, bool /*force*/)
1359 {
1360         if (!_session.writable() || !recordable()) {
1361                 return;
1362         }
1363
1364         if (_write_source && mark_write_complete) {
1365                 _write_source->mark_streaming_write_completed ();
1366         }
1367         use_new_write_source (0);
1368 }
1369
1370 void
1371 MidiDiskstream::set_block_size (pframes_t /*nframes*/)
1372 {
1373 }
1374
1375 void
1376 MidiDiskstream::allocate_temporary_buffers ()
1377 {
1378 }
1379
1380 void
1381 MidiDiskstream::ensure_jack_monitors_input (bool yn)
1382 {
1383         boost::shared_ptr<MidiPort> sp = _source_port.lock ();
1384
1385         if (sp) {
1386                 sp->ensure_jack_monitors_input (yn);
1387         }
1388 }
1389
1390 void
1391 MidiDiskstream::set_align_style_from_io ()
1392 {
1393         if (_alignment_choice != Automatic) {
1394                 return;
1395         }
1396
1397         /* XXX Not sure what, if anything we can do with MIDI
1398            as far as capture alignment etc.
1399         */
1400
1401         set_align_style (ExistingMaterial);
1402 }
1403
1404
1405 float
1406 MidiDiskstream::playback_buffer_load () const
1407 {
1408         /* For MIDI it's not trivial to differentiate the following two cases:
1409
1410            1.  The playback buffer is empty because the system has run out of time to fill it.
1411            2.  The playback buffer is empty because there is no more data on the playlist.
1412
1413            If we use a simple buffer load computation, we will report that the MIDI diskstream
1414            cannot keep up when #2 happens, when in fact it can.  Since MIDI data rates
1415            are so low compared to audio, just give a pretend answer here.
1416         */
1417
1418         return 1;
1419 }
1420
1421 float
1422 MidiDiskstream::capture_buffer_load () const
1423 {
1424         /* We don't report playback buffer load, so don't report capture load either */
1425
1426         return 1;
1427 }
1428
1429 int
1430 MidiDiskstream::use_pending_capture_data (XMLNode& /*node*/)
1431 {
1432         return 0;
1433 }
1434
1435 /** Writes playback events from playback_sample for nframes to dst, translating time stamps
1436  *  so that an event at playback_sample has time = 0
1437  */
1438 void
1439 MidiDiskstream::get_playback (MidiBuffer& dst, framecnt_t nframes)
1440 {
1441         dst.clear();
1442         assert(dst.size() == 0);
1443
1444 #ifndef NDEBUG
1445         DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose (
1446                              "%1 MDS pre-read read %4..%5 from %2 write to %3\n", _name,
1447                              _playback_buf->get_read_ptr(), _playback_buf->get_write_ptr(), playback_sample, playback_sample + nframes));
1448 //        cerr << "================\n";
1449 //        _playback_buf->dump (cerr);
1450 //        cerr << "----------------\n";
1451
1452         const size_t events_read = _playback_buf->read (dst, playback_sample, playback_sample + nframes);
1453         DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose (
1454                              "%1 MDS events read %2 range %3 .. %4 rspace %5 wspace %6 r@%7 w@%8\n",
1455                              _name, events_read, playback_sample, playback_sample + nframes,
1456                              _playback_buf->read_space(), _playback_buf->write_space(),
1457                              _playback_buf->get_read_ptr(), _playback_buf->get_write_ptr()));
1458 #else
1459         _playback_buf->read (dst, playback_sample, playback_sample + nframes);
1460 #endif
1461
1462         g_atomic_int_add (&_frames_read_from_ringbuffer, nframes);
1463 }
1464
1465 bool
1466 MidiDiskstream::set_name (string const & name)
1467 {
1468         Diskstream::set_name (name);
1469
1470         /* get a new write source so that its name reflects the new diskstream name */
1471         use_new_write_source (0);
1472
1473         return true;
1474 }
1475
1476 boost::shared_ptr<MidiBuffer>
1477 MidiDiskstream::get_gui_feed_buffer () const
1478 {
1479         boost::shared_ptr<MidiBuffer> b (new MidiBuffer (AudioEngine::instance()->raw_buffer_size (DataType::MIDI)));
1480
1481         Glib::Mutex::Lock lm (_gui_feed_buffer_mutex);
1482         b->copy (_gui_feed_buffer);
1483         return b;
1484 }
1485
1486 void
1487 MidiDiskstream::reset_tracker ()
1488 {
1489         _playback_buf->reset_tracker ();
1490
1491         boost::shared_ptr<MidiPlaylist> mp (midi_playlist());
1492
1493         if (mp) {
1494                 mp->clear_note_trackers ();
1495         }
1496 }