/** request that the IO thread perform a seek and rebuffer. This is called for each Disk_Stream whenever the RT thread determines that the transport has jumped to a new position. This is called *before* process. */ void Playback_DS::seek ( nframes_t frame ) { THREAD_ASSERT( RT ); /* FIXME: non-RT-safe IO */ DMESSAGE( "requesting seek to frame %lu", (unsigned long)frame ); if ( seek_pending() ) printf( "seek error, attempt to seek while seek is pending\n" ); _pending_seek = frame; flush(); }
/** request that the IO thread perform a seek and rebuffer. This is called for each Disk_Stream whenever the RT thread determines that the transport has jumped to a new position. This is called *before* process. */ void Playback_DS::seek ( nframes_t frame ) { THREAD_ASSERT( RT ); /* FIXME: non-RT-safe IO */ DMESSAGE( "requesting seek to frame %lu", (unsigned long)frame ); if ( seek_pending() ) printf( "seek error, attempt to seek while seek is pending\n" ); _seek_frame = frame; _pending_seek = true; /* wake the IO thread */ block_processed(); }
void Playback_DS::disk_thread ( void ) { _thread.name( "Playback" ); DMESSAGE( "playback thread running" ); /* buffer to hold the interleaved data returned by the track reader */ sample_t *buf = new sample_t[ _nframes * channels() * _disk_io_blocks ]; #ifndef AVOID_UNNECESSARY_COPYING sample_t *cbuf = new sample_t[ _nframes * _disk_io_blocks ]; #endif int blocks_ready = 0; const nframes_t nframes = _nframes * _disk_io_blocks; while ( wait_for_block() ) { // lock(); // for seeking if ( seek_pending() ) { /* FIXME: non-RT-safe IO */ DMESSAGE( "performing seek to frame %lu", (unsigned long)_pending_seek ); _frame = _pending_seek; _pending_seek = -1; blocks_ready = 0; } if ( ++blocks_ready < _disk_io_blocks ) { /* wait for more space */ continue; } /* reset */ blocks_ready = 0; read_block( buf, nframes ); // unlock(); // for seeking /* deinterleave the buffer and stuff it into the per-channel ringbuffers */ const size_t block_size = nframes * sizeof( sample_t ); for ( int i = channels(); i--; ) { #ifdef AVOID_UNNECESSARY_COPYING /* deinterleave direcectly into the ringbuffer to avoid * unnecessary copying */ jack_ringbuffer_data_t rbd[2]; memset( rbd, 0, sizeof( rbd ) ); jack_ringbuffer_get_write_vector( _rb[ i ], rbd ); if ( rbd[ 0 ].len >= block_size ) { /* it'll all fit in one go */ buffer_deinterleave_one_channel( (sample_t*)rbd[ 0 ].buf, buf, i, channels(), nframes ); } else if ( rbd[ 0 ].len + rbd[ 1 ].len >= block_size ) { /* there's enough space in the ringbuffer, but it's not contiguous */ assert( ! ( rbd[ 0 ].len % sizeof( sample_t ) ) ); // assert( ! ( rbd[ 1 ].len % sizeof( sample_t ) ) ); const nframes_t f = rbd[ 0 ].len / sizeof( sample_t ); /* do the first half */ buffer_deinterleave_one_channel( (sample_t*)rbd[ 0 ].buf, buf, i, channels(), f ); assert( rbd[ 1 ].len >= ( nframes - f ) * sizeof( sample_t ) ); /* do the second half */ buffer_deinterleave_one_channel( (sample_t*)rbd[ 1 ].buf, buf + f, i, channels(), nframes - f ); } else ++_xruns; jack_ringbuffer_write_advance( _rb[ i ], block_size ); #else buffer_deinterleave_one_channel( cbuf, buf, i, channels(), nframes ); if ( jack_ringbuffer_write( _rb[ i ], (char*)cbuf, block_size ) < block_size ) ++_xruns; #endif } } DMESSAGE( "playback thread terminating" ); delete[] buf; #ifndef AVOID_UNNECESSARY_COPYING delete[] cbuf; #endif _terminate = false; }