X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Faudio_diskstream.cc;h=cab7f5faf8eab71957c936d16aba6eef18727ec2;hb=a223b96725c68a4e41c9f2f5675756c274730889;hp=7a30e191d58641f78b4af4d05d6bacf28d51551f;hpb=c4e31356170835bf3c4231b906db128187f471d8;p=ardour.git diff --git a/libs/ardour/audio_diskstream.cc b/libs/ardour/audio_diskstream.cc index 7a30e191d5..cab7f5faf8 100644 --- a/libs/ardour/audio_diskstream.cc +++ b/libs/ardour/audio_diskstream.cc @@ -16,7 +16,6 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ -#include #include #include #include @@ -28,6 +27,7 @@ #include #include +#include "pbd/gstdio_compat.h" #include "pbd/error.h" #include "pbd/xml++.h" #include "pbd/memento_command.h" @@ -50,6 +50,7 @@ #include "ardour/region_factory.h" #include "ardour/session.h" #include "ardour/session_playlists.h" +#include "ardour/sndfile_helpers.h" #include "ardour/source_factory.h" #include "ardour/track.h" #include "ardour/types.h" @@ -62,7 +63,6 @@ using namespace std; using namespace ARDOUR; using namespace PBD; -size_t AudioDiskstream::_working_buffers_size = 0; Sample* AudioDiskstream::_mixdown_buffer = 0; gain_t* AudioDiskstream::_gain_buffer = 0; @@ -133,9 +133,13 @@ AudioDiskstream::~AudioDiskstream () void AudioDiskstream::allocate_working_buffers() { - _working_buffers_size = max (disk_write_chunk_frames, disk_read_chunk_frames); - _mixdown_buffer = new Sample[_working_buffers_size]; - _gain_buffer = new gain_t[_working_buffers_size]; + /* with varifill buffer refilling, we compute the read size in bytes (to optimize + for disk i/o bandwidth) and then convert back into samples. These buffers + need to reflect the maximum size we could use, which is 4MB reads, or 2M samples + using 16 bit samples. + */ + _mixdown_buffer = new Sample[2*1048576]; + _gain_buffer = new gain_t[2*1048576]; } void @@ -143,7 +147,6 @@ AudioDiskstream::free_working_buffers() { delete [] _mixdown_buffer; delete [] _gain_buffer; - _working_buffers_size = 0; _mixdown_buffer = 0; _gain_buffer = 0; } @@ -165,7 +168,7 @@ AudioDiskstream::non_realtime_input_change () need_write_sources = true; } - if (input_change_pending.type == IOChange::ConfigurationChanged) { + if (input_change_pending.type & IOChange::ConfigurationChanged) { RCUWriter writer (channels); boost::shared_ptr c = writer.get_copy(); @@ -210,9 +213,9 @@ AudioDiskstream::non_realtime_locate (framepos_t location) /* now refill channel buffers */ if (speed() != 1.0f || speed() != -1.0f) { - seek ((framepos_t) (location * (double) speed())); + seek ((framepos_t) (location * (double) speed()), true); } else { - seek (location); + seek (location, true); } } @@ -356,7 +359,7 @@ AudioDiskstream::use_destructive_playlist () boost::shared_ptr rp; { - const RegionList& rl (_playlist->region_list().rlist()); + const RegionList& rl (_playlist->region_list_property().rlist()); if (rl.size() > 0) { assert((rl.size() == 1)); rp = rl.front(); @@ -520,7 +523,7 @@ AudioDiskstream::process (BufferSet& bufs, framepos_t transport_frame, pframes_t Sample *buf = bufs.get_audio (n).data(rec_offset); memcpy (chaninfo->current_capture_buffer, buf, sizeof (Sample) * rec_nframes); - + } else { framecnt_t total = chaninfo->capture_vector.len[0] + chaninfo->capture_vector.len[1]; @@ -596,14 +599,14 @@ AudioDiskstream::process (BufferSet& bufs, framepos_t transport_frame, pframes_t } if ((_track->monitoring_state () & MonitoringDisk) || collect_playback) { - + /* we're doing playback */ framecnt_t necessary_samples; /* no varispeed playback if we're recording, because the output .... TBD */ - if (rec_nframes == 0 && _actual_speed != 1.0f) { + if (rec_nframes == 0 && _actual_speed != 1.0) { necessary_samples = (framecnt_t) ceil ((nframes * fabs (_actual_speed))) + 2; } else { necessary_samples = nframes; @@ -652,7 +655,7 @@ AudioDiskstream::process (BufferSet& bufs, framepos_t transport_frame, pframes_t memcpy ((char *) chaninfo->playback_wrap_buffer, chaninfo->playback_vector.buf[0], chaninfo->playback_vector.len[0] * sizeof (Sample)); - + /* Copy buf[1] from playback_buf */ memcpy (chaninfo->playback_wrap_buffer + chaninfo->playback_vector.len[0], chaninfo->playback_vector.buf[1], @@ -671,13 +674,13 @@ AudioDiskstream::process (BufferSet& bufs, framepos_t transport_frame, pframes_t int channel = 0; for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan, ++channel) { ChannelInfo* chaninfo (*chan); - + playback_distance = interpolation.interpolate ( channel, nframes, chaninfo->current_playback_buffer, chaninfo->speed_buffer); - + chaninfo->current_playback_buffer = chaninfo->speed_buffer; } - + } else { playback_distance = nframes; } @@ -688,20 +691,20 @@ AudioDiskstream::process (BufferSet& bufs, framepos_t transport_frame, pframes_t if (need_disk_signal) { /* copy data over to buffer set */ - + size_t n_buffers = bufs.count().n_audio(); size_t n_chans = c->size(); gain_t scaling = 1.0f; - + if (n_chans > n_buffers) { scaling = ((float) n_buffers)/n_chans; } for (n = 0, chan = c->begin(); chan != c->end(); ++chan, ++n) { - + AudioBuffer& buf (bufs.get_audio (n%n_buffers)); ChannelInfo* chaninfo (*chan); - + if (n < n_chans) { if (scaling != 1.0f) { buf.read_from_with_gain (chaninfo->current_playback_buffer, nframes, scaling); @@ -721,7 +724,7 @@ AudioDiskstream::process (BufferSet& bufs, framepos_t transport_frame, pframes_t ChanCount cnt (DataType::AUDIO, n_chans); cnt.set (DataType::MIDI, bufs.count().n_midi()); bufs.set_count (cnt); - + /* extra buffers will already be silent, so leave them alone */ } @@ -784,6 +787,7 @@ AudioDiskstream::commit (framecnt_t playback_distance) if (adjust_capture_position != 0) { capture_captured += adjust_capture_position; + DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose ("%1 now captured %2 (by %3)\n", name(), capture_captured, adjust_capture_position)); adjust_capture_position = 0; } @@ -924,9 +928,15 @@ AudioDiskstream::seek (framepos_t frame, bool complete_refill) file_frame = frame; if (complete_refill) { - while ((ret = do_refill_with_alloc ()) > 0) ; + /* call _do_refill() to refill the entire buffer, using + the largest reads possible. + */ + while ((ret = do_refill_with_alloc (false)) > 0) ; } else { - ret = do_refill_with_alloc (); + /* call _do_refill() to refill just one chunk, and then + return. + */ + ret = do_refill_with_alloc (true); } return ret; @@ -953,7 +963,7 @@ AudioDiskstream::internal_playback_seek (framecnt_t distance) boost::shared_ptr c = channels.reader(); for (chan = c->begin(); chan != c->end(); ++chan) { - (*chan)->playback_buf->increment_read_ptr (llabs(distance)); + (*chan)->playback_buf->increment_read_ptr (::llabs(distance)); } if (first_recordable_frame < max_framepos) { @@ -1068,12 +1078,18 @@ AudioDiskstream::read (Sample* buf, Sample* mixdown_buffer, float* gain_buffer, } int -AudioDiskstream::do_refill_with_alloc () +AudioDiskstream::_do_refill_with_alloc (bool partial_fill) { - Sample* mix_buf = new Sample[disk_read_chunk_frames]; - float* gain_buf = new float[disk_read_chunk_frames]; + /* We limit disk reads to at most 4MB chunks, which with floating point + samples would be 1M samples. But we might use 16 or 14 bit samples, + in which case 4MB is more samples than that. Therefore size this for + the smallest sample value .. 4MB = 2M samples (16 bit). + */ - int ret = _do_refill(mix_buf, gain_buf); + Sample* mix_buf = new Sample[2*1048576]; + float* gain_buf = new float[2*1048576]; + + int ret = _do_refill (mix_buf, gain_buf, (partial_fill ? disk_read_chunk_frames : 0)); delete [] mix_buf; delete [] gain_buf; @@ -1083,9 +1099,15 @@ AudioDiskstream::do_refill_with_alloc () /** Get some more data from disk and put it in our channels' playback_bufs, * if there is suitable space in them. + * + * If fill_level is non-zero, then we will refill the buffer so that there is + * still at least fill_level samples of space left to be filled. This is used + * after locates so that we do not need to wait to fill the entire buffer. + * */ + int -AudioDiskstream::_do_refill (Sample* mixdown_buffer, float* gain_buffer) +AudioDiskstream::_do_refill (Sample* mixdown_buffer, float* gain_buffer, framecnt_t fill_level) { int32_t ret = 0; framecnt_t to_read; @@ -1098,6 +1120,14 @@ AudioDiskstream::_do_refill (Sample* mixdown_buffer, float* gain_buffer) boost::shared_ptr c = channels.reader(); framecnt_t ts; + /* do not read from disk while session is marked as Loading, to avoid + useless redundant I/O. + */ + + if (_session.state_of_the_state() & Session::Loading) { + return 0; + } + if (c->empty()) { return 0; } @@ -1117,13 +1147,13 @@ AudioDiskstream::_do_refill (Sample* mixdown_buffer, float* gain_buffer) return 0; } - /* if there are 2+ chunks of disk i/o possible for - this track, let the caller know so that it can arrange - for us to be called again, ASAP. - */ - - if (total_space >= (_slaved ? 3 : 2) * disk_read_chunk_frames) { - ret = 1; + if (fill_level) { + if (fill_level < total_space) { + total_space -= fill_level; + } else { + /* we can't do anything with it */ + fill_level = 0; + } } /* if we're running close to normal speed and there isn't enough @@ -1150,10 +1180,6 @@ AudioDiskstream::_do_refill (Sample* mixdown_buffer, float* gain_buffer) return 0; } - /* never do more than disk_read_chunk_frames worth of disk input per call (limit doesn't apply for memset) */ - - total_space = min (disk_read_chunk_frames, total_space); - if (reversed) { if (file_frame == 0) { @@ -1220,6 +1246,30 @@ AudioDiskstream::_do_refill (Sample* mixdown_buffer, float* gain_buffer) framepos_t file_frame_tmp = 0; + /* total_space is in samples. We want to optimize read sizes in various sizes using bytes */ + + const size_t bits_per_sample = format_data_width (_session.config.get_native_file_data_format()); + size_t total_bytes = total_space * bits_per_sample / 8; + + /* chunk size range is 256kB to 4MB. Bigger is faster in terms of MB/sec, but bigger chunk size always takes longer + */ + size_t byte_size_for_read = max ((size_t) (256 * 1024), min ((size_t) (4 * 1048576), total_bytes)); + + /* find nearest (lower) multiple of 16384 */ + + byte_size_for_read = (byte_size_for_read / 16384) * 16384; + + /* now back to samples */ + + framecnt_t samples_to_read = byte_size_for_read / (bits_per_sample / 8); + + //cerr << name() << " will read " << byte_size_for_read << " out of total bytes " << total_bytes << " in buffer of " + // << c->front()->playback_buf->bufsize() * bits_per_sample / 8 << " bps = " << bits_per_sample << endl; + // cerr << name () << " read samples = " << samples_to_read << " out of total space " << total_space << " in buffer of " << c->front()->playback_buf->bufsize() << " samples\n"; + + // uint64_t before = g_get_monotonic_time (); + // uint64_t elapsed; + for (chan_n = 0, i = c->begin(); i != c->end(); ++i, ++chan_n) { ChannelInfo* chan (*i); @@ -1229,7 +1279,7 @@ AudioDiskstream::_do_refill (Sample* mixdown_buffer, float* gain_buffer) chan->playback_buf->get_write_vector (&vector); - if ((framecnt_t) vector.len[0] > disk_read_chunk_frames) { + if ((framecnt_t) vector.len[0] > samples_to_read) { /* we're not going to fill the first chunk, so certainly do not bother with the other part. it won't be connected with the part we do fill, as in: @@ -1261,7 +1311,7 @@ AudioDiskstream::_do_refill (Sample* mixdown_buffer, float* gain_buffer) len2 = vector.len[1]; to_read = min (ts, len1); - to_read = min (to_read, disk_read_chunk_frames); + to_read = min (to_read, (framecnt_t) samples_to_read); assert (to_read >= 0); @@ -1280,8 +1330,9 @@ AudioDiskstream::_do_refill (Sample* mixdown_buffer, float* gain_buffer) if (to_read) { - /* we read all of vector.len[0], but it wasn't an entire disk_read_chunk_frames of data, - so read some or all of vector.len[1] as well. + /* we read all of vector.len[0], but it wasn't the + entire samples_to_read of data, so read some or + all of vector.len[1] as well. */ if (read (buf2, mixdown_buffer, gain_buffer, file_frame_tmp, to_read, chan_n, reversed)) { @@ -1298,11 +1349,17 @@ AudioDiskstream::_do_refill (Sample* mixdown_buffer, float* gain_buffer) } + // elapsed = g_get_monotonic_time () - before; + // cerr << "\tbandwidth = " << (byte_size_for_read / 1048576.0) / (elapsed/1000000.0) << "MB/sec\n"; + file_frame = file_frame_tmp; assert (file_frame >= 0); - out: + ret = ((total_space - samples_to_read) > disk_read_chunk_frames); + + c->front()->playback_buf->get_write_vector (&vector); + out: return ret; } @@ -1412,7 +1469,7 @@ AudioDiskstream::do_flush (RunContext /*context*/, bool force_flush) error << string_compose(_("AudioDiskstream %1: cannot write to disk"), id()) << endmsg; return -1; } - + (*chan)->capture_buf->increment_read_ptr (to_write); (*chan)->curr_capture_cnt += to_write; @@ -1523,6 +1580,8 @@ AudioDiskstream::transport_stopped_wallclock (struct tm& when, time_t twhen, boo if (Config->get_auto_analyse_audio()) { Analyser::queue_source_for_analysis (s, true); } + + DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose ("newly captured source %1 length %2\n", s->path(), s->length (0))); } } @@ -1570,7 +1629,7 @@ AudioDiskstream::transport_stopped_wallclock (struct tm& when, time_t twhen, boo } _last_capture_sources.insert (_last_capture_sources.end(), srcs.begin(), srcs.end()); - + _playlist->clear_changes (); _playlist->set_capture_insertion_in_progress (true); _playlist->freeze (); @@ -1581,8 +1640,8 @@ AudioDiskstream::transport_stopped_wallclock (struct tm& when, time_t twhen, boo RegionFactory::region_name (region_name, whole_file_region_name, false); - DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose ("%1 capture start @ %2 length %3 add new region %4\n", - _name, (*ci)->start, (*ci)->frames, region_name)); + DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose ("%1 capture bufpos %5 start @ %2 length %3 add new region %4\n", + _name, (*ci)->start, (*ci)->frames, region_name, buffer_position)); try { @@ -1637,18 +1696,6 @@ AudioDiskstream::transport_looped (framepos_t transport_frame) // all we need to do is finish this capture, with modified capture length boost::shared_ptr c = channels.reader(); - // adjust the capture length knowing that the data will be recorded to disk - // only necessary after the first loop where we're recording - if (capture_info.size() == 0) { - capture_captured += _capture_offset; - - if (_alignment_style == ExistingMaterial) { - capture_captured += _session.worst_output_latency(); - } else { - capture_captured += _roll_delay; - } - } - finish_capture (c); // the next region will start recording via the normal mechanism @@ -1726,7 +1773,7 @@ AudioDiskstream::finish_capture (boost::shared_ptr c) */ DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose ("Finish capture, add new CI, %1 + %2\n", ci->start, ci->frames)); - + capture_info.push_back (ci); capture_captured = 0; @@ -1768,25 +1815,25 @@ AudioDiskstream::set_record_safe (bool yn) if (!recordable() || !_session.record_enabling_legal() || _io->n_ports().n_audio() == 0) { return; } - - /* can't rec-safe in destructive mode if transport is before start ???? + + /* can't rec-safe in destructive mode if transport is before start ???? REQUIRES REVIEW */ - + if (destructive() && yn && _session.transport_frame() < _session.current_start_frame()) { return; } - + /* yes, i know that this not proof against race conditions, but its good enough. i think. */ - + if (record_safe () != yn) { if (yn) { engage_record_safe (); } else { disengage_record_safe (); } - + RecordSafeChanged (); /* EMIT SIGNAL */ } } @@ -1848,7 +1895,7 @@ AudioDiskstream::get_state () { XMLNode& node (Diskstream::get_state()); char buf[64] = ""; - LocaleGuard lg (X_("C")); + LocaleGuard lg; boost::shared_ptr c = channels.reader(); snprintf (buf, sizeof(buf), "%u", (unsigned int) c->size()); @@ -1885,12 +1932,12 @@ AudioDiskstream::get_state () int AudioDiskstream::set_state (const XMLNode& node, int version) { - const XMLProperty* prop; + XMLProperty const * prop; XMLNodeList nlist = node.children(); XMLNodeIterator niter; uint32_t nchans = 1; XMLNode* capture_pending_node = 0; - LocaleGuard lg (X_("C")); + LocaleGuard lg; /* prevent write sources from being created */ @@ -2071,7 +2118,7 @@ AudioDiskstream::allocate_temporary_buffers () when slaving to MTC, Timecode etc. */ - double const sp = max (fabsf (_actual_speed), 1.2f); + double const sp = max (fabs (_actual_speed), 1.2); framecnt_t required_wrap_size = (framecnt_t) ceil (_session.get_block_size() * sp) + 2; if (required_wrap_size > wrap_buffer_size) { @@ -2190,11 +2237,11 @@ AudioDiskstream::playback_buffer_load () const boost::shared_ptr c = channels.reader(); if (c->empty ()) { - return 0; + return 1.0; } return (float) ((double) c->front()->playback_buf->read_space()/ - (double) c->front()->playback_buf->bufsize()); + (double) c->front()->playback_buf->bufsize()); } float @@ -2203,7 +2250,7 @@ AudioDiskstream::capture_buffer_load () const boost::shared_ptr c = channels.reader(); if (c->empty ()) { - return 0; + return 1.0; } return (float) ((double) c->front()->capture_buf->write_space()/ @@ -2213,7 +2260,7 @@ AudioDiskstream::capture_buffer_load () const int AudioDiskstream::use_pending_capture_data (XMLNode& node) { - const XMLProperty* prop; + XMLProperty const * prop; XMLNodeList nlist = node.children(); XMLNodeIterator niter; boost::shared_ptr fs; @@ -2237,8 +2284,8 @@ AudioDiskstream::use_pending_capture_data (XMLNode& node) } // This protects sessions from errant CapturingSources in stored sessions - struct stat sbuf; - if (stat (prop->value().c_str(), &sbuf)) { + GStatBuf sbuf; + if (g_stat (prop->value().c_str(), &sbuf)) { continue; } @@ -2286,11 +2333,11 @@ AudioDiskstream::use_pending_capture_data (XMLNode& node) boost::shared_ptr wf_region; boost::shared_ptr region; - + /* First create the whole file region */ PropertyList plist; - + plist.add (Properties::start, 0); plist.add (Properties::length, first_fs->length (first_fs->timeline_position())); plist.add (Properties::name, region_name_from_path (first_fs->name(), true)); @@ -2305,7 +2352,7 @@ AudioDiskstream::use_pending_capture_data (XMLNode& node) * the playlist */ region = boost::dynamic_pointer_cast (RegionFactory::create (pending_sources, plist)); - + _playlist->add_region (region, position); } @@ -2366,7 +2413,7 @@ AudioDiskstream::can_become_destructive (bool& requires_bounce) const if (Profile->get_trx()) { return false; } - + if (!_playlist) { requires_bounce = false; return false; @@ -2388,7 +2435,7 @@ AudioDiskstream::can_become_destructive (bool& requires_bounce) const boost::shared_ptr first; { - const RegionList& rl (_playlist->region_list().rlist()); + const RegionList& rl (_playlist->region_list_property().rlist()); assert((rl.size() == 1)); first = rl.front(); @@ -2527,7 +2574,7 @@ AudioDiskstream::ChannelInfo::~ChannelInfo () continue to exist. If we do not do this, then the Session retains a reference to it, it is not deleted, and later attempts to create a new source - file will use wierd naming because it already + file will use wierd naming because it already exists. XXX longer term TO-DO: do not add to session source