char *cFileInfo::FileNameWithoutExt(void)
{
char *ext = NULL;
char *filename = NULL;
if(Extension())
ext = strdup(Extension());
if(FileName())
filename = strdup(FileName());
FREENULL(buffer);
if(ext && filename)
{
int len = strlen(filename) - strlen(ext) + 1;
buffer = (char*)malloc(len);
strn0cpy(buffer, filename, len);
}
else if(filename)
buffer = strdup(filename);
free(ext);
free(filename);
MYDEBUG("FileInfo: FileNameWithoutExt: %s", buffer);
return buffer;
}
void FormatIdd( void ) {
//=========================
cs_label fmt_label;
grp_entry *ge;
if( RecName() && ( NameListFind() != NULL ) ) {
BIOutNameList( CITNode->sym_ptr );
ge = CITNode->sym_ptr->u.nl.group_list;
while( ge != NULL ) {
ge->sym->u.ns.flags |= SY_REFERENCED;
ge = ge->link;
}
GSetNameList( FC_SET_NML );
KWRememb( IO_NAMELIST );
} else if( RecNumber() ) {
GPassStmtNo( LkUpFormat(), FC_SET_FMT );
} else if( RecNOpn() && RecNextOpr( OPR_MUL ) ) {
if( CITNode->link->opn.ds == DSOPN_PHI ) {
AdvanceITPtr(); // nothing needs to be loaded for default
KWRememb( IO_LIST_DIR );
}
} else if( RecNOpn() && RecNextOpr( OPR_COM ) ) {
Extension( IL_NO_ASTERISK );
} else if( RecIntVar() ) {
CkVarRef();
StNumbers.var_format = true;
GFmtVarSet();
} else {
ProcIOExpr(); // will allow for array name alone
if( !AError ) {
if( RecArrName() ) {
if( CITNode->typ != FT_CHAR ) {
Extension( IL_NON_CHARACTER );
}
ChkAssumed();
GFmtArrSet();
} else if( CITNode->typ != FT_CHAR ) {
Error( IL_BAD_FMT_SPEC );
} else if( ( CITNode->opn.us == USOPN_CON ) ) {
AddConst( CITNode ); // in case single constant
fmt_label.g_label = NextLabel();
FScan( CITNode->sym_ptr->u.lt.length,
(char *)&CITNode->sym_ptr->u.lt.value, fmt_label );
GPassLabel( fmt_label.g_label, RT_SET_FMT );
} else {
GFmtExprSet();
}
}
}
}
void DetCallList(void) {
//=====================
itnode *cit;
cit = CITNode;
AdvanceITPtr();
if( RecNOpn() ) {
AdvanceITPtr();
} else {
SetDefinedStatus();
AdvanceITPtr();
while( RecComma() ) {
if( CheckColon() ) {
Extension( SS_FUNCTION_VALUE );
SubStrArgs( cit );
Detach( cit );
return;
}
if( RecNOpn() ) break;
SetDefinedStatus();
AdvanceITPtr();
}
}
if( !RecCloseParen() ) {
Error( PC_NO_CLOSEPAREN );
}
Detach( cit );
}
void StmtExtension( int errcode ) {
//====================================
char stmt[MAX_MSGLEN+1];
Extension( errcode, StmtName( stmt ) );
}
void IFChkExtension( IFF func ) {
//==================================
if( IFFlags[ func ].flags & IF_EXTENSION ) {
Extension( LI_IF_NOT_STANDARD, IFNames[ func ] );
}
}
int main(int argc,char *argv[])
{
//char *ext = NULL;
char *str_exp = NULL;
banner();
str_exp = (char *)malloc(MAX_PATH);
if( str_exp == NULL )
{
printf( "内存分配失败\n" );
system("pause");
return -1;
}
if(argv[1]==NULL)
{
system("pause");
return -1;
}
Extension((argv[1]),str_exp);
if (strcmp(str_exp,"mkv")==0||strcmp(str_exp,"mp4")==0)
Decoding_xor(argv[1]);
else
printf("文件不是音频文件\n");
free(str_exp);//内存泄露
str_exp=NULL;
system("pause");
return 0;
}
CSString CreateSrStringFilename (const char* pFilename, const char* pExtension)
{
CSString BaseFilename(pFilename);
CSString Pathname(pFilename);
CSString Extension(pExtension);
CSString Filename;
int Index;
Index = Pathname.FindCharR('\\');
if (Index > 0)
{
Pathname.Truncate(Index);
Pathname += "\\";
BaseFilename.Delete(0, Index+1);
}
else
{
Pathname.Empty();
}
Pathname += "Strings\\";
Index = BaseFilename.FindCharR('.');
if (Index > 0) BaseFilename.Truncate(Index);
Filename = Pathname + BaseFilename;
Filename += "_" + g_SrLanguage + "." + Extension;
return Filename;
}
EXPORT_C TKeyIdentifier CX509Certificate::SubjectKeyIdL() const
{
// if it is a v1 or v2 type then there is no way of knowing which is a CA, treat all certs as CA as done in the certificate recognizer.
if (Version() < 3 )
{
return SubjectKeyIdentifierL();
}
// if it is x509 v3 certificate then check for the basic constraint extension.
const CX509CertExtension* ext = Extension(KBasicConstraints);
if (ext)
{
CX509BasicConstraintsExt* basic = CX509BasicConstraintsExt::NewLC(ext->Data());
TBool markedAsCA = basic->IsCA();
CleanupStack::PopAndDestroy(basic);
// it can be an intermediate as well as root CA
if ( markedAsCA )
{
return SubjectKeyIdentifierL();
}
}
// For non-CA certs, use the recommended method of computing it from RFC5280, section 4.2.1.2
return KeyIdentifierL();
}
void CpReturn( void )
{
if( !(ProgSw & PS_IN_SUBPROGRAM) ) {
Extension( RE_IN_PROGRAM );
}
CkRemBlock();
if( RecNOpn() && RecNextOpr( OPR_TRM ) ) {
if( ( ( SubProgId->u.ns.flags & SY_CLASS ) == SY_SUBPROGRAM ) &&
( ( SubProgId->u.ns.flags & SY_SUBPROG_TYPE ) == SY_SUBROUTINE ) ) {
GNullRetIdx();
}
} else {
IntSubExpr();
if( ( ( SubProgId->u.ns.flags & SY_CLASS ) == SY_SUBPROGRAM ) &&
( ( SubProgId->u.ns.flags & SY_SUBPROG_TYPE ) == SY_SUBROUTINE ) ) {
GRetIdx();
} else {
Error( RE_ALT_IN_SUBROUTINE );
}
}
AdvanceITPtr();
ReqEOS();
GGotoEpilog();
Remember.transfer = true;
Remember.stop_or_return = true;
}
bool isFileXML(std::string FilePath)
{
std::string::size_type LastDotPos = FilePath.find_last_of(".");
++LastDotPos;
std::string Extension(FilePath.substr(LastDotPos, FilePath.length() - LastDotPos));
return Extension.compare("xml") == 0;
}
FCFileTypeP FCFileHandlerBase::getFileType(const BoostPath& FilePath, UInt32 Flags)
{
//Determine the file extension
std::string Extension(boost::filesystem::extension(FilePath.string()));
boost::algorithm::trim_if(Extension,boost::is_any_of("."));
return getFileType(Extension, Flags);
}
void NameExt( int errcod, sym_id sym ) {
//=========================================
char buff[MAX_SYMLEN+1];
STGetName( sym, buff );
Extension( errcod, buff );
}
bool Db_File::Filename (string rootname)
{
part_flag = false;
extend = 0;
if (rootname == filename) return (true);
filename.clear ();
pathname.clear ();
if (rootname.empty ()) return (false);
filename = rootname;
//---- check for a partition type ----
size_t index = filename.find (".*");
if (index != filename.npos) {
part_flag = true;
filename.erase (index);
if (f_exist (filename + ".AA")) {
Version (40);
extend = 1;
} else if (f_exist (filename + ".tAA")) {
Version (40);
extend = 2;
}
} else {
index = filename.find (".t*");
if (index != filename.npos) {
part_flag = true;
filename.erase (index);
if (f_exist (filename + ".tAA")) {
Version (40);
extend = 2;
}
} else {
part_flag = false;
}
}
if (part_flag) {
if (exe->Single_Partition ()) {
filename += Extension (exe->First_Partition ());
part_flag = false;
extend = 3;
}
} else if (exe->MPI_Size () > 1 && exe->Slave () && File_Access () == CREATE) {
filename += String (".%d") % exe->MPI_Rank ();
}
pathname = filename;
return (Filename (0));
}
bool Db_File::Find_File (int part_index)
{
string name = pathname;
if (part_flag) {
part_index = exe->Partition_Number (part_index);
if (part_index < 0) return (false);
name += Extension (part_index);
}
return (f_exist (name));
}
bool Load(const std::string& filename,
const std::string& name,
T& t,
const bool fatal,
format f)
{
if (f == format::autodetect)
{
std::string extension = Extension(filename);
if (extension == "xml")
f = format::xml;
else if (extension == "bin")
f = format::binary;
else if (extension == "txt")
f = format::text;
else
{
if (fatal)
Log::Fatal << "Unable to detect type of '" << filename << "'; incorrect"
<< " extension?" << std::endl;
else
Log::Warn << "Unable to detect type of '" << filename << "'; load "
<< "failed. Incorrect extension?" << std::endl;
return false;
}
}
// Now load the given format.
std::ifstream ifs(filename);
if (!ifs.is_open())
{
if (fatal)
Log::Fatal << "Unable to open file '" << filename << "'." << std::endl;
else
Log::Warn << "Unable to open file '" << filename << "'." << std::endl;
return false;
}
try
{
if (f == format::xml)
{
boost::archive::xml_iarchive ar(ifs);
ar >> CreateNVP(t, name);
}
else if (f == format::text)
{
boost::archive::text_iarchive ar(ifs);
ar >> CreateNVP(t, name);
}
FCFileHandlerBase::FCPtrStore FCFileHandlerBase::read(const BoostPath& FilePath)
{
FCPtrStore Result;
//Determine if the file exists
if(!boost::filesystem::exists(FilePath))
{
SWARNING << "FCFileHandlerBase::read(): " << FilePath.string() << " does not exists." << std::endl;
return Result;
}
std::string filename = initPathHandler(FilePath.string().c_str());
//Determine the file extension
std::string Extension(boost::filesystem::extension(FilePath));
boost::algorithm::trim_if(Extension,boost::is_any_of("."));
//Get the Parent Directory Path of the file
_RootFilePath = FilePath;
_RootFilePath.remove_leaf();
//Get the FileType for this extension
FCFileTypeP TheFileType(getFileType(Extension, FCFileType::OSG_READ_SUPPORTED));
//Is that extension supported for reading
if(TheFileType == NULL)
{
SWARNING << "FCFileHandlerBase::read(): Cannot read Field Container file: " << FilePath.string() << ", because no File types support " << Extension << " extension." << std::endl;
return Result;
}
else
{
//Open up the input stream of the file
std::ifstream InputStream(FilePath.string().c_str(), std::ios::binary);
if(!InputStream)
{
SWARNING << "FCFileHandlerBase::read(): Couldn't open input stream for file " << FilePath.string() << std::endl;
return Result;
}
else
{
//Read from the input stream
startReadProgressThread(InputStream);
Result = TheFileType->read(InputStream, FilePath.string());
stopReadProgressThread();
InputStream.close();
}
}
return Result;
}
static void ArithNewSubr(void) {
//==============================
if( CITNode->flags & SY_TYPE ) {
Extension( SR_FUNC_AS_SUB );
CITNode->sym_ptr->u.ns.flags |= SY_USAGE | SY_SUBPROGRAM | SY_FUNCTION;
} else {
ASType |= AST_ALT;
CITNode->sym_ptr->u.ns.flags |= SY_USAGE | SY_SUBPROGRAM |
SY_SUBROUTINE;
}
Arith();
}
void Load( const std::string &fileName, const std::string &plugin = std::string("") )
{
constexpr const char *dbg_CurFunc = "Toolbox::Image::Load(const std::string &, const std::string &)";
if ( _PluginMgr.Plugins().empty() )
throw std::runtime_error( std::string(dbg_CurFunc) + ": No Image plugins loaded!" );
// Find which plugin we need to load the file with
if ( !plugin.empty() )
{
// If explicitly given, lets use it
auto ImgPlugin = _PluginMgr.Create< Image_Plugin >( plugin );
ImgPlugin->Load( fileName, this );
}
else
{
std::string Extension( Plugin::GetExtFromFilename(fileName) );
auto Plugins = _PluginMgr.Plugins();
// If plugin is not provided, we search our plugins for the fileName's extension
bool Found = false;
for ( auto p = Plugins.begin(), p_end = Plugins.end(); p != p_end; ++p )
{
auto ImgPlugin = _PluginMgr.Create< Image_Plugin >( (*p)->Name() );
if ( !ImgPlugin )
throw std::runtime_error( std::string(dbg_CurFunc) + ": Failed to create plugin instance." );
Image_Plugin::tExtensionList Extensions = ImgPlugin->Extensions();
for ( auto e = Extensions.begin(), e_end = Extensions.end(); e != e_end; ++e )
{
if ( !e->compare(Extension) )
{
Found = true;
ImgPlugin->Load( fileName, this );
break;
}
}
ImgPlugin.reset();
Extensions.clear();
if ( Found )
break;
}
if ( !Found )
throw std::runtime_error( std::string(dbg_CurFunc) + ": Failed to load image. Couldn't find a plugin to load '" + Extension + "' files." );
}
}
void CpCall(void) {
//================
itnode *next;
unsigned_16 sp_type;
next = CITNode->link;
if( next->opr == OPR_TRM ) {
ASType = AST_CNA; // call with no parameter list
} else if( ( next->opr == OPR_LBR ) &&
( next->opn.ds == DSOPN_PHI ) &&
( next->link->opr == OPR_RBR ) &&
( next->link->opn.ds == DSOPN_PHI ) &&
( next->link->link->opr == OPR_TRM ) ) {
next->opr = OPR_TRM; // make CALL SAM() same as CALL SAM
ASType = AST_CNA; // call with no parameter list
} else {
ReqNextOpr( OPR_LBR, SX_SURP_OPR );
if( ( SPtr1 != NULL ) && ( SPtr1->link->opr != OPR_TRM ) ) {
Error( SX_JUNK_AFTER_RBR ); // ignore anything after
SPtr1->link->opr = OPR_TRM; // closing parenthesis
}
ASType = AST_OFF;
}
if( ReqName( NAME_SUBROUTINE ) ) {
LkSym();
if( ClassIs( SY_SUBPROGRAM ) ) {
sp_type = CITNode->flags & SY_SUBPROG_TYPE;
if( sp_type == SY_SUBROUTINE ) {
ASType |= AST_ALT;
Arith();
} else if( sp_type == SY_FUNCTION ) {
Extension( SR_FUNC_AS_SUB );
Arith();
} else if( sp_type == 0 ) {
ArithNewSubr();
} else {
Error( SR_NO_SUBRTN_NAME );
}
} else {
if( CITNode->flags & SY_USAGE ) {
Error( SR_NO_SUBRTN_NAME );
} else if( CITNode->flags & SY_SAVED ) {
Error( SA_SAVED );
} else {
ArithNewSubr();
}
}
}
}
void CpDo( void )
{
// Compile a DO statement.
signed_32 term;
AddCSNode( CS_DO );
term = DoLabel();
if( term == 0 ) {
Extension( DO_DO_EXT );
}
InitDo( term );
ColonLabel();
}
TableDOMTransitPtr TableFileHandlerBase::forceRead(const BoostPath& FilePath)
{
TableDOMRefPtr Result;
//Determine if the file exists
if(!boost::filesystem::exists(FilePath))
{
SWARNING << "TableFileHandlerBase::read(): " << FilePath.string() << " does not exists." << std::endl;
return TableDOMTransitPtr(NULL);
}
//Determine the file extension
std::string Extension(boost::filesystem::extension(FilePath));
boost::algorithm::trim_if(Extension,boost::is_any_of("."));
//Get the Parent Directory Path of the file
_RootFilePath = FilePath;
_RootFilePath.remove_leaf();
//Get the FileType of a "txt" file (Forcing the document to be opened as a txt file)
TableFileTypeP TheFileType(getFileType("csv", TableFileType::OSG_READ_SUPPORTED));
//Is that extension supported for reading
if(TheFileType == NULL)
{
SWARNING << "TableFileHandlerBase::read(): Cannot read Field Container file: " << FilePath.string() << ", because no File types support " << Extension << " extension." << std::endl;
return TableDOMTransitPtr(NULL);
}
else
{
//Open up the input stream of the file
std::ifstream InputStream(FilePath.string().c_str(), std::ios::binary);
if(!InputStream)
{
SWARNING << "TableFileHandlerBase::read(): Couldn't open input stream for file " << FilePath.string() << std::endl;
return TableDOMTransitPtr(NULL);
}
else
{
//Read from the input stream
startReadProgressThread(InputStream);
Result = TheFileType->read(InputStream, FilePath.string());
stopReadProgressThread();
InputStream.close();
}
}
return TableDOMTransitPtr(Result);
}
static bool DoGenerate( TYPE typ1, TYPE typ2, uint *res_size ) {
//================================================================
if( CITNode->link->opr == OPR_EQU ) {
ResultType = typ1;
*res_size = CITNode->size;
if( (ASType & AST_ASF) || CkAssignOk() ) return( true );
return( false );
} else {
if( ( ( typ1 == FT_DOUBLE ) && ( typ2 == FT_COMPLEX ) ) ||
( ( typ2 == FT_DOUBLE ) && ( typ1 == FT_COMPLEX ) ) ) {
ResultType = FT_DCOMPLEX;
*res_size = TypeSize( FT_DCOMPLEX );
Extension( MD_DBLE_WITH_CMPLX );
} else if( ( ( typ1 == FT_TRUE_EXTENDED ) && ( typ2 == FT_COMPLEX ) )
|| ( ( typ2 == FT_TRUE_EXTENDED ) && ( typ1 == FT_COMPLEX ) )
|| ( ( typ1 == FT_TRUE_EXTENDED ) && ( typ2 == FT_DCOMPLEX ) )
|| ( ( typ2 == FT_TRUE_EXTENDED ) && ( typ1 == FT_DCOMPLEX ) ) ) {
ResultType = FT_XCOMPLEX;
*res_size = TypeSize( FT_XCOMPLEX );
Extension( MD_DBLE_WITH_CMPLX );
} else if( ( typ2 > typ1 ) || ( typ1 == FT_STRUCTURE ) || ( typ1 == FT_NO_TYPE ) ) {
ResultType = typ2;
*res_size = TypeSize( typ2 );
} else {
ResultType = typ1;
if( _IsTypeInteger( ResultType ) ) {
*res_size = CITNode->size;
if( *res_size < CITNode->link->size ) {
*res_size = CITNode->link->size;
}
} else
*res_size = TypeSize( typ1 );
}
return( true );
}
}
bool Ext_File::Filename (char *rootname, int ext_number)
{
extend = 0;
if (pathname != NULL) {
delete [] pathname;
pathname = NULL;
}
extension [0] = '\0';
Db_File::Filename (NULL);
if (rootname == NULL) return (false);
int len = (int) strlen (rootname) + 1;
pathname = new char [len];
if (pathname == NULL) return (Status (MEMORY));
str_cpy (pathname, len, rootname);
char *str_ptr = strstr (pathname, ".*");
if (str_ptr != NULL) {
extend = 1;
*str_ptr = '\0';
} else {
str_ptr = strstr (pathname, ".t*");
if (str_ptr != NULL) {
extend = 2;
*str_ptr = '\0';
} else {
extend = 0;
}
}
if (ext_number >= 0 && extend) {
Extension (ext_number);
extend = 0;
len = (int) (strlen (pathname) + strlen (buffer) + 2);
str_ptr = new char [len];
if (str_ptr == NULL) return (Status (MEMORY));
str_fmt (str_ptr, len, "%s.%s", pathname, buffer);
delete [] pathname;
pathname = str_ptr;
}
return (Filename (0));
}
EXPORT_C TBool CX509Certificate::IsSelfSignedL() const
{
if (iSubjectName->Count() > 0)
{
return iSubjectName->ExactMatchL(*iIssuerName);
}
else
{
TBool res = EFalse;
const CX509CertExtension* subjectExt = Extension(KIssuerAltName);
const CX509CertExtension* issuerExt = Extension(KSubjectAltName);
if ((subjectExt) && (issuerExt))
{
const CX509AltNameExt* issuerAltName = CX509AltNameExt::NewLC(subjectExt->Data());
const CX509AltNameExt* subjectAltName = CX509AltNameExt::NewLC(issuerExt->Data());
if (subjectAltName->Match(*issuerAltName))
{
res = ETrue;
}
CleanupStack::PopAndDestroy(2);//subjectAltName, issuerAltName
}
return res;
}
}
int Db_File::Num_Parts (void)
{
if (part_flag) {
int num;
String name;
for (int part=0; ; part++) {
num = exe->Partition_Number (part);
if (num < 0) return (part);
name = pathname + Extension (num);
if (!f_exist (name)) return (part);
}
} else {
return (1);
}
}
void CpDoWhile( void )
{
// Compile a DO WHILE statement.
Extension( DO_DO_EXT );
InitLoop( CS_DO_WHILE );
CSHead->cs_info.do_term = DoLabel();
if( RecKeyWord( "WHILE" ) ) {
RemKeyword( CITNode, 5 );
CSCond( CSHead->bottom );
BlockLabel();
} else {
if( ReqNOpn() ) {
BlockLabel();
}
}
}
static void ScanningFunction( void ) {
//==========================
// Must be scanning a function.
if( CITNode->flags & SY_PS_ENTRY ) {
Extension( SR_TRIED_RECURSION );
} else if( CITNode->flags & ( SY_USAGE | SY_DO_PARM | SY_IN_EC ) ) {
IllName( CITNode->sym_ptr );
} else if( CITNode->flags & SY_SAVED ) {
Error( SA_SAVED );
} else {
CkIntrinsic();
CITNode->flags |= SY_SUBPROGRAM | SY_FUNCTION;
SetTypeUsage( SY_TYPE | SY_USAGE );
}
}
/// List of device filters based on environment variables.
inline std::vector< std::function<bool(const boost::compute::device&)> >
backend_env_filters()
{
std::vector< std::function<bool(const boost::compute::device&)> > filter;
const char *platform = boost::compute::detail::getenv("OCL_PLATFORM");
const char *vendor = boost::compute::detail::getenv("OCL_VENDOR");
const char *name = boost::compute::detail::getenv("OCL_DEVICE");
const char *devtype = boost::compute::detail::getenv("OCL_TYPE");
const char *extension = boost::compute::detail::getenv("OCL_EXTENSION");
if (platform) filter.push_back(Platform(platform));
if (vendor) filter.push_back(Vendor(vendor));
if (name) filter.push_back(Name(name));
if (devtype) filter.push_back(Type(devtype));
if (extension) filter.push_back(Extension(extension));
return filter;
}
static void NumOrLit( FCODE routine ) {
//===============================================
if( RecNOpn() ) {
AdvanceITPtr();
}
if( RecNOpn() ) {
GBreak( routine );
} else if( !RecLiteral() ) {
if( CITNode->opn.ds == DSOPN_INT ) {
if( CITNode->opnd_size > 5 ) {
Extension( ST_LONG_NUM, StmtKeywords[ StmtProc ] );
}
BreakOpn( routine );
} else {
Error( SX_NUM_OR_LIT );
}
} else {
BreakOpn( routine );
}
}
void CreateImageFromFile( const Diligent::Char *FilePath,
Image **ppImage,
IDataBlob **ppDDSData)
{
auto *pDotPos = strrchr( FilePath, '.' );
if( pDotPos == nullptr )
LOG_ERROR_AND_THROW( "File path ", FilePath, " does not contain extension" );
auto *pExtension = pDotPos + 1;
if( *pExtension == 0 )
LOG_ERROR_AND_THROW( "File path ", FilePath, " contains empty extension" );
String Extension(pExtension);
std::transform( Extension.begin(), Extension.end(), Extension.begin(), ::tolower );
Diligent::RefCntAutoPtr<BasicFileStream> pFileStream( new BasicFileStream( FilePath, EFileAccessMode::Read ) );
if( Extension == "dds" )
{
VERIFY_EXPR(ppDDSData != nullptr);
*ppDDSData = new DataBlobImpl;
pFileStream->Read(*ppDDSData);
(*ppDDSData)->AddRef();
}
else
{
ImageLoadInfo ImgLoadInfo;
if( Extension == "png" )
ImgLoadInfo.Format = EImageFileFormat::png;
else if( Extension == "jpeg" || Extension == "jpg" )
ImgLoadInfo.Format = EImageFileFormat::jpeg;
else if( Extension == "tiff" || Extension == "tif" )
ImgLoadInfo.Format = EImageFileFormat::tiff;
else
LOG_ERROR_AND_THROW( "Unsupported file format ", Extension );
*ppImage = new Image(pFileStream, ImgLoadInfo);
(*ppImage)->AddRef();
}
}
