3D Audio GSoC:
[blender.git] / intern / audaspace / ffmpeg / AUD_FFMPEGReader.cpp
index 027ac015eb5ac50369c53eb069e2727e0698a9f9..b7690d55383bdaac82f9a07dcb9cbc80a3d1cca5 100644 (file)
@@ -1,78 +1,89 @@
 /*
  * $Id$
  *
- * ***** BEGIN LGPL LICENSE BLOCK *****
+ * ***** BEGIN GPL LICENSE BLOCK *****
  *
- * Copyright 2009 Jörg Hermann Müller
+ * Copyright 2009-2011 Jörg Hermann Müller
  *
  * This file is part of AudaSpace.
  *
- * AudaSpace is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
+ * Audaspace 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.
  *
  * AudaSpace 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 Lesser General Public License for more details.
+ * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with AudaSpace.  If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU General Public License
+ * along with Audaspace; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  *
- * ***** END LGPL LICENSE BLOCK *****
+ * ***** END GPL LICENSE BLOCK *****
  */
 
+/** \file audaspace/ffmpeg/AUD_FFMPEGReader.cpp
+ *  \ingroup audffmpeg
+ */
+
+
 // needed for INT64_C
+#ifndef __STDC_CONSTANT_MACROS
 #define __STDC_CONSTANT_MACROS
+#endif
 
 #include "AUD_FFMPEGReader.h"
-#include "AUD_Buffer.h"
 
 extern "C" {
 #include <libavcodec/avcodec.h>
 #include <libavformat/avformat.h>
+#include "ffmpeg_compat.h"
 }
 
-int AUD_FFMPEGReader::decode(AVPacket* packet, AUD_Buffer* buffer)
+int AUD_FFMPEGReader::decode(AVPacket* packet, AUD_Buffer& buffer)
 {
        // save packet parameters
        uint8_t *audio_pkg_data = packet->data;
        int audio_pkg_size = packet->size;
 
-       int buf_size = buffer->getSize();
+       int buf_size = buffer.getSize();
        int buf_pos = 0;
 
        int read_length, data_size;
 
+       AVPacket tmp_pkt;
+       
+       av_init_packet(&tmp_pkt);
+
        // as long as there is still data in the package
        while(audio_pkg_size > 0)
        {
                // resize buffer if needed
                if(buf_size - buf_pos < AVCODEC_MAX_AUDIO_FRAME_SIZE)
                {
-                       buffer->resize(buf_size + AVCODEC_MAX_AUDIO_FRAME_SIZE, true);
+                       buffer.resize(buf_size + AVCODEC_MAX_AUDIO_FRAME_SIZE, true);
                        buf_size += AVCODEC_MAX_AUDIO_FRAME_SIZE;
                }
 
                // read samples from the packet
                data_size = buf_size - buf_pos;
-               /*read_length = avcodec_decode_audio3(m_codecCtx,
-                       (int16_t*)(((data_t*)buffer->getBuffer())+buf_pos),
-                       &data_size,
-                       packet);*/
-               read_length = avcodec_decode_audio2(m_codecCtx,
-                       (int16_t*)(((data_t*)buffer->getBuffer())+buf_pos),
-                       &data_size,
-                       audio_pkg_data,
-                       audio_pkg_size);
 
-               buf_pos += data_size;
+               tmp_pkt.data = audio_pkg_data;
+               tmp_pkt.size = audio_pkg_size;
+
+               read_length = avcodec_decode_audio3(
+                       m_codecCtx,
+                       (int16_t*)(((data_t*)buffer.getBuffer()) + buf_pos),
+                       &data_size, &tmp_pkt);
 
                // read error, next packet!
                if(read_length < 0)
                        break;
 
+               buf_pos += data_size;
+
                // move packet parameters
                audio_pkg_data += read_length;
                audio_pkg_size -= read_length;
@@ -81,36 +92,50 @@ int AUD_FFMPEGReader::decode(AVPacket* packet, AUD_Buffer* buffer)
        return buf_pos;
 }
 
+static const char* streaminfo_error = "AUD_FFMPEGReader: Stream info couldn't "
+                                                                         "be found.";
+static const char* noaudio_error = "AUD_FFMPEGReader: File doesn't include an "
+                                                                  "audio stream.";
+static const char* nodecoder_error = "AUD_FFMPEGReader: No decoder found for "
+                                                                        "the audio stream.";
+static const char* codecopen_error = "AUD_FFMPEGReader: Codec couldn't be "
+                                                                        "opened.";
+static const char* format_error = "AUD_FFMPEGReader: Unsupported sample "
+                                                                 "format.";
+
 void AUD_FFMPEGReader::init()
 {
        m_position = 0;
        m_pkgbuf_left = 0;
 
        if(av_find_stream_info(m_formatCtx)<0)
-               AUD_THROW(AUD_ERROR_FFMPEG);
+               AUD_THROW(AUD_ERROR_FFMPEG, streaminfo_error);
 
        // find audio stream and codec
        m_stream = -1;
 
        for(unsigned int i = 0; i < m_formatCtx->nb_streams; i++)
-               if((m_formatCtx->streams[i]->codec->codec_type == CODEC_TYPE_AUDIO)
+       {
+               if((m_formatCtx->streams[i]->codec->codec_type == AVMEDIA_TYPE_AUDIO)
                        && (m_stream < 0))
                {
                        m_stream=i;
                        break;
                }
+       }
+
        if(m_stream == -1)
-               AUD_THROW(AUD_ERROR_FFMPEG);
+               AUD_THROW(AUD_ERROR_FFMPEG, noaudio_error);
 
        m_codecCtx = m_formatCtx->streams[m_stream]->codec;
 
        // get a decoder and open it
        AVCodec *aCodec = avcodec_find_decoder(m_codecCtx->codec_id);
        if(!aCodec)
-               AUD_THROW(AUD_ERROR_FFMPEG);
+               AUD_THROW(AUD_ERROR_FFMPEG, nodecoder_error);
 
        if(avcodec_open(m_codecCtx, aCodec)<0)
-               AUD_THROW(AUD_ERROR_FFMPEG);
+               AUD_THROW(AUD_ERROR_FFMPEG, codecopen_error);
 
        // XXX this prints file information to stdout:
        //dump_format(m_formatCtx, 0, NULL, 0);
@@ -140,64 +165,75 @@ void AUD_FFMPEGReader::init()
                m_specs.format = AUD_FORMAT_FLOAT64;
                break;
        default:
-               AUD_THROW(AUD_ERROR_FILE);
+               AUD_THROW(AUD_ERROR_FFMPEG, format_error);
        }
 
        m_specs.rate = (AUD_SampleRate) m_codecCtx->sample_rate;
-
-       // last but not least if there hasn't been any error, create the buffers
-       m_buffer = new AUD_Buffer(); AUD_NEW("buffer")
-       m_pkgbuf = new AUD_Buffer(AVCODEC_MAX_AUDIO_FRAME_SIZE<<1);
-       AUD_NEW("buffer")
 }
 
-AUD_FFMPEGReader::AUD_FFMPEGReader(const char* filename)
-{
-       m_byteiocontext = NULL;
+static const char* fileopen_error = "AUD_FFMPEGReader: File couldn't be "
+                                                                       "opened.";
 
+AUD_FFMPEGReader::AUD_FFMPEGReader(std::string filename) :
+       m_pkgbuf(AVCODEC_MAX_AUDIO_FRAME_SIZE<<1),
+       m_byteiocontext(NULL),
+       m_membuf(NULL)
+{
        // open file
-       if(av_open_input_file(&m_formatCtx, filename, NULL, 0, NULL)!=0)
-               AUD_THROW(AUD_ERROR_FILE);
+       if(av_open_input_file(&m_formatCtx, filename.c_str(), NULL, 0, NULL)!=0)
+               AUD_THROW(AUD_ERROR_FILE, fileopen_error);
 
        try
        {
                init();
        }
-       catch(AUD_Exception)
+       catch(AUD_Exception&)
        {
                av_close_input_file(m_formatCtx);
                throw;
        }
 }
 
-AUD_FFMPEGReader::AUD_FFMPEGReader(AUD_Reference<AUD_Buffer> buffer)
+static const char* streamopen_error = "AUD_FFMPEGReader: Stream couldn't be "
+                                                                         "opened.";
+
+AUD_FFMPEGReader::AUD_FFMPEGReader(AUD_Reference<AUD_Buffer> buffer) :
+               m_pkgbuf(AVCODEC_MAX_AUDIO_FRAME_SIZE<<1),
+               m_membuffer(buffer),
+               m_membufferpos(0)
 {
-       m_byteiocontext = (ByteIOContext*)av_mallocz(sizeof(ByteIOContext));
-       AUD_NEW("byteiocontext")
-       m_membuffer = buffer;
+       m_membuf = reinterpret_cast<data_t*>(av_malloc(FF_MIN_BUFFER_SIZE + FF_INPUT_BUFFER_PADDING_SIZE));
 
-       if(init_put_byte(m_byteiocontext, (data_t*)buffer.get()->getBuffer(),
-                                        buffer.get()->getSize(), 0, NULL, NULL, NULL, NULL) != 0)
-               AUD_THROW(AUD_ERROR_FILE);
+       m_byteiocontext = av_alloc_put_byte(m_membuf, FF_MIN_BUFFER_SIZE, 0, this,
+                                                                               read_packet, NULL, seek_packet);
+
+       if(!m_byteiocontext)
+       {
+               av_free(m_byteiocontext);
+               AUD_THROW(AUD_ERROR_FILE, fileopen_error);
+       }
 
        AVProbeData probe_data;
        probe_data.filename = "";
-       probe_data.buf = (data_t*)buffer.get()->getBuffer();
+       probe_data.buf = reinterpret_cast<data_t*>(buffer.get()->getBuffer());
        probe_data.buf_size = buffer.get()->getSize();
        AVInputFormat* fmt = av_probe_input_format(&probe_data, 1);
 
        // open stream
        if(av_open_input_stream(&m_formatCtx, m_byteiocontext, "", fmt, NULL)!=0)
-               AUD_THROW(AUD_ERROR_FILE);
+       {
+               av_free(m_byteiocontext);
+               AUD_THROW(AUD_ERROR_FILE, streamopen_error);
+       }
 
        try
        {
                init();
        }
-       catch(AUD_Exception)
+       catch(AUD_Exception&)
        {
                av_close_input_stream(m_formatCtx);
-               av_free(m_byteiocontext); AUD_DELETE("byteiocontext")
+               av_free(m_byteiocontext);
                throw;
        }
 }
@@ -209,16 +245,47 @@ AUD_FFMPEGReader::~AUD_FFMPEGReader()
        if(m_byteiocontext)
        {
                av_close_input_stream(m_formatCtx);
-               av_free(m_byteiocontext); AUD_DELETE("byteiocontext")
+               av_free(m_byteiocontext);
        }
        else
                av_close_input_file(m_formatCtx);
+}
+
+int AUD_FFMPEGReader::read_packet(void* opaque, uint8_t* buf, int buf_size)
+{
+       AUD_FFMPEGReader* reader = reinterpret_cast<AUD_FFMPEGReader*>(opaque);
+
+       int size = AUD_MIN(buf_size, reader->m_membuffer->getSize() - reader->m_membufferpos);
+
+       if(size < 0)
+               return -1;
 
-       delete m_buffer; AUD_DELETE("buffer")
-       delete m_pkgbuf; AUD_DELETE("buffer")
+       memcpy(buf, ((data_t*)reader->m_membuffer->getBuffer()) + reader->m_membufferpos, size);
+       reader->m_membufferpos += size;
+
+       return size;
 }
 
-bool AUD_FFMPEGReader::isSeekable()
+int64_t AUD_FFMPEGReader::seek_packet(void* opaque, int64_t offset, int whence)
+{
+       AUD_FFMPEGReader* reader = reinterpret_cast<AUD_FFMPEGReader*>(opaque);
+
+       switch(whence)
+       {
+       case SEEK_SET:
+               reader->m_membufferpos = 0;
+               break;
+       case SEEK_END:
+               reader->m_membufferpos = reader->m_membuffer->getSize();
+               break;
+       case AVSEEK_SIZE:
+               return reader->m_membuffer->getSize();
+       }
+
+       return (reader->m_membufferpos += offset);
+}
+
+bool AUD_FFMPEGReader::isSeekable() const
 {
        return true;
 }
@@ -227,13 +294,26 @@ void AUD_FFMPEGReader::seek(int position)
 {
        if(position >= 0)
        {
+               uint64_t st_time = m_formatCtx->start_time;
+               uint64_t seek_pos = ((uint64_t)position) * ((uint64_t)AV_TIME_BASE) / ((uint64_t)m_specs.rate);
+
+               if (seek_pos < 0) {
+                       seek_pos = 0;
+               }
+
+               if (st_time != AV_NOPTS_VALUE) {
+                       seek_pos += st_time;
+               }
+
+               double pts_time_base = 
+                       av_q2d(m_formatCtx->streams[m_stream]->time_base);
+               uint64_t pts_st_time =
+                       ((st_time != AV_NOPTS_VALUE) ? st_time : 0)
+                       / pts_time_base / (uint64_t) AV_TIME_BASE;
+
                // a value < 0 tells us that seeking failed
-               if(av_seek_frame(m_formatCtx,
-                                                -1,
-                                                (uint64_t)(((uint64_t)position *
-                                                                        (uint64_t)AV_TIME_BASE) /
-                                                                       (uint64_t)m_specs.rate),
-                                                AVSEEK_FLAG_BACKWARD | AVSEEK_FLAG_ANY) >= 0)
+               if(av_seek_frame(m_formatCtx, -1, seek_pos,
+                                AVSEEK_FLAG_BACKWARD | AVSEEK_FLAG_ANY) >= 0)
                {
                        avcodec_flush_buffers(m_codecCtx);
                        m_position = position;
@@ -254,15 +334,23 @@ void AUD_FFMPEGReader::seek(int position)
                                        if(packet.pts != AV_NOPTS_VALUE)
                                        {
                                                // calculate real position, and read to frame!
-                                               m_position = packet.pts *
-                                                       av_q2d(m_formatCtx->streams[m_stream]->time_base) *
-                                                       m_specs.rate;
+                                               m_position = (packet.pts - 
+                                                       pts_st_time) * pts_time_base * m_specs.rate;
 
                                                if(m_position < position)
                                                {
-                                                       sample_t* buf;
-                                                       int length = position - m_position;
-                                                       read(length, buf);
+                                                       // read until we're at the right position
+                                                       int length = AUD_DEFAULT_BUFFER_SIZE;
+                                                       AUD_Buffer buffer(length * AUD_SAMPLE_SIZE(m_specs));
+                                                       bool eos;
+                                                       for(int len = position - m_position;
+                                                               length == AUD_DEFAULT_BUFFER_SIZE;
+                                                               len -= AUD_DEFAULT_BUFFER_SIZE)
+                                                       {
+                                                               if(len < AUD_DEFAULT_BUFFER_SIZE)
+                                                                       length = len;
+                                                               read(length, eos, buffer.getBuffer());
+                                                       }
                                                }
                                        }
                                }
@@ -271,39 +359,30 @@ void AUD_FFMPEGReader::seek(int position)
                }
                else
                {
+                       fprintf(stderr, "seeking failed!\n");
                        // Seeking failed, do nothing.
                }
        }
 }
 
-int AUD_FFMPEGReader::getLength()
+int AUD_FFMPEGReader::getLength() const
 {
        // return approximated remaning size
        return (int)((m_formatCtx->duration * m_codecCtx->sample_rate)
                                 / AV_TIME_BASE)-m_position;
 }
 
-int AUD_FFMPEGReader::getPosition()
+int AUD_FFMPEGReader::getPosition() const
 {
        return m_position;
 }
 
-AUD_Specs AUD_FFMPEGReader::getSpecs()
+AUD_Specs AUD_FFMPEGReader::getSpecs() const
 {
        return m_specs.specs;
 }
 
-AUD_ReaderType AUD_FFMPEGReader::getType()
-{
-       return AUD_TYPE_STREAM;
-}
-
-bool AUD_FFMPEGReader::notify(AUD_Message &message)
-{
-       return false;
-}
-
-void AUD_FFMPEGReader::read(int & length, sample_t* & buffer)
+void AUD_FFMPEGReader::read(int& length, bool& eos, sample_t* buffer)
 {
        // read packages and decode them
        AVPacket packet;
@@ -312,11 +391,7 @@ void AUD_FFMPEGReader::read(int & length, sample_t* & buffer)
        int left = length;
        int sample_size = AUD_DEVICE_SAMPLE_SIZE(m_specs);
 
-       // resize output buffer if necessary
-       if(m_buffer->getSize() < length * AUD_SAMPLE_SIZE(m_specs))
-               m_buffer->resize(length * AUD_SAMPLE_SIZE(m_specs));
-
-       buffer = m_buffer->getBuffer();
+       sample_t* buf = buffer;
        pkgbuf_pos = m_pkgbuf_left;
        m_pkgbuf_left = 0;
 
@@ -324,9 +399,9 @@ void AUD_FFMPEGReader::read(int & length, sample_t* & buffer)
        if(pkgbuf_pos > 0)
        {
                data_size = AUD_MIN(pkgbuf_pos, left * sample_size);
-               m_convert((data_t*) buffer, (data_t*) m_pkgbuf->getBuffer(),
+               m_convert((data_t*) buf, (data_t*) m_pkgbuf.getBuffer(),
                                  data_size / AUD_FORMAT_SIZE(m_specs.format));
-               buffer += data_size / AUD_FORMAT_SIZE(m_specs.format);
+               buf += data_size / AUD_FORMAT_SIZE(m_specs.format);
                left -= data_size/sample_size;
        }
 
@@ -341,9 +416,9 @@ void AUD_FFMPEGReader::read(int & length, sample_t* & buffer)
 
                        // copy to output buffer
                        data_size = AUD_MIN(pkgbuf_pos, left * sample_size);
-                       m_convert((data_t*) buffer, (data_t*) m_pkgbuf->getBuffer(),
+                       m_convert((data_t*) buf, (data_t*) m_pkgbuf.getBuffer(),
                                          data_size / AUD_FORMAT_SIZE(m_specs.format));
-                       buffer += data_size / AUD_FORMAT_SIZE(m_specs.format);
+                       buf += data_size / AUD_FORMAT_SIZE(m_specs.format);
                        left -= data_size/sample_size;
                }
                av_free_packet(&packet);
@@ -352,14 +427,13 @@ void AUD_FFMPEGReader::read(int & length, sample_t* & buffer)
        if(pkgbuf_pos > data_size)
        {
                m_pkgbuf_left = pkgbuf_pos-data_size;
-               memmove(m_pkgbuf->getBuffer(),
-                               ((data_t*)m_pkgbuf->getBuffer())+data_size,
+               memmove(m_pkgbuf.getBuffer(),
+                               ((data_t*)m_pkgbuf.getBuffer())+data_size,
                                pkgbuf_pos-data_size);
        }
 
-       buffer = m_buffer->getBuffer();
-
-       if(left > 0)
+       if((eos = (left > 0)))
                length -= left;
+
        m_position += length;
 }