avi_decoder.h

/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM 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 3 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.  If not, see <http://www.gnu.org/licenses/>.
 *
 */
 
#ifndef VIDEO_AVI_DECODER_H
#define VIDEO_AVI_DECODER_H
 
#include "common/array.h"
#include "common/rational.h"
#include "common/rect.h"
#include "common/str.h"
#include "graphics/palette.h"
 
#include "video/video_decoder.h"
#include "audio/mixer.h"
 
namespace Audio {
class AudioStream;
class PacketizedAudioStream;
}
 
namespace Common {
class SeekableReadStream;
}
 
namespace Graphics {
struct PixelFormat;
}
 
namespace Image {
class Codec;
}
 
namespace Video {
 
class AVIDecoder : public VideoDecoder {
public:
    AVIDecoder();
    AVIDecoder(const Common::Rational &frameRateOverride);
    virtual ~AVIDecoder();
 
    bool loadStream(Common::SeekableReadStream *stream) override;
    void close() override;
    uint16 getWidth() const override { return _header.width; }
    uint16 getHeight() const override { return _header.height; }
 
    bool rewind() override;
    bool isRewindable() const override { return true; }
    bool isSeekable() const override;
 
    const Graphics::Surface *decodeNextFrame() override;
 
    const Graphics::Surface *decodeNextTransparency();
protected:
    // VideoDecoder API
    void readNextPacket() override;
    bool seekIntern(const Audio::Timestamp &time) override;
    bool supportsAudioTrackSwitching() const override { return true; }
    AudioTrack *getAudioTrack(int index) override;
 
    void addTrack(Track *track, bool isExternal = false);
 
    struct BitmapInfoHeader {
        uint32 size;
        uint32 width;
        uint32 height;
        uint16 planes;
        uint16 bitCount;
        uint32 compression;
        uint32 sizeImage;
        uint32 xPelsPerMeter;
        uint32 yPelsPerMeter;
        uint32 clrUsed;
        uint32 clrImportant;
    };
 
    struct WaveFormat {
        uint16 tag;
        uint16 channels;
        uint32 samplesPerSec;
        uint32 avgBytesPerSec;
        uint16 blockAlign;
    };
 
    struct PCMWaveFormat : public WaveFormat {
        uint16 size;
    };
 
    struct WaveFormatEX : public WaveFormat {
        uint16 bitsPerSample;
        uint16 size;
    };
 
    struct OldIndex {
        uint32 id;
        uint32 flags;
        uint32 offset;
        uint32 size;
    };
 
    // Index Flags
    enum IndexFlags {
        AVIIF_INDEX = 0x10
    };
 
    struct AVIHeader {
        uint32 size;
        uint32 microSecondsPerFrame;
        uint32 maxBytesPerSecond;
        uint32 padding;
        uint32 flags;
        uint32 totalFrames;
        uint32 initialFrames;
        uint32 streams;
        uint32 bufferSize;
        uint32 width;
        uint32 height;
    };
 
    // Flags from the AVIHeader
    enum AVIFlags {
        AVIF_HASINDEX = 0x00000010,
        AVIF_MUSTUSEINDEX = 0x00000020,
        AVIF_ISINTERLEAVED = 0x00000100,
        AVIF_TRUSTCKTYPE = 0x00000800,
        AVIF_WASCAPTUREFILE = 0x00010000,
        AVIF_WASCOPYRIGHTED = 0x00020000
    };
 
    struct AVIStreamHeader {
        uint32 size;
        uint32 streamType;
        uint32 streamHandler;
        uint32 flags;
        uint16 priority;
        uint16 language;
        uint32 initialFrames;
        uint32 scale;
        uint32 rate;
        uint32 start;
        uint32 length;
        uint32 bufferSize;
        uint32 quality;
        uint32 sampleSize;
        Common::Rect frame;
        Common::String name;
    };
 
    class AVIVideoTrack : public FixedRateVideoTrack {
    public:
        AVIVideoTrack(int frameCount, const AVIStreamHeader &streamHeader, const BitmapInfoHeader &bitmapInfoHeader, byte *initialPalette, Image::CodecAccuracy accuracy);
        ~AVIVideoTrack();
 
        void decodeFrame(Common::SeekableReadStream *stream);
        void forceTrackEnd();
 
        uint16 getWidth() const override { return _bmInfo.width; }
        uint16 getHeight() const override { return _bmInfo.height; }
        uint16 getBitCount() const { return _bmInfo.bitCount; }
        Graphics::PixelFormat getPixelFormat() const override;
        bool setOutputPixelFormat(const Graphics::PixelFormat &format) override;
        void setCodecAccuracy(Image::CodecAccuracy accuracy) override;
        int getCurFrame() const override { return _curFrame; }
        int getFrameCount() const override { return _frameCount; }
        Common::String &getName() { return _vidsHeader.name; }
        const Graphics::Surface *decodeNextFrame() override { return _lastFrame; }
 
        const byte *getPalette() const override;
        bool hasDirtyPalette() const override;
        void setCurFrame(int frame) { _curFrame = frame; }
        void loadPaletteFromChunk(Common::SeekableReadStream *chunk);
        void loadPaletteFromChunkRaw(Common::SeekableReadStream *chunk, int firstEntry, int numEntries);
        void useInitialPalette();
        bool canDither() const override;
        void setDither(const byte *palette) override;
        bool isValid() const { return _videoCodec != nullptr; }
 
        bool isTruemotion1() const;
        void forceDimensions(uint16 width, uint16 height);
 
        bool isRewindable() const override { return true; }
        bool rewind() override;
 
        bool setReverse(bool reverse) override;
 
        bool isReversed() const override { return _reversed; }
 
        bool endOfTrack() const override;
 
        Common::Rational getFrameRate() const override { return Common::Rational(_vidsHeader.rate, _vidsHeader.scale); }
 
        void setFrameRate(const Common::Rational &r) {
            _vidsHeader.rate = r.getNumerator();
            _vidsHeader.scale = r.getDenominator();
        }
    private:
        AVIStreamHeader _vidsHeader;
        BitmapInfoHeader _bmInfo;
        Graphics::Palette _palette;
        byte *_initialPalette;
        mutable bool _dirtyPalette;
        int _frameCount, _curFrame;
        bool _reversed;
 
        Image::Codec *_videoCodec;
        const Graphics::Surface *_lastFrame;
        Image::CodecAccuracy _accuracy;
 
        Image::Codec *createCodec();
    };
 
    class AVIAudioTrack : public AudioTrack {
    public:
        AVIAudioTrack(const AVIStreamHeader &streamHeader, const PCMWaveFormat &waveFormat, Audio::Mixer::SoundType soundType);
        ~AVIAudioTrack();
 
        virtual void createAudioStream();
        virtual void queueSound(Common::SeekableReadStream *stream);
        void skipAudio(const Audio::Timestamp &time, const Audio::Timestamp &frameTime);
        virtual void resetStream();
        uint32 getCurChunk() const { return _curChunk; }
        Common::String &getName() { return _audsHeader.name; }
        void setCurChunk(uint32 chunk) { _curChunk = chunk; }
        bool needsAudioOnlyBuffering();
        void setAllPacketsQueued() { _allPacketsQueued = true; }
        bool endOfTrack() const override;
 
        bool isRewindable() const override { return true; }
        bool rewind() override;
 
    protected:
        Audio::AudioStream *getAudioStream() const override { return _audioStream; }
 
        AVIStreamHeader _audsHeader;
        PCMWaveFormat _wvInfo;
        Audio::AudioStream *_audioStream;
        Audio::PacketizedAudioStream *_packetStream;
        uint32 _curChunk;
        bool _bufferedAudioOnly;
        bool _allPacketsQueued;
    };
 
    struct TrackStatus {
        TrackStatus();
 
        Track *track;
        uint32 index;
        uint32 chunkSearchOffset;
    };
 
    class IndexEntries : public Common::Array<OldIndex> {
    public:
        OldIndex *find(uint index, uint frameNumber);
    };
 
    AVIHeader _header;
 
    void readOldIndex(uint32 size);
    IndexEntries _indexEntries;
 
    Common::SeekableReadStream *_fileStream;
    bool _decodedHeader;
    bool _foundMovieList;
    uint32 _movieListStart, _movieListEnd;
 
    Common::Rational _frameRateOverride;
 
    int _videoTrackCounter, _audioTrackCounter;
    Track *_lastAddedTrack;
 
    void initCommon();
 
    bool parseNextChunk();
    void skipChunk(uint32 size);
    void handleList(uint32 listSize);
    bool handleStreamHeader(uint32 size);
    void readStreamName(uint32 size);
    void readPalette8(uint32 size);
    uint16 getStreamType(uint32 tag) const { return tag & 0xFFFF; }
    static byte getStreamIndex(uint32 tag);
    void checkTruemotion1();
    uint getVideoTrackOffset(uint trackIndex, uint frameNumber = 0);
 
    void handleNextPacket(TrackStatus& status);
    bool shouldQueueAudio(TrackStatus& status);
    void seekTransparencyFrame(int frame);
 
    Common::Array<TrackStatus> _videoTracks, _audioTracks;
    TrackStatus _transparencyTrack;
 
public:
    virtual AVIAudioTrack *createAudioTrack(AVIStreamHeader sHeader, PCMWaveFormat wvInfo);
 
    bool seekToFrame(uint frame) override;
};
 
} // End of namespace Video
 
#endif