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

#ifndef _SVIDEO_H_
#define _SVIDEO_H_

/** * * * * * * * * * * * * * * * * * * * * * * * * *
* *
* created by Ovan or Magun *
* compile with : lavformat,lavcodec,lavutil *
* and other library defined last *
* *
* conctact me : *
* www.irrlicht.fr *
* www.immortal-galaxy.com *
* *
* * * * * * * * * * * * * * * * * * * * * * * * * **/

#include <stdint.h>
#if defined WIN32 || defined WIN64 || defined _WIN32_ || defined _WIN64_
#define WINDOWS
#endif

struct AVFormatContext;
struct AVCodecContext;
struct AVCodec;
struct AVPicture;
struct AVFrame;

namespace interne
{
namespace _interface { class CGUIVideo; }
struct SVideo
{
public :
SVideo();
SVideo(char*file,bool sound = false);
~SVideo();
bool open( char *file, bool sound);
void play( bool p = true ), stop(), setLoop(bool b = false);
bool restart(), isPlay(), isLoop();

int getWindowFPS(), getVideoFPS();
double getOriginalFPS(); //! get video file fps info
int getFrame(), getTotalFrame();
int getTime(), getTotalTime();//!
void goToFrame(int frm);
void goToTime(int sec = 0, int min = 0, int h = 0);
//! file info ... update ffmpeg for use this
char *getAuthor(), *getAlbum();
char *getTitle(), *getCopyright();
char *getComment(), *getGenre();
int getYear(), getTrack();

bool makeFrame();
signed int width, height;
private :
friend class _interface::CGUIVideo;
char *file;

AVFrame *Frame,*FrameRGB;
AVFormatContext *FormatCtx;
AVCodecContext *videoCodecCtx ,*audioCodecCtx ,*dataCodecCtx;
AVCodec *videoCodec ,*audioCodec ,*dataCodec;

uint8_t *buffer;

double videoFPS;
int nFrm, frame, numBytes, windowFPS;
int videoStream, audioStream, dataStream;
bool drawFrame, Sound, Play, Replay, writeConsol;
};
}
#endif

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
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211

#include "SVideo.h"

/** * * * * * * * * * * * * * * * * * * * * * * * * *
* *
* created by Ovan or Magun *
* compile with : lavformat,lavcodec,lavutil *
* and other library defined last *
* *
* conctact me : *
* www.irrlicht.fr *
* www.immortal-galaxy.com *
* *
* * * * * * * * * * * * * * * * * * * * * * * * * **/

#if defined WIN32 || defined WIN64 || defined _WIN32_ || defined _WIN64_
extern "data/intro.data"
{
#include <ffmpeg/avcodec.h>
#include <ffmpeg/avformat.h>
#include <ffmpeg/swscale.h>
}
#else
extern "C"
{
#include <libavcodec/avcodec.h>
#include <libavformat/avformat.h>
#include <libswscale/swscale.h>
}
#endif

#if LIBAVCODEC_VERSION_MAJOR > 51
int img_convert(AVPicture* dst, PixelFormat dst_pix_fmt, AVPicture* src, PixelFormat pix_fmt, int width, int height)
{
int av_log = av_log_get_level();
av_log_set_level(AV_LOG_QUIET);
SwsContext *img_convert_ctx = sws_getContext(width, height, pix_fmt, width, height, dst_pix_fmt, SWS_BICUBIC, NULL, NULL, NULL);
int result = sws_scale(img_convert_ctx, src->data, src->linesize, 0, height, dst->data, dst->linesize);
sws_freeContext(img_convert_ctx);
av_log_set_level(av_log);
return result;
}
#endif
namespace interne
{
SVideo::SVideo()
{
av_register_all();
}
SVideo::SVideo(char*file,bool sound)
{
av_register_all();
open(file,sound);
}
SVideo::~SVideo()
{
if(buffer != NULL) av_free(buffer);
if(FrameRGB != NULL) av_free(FrameRGB);
if(Frame != NULL) av_free(Frame);
if(videoCodecCtx != NULL) avcodec_close(videoCodecCtx);
if(FormatCtx != NULL) av_close_input_file(FormatCtx);
}
bool SVideo::open(char *f,bool sound)
{
file = f;
Sound = sound;
if(av_open_input_file(&FormatCtx, file, NULL, 0, NULL)!=0)
{
Play = false;
return true;
}
if(av_find_stream_info(FormatCtx)<0)
{
Play = false;
return true;
}

dump_format(FormatCtx, 0, file, 0);

videoStream=-1;
audioStream=-1;
dataStream=-1;
for(nFrm=0; nFrm<FormatCtx->nb_streams; nFrm++)
{
if(FormatCtx->streams[nFrm]->codec->codec_type == CODEC_TYPE_VIDEO)
{
videoStream = nFrm;
}
if(FormatCtx->streams[nFrm]->codec->codec_type == CODEC_TYPE_AUDIO)
{
audioStream = nFrm;
}
if(FormatCtx->streams[nFrm]->codec->codec_type == CODEC_TYPE_DATA)
{
dataStream = nFrm;
}
}
if(dataStream > -1)
dataCodecCtx = FormatCtx->streams[dataStream]->codec;
if(audioStream > -1 && sound)
{
audioCodecCtx = FormatCtx->streams[audioStream]->codec;
audioCodec = avcodec_find_decoder(audioCodecCtx->codec_id);
avcodec_open(audioCodecCtx, audioCodec);
}
if(videoStream > -1)
{
videoCodecCtx = FormatCtx->streams[videoStream]->codec;
videoCodec = avcodec_find_decoder(videoCodecCtx->codec_id);
avcodec_open(videoCodecCtx, videoCodec);
videoFPS = (double)FormatCtx->streams[videoStream]->r_frame_rate.den / FormatCtx->streams[videoStream]->r_frame_rate.num;
Frame = avcodec_alloc_frame();
FrameRGB = avcodec_alloc_frame();
}
#if defined IRRLICHT_SUPPORT
numBytes = avpicture_get_size(PIX_FMT_RGB555, videoCodecCtx->width,videoCodecCtx->height);
buffer = (uint8_t *)av_malloc(numBytes*sizeof(uint8_t));
avpicture_fill((AVPicture *)FrameRGB, buffer, PIX_FMT_RGB555, videoCodecCtx->width, videoCodecCtx->height);
#else
numBytes = avpicture_get_size(PIX_FMT_RGB32, videoCodecCtx->width,videoCodecCtx->height);
buffer = (uint8_t *)av_malloc(numBytes*sizeof(uint8_t));
avpicture_fill((AVPicture *)FrameRGB, buffer, PIX_FMT_RGB32, videoCodecCtx->width, videoCodecCtx->height);
#endif
nFrm = 0;
width = videoCodecCtx->width;
height = videoCodecCtx->height;
return true;
}
bool SVideo::makeFrame()
{
if(Play)
{
AVPacket packet;
if(av_read_frame(FormatCtx, &packet) >= 0)
{
if(packet.stream_index == videoStream)
{
avcodec_decode_video(videoCodecCtx, Frame, &frame, packet.data, packet.size);
if(frame)
{
#if defined SDL_SUPPORT
#elif defined IRRLICHT_SUPPORT
img_convert((AVPicture *)FrameRGB, PIX_FMT_RGB555, (AVPicture*)Frame, videoCodecCtx->pix_fmt,width,height);
#else
img_convert((AVPicture *)FrameRGB, PIX_FMT_RGB32 , (AVPicture*)Frame, videoCodecCtx->pix_fmt,width,height);
#endif
nFrm++;
av_free_packet(&packet);
}
}
else if(packet.stream_index == audioStream);
else av_free_packet(&packet);
}
else
{
if(Replay == true) restart();
else
{
if(writeConsol) printf("C");
play(false);
return false;
}
}
drawFrame = true;
}
return true;
}
void SVideo::play(bool b) { Play = b; }
void SVideo::stop() { restart(); Play = false; }
void SVideo::setLoop(bool b){ Replay = b; }
/******************************/
bool SVideo::isPlay(){ return Play; }
bool SVideo::isLoop(){ return Replay; }
void SVideo::goToTime( int sec, int min, int h ) { sec += ((h*60)+min)*60; goToFrame((int)(sec/videoFPS)); }
void SVideo::goToFrame(int frm)
{
if( frm > nFrm) av_seek_frame(FormatCtx, videoStream, frm, AVSEEK_FLAG_BACKWARD);
else
{
restart();
av_seek_frame(FormatCtx, videoStream, frm, AVSEEK_FLAG_BACKWARD);
}
nFrm = frm;
}
bool SVideo::restart()
{
if (FormatCtx)
{
if (av_open_input_file(&FormatCtx, file, NULL, 0, NULL) != 0)
return false;
nFrm = 0;
if(writeConsol) printf("\n> END <\n\n");
return true;
}
}
/********** FILE INFO *********/
char *SVideo::getAuthor() { return FormatCtx->author; }
char *SVideo::getAlbum() { return FormatCtx->album; }
char *SVideo::getTitle() { return FormatCtx->title; }
char *SVideo::getCopyright(){ return FormatCtx->copyright; }
char *SVideo::getComment() { return FormatCtx->comment; }
char *SVideo::getGenre(){ return FormatCtx->genre; }
int SVideo::getYear() { return FormatCtx->year; }
int SVideo::getTrack() { return FormatCtx->track; }
int SVideo::getVideoFPS() { return (int)videoFPS; }
double SVideo::getOriginalFPS(){ return (double)FormatCtx->streams[videoStream]->r_frame_rate.den / FormatCtx->streams[videoStream]->r_frame_rate.num; }
int SVideo::getFrame() { return nFrm; }
int SVideo::getTime() { return (int)(nFrm/videoFPS)/60; }
int SVideo::getTotalFrame() { return FormatCtx->streams[videoStream]->nb_frames; }
int SVideo::getTotalTime() { return (int)(FormatCtx->streams[videoStream]->nb_frames/videoFPS); }
int SVideo::getWindowFPS() { return windowFPS; }
/******************************/
}

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

#ifndef _CGUI_VIDEO_H_
#define _CGUI_VIDEO_H_
#include "../SVideo.h"
//!compatible graphique library
//#define SDL_SUPPORT
#define IRRLICHT_SUPPORT
//!futur compatible graphique labrary ?
//////////////#define DIRECTX_SUPPORT
//////////////#define OPENGL_SUPPORT
//////////////#define OGRE_SUPPORT
//!futur compatible Sound labrary ?
//////////////#define FMOD_SUPPORT
//////////////#define IRRKLANG_SUPPORT
//////////////#define SDL_AUDIO_SUPPORT
//////////////#define DIRECT_SOUND_SUPPORT
#if defined SDL_SUPPORT || SDL_AUDIO_SUPPORT
#include <SDL.h>
#include <SDL_audio.h>
#undef FMOD_SUPPORT
#undef IRRKLANG_SUPPORT
#define SDL_AUDIO_SUPPORT
#elif defined IRRLICHT_SUPPORT
#include <irrlicht/irrlicht.h>
//#elif defined OPENGL_SUPPORT
// #include <GL/gl.h>
// #include <GL/glu.h>
//#elif ( defined DIRECTX_SUPPORT || defined DIRECT_SOUND_SUPPORT ) && defined WINDOWS
// #include <d3d9.h>
// #include <dsound.h>
#endif

/** * * * * * * * * * * * * * * * * * * * * * * * * * **/
/** * * **/
/** * created by Ovan or Magun * **/
/** * compile with : lavformat,lavcodec,lavutil * **/
/** * and other library defined last * **/
/** * * **/
/** * conctact me : * **/
/** * www.irrlicht.fr * **/
/** * www.immortal-galaxy.com * **/
/** * * **/
/** * * * * * * * * * * * * * * * * * * * * * * * * * **/

namespace interne
{
namespace _interface
{
class CGUIVideo
{
public:
CGUIVideo(SVideo*,bool run = true,bool loop = false);
virtual ~CGUIVideo();//free memory class
virtual bool refresh(),// no limite refresh video
refreshByTime(),//limite refresh by time
refreshByFPS();//sync video fps and window fps for slow computer or slow render window ... no finished
virtual bool creatFrameScreenshot(char *name);
virtual void setFPS( double fps );//set the video decoding frame rate, if 0 fps = video.fps
virtual void setConsole( bool b = false );//!sdl note suported
#if defined SDL_SUPPORT
virtual bool draw(SDL_Surface *screen, SDL_Rect rect);
#elif defined IRRLICHT_SUPPORT
virtual irr::video::ITexture *draw();
virtual void setVideoDriver(irr::video::IVideoDriver*drive, irr::ITimer *time);
virtual irr::video::IImage *getImage();
virtual irr::video::ITexture *getTexture();
#endif
SVideo *getVideoData() { return data; }
protected:
SVideo *data;
bool writeConsol;
private:
int lastTime;
#if defined SDL_SUPPORT
SDL_Overlay *bmp;
#elif defined OGRE_SUPPORT
#elif defined IRRLICHT_SUPPORT
irr::ITimer *Timer;
irr::video::IImage *VImage;
irr::video::ITexture *VTexture;
irr::video::IVideoDriver*driver;
#endif
#if defined SDL_AUDIO_SUPPORT
SDL_AudioSpec wanted_spec, spec;
#endif
void WindowFPS();
};
}
}
#endif // CGUIVideo_H

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

#include "CGUIVideo.h"

using namespace std;
#if defined WIN32 || defined WIN64 || defined _WIN32_ || defined _WIN64_
extern "data/intro.data"
{
#include <ffmpeg/avcodec.h>
}
#else
extern "C"
{
#include <libavcodec/avcodec.h>
}
#endif

/** * * * * * * * * * * * * * * * * * * * * * * * * *
* *
* created by Ovan or Magun *
* compile with : lavformat,lavcodec,lavutil *
* and other library defined last *
* *
* conctact me : *
* www.irrlicht.fr *
* www.immortal-galaxy.com *
* *
* * * * * * * * * * * * * * * * * * * * * * * * * **/

namespace interne
{
namespace _interface
{
CGUIVideo::CGUIVideo( SVideo *d, bool run, bool loop )
{
data = d;
data->Play = data->Replay = writeConsol = data->drawFrame = false;
#if defined SDL_SUPPORT
bmp = false;
#elif defined IRRLICHT_SUPPORT
VTexture = false;
VImage = false;
#endif
data->Play = run;
data->Replay = loop;
writeConsol = data->writeConsol = false;
lastTime = 0;
}
CGUIVideo::~CGUIVideo(){ }
void CGUIVideo::setConsole(bool b){ data->writeConsol = writeConsol = b; }
/********** video VIEW *********/
void CGUIVideo::setFPS(double fps) { data->videoFPS = fps; }
bool CGUIVideo::creatFrameScreenshot(char *name){}
void CGUIVideo::WindowFPS()
{
#if defined SDL_SUPPORT
static int time, frame,i;
i+=1;
if(SDL_GetTicks() - time > 1000)
{
windowFPS = i - frame;
frame = i;
time = SDL_GetTicks();
}
#elif defined IRRLICHT_SUPPORT
data->windowFPS = driver->getFPS();
#elif SFML_SUPPORT
static double time, frame,i;
i+=1;
if(timer.GetElapsedTime() - time)
{
windowFPS = i - frame;
frame = i;
time = timer.GetElapsedTime();
}
#endif
}
bool CGUIVideo::refreshByTime()
{
bool rf;
if(data->Play
#if defined SDL_SUPPORT
&& SDL_GetTicks() - lastTime > videoFPS*1000
#elif defined SFML_SUPPORT
&& timer.GetElapsedTime() > videoFPS
#elif defined IRRLICHT_SUPPORT
&& Timer->getRealTime() - lastTime > data->videoFPS*1000
#endif
)
{
#if defined SDL_SUPPORT
lastTime = SDL_GetTicks();
#elif defined SFML_SUPPORT
timer.Reset();
#elif defined IRRLICHT_SUPPORT
lastTime = Timer->getRealTime();
#endif
return refresh();
}
}
bool CGUIVideo::refreshByFPS()
{
WindowFPS();
static int i = (int)(data->getTotalFrame() / data->videoFPS), io = 0;
io = io+i;
data->goToFrame((int)io);
}
bool CGUIVideo::refresh() { return data->makeFrame(); }
#if defined SDL_SUPPORT
bool CGUIVideo::draw(SDL_Surface *screen, SDL_Rect rect)
{
WindowFPS();
if(Play && frame)
{
if(!bmp)
bmp = SDL_CreateYUVOverlay(data->width,data->height, SDL_YV12_OVERLAY,screen);

SDL_LockYUVOverlay(bmp);
pict.data[0] = bmp->pixels[0];
pict.data[1] = bmp->pixels[2];
pict.data[2] = bmp->pixels[1];

pict.linesize[0] = bmp->pitches[0];
pict.linesize[1] = bmp->pitches[2];
pict.linesize[2] = bmp->pitches[1];

img_convert(&pict, PIX_FMT_YUVJ420P,(AVPicture *)Frame,videoCodecCtx->pix_fmt,width,height);
SDL_UnlockYUVOverlay(bmp);
SDL_DisplayYUVOverlay(bmp, &rect);
}
}
#elif defined IRRLICHT_SUPPORT
irr::video::IImage* CGUIVideo::getImage() { return VImage; }
irr::video::ITexture* CGUIVideo::getTexture() { return VTexture; }
void CGUIVideo::setVideoDriver(irr::video::IVideoDriver*drive,irr::ITimer *time)
{
driver = drive; Timer = time;
}
irr::video::ITexture* CGUIVideo::draw()
{
WindowFPS();//temporaire, wait to dev syncronisation video
if(data->Play && data->frame && data->drawFrame)
{
if(!VImage) VImage = driver->createImageFromData(irr::video::ECF_A1R5G5B5,irr::core::dimension2d<irr::u32>(data->width,data->height),data->FrameRGB->data[0],true);
if(!VTexture) VTexture = driver->addTexture("C", VImage);

irr::u32 *tBits = (irr::u32*)VTexture->lock();
for(irr::u32 j=0; j<data->height; ++j)
for(irr::u32 i=0; i<data->width; ++i)
tBits[j*data->width+i] = VImage->getPixel(i,j).color;
VTexture->unlock();

data->drawFrame = false;
return VTexture;
}
}
#endif
}
}

Code c++ :

Code c++ :

Code c++ :