video32.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 SCI_GRAPHICS_VIDEO32_H
#define SCI_GRAPHICS_VIDEO32_H

#include "common/config-manager.h" // for ConfMan
#include "common/path.h"          // for Path
#include "common/ptr.h"
#include "common/rect.h"          // for Rect
#include "common/scummsys.h"      // for int16, uint8, uint16, int32
#include "sci/engine/vm_types.h"  // for reg_t
#include "sci/video/robot_decoder.h" // for RobotDecoder
#include "sci/sound/audio32.h"    // for Audio32::kMaxVolume
#include "video/avi_decoder.h"    // for AVIDecoder::setVolume
#include "video/subtitles.h"      // for Video::Subtitles

namespace Video {
class AdvancedVMDDecoder;
}
namespace Sci {
class EventManager;
class Plane;
class ScreenItem;
class SegManager;
class SEQDecoder;
struct Palette;

class VideoPlayer {
public:
    enum EventFlags {
        kEventFlagNone         = 0,
        kEventFlagEnd          = 1,
        kEventFlagEscapeKey    = 2,
        kEventFlagMouseDown    = 4,
        kEventFlagHotRectangle = 8,
        kEventFlagToFrame      = 0x10,
        kEventFlagYieldToVM    = 0x20,
        kEventFlagReverse      = 0x80
    };

    friend EventFlags operator|(const EventFlags a, const EventFlags b) {
        return static_cast<EventFlags>((int)a | (int)b);
    }

    VideoPlayer(EventManager *eventMan, Video::VideoDecoder *decoder = nullptr) :
        _eventMan(eventMan),
        _decoder(decoder),
        _needsUpdate(false),
        _currentFrame(nullptr),
        _hqVideoMode(false)
        {}

    virtual ~VideoPlayer() {}

protected:
    EventManager *_eventMan;

    Common::ScopedPtr<Video::VideoDecoder> _decoder;

    bool open(const Common::Path &fileName);

    bool startHQVideo(const Graphics::PixelFormat &format);

    virtual bool shouldStartHQVideo() const {
        if (!ConfMan.getBool("enable_hq_video")) {
            return false;
        }

        if (_decoder->getWidth() == _drawRect.width() &&
            _decoder->getHeight() == _drawRect.height()) {
            return false;
        }

        return true;
    }

    bool endHQVideo();

    virtual EventFlags playUntilEvent(const EventFlags flags, const uint32 maxSleepMs = 0xFFFFFFFF);

    virtual EventFlags checkForEvent(const EventFlags flags);

    virtual void submitPalette(const uint8 palette[256 * 3]) const;

    virtual void renderFrame(const Graphics::Surface &nextFrame) const;

    void renderLQToSurface(Graphics::Surface &out, const Graphics::Surface &nextFrame, const bool doublePixels, const bool blackLines) const;

    template <typename PixelType>
    void renderLQToSurfaceDouble(Graphics::Surface &out, const Graphics::Surface &nextFrame, int lineCount) const;

    void setDrawRect(const int16 x, const int16 y, const int16 width, const int16 height);

    void setSubtitlePosition() const;

    void showUnsupportedFormatDialog();

    Common::Rect _drawRect;

    bool _needsUpdate;

    const Graphics::Surface* _currentFrame;

    mutable Video::Subtitles _subtitles;

    bool _hqVideoMode;
};

#pragma mark SEQPlayer

class SEQPlayer : public VideoPlayer {
public:
    SEQPlayer(EventManager *eventMan);

    void play(const Common::Path &fileName, const int16 numTicks, const int16 x, const int16 y);
};

#pragma mark -
#pragma mark AVIPlayer

class AVIPlayer : public VideoPlayer {
public:
    enum IOStatus {
        kIOSuccess      = 0,
        kIOFileNotFound = 2,
        kIOSeekFailed   = 12
    };

    enum AVIStatus {
        kAVINotOpen  = 0,
        kAVIOpen     = 1,
        kAVIPlaying  = 2,
        kAVIPaused   = 3
    };

    AVIPlayer(EventManager *eventMan);

    IOStatus open(const Common::Path &fileName);

    IOStatus init(const bool doublePixels);

    IOStatus play(const int16 from, const int16 to, const int16 showStyle, const bool cue);

    EventFlags playUntilEvent(const EventFlags flags, const uint32 maxSleepMs = 0xFFFFFFFF) override;

    IOStatus close();

    IOStatus cue(const uint16 frameNo);

    uint16 getDuration() const;

private:
    AVIStatus _status;
};

#pragma mark -
#pragma mark QuickTimePlayer

class QuickTimePlayer : public VideoPlayer {
public:
    QuickTimePlayer(EventManager *eventMan);

    void play(const Common::Path &fileName);
};

#pragma mark -
#pragma mark VMDPlayer

class VMDPlayer : public VideoPlayer {
public:
    enum OpenFlags {
        kOpenFlagNone = 0,
        kOpenFlagMute = 1
    };

    enum IOStatus {
        kIOSuccess = 0,
        kIOError   = 0xFFFF
    };

    enum PlayFlags {
        kPlayFlagNone             = 0,
        kPlayFlagDoublePixels     = 1,
        kPlayFlagBlackLines       = 4,
        kPlayFlagBoost            = 0x10,
        kPlayFlagLeaveScreenBlack = 0x20,
        kPlayFlagLeaveLastFrame   = 0x40,
        kPlayFlagBlackPalette     = 0x80,
        kPlayFlagStretchVertical  = 0x100
    };

    enum VMDStatus {
        kVMDNotOpen  = 0,
        kVMDOpen     = 1,
        kVMDPlaying  = 2,
        kVMDPaused   = 3,
        kVMDStopped  = 4,
        kVMDFinished = 5
    };

    VMDPlayer(EventManager *eventMan, SegManager *segMan);
    ~VMDPlayer() override;

private:
    SegManager *_segMan;

#pragma mark -
#pragma mark VMDPlayer - Playback
public:
    IOStatus open(const Common::Path &fileName, const OpenFlags flags);

    void init(int16 x, int16 y, const PlayFlags flags, const int16 boostPercent, const int16 boostStartColor, const int16 boostEndColor);

    IOStatus close();

    VMDStatus getStatus() const;

    // Was WaitForEvent in SSCI
    EventFlags kernelPlayUntilEvent(const EventFlags flags, const int16 lastFrameNo, const int16 yieldInterval);

private:
    bool _isOpen;

    bool _isInitialized;

    Resource *_bundledVmd;

    int32 _yieldFrame;

    int32 _yieldInterval;

    int _lastYieldedFrameNo;

    EventFlags playUntilEvent(const EventFlags flags, const uint32 = 0xFFFFFFFF) override;
    EventFlags checkForEvent(const EventFlags flags) override;

#pragma mark -
#pragma mark VMDPlayer - Rendering
public:
    void ignorePalettes() { _ignorePalettes = true; }

    void setPlane(const int16 priority, const reg_t planeId);

protected:
    void renderFrame(const Graphics::Surface &nextFrame) const override;

    void submitPalette(const uint8 palette[256 * 3]) const override;

private:
    Plane *_plane;

    ScreenItem *_screenItem;

    reg_t _bitmapId;

    bool _planeIsOwned;

    int _priority;

    bool _doublePixels;

    bool _stretchVertical;

    bool _blackLines;

    bool _leaveScreenBlack;

    bool _leaveLastFrame;

    bool _ignorePalettes;

    bool _isComposited;

    void fillPalette(const uint8 rawPalette[256 * 3], Palette &outPalette) const;

    void redrawGameScreen() const;

    bool shouldStartHQVideo() const override {
        if (!VideoPlayer::shouldStartHQVideo()) {
            return false;
        }

        if (_priority != 0 || _leaveLastFrame || _showCursor || _blackLines) {
            return false;
        }

        return true;
    }

    bool shouldUseCompositing() const {
        return isNormallyComposited() && !shouldStartHQVideo();
    }

    bool isNormallyComposited() const {
        return (getSciVersion() == SCI_VERSION_3) ||
                (g_sci->getPlatform() == Common::kPlatformMacintosh &&
                 getSciVersion() >= SCI_VERSION_2_1_LATE);
    }

    void initOverlay();
    void renderOverlay(const Graphics::Surface &nextFrame) const;
    void closeOverlay();

    void initComposited();
    void renderComposited() const;
    void closeComposited();

#pragma mark -
#pragma mark VMDPlayer - Blackout
public:
    void setBlackoutArea(const Common::Rect &rect) { _blackoutRect = rect; }

private:
    Common::Rect _blackoutRect;

    Plane *_blackoutPlane;

#pragma mark -
#pragma mark VMDPlayer - Palette
public:
    void restrictPalette(const uint8 startColor, const int16 endColor);

private:
    uint8 _startColor;

    uint8 _endColor;

#ifdef SCI_VMD_BLACK_PALETTE
    bool _blackPalette;
#endif

#pragma mark -
#pragma mark VMDPlayer - Brightness boost
private:
    int16 _boostPercent;

    uint8 _boostStartColor;

    uint8 _boostEndColor;

#pragma mark -
#pragma mark VMDPlayer - Mouse cursor
public:
    void setShowCursor(const bool shouldShow) { _showCursor = shouldShow; }

private:
    bool _showCursor;

#pragma mark -
#pragma mark VMDPlayer - Censorship blobs
public:
    int16 addBlob(int16 blockSize, int16 top, int16 left, int16 bottom, int16 right);
    void deleteBlobs();
    void deleteBlob(int16 blobNumber);

private:
    enum {
        kMaxBlobs = 10
    };

    struct Blob {
        int16 blobNumber;
        int16 blockSize;
        int16 top;
        int16 left;
        int16 bottom;
        int16 right;
    };

    Common::List<Blob> _blobs;

    void drawBlobs(Graphics::Surface& frame) const;
};

#pragma mark -
#pragma mark DuckPlayer

class DuckPlayer : public VideoPlayer {
public:
    enum DuckStatus {
        kDuckClosed  = 0,
        kDuckOpen    = 1,
        kDuckPlaying = 2,
        kDuckPaused  = 3
    };

    DuckPlayer(EventManager *eventMan, SegManager *segMan);

    void open(const GuiResourceId resourceId, const int displayMode, const int16 x, const int16 y);

    void close();

    void play(const int lastFrameNo);

    void setDoFrameOut(const bool value) { _doFrameOut = value; }

    void setVolume(const uint8 value) {
        _volume = value * Audio::Mixer::kMaxChannelVolume / Audio32::kMaxVolume;
        _decoder->setVolume(_volume);
    }

protected:
    bool shouldStartHQVideo() const override {
        if (!VideoPlayer::shouldStartHQVideo() || _blackLines) {
            return false;
        }

        return true;
    }

    void renderFrame(const Graphics::Surface &nextFrame) const override;

private:
    Plane *_plane;

    DuckStatus _status;

    uint8 _volume;

    bool _doFrameOut;

    bool _doublePixels;

    bool _blackLines;
};

#pragma mark -
#pragma mark Video32

class Video32 : public Common::Serializable {
public:
    Video32(SegManager *segMan, EventManager *eventMan) :
    _SEQPlayer(eventMan),
    _AVIPlayer(eventMan),
    _QuickTimePlayer(eventMan),
    _VMDPlayer(eventMan, segMan),
    _robotPlayer(segMan),
    _duckPlayer(eventMan, segMan) {}

    void beforeSaveLoadWithSerializer(Common::Serializer &ser);
    void saveLoadWithSerializer(Common::Serializer &ser) override;

    SEQPlayer &getSEQPlayer() { return _SEQPlayer; }
    AVIPlayer &getAVIPlayer() { return _AVIPlayer; }
    QuickTimePlayer &getQuickTimePlayer() { return _QuickTimePlayer; }
    VMDPlayer &getVMDPlayer() { return _VMDPlayer; }
    RobotDecoder &getRobotPlayer() { return _robotPlayer; }
    DuckPlayer &getDuckPlayer() { return _duckPlayer; }

private:
    SEQPlayer _SEQPlayer;
    AVIPlayer _AVIPlayer;
    QuickTimePlayer _QuickTimePlayer;
    VMDPlayer _VMDPlayer;
    RobotDecoder _robotPlayer;
    DuckPlayer _duckPlayer;
};

} // End of namespace Sci

#endif // SCI_GRAPHICS_VIDEO32_H