xmv.h

Go to the documentation of this file.

/* xoreos - A reimplementation of BioWare's Aurora engine
 *
 * xoreos is the legal property of its developers, whose names
 * can be found in the AUTHORS file distributed with this source
 * distribution.
 *
 * xoreos 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 3
 * of the License, or (at your option) any later version.
 *
 * xoreos 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 xoreos. If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef VIDEO_XMV_H
#define VIDEO_XMV_H

#include <vector>

#include "src/common/scopedptr.h"

#include "src/video/decoder.h"

namespace Common {
    class SeekableReadStream;
}

namespace Sound {
    class AudioStream;
    class PacketizedAudioStream;
}

namespace Video {

class Codec;

class XboxMediaVideo : public VideoDecoder {
public:
    XboxMediaVideo(Common::SeekableReadStream *xmv);
    ~XboxMediaVideo();

protected:
    void decodeNextTrackFrame(VideoTrack &track);

private:
    struct AudioInfo {
        uint16 compression;   
        uint16 channels;      
        uint32 rate;          
        uint16 bitsPerSample; 
        uint16 flags;         
    };

    class XMVVideoTrack : public VideoTrack {
    public:
        XMVVideoTrack(uint32 width, uint32 height, uint32 &timestamp);

        bool endOfTrack() const { return _finished; }

        uint32 getWidth() const { return _width; }
        uint32 getHeight() const { return _height; }
        int getCurFrame() const { return _curFrame; }
        Common::Timestamp getNextFrameStartTime() const;

        bool decodeFrame(Graphics::Surface &surface, Common::SeekableReadStream &frameData);
        void initCodec(Common::SeekableReadStream &extraData);
        void finish() { _finished = true; }

    private:
        uint32 _width;
        uint32 _height;
        uint32 &_timestamp;
        int _curFrame;
        bool _finished;

        Common::ScopedPtr<Codec> _videoCodec;
    };

    class XMVAudioTrack : public AudioTrack {
    public:
        XMVAudioTrack(const AudioInfo &info);

        void queueAudio(Common::SeekableReadStream *stream);

        void finish();

        // AudioTrack API
        bool canBufferData() const;
        Sound::AudioStream *getAudioStream() const;

    private:
        AudioInfo _info;
        Common::ScopedPtr<Sound::PacketizedAudioStream> _audioStream;
        Sound::PacketizedAudioStream *createStream() const;
    };

    class XMVAudioTrack51 : public AudioTrack {
    public:
        XMVAudioTrack51(XMVAudioTrack *info1, XMVAudioTrack *info2, XMVAudioTrack *info3);

        // AudioTrack API
        bool canBufferData() const;

    protected:
        // AudioTrack API
        Sound::AudioStream *getAudioStream() const;

    private:
        Common::ScopedPtr<XMVAudioTrack> _realTracks[3];
        Common::ScopedPtr<Sound::AudioStream> _interleaved;
    };

    struct PacketVideo {
        uint32 dataSize;   
        uint32 dataOffset; 

        uint32 frameCount; 

        uint32 currentFrameSize; 

        uint32 currentFrameTimestamp;

        uint32 lastFrameTime;
    };

    struct PacketAudio {
        uint32 dataSize;   
        uint32 dataOffset; 

        XMVAudioTrack *track; 
        AudioInfo *info; 

        bool newSlice; 
    };

    struct Packet {
        size_t thisPacketSize; 
        size_t nextPacketSize; 

        size_t thisPacketOffset; 
        size_t nextPacketOffset; 

        PacketVideo video;

        std::vector<PacketAudio> audio;
    };

    Common::ScopedPtr<Common::SeekableReadStream> _xmv;

    XMVVideoTrack *_videoTrack;

    uint32 _audioTrackCount;

    Packet _curPacket;


    void load();

    void fetchNextPacket(Packet &packet);

    void processPacketHeader(Packet &packet);

    void queueNewAudio(PacketAudio &audioPacket);
    void queueNewAudio(Packet &packet);

    void processNextFrame(PacketVideo &videoPacket);
};

} // End of namespace Video

#endif // VIDEO_XMV_H