blob: 62aa4961483b30a7126092fc803a74abc09c6147 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
|
/* 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 2
* 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, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
* $URL$
* $Id$
*
*/
#ifndef GRAPHICS_VIDEO_PLAYER_H
#define GRAPHICS_VIDEO_PLAYER_H
#include "common/events.h"
#include "common/list.h"
#include "common/rational.h"
#include "common/stream.h"
#include "graphics/surface.h"
#include "graphics/pixelformat.h"
namespace Common {
class SeekableReadStream;
}
namespace Graphics {
/**
* Implementation of a generic video decoder
*/
class VideoDecoder {
public:
VideoDecoder();
virtual ~VideoDecoder() {}
/**
* Returns the width of the video
* @return the width of the video
*/
virtual uint16 getWidth() const = 0;
/**
* Returns the height of the video
* @return the height of the video
*/
virtual uint16 getHeight() const = 0;
/**
* Returns the current frame number of the video
* @return the last frame decoded by the video
*/
virtual int32 getCurFrame() const { return _curFrame; }
/**
* Returns the amount of frames in the video
* @return the amount of frames in the video
*/
virtual uint32 getFrameCount() const = 0;
/**
* Returns the time (in ms) that the video has been running
*/
virtual uint32 getElapsedTime() const;
/**
* Returns whether a frame should be decoded or not
* @return whether a frame should be decoded or not
*/
virtual bool needsUpdate() const;
/**
* Load a video file
* @param filename the filename to load
*/
virtual bool loadFile(const Common::String &filename);
/**
* Load a video file
* @param stream the stream to load
*/
virtual bool load(Common::SeekableReadStream &stream) = 0;
/**
* Close a video file
*/
virtual void close() = 0;
/**
* Returns if a video file is loaded or not
*/
virtual bool isVideoLoaded() const = 0;
/**
* Decode the next frame and return the frame's surface
* @note the return surface should *not* be freed
* @note this may return 0, in which case the last frame should be kept on screen
*/
virtual Surface *decodeNextFrame() = 0;
/**
* Get the pixel format of the video
*/
virtual PixelFormat getPixelFormat() const = 0;
/**
* Get the palette for the video in RGB format (if 8bpp or less)
*/
virtual byte *getPalette() { return 0; }
/**
* Returns if the palette is dirty or not
*/
virtual bool hasDirtyPalette() const { return false; }
/**
* Add the time the video has been paused to maintain sync
*/
virtual void addPauseTime(uint32 ms) { _startTime += ms; }
/**
* Returns if the video is finished or not
*/
virtual bool endOfVideo() const;
/**
* Set the current palette to the system palette
*/
void setSystemPalette();
/**
* Return the time until the next frame (in ms)
*/
virtual uint32 getTimeToNextFrame() const = 0;
protected:
/**
* Resets _curFrame and _startTime. Should be called from every close() function.
*/
void reset();
int32 _curFrame;
uint32 _startTime;
};
/**
* A VideoDecoder wrapper that implements getTimeToNextFrame() based on getFrameRate().
*/
class FixedRateVideoDecoder : public VideoDecoder {
public:
FixedRateVideoDecoder() {}
virtual ~FixedRateVideoDecoder() {}
uint32 getTimeToNextFrame() const;
protected:
/**
* Return the frame rate in frames per second
* This returns a Rational because videos can have rates that are not integers and
* there are some videos with frame rates < 1.
*/
virtual Common::Rational getFrameRate() const = 0;
private:
uint32 getFrameBeginTime(uint32 frame) const;
};
} // End of namespace Graphics
#endif
|