void QGstAppSrc::pushDataToAppSrc()
{
if (!isStreamValid() || !m_setup)
return;
if (m_dataRequested && !m_enoughData) {
qint64 size;
if (m_dataRequestSize == (unsigned int)-1)
size = qMin(m_stream->bytesAvailable(), queueSize());
else
size = qMin(m_stream->bytesAvailable(), (qint64)m_dataRequestSize);
void *data = g_malloc(size);
GstBuffer* buffer = gst_app_buffer_new(data, size, g_free, data);
buffer->offset = m_stream->pos();
qint64 bytesRead = m_stream->read((char*)GST_BUFFER_DATA(buffer), size);
buffer->offset_end = buffer->offset + bytesRead - 1;
if (bytesRead > 0) {
m_dataRequested = false;
m_enoughData = false;
GstFlowReturn ret = gst_app_src_push_buffer (GST_APP_SRC (element()), buffer);
if (ret == GST_FLOW_ERROR) {
qWarning()<<"appsrc: push buffer error";
} else if (ret == GST_FLOW_WRONG_STATE) {
qWarning()<<"appsrc: push buffer wrong state";
} else if (ret == GST_FLOW_RESEND) {
qWarning()<<"appsrc: push buffer resend";
}
}
} else if (m_stream->atEnd()) {
sendEOS();
}
}
SINT SoundSourceMp3::restartDecoding(
const SeekFrameType& seekFrame) {
qDebug() << "restartDecoding @" << seekFrame.frameIndex;
// Discard decoded output
m_madSynthCount = 0;
if (getMinFrameIndex() == seekFrame.frameIndex) {
mad_frame_finish(&m_madFrame);
mad_synth_finish(&m_madSynth);
}
mad_stream_finish(&m_madStream);
mad_stream_init(&m_madStream);
mad_stream_options(&m_madStream, MAD_OPTION_IGNORECRC);
if (getMinFrameIndex() == seekFrame.frameIndex) {
mad_synth_init(&m_madSynth);
mad_frame_init(&m_madFrame);
}
// Fill input buffer
mad_stream_buffer(&m_madStream, seekFrame.pInputData,
m_fileSize - (seekFrame.pInputData - m_pFileData));
if (getMinFrameIndex() < seekFrame.frameIndex) {
// Muting is done here to eliminate potential pops/clicks
// from skipping Rob Leslie explains why here:
// http://www.mars.org/mailman/public/mad-dev/2001-August/000321.html
mad_frame_mute(&m_madFrame);
mad_synth_mute(&m_madSynth);
}
if (!decodeFrameHeader(&m_madFrame.header, &m_madStream, false)) {
if (!isStreamValid(m_madStream)) {
// Failure -> Seek to EOF
return getFrameCount();
}
}
return seekFrame.frameIndex;
}
SINT SoundSourceMp3::readSampleFrames(
SINT numberOfFrames, CSAMPLE* sampleBuffer,
SINT sampleBufferSize, bool readStereoSamples) {
DEBUG_ASSERT(isValidFrameIndex(m_curFrameIndex));
DEBUG_ASSERT(getSampleBufferSize(numberOfFrames, readStereoSamples) <= sampleBufferSize);
const SINT numberOfFramesTotal = math_min(
numberOfFrames, getMaxFrameIndex() - m_curFrameIndex);
CSAMPLE* pSampleBuffer = sampleBuffer;
SINT numberOfFramesRemaining = numberOfFramesTotal;
while (0 < numberOfFramesRemaining) {
if (0 >= m_madSynthCount) {
// When all decoded output data has been consumed...
DEBUG_ASSERT(0 == m_madSynthCount);
// ...decode the next MP3 frame
DEBUG_ASSERT(m_madStream.buffer);
DEBUG_ASSERT(m_madStream.this_frame);
// WARNING: Correctly evaluating and handling the result
// of mad_frame_decode() has proven to be extremely tricky.
// Don't change anything at the following lines of code
// unless you know what you are doing!!!
unsigned char const* pMadThisFrame = m_madStream.this_frame;
if (mad_frame_decode(&m_madFrame, &m_madStream)) {
// Something went wrong when decoding the frame...
if (MAD_ERROR_BUFLEN == m_madStream.error) {
// Abort
break;
}
if (isUnrecoverableError(m_madStream)) {
qWarning() << "Unrecoverable MP3 frame decoding error:"
<< mad_stream_errorstr(&m_madStream);
// Abort decoding
break;
}
if (isRecoverableError(m_madStream)) {
if (pMadThisFrame != m_madStream.this_frame) {
// Ignore all recoverable errors (and especially
// "lost synchronization" warnings) while skipping
// over prefetched frames after seeking.
if (pSampleBuffer) {
qWarning() << "Recoverable MP3 frame decoding error:"
<< mad_stream_errorstr(&m_madStream);
} else {
// Decoded samples will simply be discarded
qDebug() << "Recoverable MP3 frame decoding error while skipping:"
<< mad_stream_errorstr(&m_madStream);
}
}
// Continue decoding
}
}
if (pMadThisFrame == m_madStream.this_frame) {
qDebug() << "Retry decoding MP3 frame @" << m_curFrameIndex;
// Retry decoding
continue;
}
DEBUG_ASSERT(isStreamValid(m_madStream));
#ifndef QT_NO_DEBUG_OUTPUT
const SINT madFrameChannelCount = MAD_NCHANNELS(&m_madFrame.header);
if (madFrameChannelCount != getChannelCount()) {
qDebug() << "MP3 frame header with mismatching number of channels"
<< madFrameChannelCount << "<>" << getChannelCount();
}
#endif
// Once decoded the frame is synthesized to PCM samples
mad_synth_frame(&m_madSynth, &m_madFrame);
#ifndef QT_NO_DEBUG_OUTPUT
const SINT madSynthSampleRate = m_madSynth.pcm.samplerate;
if (madSynthSampleRate != getSamplingRate()) {
qDebug() << "Reading MP3 data with different sampling rate"
<< madSynthSampleRate << "<>" << getSamplingRate();
}
#endif
m_madSynthCount = m_madSynth.pcm.length;
DEBUG_ASSERT(0 < m_madSynthCount);
}
const SINT synthReadCount = math_min(
m_madSynthCount, numberOfFramesRemaining);
if (pSampleBuffer) {
DEBUG_ASSERT(m_madSynthCount <= m_madSynth.pcm.length);
const SINT madSynthOffset =
m_madSynth.pcm.length - m_madSynthCount;
DEBUG_ASSERT(madSynthOffset < m_madSynth.pcm.length);
const SINT madSynthChannelCount = m_madSynth.pcm.channels;
DEBUG_ASSERT(0 < madSynthChannelCount);
DEBUG_ASSERT(madSynthChannelCount <= getChannelCount());
#ifndef QT_NO_DEBUG_OUTPUT
if (madSynthChannelCount != getChannelCount()) {
qDebug() << "Reading MP3 data with different number of channels"
<< madSynthChannelCount << "<>" << getChannelCount();
}
#endif
if (kChannelCountMono == madSynthChannelCount) {
// MP3 frame contains a mono signal
if (readStereoSamples || (kChannelCountStereo == getChannelCount())) {
// The reader explicitly requested a stereo signal
// or the AudioSource itself provides a stereo signal.
// Mono -> Stereo: Copy 1st channel twice
for (SINT i = 0; i < synthReadCount; ++i) {
const CSAMPLE sampleValue = madScaleSampleValue(
m_madSynth.pcm.samples[0][madSynthOffset + i]);
*pSampleBuffer++ = sampleValue;
*pSampleBuffer++ = sampleValue;
}
} else {
// Mono -> Mono: Copy 1st channel
for (SINT i = 0; i < synthReadCount; ++i) {
const CSAMPLE sampleValue = madScaleSampleValue(
m_madSynth.pcm.samples[0][madSynthOffset + i]);
*pSampleBuffer++ = sampleValue;
}
}
} else {
// MP3 frame contains a stereo signal
DEBUG_ASSERT(kChannelCountStereo == madSynthChannelCount);
// If the MP3 frame contains a stereo signal then the whole
// AudioSource must also provide 2 channels, because the
// maximum channel count of all MP3 frames is used.
DEBUG_ASSERT(kChannelCountStereo == getChannelCount());
// Stereo -> Stereo: Copy 1st + 2nd channel
for (SINT i = 0; i < synthReadCount; ++i) {
*pSampleBuffer++ = madScaleSampleValue(
m_madSynth.pcm.samples[0][madSynthOffset + i]);
*pSampleBuffer++ = madScaleSampleValue(
m_madSynth.pcm.samples[1][madSynthOffset + i]);
}
}
}
// consume decoded output data
m_madSynthCount -= synthReadCount;
m_curFrameIndex += synthReadCount;
numberOfFramesRemaining -= synthReadCount;
}
DEBUG_ASSERT(isValidFrameIndex(m_curFrameIndex));
DEBUG_ASSERT(numberOfFramesTotal >= numberOfFramesRemaining);
return numberOfFramesTotal - numberOfFramesRemaining;
}
SoundSource::OpenResult SoundSourceMp3::tryOpen(const AudioSourceConfig& /*audioSrcCfg*/) {
DEBUG_ASSERT(!hasValidChannelCount());
DEBUG_ASSERT(!hasValidSamplingRate());
DEBUG_ASSERT(!m_file.isOpen());
if (!m_file.open(QIODevice::ReadOnly)) {
qWarning() << "Failed to open file:" << m_file.fileName();
return OpenResult::FAILED;
}
// Get a pointer to the file using memory mapped IO
m_fileSize = m_file.size();
m_pFileData = m_file.map(0, m_fileSize);
// NOTE(uklotzde): If the file disappears unexpectedly while mapped
// a SIGBUS error might occur that is not handled and will terminate
// Mixxx immediately. This behavior is documented in the manpage of
// mmap(). It has already appeared due to hardware errors and is
// described in the following bug report:
// https://bugs.launchpad.net/mixxx/+bug/1452005
// Transfer it to the mad stream-buffer:
mad_stream_options(&m_madStream, MAD_OPTION_IGNORECRC);
mad_stream_buffer(&m_madStream, m_pFileData, m_fileSize);
DEBUG_ASSERT(m_pFileData == m_madStream.this_frame);
DEBUG_ASSERT(m_seekFrameList.empty());
m_avgSeekFrameCount = 0;
m_curFrameIndex = getMinFrameIndex();
int headerPerSamplingRate[kSamplingRateCount];
for (int i = 0; i < kSamplingRateCount; ++i) {
headerPerSamplingRate[i] = 0;
}
// Decode all the headers and calculate audio properties
unsigned long sumBitrate = 0;
mad_header madHeader;
mad_header_init(&madHeader);
SINT maxChannelCount = getChannelCount();
do {
if (!decodeFrameHeader(&madHeader, &m_madStream, true)) {
if (isStreamValid(m_madStream)) {
// Skip frame
continue;
} else {
// Abort decoding
break;
}
}
// Grab data from madHeader
const unsigned int madSampleRate = madHeader.samplerate;
// TODO(XXX): Replace DEBUG_ASSERT with static_assert
// MAD must not change its enum values!
DEBUG_ASSERT(MAD_UNITS_8000_HZ == 8000);
const mad_units madUnits = static_cast<mad_units>(madSampleRate);
const long madFrameLength = mad_timer_count(madHeader.duration, madUnits);
if (0 >= madFrameLength) {
qWarning() << "Skipping MP3 frame with invalid length"
<< madFrameLength
<< "in:" << m_file.fileName();
// Skip frame
continue;
}
const SINT madChannelCount = MAD_NCHANNELS(&madHeader);
if (isValidChannelCount(maxChannelCount) && (madChannelCount != maxChannelCount)) {
qWarning() << "Differing number of channels"
<< madChannelCount << "<>" << maxChannelCount
<< "in some MP3 frame headers:"
<< m_file.fileName();
}
maxChannelCount = math_max(madChannelCount, maxChannelCount);
const int samplingRateIndex = getIndexBySamplingRate(madSampleRate);
if (samplingRateIndex >= kSamplingRateCount) {
qWarning() << "Invalid sample rate:" << m_file.fileName()
<< madSampleRate;
// Abort
mad_header_finish(&madHeader);
return OpenResult::FAILED;
}
// Count valid frames separated by its sampling rate
headerPerSamplingRate[samplingRateIndex]++;
addSeekFrame(m_curFrameIndex, m_madStream.this_frame);
// Accumulate data from the header
sumBitrate += madHeader.bitrate;
// Update current stream position
m_curFrameIndex += madFrameLength;
DEBUG_ASSERT(m_madStream.this_frame);
DEBUG_ASSERT(0 <= (m_madStream.this_frame - m_pFileData));
} while (quint64(m_madStream.this_frame - m_pFileData) < m_fileSize);
mad_header_finish(&madHeader);
if (MAD_ERROR_NONE != m_madStream.error) {
// Unreachable code for recoverable errors
DEBUG_ASSERT(!MAD_RECOVERABLE(m_madStream.error));
if (MAD_ERROR_BUFLEN != m_madStream.error) {
qWarning() << "Unrecoverable MP3 header error:"
<< mad_stream_errorstr(&m_madStream);
// Abort
return OpenResult::FAILED;
}
}
if (m_seekFrameList.empty()) {
// This is not a working MP3 file.
qWarning() << "SSMP3: This is not a working MP3 file:"
<< m_file.fileName();
// Abort
return OpenResult::FAILED;
}
int mostCommonSamplingRateIndex = kSamplingRateCount; // invalid
int mostCommonSamplingRateCount = 0;
int differentRates = 0;
for (int i = 0; i < kSamplingRateCount; ++i) {
// Find most common sampling rate
if (mostCommonSamplingRateCount < headerPerSamplingRate[i]) {
mostCommonSamplingRateCount = headerPerSamplingRate[i];
mostCommonSamplingRateIndex = i;
differentRates++;
}
}
if (differentRates > 1) {
qWarning() << "Differing sampling rate in some headers:"
<< m_file.fileName();
for (int i = 0; i < kSamplingRateCount; ++i) {
if (0 < headerPerSamplingRate[i]) {
qWarning() << headerPerSamplingRate[i] << "MP3 headers with sampling rate" << getSamplingRateByIndex(i);
}
}
qWarning() << "MP3 files with varying sample rate are not supported!";
qWarning() << "Since this happens most likely due to a corrupt file";
qWarning() << "Mixxx tries to plays it with the most common sample rate for this file";
}
if (mostCommonSamplingRateIndex < kSamplingRateCount) {
setSamplingRate(getSamplingRateByIndex(mostCommonSamplingRateIndex));
} else {
qWarning() << "No single valid sampling rate in header";
// Abort
return OpenResult::FAILED;
}
// Initialize the AudioSource
setChannelCount(maxChannelCount);
setFrameCount(m_curFrameIndex);
// Calculate average values
m_avgSeekFrameCount = getFrameCount() / m_seekFrameList.size();
const unsigned long avgBitrate = sumBitrate / m_seekFrameList.size();
setBitrate(avgBitrate / 1000);
// Terminate m_seekFrameList
addSeekFrame(m_curFrameIndex, 0);
// Reset positions
m_curFrameIndex = getMinFrameIndex();
// Restart decoding at the beginning of the audio stream
m_curFrameIndex = restartDecoding(m_seekFrameList.front());
if (m_curFrameIndex != m_seekFrameList.front().frameIndex) {
qWarning() << "Failed to start decoding:" << m_file.fileName();
// Abort
return OpenResult::FAILED;
}
return OpenResult::SUCCEEDED;
}
void QGstAppSrc::sendEOS()
{
gst_app_src_end_of_stream(GST_APP_SRC(m_appSrc));
if (isStreamValid() && !stream()->isSequential())
stream()->reset();
}
bool QGstAppSrc::doSeek(qint64 value)
{
if (isStreamValid())
return stream()->seek(value);
return false;
}
