SoundSource::OpenResult SoundSourceFLAC::tryOpen(
OpenMode /*mode*/,
const OpenParams& /*config*/) {
DEBUG_ASSERT(!m_file.isOpen());
if (!m_file.open(QIODevice::ReadOnly)) {
kLogger.warning() << "Failed to open FLAC file:" << m_file.fileName();
return OpenResult::Failed;
}
m_decoder = FLAC__stream_decoder_new();
if (m_decoder == nullptr) {
kLogger.warning() << "Failed to create FLAC decoder!";
return OpenResult::Failed;
}
FLAC__stream_decoder_set_md5_checking(m_decoder, false);
const FLAC__StreamDecoderInitStatus initStatus(
FLAC__stream_decoder_init_stream(m_decoder, FLAC_read_cb,
FLAC_seek_cb, FLAC_tell_cb, FLAC_length_cb, FLAC_eof_cb,
FLAC_write_cb, FLAC_metadata_cb, FLAC_error_cb, this));
if (initStatus != FLAC__STREAM_DECODER_INIT_STATUS_OK) {
kLogger.warning() << "Failed to initialize FLAC decoder:" << initStatus;
return OpenResult::Failed;
}
if (!FLAC__stream_decoder_process_until_end_of_metadata(m_decoder)) {
kLogger.warning() << "Failed to process FLAC metadata:"
<< FLAC__stream_decoder_get_state(m_decoder);
return OpenResult::Failed;
}
m_curFrameIndex = frameIndexMin();
return OpenResult::Succeeded;
}
SoundSource::OpenResult SoundSourceWV::tryOpen(
OpenMode /*mode*/,
const OpenParams& params) {
DEBUG_ASSERT(!m_wpc);
char msg[80]; // hold possible error message
int openFlags = OPEN_WVC | OPEN_NORMALIZE;
if ((params.channelCount() == 1) ||
(params.channelCount() == 2)) {
openFlags |= OPEN_2CH_MAX;
}
// We use WavpackOpenFileInputEx to support Unicode paths on windows
// http://www.wavpack.com/lib_use.txt
QString wavPackFileName = getLocalFileName();
m_pWVFile = new QFile(wavPackFileName);
m_pWVFile->open(QFile::ReadOnly);
QString correctionFileName(wavPackFileName + "c");
if (QFile::exists(correctionFileName)) {
// If there is a correction file, open it as well
m_pWVCFile = new QFile(correctionFileName);
m_pWVCFile->open(QFile::ReadOnly);
}
m_wpc = WavpackOpenFileInputEx(&s_streamReader, m_pWVFile, m_pWVCFile,
msg, openFlags, 0);
if (!m_wpc) {
kLogger.warning() << "failed to open file : " << msg;
return OpenResult::Failed;
}
setChannelCount(WavpackGetReducedChannels(m_wpc));
setSampleRate(WavpackGetSampleRate(m_wpc));
initFrameIndexRangeOnce(
mixxx::IndexRange::forward(
0,
WavpackGetNumSamples(m_wpc)));
if (WavpackGetMode(m_wpc) & MODE_FLOAT) {
m_sampleScaleFactor = CSAMPLE_PEAK;
} else {
const int bitsPerSample = WavpackGetBitsPerSample(m_wpc);
if ((bitsPerSample >= 8) && (bitsPerSample <= 32)) {
// Range of signed sample values: [-2 ^ (bitsPerSample - 1), 2 ^ (bitsPerSample - 1) - 1]
const uint32_t absSamplePeak = 1u << (bitsPerSample - 1);
DEBUG_ASSERT(absSamplePeak > 0);
// Scaled range of sample values: [-CSAMPLE_PEAK, CSAMPLE_PEAK)
m_sampleScaleFactor = CSAMPLE_PEAK / absSamplePeak;
} else {
kLogger.warning()
<< "Invalid bits per sample:"
<< bitsPerSample;
return OpenResult::Aborted;
}
}
m_curFrameIndex = frameIndexMin();
return OpenResult::Succeeded;
}
QString ChromaPrinter::getFingerprint(TrackPointer pTrack) {
mixxx::AudioSource::OpenParams config;
config.setChannelCount(2); // always stereo / 2 channels (see below)
auto pAudioSource = SoundSourceProxy(pTrack).openAudioSource(config);
if (!pAudioSource) {
qDebug()
<< "Failed to open file for fingerprinting"
<< pTrack->getLocation()
<< *pAudioSource;
return QString();
}
const auto fingerprintRange = intersect(
pAudioSource->frameIndexRange(),
mixxx::IndexRange::forward(
pAudioSource->frameIndexMin(),
kFingerprintDuration * pAudioSource->sampleRate()));
mixxx::AudioSourceStereoProxy audioSourceProxy(
pAudioSource,
fingerprintRange.length());
return calcFingerprint(audioSourceProxy, fingerprintRange);
}
ReadableSampleFrames SoundSourceFLAC::readSampleFramesClamped(
WritableSampleFrames writableSampleFrames) {
const SINT firstFrameIndex = writableSampleFrames.frameIndexRange().start();
if (m_curFrameIndex != firstFrameIndex) {
// Seek to the new position
SINT seekFrameIndex = firstFrameIndex;
int retryCount = 0;
// NOTE(uklotzde): This loop avoids unnecessary seek operations.
// If the file is decoded from the beginning to the end during
// continuous playback no seek operations are necessary. This
// may hide rare seek errors that we have observed in some "flaky"
// FLAC files. The retry strategy implemented by this loop tries
// to solve these issues when randomly seeking through such a file.
while ((seekFrameIndex != m_curFrameIndex) &&
(retryCount <= kSeekErrorMaxRetryCount)) {
// Discard decoded sample data before seeking
m_sampleBuffer.clear();
invalidateCurFrameIndex();
if (FLAC__stream_decoder_seek_absolute(m_decoder, seekFrameIndex)) {
// Success: Set the new position
m_curFrameIndex = seekFrameIndex;
DEBUG_ASSERT(FLAC__STREAM_DECODER_SEEK_ERROR != FLAC__stream_decoder_get_state(m_decoder));
} else {
// Failure
kLogger.warning()
<< "Seek error at" << seekFrameIndex
<< "in file" << m_file.fileName();
if (FLAC__STREAM_DECODER_SEEK_ERROR == FLAC__stream_decoder_get_state(m_decoder)) {
// Flush the input stream of the decoder according to the
// documentation of FLAC__stream_decoder_seek_absolute()
if (!FLAC__stream_decoder_flush(m_decoder)) {
kLogger.warning()
<< "Failed to flush input buffer of the FLAC decoder after seek failure"
<< "in file" << m_file.fileName();
invalidateCurFrameIndex();
// ...and abort
return ReadableSampleFrames(
IndexRange::between(
m_curFrameIndex,
m_curFrameIndex));
}
}
if (frameIndexMin() < seekFrameIndex) {
// The next seek position should start at a preceding sample block.
// By subtracting max. blocksize from the current seek position it
// is guaranteed that the targeted sample blocks of subsequent seek
// operations will differ.
DEBUG_ASSERT(0 < m_maxBlocksize);
seekFrameIndex -= m_maxBlocksize;
if (seekFrameIndex < frameIndexMin()) {
seekFrameIndex = frameIndexMin();
}
} else {
// We have already reached the beginning of the file
// and cannot move the seek position backwards any
// further!
break; // exit loop
}
}
}
// Decoding starts before the actual target position
DEBUG_ASSERT(m_curFrameIndex <= firstFrameIndex);
const auto precedingFrames =
IndexRange::between(m_curFrameIndex, firstFrameIndex);
if (!precedingFrames.empty() &&
(precedingFrames != readSampleFramesClamped(WritableSampleFrames(precedingFrames)).frameIndexRange())) {
kLogger.warning()
<< "Failed to skip preceding frames"
<< precedingFrames;
// Abort
return ReadableSampleFrames(
IndexRange::between(
m_curFrameIndex,
m_curFrameIndex));
}
}
DEBUG_ASSERT(m_curFrameIndex == firstFrameIndex);
const SINT numberOfSamplesTotal = frames2samples(writableSampleFrames.frameLength());
SINT numberOfSamplesRemaining = numberOfSamplesTotal;
SINT outputSampleOffset = 0;
while (0 < numberOfSamplesRemaining) {
// If our buffer from libflac is empty (either because we explicitly cleared
// it or because we've simply used all the samples), ask for a new buffer
if (m_sampleBuffer.empty()) {
// Save the current frame index
const SINT curFrameIndexBeforeProcessing = m_curFrameIndex;
// Documentation of FLAC__stream_decoder_process_single():
// "Depending on what was decoded, the metadata or write callback
// will be called with the decoded metadata block or audio frame."
// See also: https://xiph.org/flac/api/group__flac__stream__decoder.html#ga9d6df4a39892c05955122cf7f987f856
if (!FLAC__stream_decoder_process_single(m_decoder)) {
kLogger.warning()
<< "Failed to decode FLAC file"
<< m_file.fileName();
break; // abort
}
// After decoding we might first need to skip some samples if the
// decoder complained that it has lost sync for some malformed(?)
// files
if (m_curFrameIndex != curFrameIndexBeforeProcessing) {
if (m_curFrameIndex < curFrameIndexBeforeProcessing) {
kLogger.warning()
<< "Trying to adjust frame index"
<< m_curFrameIndex << "<" << curFrameIndexBeforeProcessing
<< "while decoding FLAC file"
<< m_file.fileName();
const auto skipFrames =
IndexRange::between(m_curFrameIndex, curFrameIndexBeforeProcessing);
if (skipFrames != readSampleFramesClamped(WritableSampleFrames(skipFrames)).frameIndexRange()) {
kLogger.warning()
<< "Failed to skip sample frames"
<< skipFrames
<< "while decoding FLAC file"
<< m_file.fileName();
break; // abort
}
} else {
kLogger.warning()
<< "Unexpected frame index"
<< m_curFrameIndex << ">" << curFrameIndexBeforeProcessing
<< "while decoding FLAC file"
<< m_file.fileName();
break; // abort
}
}
DEBUG_ASSERT(curFrameIndexBeforeProcessing == m_curFrameIndex);
}
if (m_sampleBuffer.empty()) {
break; // EOF
}
const SINT numberOfSamplesRead =
std::min(m_sampleBuffer.readableLength(), numberOfSamplesRemaining);
const SampleBuffer::ReadableSlice readableSlice(
m_sampleBuffer.shrinkForReading(numberOfSamplesRead));
DEBUG_ASSERT(readableSlice.length() == numberOfSamplesRead);
if (writableSampleFrames.writableData()) {
SampleUtil::copy(
writableSampleFrames.writableData(outputSampleOffset),
readableSlice.data(),
readableSlice.length());
outputSampleOffset += numberOfSamplesRead;
}
m_curFrameIndex += samples2frames(numberOfSamplesRead);
numberOfSamplesRemaining -= numberOfSamplesRead;
}
DEBUG_ASSERT(isValidFrameIndex(m_curFrameIndex));
DEBUG_ASSERT(numberOfSamplesTotal >= numberOfSamplesRemaining);
const SINT numberOfSamples = numberOfSamplesTotal - numberOfSamplesRemaining;
return ReadableSampleFrames(
IndexRange::forward(firstFrameIndex, samples2frames(numberOfSamples)),
SampleBuffer::ReadableSlice(
writableSampleFrames.writableData(),
std::min(writableSampleFrames.writableLength(), numberOfSamples)));
}