datalore/CnC_Red_Alert
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
main
CnC_Red_Alert/WINVQ/VQAVIEW/MOVIES.CPP

740 lines
24 KiB
C++
Raw Permalink Normal View History

Initial commit of Command & Conquer Red Alert source code.
2025-02-27 17:15:05 +01:00
/*
** Command & Conquer Red Alert(tm)
** Copyright 2025 Electronic Arts Inc.
**
** 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/>.
*/
/***************************************************************************
** C O N F I D E N T I A L --- W E S T W O O D S T U D I O S **
***************************************************************************
* *
* Project Name : VQAVIEW *
* *
* File Name : MOVIES.CPP *
* *
* Programmer : Michael Grayford *
* *
* Start Date : *
* *
* Last Update : Nov 29, 1995 [MG] *
* *
*-------------------------------------------------------------------------*
* Functions: *
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
//==========================================================================
// INCLUDES
//==========================================================================
#include <windows.h>
#include <westwood.h>
#include <vq.h>
#include <movies.h>
#include <mainwind.h>
#include <main.h>
#include <pal.h>
//==========================================================================
// PRIVATE FUNCTIONS
//==========================================================================
void VQA_Test( char *filename );
void Create_Palette_Interpolation_Table( void );
void Interpolate_2X_Scale( GraphicBufferClass *source, GraphicBufferClass *dest );
//==========================================================================
// PRIVATE GLOBALS
//==========================================================================
extern "C"{
extern unsigned char *InterpolationPalette;
extern unsigned char Palette_Interpolation_Table[SIZE_OF_PALETTE][SIZE_OF_PALETTE];
extern void __cdecl Asm_Create_Palette_Interpolation_Table(void);
extern void __cdecl Asm_Interpolate (unsigned char* src_ptr ,
unsigned char* dest_ptr ,
int lines ,
int src_width ,
int dest_width);
}
unsigned char Palette_Interpolation_Table[ SIZE_OF_PALETTE ][ SIZE_OF_PALETTE ];
unsigned char *InterpolationPalette;
VQAClass *TestVqa;
#if( ! DRAW_TO_VIDEO )
GraphicBufferClass *Draw_Page = NULL;
GraphicBufferClass *Back_Page = NULL;
GraphicBufferClass *Hid_Page = NULL;
#endif
/***************************************************************************
* Initialize_Movie_System - Allocate memory needed for caching and any *
* permanent Movie data. *
* *
* INPUT: NONE *
* *
* OUTPUT: int - an error value *
* *
* WARNINGS: Yellow alert! *
* *
* HISTORY: *
* 09/29/1995 MG : Created. *
*=========================================================================*/
int Initialize_Movie_System( void )
{
#if( ! DRAW_TO_VIDEO )
//
// Set up the graphic pages:
// Draw_Page - the page that the VQA library draws to. (Normal RAM)
// Back_Page - the page that the drawn image is scaled to. (Normal RAM)
// Hid_Page - the page in video RAM that the scaled image is copied to before copy to screen.
//
Draw_Page = new GraphicBufferClass ( MOVIE_WIDTH, MOVIE_HEIGHT );
Back_Page = new GraphicBufferClass ( VIDEO_MODE_WIDTH, VIDEO_MODE_HEIGHT );
Hid_Page = new GraphicBufferClass ( VIDEO_MODE_WIDTH, VIDEO_MODE_HEIGHT, (GBC_Enum)(GBC_VIDEOMEM) );
#endif
//
// Okay, we're cool.
//
return( VQA_INIT_NO_ERROR );
}
/***************************************************************************
* Free_Movie_System - Free up memory used by Movie cache system and any *
* permanent Movie data. *
* *
* INPUT: NONE *
* *
* OUTPUT: NONE *
* *
* WARNINGS: Red alert! *
* *
* HISTORY: *
* 09/29/1995 MG : Created. *
*=========================================================================*/
void Free_Movie_System( void )
{
#if( ! DRAW_TO_VIDEO )
if ( Draw_Page ) {
delete( Draw_Page );
}
if ( Back_Page ) {
delete( Back_Page );
}
if ( Hid_Page ) {
delete( Hid_Page );
}
Draw_Page = NULL;
Back_Page = NULL;
Hid_Page = NULL;
#endif
return;
}
/***************************************************************************
* Choose_Movie - Brings up choice of VQA files. *
* *
* INPUT: NONE *
* *
* OUTPUT: NONE *
* *
* WARNINGS: *
* *
* HISTORY: *
* 05/15/1995 MG : Created. *
*=========================================================================*/
void Choose_Movie( WindowHandle window_handle )
{
int i;
char temp_file[_MAX_FNAME + _MAX_EXT];
static OPENFILENAME open_file_dlg;
static char path_filename[ _MAX_PATH*500 ];
static char filename[ _MAX_FNAME + _MAX_EXT ];
static char *filters[] = {
"VQA files (*.VQA)", "*.vqa",
"All Files", "*.*",
"" } ;
filename[0]=0;
memset (&path_filename[0],0,_MAX_PATH*500);
open_file_dlg.lStructSize = sizeof( OPENFILENAME );
open_file_dlg.hwndOwner = window_handle;
open_file_dlg.hInstance = NULL;
open_file_dlg.lpstrFilter = filters[ 0 ];
open_file_dlg.lpstrCustomFilter = NULL;
open_file_dlg.nMaxCustFilter = 0;
open_file_dlg.nFilterIndex = 1;
open_file_dlg.lpstrFile = path_filename;
open_file_dlg.nMaxFile = _MAX_PATH*500;
open_file_dlg.lpstrFileTitle = filename;
open_file_dlg.nMaxFileTitle = _MAX_FNAME + _MAX_EXT;
open_file_dlg.lpstrInitialDir = NULL;
open_file_dlg.lpstrTitle = "Choose a VQA to run";
open_file_dlg.Flags = OFN_FILEMUSTEXIST | OFN_ALLOWMULTISELECT;
open_file_dlg.nFileOffset = 0;
open_file_dlg.nFileExtension = 0;
open_file_dlg.lpstrDefExt = "vqa";
open_file_dlg.lCustData = 0l;
open_file_dlg.lpfnHook = NULL;
open_file_dlg.lpTemplateName = NULL;
if ( GetOpenFileName( &open_file_dlg ) ) {
if ( filename[ 0 ] != '\0' ) {
VQA_Test( filename );
} else {
int last_file=0;
for (i=0 ; i<open_file_dlg.nMaxFile ; i++){
if (path_filename[i]==0 || path_filename[i]==' '){
if (!(i-last_file)) break;
memcpy( &temp_file[0] , &path_filename[last_file] , i-last_file);
temp_file[i-last_file]=0;
if (last_file){
VQA_Test(temp_file);
}else{
SetCurrentDirectory(temp_file);
}
if (path_filename[i]==0){
break;
}else{
last_file = i+1;
}
}
}
}
}
}
/***************************************************************************
* VQA_Test - plays a generic VQA *
* *
* INPUT: char *filename *
* *
* OUTPUT: NONE *
* *
* WARNINGS: Red alert! *
* *
* HISTORY: *
* 11/22/1995 MG : Created. *
*=========================================================================*/
void VQA_Test( char *filename )
{
char *temp_ptr;
int i;
char *draw_surface_ptr;
GraphicBufferClass *draw_buffer_ptr;
long (*callback_function_ptr) (unsigned char *, long);
//
// Handle windows messages so that any repaint occurs before we start
// playing the movie.
//
Main_Window.Update_Windows_Messages();
// Strip the extension off the filename.
filename = strtok( filename, "." );
#if( DRAW_TO_VIDEO )
draw_buffer_ptr = Screen_Buffer;
callback_function_ptr = Draw_To_Video_Callback;
#else
draw_buffer_ptr = Draw_Page;
callback_function_ptr = Draw_To_Buffer_Callback;
#endif
//
// Get the draw buffer.
//
draw_buffer_ptr->Lock();
draw_surface_ptr = (char *) draw_buffer_ptr->Get_Offset();
draw_buffer_ptr->Unlock();
//
// Clear the drawing surface with color 0.
//
draw_buffer_ptr->Lock();
temp_ptr = draw_surface_ptr;
for ( i = 0; i < (MOVIE_WIDTH * MOVIE_HEIGHT); i ++ ) {
*temp_ptr = COLOR_BLACK;
temp_ptr ++;
}
draw_buffer_ptr->Unlock();
//
// Create a new VQA object.
//
TestVqa = new VQAClass(
filename,
draw_surface_ptr,
FROM_DISK,
callback_function_ptr );
//
// Allocate the buffers for the VQA.
//
if ( TestVqa->Open_And_Load_Buffers() ) {
TestVqa->Read_Palettes();
//
// Play the VQA.
//
TestVqa->Play_VQA( PLAY_ALL_FRAMES );
//
// Close the VQA.
//
TestVqa->Close_And_Free_VQA();
TestVqa->Write_Palettes();
delete TestVqa;
}
}
/***************************************************************************
* DRAW_TO_VIDEO_CALLBACK -- Callback after a VQA frame is drawn to video *
* *
* INPUT: *
* *
* OUTPUT: *
* *
* WARNINGS: *
* *
* HISTORY: *
* 11/22/1995 MG : Created. *
*=========================================================================*/
long Draw_To_Video_Callback( unsigned char *buffer, long frame_number )
{
return( 0 );
}
/***************************************************************************
* DRAW_TO_BUFFER_CALLBACK -- Copies the drawn frame to the screen *
* *
* INPUT: *
* *
* OUTPUT: *
* *
* WARNINGS: *
* *
* HISTORY: *
* 11/22/1995 MG : Created. *
*=========================================================================*/
long Draw_To_Buffer_Callback( unsigned char *buffer, long frame_number )
{
//
// Frame was skipped, bail.
//
if ( buffer == NULL ) {
return( 0 );
}
#if( ! DRAW_TO_VIDEO )
//
// Do the cool interpolated, interlaced scale.
//
#if( 1 )
Interpolate_2X_Scale( Draw_Page, Back_Page );
Back_Page->Blit( *Screen_Buffer, 0, 0, 0, 100, 640, 314 );
#endif
//
// Draw 320x200 to Normal RAM, scale to Screen.
//
#if( 0 )
Draw_Page->Scale( *Screen_Buffer );
#endif
//
// Draw 320x200 to Normal RAM, scale to Normal RAM, Blit to Hid, Blit to Screen.
//
#if( 0 )
Draw_Page->Scale( *Back_Page );
Back_Page->Blit( *Hid_Page );
Hid_Page->Blit( *Screen_Buffer );
#endif
//
// Draw 320x200 to Normal RAM, scale to Normal RAM, Blit to Screen.
//
#if( 0 )
Draw_Page->Scale( *Back_Page );
Back_Page->Blit( *Screen_Buffer );
#endif
//
// Draw 320x200 to Normal RAM, Blit to Screen.
//
#if( 0 )
Draw_Page->Blit( *Screen_Buffer );
#endif
#endif
return( 0 );
}
/***************************************************************************
* CREATE_PALETTE_INTERPOLATION_TABLE *
* *
* INPUT: *
* *
* OUTPUT: *
* *
* WARNINGS: *
* *
* HISTORY: *
* 12/06/1995 MG : Created. *
*=========================================================================*/
void Create_Palette_Interpolation_Table( void )
{
// InterpolationPalette = (unsigned char*)CurrentPalette;
// Asm_Create_Palette_Interpolation_Table();
//#if 0
int i;
int j;
int p;
unsigned char *first_palette_ptr;
unsigned char *second_palette_ptr;
unsigned char *match_pal_ptr;
int first_r;
int first_g;
int first_b;
int second_r;
int second_g;
int second_b;
int diff_r;
int diff_g;
int diff_b;
int dest_r;
int dest_g;
int dest_b;
int distance;
int closest_distance;
int index_of_closest_color;
//
// Create an interpolation table for the current palette.
//
first_palette_ptr = (unsigned char *) CurrentPalette;
for ( i = 0; i < SIZE_OF_PALETTE; i ++ ) {
//
// Get the first palette entry's RGB.
//
first_r = *first_palette_ptr;
first_palette_ptr ++;
first_g = *first_palette_ptr;
first_palette_ptr ++;
first_b = *first_palette_ptr;
first_palette_ptr ++;
second_palette_ptr = (unsigned char *) CurrentPalette;
for ( j = 0; j < SIZE_OF_PALETTE; j ++ ) {
//
// Get the second palette entry's RGB.
//
second_r = *second_palette_ptr;
second_palette_ptr ++;
second_g = *second_palette_ptr;
second_palette_ptr ++;
second_b = *second_palette_ptr;
second_palette_ptr ++;
//
// Now calculate the RGB halfway between the first and second colors.
//
dest_r = ( first_r + second_r ) >> 1;
dest_g = ( first_g + second_g ) >> 1;
dest_b = ( first_b + second_b ) >> 1;
//
// Now find the color in the palette that most closely matches the interpolated color.
//
index_of_closest_color = 0;
// closest_distance = (256 * 256) * 3;
closest_distance = 500000;
match_pal_ptr = (unsigned char *) CurrentPalette;
for ( p = 0; p < SIZE_OF_PALETTE; p ++ ) {
diff_r = ( ((int) (*match_pal_ptr)) - dest_r );
match_pal_ptr ++;
diff_g = ( ((int) (*match_pal_ptr)) - dest_g );
match_pal_ptr ++;
diff_b = ( ((int) (*match_pal_ptr)) - dest_b );
match_pal_ptr ++;
distance = ( diff_r * diff_r ) + ( diff_g * diff_g ) + ( diff_b * diff_b );
if ( distance < closest_distance ) {
closest_distance = distance;
index_of_closest_color = p;
}
}
Palette_Interpolation_Table[ i ][ j ] = (unsigned char) index_of_closest_color;
}
}
return;
//#endif
}
#if( 1 )
/***************************************************************************
* INTERPOLATE_2X_SCALE *
* *
* INPUT: *
* *
* OUTPUT: *
* *
* WARNINGS: *
* *
* HISTORY: *
* 12/06/1995 MG : Created. *
*=========================================================================*/
void Interpolate_2X_Scale( GraphicBufferClass *source, GraphicBufferClass *dest)
{
unsigned char *src_ptr;
unsigned char *dest_ptr;
unsigned char *last_dest_ptr;
unsigned char *end_of_source;
int src_width;
int dest_width;
// int width_counter;
BOOL source_locked = FALSE;
BOOL dest_locked = FALSE;
/*
** Lock video surfaces if requred
*/
if (source->Get_IsDirectDraw()){
if (!source->Lock()) return;
source_locked = TRUE;
}
if (dest->Get_IsDirectDraw()){
if (!dest->Lock()) {
if (source_locked){
source->Unlock();
}
return;
}
dest_locked = TRUE;
}
//
// Get pointers to the source and destination buffers.
//
src_ptr = (unsigned char *) source->Get_Offset();
dest_ptr = (unsigned char *) dest->Get_Offset();
end_of_source = src_ptr + ( source->Get_Width() * source->Get_Height() );
//
// Get width of source and dest buffers.
//
src_width = source->Get_Width();
dest_width = 2*(dest->Get_Width() + dest->Get_XAdd() + dest->Get_Pitch());
last_dest_ptr = dest_ptr;
Asm_Interpolate ( src_ptr , dest_ptr , source->Get_Height() , src_width , dest_width);
if (source_locked) source->Unlock();
if (dest_locked) dest->Unlock();
return;
}
#endif
#if( 0 )
/***************************************************************************
* INTERPOLATE_2X_SCALE *
* *
* INPUT: *
* *
* OUTPUT: *
* *
* WARNINGS: *
* *
* HISTORY: *
* 12/06/1995 MG : Created. *
*=========================================================================*/
void Interpolate_2X_Scale( GraphicBufferClass *source, GraphicBufferClass *dest )
{
unsigned char *src_ptr;
unsigned char *dest_ptr;
unsigned char *end_of_source;
int src_width;
int dest_width;
int width_counter;
//
// Get pointers to the source and destination buffers.
//
src_ptr = (unsigned char *) source->Get_Offset();
dest_ptr = (unsigned char *) dest->Get_Offset();
end_of_source = src_ptr + ( source->Get_Width() * source->Get_Height() );
//
// Get width of source and dest buffers.
//
src_width = source->Get_Width();
dest_width = dest->Get_Width();
//
// Copy over the first pixel (upper left).
//
*dest_ptr = *src_ptr;
src_ptr ++;
dest_ptr ++;
//
// Scale copy.
//
width_counter = 0;
while ( src_ptr < end_of_source ) {
//
// Blend this pixel with the one to the left and place this new color in the dest buffer.
//
*dest_ptr = Palette_Interpolation_Table[ (*src_ptr) ][ (*( src_ptr - 1 )) ];
dest_ptr ++;
//
// Now place the source pixel into the dest buffer.
//
*dest_ptr = *src_ptr;
src_ptr ++;
dest_ptr ++;
width_counter ++;
if ( width_counter == src_width ) {
width_counter = 0;
dest_ptr += dest_width;
}
}
return;
}
#endif
#if( 0 )
/***************************************************************************
* INTERPOLATE_2X_SCALE *
* *
* INPUT: *
* *
* OUTPUT: *
* *
* WARNINGS: *
* *
* HISTORY: *
* 12/06/1995 MG : Created. *
*=========================================================================*/
void Interpolate_2X_Scale( GraphicBufferClass *source, GraphicBufferClass *dest )
{
unsigned char *src_ptr;
unsigned char *dest_ptr;
unsigned char *dest2_ptr;
unsigned char *end_of_source;
int src_width;
int dest_width;
int width_counter;
//
// Get pointers to the source and destination buffers.
//
src_ptr = (unsigned char *) source->Get_Offset();
dest_ptr = (unsigned char *) dest->Get_Offset();
end_of_source = src_ptr + ( source->Get_Width() * source->Get_Height() );
//
// Get width of source and dest buffers.
//
src_width = source->Get_Width();
dest_width = dest->Get_Width();
//
// Copy over the first pixel (upper left).
//
*dest_ptr = *src_ptr;
src_ptr ++;
dest_ptr += 2;
dest2_ptr = dest_ptr + dest_width + 1;
//
// Scale copy.
//
width_counter = 0;
while ( src_ptr < end_of_source ) {
//
// Blend this pixel with the one to the left and place this new color in the dest buffer.
//
*dest2_ptr = Palette_Interpolation_Table[ (*src_ptr) ][ (*( src_ptr - 1 )) ];
dest2_ptr += 2;
//
// Now place the source pixel into the dest buffer.
//
*dest_ptr = *src_ptr;
src_ptr ++;
dest_ptr += 2;
width_counter ++;
if ( width_counter == src_width ) {
width_counter = 0;
dest_ptr += dest_width;
dest2_ptr += dest_width;
}
}
return;
}
#endif
Reference in New Issue Copy Permalink