|
0
|
1 #include "OSAPI.h"
|
|
|
2
|
|
|
3 #include "Bink_Smacker.h"
|
|
|
4
|
|
|
5 #include "OSInfo.h"
|
|
|
6 #include "VideoPlayer.h"
|
|
|
7 #include "AudioPlayer.h"
|
|
|
8 #include "Game.h"
|
|
|
9 #include "Render.h"
|
|
|
10 #include "Party.h"
|
|
|
11 #include "GUIWindow.h"
|
|
|
12 #include "Allocator.h"
|
|
|
13 #include "Time.h"
|
|
|
14 #include "Log.h"
|
|
629
|
15 #include "UIHouses.h"
|
|
898
|
16 #include "texts.h"
|
|
481
|
17 #include "MM7.h"
|
|
0
|
18 #include "mm7_data.h"
|
|
|
19
|
|
|
20
|
|
|
21 VideoPlayer *pVideoPlayer = nullptr;
|
|
|
22
|
|
|
23
|
|
|
24
|
|
|
25
|
|
|
26
|
|
|
27
|
|
|
28
|
|
|
29 #pragma comment(lib, "Version.lib")
|
|
|
30 bool GetDllVersion(const wchar_t *pDllName, uint *pMajor, uint *pMinor)
|
|
|
31 {
|
|
|
32 uint uVersionSize = GetFileVersionInfoSizeW(pDllName, nullptr);
|
|
|
33 void *pVersionData = HeapAlloc(GetProcessHeap(), 0, uVersionSize);
|
|
|
34 {
|
|
|
35 GetFileVersionInfoW(pDllName, 0, uVersionSize, pVersionData);
|
|
|
36
|
|
|
37 VS_FIXEDFILEINFO *pInfo = nullptr;
|
|
|
38 UINT uInfoSize = 0;
|
|
|
39 VerQueryValueW(pVersionData, L"\\", (void **)&pInfo, &uInfoSize);
|
|
|
40
|
|
|
41 if (!pMajor || !pMinor)
|
|
|
42 {
|
|
|
43 HeapFree(GetProcessHeap(), 0, pVersionData);
|
|
|
44 return false;
|
|
|
45 }
|
|
|
46 *pMajor = pInfo->dwFileVersionMS;
|
|
|
47 *pMinor = pInfo->dwFileVersionLS;
|
|
|
48 }
|
|
|
49 HeapFree(GetProcessHeap(), 0, pVersionData);
|
|
|
50 return true;
|
|
|
51 }
|
|
|
52
|
|
|
53
|
|
|
54 // 3.15.1.0:
|
|
|
55 // 3 15 1 0
|
|
|
56 // 0x0003000F00010000
|
|
|
57 unsigned __int64 uBinkVersion;
|
|
|
58
|
|
|
59
|
|
|
60
|
|
|
61
|
|
|
62
|
|
|
63
|
|
|
64 //----- (004BFE2D) --------------------------------------------------------
|
|
|
65 _BINKBUF *VideoPlayer::CreateBinkBuffer(HWND hWindow, unsigned int uWidth, unsigned int uHeight, char a4)
|
|
|
66 {
|
|
|
67 __int32 v4; // edi@3
|
|
|
68 _BINKBUF *v5; // esi@3
|
|
|
69 HRESULT v6; // eax@5
|
|
|
70 IDirectDrawSurface *v7; // eax@6
|
|
|
71 HRESULT v8; // eax@9
|
|
|
72 char v9; // al@11
|
|
|
73 DDSURFACEDESC2 v11; // [sp+Ch] [bp-108h]@7
|
|
|
74 DDSURFACEDESC Dst; // [sp+88h] [bp-8Ch]@3
|
|
|
75 unsigned int v13; // [sp+F4h] [bp-20h]@1
|
|
|
76 struct tagRECT Rect; // [sp+F8h] [bp-1Ch]@11
|
|
|
77 IDirectDrawSurface4 *v15; // [sp+108h] [bp-Ch]@7
|
|
|
78 IDirectDrawSurface2 *a2; // [sp+10Ch] [bp-8h]@3
|
|
|
79 HWND hWnd; // [sp+110h] [bp-4h]@1
|
|
|
80
|
|
|
81 v13 = uWidth;
|
|
|
82 hWnd = hWindow;
|
|
|
83 if ( pVersion->pVersionInfo.dwPlatformId != VER_PLATFORM_WIN32_NT || pVersion->pVersionInfo.dwMajorVersion >= 5u )
|
|
|
84 {
|
|
|
85 v4 = 0;
|
|
|
86 v15 = 0;
|
|
|
87
|
|
|
88 if (uBinkVersion == 0x0001000500150000)
|
|
|
89 {
|
|
|
90 v5 = new _BINKBUF_1_5_21_0;
|
|
|
91 memset(v5, 0, sizeof(_BINKBUF_1_5_21_0));
|
|
|
92 }
|
|
|
93 else if (uBinkVersion == 0x0003000000000000)
|
|
|
94 {
|
|
|
95 v5 = new _BINKBUF_3_0_0_0;
|
|
|
96 memset(v5, 0, sizeof(_BINKBUF_3_0_0_0));
|
|
|
97 }
|
|
|
98
|
|
|
99 memset(&v11, 0, 0x7Cu);
|
|
|
100 v11.dwSize = 124;
|
|
|
101 v11.dwWidth = v13;
|
|
|
102 v11.dwFlags = 0x1007u; // DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT | DDSD_PIXELFORMAT
|
|
|
103 v11.ddsCaps.dwCaps = 0x4040u; // DDSCAPS_OFFSCREENPLAIN | DDSCAPS_VIDEOMEMORY
|
|
|
104 v11.dwHeight = uHeight;
|
|
|
105 *(_QWORD *)&v11.ddpfPixelFormat.dwSize = 0x400000020ui64;// DDPF_FOURCC
|
|
|
106 v11.ddpfPixelFormat.dwFourCC = 0x32595559u;
|
|
|
107 if ( dword_6BE384_2dacceloff || pRenderer->pDirectDraw4->CreateSurface(&v11, &v15, 0) )
|
|
|
108 {
|
|
|
109 memset(&v11.ddpfPixelFormat, 0, sizeof(DDPIXELFORMAT));
|
|
|
110
|
|
|
111 v11.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT;
|
|
|
112 v11.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | DDSCAPS_SYSTEMMEMORY;
|
|
|
113
|
|
|
114 auto hr = pRenderer->pDirectDraw4->CreateSurface(&v11, &v15, 0);
|
|
|
115 ErrD3D(hr, "E:\\WORK\\MSDEV\\MM7\\MM7\\Code\\Video.cpp:1476");
|
|
|
116 }
|
|
|
117 v5->uWidth = v11.dwWidth;
|
|
|
118 v5->uHeight = v11.dwHeight;
|
|
|
119 v5->uBinkDDSurfaceType = BinkDDSurfaceType((IDirectDrawSurface *)v15);
|
|
|
120 v5->field_38 = 0;
|
|
|
121 v7 = (IDirectDrawSurface *)v15;
|
|
|
122 }
|
|
|
123 else
|
|
|
124 {
|
|
|
125 v4 = 0;
|
|
|
126 a2 = 0;
|
|
|
127
|
|
|
128
|
|
|
129 if (uBinkVersion == 0x0001000500150000)
|
|
|
130 {
|
|
|
131 v5 = new _BINKBUF_1_5_21_0;
|
|
|
132 memset(v5, 0, sizeof(_BINKBUF_1_5_21_0));
|
|
|
133 }
|
|
|
134 else if (uBinkVersion == 0x0003000000000000)
|
|
|
135 {
|
|
|
136 v5 = new _BINKBUF_3_0_0_0;
|
|
|
137 memset(v5, 0, sizeof(_BINKBUF_3_0_0_0));
|
|
|
138 }
|
|
|
139
|
|
|
140 memset(&Dst, 0, 0x6Cu);
|
|
|
141 Dst.dwSize = 108;
|
|
|
142 Dst.dwWidth = v13;
|
|
|
143 Dst.dwFlags = 4103;
|
|
|
144 Dst.ddsCaps.dwCaps = 16448;
|
|
|
145 Dst.dwHeight = uHeight;
|
|
|
146 Dst.ddpfPixelFormat.dwSize = 32;
|
|
|
147 Dst.ddpfPixelFormat.dwFlags = 4;
|
|
|
148 Dst.ddpfPixelFormat.dwFourCC = 844715353;
|
|
|
149 if ( dword_6BE384_2dacceloff
|
|
|
150 || pRenderer->pDirectDraw2->CreateSurface(&Dst, (LPDIRECTDRAWSURFACE *)&a2, 0) )
|
|
|
151 {
|
|
|
152 memset(&Dst.ddpfPixelFormat, 0, sizeof(DDPIXELFORMAT));
|
|
|
153
|
|
|
154 Dst.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT;
|
|
|
155 Dst.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | DDSCAPS_SYSTEMMEMORY;
|
|
|
156
|
|
|
157 auto hr = pRenderer->pDirectDraw2->CreateSurface(&Dst, (LPDIRECTDRAWSURFACE *)&a2, 0);
|
|
|
158 ErrD3D(hr, "E:\\WORK\\MSDEV\\MM7\\MM7\\Code\\Video.cpp:1426");
|
|
|
159 }
|
|
|
160 v5->uWidth = Dst.dwWidth;
|
|
|
161 v5->uHeight = Dst.dwHeight;
|
|
|
162 v5->uBinkDDSurfaceType = BinkDDSurfaceType((IDirectDrawSurface *)a2);
|
|
|
163 v5->field_38 = 0;
|
|
|
164 v7 = (IDirectDrawSurface *)a2;
|
|
|
165 }
|
|
|
166 v5->pTargetDDrawSurface = v7;
|
|
|
167 v5->hWnd = hWnd;
|
|
|
168 v9 = a4;
|
|
|
169 v5->field_4C = v4;
|
|
|
170 v5->field_68 = v4;
|
|
|
171 v5->field_5C = v4;
|
|
|
172 v5->field_74 = v9 & 0x1F;
|
|
|
173 v5->field_78 = 1;
|
|
|
174 v5->field_24 = GetSystemMetrics(v4);
|
|
|
175 v5->field_28 = GetSystemMetrics(SM_CYSCREEN);
|
|
|
176 v5->field_2C = 16;
|
|
|
177 GetWindowRect(hWnd, &Rect);
|
|
|
178 v5->field_8 = Rect.right - Rect.left;
|
|
|
179 v5->field_C = Rect.bottom - Rect.top;
|
|
|
180 v5->field_1C = Rect.left;
|
|
|
181 v5->field_20 = Rect.top;
|
|
|
182 Rect.left = v4;
|
|
|
183 Rect.top = v4;
|
|
|
184 ClientToScreen(hWnd, (LPPOINT)&Rect);
|
|
|
185 v5->field_1C = Rect.left - v5->field_1C;
|
|
|
186 v5->field_20 = Rect.top - v5->field_20;
|
|
|
187 GetClientRect(hWnd, &Rect);
|
|
|
188 v5->field_30 = v5->field_8 - Rect.right;
|
|
|
189 v5->field_34 = v5->field_C - Rect.bottom;
|
|
|
190 v5->field_8 = v5->uWidth + v5->field_30;
|
|
|
191 v5->field_C = v5->uHeight + v5->field_34;
|
|
|
192 BinkBufferSetOffset(v5, v4, v4);
|
|
|
193 BinkBufferSetScale(v5, v5->uWidth, v5->uHeight);
|
|
|
194 return v5;
|
|
|
195 }
|
|
|
196
|
|
|
197
|
|
|
198 //----- (004C0133) --------------------------------------------------------
|
|
|
199 bool BinkLockBuffer(_BINKBUF *_this)
|
|
|
200 {
|
|
|
201 _BINKBUF *v1; // esi@1
|
|
|
202 IDirectDrawSurface *v2; // edi@5
|
|
|
203 DWORD v4; // eax@8
|
|
|
204 DWORD v5; // eax@8
|
|
|
205 IDirectDrawSurface4 *v6; // edi@11
|
|
|
206 LPVOID v7; // eax@14
|
|
|
207
|
|
|
208 v1 = _this;
|
|
|
209 if ( pVersion->pVersionInfo.dwPlatformId != VER_PLATFORM_WIN32_NT || pVersion->pVersionInfo.dwMajorVersion >= 5u )
|
|
|
210 {
|
|
|
211 DDSURFACEDESC2 v8; // [sp+Ch] [bp-7Ch]@4
|
|
|
212 if ( _this->pTargetDDrawSurface )
|
|
|
213 {
|
|
|
214 memset(&v8, 0, 0x7Cu);
|
|
|
215 v8.dwSize = 124;
|
|
|
216 while ( 1 )
|
|
|
217 {
|
|
|
218 v6 = (IDirectDrawSurface4 *)v1->pTargetDDrawSurface;
|
|
|
219 if ( !v6->Lock(0, &v8, 1u, 0) )
|
|
|
220 break;
|
|
|
221
|
|
|
222 if (uBinkVersion < 0x0003000000000000)
|
|
|
223 BYTE3(v1->uBinkDDSurfaceType) |= 0x80u;
|
|
|
224 else
|
|
|
225 BYTE3(v1->uBinkDDSurfaceType) |= 0x04;
|
|
|
226
|
|
|
227 if ( v6->Restore() )
|
|
|
228 return 0;
|
|
|
229 }
|
|
|
230 v7 = v8.lpSurface;
|
|
|
231 v1->pDDrawSurfaceData_ = v8.lpSurface;
|
|
|
232 v1->pDDrawSurfaceData = v7;
|
|
|
233 v5 = v8.lPitch;
|
|
|
234 goto LABEL_15;
|
|
|
235 }
|
|
|
236 }
|
|
|
237 else
|
|
|
238 {
|
|
|
239 DDSURFACEDESC v8; // [sp+Ch] [bp-7Ch]@4
|
|
|
240 if ( _this->pTargetDDrawSurface )
|
|
|
241 {
|
|
|
242 memset(&v8.lPitch, 0, 0x6Cu);
|
|
|
243 v8.lPitch = 108;
|
|
|
244 while ( 1 )
|
|
|
245 {
|
|
|
246 v2 = v1->pTargetDDrawSurface;
|
|
|
247 if ( !v2->Lock(0, (LPDDSURFACEDESC)&v8.lPitch, 1u, 0) )
|
|
|
248 break;
|
|
|
249
|
|
|
250 if (uBinkVersion < 0x0003000000000000)
|
|
|
251 __asm int 3;
|
|
|
252 else
|
|
|
253 BYTE3(v1->uBinkDDSurfaceType) |= 4u;
|
|
|
254
|
|
|
255 if ( v2->Restore() )
|
|
|
256 return 0;
|
|
|
257 }
|
|
|
258 v4 = (DWORD)v8.lpSurface;
|
|
|
259 v1->pDDrawSurfaceData_ = (void *)v8.lpSurface;
|
|
|
260 v1->pDDrawSurfaceData = (void *)v4;
|
|
|
261 v5 = v8.dwReserved;
|
|
|
262 LABEL_15:
|
|
|
263 v1->uDDrawSurfacePitch = v5;
|
|
|
264 return 1;
|
|
|
265 }
|
|
|
266 }
|
|
|
267 return 1;
|
|
|
268 }
|
|
|
269
|
|
|
270 //----- (004C01FB) --------------------------------------------------------
|
|
|
271 void BinkUnlockBuffer(_BINKBUF *_this)
|
|
|
272 {
|
|
|
273 _BINKBUF *v1; // esi@1
|
|
|
274 IDirectDrawSurface *v2; // eax@1
|
|
|
275
|
|
|
276 v1 = _this;
|
|
|
277 v2 = _this->pTargetDDrawSurface;
|
|
|
278 if ( v2 )
|
|
|
279 {
|
|
|
280 v2->Unlock(0);
|
|
|
281 v1->uDDrawSurfacePitch = 0;
|
|
|
282 v1->pDDrawSurfaceData = 0;
|
|
|
283
|
|
|
284 if (uBinkVersion < 0x0003000000000000)
|
|
|
285 BYTE3(_this->uBinkDDSurfaceType) &= 0x7F;
|
|
|
286 else
|
|
|
287 BYTE3(_this->uBinkDDSurfaceType) &= 0xFB;
|
|
|
288 }
|
|
|
289 }
|
|
|
290 //----- (004BF794) --------------------------------------------------------
|
|
|
291 void __cdecl ShowIntroVideo_and_LoadingScreen()
|
|
|
292 {
|
|
|
293 RGBTexture tex; // [sp+Ch] [bp-30h]@1
|
|
|
294 unsigned int uTrackStartMS; // [sp+34h] [bp-8h]@8
|
|
|
295 unsigned int uTrackEndMS; // [sp+38h] [bp-4h]@8
|
|
|
296
|
|
|
297 pVideoPlayer->bStopBeforeSchedule = false;
|
|
165
|
298 pVideoPlayer->pResetflag = 0;
|
|
0
|
299 bGameoverLoop = 1;
|
|
256
|
300 if (!bNoVideo)
|
|
0
|
301 {
|
|
|
302 pRenderer->PresentBlackScreen();
|
|
|
303 pGame->pCShow->PlayMovie(MOVIE_3DOLogo, 1);
|
|
|
304 if ( !pVideoPlayer->bStopBeforeSchedule )
|
|
|
305 {
|
|
|
306 pGame->pCShow->PlayMovie(MOVIE_NWCLogo, 1);
|
|
|
307 if ( !pVideoPlayer->bStopBeforeSchedule )
|
|
|
308 {
|
|
|
309 pGame->pCShow->PlayMovie(MOVIE_JVC, 1);
|
|
|
310 if ( !pVideoPlayer->bStopBeforeSchedule )
|
|
|
311 pGame->pCShow->PlayMovie(MOVIE_Intro, 1);
|
|
|
312 }
|
|
|
313 }
|
|
|
314 }
|
|
|
315 tex.Load("mm6title.pcx", 2);
|
|
|
316 pRenderer->BeginScene();
|
|
|
317 pRenderer->DrawTextureRGB(0, 0, &tex);
|
|
|
318 free(tex.pPixels);
|
|
|
319 tex.pPixels = 0;
|
|
762
|
320
|
|
|
321 LoadFonts_and_DrawCopyrightWindow();
|
|
|
322
|
|
0
|
323 pRenderer->EndScene();
|
|
|
324 pRenderer->Present();
|
|
1004
|
325
|
|
|
326 #ifndef _DEBUG
|
|
|
327 Sleep(1500); // let the copyright window stay for a while
|
|
|
328 #endif
|
|
|
329
|
|
0
|
330 if (!bNoSound && pAudioPlayer->hAILRedbook )
|
|
|
331 {
|
|
|
332 pAudioPlayer->SetMusicVolume((signed __int64)(pSoundVolumeLevels[uMusicVolimeMultiplier] * 64.0));
|
|
|
333 AIL_redbook_stop(pAudioPlayer->hAILRedbook);
|
|
|
334 AIL_redbook_track_info(pAudioPlayer->hAILRedbook, 0xE, &uTrackStartMS, &uTrackEndMS);
|
|
|
335 AIL_redbook_play(pAudioPlayer->hAILRedbook, uTrackStartMS + 1, uTrackEndMS);
|
|
|
336 }
|
|
|
337 bGameoverLoop = 0;
|
|
|
338 }
|
|
|
339
|
|
|
340
|
|
|
341
|
|
|
342
|
|
|
343 //----- (004BE70E) --------------------------------------------------------
|
|
227
|
344 void __fastcall VideoPlayer::MovieLoop(const char *pMovieName, int a2, int ScreenSizeFlag, int a4)
|
|
0
|
345 {
|
|
|
346 int v4; // ebp@1
|
|
|
347 const char *pName; // edi@1
|
|
|
348 MSG Msg; // [sp+Ch] [bp-1Ch]@12
|
|
|
349
|
|
|
350 v4 = a2;
|
|
|
351 pName = pMovieName;
|
|
|
352 if ( !(dword_6BE364_game_settings_1 & 0x44) )
|
|
|
353 {
|
|
|
354 if ( a2 == 2 )
|
|
|
355 v4 = 0;
|
|
|
356 ShowCursor(0);
|
|
898
|
357 pVideoPlayer->OpenGlobalMovie(pName, 0, ScreenSizeFlag);
|
|
0
|
358 pVideoPlayer->bPlayingMovie = 1;
|
|
|
359 pVideoPlayer->field_44 = v4;
|
|
|
360 if ( pRenderer->pRenderD3D )
|
|
|
361 {
|
|
|
362 pRenderer->ClearTarget(0);
|
|
|
363 }
|
|
|
364 else
|
|
|
365 {
|
|
|
366 pRenderer->BeginScene();
|
|
|
367 pRenderer->ClearTarget(0);
|
|
|
368 pRenderer->EndScene();
|
|
|
369 }
|
|
151
|
370 pCurrentScreen = SCREEN_VIDEO;
|
|
0
|
371 if ( pVideoPlayer->uMovieFormat == 2 )
|
|
|
372 {
|
|
|
373 if ( pVideoPlayer->pBinkMovie )
|
|
|
374 {
|
|
|
375 pVideoPlayer->BinkDrawFrame(pVideoPlayer->hWindow, v4, ScreenSizeFlag);
|
|
|
376 while ( pVideoPlayer->pBinkMovie )
|
|
|
377 {
|
|
|
378 if ( pVideoPlayer->bStopBeforeSchedule )
|
|
|
379 break;
|
|
|
380 while ( PeekMessageA(&Msg, 0, 0, 0, 1) )
|
|
|
381 {
|
|
|
382 if ( Msg.message == 18 )
|
|
|
383 Game_DeinitializeAndTerminate(0);
|
|
|
384 if ( Msg.message == 15 )
|
|
|
385 break;
|
|
|
386 TranslateMessage(&Msg);
|
|
|
387 DispatchMessageA(&Msg);
|
|
|
388 }
|
|
|
389 GUI_MainMenuMessageProc();
|
|
|
390 if ( !pVideoPlayer->pBinkMovie )
|
|
|
391 break;
|
|
|
392 if ( !BinkWait(pVideoPlayer->pBinkMovie) && !pVideoPlayer->bStopBeforeSchedule )
|
|
|
393 pVideoPlayer->BinkDrawFrame(pVideoPlayer->hWindow, v4, ScreenSizeFlag);
|
|
|
394 }
|
|
|
395 }
|
|
|
396 if ( pVideoPlayer->bStopBeforeSchedule == 1 )
|
|
|
397 Sleep(0x3E8u);
|
|
|
398 }
|
|
|
399 else
|
|
|
400 {
|
|
|
401 if ( pVideoPlayer->uMovieFormat == 1 )
|
|
|
402 {
|
|
|
403 if ( pVideoPlayer->pSmackerMovie )
|
|
|
404 {
|
|
|
405 pVideoPlayer->SmackDrawFrame(pVideoPlayer->hWindow, v4, ScreenSizeFlag);
|
|
|
406 while ( pVideoPlayer->pSmackerMovie )
|
|
|
407 {
|
|
|
408 if ( pVideoPlayer->bStopBeforeSchedule )
|
|
|
409 break;
|
|
|
410 while ( PeekMessageW(&Msg, 0, 0, 0, 1) )
|
|
|
411 {
|
|
|
412 if (Msg.message == WM_QUIT)
|
|
|
413 Game_DeinitializeAndTerminate(0);
|
|
|
414 if (Msg.message == WM_PAINT)
|
|
|
415 break;
|
|
|
416 TranslateMessage(&Msg);
|
|
|
417 DispatchMessageW(&Msg);
|
|
|
418 }
|
|
4
|
419 GUI_MainMenuMessageProc();
|
|
0
|
420 if ( !pVideoPlayer->pSmackerMovie )
|
|
|
421 break;
|
|
|
422 if ( !SmackWait(pVideoPlayer->pSmackerMovie) && !pVideoPlayer->bStopBeforeSchedule )
|
|
|
423 pVideoPlayer->SmackDrawFrame(pVideoPlayer->hWindow, v4, ScreenSizeFlag);
|
|
|
424 }
|
|
|
425 }
|
|
|
426 }
|
|
|
427 }
|
|
227
|
428 if (a4 == 1)
|
|
151
|
429 pCurrentScreen = SCREEN_GAME;
|
|
0
|
430 pVideoPlayer->bPlayingMovie = 0;
|
|
|
431 ShowCursor(1);
|
|
151
|
432 if ( pCurrentScreen == SCREEN_VIDEO )
|
|
|
433 pCurrentScreen = SCREEN_GAME;
|
|
0
|
434 }
|
|
|
435 }
|
|
|
436
|
|
|
437
|
|
|
438
|
|
|
439
|
|
|
440 //----- (004BE95A) --------------------------------------------------------
|
|
|
441 unsigned int VideoPlayer::SmackCheckSurfaceFromat()
|
|
|
442 {
|
|
|
443 DDPIXELFORMAT a2; // [sp+0h] [bp-20h]@1
|
|
|
444
|
|
|
445 a2.dwSize = 32;
|
|
|
446 a2.dwFlags = 64;
|
|
|
447 pRenderer->GetTargetPixelFormat(&a2);
|
|
|
448 if ( a2.dwRGBBitCount != 8 )
|
|
|
449 {
|
|
|
450 if ( a2.dwRBitMask == 0xF800 )
|
|
|
451 {
|
|
|
452 if ( a2.dwGBitMask == 0x7E0 && a2.dwBBitMask == 0x1F )
|
|
|
453 return 0xC0000000u;
|
|
|
454 }
|
|
|
455 else
|
|
|
456 {
|
|
|
457 if ( a2.dwRBitMask == 0x7C00
|
|
|
458 && a2.dwGBitMask == 0x3E0
|
|
|
459 && a2.dwBBitMask == 0x1F )
|
|
|
460 return 0x80000000u;
|
|
|
461 }
|
|
|
462 MessageBoxA(0, "Unsupported pixel format.", "Smacker Error", 0);
|
|
|
463 }
|
|
|
464 return 0;
|
|
|
465 }
|
|
|
466
|
|
|
467 //----- (004BE9D8) --------------------------------------------------------
|
|
|
468 void VideoPlayer::Initialize()
|
|
|
469 {
|
|
|
470 DWORD NumberOfBytesRead; // [sp+10h] [bp-4h]@9
|
|
|
471
|
|
|
472 uint uBinkVersionMajor = -1,
|
|
|
473 uBinkVersionMinor = -1;
|
|
|
474 GetDllVersion(L"BINKW32.DLL", &uBinkVersionMajor, &uBinkVersionMinor);
|
|
|
475 uBinkVersion = (unsigned __int64)uBinkVersionMajor << 32 | uBinkVersionMinor;
|
|
|
476
|
|
|
477 strcpy(pTmpBuf, "anims\\might7.vid");
|
|
|
478 hMightVid = CreateFileW(L"anims\\might7.vid", GENERIC_READ, FILE_SHARE_READ, 0, OPEN_EXISTING, 0x8000080u, 0);
|
|
|
479 if ( hMightVid == INVALID_HANDLE_VALUE )
|
|
|
480 {
|
|
|
481 sprintf(pTmpBuf2, "Can't open file - anims\\%s.smk", pTmpBuf);
|
|
|
482 MessageBoxA(0, pTmpBuf2, "Video File Error", 0);
|
|
|
483 return;
|
|
|
484 }
|
|
|
485 strcpy(pTmpBuf, "anims\\magic7.vid");
|
|
|
486 hMagicVid = CreateFileW(L"anims\\magic7.vid", GENERIC_READ, FILE_SHARE_READ, 0, OPEN_EXISTING, 0x8000080u, 0);
|
|
|
487 if ( hMagicVid == INVALID_HANDLE_VALUE )
|
|
|
488 {
|
|
|
489 if ( !bCanLoadFromCD )
|
|
|
490 {
|
|
|
491 sprintf(pTmpBuf2, "Can't open file - anims\\%s.smk", pTmpBuf);
|
|
|
492 MessageBoxA(0, pTmpBuf2, "Video File Error", 0);
|
|
|
493 return;
|
|
|
494 }
|
|
|
495 sprintf(pTmpBuf2, "%c:\\%s", (unsigned __int8)cMM7GameCDDriveLetter, pTmpBuf);
|
|
|
496 hMagicVid = CreateFileA(pTmpBuf2, GENERIC_READ, FILE_SHARE_READ, 0, OPEN_EXISTING, 0x8000080u, 0);
|
|
|
497 if ( hMagicVid == (HANDLE)INVALID_HANDLE_VALUE )
|
|
|
498 {
|
|
|
499 sprintf(pTmpBuf2, "Can't open file - %s", pTmpBuf);
|
|
|
500 MessageBoxA(0, pTmpBuf2, "Video File Error", 0);
|
|
|
501 return;
|
|
|
502 }
|
|
|
503 }
|
|
|
504 ReadFile(hMightVid, &uNumMightVideoHeaders, 4, &NumberOfBytesRead, 0);
|
|
|
505 ReadFile(hMagicVid, &uNumMagicVideoHeaders, 4, &NumberOfBytesRead, 0);
|
|
|
506 pMagicVideoHeaders = 0;
|
|
|
507 pMightVideoHeaders = 0;
|
|
|
508 pMightVideoHeaders = (MovieHeader *)pAllocator->AllocNamedChunk(0, 44 * uNumMightVideoHeaders + 2, 0);
|
|
|
509 pMagicVideoHeaders = (MovieHeader *)pAllocator->AllocNamedChunk(pMagicVideoHeaders, 44 * uNumMagicVideoHeaders + 2, 0);
|
|
|
510 ReadFile(hMightVid, pMightVideoHeaders, 44 * uNumMightVideoHeaders, &NumberOfBytesRead, 0);
|
|
|
511 ReadFile(hMagicVid, pMagicVideoHeaders, 44 * uNumMagicVideoHeaders, &NumberOfBytesRead, 0);
|
|
|
512 }
|
|
|
513
|
|
|
514 //----- (004BEB41) --------------------------------------------------------
|
|
|
515 void VideoPlayer::Prepare()
|
|
|
516 {
|
|
|
517 VideoPlayer *pVideoPlayer; // esi@1
|
|
|
518 IDirectDrawSurface *v2; // [sp-4h] [bp-Ch]@5
|
|
|
519
|
|
|
520 pVideoPlayer = this;
|
|
|
521 pEventTimer->Pause();
|
|
|
522 pVideoPlayer->bStopBeforeSchedule = 0;
|
|
|
523 if ( pAudioPlayer->hAILRedbook )
|
|
|
524 AIL_redbook_pause(pAudioPlayer->hAILRedbook);
|
|
|
525 pVideoPlayer->field_54 = 1;
|
|
|
526 pVideoPlayer->hWindow = hWnd;
|
|
|
527 pVideoPlayer->pSmackerMovie = 0;
|
|
|
528 pVideoPlayer->pSmackerBuffer = 0;
|
|
|
529 pVideoPlayer->pBinkMovie = 0;
|
|
|
530 pVideoPlayer->pBinkBuffer = 0;
|
|
|
531 pVideoPlayer->bPlayingMovie = 0;
|
|
|
532 pVideoPlayer->bFirstFrame = 0;
|
|
|
533 pVideoPlayer->bUsingSmackerMMX = SmackUseMMX(1);
|
|
|
534 BinkSetSoundSystem(BinkOpenMiles, pAudioPlayer->hDigDriver);
|
|
|
535 if ( pVersion->pVersionInfo.dwPlatformId != VER_PLATFORM_WIN32_NT || pVersion->pVersionInfo.dwMajorVersion >= 5 )
|
|
|
536 v2 = (IDirectDrawSurface*)pRenderer->pBackBuffer4;
|
|
|
537 else
|
|
|
538 v2 = (IDirectDrawSurface*)pRenderer->pBackBuffer2;
|
|
|
539 pVideoPlayer->uBinkDirectDrawSurfaceType = BinkDDSurfaceType(v2);
|
|
|
540 _flushall();
|
|
|
541 }
|
|
|
542
|
|
|
543
|
|
|
544 //----- (004BEBD7) --------------------------------------------------------
|
|
|
545 void VideoPlayer::Unload()
|
|
|
546 {
|
|
|
547 VideoPlayer *pVideoPlayer; // esi@1
|
|
|
548 _BINK *pBinkMovie; // eax@1
|
|
|
549 _BINKBUF *pBinkBuffer; // eax@3
|
|
|
550 _SMACK *pSmackerMovie; // eax@5
|
|
|
551
|
|
|
552 pVideoPlayer = this;
|
|
|
553 pBinkMovie = this->pBinkMovie;
|
|
|
554 if ( pBinkMovie )
|
|
|
555 {
|
|
|
556 BinkPause(pBinkMovie, 1);
|
|
|
557 Sleep(300);
|
|
|
558 BinkClose(pVideoPlayer->pBinkMovie);
|
|
|
559 pVideoPlayer->pBinkMovie = 0;
|
|
|
560 }
|
|
|
561 pBinkBuffer = pVideoPlayer->pBinkBuffer;
|
|
|
562 if ( pBinkBuffer )
|
|
|
563 {
|
|
|
564 pBinkBuffer->pTargetDDrawSurface->Release();
|
|
|
565 pVideoPlayer->pBinkBuffer->pTargetDDrawSurface = 0;
|
|
|
566 free(pVideoPlayer->pBinkBuffer);
|
|
|
567 pVideoPlayer->pBinkBuffer = 0;
|
|
|
568 }
|
|
|
569 pSmackerMovie = pVideoPlayer->pSmackerMovie;
|
|
|
570 if ( pSmackerMovie )
|
|
|
571 {
|
|
|
572 SmackSoundOnOff(pSmackerMovie, 0);
|
|
|
573 SmackClose(pVideoPlayer->pSmackerMovie);
|
|
|
574 pVideoPlayer->pSmackerMovie = 0;
|
|
|
575 }
|
|
|
576 if ( pVideoPlayer->pSmackerBuffer )
|
|
|
577 {
|
|
|
578 SmackBufferClose(pVideoPlayer->pSmackerBuffer);
|
|
|
579 pVideoPlayer->pSmackerBuffer = 0;
|
|
|
580 }
|
|
|
581 if ( pVideoPlayer->pSmackMovieBlit )
|
|
|
582 {
|
|
|
583 SmackBlitClose(pVideoPlayer->pSmackMovieBlit);
|
|
|
584 pVideoPlayer->pSmackMovieBlit = 0;
|
|
|
585 }
|
|
|
586 pVideoPlayer->field_54 = 0;
|
|
|
587 pVideoPlayer->uMovieFormat = 0;
|
|
|
588 pVideoPlayer->dword_0000A0 = 0;
|
|
|
589 memset(pVideoPlayer->pCurrentMovieName, 0, 0x40);
|
|
|
590 if ( pAudioPlayer->hAILRedbook && !bGameoverLoop )
|
|
|
591 AIL_redbook_resume(pAudioPlayer->hAILRedbook);
|
|
|
592 pEventTimer->Resume();
|
|
|
593 }
|
|
|
594
|
|
|
595 //----- (004BECD5) --------------------------------------------------------
|
|
|
596 void VideoPlayer::FastForwardToFrame(unsigned int uDstFrameNum)
|
|
|
597 {
|
|
|
598 VideoPlayer *v2; // esi@1
|
|
|
599 unsigned int v3; // eax@1
|
|
|
600
|
|
|
601 v2 = this;
|
|
|
602 v3 = this->uMovieFormat;
|
|
|
603 if ( v3 == 2 )
|
|
|
604 {
|
|
|
605 if (uDstFrameNum)
|
|
|
606 {
|
|
|
607 int *pCurrentFrame = uBinkVersion == 0x0001000500150000 ? &((_BINK_1_5_21_0 *)pBinkMovie)->uCurrentFrame :
|
|
|
608 uBinkVersion == 0x0003000000000000 ? &((_BINK_3_0_0_0 *)pBinkMovie)->uCurrentFrame :
|
|
|
609 nullptr;
|
|
|
610 while (*pCurrentFrame < uDstFrameNum)
|
|
|
611 {
|
|
|
612 BinkDoFrame(pBinkMovie);
|
|
|
613 BinkNextFrame(pBinkMovie);
|
|
|
614 }
|
|
|
615 }
|
|
|
616 }
|
|
|
617 else
|
|
|
618 {
|
|
|
619 if ( v3 != 1 )
|
|
|
620 return;
|
|
|
621 SmackSoundOnOff(this->pSmackerMovie, 0);
|
|
|
622 if (uDstFrameNum)
|
|
|
623 {
|
|
|
624 while ( v2->pSmackerMovie->FrameNum < uDstFrameNum)
|
|
|
625 {
|
|
|
626 SmackDoFrame(v2->pSmackerMovie);
|
|
|
627 SmackNextFrame(v2->pSmackerMovie);
|
|
|
628 }
|
|
|
629 }
|
|
|
630 }
|
|
|
631 Unload();
|
|
|
632 }
|
|
|
633
|
|
|
634
|
|
|
635 //----- (004BED4F) --------------------------------------------------------
|
|
|
636 void VideoPlayer::BinkDrawFrame(HWND hWnd, int a3, int a4)
|
|
|
637 {
|
|
|
638 //VideoPlayer *v4; // esi@1
|
|
|
639 _BINKBUF *v5; // eax@5
|
|
|
640 LONG v6; // edx@6
|
|
|
641 int v7; // ecx@6
|
|
|
642 LONG v8; // edx@6
|
|
|
643 struct tagRECT a3a; // [sp+8h] [bp-20h]@10
|
|
|
644 struct tagRECT a1; // [sp+18h] [bp-10h]@6
|
|
|
645
|
|
|
646 //v4 = this;
|
|
|
647 if ( this->pBinkMovie && this->pBinkBuffer )
|
|
|
648 {
|
|
|
649 BinkDoFrame(pBinkMovie);
|
|
|
650 BinkGetRects(pBinkMovie, pBinkBuffer->uBinkDDSurfaceType);
|
|
|
651 if ( BinkLockBuffer(pBinkBuffer) )
|
|
|
652 {
|
|
|
653 BinkCopyToBuffer(pBinkMovie, pBinkBuffer->pDDrawSurfaceData, pBinkBuffer->uDDrawSurfacePitch, pBinkBuffer->uHeight,
|
|
|
654 0, 0, pBinkBuffer->uBinkDDSurfaceType);
|
|
|
655 BinkUnlockBuffer(pBinkBuffer);
|
|
|
656 }
|
|
|
657 v5 = pBinkBuffer;
|
|
|
658 if ( pRenderer->bWindowMode )
|
|
|
659 {
|
|
|
660 v6 = v5->uRectX;
|
|
|
661 a1.left = v6;
|
|
|
662 a1.top = v5->uRectY;
|
|
|
663 v7 = v6 + v5->uWidth;
|
|
|
664 a1.right = v6 + v5->uWidth;
|
|
|
665 v8 = a1.top + v5->uHeight;
|
|
|
666 }
|
|
|
667 else
|
|
|
668 {
|
|
|
669 a1.left = 0;
|
|
|
670 a1.top = 0;
|
|
|
671 v7 = v5->uWidth;
|
|
|
672 a1.right = v5->uWidth;
|
|
|
673 v8 = v5->uHeight;
|
|
|
674 }
|
|
|
675 a1.bottom = v8;
|
|
|
676 if ( a4 )
|
|
|
677 {
|
|
|
678 a1.right = v5->uWidth + v7;
|
|
|
679 a1.bottom = v5->uHeight + v8;
|
|
|
680 }
|
|
|
681 a3a.left = 0;
|
|
|
682 a3a.top = 0;
|
|
|
683 a3a.right = v5->uWidth;
|
|
|
684 a3a.bottom = v5->uHeight;
|
|
|
685 pRenderer->BltToFront(&a1, v5->pTargetDDrawSurface, &a3a, 0x1000000u);
|
|
|
686
|
|
|
687
|
|
|
688 int *pCurrentFrame = uBinkVersion == 0x0001000500150000 ? &((_BINK_1_5_21_0 *)pBinkMovie)->uCurrentFrame :
|
|
|
689 uBinkVersion == 0x0003000000000000 ? &((_BINK_3_0_0_0 *)pBinkMovie)->uCurrentFrame:
|
|
|
690 nullptr;
|
|
|
691 int *pNumFrames = uBinkVersion == 0x0001000500150000 ? &((_BINK_1_5_21_0 *)pBinkMovie)->uNumFrames :
|
|
|
692 uBinkVersion == 0x0003000000000000 ? &((_BINK_3_0_0_0 *)pBinkMovie)->uNumFrames :
|
|
|
693 nullptr;
|
|
|
694
|
|
|
695 if (*pCurrentFrame != *pNumFrames - 1 || bLoopPlaying)
|
|
|
696 BinkNextFrame(pBinkMovie);
|
|
|
697 else
|
|
|
698 Unload();
|
|
|
699 }
|
|
|
700 }
|
|
|
701
|
|
|
702
|
|
|
703
|
|
|
704 //----- (004BEE6B) --------------------------------------------------------
|
|
|
705 void VideoPlayer::SmackDrawFrame(HWND hWnd, int a3, int a4)
|
|
|
706 {
|
|
|
707 VideoPlayer *v4; // esi@1
|
|
|
708 _SMACK *v5; // eax@3
|
|
|
709 unsigned int v6; // eax@5
|
|
|
710 char v7; // zf@5
|
|
|
711 int v8; // eax@11
|
|
|
712 _SMACK *v9; // eax@13
|
|
|
713 _SMACK *v10; // eax@16
|
|
|
714 _SMACK *v11; // eax@20
|
|
|
715 unsigned int v12; // [sp-1Ch] [bp-34h]@7
|
|
|
716 LONG v13; // [sp-18h] [bp-30h]@7
|
|
|
717 LONG v14; // [sp-14h] [bp-2Ch]@7
|
|
|
718 signed int v15; // [sp-10h] [bp-28h]@7
|
|
|
719 signed int v16; // [sp-Ch] [bp-24h]@7
|
|
|
720 signed int v17; // [sp-8h] [bp-20h]@7
|
|
|
721 struct tagPOINT Point; // [sp+8h] [bp-10h]@7
|
|
|
722 unsigned short *pOutSurface; // [sp+10h] [bp-8h]@5
|
|
|
723 unsigned int uPixelsPerRow; // [sp+14h] [bp-4h]@5
|
|
|
724
|
|
|
725 v4 = this;
|
|
|
726 if ( !pRenderer->bWindowMode || GetFocus() == hWnd )
|
|
|
727 {
|
|
|
728 v5 = v4->pSmackerMovie;
|
|
|
729 if ( v5->NewPalette )
|
|
|
730 SmackBlitSetPalette(v4->pSmackMovieBlit, v5->Palette, v5->PalType);
|
|
|
731 SmackDoFrame(v4->pSmackerMovie);
|
|
|
732 pRenderer->LockFrontBuffer((void **)&pOutSurface, &uPixelsPerRow);
|
|
|
733 v6 = 2 * uPixelsPerRow;
|
|
|
734 v7 = v4->bFirstFrame == 0;
|
|
|
735 uPixelsPerRow *= 2;
|
|
|
736 if ( !v7 )
|
|
|
737 {
|
|
|
738 if ( pRenderer->bWindowMode )
|
|
|
739 {
|
|
|
740 Point.y = 0;
|
|
|
741 Point.x = 0;
|
|
|
742 ClientToScreen(hWnd, &Point);
|
|
|
743 v17 = -1;
|
|
|
744 v16 = 480;
|
|
|
745 v15 = 640;
|
|
|
746 v14 = Point.y;
|
|
|
747 v13 = Point.x;
|
|
|
748 v12 = uPixelsPerRow;
|
|
|
749 }
|
|
|
750 else
|
|
|
751 {
|
|
|
752 v17 = -1;
|
|
|
753 v16 = 480;
|
|
|
754 v15 = 640;
|
|
|
755 v14 = 0;
|
|
|
756 v13 = 0;
|
|
|
757 v12 = v6;
|
|
|
758 }
|
|
|
759 SmackBlitClear(v4->pSmackMovieBlit, pOutSurface, v12, v13, v14, v15, v16, v17);
|
|
|
760 v4->bFirstFrame = 0;
|
|
|
761 }
|
|
|
762 pRenderer->RestoreFrontBuffer();
|
|
|
763 if ( pRenderer->bWindowMode )
|
|
|
764 {
|
|
|
765 Point.y = 0;
|
|
|
766 Point.x = 0;
|
|
|
767 ClientToScreen(hWnd, &Point);
|
|
|
768 v8 = SmackToBufferRect(v4->pSmackerMovie, 0);
|
|
|
769 if ( a4 )
|
|
|
770 {
|
|
|
771 while ( v8 )
|
|
|
772 {
|
|
|
773 v9 = v4->pSmackerMovie;
|
|
|
774 SmackBlit(
|
|
|
775 v4->pSmackMovieBlit,
|
|
|
776 pOutSurface,
|
|
|
777 uPixelsPerRow,
|
|
|
778 v9->LastRectx + Point.x / 2,
|
|
|
779 a3 + v9->LastRecty + Point.y / 2,
|
|
|
780 v4->pSomeSmackerBuffer,
|
|
|
781 v9->Width,
|
|
|
782 v9->LastRectx,
|
|
|
783 v9->LastRecty,
|
|
|
784 v9->LastRectw,
|
|
|
785 v9->LastRecth);
|
|
|
786 v8 = SmackToBufferRect(v4->pSmackerMovie, 0);
|
|
|
787 }
|
|
|
788 }
|
|
|
789 else
|
|
|
790 {
|
|
|
791 while ( v8 )
|
|
|
792 {
|
|
|
793 v10 = v4->pSmackerMovie;
|
|
|
794 SmackBlit(v4->pSmackMovieBlit, pOutSurface, uPixelsPerRow, Point.x + v10->LastRectx, a3 + Point.y + v10->LastRecty,
|
|
|
795 v4->pSomeSmackerBuffer, v10->Width, v10->LastRectx, v10->LastRecty, v10->LastRectw, v10->LastRecth);
|
|
|
796 v8 = SmackToBufferRect(v4->pSmackerMovie, 0);
|
|
|
797 }
|
|
|
798 }
|
|
|
799 }
|
|
|
800 else
|
|
|
801 {
|
|
|
802 while ( SmackToBufferRect(v4->pSmackerMovie, 0) )
|
|
|
803 {
|
|
|
804 v11 = v4->pSmackerMovie;
|
|
|
805 SmackBlit(v4->pSmackMovieBlit, pOutSurface, uPixelsPerRow, v11->LastRectx, a3 + v11->LastRecty, v4->pSomeSmackerBuffer,
|
|
|
806 v11->Width, v11->LastRectx, v11->LastRecty, v11->LastRectw, v11->LastRecth);
|
|
|
807 }
|
|
|
808 }
|
|
|
809 pRenderer->UnlockFrontBuffer();
|
|
|
810 if ( v4->pSmackerMovie->FrameNum != v4->pSmackerMovie->Frames - 1 || v4->bLoopPlaying )
|
|
|
811 SmackNextFrame(v4->pSmackerMovie);
|
|
|
812 else
|
|
|
813 Unload();
|
|
|
814 }
|
|
|
815 }
|
|
|
816 // 4D83D8: using guessed type int __stdcall SmackBlitSetPalette(int, int, int);
|
|
|
817 // 4D83DC: using guessed type int __stdcall SmackBlitClear(int, int, int, int, int, int, int, int);
|
|
|
818 // 4D83E0: using guessed type int __stdcall SmackToBufferRect(int, int);
|
|
|
819 // 4D83E4: using guessed type int __stdcall SmackDoFrame(int);
|
|
|
820 // 4D83E8: using guessed type int __stdcall SmackNextFrame(int);
|
|
|
821 // 4D8404: using guessed type int __stdcall SmackBlit(int, int, int, int, int, int, int, int, int, int, int);
|
|
|
822
|
|
|
823 //----- (004BF08B) --------------------------------------------------------
|
|
|
824 void VideoPlayer::SmackUpdatePalette(HWND hWnd)
|
|
|
825 {
|
|
|
826 VideoPlayer *v2; // esi@1
|
|
|
827 unsigned __int16 *v3; // ebx@1
|
|
|
828 unsigned int v4; // edi@1
|
|
|
829 unsigned int v5; // eax@1
|
|
|
830 _SMACK *v6; // eax@1
|
|
|
831
|
|
|
832 v2 = this;
|
|
|
833 pRenderer->BeginScene();
|
|
|
834 v3 = pRenderer->pTargetSurface;
|
|
|
835 v4 = pRenderer->uTargetSurfacePitch;
|
|
|
836 v5 = SmackCheckSurfaceFromat();
|
|
|
837 SmackToBuffer(v2->pSmackerMovie, 8, 8, 2 * v4, pRenderer->field_14, v3, v5);
|
|
|
838 v6 = v2->pSmackerMovie;
|
|
|
839 if ( v6->NewPalette )
|
|
|
840 {
|
|
|
841 SmackBufferNewPalette((long)pSmackerBuffer, (long)v6->Palette, LOWORD(v6->PalType));
|
|
|
842 SmackColorRemapWithTrans(
|
|
|
843 (long)pSmackerMovie,
|
|
|
844 (long)pSmackerBuffer->Palette,
|
|
|
845 (long)pSmackerBuffer->MaxPalColors,
|
|
|
846 (long)pSmackerBuffer->PalType,
|
|
|
847 1000);
|
|
|
848 }
|
|
|
849 SmackDoFrame(v2->pSmackerMovie);
|
|
|
850 if ( v2->pSmackerMovie->FrameNum != v2->pSmackerMovie->Frames - 1 || v2->bLoopPlaying )
|
|
|
851 SmackNextFrame(v2->pSmackerMovie);
|
|
|
852 else
|
|
|
853 Unload();
|
|
|
854 pRenderer->EndScene();
|
|
|
855 }
|
|
|
856
|
|
|
857
|
|
|
858
|
|
|
859
|
|
|
860
|
|
|
861 //----- (004BF141) --------------------------------------------------------
|
|
|
862 _BINK *VideoPlayer::OpenBink(const char *pName)
|
|
|
863 {
|
|
|
864 //VideoPlayer *v2; // esi@1
|
|
|
865 signed int v3; // edi@1
|
|
|
866 int v4; // ebx@2
|
|
|
867 signed int v5; // edi@5
|
|
|
868 int v6; // ebx@6
|
|
|
869 HANDLE v8; // [sp-8h] [bp-18h]@10
|
|
|
870 unsigned int v9; // [sp-4h] [bp-14h]@10
|
|
|
871
|
|
|
872 for (uint i = 0; i < uNumMightVideoHeaders; ++i)
|
|
|
873 if (!strcmpi(pName, pMightVideoHeaders[i].pVideoName))
|
|
|
874 {
|
|
|
875 SetFilePointer(hMightVid, pMightVideoHeaders[i].uFileOffset, 0, FILE_BEGIN);
|
|
|
876
|
|
|
877 if (uBinkVersion < 0x0003000000000000)
|
|
|
878 return BinkOpen(hMightVid, 0x8800000);
|
|
|
879 else
|
|
|
880 return BinkOpen(hMightVid, 0x82000000);
|
|
|
881 }
|
|
|
882
|
|
|
883 for (uint i = 0; i < uNumMagicVideoHeaders; ++i)
|
|
|
884 if (!strcmpi(pName, pMagicVideoHeaders[i].pVideoName))
|
|
|
885 {
|
|
|
886 SetFilePointer(hMagicVid, pMagicVideoHeaders[i].uFileOffset, 0, FILE_BEGIN);
|
|
|
887
|
|
|
888 if (uBinkVersion < 0x0003000000000000)
|
|
|
889 return BinkOpen(hMagicVid, 0x8800000);
|
|
|
890 else
|
|
|
891 return BinkOpen(hMagicVid, 0x82000000);
|
|
|
892 }
|
|
|
893
|
|
|
894 return nullptr;
|
|
|
895 }
|
|
|
896 //----- (004BF1E6) --------------------------------------------------------
|
|
|
897 _SMACK *VideoPlayer::OpenSmack(const char *pFilename)
|
|
|
898 {
|
|
|
899 VideoPlayer *pVideoPlayer; // esi@1
|
|
|
900 signed int v3; // edi@1
|
|
|
901 int v4; // ebx@2
|
|
|
902 signed int v5; // edi@5
|
|
|
903 //int v6; // ebx@6
|
|
|
904 //HANDLE v8; // [sp-Ch] [bp-1Ch]@10
|
|
|
905 //unsigned int v9; // [sp-8h] [bp-18h]@10
|
|
|
906 //signed int v10; // [sp-4h] [bp-14h]@10
|
|
|
907
|
|
|
908 pVideoPlayer = this;
|
|
|
909 if ( (signed int)this->uNumMightVideoHeaders > 0 )
|
|
|
910 {
|
|
|
911 for ( v3 = 0; v3 < (signed int)pVideoPlayer->uNumMightVideoHeaders; ++v3)
|
|
|
912 {
|
|
|
913 v4 = _strcmpi(pVideoPlayer->pMightVideoHeaders[v3].pVideoName, pFilename);
|
|
|
914 if ( !v4 )
|
|
|
915 {
|
|
|
916 SetFilePointer(pVideoPlayer->hMightVid, pVideoPlayer->pMightVideoHeaders[v3].uFileOffset, 0, 0);
|
|
898
|
917 return SmackOpen(pVideoPlayer->hMightVid, 0x7140, -1);//problem training house video in WinXP
|
|
0
|
918 }
|
|
|
919 }
|
|
|
920 }
|
|
|
921 v5 = 0;
|
|
|
922 if ( (signed int)pVideoPlayer->uNumMagicVideoHeaders > 0 )
|
|
|
923 {
|
|
|
924 while ( _strcmpi(pVideoPlayer->pMagicVideoHeaders[v5].pVideoName, pFilename) )
|
|
|
925 {
|
|
|
926 ++v5;
|
|
|
927 if ( v5 >= (signed int)pVideoPlayer->uNumMagicVideoHeaders )
|
|
|
928 return 0;
|
|
|
929 }
|
|
|
930 SetFilePointer(pVideoPlayer->hMagicVid, pVideoPlayer->pMagicVideoHeaders[v5].uFileOffset, 0, 0);
|
|
|
931 return SmackOpen(pVideoPlayer->hMagicVid, 0x7140, -1);
|
|
|
932 }
|
|
|
933 return 0;
|
|
|
934 }
|
|
|
935
|
|
|
936 //----- (004BF28F) --------------------------------------------------------
|
|
898
|
937 void VideoPlayer::OpenHouseMovie(const char *pMovieName, unsigned int a3_1)
|
|
0
|
938 {
|
|
|
939 VideoPlayer *v3; // esi@1
|
|
|
940 std::string *v4; // ecx@3
|
|
|
941 _SMACK *v5; // eax@4
|
|
|
942 _SMACK *v6; // eax@7
|
|
|
943 int v7; // eax@7
|
|
|
944 int v8; // ecx@7
|
|
|
945 unsigned int v9; // ebx@8
|
|
|
946 unsigned int v10; // eax@8
|
|
|
947 signed __int64 v11; // qax@9
|
|
|
948 char *v12; // [sp-20h] [bp-54h]@3
|
|
|
949 int v13; // [sp-1Ch] [bp-50h]@3
|
|
|
950 std::string v14; // [sp-18h] [bp-4Ch]@3
|
|
|
951 const char *v15; // [sp-8h] [bp-3Ch]@3
|
|
|
952 int v16; // [sp-4h] [bp-38h]@3
|
|
|
953 char Str2[0x30]; // [sp+Ch] [bp-28h]@4
|
|
|
954 std::string *v18; // [sp+3Ch] [bp+8h]@3
|
|
|
955 std::string *v19; // [sp+3Ch] [bp+8h]@5
|
|
|
956 unsigned __int16 *v20; // [sp+3Ch] [bp+8h]@8
|
|
|
957
|
|
|
958 v3 = this;
|
|
|
959 if ( !this->field_54 )
|
|
|
960 {
|
|
|
961 Prepare();
|
|
|
962 v3->bLoopPlaying = a3_1;
|
|
323
|
963 if ( LOBYTE(v3->field_104) == 1 )
|
|
0
|
964 {
|
|
|
965 v15 = "E:\\WORK\\MSDEV\\MM7\\MM7\\Code\\Video.cpp:925";
|
|
|
966 v12 = "Unsupported Bink playback!";
|
|
898
|
967 MessageBoxA(nullptr, v12, v15, 0);
|
|
0
|
968 return;
|
|
|
969 }
|
|
898
|
970 sprintfex(Str2, "%s.smk", pMovieName);
|
|
0
|
971 v5 = OpenSmack(Str2);
|
|
|
972 v3->pSmackerMovie = v5;
|
|
|
973 if ( !v5 )
|
|
|
974 {
|
|
|
975 v3->Unload();
|
|
|
976 sprintf(pTmpBuf, "Can't load %s", &Str2);
|
|
|
977 v15 = "E:\\WORK\\MSDEV\\MM7\\MM7\\Code\\Video.cpp:937";
|
|
898
|
978 MessageBoxA(nullptr, pTmpBuf, v15, 0);
|
|
|
979 return;
|
|
0
|
980 }
|
|
|
981 v16 = (int)pMovieName;
|
|
|
982 v3->uMovieFormat = 1;
|
|
|
983 strcpy(v3->pCurrentMovieName, (const char *)v16);
|
|
|
984 v6 = v3->pSmackerMovie;
|
|
|
985 v3->dword_0000A0 = 1;
|
|
|
986 v7 = SmackBufferOpen(v3->hWindow, 4, LOWORD(v6->Width), LOWORD(v6->Height), LOWORD(v6->Width), LOWORD(v6->Height));
|
|
|
987 v3->pSmackerBuffer = (_SMACKBUF *)v7;
|
|
|
988 if ( v7 )
|
|
|
989 {
|
|
|
990 pRenderer->BeginScene();
|
|
|
991 v9 = pRenderer->uTargetSurfacePitch;
|
|
|
992 v20 = pRenderer->pTargetSurface;
|
|
|
993 v10 = SmackCheckSurfaceFromat();
|
|
|
994 SmackToBuffer(v3->pSmackerMovie, 8, 8, 2 * v9, pRenderer->field_14, v20, v10);
|
|
|
995 pRenderer->EndScene();
|
|
|
996 }
|
|
|
997 v16 = 32767;
|
|
|
998 v11 = (signed __int64)(pSoundVolumeLevels[(char)uSoundVolumeMultiplier] * 32767.0);
|
|
347
|
999 SmackVolumePan(v3->pSmackerMovie, 1040384, v11, 32767);
|
|
0
|
1000 }
|
|
|
1001 }
|
|
|
1002
|
|
|
1003 //----- (004BF3F9) --------------------------------------------------------
|
|
|
1004 bool VideoPlayer::AnyMovieLoaded()
|
|
|
1005 {
|
|
|
1006 return pSmackerMovie || pBinkMovie;
|
|
|
1007 }
|
|
|
1008
|
|
|
1009 //----- (004BF411) --------------------------------------------------------
|
|
898
|
1010 void VideoPlayer::OpenGlobalMovie(const char *pFilename, unsigned int bLoop, int a4)
|
|
0
|
1011 {
|
|
|
1012 VideoPlayer *pVideoPlayer; // esi@1
|
|
|
1013 _BINK *pVideoOpen; // eax@2
|
|
|
1014 _SMACK *v6; // eax@3
|
|
|
1015 _BINK *pBinkMovie; // eax@5
|
|
|
1016 _SMACK *v8; // eax@7
|
|
|
1017 char *v9; // eax@7
|
|
|
1018 unsigned int v10; // eax@11
|
|
|
1019 _SMACKBLIT *v11; // eax@14
|
|
|
1020 const char *v12; // [sp-4h] [bp-38h]@8
|
|
|
1021 char pVideoName[120]; // [sp+Ch] [bp-28h]@2
|
|
|
1022
|
|
|
1023 pVideoPlayer = this;
|
|
|
1024 if ( !this->field_54 )
|
|
|
1025 {
|
|
|
1026 Prepare();
|
|
|
1027 pVideoPlayer->bLoopPlaying = bLoop;
|
|
|
1028 sprintf(pVideoName, "%s.bik", pFilename);
|
|
|
1029 pVideoOpen = OpenBink(pVideoName);
|
|
|
1030 pVideoPlayer->pBinkMovie = pVideoOpen;
|
|
|
1031 if ( pVideoOpen )
|
|
|
1032 {
|
|
|
1033 pVideoPlayer->uMovieFormat = 2;
|
|
|
1034 strcpy(pVideoPlayer->pCurrentMovieName, pFilename);
|
|
|
1035 pBinkMovie = pVideoPlayer->pBinkMovie;
|
|
|
1036 pVideoPlayer->dword_0000A0 = 1;
|
|
|
1037 if ( pBinkMovie )
|
|
|
1038 pVideoPlayer->pBinkBuffer = CreateBinkBuffer(pVideoPlayer->hWindow, pBinkMovie->uWidth, pBinkMovie->uHeight, 0);
|
|
|
1039 }
|
|
|
1040 else
|
|
|
1041 {
|
|
|
1042 Unload();
|
|
898
|
1043 sprintfex(pVideoName, "%s.smk", pFilename);
|
|
0
|
1044 v6 = OpenSmack(pVideoName);
|
|
|
1045 pVideoPlayer->pSmackerMovie = v6;
|
|
|
1046 if ( !v6 )
|
|
|
1047 {
|
|
|
1048 Unload();
|
|
|
1049 sprintf(pVideoName, "Can't load file - anims\\%s.smk", pFilename);
|
|
|
1050 MessageBoxA(0, pVideoName, "Smacker Error", 0);
|
|
|
1051 return;
|
|
|
1052 }
|
|
|
1053 pVideoPlayer->uMovieFormat = 1;
|
|
|
1054 strcpy(pVideoPlayer->pCurrentMovieName, pFilename);
|
|
|
1055 v8 = pVideoPlayer->pSmackerMovie;
|
|
|
1056 pVideoPlayer->dword_0000A0 = 2;
|
|
|
1057 v9 = (char *)malloc(v8->Width * v8->Height);
|
|
|
1058 pVideoPlayer->pSomeSmackerBuffer = v9;
|
|
|
1059 if ( !v9 )
|
|
|
1060 {
|
|
|
1061 Unload();
|
|
|
1062 v12 = "Can't allocate memory for buffer";
|
|
|
1063 sprintf(pVideoName, v12);
|
|
|
1064 MessageBoxA(0, pVideoName, "Smacker Error", 0);
|
|
|
1065 return;
|
|
|
1066 }
|
|
|
1067 SmackToBuffer(pVideoPlayer->pSmackerMovie, 0, 0, pVideoPlayer->pSmackerMovie->Width, pVideoPlayer->pSmackerMovie->Height, v9, 0);
|
|
|
1068 if ( a4 )
|
|
|
1069 {
|
|
|
1070 if ( (unsigned int)uCPUSpeed < 165 )
|
|
|
1071 {
|
|
731
|
1072 Log::Warning(L"Smacker seems to use lower resolution because it thinks CPU is slow");
|
|
0
|
1073 v10 = SmackCheckSurfaceFromat() | 2;
|
|
|
1074 }
|
|
|
1075 else
|
|
|
1076 {
|
|
|
1077 v10 = SmackCheckSurfaceFromat();
|
|
|
1078 LOBYTE(v10) = v10 | 6;
|
|
|
1079 }
|
|
|
1080 }
|
|
|
1081 else
|
|
|
1082 {
|
|
|
1083 v10 = SmackCheckSurfaceFromat();
|
|
|
1084 }
|
|
|
1085 v11 = SmackBlitOpen(v10);
|
|
|
1086 pVideoPlayer->pSmackMovieBlit = v11;
|
|
|
1087 if ( !v11 )
|
|
|
1088 {
|
|
|
1089 Unload();
|
|
|
1090 v12 = "Failed to open Blit API";
|
|
|
1091 sprintf(pVideoName, v12);
|
|
|
1092 MessageBoxA(0, pVideoName, "Smacker Error", 0);
|
|
|
1093 return;
|
|
|
1094 }
|
|
|
1095 }
|
|
|
1096 }
|
|
|
1097 }
|
|
|
1098
|
|
|
1099
|
|
|
1100 //----- (004BF5B2) --------------------------------------------------------
|
|
|
1101 void VideoPlayer::_4BF5B2()
|
|
|
1102 {
|
|
|
1103 VideoPlayer *v1; // esi@1
|
|
|
1104 unsigned int v2; // eax@1
|
|
|
1105 _BINK **v3; // edi@2
|
|
|
1106
|
|
|
1107 v1 = this;
|
|
|
1108 v2 = this->uMovieFormat;
|
|
|
1109 if ( v2 == 2 )
|
|
|
1110 {
|
|
|
1111 v3 = &this->pBinkMovie;
|
|
|
1112 BinkGoto(pBinkMovie, 1, 0);
|
|
|
1113 BinkDoFrame(pBinkMovie);
|
|
|
1114 BinkNextFrame(pBinkMovie);
|
|
|
1115 }
|
|
|
1116 else
|
|
|
1117 {
|
|
|
1118 if ( v2 != 1 )
|
|
|
1119 return;
|
|
|
1120 SmackGoto(pSmackerMovie, 1);
|
|
|
1121 if ( pVersion->pVersionInfo.dwPlatformId != VER_PLATFORM_WIN32_NT || pVersion->pVersionInfo.dwMajorVersion != 4 )
|
|
|
1122 {
|
|
|
1123 SmackDoFrame(pSmackerMovie);
|
|
|
1124 SmackNextFrame(pSmackerMovie);
|
|
|
1125 }
|
|
|
1126 }
|
|
|
1127 pMouse->_469E24();
|
|
336
|
1128 if ( window_SpeakInHouse && window_SpeakInHouse->ptr_1C == (void *)165 && !v1->pSmackerMovie )
|
|
0
|
1129 {
|
|
|
1130 bGameoverLoop = 1;
|
|
|
1131 sub_4BD8B5();
|
|
336
|
1132 window_SpeakInHouse->Release();
|
|
0
|
1133 pParty->uFlags &= 0xFFFFFFFDu;
|
|
481
|
1134 if ( EnterHouse(HOUSE_BODY_GUILD_ERATHIA) )
|
|
0
|
1135 {
|
|
388
|
1136 pAudioPlayer->PlaySound(SOUND_Invalid, 0, 0, -1, 0, 0, 0, 0);
|
|
336
|
1137 window_SpeakInHouse = GUIWindow::Create(0, 0, 640, 480, WINDOW_HouseInterior, 165, 0);
|
|
832
|
1138 window_SpeakInHouse->CreateButton(0x3Du, 0x1A8u, 0x1Fu, 0, 2, 94, UIMSG_SelectCharacter, 1u, 0x31u, "", 0);
|
|
|
1139 window_SpeakInHouse->CreateButton(0xB1u, 0x1A8u, 0x1Fu, 0, 2, 94, UIMSG_SelectCharacter, 2u, 0x32u, "", 0);
|
|
|
1140 window_SpeakInHouse->CreateButton(0x124u, 0x1A8u, 0x1Fu, 0, 2, 94, UIMSG_SelectCharacter, 3u, 0x33u, "", 0);
|
|
|
1141 window_SpeakInHouse->CreateButton(0x197u, 0x1A8u, 0x1Fu, 0, 2, 94, UIMSG_SelectCharacter, 4u, 0x34u, "", 0);
|
|
0
|
1142 }
|
|
|
1143 bGameoverLoop = 0;
|
|
|
1144 }
|
|
|
1145 }
|
|
|
1146
|
|
|
1147 //----- (004BF73A) --------------------------------------------------------
|
|
898
|
1148 void VideoPlayer::SelectMovieType()
|
|
0
|
1149 {
|
|
|
1150 VideoPlayer *v1; // esi@1
|
|
|
1151 int v2; // edi@1
|
|
|
1152 unsigned __int8 v3; // bl@1
|
|
|
1153 int v4; // edi@1
|
|
|
1154 char Source[32]; // [sp+Ch] [bp-40h]@1
|
|
|
1155
|
|
|
1156 v1 = this;
|
|
|
1157 v2 = this->dword_0000A0;
|
|
|
1158 v3 = LOBYTE(this->bLoopPlaying);
|
|
|
1159 strcpy(Source, this->pCurrentMovieName);
|
|
|
1160 Unload();
|
|
|
1161 v4 = v2 - 1;
|
|
|
1162 if ( v4 )
|
|
|
1163 {
|
|
|
1164 if ( v4 == 1 )
|
|
898
|
1165 OpenGlobalMovie(Source, v3, 1);
|
|
0
|
1166 }
|
|
|
1167 else
|
|
|
1168 {
|
|
898
|
1169 OpenHouseMovie(Source, v3);
|
|
0
|
1170 }
|
|
|
1171 }
|
|
|
1172
|
|
|
1173 //----- (004BF8F6) --------------------------------------------------------
|
|
|
1174 void VideoPlayer::PlayDeathMovie()
|
|
|
1175 {
|
|
|
1176 bStopBeforeSchedule = 0;
|
|
165
|
1177 pResetflag = 0;
|
|
0
|
1178 pGame->pCShow->PlayMovie(MOVIE_Death, 1);
|
|
|
1179 } |
