videoplayer.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/>.
 *
 *
 * This file is dual-licensed.
 * In addition to the GPLv3 license mentioned above, this code is also
 * licensed under LGPL 2.1. See LICENSES/COPYING.LGPL file for the
 * full text of the license.
 *
 */
 
#ifndef GOB_VIDEOPLAYER_H
#define GOB_VIDEOPLAYER_H
 
#include "common/array.h"
#include "common/list.h"
#include "common/rect.h"
#include "common/str.h"
 
#include "graphics/surface.h"
 
#include "gob/util.h"
#include "gob/draw.h"
 
namespace Video {
class CoktelDecoder;
}
 
namespace Gob {
 
class GobEngine;
class DataStream;
 
class VideoPlayer {
public:
    enum Flags {
        kFlagNone                               = 0x000000,
        kFlagUseBackSurfaceContentOrDoubleVideo = 0x000040, 
        // In later version of the engine, this 0x40 flag indicates instead that the video should be doubled.
        kFlagFrontSurface                       = 0x000080, 
        kFlagNoVideo                            = 0x000100, 
        kFlagOtherSurface                       = 0x000800, 
        kFlagScreenSurface                      = 0x400000  
    };
 
    enum Type {
        kVideoTypeTry    = -1, 
        kVideoTypeIMD    =  0,
        kVideoTypePreIMD =  1, 
        kVideoTypeVMD    =  2,
        kVideoTypeRMD    =  3  
    };
 
    struct Properties {
        Type type; 
 
        int sprite; 
 
        int32 x;      
        int32 y;      
        int32 width;  
        int32 height; 
 
        uint32 flags; 
 
        bool switchColorMode; 
 
        int32 startFrame; 
        int32 lastFrame;  
        int32 endFrame;   
 
        bool forceSeek; 
 
        int16 breakKey; 
 
        uint16 palCmd;      
        int16 palStart;    
        int16 palEnd;      
        int32 palFrame;    
 
        bool noBlock; 
 
        bool loop; 
        bool fade; 
 
        bool waitEndFrame; 
 
        bool hasSound; 
        bool canceled; 
 
        int slot; 
        bool reuseSlotWitSameFilename;
 
        bool noWaitSound;
 
        Properties();
    };
 
    VideoPlayer(GobEngine *vm);
    ~VideoPlayer();
 
    void evaluateFlags(Properties &properties);
 
    int  openVideo(bool primary, const Common::String &file, Properties &properties);
    bool closeVideo(int slot = 0);
 
    void closeLiveVideos();
    void closeAll();
 
    bool reopenVideo(int slot = 0);
    bool reopenAll();
 
    void pauseVideo(int slot, bool pause);
    void pauseAll(bool pause);
 
    void finishVideoSound(int slot);
    void waitSoundEnd(int slot);
 
    bool play(int slot, Properties &properties);
    void waitEndFrame(int slot, bool onlySound = false);
    int32 getExpectedFrameFromCurrentTime(int slot);
 
    bool isPlayingLive() const;
    bool isSoundPlaying() const;
 
    void updateVideos(bool force = false, int exceptSlot = -1);
    void liveVideosLoop();
 
    bool slotIsOpen(int slot = 0) const;
 
    Common::String getFileName(int slot = 0) const;
 
    uint32 getFrameCount     (int slot = 0) const;
    uint32 getCurrentFrame   (int slot = 0) const;
    uint16 getWidth          (int slot = 0) const;
    uint16 getHeight         (int slot = 0) const;
    uint16 getDefaultX       (int slot = 0) const;
    uint16 getDefaultY       (int slot = 0) const;
    uint32 getFlags          (int slot = 0) const;
    uint16 getSoundFlags     (int slot = 0) const;
    uint32 getVideoBufferSize(int slot = 0) const;
    bool   hasVideo          (int slot = 0) const;
 
 
    bool getFrameCoords(int slot, int16 frame, int16 &x, int16 &y, int16 &width, int16 &height) const;
 
    const Common::List<Common::Rect> *getDirtyRects(int slot = 0) const;
 
    bool                      hasEmbeddedFile(const Common::String &fileName, int slot = 0) const;
    Common::SeekableReadStream *getEmbeddedFile(const Common::String &fileName, int slot = 0);
 
    int32 getSubtitleIndex(int slot = 0) const;
 
    void writeVideoInfo(const Common::String &file, uint16 varX, uint16 varY,
                        uint16 varFrames, uint16 varWidth, uint16 varHeight);
 
    bool copyFrame(int slot, Surface &dest,
            uint16 left, uint16 top, uint16 width, uint16 height, uint16 x, uint16 y,
            int32 transp = -1, bool yAxisReflexion = false) const;
 
private:
    struct Video {
        ::Video::CoktelDecoder *decoder;
        Common::String fileName;
 
        SurfacePtr surface;
        SurfacePtr tmpSurfDouble; 
        int16 doubleVideoDestX;   
        int16 doubleVideoDestY;   
        Common::SharedPtr<Graphics::Surface> tmpSurfBppConversion;
        uint32 *highColorMap;
 
        Properties properties;
 
        bool doubleVideo; 
        bool live;
        bool autoUpdate; 
 
        Video();
 
        bool isEmpty() const;
        void close();
 
        void reopen();
    };
 
    static const int kVideoSlotCount = 32;
    static const int kPrimaryVideoSlot = 0;
    static const int kLiveVideoSlotCount = 6;
    static const int kVideoSlotWithCurFrameVarCount = 4;
 
    static const char *const _extensions[];
 
    GobEngine *_vm;
 
    // _videoSlots[0] is reserved for the "primary" video
    Video _videoSlots[kVideoSlotCount];
 
    bool _needBlit;
 
    bool _noCursorSwitch;
    bool _woodruffCohCottWorkaround;
    uint32 _lastLiveVideosLoopCall;
 
 
    const Video *getVideoBySlot(int slot) const;
    Video *getVideoBySlot(int slot);
 
    int getNextFreeSlot();
 
    Common::String findFile(const Common::String &file, Properties &properties);
 
    ::Video::CoktelDecoder *openVideo(const Common::String &file, Properties &properties);
 
    bool reopenVideo(Video &video);
 
    bool lastFrameReached(Video &video, Properties &properties);
    bool playFrame(int slot, Properties &properties);
 
    void checkAbort(Video &video, Properties &properties);
    void evalBgShading(Video &video);
 
    void copyPalette(const Video &video, int16 palStart, int16 palEnd);
 
    void updateVideo(int slot, bool force = false);
};
 
} // End of namespace Gob
 
#endif // GOB_VIDEOPLAYER_H