mixxxdj / mixxx / 4725386255

#include "engine/cachingreader/cachingreader.h"

#include <QFileInfo>

#include <QtDebug>

#include "control/controlobject.h"

#include "moc_cachingreader.cpp"

#include "track/track.h"

#include "util/assert.h"

#include "util/compatibility/qatomic.h"

#include "util/counter.h"

#include "util/logger.h"

#include "util/math.h"

#include "util/sample.h"

namespace {

mixxx::Logger kLogger("CachingReader");

// This is the default hint frameCount that is adopted in case of Hint::kFrameCountForward and

// Hint::kFrameCountBackward count is provided. It matches 23 ms @ 44.1 kHz

// TODO() Do we suffer cache misses if we use an audio buffer of above 23 ms?

constexpr SINT kDefaultHintFrames = 1024;

// With CachingReaderChunk::kFrames = 8192 each chunk consumes

// 8192 frames * 2 channels/frame * 4-bytes per sample = 65 kB.

//

//     80 chunks ->  5120 KB =  5 MB

//

// Each deck (including sample decks) will use their own CachingReader.

// Consequently the total memory required for all allocated chunks depends

// on the number of decks. The amount of memory reserved for a single

// CachingReader must be multiplied by the number of decks to calculate

// the total amount!

//

// NOTE(uklotzde, 2019-09-05): Reduce this number to just few chunks

// (kNumberOfCachedChunksInMemory = 1, 2, 3, ...) for testing purposes

// to verify that the MRU/LRU cache works as expected. Even though

// massive drop outs are expected to occur Mixxx should run reliably!

constexpr SINT kNumberOfCachedChunksInMemory = 80;

} // anonymous namespace

          // Limit the number of in-flight requests to the worker. This should

          // prevent to overload the worker when it is not able to fetch those

          // requests from the FIFO timely. Otherwise outdated requests pile up

          // in the FIFO and it would take a long time to process them, just to

          // discard the results that most likely have already become obsolete.

          // TODO(XXX): Ideally the request FIFO would be implemented as a ring

          // buffer, where new requests replace old requests when full. Those

          // old requests need to be returned immediately to the CachingReader

          // that must take ownership and free them!!!

          // The capacity of the back channel must be equal to the number of

          // allocated chunks, because the worker use writeBlocking(). Otherwise

          // the worker could get stuck in a hot loop!!!

    // Divide up the allocated raw memory buffer into total_chunks

    // chunks. Initialize each chunk to hold nothing and add it to the free

    // list.

        CachingReaderChunkForOwner* c =

                new CachingReaderChunkForOwner(

    }

    // Forward signals from worker

            this, &CachingReader::trackLoading,

            Qt::DirectConnection);

            this, &CachingReader::trackLoaded,

            Qt::DirectConnection);

            this, &CachingReader::trackLoadFailed,

            Qt::DirectConnection);

            &m_mruCachingReaderChunk,

            &m_lruCachingReaderChunk);

    Q_UNUSED(removed); // only used in DEBUG_ASSERT

    // We'll tolerate not being in allocatedCachingReaderChunks,

    // because sometime you free a chunk right after you allocated it.

        // We will receive CHUNK_READ_INVALID for all pending chunk reads

        // which should free the chunks individually.

        }

        }

    }

    }

}

        } else {

        }

    }

    }

}

    // Defaults to nullptr if it's not in the hash.

}

    }

    // Remove the chunk from the MRU/LRU list

            &m_mruCachingReaderChunk,

            &m_lruCachingReaderChunk);

    // Reinsert has new head of MRU list

            &m_mruCachingReaderChunk,

            &m_lruCachingReaderChunk,

            m_mruCachingReaderChunk);

    }

}

// Invoked from the UI thread!!

    // TODO():

    // BaseTrackPlayerImpl::slotLoadTrack() distributes the new track via

    // emit loadingTrack(pNewTrack, pOldTrack);

    // but the newTrack may change if we load a new track while the previous one

    // is still loading. This leads to inconsistent states for example a different

    // track in the Mixxx Title and the Deck label.

            newState == STATE_TRACK_LOADING) {

    }

// Called from the engine thread

    ReaderStatusUpdate update;

            // Result of a read request (with a chunk)

                    update.status == CHUNK_READ_SUCCESS ||

                    update.status == CHUNK_READ_EOF ||

                    update.status == CHUNK_READ_INVALID ||

                    update.status == CHUNK_READ_DISCARDED);

                // Discard all results from pending read requests for the

                // previous track before the next track has been loaded.

            }

                // Insert or freshen the chunk in the MRU/LRU list after

                // obtaining ownership from the worker.

            } else {

                // Discard chunks that don't carry any data

            }

            // Adjust the readable frame index range (if available)

                        m_readableFrameIndexRange,

            }

        } else {

            // State update (without a chunk)

                // We have a new Track ready to go.

                // Assert that we either have had STATE_TRACK_LOADING before and all

                // chunks in the m_readerStatusUpdateFIFO have been discarded.

                // or the cache has been already cleared.

                // In case of two consecutive load events, we receive two consecutive

                // TRACK_LOADED without a chunk in between, assert this here.

                        (atomicLoadRelaxed(m_state) == STATE_TRACK_LOADED &&

                                !m_mruCachingReaderChunk && !m_lruCachingReaderChunk));

                // now purge also the recently used chunk list from the old track.

                }

                // Reset the readable frame index range

            } else {

                // This message could be processed later when a new

                // track is already loading! In this case the TRACK_LOADED will

                // be the very next status update.

                            atomicLoadRelaxed(m_state) == STATE_TRACK_LOADING ||

                            atomicLoadRelaxed(m_state) == STATE_IDLE);

                }

            }

        }

    }

    // Check for bad inputs

            // Refuse to read from an invalid position

            (startSample % CachingReaderChunk::kChannels == 0) &&

            // Refuse to read from an invalid number of samples

            (numSamples % CachingReaderChunk::kChannels == 0) && (numSamples >= 0)) {

    }

    }

    // If no track is loaded, don't do anything.

    }

    // If asked to read 0 samples, don't do anything. (this is a perfectly

    // reasonable request that happens sometimes.

    }

    // the samples are always read in forward direction

    // If reverse = true, the frames are copied in reverse order to the

    // destination buffer

        // Start with the last sample in buffer

    }

    // Process new messages from the reader thread before looking up

    // the first chunk and to update m_readableFrameIndexRange

    auto remainingFrameIndexRange =

                    CachingReaderChunk::samples2frames(sample),

                    CachingReaderChunk::samples2frames(numSamples));

        // Fill the buffer up to the first readable sample with

        // silence. This may happen when the engine is in preroll,

        // i.e. if the frame index points a region before the first

        // track sample.

            const auto prerollFrameIndexRange =

                            remainingFrameIndexRange.start(),

                            m_readableFrameIndexRange.start());

            }

            } else {

            }

        }

        // Read the actual samples from the audio source into the

        // buffer. The buffer will be filled with silence for every

        // unreadable sample or samples outside of the track region

        // later at the end of this function.

            // The intersection between the readable samples from the track

            // and the requested samples is not empty, so start reading.

            const SINT firstChunkIndex =

            SINT lastChunkIndex =

                    ++chunkIndex) {

                // Process new messages from the reader thread before looking up

                // the next chunk

                // m_readableFrameIndexRange might change with every read operation!

                // On a cache miss audio data will be read from the audio source in

                // process() and the readable frame index range might get adjusted

                // if decoding errors occur.

                remainingFrameIndexRange =

                                remainingFrameIndexRange,

                    // No more readable data available. Exit the loop and

                    // fill the remaining buffer with silence.

                }

                lastChunkIndex =

                    // No more readable data available. Exit the loop and

                    // fill the remaining buffer with silence.

                }

                        bufferedFrameIndexRange =

                    } else {

                        bufferedFrameIndexRange =

                                        buffer,

                    }

                } else {

                    // This will happen regularly when jumping to a new position

                    // within the file and decoding of the audio data is still

                    // pending.

                            (pChunk->getState() == CachingReaderChunkForOwner::READ_PENDING));

                    }

                    // Abort reading (see below)

                }

                        // We have not read a single frame caused by a cache miss of

                        // the first required chunk. Inform the calling code that no

                        // data has been written into the buffer and to handle this

                        // situation appropriately.

                    }

                    // No more readable data available. Exit the loop and

                    // finally fill the remaining buffer with silence.

                }

                    const auto paddingFrameIndexRange =

                                    remainingFrameIndexRange.start(),

                                    bufferedFrameIndexRange.start());

                    } else {

                    }

                }

                const SINT chunkSamples =

                }

            }

        }

    }

    // Finally fill the remaining buffer with silence

    }

}

    // If no file is loaded, skip.

    }

    // For every chunk that the hints indicated, check if it is in the cache. If

    // any are not, then wake.

        // Handle some special length values

                }

            }

        }

        }

                m_readableFrameIndexRange,

                mixxx::IndexRange::forward(hintFrame, hintFrameCount));

        }

                }

                // Do not insert the allocated chunk into the MRU/LRU list,

                // because it will be handed over to the worker immediately

                CachingReaderChunkReadRequest request;

                }

                    // Revoke the chunk from the worker and free it

                }

                // This will cause the chunk to be 'freshened' in the cache. The

                // chunk will be moved to the end of the LRU list.

            }

        }

    }

    // If there are chunks to be read, wake up.

    }

}