chore(fmod): add files from Chensne/DragonNest
This commit is contained in:
commit
50fb3c6b1c
544 changed files with 315778 additions and 0 deletions
311
lib/neural_thx/Neural_THX_Global.h
Executable file
311
lib/neural_thx/Neural_THX_Global.h
Executable file
|
|
@ -0,0 +1,311 @@
|
|||
//////////////////////////////////////////////////////////////////////
|
||||
// ___________________ //
|
||||
// | //
|
||||
// | | | \ / //
|
||||
// | | | \ / //
|
||||
// | |----| / //
|
||||
// | | | / \ //
|
||||
// | | | / \ //
|
||||
// ___________________ //
|
||||
// //
|
||||
// Neural-THX (R) Surround Technology //
|
||||
// //
|
||||
// Copyright (c) 2008 THX Ltd. //
|
||||
// //
|
||||
// THX is a trademark of THX Ltd., which may be registered //
|
||||
// in some jurisdictions. //
|
||||
// All Rights Reserved. //
|
||||
// //
|
||||
// THX Confidential Information //
|
||||
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Name : Neural_THX_Global.h
|
||||
//
|
||||
// Author(s) : Mark Gugler (mgugler@thx.com)
|
||||
//
|
||||
// Created On : 08/20/2007
|
||||
//
|
||||
// Last Modified : 03/03/2008
|
||||
//
|
||||
// Version : 1.61
|
||||
//
|
||||
// References :
|
||||
//
|
||||
// Description : Encapsulates any enumerations, structures, and
|
||||
// defines needed by the Neural-THX API
|
||||
//
|
||||
// Revision History : 08/20/2007 Build basic framework and add in new
|
||||
// structs for the encoder
|
||||
// 08/21/2007 Add in more comments and update some values
|
||||
// based on what was received from Neural
|
||||
// 08/22/2007 Add in a new structure to encapsulate
|
||||
// parameter structures into one interface
|
||||
// 08/23/2007 Finish adding functions to the new struct
|
||||
// Add 522 parameters to settings struct
|
||||
// 08/31/2007 Updating comments for clearly outlining
|
||||
// what values represent
|
||||
// 09/04/2007 Update comments and prepare for 722
|
||||
// encoder integration
|
||||
// 02/15/2008 Got 722 encoder so integrating and testing
|
||||
// 02/26/2008 Added some defines and stripped out any
|
||||
// remaining memory allocation from the API
|
||||
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
#ifndef __NEURAL_THX_GLOBAL__
|
||||
#define __NEURAL_THX_GLOBAL__
|
||||
|
||||
#include "Neural_THX_Encoders.h"
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Global Defines
|
||||
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// NOTE:: Only comment out the encoders you won't use over the course of the game
|
||||
// This was implemented to not have any memory allocation
|
||||
// throughout the entire API.
|
||||
#define USING_725
|
||||
#define USING_722
|
||||
// #define USING_522
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Definitions
|
||||
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Name : Neural_THX_Encoder_Params
|
||||
//
|
||||
// Created On : 08/22/2007
|
||||
//
|
||||
// Last Modified : 02/28/2008
|
||||
//
|
||||
// Description : Parameter structure encapsulating all other param structs
|
||||
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
struct Neural_THX_Encoder_Params
|
||||
{
|
||||
#ifdef USING_725
|
||||
Neural_THX_725_Encode_Struct t725;
|
||||
#endif
|
||||
#ifdef USING_522
|
||||
Neural_THX_522_Encode_Struct t522;
|
||||
#endif
|
||||
#ifdef USING_722
|
||||
Neural_THX_722_Encode_Struct t722;
|
||||
#endif
|
||||
|
||||
void * pParams;
|
||||
Neural_THX_Encoder_Params()
|
||||
{
|
||||
pParams = NULL;
|
||||
}
|
||||
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Name : Init
|
||||
//
|
||||
// Params : int - Channel Configuration to know which structure to use
|
||||
//
|
||||
// Return : void
|
||||
//
|
||||
// Purpose : Initialize the pointer needed by this encoder :)
|
||||
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
void Init(int nChanConfig)
|
||||
{
|
||||
// see which configuration we have :)
|
||||
if(nChanConfig == NEURAL_THX_7_5_GAMING)
|
||||
{
|
||||
#ifdef USING_725
|
||||
pParams = &t725;
|
||||
#endif
|
||||
}
|
||||
else if(nChanConfig == NEURAL_THX_5_2_GAMING)
|
||||
{
|
||||
#ifdef USING_522
|
||||
pParams = &t522;
|
||||
#endif
|
||||
}
|
||||
else if(nChanConfig == NEURAL_THX_7_2_GAMING)
|
||||
{
|
||||
#ifdef USING_722
|
||||
pParams = &t722;
|
||||
#endif
|
||||
}
|
||||
}
|
||||
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Name : Release
|
||||
//
|
||||
// Params : void
|
||||
//
|
||||
// Return : void
|
||||
//
|
||||
// Purpose : Releases memory if any has been allocated through the init
|
||||
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
void Release(void)
|
||||
{
|
||||
pParams = NULL;
|
||||
}
|
||||
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Name : ValidStruct
|
||||
//
|
||||
// Params : void
|
||||
//
|
||||
// Return : bool - whether any of the pointers are valid or not
|
||||
//
|
||||
// Purpose : Checks to see if the init was successful
|
||||
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
bool ValidStruct(void)
|
||||
{
|
||||
if(pParams == NULL)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
// return yes
|
||||
return true;
|
||||
}
|
||||
};
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Name : Neural_THX_Encoder_Settings
|
||||
//
|
||||
// Created On : 08/20/2007
|
||||
//
|
||||
// Last Modified : 02/28/2008
|
||||
//
|
||||
// Description : Settings structure for the Neural-THX encoder
|
||||
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
struct Neural_THX_Encoder_Settings
|
||||
{
|
||||
// The Number of audio samples in each mono channel buffers passed to the
|
||||
// encoder
|
||||
// NOTE: The encoder currently only supports an audio frame size of NEURAL_FRAMESIZE
|
||||
unsigned int nFramesize;
|
||||
// A configuration value indicating that the encoder is to perform a Neural-THX
|
||||
// compatible encoding.
|
||||
unsigned int nChanConfig;
|
||||
// The sample rate of the input/output audio.
|
||||
// NOTE: The encoder currently supports sample rates of 32 kHz, 44.1 kHz, and
|
||||
// 48 kHz.
|
||||
unsigned int nSampleRate;
|
||||
// Whether to use Final Limiting or not
|
||||
// NOTE: Used in 522 & 722 encoder
|
||||
THX_bool bUseFinalLimiting;
|
||||
// LFE Cutoff when converting to 2 channels
|
||||
// NOTE: Used in 522 & 722 encoder
|
||||
float fLFECutOff;
|
||||
|
||||
// Default Constructor Set to defaults
|
||||
Neural_THX_Encoder_Settings()
|
||||
{
|
||||
nFramesize = NEURAL_FRAMESIZE;
|
||||
nChanConfig = NEURAL_THX_7_5_GAMING;
|
||||
nSampleRate = SAMPLERATE_44_1;
|
||||
bUseFinalLimiting = true;
|
||||
fLFECutOff = 0.0f;
|
||||
}
|
||||
};
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Name : Neural_THX_Channel_Format
|
||||
//
|
||||
// Created On : 08/20/2007
|
||||
//
|
||||
// Last Modified : 02/28/2008
|
||||
//
|
||||
// Description : Surround Setup structure
|
||||
//
|
||||
// m_fL[n] equals 1 Sample point for the channel
|
||||
// while variable_name[n] =s a sample frame
|
||||
// NOTE: The encoder uses 32 bit max for sample points
|
||||
// which requires the user to compensate based on
|
||||
// the bytes each sample point takes
|
||||
// (i.e. bitsPerSample / 8 = nBytesPerSample rounded up)
|
||||
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
struct Neural_THX_Channel_Format // double check if we need to support the framesize
|
||||
{
|
||||
// Front
|
||||
float m_fL[NEURAL_FRAMESIZE];
|
||||
float m_fC[NEURAL_FRAMESIZE];
|
||||
float m_fR[NEURAL_FRAMESIZE];
|
||||
// Sides/Surround & LFE
|
||||
float m_fLs[NEURAL_FRAMESIZE];
|
||||
float m_fRs[NEURAL_FRAMESIZE];
|
||||
float m_fLFE[NEURAL_FRAMESIZE];
|
||||
// Back
|
||||
float m_fLb[NEURAL_FRAMESIZE];
|
||||
float m_fRb[NEURAL_FRAMESIZE];
|
||||
|
||||
// Constructor set everything to NULL
|
||||
Neural_THX_Channel_Format()
|
||||
{
|
||||
// Fill with silence
|
||||
// CPS - FMOD_memset(this->m_fL,0,sizeof(float) * NEURAL_FRAMESIZE);
|
||||
// CPS - FMOD_memset(this->m_fC,0,sizeof(float) * NEURAL_FRAMESIZE);
|
||||
// CPS - FMOD_memset(this->m_fR,0,sizeof(float) * NEURAL_FRAMESIZE);
|
||||
// CPS - FMOD_memset(this->m_fLs,0,sizeof(float) * NEURAL_FRAMESIZE);
|
||||
// CPS - FMOD_memset(this->m_fRs,0,sizeof(float) * NEURAL_FRAMESIZE);
|
||||
// CPS - FMOD_memset(this->m_fLFE,0,sizeof(float) * NEURAL_FRAMESIZE);
|
||||
// CPS - FMOD_memset(this->m_fLb,0,sizeof(float) * NEURAL_FRAMESIZE);
|
||||
// CPS - FMOD_memset(this->m_fRb,0,sizeof(float) * NEURAL_FRAMESIZE);
|
||||
|
||||
//ZeroMemory(this->m_fL, sizeof(float) * NEURAL_FRAMESIZE);
|
||||
//ZeroMemory(this->m_fC, sizeof(float) * NEURAL_FRAMESIZE);
|
||||
//ZeroMemory(this->m_fR, sizeof(float) * NEURAL_FRAMESIZE);
|
||||
//ZeroMemory(this->m_fLs, sizeof(float) * NEURAL_FRAMESIZE);
|
||||
//ZeroMemory(this->m_fRs, sizeof(float) * NEURAL_FRAMESIZE);
|
||||
//ZeroMemory(this->m_fLFE,sizeof(float) * NEURAL_FRAMESIZE);
|
||||
//ZeroMemory(this->m_fLb, sizeof(float) * NEURAL_FRAMESIZE);
|
||||
//ZeroMemory(this->m_fRb, sizeof(float) * NEURAL_FRAMESIZE);
|
||||
}
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
//// Name : Convert
|
||||
////
|
||||
//// Params : void * - Source of channels
|
||||
////
|
||||
//// Return : void
|
||||
////
|
||||
//// Purpose : Used to provide conversion support on any platform
|
||||
//// * converts any source into this format for use by
|
||||
//// the Neural-THX encoder
|
||||
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
//void Convert(void *pSource)
|
||||
//{
|
||||
// // TODO : Use this function to transfer your channels into this
|
||||
// // structure which will later be passed into the encoder
|
||||
//}
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Name : Initialize
|
||||
//
|
||||
// Params : void * - Source of channels
|
||||
//
|
||||
// Return : void
|
||||
//
|
||||
// Purpose : Used to set all channels in one easy to use function
|
||||
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
//void Initialize(float *fL = NULL,
|
||||
// float *fC = NULL,
|
||||
// float *fR = NULL,
|
||||
// float *fLs = NULL,
|
||||
// float *fRs = NULL,
|
||||
// float *fLFE = NULL,
|
||||
// float *fLb = NULL,
|
||||
// float *fRb = NULL)
|
||||
//{
|
||||
// // Copy over the information into the structure's variables
|
||||
// if(fL)
|
||||
// FMOD_memcpy(this->m_fL,fL,sizeof(float) * NEURAL_FRAMESIZE);
|
||||
// if(fC)
|
||||
// FMOD_memcpy(this->m_fC,fC,sizeof(float) * NEURAL_FRAMESIZE);
|
||||
// if(fR)
|
||||
// FMOD_memcpy(this->m_fR,fR,sizeof(float) * NEURAL_FRAMESIZE);
|
||||
// if(fLs)
|
||||
// FMOD_memcpy(this->m_fLs,fLs,sizeof(float) * NEURAL_FRAMESIZE);
|
||||
// if(fRs)
|
||||
// FMOD_memcpy(this->m_fRs,fRs,sizeof(float) * NEURAL_FRAMESIZE);
|
||||
// if(fLFE)
|
||||
// FMOD_memcpy(this->m_fLFE,fLFE,sizeof(float) * NEURAL_FRAMESIZE);
|
||||
// if(fLb)
|
||||
// FMOD_memcpy(this->m_fLb,fLb,sizeof(float) * NEURAL_FRAMESIZE);
|
||||
// if(fRb)
|
||||
// FMOD_memcpy(this->m_fRb,fRb,sizeof(float) * NEURAL_FRAMESIZE);
|
||||
//}
|
||||
};
|
||||
|
||||
|
||||
#endif // __NEURAL_THX_GLOBAL__
|
||||
|
||||
Loading…
Add table
Add a link
Reference in a new issue