diff options
Diffstat (limited to 'mediaplugin/src/plugins')
21 files changed, 3536 insertions, 0 deletions
diff --git a/mediaplugin/src/plugins/media/core/logger.cpp b/mediaplugin/src/plugins/media/core/logger.cpp new file mode 100644 index 00000000..fbdeb6a1 --- /dev/null +++ b/mediaplugin/src/plugins/media/core/logger.cpp @@ -0,0 +1,31 @@ +/* UltraStar Deluxe - Karaoke Game + * + * UltraStar Deluxe is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + */ +#include "core/logger.h" + +#ifdef __cplusplus + +Logger Logger::_instance; + +#endif /* __cplusplus */ diff --git a/mediaplugin/src/plugins/media/core/plugin_core.cpp b/mediaplugin/src/plugins/media/core/plugin_core.cpp new file mode 100644 index 00000000..751b93fa --- /dev/null +++ b/mediaplugin/src/plugins/media/core/plugin_core.cpp @@ -0,0 +1,40 @@ +/* UltraStar Deluxe - Karaoke Game + * + * UltraStar Deluxe is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + */ +#include "core/plugin_core.h" + +#ifdef __cplusplus +extern "C" { +#endif + +const pluginCore_t *pluginCore; + +BOOL pluginInitCore(const pluginCore_t *core) { + pluginCore = core; + return TRUE; +} + +#ifdef __cplusplus +} +#endif diff --git a/mediaplugin/src/plugins/media/core/util.cpp b/mediaplugin/src/plugins/media/core/util.cpp new file mode 100644 index 00000000..02487521 --- /dev/null +++ b/mediaplugin/src/plugins/media/core/util.cpp @@ -0,0 +1,30 @@ +/* UltraStar Deluxe - Karaoke Game + * + * UltraStar Deluxe is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + */ +#include "core/util.h" + +PLUGIN_CALL int threadMainRoutine(void *data) { + Thread *thread = (Thread *)data; + return thread->run(); +} diff --git a/mediaplugin/src/plugins/media/ffmpeg/ffmpeg_audio_convert.cpp b/mediaplugin/src/plugins/media/ffmpeg/ffmpeg_audio_convert.cpp new file mode 100644 index 00000000..ccbc5400 --- /dev/null +++ b/mediaplugin/src/plugins/media/ffmpeg/ffmpeg_audio_convert.cpp @@ -0,0 +1,74 @@ +/* UltraStar Deluxe - Karaoke Game + * + * UltraStar Deluxe is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + */ +#include "ffmpeg_audio_convert.h" + +/************************************ + * C Interface + ************************************/ + +#define ConvertStreamObj(ptr) reinterpret_cast<FFmpegAudioConvertStream*>(ptr) + +static BOOL PLUGIN_CALL ffmpegAudioConverter_init() { + return TRUE; +} + +static BOOL PLUGIN_CALL ffmpegAudioConverter_finalize() { + return TRUE; +} + +static audioConvertStream_t* PLUGIN_CALL ffmpegAudioConverter_open(audioFormatInfo_t *inputFormat, audioFormatInfo_t *outputFormat) { + return (audioConvertStream_t*)FFmpegAudioConvertStream::open(inputFormat, outputFormat); +} + +static void PLUGIN_CALL ffmpegAudioConverter_close(audioConvertStream_t *stream) { + delete ConvertStreamObj(stream); +} + +static int PLUGIN_CALL ffmpegAudioConverter_convert(audioConvertStream_t *stream, uint8_t *input, uint8_t *output, int *numSamples) { + return ConvertStreamObj(stream)->convert(input, output, *numSamples); +} + +static int PLUGIN_CALL ffmpegAudioConverter_getOutputBufferSize(audioConvertStream_t *stream, int inputSize) { + return ConvertStreamObj(stream)->getOutputBufferSize(inputSize); +} + +static double PLUGIN_CALL ffmpegAudioConverter_getRatio(audioConvertStream_t *stream) { + return ConvertStreamObj(stream)->getRatio(); +} + +/************************************ + * Module information + ************************************/ + +const audioConverterInfo_t audioConverterInfo = { + 70, + ffmpegAudioConverter_init, + ffmpegAudioConverter_finalize, + ffmpegAudioConverter_open, + ffmpegAudioConverter_close, + ffmpegAudioConverter_convert, + ffmpegAudioConverter_getOutputBufferSize, + ffmpegAudioConverter_getRatio +}; diff --git a/mediaplugin/src/plugins/media/ffmpeg/ffmpeg_audio_convert.h b/mediaplugin/src/plugins/media/ffmpeg/ffmpeg_audio_convert.h new file mode 100644 index 00000000..f2b44e48 --- /dev/null +++ b/mediaplugin/src/plugins/media/ffmpeg/ffmpeg_audio_convert.h @@ -0,0 +1,132 @@ +/* UltraStar Deluxe - Karaoke Game + * + * UltraStar Deluxe is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + */ +#ifndef _FFMPEG_AUDIO_CONVERT_H_ +#define _FFMPEG_AUDIO_CONVERT_H_ + +#include "ffmpeg_core.h" +#include "core/plugin_audio_convert.h" + +extern const audioConverterInfo_t audioConverterInfo; + +// Note: FFmpeg seems to be using "kaiser windowed sinc" for resampling, so +// the quality should be good. +class FFmpegAudioConvertStream : public AudioConvertStream { +private: + ReSampleContext *_resampleContext; + double _ratio; + +protected: + FFmpegAudioConvertStream(const AudioFormatInfo &srcFormatInfo, const AudioFormatInfo &dstFormatInfo) : + AudioConvertStream(srcFormatInfo, dstFormatInfo), + _resampleContext(NULL), + _ratio(0) {} + + bool init() { + // Note: FFmpeg does not support resampling for more than 2 input channels + + if (_srcFormatInfo.getFormat() != asfS16) { + logger.error("Unsupported format", "TAudioConverter_FFmpeg.Init"); + return false; + } + + if (_srcFormatInfo.getFormat() != _dstFormatInfo.getFormat()) { + logger.error("Incompatible formats", "TAudioConverter_FFmpeg.Init"); + return false; + } + +#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(52,15,0) + // use same values as the deprecated audio_resample_init() + const int TAPS = 16; + _resampleContext = av_audio_resample_init( + _dstFormatInfo.getChannels(), + _srcFormatInfo.getChannels(), + lround(_dstFormatInfo.getSampleRate()), + lround(_srcFormatInfo.getSampleRate()), + SAMPLE_FMT_S16, SAMPLE_FMT_S16, + TAPS, 10, 0, 0.8); +#else + _resampleContext = audio_resample_init( + dstFormatInfo.getChannels(), + srcFormatInfo.getChannels(), + lround(dstFormatInfo.getSampleRate()), + lround(srcFormatInfo.getSampleRate())); +#endif + + if (!_resampleContext) { + logger.error("audio_resample_init() failed", "TAudioConverter_FFmpeg.Init"); + return false; + } + + // calculate ratio + _ratio = ((double)_dstFormatInfo.getChannels() / _srcFormatInfo.getChannels()) * + (_dstFormatInfo.getSampleRate() / _srcFormatInfo.getSampleRate()); + + return true; + } + +public: + virtual ~FFmpegAudioConvertStream() { + if (_resampleContext) + audio_resample_close(_resampleContext); + } + + static FFmpegAudioConvertStream* open(const AudioFormatInfo &srcFormatInfo, const AudioFormatInfo &dstFormatInfo) { + FFmpegAudioConvertStream *converter = new FFmpegAudioConvertStream(srcFormatInfo, dstFormatInfo); + if (!converter->init()) { + delete converter; + return 0; + } + return converter; + } + + virtual int convert(uint8_t *inputBuffer, uint8_t *outputBuffer, int &inputSize) { + if (inputSize <= 0) { + // avoid div-by-zero in audio_resample() + return (inputSize == 0) ? 0 : -1; + } + + int inputSampleCount = inputSize / _srcFormatInfo.getFrameSize(); + int outputSampleCount = audio_resample(_resampleContext, + (short*)outputBuffer, (short*)inputBuffer, inputSampleCount); + if (outputSampleCount == -1) { + logger.error("audio_resample() failed", "TAudioConverter_FFmpeg.Convert"); + return -1; + } + return outputSampleCount * _dstFormatInfo.getFrameSize(); + } + + /** + * Destination/Source size ratio + */ + virtual double getRatio() { + return _ratio; + } + + virtual int getOutputBufferSize(int inputSize) { + return ceil(inputSize * getRatio()); + } +}; + +#endif /* _FFMPEG_AUDIO_CONVERT_H_ */ diff --git a/mediaplugin/src/plugins/media/ffmpeg/ffmpeg_audio_decode.cpp b/mediaplugin/src/plugins/media/ffmpeg/ffmpeg_audio_decode.cpp new file mode 100644 index 00000000..da49891c --- /dev/null +++ b/mediaplugin/src/plugins/media/ffmpeg/ffmpeg_audio_decode.cpp @@ -0,0 +1,705 @@ +/* UltraStar Deluxe - Karaoke Game + * + * UltraStar Deluxe is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + */ + +/******************************************************************************* + * + * This code is primarily based upon - + * http://www.dranger.com/ffmpeg/ffmpegtutorial_all.html + * + * and tutorial03.c + * + * http://www.inb.uni-luebeck.de/~boehme/using_libavcodec.html + * + *******************************************************************************/ + +#include "ffmpeg_audio_decode.h" +#include <string> +#include <sstream> +#include <cmath> + +// show FFmpeg specific debug output +//#define DEBUG_FFMPEG_DECODE + +// FFmpeg is very verbose and shows a bunch of errors. +// Those errors (they can be considered as warnings by us) can be ignored +// as they do not give any useful information. +// There is no solution to fix this except for turning them off. +//#define ENABLE_FFMPEG_ERROR_OUTPUT + +#define MAX_AUDIOQ_SIZE (5 * 16 * 1024) + +/* FFmpegDecodeStream */ + +FFmpegAudioDecodeStream::FFmpegAudioDecodeStream() : + _eofState(false), + _errorState(false), + _quitRequest(false), + _parserLocked(false), + _parserPauseRequestCount(0), + _seekRequest(false), + _seekFlags(0), + _seekPos(0), + _seekFlush(false), + _loop(false), + _formatCtx(NULL), + _codecCtx(NULL), + _codec(NULL), + _audioStreamIndex(-1), + _audioStream(NULL), + _audioStreamPos(0.0), + _decoderLocked(false), + _decoderPauseRequestCount(0), + _audioPaketSilence(0), + _audioBufferPos(0), + _audioBufferSize(0), + _filename("") +{ + memset(&_audioPaket, 0, sizeof(_audioPaket)); + memset(&_audioPaketTemp, 0, sizeof(_audioPaketTemp)); +} + +FFmpegAudioDecodeStream* FFmpegAudioDecodeStream::open(const IPath &filename) { + FFmpegAudioDecodeStream *stream = new FFmpegAudioDecodeStream(); + if (!stream->_open(filename)) { + delete stream; + return 0; + } + return stream; +} + +bool FFmpegAudioDecodeStream::_open(const IPath &filename) { + _filename = filename; + if (!filename.isFile()) { + logger.error("Audio-file does not exist: '" + filename.toNative() + "'", "UAudio_FFmpeg"); + return false; + } + + // use custom 'ufile' protocol for UTF-8 support + if (av_open_input_file(&_formatCtx, + ("ufile:" + filename.toUTF8()).c_str(), NULL, 0, NULL) != 0) + { + logger.error("av_open_input_file failed: '" + filename.toNative() + "'", "UAudio_FFmpeg"); + return false; + } + + // generate PTS values if they do not exist + _formatCtx->flags |= AVFMT_FLAG_GENPTS; + + // retrieve stream information + if (av_find_stream_info(_formatCtx) < 0) { + logger.error("av_find_stream_info failed: '" + filename.toNative() + "'", "UAudio_FFmpeg"); + return false; + } + + // FIXME: hack used by ffplay. Maybe should not use url_feof() to test for the end + _formatCtx->pb->eof_reached = 0; + +#ifdef DEBUG_FFMPEG_DECODE + dump_format(_formatCtx, 0, filename.toNative(), 0); +#endif + + _audioStreamIndex = ffmpegCore->findAudioStreamIndex(_formatCtx); + if (_audioStreamIndex < 0) { + logger.error("FindAudioStreamIndex: No Audio-stream found '" + filename.toNative() + "'", "UAudio_FFmpeg"); + return false; + } + + //std::stringstream s; + //s << _audioStreamIndex; + //logger.status("AudioStreamIndex is: " + s.str(), "UAudio_FFmpeg"); + + _audioStream = _formatCtx->streams[_audioStreamIndex]; + _audioStreamPos = 0; + _codecCtx = _audioStream->codec; + +#ifdef REQUEST_CHANNELS + // TODO: should we use this or not? Should we allow 5.1 channel audio? + #if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(51,42,0) + if (_codecCtx->channels > 0) + _codecCtx->request_channels = std::min(2, _codecCtx->channels); + else + _codecCtx->request_channels = 2; + #endif +#endif + + _codec = avcodec_find_decoder(_codecCtx->codec_id); + if (!_codec) { + logger.error("Unsupported codec!", "UAudio_FFmpeg"); + _codecCtx = NULL; + return false; + } + + // set debug options + _codecCtx->debug_mv = 0; + _codecCtx->debug = 0; + + // detect bug-workarounds automatically + _codecCtx->workaround_bugs = FF_BUG_AUTODETECT; + // error resilience strategy (careful/compliant/agressive/very_aggressive) + //CodecCtx->error_resilience = FF_ER_CAREFUL; //FF_ER_COMPLIANT; + // allow non spec compliant speedup tricks. + //CodecCtx->flags2 |= CODEC_FLAG2_FAST; + + // Note: avcodec_open() and avcodec_close() are not thread-safe and will + // fail if called concurrently by different threads. + int avResult; + { + MediaCore_FFmpeg::AVCodecLock codecLock; + avResult = avcodec_open(_codecCtx, _codec); + } + if (avResult < 0) { + logger.error("avcodec_open failed!", "UAudio_FFmpeg"); + return false; + } + + // now initialize the audio-format + + audioSampleFormat_t sampleFormat; + if (!ffmpegCore->convertFFmpegToAudioFormat(_codecCtx->sample_fmt, &sampleFormat)) { + // try standard format + sampleFormat = asfS16; + } + if (_codecCtx->channels > 255) { + logger.status("Error: _codecCtx->channels > 255", "TFFmpegDecodeStream.Open"); + } + _formatInfo = AudioFormatInfo( + _codecCtx->channels, + _codecCtx->sample_rate, + sampleFormat + ); + + // finally start the decode thread + start(); + + return true; +} + +void FFmpegAudioDecodeStream::close() { + // wake threads waiting for packet-queue data + // Note: normally, there are no waiting threads. If there were waiting + // ones, they would block the audio-callback thread. + _packetQueue.abort(); + + // send quit request (to parse-thread etc) + { + Mutex::RegionLock lock(_stateLock); + _quitRequest = true; + _parserIdleCond.broadcast(); + } + + // abort parse-thread + // and wait until it terminates + wait(); + + // Close the codec + if (_codecCtx) { + // avcodec_close() is not thread-safe + MediaCore_FFmpeg::AVCodecLock codecLock; + avcodec_close(_codecCtx); + } + + // Close the video file + if (_formatCtx) { + av_close_input_file(_formatCtx); + } +} + +double FFmpegAudioDecodeStream::getLength() { + // do not forget to consider the start_time value here + // there is a type size mismatch warnign because start_time and duration are cint64. + // So, in principle there could be an overflow when doing the sum. + return (double)(_formatCtx->start_time + _formatCtx->duration) / AV_TIME_BASE; +} + +double FFmpegAudioDecodeStream::getPosition() { + DecoderPauser decoderPauser(this); + + // ReadData() does not return all of the buffer retrieved by DecodeFrame(). + // Determine the size of the unused part of the decode-buffer. + double bufferSizeSec = (double)(_audioBufferSize - _audioBufferPos) / + _formatInfo.getBytesPerSec(); + + // subtract the size of unused buffer-data from the audio clock. + return _audioStreamPos - bufferSizeSec; +} + +void FFmpegAudioDecodeStream::setPosition(double time) { + setPositionIntern(time, true, true); +} + +/******************************************** +* Parser section +********************************************/ + +void FFmpegAudioDecodeStream::setPositionIntern(double time, bool flush, bool blocking) { + // - Pause the parser first to prevent it from putting obsolete packages + // into the queue after the queue was flushed and before seeking is done. + // Otherwise we will hear fragments of old data, if the stream was seeked + // in stopped mode and resumed afterwards (applies to non-blocking mode only). + // - Pause the decoder to avoid race-condition that might occur otherwise. + // - Last lock the state lock because we are manipulating some shared state-vars. + { + ParserPauser parserPauser(this); + DecoderPauser decoderPauser(this); + Mutex::RegionLock lock(_stateLock); + + _eofState = false; + _errorState = false; + + // do not seek if we are already at the correct position. + // This is important especially for seeking to position 0 if we already are + // at the beginning. Although seeking with AVSEEK_FLAG_BACKWARD for pos 0 works, + // it is still a bit choppy (although much better than w/o AVSEEK_FLAG_BACKWARD). + if (time == _audioStreamPos) + return; + + // configure seek parameters + _seekPos = time; + _seekFlush = flush; + _seekFlags = AVSEEK_FLAG_ANY; + _seekRequest = true; + + // Note: the BACKWARD-flag seeks to the first position <= the position + // searched for. Otherwise e.g. position 0 might not be seeked correct. + // For some reason ffmpeg sometimes doesn't use position 0 but the key-frame + // following. In streams with few key-frames (like many flv-files) the next + // key-frame after 0 might be 5secs ahead. + if (time <= _audioStreamPos) + _seekFlags |= AVSEEK_FLAG_BACKWARD; + + // send a reuse signal in case the parser was stopped (e.g. because of an EOF) + _parserIdleCond.signal(); + } + + // in blocking mode, wait until seeking is done + if (blocking) { + Mutex::RegionLock lock(_stateLock); + while (_seekRequest) + _seekFinishedCond.wait(_stateLock); + } +} + +int FFmpegAudioDecodeStream::run() { + // reuse thread as long as the stream is not terminated + while (parseLoop()) { + // wait for reuse or destruction of stream + Mutex::RegionLock lock(_stateLock); + while (!(_seekRequest || _quitRequest)) { + _parserIdleCond.wait(_stateLock); + } + } + return 0; +} + +/** +* Parser main loop. +* Will not return until parsing of the stream is finished. +* Reasons for the parser to return are: +* - the end-of-file is reached +* - an error occured +* - the stream was quited (received a quit-request) +* Returns true if the stream can be resumed or false if the stream has to +* be terminated. +*/ +bool FFmpegAudioDecodeStream::parseLoop() { + AVPacket packet; + while (true) { + ParserLock parserLock(this); + if (isQuit()) { + return false; + } + + // handle seek-request (Note: no need to lock SeekRequest here) + if (_seekRequest) { + // first try: seek on the audio stream + int64_t seekTarget = llround(_seekPos / av_q2d(_audioStream->time_base)); + // duration of silence at start of stream + double startSilence = 0; + if (seekTarget < _audioStream->start_time) + startSilence = (double)(_audioStream->start_time - seekTarget) * av_q2d(_audioStream->time_base); + int errorCode = av_seek_frame(_formatCtx, _audioStreamIndex, seekTarget, _seekFlags); + + if (errorCode < 0) { + // second try: seek on the default stream (necessary for flv-videos and some ogg-files) + seekTarget = llround(_seekPos * AV_TIME_BASE); + startSilence = 0; + if (seekTarget < _formatCtx->start_time) + startSilence = (double)(_formatCtx->start_time - seekTarget) / AV_TIME_BASE; + errorCode = av_seek_frame(_formatCtx, -1, seekTarget, _seekFlags); + } + + // pause decoder and lock state (keep the lock-order to avoid deadlocks). + // Note that the decoder does not block in the packet-queue in seeking state, + // so locking the decoder here does not cause a dead-lock. + { + DecoderPauser pause(this); + Mutex::RegionLock lock(_stateLock); + + if (errorCode < 0) { + // seeking failed + _errorState = true; + std::stringstream s; + s << "Seek Error in '" << _formatCtx->filename << "'"; + logger.error(s.str(), "UAudioDecoder_FFmpeg"); + } else { + if (_seekFlush) { + // flush queue (we will send a Flush-Packet when seeking is finished) + _packetQueue.flush(); + + // flush the decode buffers + _audioBufferSize = 0; + _audioBufferPos = 0; + _audioPaketSilence = 0; + memset(&_audioPaketTemp, 0, sizeof(_audioPaketTemp)); + flushCodecBuffers(); + + // Set preliminary stream position. The position will be set to + // the correct value as soon as the first packet is decoded. + _audioStreamPos = _seekPos; + } else { + // request avcodec buffer flush + _packetQueue.putStatus(PKT_STATUS_FLAG_FLUSH, NULL); + } + + // fill the gap between position 0 and start_time with silence + // but not if we are in loop mode + if (startSilence > 0 && !_loop) { + // pointer for the EMPTY status packet + double *startSilencePtr = (double*)malloc(sizeof(startSilence)); + *startSilencePtr = startSilence; + _packetQueue.putStatus(PKT_STATUS_FLAG_EMPTY, startSilencePtr); + } + } + _seekRequest = false; + _seekFinishedCond.broadcast(); + } + } + + if (_packetQueue.getSize() > MAX_AUDIOQ_SIZE) { + Thread::sleep(10); + continue; + } + + if (av_read_frame(_formatCtx, &packet) < 0) { + // failed to read a frame, check reason + ByteIOContext *byteIOCtx; +#if LIBAVFORMAT_VERSION_MAJOR >= 52 + byteIOCtx = _formatCtx->pb; +#else + byteIOCtx = &_formatCtx->pb; +#endif + + // check for end-of-file (eof is not an error) + if (url_feof(byteIOCtx) != 0) { + if (getLoop()) { + // rewind stream (but do not flush) + setPositionIntern(0, false, false); + continue; + } else { + // signal end-of-file + _packetQueue.putStatus(PKT_STATUS_FLAG_EOF, NULL); + return true; + } + } + + // check for errors + if (url_ferror(byteIOCtx) != 0) { + // an error occured -> abort and wait for repositioning or termination + _packetQueue.putStatus(PKT_STATUS_FLAG_ERROR, NULL); + return true; + } + + // url_feof() does not detect an EOF for some files + // so we have to do it this way. + if ((_formatCtx->file_size != 0) && (byteIOCtx->pos >= _formatCtx->file_size)) { + _packetQueue.putStatus(PKT_STATUS_FLAG_EOF, NULL); + return true; + } + + // unknown error occured, exit + _packetQueue.putStatus(PKT_STATUS_FLAG_ERROR, NULL); + return true; + } + + if (packet.stream_index == _audioStreamIndex) { + _packetQueue.put(&packet); + } else { + av_free_packet(&packet); + } + } +} + +/******************************************** +* Decoder section +********************************************/ + +void FFmpegAudioDecodeStream::flushCodecBuffers() { + // if no flush operation is specified, avcodec_flush_buffers will not do anything. + if (_codecCtx->codec->flush) { + // flush buffers used by avcodec_decode_audio, etc. + avcodec_flush_buffers(_codecCtx); + } else { + // we need a Workaround to avoid plopping noise with ogg-vorbis and + // mp3 (in older versions of FFmpeg). + // We will just reopen the codec. + MediaCore_FFmpeg::AVCodecLock codecLock; + avcodec_close(_codecCtx); + avcodec_open(_codecCtx, _codec); + } +} + +int FFmpegAudioDecodeStream::decodeFrame(uint8_t *buffer, int bufferSize) { + if (isEOF()) + return -1; + + while (true) { + // for titles with start_time > 0 we have to generate silence + // until we reach the pts of the first data packet. + if (_audioPaketSilence > 0) { + int dataSize = std::min(_audioPaketSilence, bufferSize); + memset(buffer, 0, dataSize); + _audioPaketSilence -= dataSize; + _audioStreamPos += dataSize / _formatInfo.getBytesPerSec(); + return dataSize; + } + + // read packet data + while (_audioPaketTemp.size > 0) { + // size of output data decoded by FFmpeg + int dataSize = bufferSize; + + int paketDecodedSize; // size of packet data used for decoding + paketDecodedSize = avcodec_decode_audio3(_codecCtx, (int16_t*)buffer, + &dataSize, &_audioPaketTemp); + + if (paketDecodedSize < 0) { + // if error, skip frame +#ifdef DEBUG_FFMPEG_DECODE + logger.status("Skip audio frame", ""); +#endif + _audioPaketTemp.size = 0; + break; + } + + _audioPaketTemp.data += paketDecodedSize; + _audioPaketTemp.size -= paketDecodedSize; + + // check if avcodec_decode_audio returned data, otherwise fetch more frames + if (dataSize <= 0) + continue; + + // update stream position by the amount of fetched data + _audioStreamPos += dataSize / _formatInfo.getBytesPerSec(); + + // we have data, return it and come back for more later + return dataSize; + } + + // free old packet data + if (_audioPaket.data) + av_free_packet(&_audioPaket); + + // do not block queue on seeking (to avoid deadlocks on the DecoderLock) + bool blockQueue = !isSeeking(); + + // request a new packet and block if none available. + // If this fails, the queue was aborted. + if (_packetQueue.get(&_audioPaket, blockQueue) <= 0) + return -1; + + // handle Status-packet + if (_audioPaket.data == STATUS_PACKET) { + _audioPaket.data = NULL; + memset(&_audioPaketTemp, 0, sizeof(_audioPaketTemp)); + + switch (_audioPaket.flags) { + case PKT_STATUS_FLAG_FLUSH: + // just used if SetPositionIntern was called without the flush flag. + flushCodecBuffers(); + break; + case PKT_STATUS_FLAG_EOF: // end-of-file + // ignore EOF while seeking + if (!isSeeking()) + setEOF(true); + // buffer contains no data + return -1; + case PKT_STATUS_FLAG_ERROR: + setError(true); + logger.status("I/O Error", "TFFmpegDecodeStream.DecodeFrame"); + return -1; + case PKT_STATUS_FLAG_EMPTY: { + double silenceDuration = *(double*) (_packetQueue.getStatusInfo(&_audioPaket)); + _audioPaketSilence = lround(silenceDuration * _formatInfo.getSampleRate()) * + _formatInfo.getFrameSize(); + _packetQueue.freeStatusInfo(&_audioPaket); + break; + } + default: + logger.status("Unknown status", "TFFmpegDecodeStream.DecodeFrame"); + } + + continue; + } + + _audioPaketTemp.data = _audioPaket.data; + _audioPaketTemp.size = _audioPaket.size; + + // if available, update the stream position to the presentation time of this package + if (_audioPaket.pts != (int64_t)AV_NOPTS_VALUE) { +#ifdef DEBUG_FFMPEG_DECODE + double tmpPos = _audioStreamPos; +#endif + _audioStreamPos = av_q2d(_audioStream->time_base) * _audioPaket.pts; +#ifdef DEBUG_FFMPEG_DECODE + stringstream s; + s << "Timestamp: " << _audioStreamPos << " " + << "(Calc: " << tmpPos << "), " + << "Diff: " << (_audioStreamPos-TmpPos); + logger.status(s.str(), ""); +#endif + } + } +} + +int FFmpegAudioDecodeStream::readData(uint8_t *buffer, int bufferSize) { + // set number of bytes to copy to the output buffer + int bufferPos = 0; + + { + DecoderLock decoderLock(this); + + // leave if end-of-file is reached + if (isEOF()) { + return -1; + } + + // copy data to output buffer + while (bufferPos < bufferSize) { + // check if we need more data + if (_audioBufferPos >= _audioBufferSize) { + _audioBufferPos = 0; + + // we have already sent all our data; get more + _audioBufferSize = decodeFrame(_audioBuffer, AUDIO_BUFFER_SIZE); + if (_audioBufferSize < 0) { + // error or EOF occurred + return bufferPos; + } + } + + // calc number of new bytes in the decode-buffer (number of bytes to copy) + int copyByteCount = _audioBufferSize - _audioBufferPos; + // number of bytes left (remain) to read + int remainByteCount = bufferSize - bufferPos; + // resize copy-count if more bytes available than needed (remaining bytes are used the next time) + if (copyByteCount > remainByteCount) + copyByteCount = remainByteCount; + + memcpy(&buffer[bufferPos], &_audioBuffer[_audioBufferPos], copyByteCount); + bufferPos += copyByteCount; + _audioBufferPos += copyByteCount; + } + } + return bufferSize; +} + +/************************************ + * C Interface + ************************************/ + +#define DecodeStreamObj(ptr) reinterpret_cast<PluginDecodeStream*>(ptr) + +static BOOL PLUGIN_CALL ffmpegAudioDecoder_init() { + return TRUE; +} + +static BOOL PLUGIN_CALL ffmpegAudioDecoder_finalize() { + return TRUE; +} + +static audioDecodeStream_t* PLUGIN_CALL ffmpegAudioDecoder_open(const char *filename) { + return (audioDecodeStream_t*)FFmpegAudioDecodeStream::open(filename); +} + +static void PLUGIN_CALL ffmpegAudioDecoder_close(audioDecodeStream_t *stream) { + delete DecodeStreamObj(stream); +} + +static double PLUGIN_CALL ffmpegAudioDecoder_getLength(audioDecodeStream_t *stream) { + return DecodeStreamObj(stream)->getLength(); +} + +static void PLUGIN_CALL ffmpegAudioDecoder_getAudioFormatInfo(audioDecodeStream_t *stream, audioFormatInfo_t *info) { + DecodeStreamObj(stream)->getAudioFormatInfo().toCStruct(info); +} + +static double PLUGIN_CALL ffmpegAudioDecoder_getPosition(audioDecodeStream_t *stream) { + return DecodeStreamObj(stream)->getPosition(); +} + +static void PLUGIN_CALL ffmpegAudioDecoder_setPosition(audioDecodeStream_t *stream, double time) { + DecodeStreamObj(stream)->setPosition(time); +} + +static BOOL PLUGIN_CALL ffmpegAudioDecoder_getLoop(audioDecodeStream_t *stream) { + return (BOOL)DecodeStreamObj(stream)->getLoop(); +} + +static void PLUGIN_CALL ffmpegAudioDecoder_setLoop(audioDecodeStream_t *stream, BOOL enabled) { + DecodeStreamObj(stream)->setLoop(enabled); +} + +static BOOL PLUGIN_CALL ffmpegAudioDecoder_isEOF(audioDecodeStream_t *stream) { + return (BOOL)DecodeStreamObj(stream)->isEOF(); +} + +static BOOL PLUGIN_CALL ffmpegAudioDecoder_isError(audioDecodeStream_t *stream) { + return (BOOL)DecodeStreamObj(stream)->isError(); +} + +static int PLUGIN_CALL ffmpegAudioDecoder_readData(audioDecodeStream_t *stream, uint8_t *buffer, int bufferSize) { + return DecodeStreamObj(stream)->readData(buffer, bufferSize); +} + +/************************************ + * Module information + ************************************/ + +const audioDecoderInfo_t audioDecoderInfo = { + 50, + ffmpegAudioDecoder_init, + ffmpegAudioDecoder_finalize, + ffmpegAudioDecoder_open, + ffmpegAudioDecoder_close, + ffmpegAudioDecoder_getLength, + ffmpegAudioDecoder_getAudioFormatInfo, + ffmpegAudioDecoder_getPosition, + ffmpegAudioDecoder_setPosition, + ffmpegAudioDecoder_getLoop, + ffmpegAudioDecoder_setLoop, + ffmpegAudioDecoder_isEOF, + ffmpegAudioDecoder_isError, + ffmpegAudioDecoder_readData +}; diff --git a/mediaplugin/src/plugins/media/ffmpeg/ffmpeg_audio_decode.h b/mediaplugin/src/plugins/media/ffmpeg/ffmpeg_audio_decode.h new file mode 100644 index 00000000..c0d1b288 --- /dev/null +++ b/mediaplugin/src/plugins/media/ffmpeg/ffmpeg_audio_decode.h @@ -0,0 +1,257 @@ +/* UltraStar Deluxe - Karaoke Game + * + * UltraStar Deluxe is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + */ +#ifndef _FFMPEG_AUDIO_DECODE_H_ +#define _FFMPEG_AUDIO_DECODE_H_ + +#include "ffmpeg_core.h" +#include "core/plugin_audio_decode.h" + +// TODO: The factor 3/2 might not be necessary as we do not need extra +// space for synchronizing as in the tutorial. +#define AUDIO_BUFFER_SIZE ((AVCODEC_MAX_AUDIO_FRAME_SIZE * 3) / 2) + +extern const audioDecoderInfo_t audioDecoderInfo; + +class FFmpegAudioDecodeStream : public PluginDecodeStream, private Thread { +private: + Mutex _stateLock; + + bool _eofState; // end-of-stream flag (locked by StateLock) + bool _errorState; // error flag (locked by StateLock) + + bool _quitRequest; // (locked by StateLock) + Condition _parserIdleCond; + + // parser pause/resume data + bool _parserLocked; + int _parserPauseRequestCount; + Condition _parserUnlockedCond; + Condition _parserResumeCond; + + bool _seekRequest; // (locked by StateLock) + int _seekFlags; // (locked by StateLock) + double _seekPos; // stream position to seek for (in secs) (locked by StateLock) + bool _seekFlush; // true if the buffers should be flushed after seeking (locked by StateLock) + Condition _seekFinishedCond; + + bool _loop; // (locked by StateLock) + + PacketQueue _packetQueue; + + AudioFormatInfo _formatInfo; + + // FFmpeg specific data + AVFormatContext *_formatCtx; + AVCodecContext *_codecCtx; + AVCodec *_codec; + + int _audioStreamIndex; + AVStream *_audioStream; + double _audioStreamPos; // stream position in seconds (locked by DecoderLock) + + // decoder pause/resume data + bool _decoderLocked; + int _decoderPauseRequestCount; + Condition _decoderUnlockedCond; + Condition _decoderResumeCond; + + // state-vars for DecodeFrame (locked by DecoderLock) + AVPacket _audioPaket; + AVPacket _audioPaketTemp; + int _audioPaketSilence; // number of bytes of silence to return + + // state-vars for AudioCallback (locked by DecoderLock) + int _audioBufferPos; + int _audioBufferSize; + DECLARE_ALIGNED(16, uint8_t, _audioBuffer[AUDIO_BUFFER_SIZE]); + + IPath _filename; + +private: + FFmpegAudioDecodeStream(); + + void setPositionIntern(double time, bool flush, bool blocking); + + void setEOF(bool state) { + Mutex::RegionLock lock(_stateLock); + _eofState = state; + } + + void setError(bool state) { + Mutex::RegionLock lock(_stateLock); + _errorState = state; + } + + bool isSeeking() { + Mutex::RegionLock lock(_stateLock); + return _seekRequest; + } + + bool isQuit() { + Mutex::RegionLock lock(_stateLock); + return _quitRequest; + } + + bool parseLoop(); + + int decodeFrame(uint8_t *buffer, int bufferSize); + void flushCodecBuffers(); + + bool _open(const IPath &filename); + void close(); + +public: + virtual ~FFmpegAudioDecodeStream() { + close(); + } + + static FFmpegAudioDecodeStream* open(const IPath &filename); + + virtual double getLength(); + + virtual const AudioFormatInfo &getAudioFormatInfo() { + return _formatInfo; + } + + virtual double getPosition(); + virtual void setPosition(double time); + + virtual bool getLoop() { + Mutex::RegionLock lock(_stateLock); + return _loop; + } + + virtual void setLoop(bool Enabled) { + Mutex::RegionLock lock(_stateLock); + _loop = Enabled; + } + + virtual bool isEOF() { + Mutex::RegionLock lock(_stateLock); + return _eofState; + } + + virtual bool isError() { + Mutex::RegionLock lock(_stateLock); + return _errorState; + } + + virtual int readData(uint8_t *buffer, int bufferSize); + +public: + int run(); + +public: + class ParserLock { + private: + FFmpegAudioDecodeStream *_stream; + public: + // Note: pthreads wakes threads waiting on a mutex in the order of their + // priority and not in FIFO order. SDL does not provide any option to + // control priorities. This might (and already did) starve threads waiting + // on the mutex (e.g. SetPosition) making usdx look like it was froozen. + // Instead of simply locking the critical section we set a ParserLocked flag + // instead and give priority to the threads requesting the parser to pause. + ParserLock(FFmpegAudioDecodeStream *stream) : _stream(stream) { + Mutex::RegionLock lock(_stream->_stateLock); + while (_stream->_parserPauseRequestCount > 0) + _stream->_parserResumeCond.wait(_stream->_stateLock); + _stream->_parserLocked = true; + } + + ~ParserLock() { + Mutex::RegionLock lock(_stream->_stateLock); + _stream->_parserLocked = false; + _stream->_parserUnlockedCond.broadcast(); + } + }; + + class ParserPauser { + private: + FFmpegAudioDecodeStream *_stream; + public: + ParserPauser(FFmpegAudioDecodeStream *stream) : _stream(stream) { + if (Thread::getCurrentThreadID() == _stream->getThreadID()) + return; + + { + Mutex::RegionLock lock(_stream->_stateLock); + ++_stream->_parserPauseRequestCount; + while (_stream->_parserLocked) + _stream->_parserUnlockedCond.wait(_stream->_stateLock); + } + } + + ~ParserPauser() { + if (Thread::getCurrentThreadID() == _stream->getThreadID()) + return; + + { + Mutex::RegionLock lock(_stream->_stateLock); + --_stream->_parserPauseRequestCount; + _stream->_parserResumeCond.signal(); + } + } + }; + + class DecoderLock { + private: + FFmpegAudioDecodeStream *_stream; + public: + // prioritize pause requests + DecoderLock(FFmpegAudioDecodeStream *stream) : _stream(stream) { + Mutex::RegionLock lock(_stream->_stateLock); + while (_stream->_decoderPauseRequestCount > 0) + _stream->_decoderResumeCond.wait(_stream->_stateLock); + _stream->_decoderLocked = true; + } + + ~DecoderLock() { + Mutex::RegionLock lock(_stream->_stateLock); + _stream->_decoderLocked = false; + _stream->_decoderUnlockedCond.broadcast(); + } + }; + + class DecoderPauser { + private: + FFmpegAudioDecodeStream *_stream; + public: + DecoderPauser(FFmpegAudioDecodeStream *stream) : _stream(stream) { + Mutex::RegionLock lock(_stream->_stateLock); + ++_stream->_decoderPauseRequestCount; + while (_stream->_decoderLocked) + _stream->_decoderUnlockedCond.wait(_stream->_stateLock); + } + + ~DecoderPauser() { + Mutex::RegionLock lock(_stream->_stateLock); + --_stream->_decoderPauseRequestCount; + _stream->_decoderResumeCond.signal(); + } + }; +}; + +#endif /* _FFMPEG_AUDIO_DECODE_H_ */ diff --git a/mediaplugin/src/plugins/media/ffmpeg/ffmpeg_core.cpp b/mediaplugin/src/plugins/media/ffmpeg/ffmpeg_core.cpp new file mode 100644 index 00000000..6f48c199 --- /dev/null +++ b/mediaplugin/src/plugins/media/ffmpeg/ffmpeg_core.cpp @@ -0,0 +1,412 @@ +/* UltraStar Deluxe - Karaoke Game + * + * UltraStar Deluxe is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + */ +#include "ffmpeg_core.h" +#include "core/logger.h" +#include <sstream> + +const uint8_t* STATUS_PACKET = (uint8_t*)"STATUS_PACKET"; + +static int CDECL ffmpegStreamOpen(URLContext *h, const char *filename, int flags); +static int CDECL ffmpegStreamRead(URLContext *h, uint8_t *buf, int size); +static int CDECL ffmpegStreamWrite(URLContext *h, const unsigned char *buf, int size); +static int64_t CDECL ffmpegStreamSeek(URLContext *h, int64_t pos, int whence); +static int CDECL ffmpegStreamClose(URLContext *h); + +#define UNICODE_PROTOCOL_NAME "ufile" +#define UNICODE_PROTOCOL_PREFIX UNICODE_PROTOCOL_NAME ":" + +std::string hexVerToStr(unsigned version) { + unsigned major = (version >> 16) & 0xFF; + unsigned minor = (version >> 8) & 0xFF; + unsigned release = version & 0xFF; + std::stringstream s; + s << major << "." << minor << "." << release; + return s.str(); +} + +void checkVersions() { + unsigned libVersion; + unsigned headerVersion; + + #ifdef LIBAVCODEC_VERSION_INT + libVersion = avcodec_version(); + headerVersion = LIBAVCODEC_VERSION_INT; + if (libVersion != headerVersion) { + logger.error("libavcodec header (" + hexVerToStr(headerVersion) + + ") and " + "DLL (" + hexVerToStr(libVersion) + + ") versions do not match.", ""); + } + #endif + + #if defined(LIBAVFORMAT_VERSION_INT) && \ + (LIBAVFORMAT_VERSION_INT >= AV_VERSION_INT(52,20,0)) + libVersion = avformat_version(); + headerVersion = LIBAVFORMAT_VERSION_INT; + if (libVersion != headerVersion) { + logger.error("libavformat header (" + hexVerToStr(headerVersion) + + ") and " + "DLL (" + hexVerToStr(libVersion) + + ") versions do not match.", ""); + } + #endif + + #if defined(LIBAVUTIL_VERSION_INT) && \ + (LIBAVUTIL_VERSION_INT >= AV_VERSION_INT(49,8,0)) + libVersion = avutil_version(); + headerVersion = LIBAVUTIL_VERSION_INT; + if (libVersion != headerVersion) { + logger.error("libavutil header (" + hexVerToStr(headerVersion) + ") and " + + "DLL (" + hexVerToStr(libVersion) + + ") versions do not match.", ""); + } + #endif + + #if defined(LIBSWSCALE_VERSION_INT) && \ + (LIBSWSCALE_VERSION_INT >= AV_VERSION_INT(0,6,1)) + libVersion = swscale_version(); + headerVersion = LIBSWSCALE_VERSION_INT; + if (libVersion != headerVersion) { + logger.error("libswscale header (" + hexVerToStr(headerVersion) + + ") and " + "DLL (" + hexVerToStr(libVersion) + + ") versions do not match.", ""); + } + #endif +} + +MediaCore_FFmpeg::MediaCore_FFmpeg() { + checkVersions(); + + memset(&utf8FileProtocol, 0, sizeof(URLProtocol)); + utf8FileProtocol.name = UNICODE_PROTOCOL_NAME; + utf8FileProtocol.url_open = ffmpegStreamOpen; + utf8FileProtocol.url_read = ffmpegStreamRead; + utf8FileProtocol.url_write = ffmpegStreamWrite; + utf8FileProtocol.url_seek = ffmpegStreamSeek; + utf8FileProtocol.url_close = ffmpegStreamClose; + + av_register_protocol2(&utf8FileProtocol, sizeof(URLProtocol)); +} + +MediaCore_FFmpeg::~MediaCore_FFmpeg() { +} + +std::string MediaCore_FFmpeg::getErrorString(int errorNum) const { + switch (errorNum) { + case AVERROR_IO: + return "AVERROR_IO"; + case AVERROR_NUMEXPECTED: + return "AVERROR_NUMEXPECTED"; + case AVERROR_INVALIDDATA: + return "AVERROR_INVALIDDATA"; + case AVERROR_NOMEM: + return "AVERROR_NOMEM"; + case AVERROR_NOFMT: + return "AVERROR_NOFMT"; + case AVERROR_NOTSUPP: + return "AVERROR_NOTSUPP"; + case AVERROR_NOENT: + return "AVERROR_NOENT"; + case AVERROR_PATCHWELCOME: + return "AVERROR_PATCHWELCOME"; + default: + return "AVERROR_#" + errorNum; + } +} + +/* + @param(formatCtx is a PAVFormatContext returned from av_open_input_file ) + @param(firstVideoStream is an OUT value of type integer, this is the index of the video stream) + @param(firstAudioStream is an OUT value of type integer, this is the index of the audio stream) + @returns(@true on success, @false otherwise) + */ +bool MediaCore_FFmpeg::findStreamIDs(AVFormatContext *formatCtx, + int *firstVideoStream, int *firstAudioStream) const +{ + // find the first video stream + *firstAudioStream = -1; + *firstVideoStream = -1; + + for (unsigned i = 0; i < formatCtx->nb_streams; ++i) { + AVStream *stream = formatCtx->streams[i]; + + if ((stream->codec->codec_type == AVMEDIA_TYPE_VIDEO) && (*firstVideoStream < 0)) { + *firstVideoStream = i; + } + + if ((stream->codec->codec_type == AVMEDIA_TYPE_AUDIO) && (*firstAudioStream < 0)) { + *firstAudioStream = i; + } + } + + // return true if either an audio- or video-stream was found + return (*firstAudioStream > -1) || (*firstVideoStream > -1); +} + +int MediaCore_FFmpeg::findAudioStreamIndex(AVFormatContext *formatCtx) const { + // find the first audio stream + int streamIndex = -1; + for (unsigned i = 0; i < formatCtx->nb_streams; ++i) { + AVStream *stream = formatCtx->streams[i]; + if (stream->codec->codec_type == AVMEDIA_TYPE_AUDIO) { + streamIndex = i; + break; + } + } + return streamIndex; +} + +bool MediaCore_FFmpeg::convertFFmpegToAudioFormat(SampleFormat ffmpegFormat, audioSampleFormat_t *format) const { + switch (ffmpegFormat) { + case SAMPLE_FMT_U8: + *format = asfU8; + break; + case SAMPLE_FMT_S16: + *format = asfS16; + break; + case SAMPLE_FMT_S32: + *format = asfS32; + break; + case SAMPLE_FMT_FLT: + *format = asfFloat; + break; + case SAMPLE_FMT_DBL: + *format = asfDouble; + break; + default: + return false; + } + return true; +} + +/** + * UTF-8 Filename wrapper based on: + * http://www.mail-archive.com/libav-user@mplayerhq.hu/msg02460.html + */ + +int CDECL ffmpegStreamOpen(URLContext *h, const char *filename, int flags) { + // check for protocol prefix ("ufile:") and strip it + const std::string protPrefix(UNICODE_PROTOCOL_PREFIX); + std::string utf8Filename(filename); + if (utf8Filename.compare(0, protPrefix.size(), protPrefix) == 0) + utf8Filename.erase(0, protPrefix.size()); + + int mode; + switch (flags) { + case URL_RDWR: + mode = FILE_OPEN_MODE_READ_WRITE; + break; + case URL_WRONLY: + mode = FILE_OPEN_MODE_WRITE; + break; + case URL_RDONLY: + mode = FILE_OPEN_MODE_READ; + } + + fileStream_t *stream = pluginCore->fileOpen(utf8Filename.c_str(), mode); + if (!stream) + return AVERROR_NOENT; + h->priv_data = stream; + return 0; +} + +int CDECL ffmpegStreamRead(URLContext *h, uint8_t *buf, int size) { + fileStream_t *stream = (fileStream_t*)h->priv_data; + return pluginCore->fileRead(stream, buf, size); +} + +int CDECL ffmpegStreamWrite(URLContext *h, const uint8_t *buf, int size) { + fileStream_t *stream = (fileStream_t*)h->priv_data; + return pluginCore->fileWrite(stream, buf, size); +} + +int64_t CDECL ffmpegStreamSeek(URLContext *h, int64_t pos, int whence) { + fileStream_t *stream = (fileStream_t*)h->priv_data; + switch (whence) { + case AVSEEK_SIZE: + return pluginCore->fileSize(stream); + default: + return pluginCore->fileSeek(stream, pos, whence); + } +} + +int CDECL ffmpegStreamClose(URLContext *h) { + fileStream_t *stream = (fileStream_t*)h->priv_data; + pluginCore->fileClose(stream); + return 0; +} + +/* PacketQueue */ + +PacketQueue::PacketQueue() : + _firstListEntry(NULL), + _lastListEntry(NULL), + _packetCount(0), + _size(0), + _abortRequest(false) +{} + +PacketQueue::~PacketQueue() { + flush(); +} + +void PacketQueue::abort() { + Mutex::RegionLock lock(_mutex); + _abortRequest = true; + _condition.broadcast(); +} + +bool PacketQueue::isAborted() { + Mutex::RegionLock lock(_mutex); + return _abortRequest; +} + +int PacketQueue::put(AVPacket *packet) { + if (!packet) + return -1; + + if (packet->data != STATUS_PACKET) { + if (av_dup_packet(packet) < 0) + return -1; + } + + AVPacketList *currentListEntry = (AVPacketList*) av_malloc(sizeof(AVPacketList)); + if (!currentListEntry) + return -1; + + currentListEntry->pkt = *packet; + currentListEntry->next = NULL; + + { + Mutex::RegionLock lock(_mutex); + + if (!_lastListEntry) + _firstListEntry = currentListEntry; + else + _lastListEntry->next = currentListEntry; + + _lastListEntry = currentListEntry; + ++_packetCount; + + _size += currentListEntry->pkt.size; + _condition.signal(); + } + + return 0; +} + +/** + * Adds a status packet (EOF, Flush, etc.) to the end of the queue. + * StatusInfo can be used to pass additional information to the decoder. + * Only assign nil or a valid pointer to data allocated with Getmem() to + * StatusInfo because the pointer will be disposed with Freemem() on a call + * to Flush(). If the packet is removed from the queue it is the decoder's + * responsibility to free the StatusInfo data with FreeStatusInfo(). + */ +int PacketQueue::putStatus(int statusFlag, void *statusInfo) { + // create temp. package + AVPacket *tempPacket = (AVPacket*) av_malloc(sizeof(AVPacket)); + if (!tempPacket) + return -1; + + // init package + av_init_packet(tempPacket); + tempPacket->data = const_cast<uint8_t*> (STATUS_PACKET); + tempPacket->flags = statusFlag; + tempPacket->priv = statusInfo; + // put a copy of the package into the queue + const int result = put(tempPacket); + // data has been copied -> delete temp. package + av_free(tempPacket); + return result; +} + +void PacketQueue::freeStatusInfo(AVPacket *packet) { + if (packet->priv) + free(packet->priv); +} + +void* PacketQueue::getStatusInfo(AVPacket *packet) { + return packet->priv; +} + +int PacketQueue::get(AVPacket *packet, bool blocking) { + const int WAIT_TIMEOUT = 10; // timeout in ms + + { + Mutex::RegionLock lock(_mutex); + while (true) { + if (_abortRequest) + return -1; + + AVPacketList *currentListEntry = _firstListEntry; + if (currentListEntry) { + _firstListEntry = currentListEntry->next; + if (!_firstListEntry) + _lastListEntry = NULL; + --_packetCount; + + _size -= currentListEntry->pkt.size; + *packet = currentListEntry->pkt; + av_free(currentListEntry); + + return 1; + } else if (!blocking) { + return 0; + } else { + // block until a new package arrives, + // but do not wait till infinity to avoid deadlocks + if (_condition.waitTimeout(_mutex, WAIT_TIMEOUT) == MUTEX_TIMEDOUT) { + return 0; + } + } + } + } +} + +int PacketQueue::getSize() { + Mutex::RegionLock lock(_mutex); + return _size; +} + +void PacketQueue::flush() { + Mutex::RegionLock lock(_mutex); + + AVPacketList *tempListEntry; + AVPacketList *currentListEntry = _firstListEntry; + while (currentListEntry) { + tempListEntry = currentListEntry->next; + // free status data + if (currentListEntry->pkt.data == STATUS_PACKET) + freeStatusInfo(¤tListEntry->pkt); + // free packet data + av_free_packet(¤tListEntry->pkt); + // Note: param must be a pointer to a pointer! + av_freep(¤tListEntry); + currentListEntry = tempListEntry; + } + _lastListEntry = NULL; + _firstListEntry = NULL; + _packetCount = 0; + _size = 0; +} diff --git a/mediaplugin/src/plugins/media/ffmpeg/ffmpeg_core.h b/mediaplugin/src/plugins/media/ffmpeg/ffmpeg_core.h new file mode 100644 index 00000000..9b55d5e4 --- /dev/null +++ b/mediaplugin/src/plugins/media/ffmpeg/ffmpeg_core.h @@ -0,0 +1,136 @@ +/* UltraStar Deluxe - Karaoke Game + * + * UltraStar Deluxe is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + */ +#ifndef _FFMPEG_CORE_H_ +#define _FFMPEG_CORE_H_ + +#ifndef __STDC_CONSTANT_MACROS +#define __STDC_CONSTANT_MACROS +#endif +#include <inttypes.h> +#include <string> +extern "C" { +#include <libavcodec/avcodec.h> +#include <libavformat/avformat.h> +#include <libavformat/avio.h> +#include <libavutil/avutil.h> +#include <libavutil/mathematics.h> +#include <libavutil/rational.h> // used for av_rescale_q +#include <libswscale/swscale.h> +} +#include "core/util.h" + +class PacketQueue { +private: + AVPacketList *_firstListEntry; + AVPacketList *_lastListEntry; + int _packetCount; + Mutex _mutex; + Condition _condition; + int _size; + bool _abortRequest; +public: + PacketQueue(); + ~PacketQueue(); + + int put(AVPacket *packet); + int putStatus(int statusFlag, void *statusInfo); + void freeStatusInfo(AVPacket *packet); + void* getStatusInfo(AVPacket *packet); + int get(AVPacket *packet, bool blocking); + int getSize(); + void flush(); + void abort(); + bool isAborted(); +}; + +extern const uint8_t* STATUS_PACKET; +enum { + PKT_STATUS_FLAG_EOF = 1, // signal end-of-file + PKT_STATUS_FLAG_FLUSH, // request the decoder to flush its avcodec decode buffers + PKT_STATUS_FLAG_ERROR, // signal an error state + PKT_STATUS_FLAG_EMPTY // request the decoder to output empty data (silence or black frames) +}; + +class MediaCore_FFmpeg; + +// Note: singleton pattern does not work here as static vars +// are initialized before the plugin itself is initialized. +extern MediaCore_FFmpeg *ffmpegCore; + +class MediaCore_FFmpeg { +private: + URLProtocol utf8FileProtocol; + Mutex _codecLock; +public: + MediaCore_FFmpeg(); + ~MediaCore_FFmpeg(); + + std::string getErrorString(int errorNum) const; + bool findStreamIDs(AVFormatContext *formatCtx, int *firstVideoStream, int *firstAudioStream) const; + int findAudioStreamIndex(AVFormatContext *formatCtx) const; + bool convertFFmpegToAudioFormat(SampleFormat ffmpegFormat, audioSampleFormat_t *format) const; + +public: + class AVCodecLock { + public: + AVCodecLock() { + ffmpegCore->_codecLock.lock(); + } + + ~AVCodecLock() { + ffmpegCore->_codecLock.unlock(); + } + }; +}; + +// FFmpeg compatibility with older versions + +#if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(52,64,0) +#define AVMEDIA_TYPE_VIDEO CODEC_TYPE_VIDEO +#define AVMEDIA_TYPE_AUDIO CODEC_TYPE_AUDIO +#endif + +#if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(52,26,0) +#define avcodec_decode_video2(avctx, picture, got_picture_ptr, avpkt) \ + avcodec_decode_video((avctx), (picture), (got_picture_ptr), \ + (avpkt)->data, (avpkt)->size) +#endif + +#if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(51,30,0) +#define avcodec_decode_audio3(avctx, samples, frame_size_ptr, avpkt) \ + avcodec_decode_audio((avctx), (samples), (frame_size_ptr), \ + (avpkt)->data, (avpkt)->size) +#elif LIBAVCODEC_VERSION_INT < AV_VERSION_INT(52,26,0) +#define avcodec_decode_audio3(avctx, samples, frame_size_ptr, avpkt) \ + avcodec_decode_audio2((avctx), (samples), (frame_size_ptr), \ + (avpkt)->data, (avpkt)->size) +#endif + +#if LIBAVFORMAT_VERSION_INT < AV_VERSION_INT(52,69,0) +#define av_register_protocol2(prot, size) \ + av_register_protocol(prot) +#endif + +#endif /* _FFMPEG_CORE_H_ */ diff --git a/mediaplugin/src/plugins/media/ffmpeg/ffmpeg_plugin.cpp b/mediaplugin/src/plugins/media/ffmpeg/ffmpeg_plugin.cpp new file mode 100644 index 00000000..35451388 --- /dev/null +++ b/mediaplugin/src/plugins/media/ffmpeg/ffmpeg_plugin.cpp @@ -0,0 +1,82 @@ +/* UltraStar Deluxe - Karaoke Game + * + * UltraStar Deluxe is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + */ +#include "ffmpeg_core.h" +#include "core/plugin_core.h" +#include "ffmpeg_plugin.h" +#include "ffmpeg_audio_decode.h" +#include "ffmpeg_audio_convert.h" +#include "ffmpeg_video_decode.h" + +MediaCore_FFmpeg *ffmpegCore; + +DLL_EXPORT const pluginInfo_t* PLUGIN_CALL Plugin_register(const pluginCore_t *core) { + pluginInitCore(core); + return &pluginInfo; +} + +static BOOL PLUGIN_CALL Plugin_initialize() { + static bool initialized = false; + if (initialized) + return TRUE; + initialized = TRUE; + + //logger.status("InitializeDecoder", "Plugin_initialize"); + + av_register_all(); + + ffmpegCore = new MediaCore_FFmpeg(); + + // Do not show uninformative error messages by default. + // FFmpeg prints all error-infos on the console by default what + // is very confusing as the playback of the files is correct. + // We consider these errors to be internal to FFMpeg. They can be fixed + // by the FFmpeg guys only and do not provide any useful information in + // respect to USDX. +#ifndef ENABLE_FFMPEG_ERROR_OUTPUT +#if LIBAVUTIL_VERSION_MAJOR >= 50 + av_log_set_level(AV_LOG_FATAL); +#else + // FATAL and ERROR share one log-level, so we have to use QUIET + av_log_set_level(AV_LOG_QUIET); +#endif //LIBAVUTIL_VERSION_MAJOR +#endif //ENABLE_FFMPEG_ERROR_OUTPUT + + return TRUE; +} + +static BOOL PLUGIN_CALL Plugin_finalize() { + delete ffmpegCore; + return TRUE; +} + +const pluginInfo_t pluginInfo = { + MAKE_VERSION(0, 0, 0), + "FFmpeg", + Plugin_initialize, + Plugin_finalize, + &audioDecoderInfo, + &audioConverterInfo, + &videoDecoderInfo +}; diff --git a/mediaplugin/src/plugins/media/ffmpeg/ffmpeg_plugin.h b/mediaplugin/src/plugins/media/ffmpeg/ffmpeg_plugin.h new file mode 100644 index 00000000..7263bada --- /dev/null +++ b/mediaplugin/src/plugins/media/ffmpeg/ffmpeg_plugin.h @@ -0,0 +1,30 @@ +/* UltraStar Deluxe - Karaoke Game + * + * UltraStar Deluxe is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + */ +#ifndef _FFMPEG_PLUGIN_H_ +#define _FFMPEG_PLUGIN_H_ + +extern const pluginInfo_t pluginInfo; + +#endif /* _FFMPEG_PLUGIN_H_ */ diff --git a/mediaplugin/src/plugins/media/ffmpeg/ffmpeg_video_decode.cpp b/mediaplugin/src/plugins/media/ffmpeg/ffmpeg_video_decode.cpp new file mode 100644 index 00000000..c582c771 --- /dev/null +++ b/mediaplugin/src/plugins/media/ffmpeg/ffmpeg_video_decode.cpp @@ -0,0 +1,661 @@ +/* UltraStar Deluxe - Karaoke Game + * + * UltraStar Deluxe is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + */ + +/* + * based on 'An ffmpeg and SDL Tutorial' (http://www.dranger.com/ffmpeg/) + */ + +#include "ffmpeg_video_decode.h" +#include <sstream> + +// These are called whenever we allocate a frame buffer. +// We use this to store the global_pts in a frame at the time it is allocated. +int CDECL ptsGetBuffer(AVCodecContext *codecCtx, AVFrame *frame) { + int result = avcodec_default_get_buffer(codecCtx, frame); + int64_t *videoPktPts = (int64_t*)codecCtx->opaque; + if (videoPktPts) { + // Note: we must copy the pts instead of passing a pointer, because the packet + // (and with it the pts) might change before a frame is returned by av_decode_video. + int64_t *pts = (int64_t*)av_malloc(sizeof(int64_t)); + *pts = *videoPktPts; + frame->opaque = pts; + } + return result; +} + +void CDECL ptsReleaseBuffer(AVCodecContext *codecCtx, AVFrame *frame) { + if (frame) + av_freep(&frame->opaque); + avcodec_default_release_buffer(codecCtx, frame); +} + +/* + * TVideoDecoder_FFmpeg + */ + +FFmpegVideoDecodeStream::FFmpegVideoDecodeStream() : + _opened(false), + _eof(false), + _loop(false), + _stream(NULL), + _streamIndex(-1), + _formatContext(NULL), + _codecContext(NULL), + _codec(NULL), + _avFrame(NULL), + _avFrameRGB(NULL), + _frameBuffer(NULL), + _frameTexValid(false), +#ifdef USE_SWSCALE + _swScaleContext(NULL), +#endif + _aspect(0), + _frameDuration(0), + _frameTime(0), + _loopTime(0) {} + +FFmpegVideoDecodeStream* FFmpegVideoDecodeStream::open(const IPath &filename) { + FFmpegVideoDecodeStream *stream = new FFmpegVideoDecodeStream(); + if (!stream->_open(filename)) { + delete stream; + return 0; + } + return stream; +} + +bool FFmpegVideoDecodeStream::_open(const IPath &filename) { + std::stringstream ss; + + // use custom 'ufile' protocol for UTF-8 support + int errnum = av_open_input_file(&_formatContext, + ("ufile:" + filename.toUTF8()).c_str(), NULL, 0, NULL); + if (errnum != 0) { + logger.error("Failed to open file '" + filename.toNative() + "' (" + + ffmpegCore->getErrorString(errnum) + ")", + "VideoDecodeStream_FFmpeg::Open"); + return false; + } + + // update video info + if (av_find_stream_info(_formatContext) < 0) { + logger.error("No stream info found", "VideoPlayback_ffmpeg.Open"); + close(); + return false; + } + + ss.str(""); + ss << "VideoStreamIndex: " << _streamIndex; + logger.info(ss.str(), "VideoPlayback_ffmpeg.Open"); + + // find video stream + int audioStreamIndex; + ffmpegCore->findStreamIDs(_formatContext, &_streamIndex, &audioStreamIndex); + if (_streamIndex < 0) { + logger.error("No video stream found", "VideoPlayback_ffmpeg.Open"); + close(); + return false; + } + + _stream = _formatContext->streams[_streamIndex]; + _codecContext = _stream->codec; + + _codec = avcodec_find_decoder(_codecContext->codec_id); + if (!_codec) { + logger.error("No matching codec found", "VideoPlayback_ffmpeg.Open"); + close(); + return false; + } + + // set debug options + _codecContext->debug_mv = 0; + _codecContext->debug = 0; + + // detect bug-workarounds automatically + _codecContext->workaround_bugs = FF_BUG_AUTODETECT; + // error resilience strategy (careful/compliant/agressive/very_aggressive) + //fCodecContext->error_resilience = FF_ER_CAREFUL; //FF_ER_COMPLIANT; + // allow non spec compliant speedup tricks. + //fCodecContext->flags2 = fCodecContext->flags2 | CODEC_FLAG2_FAST; + + // Note: avcodec_open() and avcodec_close() are not thread-safe and will + // fail if called concurrently by different threads. + { + MediaCore_FFmpeg::AVCodecLock codecLock; + errnum = avcodec_open(_codecContext, _codec); + } + if (errnum < 0) { + logger.error("No matching codec found", "VideoPlayback_ffmpeg.Open"); + close(); + return false; + } + + // register custom callbacks for pts-determination + _codecContext->get_buffer = ptsGetBuffer; + _codecContext->release_buffer = ptsReleaseBuffer; + +#ifdef DEBUG_DISPLAY + ss.str(""); + ss << "Found a matching Codec: " << _codecContext->codec->name << std::endl + << std::endl + << " Width = " << _codecContext->width + << ", Height=" << _codecContext->height << std::endl + << " Aspect : " << _codecContext->sample_aspect_ratio.num << "/" + << _codecContext->sample_aspect_ratio.den << std::endl + << " Framerate : " << _codecContext->time_base.num << "/" + << _codecContext->time_base.den; + logger.status(ss.str(), ""); +#endif + + // allocate space for decoded frame and rgb frame + _avFrame = avcodec_alloc_frame(); + _avFrameRGB = avcodec_alloc_frame(); + _frameBuffer = (uint8_t*) av_malloc(avpicture_get_size(PIXEL_FMT_FFMPEG, + _codecContext->width, _codecContext->height)); + + if (!_avFrame || !_avFrameRGB || !_frameBuffer) { + logger.error("Failed to allocate buffers", "VideoPlayback_ffmpeg.Open"); + close(); + return false; + } + + // TODO: pad data for OpenGL to GL_UNPACK_ALIGNMENT + // (otherwise video will be distorted if width/height is not a multiple of the alignment) + errnum = avpicture_fill((AVPicture*)_avFrameRGB, _frameBuffer, + PIXEL_FMT_FFMPEG, _codecContext->width, _codecContext->height); + if (errnum < 0) { + logger.error("avpicture_fill failed: " + ffmpegCore->getErrorString(errnum), + "VideoPlayback_ffmpeg.Open"); + close(); + return false; + } + + // calculate some information for video display + _aspect = av_q2d(_codecContext->sample_aspect_ratio); + if (_aspect == 0) { + _aspect = (double)_codecContext->width / _codecContext->height; + } else { + _aspect *= (double)_codecContext->width / _codecContext->height; + } + + _frameDuration = 1.0 / av_q2d(_stream->r_frame_rate); + + // hack to get reasonable framerate (for divx and others) + if (_frameDuration < 0.02) { // 0.02 <-> 50 fps + _frameDuration = av_q2d(_stream->r_frame_rate); + while (_frameDuration > 50.0) + _frameDuration /= 10.0; + _frameDuration = 1.0 / _frameDuration; + } + + ss.str(""); + ss << "Framerate: " << (int)(1.0 / _frameDuration) << "fps"; + logger.info(ss.str(), "VideoPlayback_ffmpeg.Open"); + +#ifdef USE_SWSCALE + // if available get a SWScale-context -> faster than the deprecated img_convert(). + // SWScale has accelerated support for PIX_FMT_RGB32/PIX_FMT_BGR24/PIX_FMT_BGR565/PIX_FMT_BGR555. + // Note: PIX_FMT_RGB32 is a BGR- and not an RGB-format (maybe a bug)!!! + // The BGR565-formats (GL_UNSIGNED_SHORT_5_6_5) is way too slow because of its + // bad OpenGL support. The BGR formats have MMX(2) implementations but no speed-up + // could be observed in comparison to the RGB versions. + _swScaleContext = sws_getCachedContext(NULL, + _codecContext->width, _codecContext->height, _codecContext->pix_fmt, + _codecContext->width, _codecContext->height, PIXEL_FMT_FFMPEG, + SWS_FAST_BILINEAR, + NULL, NULL, NULL); + if (!_swScaleContext) { + logger.error("Failed to get swscale context", "VideoPlayback_ffmpeg.Open"); + close(); + return false; + } +#endif + + _opened = true; + return true; +} + +void FFmpegVideoDecodeStream::close() { + if (_frameBuffer) + av_free(_frameBuffer); + if (_avFrameRGB) + av_free(_avFrameRGB); + if (_avFrame) + av_free(_avFrame); + + _avFrame = NULL; + _avFrameRGB = NULL; + _frameBuffer = NULL; + + if (_codecContext) { + // avcodec_close() is not thread-safe + MediaCore_FFmpeg::AVCodecLock codecLock; + avcodec_close(_codecContext); + } + + if (_formatContext) + av_close_input_file(_formatContext); + + _codecContext = NULL; + _formatContext = NULL; + + _opened = false; +} + +void FFmpegVideoDecodeStream::synchronizeTime(AVFrame *frame, double &pts) { + if (pts != 0) { + // if we have pts, set video clock to it + _frameTime = pts; + } else { + // if we aren't given a pts, set it to the clock + pts = _frameTime; + } + // update the video clock + double frameDelay = av_q2d(_codecContext->time_base); + // if we are repeating a frame, adjust clock accordingly + frameDelay = frameDelay + frame->repeat_pict * (frameDelay * 0.5); + _frameTime = _frameTime + frameDelay; +} + +/** + * Decode a new frame from the video stream. + * The decoded frame is stored in fAVFrame. fFrameTime is updated to the new frame's + * time. + * @param pts will be updated to the presentation time of the decoded frame. + * returns true if a frame could be decoded. False if an error or EOF occured. + */ +bool FFmpegVideoDecodeStream::decodeFrame() { + int64_t videoPktPts; + ByteIOContext *pbIOCtx; + int errnum; + AVPacket packet; + double pts; + + if (_eof) + return false; + + // read packets until we have a finished frame (or there are no more packets) + int frameFinished = 0; + while (frameFinished == 0) { + errnum = av_read_frame(_formatContext, &packet); + if (errnum < 0) { + // failed to read a frame, check reason + +#if LIBAVFORMAT_VERSION_MAJOR >= 52 + pbIOCtx = _formatContext->pb; +#else + pbIOCtx = &_formatContext->pb; +#endif + + // check for end-of-file (EOF is not an error) + if (url_feof(pbIOCtx) != 0) { + _eof = true; + return false; + } + + // check for errors + if (url_ferror(pbIOCtx) != 0) { + logger.error("Video decoding file error", "TVideoPlayback_FFmpeg.DecodeFrame"); + return false; + } + + // url_feof() does not detect an EOF for some mov-files (e.g. deluxe.mov) + // so we have to do it this way. + if ((_formatContext->file_size != 0) && + (pbIOCtx->pos >= _formatContext->file_size)) + { + _eof = true; + return false; + } + + // error occured, log and exit + logger.error("Video decoding error", "TVideoPlayback_FFmpeg.DecodeFrame"); + return false; + } + + // if we got a packet from the video stream, then decode it + if (packet.stream_index == _streamIndex) { + // save pts to be stored in pFrame in first call of PtsGetBuffer() + videoPktPts = packet.pts; + // FIXME: is the pointer valid when it is used? + _codecContext->opaque = &videoPktPts; + + // decode packet + avcodec_decode_video2(_codecContext, _avFrame, &frameFinished, &packet); + + // reset opaque data + _codecContext->opaque = NULL; + + // update pts + if (packet.dts != (int64_t)AV_NOPTS_VALUE) { + pts = packet.dts; + } else if (_avFrame->opaque && + (*((int64_t*)_avFrame->opaque) != (int64_t)AV_NOPTS_VALUE)) + { + pts = *((int64_t*)_avFrame->opaque); + } else { + pts = 0; + } + + if (_stream->start_time != (int64_t)AV_NOPTS_VALUE) + pts -= _stream->start_time; + + pts *= av_q2d(_stream->time_base); + + // synchronize time on each complete frame + if (frameFinished != 0) + synchronizeTime(_avFrame, pts); + } + + // free the packet from av_read_frame + av_free_packet(&packet); + } + + return true; +} + +#ifdef DEBUG_FRAMES +void spawnGoldenRec(double x, double y, int screen, uint8_t live, int startFrame, + int recArrayIndex, unsigned player) +{ + //GoldenRec.Spawn(x, y, screen, live, startFrame, recArrayIndex, ColoredStar, player) +} +#endif + +uint8_t* FFmpegVideoDecodeStream::getFrame(long double time) { + const long double SKIP_FRAME_DIFF = 0.010; // start skipping if we are >= 10ms too late + std::stringstream ss; + + if (!_opened) + return NULL; + + /* + * Synchronization - begin + */ + + // requested stream position (relative to the last loop's start) + long double currentTime; + if (_loop) + currentTime = time - _loopTime; + else + currentTime = time; + + // check if current texture still contains the active frame + if (_frameTexValid) { + // time since the last frame was returned + long double timeDiff = currentTime - _frameTime; + +#ifdef DEBUG_DISPLAY + ss.str(""); + ss << "time: " << floor(time*1000) << std::endl + << "VideoTime: " << floor(_frameTime*1000) << std::endl + << "TimeBase: " << floor(_frameDuration*1000) << std::endl + << "timeDiff: " << floor(timeDiff*1000); + logger.status(ss.str(), ""); +#endif + + // check if time has reached the next frame + if (timeDiff < _frameDuration) { +#ifdef DEBUG_FRAMES + // frame delay debug display + spawnGoldenRec(200, 15, 1, 16, 0, -1, 0x00ff00); +#endif + +#ifdef DEBUG_DISPLAY + ss.str(""); + ss << "not getting new frame" << std::endl + << "time: " << floor(time*1000) << std::endl + << "VideoTime: " << floor(_frameTime*1000) << std::endl + << "TimeBase: " << floor(_frameDuration*1000) << std::endl + << "timeDiff: " << floor(timeDiff*1000); + logger.status(ss.str(), ""); +#endif + + // we do not need a new frame now + return NULL; + } + } + + // fetch new frame (updates fFrameTime) + bool success = decodeFrame(); + long double timeDiff = currentTime - _frameTime; + + // check if we have to skip frames + // Either if we are one frame behind or if the skip threshold has been reached. + // Do not skip if the difference is less than fFrameDuration as there is no next frame. + // Note: We assume that fFrameDuration is the length of one frame. + if (timeDiff >= std::max(_frameDuration, SKIP_FRAME_DIFF)) { +#ifdef DEBUG_FRAMES + //frame drop debug display + spawnGoldenRec(200, 55, 1, 16, 0, -1, 0xff0000); +#endif +#ifdef DEBUG_DISPLAY + ss.str(""); + ss << "skipping frames" << std::endl + << "TimeBase: " << floor(_frameDuration*1000) << std::endl + << "timeDiff: " << floor(timeDiff*1000); + logger.status(ss.str(), ""); +#endif + + // update video-time + int dropFrameCount = (int)(timeDiff / _frameDuration); + _frameTime = _frameTime + dropFrameCount * _frameDuration; + + // skip frames + for (int i = 1; i <= dropFrameCount; ++i) + success = decodeFrame(); + } + + // check if we got an EOF or error + if (!success) { + if (_loop) { + // we have to loop, so rewind + setPosition(0); + // record the start-time of the current loop, so we can + // determine the position in the stream (fFrameTime-fLoopTime) later. + _loopTime = time; + } + return NULL; + } + + /* + * Synchronization - end + */ + + // TODO: support for pan&scan + //if (_avFrame->pan_scan) { + // printf("PanScan: %d/%d", _avFrame->pan_scan->width, _avFrame->pan_scan->height); + //} + + // otherwise we convert the pixeldata from YUV to RGB + int errnum; +#ifdef USE_SWSCALE + errnum = sws_scale(_swScaleContext, + (uint8_t**)_avFrame->data, _avFrame->linesize, + 0, _codecContext->height, + (uint8_t**)_avFrameRGB->data, _avFrameRGB->linesize); +#else + // img_convert from lib/ffmpeg/avcodec.pas is actually deprecated. + // If ./configure does not find SWScale then this gives the error + // that the identifier img_convert is not known or similar. + // I think this should be removed, but am not sure whether there should + // be some other replacement or a warning, Therefore, I leave it for now. + // April 2009, mischi + errnum = img_convert((AVPicture*)_avFrameRGB, PIXEL_FMT_FFMPEG, + (AVPicture*)_avFrame, _codecContext->pix_fmt, + _codecContext->width, _codecContext->height); +#endif + + if (errnum < 0) { + logger.error("Image conversion failed", "TVideoPlayback_ffmpeg.GetFrame"); + return NULL; + } + + if (!_frameTexValid) + _frameTexValid = true; + + return _avFrameRGB->data[0]; +} + +void FFmpegVideoDecodeStream::setLoop(bool enable) { + _loop = enable; + _loopTime = 0; +} + +bool FFmpegVideoDecodeStream::getLoop() { + return _loop; +} + +/** + * Sets the stream's position. + * The stream is set to the first keyframe with timestamp <= Time. + * Note that fFrameTime is set to Time no matter if the actual position seeked to is + * at Time or the time of a preceding keyframe. fFrameTime will be updated to the + * actual frame time when GetFrame() is called the next time. + * @param Time new position in seconds + */ +void FFmpegVideoDecodeStream::setPosition(double time) { + int seekFlags; + + if (!_opened) + return; + + if (time < 0) + time = 0; + + // TODO: handle fLoop-times + //time %= videoDuration; + + // Do not use the AVSEEK_FLAG_ANY here. It will seek to any frame, even + // non keyframes (P-/B-frames). It will produce corrupted video frames as + // FFmpeg does not use the information of the preceding I-frame. + // The picture might be gray or green until the next keyframe occurs. + // Instead seek the first keyframe smaller than the requested time + // (AVSEEK_FLAG_BACKWARD). As this can be some seconds earlier than the + // requested time, let the sync in GetFrame() do its job. + seekFlags = AVSEEK_FLAG_BACKWARD; + + _frameTime = time; + _eof = false; + _frameTexValid = false; + + if (av_seek_frame(_formatContext, _streamIndex, + llround(time / av_q2d(_stream->time_base)), seekFlags) < 0) + { + logger.error("av_seek_frame() failed", "TVideoPlayback_ffmpeg.SetPosition"); + return; + } + + avcodec_flush_buffers(_codecContext); +} + +double FFmpegVideoDecodeStream::getPosition() { + return _frameTime; +} + +int FFmpegVideoDecodeStream::getFrameWidth() { + return _codecContext->width; +} + +int FFmpegVideoDecodeStream::getFrameHeight() { + return _codecContext->height; +} + +double FFmpegVideoDecodeStream::getFrameAspect() { + return _aspect; +} + +/************************************ + * C Interface + ************************************/ + +#define VideoDecodeStreamObj(ptr) reinterpret_cast<FFmpegVideoDecodeStream*>(ptr) + +static BOOL PLUGIN_CALL ffmpegVideoDecoder_init() { + return TRUE; +} + +static BOOL PLUGIN_CALL ffmpegVideoDecoder_finalize() { + return TRUE; +} + +static videoDecodeStream_t* PLUGIN_CALL ffmpegVideoDecoder_open(const char *filename) { + return (videoDecodeStream_t*)FFmpegVideoDecodeStream::open(filename); +} + +static void PLUGIN_CALL ffmpegVideoDecoder_close(videoDecodeStream_t *stream) { + delete VideoDecodeStreamObj(stream); +} + +static void PLUGIN_CALL ffmpegVideoDecoder_setLoop(videoDecodeStream_t *stream, BOOL enable) { + VideoDecodeStreamObj(stream)->setLoop(enable); +} + +static BOOL PLUGIN_CALL ffmpegVideoDecoder_getLoop(videoDecodeStream_t *stream) { + return (BOOL)VideoDecodeStreamObj(stream)->getLoop(); +} + +static void PLUGIN_CALL ffmpegVideoDecoder_setPosition(videoDecodeStream_t *stream, double time) { + VideoDecodeStreamObj(stream)->setPosition(time); +} + +static double PLUGIN_CALL ffmpegVideoDecoder_getPosition(videoDecodeStream_t *stream) { + return VideoDecodeStreamObj(stream)->getPosition(); +} + +static int PLUGIN_CALL ffmpegVideoDecoder_getFrameWidth(videoDecodeStream_t *stream) { + return VideoDecodeStreamObj(stream)->getFrameWidth(); +} + +static int PLUGIN_CALL ffmpegVideoDecoder_getFrameHeight(videoDecodeStream_t *stream) { + return VideoDecodeStreamObj(stream)->getFrameHeight(); +} + +static double PLUGIN_CALL ffmpegVideoDecoder_getFrameAspect(videoDecodeStream_t *stream) { + return VideoDecodeStreamObj(stream)->getFrameAspect(); +} + +static uint8_t* PLUGIN_CALL ffmpegVideoDecoder_getFrame(videoDecodeStream_t *stream, long double time) { + return VideoDecodeStreamObj(stream)->getFrame(time); +} + +/************************************ + * Module information + ************************************/ + +const videoDecoderInfo_t videoDecoderInfo = { + 80, + ffmpegVideoDecoder_init, + ffmpegVideoDecoder_finalize, + ffmpegVideoDecoder_open, + ffmpegVideoDecoder_close, + ffmpegVideoDecoder_setLoop, + ffmpegVideoDecoder_getLoop, + ffmpegVideoDecoder_setPosition, + ffmpegVideoDecoder_getPosition, + ffmpegVideoDecoder_getFrameWidth, + ffmpegVideoDecoder_getFrameHeight, + ffmpegVideoDecoder_getFrameAspect, + ffmpegVideoDecoder_getFrame +}; diff --git a/mediaplugin/src/plugins/media/ffmpeg/ffmpeg_video_decode.h b/mediaplugin/src/plugins/media/ffmpeg/ffmpeg_video_decode.h new file mode 100644 index 00000000..7abe1257 --- /dev/null +++ b/mediaplugin/src/plugins/media/ffmpeg/ffmpeg_video_decode.h @@ -0,0 +1,115 @@ +/* UltraStar Deluxe - Karaoke Game + * + * UltraStar Deluxe is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + */ +#ifndef _FFMPEG_VIDEO_DECODE_H_ +#define _FFMPEG_VIDEO_DECODE_H_ + +#include "ffmpeg_core.h" +#include "core/plugin_video_decode.h" + +#define USE_SWSCALE + +// uncomment if you want to see the debug stuff +//#define DEBUG_DISPLAY +//#define DEBUG_FRAMES + +// use BGR-format for accelerated colorspace conversion with swscale +#ifdef USE_SWSCALE +# define PIXEL_FMT_BGR +#endif + +#define PIXEL_FMT_BGR + +#ifdef PIXEL_FMT_BGR +# define PIXEL_FMT_FFMPEG PIX_FMT_BGR24 +# define PIXEL_FMT_SIZE 3 +// looks strange on linux +//# define PIXEL_FMT_FFMPEG PIX_FMT_BGR32; +//# define PIXEL_FMT_SIZE 4; +#else +// looks strange on linux: +# define PIXEL_FMT_FFMPEG PIX_FMT_RGB24 +# define PIXEL_FMT_SIZE 3 +#endif + +extern const videoDecoderInfo_t videoDecoderInfo; + +class FFmpegVideoDecodeStream : public VideoDecodeStream { +private: + bool _opened; //**< stream successfully opened + bool _eof; //**< end-of-file state + + bool _loop; //**< looping enabled + + AVStream *_stream; + int _streamIndex; + AVFormatContext *_formatContext; + AVCodecContext *_codecContext; + AVCodec *_codec; + + AVFrame *_avFrame; + AVFrame *_avFrameRGB; + + uint8_t *_frameBuffer; //**< stores a FFmpeg video frame + bool _frameTexValid; //**< if true, fFrameTex contains the current frame + +#ifdef USE_SWSCALE + SwsContext *_swScaleContext; +#endif + + double _aspect; //**< width/height ratio + + long double _frameDuration; //**< duration of a video frame in seconds (= 1/fps) + long double _frameTime; //**< video time position (absolute) + long double _loopTime; //**< start time of the current loop + + FFmpegVideoDecodeStream(); + + bool decodeFrame(); + void synchronizeTime(AVFrame *frame, double &pts); + + bool _open(const IPath &filename); + void close(); + +public: + virtual ~FFmpegVideoDecodeStream() { + close(); + } + + static FFmpegVideoDecodeStream* open(const IPath &filename); + + virtual void setLoop(bool enable); + virtual bool getLoop(); + + virtual void setPosition(double time); + virtual double getPosition(); + + virtual int getFrameWidth(); + virtual int getFrameHeight(); + + virtual double getFrameAspect(); + virtual uint8_t* getFrame(long double time); +}; + +#endif /* _FFMPEG_VIDEO_DECODE_H_ */ diff --git a/mediaplugin/src/plugins/media/include/core/begin_pack.h b/mediaplugin/src/plugins/media/include/core/begin_pack.h new file mode 100644 index 00000000..504f2f75 --- /dev/null +++ b/mediaplugin/src/plugins/media/include/core/begin_pack.h @@ -0,0 +1,36 @@ +/* UltraStar Deluxe - Karaoke Game + * + * UltraStar Deluxe is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + */ +#ifndef _BEGIN_PACK_H_ +#define _BEGIN_PACK_H_ + +/* + * begin structure packing with 4 byte alignment. + */ +#ifdef _MSC_VER +#pragma warning(disable: 4103) \ +#pragma pack(push,4) +#endif + +#endif /* _BEGIN_PACK_H_ */ diff --git a/mediaplugin/src/plugins/media/include/core/end_pack.h b/mediaplugin/src/plugins/media/include/core/end_pack.h new file mode 100644 index 00000000..f6ee748b --- /dev/null +++ b/mediaplugin/src/plugins/media/include/core/end_pack.h @@ -0,0 +1,35 @@ +/* UltraStar Deluxe - Karaoke Game + * + * UltraStar Deluxe is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + */ +#ifndef _END_PACK_H_ +#define _END_PACK_H_ + +/* + * end structure packing at previous byte alignment + */ +#if defined(_MSC_VER) +#pragma pack(pop) +#endif + +#endif /* _END_PACK_H_ */ diff --git a/mediaplugin/src/plugins/media/include/core/logger.h b/mediaplugin/src/plugins/media/include/core/logger.h new file mode 100644 index 00000000..c9924b83 --- /dev/null +++ b/mediaplugin/src/plugins/media/include/core/logger.h @@ -0,0 +1,73 @@ +/* UltraStar Deluxe - Karaoke Game + * + * UltraStar Deluxe is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + */ +#ifndef _LOGGER_H_ +#define _LOGGER_H_ + +#include "plugin_core.h" +#include <string> + +#ifdef __cplusplus + +#define logger (Logger::getInstance()) +class Logger { +private: + static Logger _instance; + + Logger() {} + ~Logger() {} + +public: + static const Logger &getInstance() { + return _instance; + } + + void log(log_level level, const std::string &msg, const std::string &context) const { + pluginCore->log(level, msg.c_str(), context.c_str()); + } + + void info(const std::string &msg, const std::string &context) const { + log(INFO, msg, context); + } + + void status(const std::string &msg, const std::string &context) const { + log(STATUS, msg, context); + } + + void warn(const std::string &msg, const std::string &context) const { + log(WARN, msg, context); + } + + void error(const std::string &msg, const std::string &context) const { + log(ERROR, msg, context); + } + + void critical(const std::string &msg, const std::string &context) const { + log(CRITICAL, msg, context); + } +}; + +#endif /* __cplusplus */ + +#endif /* _LOGGER_H_ */ diff --git a/mediaplugin/src/plugins/media/include/core/plugin_audio_convert.h b/mediaplugin/src/plugins/media/include/core/plugin_audio_convert.h new file mode 100644 index 00000000..e3a31b26 --- /dev/null +++ b/mediaplugin/src/plugins/media/include/core/plugin_audio_convert.h @@ -0,0 +1,69 @@ +/* UltraStar Deluxe - Karaoke Game + * + * UltraStar Deluxe is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + */ +#ifndef _PLUGIN_AUDIO_CONVERT_H_ +#define _PLUGIN_AUDIO_CONVERT_H_ + +#include "util.h" +#include "plugin_core.h" +#include "logger.h" + +#ifdef __cplusplus + +class AudioConvertStream { +protected: + AudioFormatInfo _srcFormatInfo; + AudioFormatInfo _dstFormatInfo; + + AudioConvertStream(const AudioFormatInfo &srcFormatInfo, const AudioFormatInfo &dstFormatInfo) { + _srcFormatInfo = srcFormatInfo; + _dstFormatInfo = dstFormatInfo; + } + +public: + virtual ~AudioConvertStream() {}; + + /** + * Converts the InputBuffer and stores the result in OutputBuffer. + * If the result is not -1, inputSize will be set to the actual number of + * input-buffer bytes used. + * Returns the number of bytes written to the output-buffer or -1 if an error occured. + */ + virtual int convert(uint8_t *inputBuffer, uint8_t *outputBuffer, int &inputSize) = 0; + + /** + * Destination/Source size ratio + */ + virtual double getRatio() = 0; + + /** + * Size of an output buffer needed to store the result of a converted buffer with + * an input size of inputSize bytes. + */ + virtual int getOutputBufferSize(int inputSize) = 0; +}; + +#endif /* __cplusplus */ + +#endif /* _PLUGIN_AUDIO_CONVERT_H_ */ diff --git a/mediaplugin/src/plugins/media/include/core/plugin_audio_decode.h b/mediaplugin/src/plugins/media/include/core/plugin_audio_decode.h new file mode 100644 index 00000000..2385f77c --- /dev/null +++ b/mediaplugin/src/plugins/media/include/core/plugin_audio_decode.h @@ -0,0 +1,51 @@ +/* UltraStar Deluxe - Karaoke Game + * + * UltraStar Deluxe is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + */ +#ifndef _PLUGIN_AUDIO_DECODE_H_ +#define _PLUGIN_AUDIO_DECODE_H_ + +#include "util.h" +#include "plugin_core.h" +#include "logger.h" + +#ifdef __cplusplus + +class PluginDecodeStream { +public: + virtual ~PluginDecodeStream() {}; + + virtual double getLength() = 0; + virtual const AudioFormatInfo &getAudioFormatInfo() = 0; + virtual double getPosition() = 0; + virtual void setPosition(double time) = 0; + virtual bool getLoop() = 0; + virtual void setLoop(bool Enabled) = 0; + virtual bool isEOF() = 0; + virtual bool isError() = 0; + virtual int readData(uint8_t *buffer, int bufferSize) = 0; +}; + +#endif /* __cplusplus */ + +#endif /* _PLUGIN_AUDIO_DECODE_H_ */ diff --git a/mediaplugin/src/plugins/media/include/core/plugin_core.h b/mediaplugin/src/plugins/media/include/core/plugin_core.h new file mode 100644 index 00000000..f0cb19da --- /dev/null +++ b/mediaplugin/src/plugins/media/include/core/plugin_core.h @@ -0,0 +1,222 @@ +/* UltraStar Deluxe - Karaoke Game + * + * UltraStar Deluxe is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + */ +#ifndef _PLUGIN_CORE_H_ +#define _PLUGIN_CORE_H_ + +#include "inttypes.h" + +/* + * C Interface + */ + +#ifdef __cplusplus +extern "C" { +#endif + +/* declaration for export */ +#ifndef DLL_EXPORT +# if defined(__WIN32__) +# define DLL_EXPORT __declspec(dllexport) +# else +# if defined(__GNUC__) && __GNUC__ >= 4 +# define DLL_EXPORT __attribute__ ((visibility("default"))) +# else +# define DLL_EXPORT +# endif +# endif +#endif /* DLL_EXPORT */ + +/* use C calling convention */ +#ifndef CDECL +#if defined(__WIN32__) && !defined(__GNUC__) +#define CDECL __cdecl +#else +#define CDECL +#endif +#endif /* CDECL */ + +#define PLUGIN_CALL CDECL + +// VERSION: AAABBBCCC (A: Major, B: Minor, C: Revision) +#define MAKE_VERSION(a,b,c) ((((a) * 1000 + (b)) * 1000) + (c)) + +typedef enum { FALSE , TRUE } BOOL; + +typedef enum log_level { + DEBUG, + INFO, + STATUS, + WARN, + ERROR, + CRITICAL +} log_level; + +typedef struct{} fileStream_t; +typedef struct{} cond_t; +typedef struct{} mutex_t; +typedef struct{} thread_t; + +#define FILE_OPEN_MODE_READ 0x01 +#define FILE_OPEN_MODE_WRITE 0x02 +#define FILE_OPEN_MODE_READ_WRITE (FILE_OPEN_MODE_READ | FILE_OPEN_MODE_WRITE) + +/* returned by condWaitTimeout() if a timeout occurs. */ +#define MUTEX_TIMEDOUT 1 + +typedef struct pluginCore_t { + int version; + + void PLUGIN_CALL (*log)(int level, const char *msg, const char *context); + uint32_t PLUGIN_CALL (*ticksMillis); + + fileStream_t* PLUGIN_CALL (*fileOpen)(const char *utf8Filename, int mode); + void PLUGIN_CALL (*fileClose)(fileStream_t *stream); + int64_t PLUGIN_CALL (*fileRead)(fileStream_t *stream, uint8_t *buf, int size); + int64_t PLUGIN_CALL (*fileWrite)(fileStream_t *stream, const uint8_t *buf, int size); + int64_t PLUGIN_CALL (*fileSeek)(fileStream_t *stream, int64_t pos, int whence); + int64_t PLUGIN_CALL (*fileSize)(fileStream_t *stream); + + thread_t* PLUGIN_CALL (*threadCreate)(int (PLUGIN_CALL *fn)(void *), void *data); + uint32_t PLUGIN_CALL (*threadCurrentID)(); + uint32_t PLUGIN_CALL (*threadGetID)(thread_t *thread); + void PLUGIN_CALL (*threadWait)(thread_t *thread, int *status); + void PLUGIN_CALL (*threadSleep)(uint32_t millisecs); + + mutex_t* PLUGIN_CALL (*mutexCreate)(); + void PLUGIN_CALL (*mutexDestroy)(mutex_t *mutex); + int PLUGIN_CALL (*mutexLock)(mutex_t *mutex); + int PLUGIN_CALL (*mutexUnlock)(mutex_t *mutex); + + cond_t* PLUGIN_CALL (*condCreate)(); + void PLUGIN_CALL (*condDestroy)(cond_t *cond); + int PLUGIN_CALL (*condSignal)(cond_t *cond); + int PLUGIN_CALL (*condBroadcast)(cond_t *cond); + int PLUGIN_CALL (*condWait)(cond_t *cond, mutex_t *mutex); + int PLUGIN_CALL (*condWaitTimeout)(cond_t *cond, mutex_t *mutex, uint32_t ms); +} pluginCore_t; + +typedef enum audioSampleFormat_t { + asfUnknown, // unknown format + asfU8, asfS8, // unsigned/signed 8 bits + asfU16LSB, asfS16LSB, // unsigned/signed 16 bits (endianness: LSB) + asfU16MSB, asfS16MSB, // unsigned/signed 16 bits (endianness: MSB) + asfU16, asfS16, // unsigned/signed 16 bits (endianness: System) + asfS32, // signed 32 bits (endianness: System) + asfFloat, // float + asfDouble // double +} audioSampleFormat_t; + +// Size of one sample (one channel only) in bytes +static const int g_audioSampleSize[] = { + 0, // asfUnknown + 1, 1, // asfU8, asfS8 + 2, 2, // asfU16LSB, asfS16LSB + 2, 2, // asfU16MSB, asfS16MSB + 2, 2, // asfU16, asfS16 + 3, // asfS24 + 4, // asfS32 + 4, // asfFloat +}; + +struct audioFormatInfo_t { + double sampleRate; + uint8_t channels; + audioSampleFormat_t format; +}; + +typedef struct{} audioDecodeStream_t; +typedef struct{} audioConvertStream_t; +typedef struct{} videoDecodeStream_t; + +typedef struct audioDecoderInfo_t { + int priority; + BOOL PLUGIN_CALL (*init)(); + BOOL PLUGIN_CALL (*finalize)(); + audioDecodeStream_t* PLUGIN_CALL (*open)(const char *filename); + void PLUGIN_CALL (*close)(audioDecodeStream_t *stream); + double PLUGIN_CALL (*getLength)(audioDecodeStream_t *stream); + void PLUGIN_CALL (*getAudioFormatInfo)(audioDecodeStream_t *stream, audioFormatInfo_t *info); + double PLUGIN_CALL (*getPosition)(audioDecodeStream_t *stream); + void PLUGIN_CALL (*setPosition)(audioDecodeStream_t *stream, double time); + BOOL PLUGIN_CALL (*getLoop)(audioDecodeStream_t *stream); + void PLUGIN_CALL (*setLoop)(audioDecodeStream_t *stream, BOOL enabled); + BOOL PLUGIN_CALL (*isEOF)(audioDecodeStream_t *stream); + BOOL PLUGIN_CALL (*isError)(audioDecodeStream_t *stream); + int PLUGIN_CALL (*readData)(audioDecodeStream_t *stream, uint8_t *buffer, int bufferSize); +} audioDecoderInfo_t; + +typedef struct audioConverterInfo_t { + int priority; + BOOL PLUGIN_CALL (*init)(); + BOOL PLUGIN_CALL (*finalize)(); + audioConvertStream_t* PLUGIN_CALL (*open)(audioFormatInfo_t *inputFormat, + audioFormatInfo_t *outputFormat); + void PLUGIN_CALL (*close)(audioConvertStream_t *stream); + int PLUGIN_CALL (*convert)(audioConvertStream_t *stream, + uint8_t *input, uint8_t *output, int *numSamples); + int PLUGIN_CALL (*getOutputBufferSize)(audioConvertStream_t *stream, int inputSize); + double PLUGIN_CALL (*getRatio)(audioConvertStream_t *stream); +} audioConverterInfo_t; + +typedef struct videoDecoderInfo_t { + int priority; + BOOL PLUGIN_CALL (*init)(); + BOOL PLUGIN_CALL (*finalize)(); + videoDecodeStream_t* PLUGIN_CALL (*open)(const char *filename); + void PLUGIN_CALL (*close)(videoDecodeStream_t *stream); + void PLUGIN_CALL (*setLoop)(videoDecodeStream_t *stream, BOOL enable); + BOOL PLUGIN_CALL (*getLoop)(videoDecodeStream_t *stream); + void PLUGIN_CALL (*setPosition)(videoDecodeStream_t *stream, double time); + double PLUGIN_CALL (*getPosition)(videoDecodeStream_t *stream); + int PLUGIN_CALL (*getFrameWidth)(videoDecodeStream_t *stream); + int PLUGIN_CALL (*getFrameHeight)(videoDecodeStream_t *stream); + double PLUGIN_CALL (*getFrameAspect)(videoDecodeStream_t *stream); + uint8_t* PLUGIN_CALL (*getFrame)(videoDecodeStream_t *stream, long double time); +} videoDecoderInfo_t; + +typedef struct pluginInfo_t { + int version; + const char *name; + BOOL PLUGIN_CALL (*initialize)(); + BOOL PLUGIN_CALL (*finalize)(); + const audioDecoderInfo_t *audioDecoder; + const audioConverterInfo_t *audioConverter; + const videoDecoderInfo_t *videoDecoder; +} pluginInfo_t; + + +// plugin entry function (must be implemented by the plugin) +DLL_EXPORT const pluginInfo_t* PLUGIN_CALL Plugin_register(const pluginCore_t *core); + +// must be provided by the plugin and initialized on plugin initialization +extern const pluginCore_t *pluginCore; + +BOOL pluginInitCore(const pluginCore_t *core); + +#ifdef __cplusplus +} +#endif + +#endif /* _PLUGIN_CORE_H_ */ diff --git a/mediaplugin/src/plugins/media/include/core/plugin_video_decode.h b/mediaplugin/src/plugins/media/include/core/plugin_video_decode.h new file mode 100644 index 00000000..6403852f --- /dev/null +++ b/mediaplugin/src/plugins/media/include/core/plugin_video_decode.h @@ -0,0 +1,53 @@ +/* UltraStar Deluxe - Karaoke Game + * + * UltraStar Deluxe is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + */ +#ifndef _PLUGIN_VIDEO_DECODE_H_ +#define _PLUGIN_VIDEO_DECODE_H_ + +#include "util.h" +#include "plugin_core.h" +#include "logger.h" + +#ifdef __cplusplus + +class VideoDecodeStream { +public: + virtual ~VideoDecodeStream() {} + + virtual void setLoop(bool enable) = 0; + virtual bool getLoop() = 0; + + virtual void setPosition(double time) = 0; + virtual double getPosition() = 0; + + virtual int getFrameWidth() = 0; + virtual int getFrameHeight() = 0; + + virtual double getFrameAspect() = 0; + virtual uint8_t* getFrame(long double time) = 0; +}; + +#endif /* __cplusplus */ + +#endif /* _PLUGIN_VIDEO_DECODE_H_ */ diff --git a/mediaplugin/src/plugins/media/include/core/util.h b/mediaplugin/src/plugins/media/include/core/util.h new file mode 100644 index 00000000..55c5e93f --- /dev/null +++ b/mediaplugin/src/plugins/media/include/core/util.h @@ -0,0 +1,292 @@ +/* UltraStar Deluxe - Karaoke Game + * + * UltraStar Deluxe is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + * + * $URL$ + * $Id$ + */ +#ifndef _UTIL_H_ +#define _UTIL_H_ + +#include <string> +#include "plugin_core.h" + +class AudioFormatInfo { +private: + double _sampleRate; + uint8_t _channels; + audioSampleFormat_t _format; + int _frameSize; + + void updateFrameSize() { + _frameSize = g_audioSampleSize[_format] * _channels; + } + +public: + double getSampleRate() const { return _sampleRate; } + void setSampleRate(double sampleRate) { _sampleRate = sampleRate; } + + uint8_t getChannels() const { return _channels; } + void setChannels(uint8_t channels) { + _channels = channels; + updateFrameSize(); + } + + audioSampleFormat_t getFormat() const { return _format; } + void setFormat(audioSampleFormat_t sampleFormat) { + _format = sampleFormat; + updateFrameSize(); + } + + long getFrameSize() const { return _frameSize; } + double getBytesPerSec() const { return _frameSize * _sampleRate; } + +public: + AudioFormatInfo() : + _sampleRate(0), + _channels(0), + _format(asfUnknown), + _frameSize(0) + {} + + AudioFormatInfo(int channels, int sampleRate, audioSampleFormat_t sampleFormat) : + _sampleRate(sampleRate), _channels(channels), _format(sampleFormat) + { + updateFrameSize(); + } + + AudioFormatInfo(audioFormatInfo_t *info) : + _sampleRate(info->sampleRate), + _channels(info->channels), + _format(info->format) + { + updateFrameSize(); + } + + /** + * Returns the inverse ratio of the size of data in this format to its + * size in a given target format. + * Example: SrcSize*SrcInfo.GetRatio(TgtInfo) = TgtSize + */ + double getRatio(const AudioFormatInfo &targetInfo) const { + return (targetInfo.getFrameSize() / this->_frameSize) * + (targetInfo.getSampleRate() / this->_sampleRate); + } + + void toCStruct(audioFormatInfo_t *info) const { + info->channels = _channels; + info->format = _format; + info->sampleRate = _sampleRate; + } + + //AudioFormatInfo copy(); +}; + +class IPath { +private: + std::string _filename; +public: + IPath(const char *filename) : + _filename(filename) + { + // TODO + } + + IPath(std::string filename) : + _filename(filename) + { + // TODO + } + + std::string toNative() const { + // TODO + return _filename; + } + + std::string toUTF8() const { + // TODO + return _filename; + } + + bool isFile() const { + // TODO + return true; + } +}; + +extern "C" { +PLUGIN_CALL int threadMainRoutine(void *data); +} + +class Thread { +private: + thread_t *_thread; +public: + Thread() : _thread(0) {} + virtual ~Thread() {} + + virtual int run() = 0; + + void start() { + _thread = pluginCore->threadCreate(threadMainRoutine, this); + } + + /** + * Get the 32-bit thread identifier for the current thread. + */ + static uint32_t getCurrentThreadID() { + return pluginCore->threadCurrentID(); + } + + /** + * Get the 32-bit thread identifier for the specified thread, + * equivalent to SDL_ThreadID() if the specified thread is NULL. + */ + uint32_t getThreadID() { + return pluginCore->threadGetID(_thread); + } + + /** + * Wait a specified number of milliseconds before returning. + */ + static void sleep(uint32_t ms) { + pluginCore->threadSleep(ms); + } + + /** + * Wait for a thread to finish. + * The return code for the thread function is placed in the area + * pointed to by 'status', if 'status' is not NULL. + */ + void wait(int *status) { + if (_thread) { + pluginCore->threadWait(_thread, status); + } + } + + void wait() { + int status; + if (_thread) { + pluginCore->threadWait(_thread, &status); + } + } +}; + +class Condition; + +class Mutex { +private: + friend class Condition; + mutex_t *_mutex; +public: + Mutex() { + _mutex = pluginCore->mutexCreate(); + } + + ~Mutex() { + pluginCore->mutexDestroy(_mutex); + } + + /** + * Lock the mutex + * Returns 0, or -1 on error + */ + int lock() { + return pluginCore->mutexLock(_mutex); + } + + /** + * Unlock the mutex + * It is an error to unlock a mutex that has not been locked by + * the current thread, and doing so results in undefined behavior. + * + * Returns 0, or -1 on error + */ + int unlock() { + return pluginCore->mutexUnlock(_mutex); + } + + class RegionLock { + private: + Mutex *_mutex; + public: + RegionLock(Mutex &mutex) : + _mutex(&mutex) + { + _mutex->lock(); + } + + ~RegionLock() { + _mutex->unlock(); + } + }; +}; + +class Condition { +private: + cond_t *_cond; +public: + Condition() { + _cond = pluginCore->condCreate(); + } + + ~Condition() { + pluginCore->condDestroy(_cond); + } + + /** + * Wait on the condition variable, unlocking the provided mutex. + * The mutex must be locked before entering this function! + * The mutex is re-locked once the condition variable is signaled. + * Returns 0 when it is signaled, or -1 on error. + */ + int wait(const Mutex &mutex) { + return pluginCore->condWait(_cond, mutex._mutex); + } + + /* + * Waits for at most 'ms' milliseconds, and returns 0 if the condition + * variable is signaled, SDL_MUTEX_TIMEDOUT if the condition is not + * signaled in the allotted time, and -1 on error. + * On some platforms this function is implemented by looping with a delay + * of 1 ms, and so should be avoided if possible. + */ + int waitTimeout(const Mutex &mutex, uint32_t ms) { + return pluginCore->condWaitTimeout(_cond, mutex._mutex, ms); + } + + /** + * Restart one of the threads that are waiting on the condition variable. + * Returns 0 or -1 on error. + */ + int signal() { + return pluginCore->condSignal(_cond); + } + + /** + * Restart all threads that are waiting on the condition variable. + * Returns 0 or -1 on error. + */ + int broadcast() { + return pluginCore->condBroadcast(_cond); + } +}; + +#endif /* _UTIL_H_ */ |