graphics/video/video_player.h

   1 /* ScummVM - Graphic Adventure Engine
   2  *
   3  * ScummVM is the legal property of its developers, whose names
   4  * are too numerous to list here. Please refer to the COPYRIGHT
   5  * file distributed with this source distribution.
   6  *
   7  * This program is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License
   9  * as published by the Free Software Foundation; either version 2
  10  * of the License, or (at your option) any later version.
  11
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  20  *
  21  * $URL$
  22  * $Id$
  23  *
  24  */
  25
  26 #ifndef GRAPHICS_VIDEO_PLAYER_H
  27 #define GRAPHICS_VIDEO_PLAYER_H
  28
  29 #include "common/events.h"
  30 #include "common/list.h"
  31 #include "common/stream.h"
  32
  33 namespace Common {
  34         class SeekableReadStream;
  35 }
  36
  37 namespace Graphics {
  38
  39 /**
  40  * Implementation of a generic video decoder
  41  */
  42 class VideoDecoder {
  43 public:
  44         VideoDecoder();
  45         virtual ~VideoDecoder();
  46
  47         /**
  48          * Returns the width of the video
  49          * @return the width of the video
  50          */
  51         virtual int getWidth();
  52
  53         /**
  54          * Returns the height of the video
  55          * @return the height of the video
  56          */
  57         virtual int getHeight();
  58
  59         /**
  60          * Returns the current frame number of the video
  61          * @return the current frame number of the video
  62          */
  63         virtual int32 getCurFrame();
  64
  65         /**
  66          * Returns the amount of frames in the video
  67          * @return the amount of frames in the video
  68          */
  69         virtual int32 getFrameCount();
  70
  71         /**
  72          * Returns the frame rate of the video
  73          * @return the frame rate of the video
  74          */
  75         virtual int32 getFrameRate();
  76
  77         /**
  78          * Returns the time to wait for each frame in 1/100 ms (to avoid rounding errors)
  79          * @return the time to wait for each frame in 1/100 ms (to avoid rounding errors)
  80          */
  81         virtual int32 getFrameDelay();
  82
  83         /**
  84          * Returns the current A/V lag in 1/100 ms (to avoid rounding errors)
  85          * If > 0, audio lags behind
  86          * If < 0, video lags behind
  87          * @return the current A/V lag in 1/100 ms (to avoid rounding errors)
  88          */
  89         virtual int32 getAudioLag();
  90
  91         /**
  92          * Returns the time to wait until the next frame in ms, minding any lag
  93          * @return the time to wait until the next frame in ms
  94          */
  95         virtual uint32 getFrameWaitTime();
  96
  97         /**
  98          * Load a video file
  99          * @param filename      the filename to load
 100          */
 101         virtual bool loadFile(const char *filename) = 0;
 102
 103         /**
 104          * Close a video file
 105          */
 106         virtual void closeFile() = 0;
 107
 108         /**
 109          * Returns if a video file is loaded or not
 110          */
 111         bool isVideoLoaded() { return (_fileStream != NULL); }
 112
 113         /**
 114          * Set RGB palette, based on current frame
 115          * @param pal           the RGB palette data
 116          */
 117         virtual void setPalette(byte *pal);
 118
 119         /**
 120          * Gets the value of the pixel at the specified x and y coordinates
 121          * Note: This method assumes that the video's pitch equals its width, and that
 122          * the video has an 8bpp palette
 123          * @param x     the x coordinate of the pixel
 124          * @param y     the y coordinate of the pixel
 125          */
 126         byte getPixel(int x, int y) {
 127                 return *(_videoFrameBuffer + y * _videoInfo.width + x * 1);
 128         }
 129
 130         /**
 131          * Gets the value of the pixel at the specified offset
 132          * @param offset        the offset of the pixel in the video buffer
 133          */
 134         byte getPixel(int offset) { return getPixel(offset, 0); }
 135
 136         /**
 137          * Return the black palette color for the current frame
 138          */
 139         byte getBlack() { return _curFrameBlack; }
 140
 141         /**
 142          * Return the white palette color for the current frame
 143          */
 144         byte getWhite() { return _curFrameWhite; }
 145
 146         /**
 147          * Copy current frame into the specified position of the destination
 148          * buffer.
 149          * @param dst           the buffer
 150          * @param x             the x position of the buffer
 151          * @param y             the y position of the buffer
 152          * @param pitch         the pitch of buffer
 153          */
 154         void copyFrameToBuffer(byte *dst, uint x, uint y, uint pitch);
 155
 156         /**
 157          * Decode the next frame to _videoFrameBuffer
 158          */
 159         virtual bool decodeNextFrame() = 0;
 160
 161 protected:
 162         struct {
 163                 uint32 width;
 164                 uint32 height;
 165                 uint32 frameCount;
 166                 int32 frameRate;
 167                 int32 frameDelay;               // 1/100 ms (to avoid rounding errors)
 168                 uint32 firstframeOffset;
 169                 uint32 currentFrame;
 170                 uint32 startTime;
 171         } _videoInfo;
 172
 173         byte _curFrameBlack, _curFrameWhite;
 174
 175         Common::SeekableReadStream *_fileStream;
 176         byte *_videoFrameBuffer;
 177 };
 178
 179 class VideoPlayer {
 180 public:
 181         VideoPlayer(VideoDecoder* decoder) : _skipVideo(false), _decoder(decoder)
 182                 { }
 183         virtual ~VideoPlayer() { }
 184         /**
 185          * A default implementation of a video player
 186          * Plays a non-interactive full screen video till it's stopped by a
 187          * specific event
 188          * @param filename              the name of the file to play
 189          * @param stopEvents    a list of events that can stop the video
 190          *
 191          * Returns true if the video was played to the end, false if skipped
 192          */
 193         bool playVideo(Common::List<Common::Event> &stopEvents);
 194
 195 protected:
 196         /**
 197          * Perform postprocessing once the frame data is copied to the screen,
 198          * right before the frame is drawn. Called by playVideo()
 199          */
 200         virtual void performPostProcessing(byte *screen);
 201
 202         bool _skipVideo;
 203         VideoDecoder* _decoder;
 204
 205         void processVideoEvents(Common::List<Common::Event> &stopEvents);
 206 };
 207
 208 } // End of namespace Graphics
 209
 210 #endif