Image* TGAImageDecoder::Decode(DataStream* ds) {
    TGAHeader header;
    if (!LoadHeader(&header, ds)) return 0;
    ImageFormat fmt = IMAGE_FORMAT_UNKNOWN;
    if (header.bitsperpixel==32)
        fmt = IMAGE_FORMAT_RGBA;
    else if(header.bitsperpixel==24)
        fmt = IMAGE_FORMAT_RGB;
    else if (header.bitsperpixel==8)
        fmt = IMAGE_FORMAT_GRAY;

    bool rle = (header.datatypecode & 8)!=0;
    UInt32 width = header.width;
    UInt32 height = header.height;
    ImageImpl* img = new ImageImpl(width,height,fmt);
    bool res = rle ? LoadRLE(ds,img) : LoadRAW(ds,img);
    if (!res) {
        delete img;
        img = 0;
    } else {
        img->SwapChannelsRB();
        if ( (header.imagedescriptor & 0x20 ) == 0) {
            img->FlipV();
        }
    }
    return img;
}

// イメージ読み込み指示
IBMP* BmpIO_Load( File::IResourceFile *infile )
{
	unsigned int ctsize;	// カラーテーブルのエントリ数
	int blen;		// １ピクセルあたりビット長
	IBMP *pBmp;
	int w, h;
	BOOL r;

	// ファイルヘッダの入力、カラーテーブル長、
	// pixelsの領域長、ピクセルあたりのビット長を取得
	if ( !LoadHeader( infile, &ctsize, &blen, &w, &h ) ) return FALSE;

	// メモリ領域を確保
	pBmp = BmpIO_CreateBitmap( w, h, blen );
	if ( NULL == pBmp ) return NULL;

	// ピクセルあたりビット長別にファイルボディ部を読み込む
	if ( 24 != blen )
		r = LoadBody1( infile, blen, pBmp );
	else
		r = LoadBody24( infile, pBmp );

	if ( !r ) {
		// 失敗
		BmpIO_DeleteBitmap( pBmp );
		return NULL;
	}

	return pBmp;
}

/*
** load precompiled chunk
*/
Closure* luaU_undump (lua_State* L, ZIO* Z, Mbuffer* buff, const char* name)
{
 LoadState S;
 Closure* cl;
 if (*name=='@' || *name=='=')
  S.name=name+1;
 else if (*name==LUA_SIGNATURE[0])
  S.name="binary string";
 else
  S.name=name;
 S.L=L;
 S.Z=Z;
 S.b=buff;
 LoadHeader(&S);
 cl=luaF_newLclosure(L,1);
 setclLvalue(L,L->top,cl); incr_top(L);
 cl->l.p=luaF_newproto(L);
 LoadFunction(&S,cl->l.p);
 if (cl->l.p->sizeupvalues != 1)
 {
  Proto* p=cl->l.p;
  cl=luaF_newLclosure(L,cl->l.p->sizeupvalues);
  cl->l.p=p;
  setclLvalue(L,L->top-1,cl);
 }
 luai_verifycode(L,buff,cl->l.p);
 return cl;
}

//----------------------------------------------------------------------------------------------------------------------
bool HoudiniGeo::Load(
                      const std::string& _fName
                     )
{
  // Open the stream and parse
  std::ifstream fileIn;
  fileIn.open(_fName.c_str());
  if (!fileIn.is_open())
  {
    std::cout <<"File : "<<_fName<<" Not founds "<<std::endl;
    return false;
  }
// first we check the header to see if we have a valid file
// if only OBJ's did this!!

  LoadHeader(fileIn);
  // check to see if we need to load any attribs
  if(m_nPointAttrib !=0)
  {
    LoadPointAttribDictionary(fileIn);
  }
  LoadPoints(fileIn);
  // set the center and BBox
  this->CalcDimensions();

  fileIn.close();
  return true;
}

STDMETHODIMP CImpIPersistStream::Load(LPSTREAM pIStream)
{                      
	ASSERT(pIStream);

ebFILEHEADER Head; 
	memset(&Head, 0, sizeof(Head));                          	
HRESULT hr = LoadHeader (pIStream, &Head) ;
	if (FAILED (hr)) return hr;

	if(m_hCode) CoTaskMemFree(m_hCode); 
	m_hCode = NULL;

	if (Head.dwCodeSz > 0 && Head.dwScriptSz > 0) 
		hr = LoadCode_FromDB (pIStream, Head); 
	else if (Head.dwScriptSz > 0)
		hr = LoadScript_FromDB (pIStream, Head);
	else 
		ASSERT(0);

	if (FAILED(hr)) return hr;					

	m_fIsDirty = false;
	
return hr;
}

BYTE MMXCore::CheckROM()
{
	LoadHeader();
	if (*(LPDWORD)(header->title+0) == 0x4147454D)
		if (*(LPDWORD)(header->title+4) == 0x204E414D)
		{
			switch(*(LPWORD)(header->title+8))
			{
			case 0x2058:
				type = 0;
				break;
			case 0x3258:
				type = 1;
				break;
			case 0x3358:
				type = 2;
				break;
			default:
				type = 0xFF;
				return 0;
			}
			return type+1;
		}
	type = 0xFF;
	return 0;
}

//=================================================================================================
// Load metadata only from mesh (points)
void Mesh::LoadMetadata(StreamReader& stream)
{
	if(vb)
		return;
	LoadHeader(stream);
	stream.SetOffset(head.points_offset);
	LoadPoints(stream);
}

//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
    : TForm(Owner)
{
    Caption = "远程桌面连接管理器";
    Application->Title = Caption;
    LoadHeader();
    LoadDb();
    Timer1->Enabled = true;
}

void RSOView::LoadAll(u32 address)
{
  LoadHeader(address);
  LoadSections();
  LoadImports();
  LoadExports();
  LoadInternals();
  LoadExternals();
}

void CWorkGrammar::VerifyHeader(TInputStream* input)
{
    if (!LoadHeader(input)) {
        Stroka msg = "Failed to load tomita grammar: the binary is incompatible with your program. "
                     "You should either re-compiler your .bin, or rebuild your program from corresponding version of sources.\n";
        Cerr << msg << Endl;
        ythrow yexception() << msg;
    }
}

bool PSFLoader::Load(bool show)
{
	if(!psf_f.IsOpened()) return false;

	m_show_log = show;

	if(!LoadHeader()) return false;
	if(!LoadKeyTable()) return false;
	if(!LoadDataTable()) return false;

	return true;
}

 bool TGAImageDecoder::GetFileInfo(DataStream* ds, ImageInfo* info) {
     TGAHeader header;
     if (!LoadHeader(&header, ds)) return false;
     if (header.bitsperpixel==32)
         info->image_format = IMAGE_FORMAT_RGBA;
     else if(header.bitsperpixel==24)
         info->image_format = IMAGE_FORMAT_RGB;
     else if (header.bitsperpixel==8)
         info->image_format = IMAGE_FORMAT_GRAY;
     else
         return false;
     info->width = header.width;
     info->height = header.height;
     return true;
 }

/*
** load precompiled chunk
*/
killa_Proto* killaU_undump (killa_State* L, killa_ZIO* Z, killa_Mbuffer* buff, const char* name)
{
 LoadState S;
 if (*name=='@' || *name=='=')
  S.name=name+1;
 else if (*name == KILLA_SIGNATURE[0])
  S.name="binary string";
 else
  S.name=name;
 S.L=L;
 S.Z=Z;
 S.b=buff;
 LoadHeader(&S);
 return killai_verifycode(L,buff,LoadFunction(&S));
}

/*
** load precompiled chunk
*/
Proto* luaU_undump (lua_State* L, ZIO* Z, Mbuffer* buff, const char* name)
{
 LoadState S;
 if (*name=='@' || *name=='=')
  S.name=name+1;
 else if (*name==LUA_SIGNATURE[0])
  S.name="binary string";
 else
  S.name=name;
 S.L=L;
 S.Z=Z;
 S.b=buff;
 LoadHeader(&S);
 return LoadFunction(&S,luaS_newliteral(L,"=?"));
}

int SWF::LoadSWF(const char* path)
{
	m_pFile = new SWF_FILE;
	m_pFile->LoadSWF(path);
	
	if(!m_pFile->IsLoaded())
		return -1;
	
	LoadHeader(m_pFile);

	while(!m_bIsEnd)
		LoadTag(m_pFile);
	
	return 0;
}

bool TROPUSRLoader::Load(const std::string& filepath, const std::string& configpath)
{
	if (m_file)
		Close();

	// TODO: This seems to be always true... A bug in ExistsFile() ?
	if (!Emu.GetVFS().ExistsFile(filepath))
		Generate(filepath, configpath);

	m_file = Emu.GetVFS().OpenFile(filepath, vfsRead);
	LoadHeader();
	LoadTableHeaders();
	LoadTables();

	Close();
	return true;
}

void
ReasoningKernel :: Load ( SaveLoadManager& m )
{
	TsProcTimer t;
	t.Start();
	m.checkStream();
//	releaseKB();	// we'll start a new one if necessary
	LoadHeader(m);
	m.checkStream();
	LoadOptions(m);
	m.checkStream();
	LoadKB(m);
	m.checkStream();
	LoadIncremental(m);
	m.checkStream();
	t.Stop();
	std::cout << "Reasoner internal state loaded in " << t << " sec" << std::endl;
}

	//==========================================
	// 関数 : LoadBMPFromFilePointer
	// 目的 : 受け取ったファイルポインタが示すBMPファイルのロード
	// 戻り値: TImageInfo *	※読み込みに失敗した場合はNULLを返す
	// 引数 : FILE * pf	ファイルポインタ
	//==========================================
	TImageInfo * LoadBMPFromFilePointer(FILE * pf)
	{
		TImageInfo * pBmp;				// BMP用構造体のポインタ
		int nWidth;						// 横幅情報受け取り用
		int nHeight;					// 縦幅情報受け取り用
		unsigned short wBitCount;		// ビット数情報受け取り用
		unsigned long dwCompression;	// 圧縮情報受け取り用
		bool nResult;					// 処理結果受け取り用

		nResult = LoadHeader(pf);
		if (nResult == false) return NULL;		// ファイルヘッダ部の読み込みに失敗した場合、処理を終了して関数から脱出する

		// 情報ヘッダ部の読み込みを行い、横幅・縦幅・ビット数・圧縮情報　のデータを受け取る
		nResult = LoadInfo(pf, &nWidth, &nHeight, &wBitCount, &dwCompression);

		if (nResult == false) return NULL;		// 情報ヘッダ部の読み込みに失敗した場合、処理を終了して関数から脱出する

		pBmp = (TImageInfo *)malloc(sizeof(TImageInfo));	// TImageInfo型変数を動的確保する
		pBmp->nWidth = nWidth;							// 先ほど取得した横幅情報を代入する
		pBmp->nHeight = nHeight;						// 先ほど取得した縦幅情報を代入する
		pBmp->pbyPixels = NULL;							// ピクセル情報を入れるポインタはNULLで初期化しておく

		if (wBitCount != 24)	// 24bit形式でなかった場合
		{
			pBmp->bEffective = false;	// 対応できない形式であるため、フラグを折って関数から脱出する
			return pBmp;
		}
		if (dwCompression != 0)	// 圧縮されている場合
		{
			pBmp->bEffective = false;	// 対応できない形式であるため、フラグを折って関数から脱出する
			return pBmp;
		}
		pBmp->bEffective = true;	// 以上の条件をクリアしたということは対応できる形式であるため、フラグを立てておく

		pBmp->pbyPixels = LoadRGB(pf, pBmp->nWidth, pBmp->nHeight);	// RGB情報を読み込む

		if (pBmp->pbyPixels == NULL)	// RGB情報の読み込みに失敗した場合
		{
			free(pBmp);				// TImageInfo用に確保したメモリを解放する
			return NULL;
		}

		return pBmp;
	}

Loader::ResultStatus CIAContainer::Load(const std::vector<u8>& file_data) {
    Loader::ResultStatus result = LoadHeader(file_data);
    if (result != Loader::ResultStatus::Success)
        return result;

    // Load Title Metadata
    result = LoadTitleMetadata(file_data, GetTitleMetadataOffset());
    if (result != Loader::ResultStatus::Success)
        return result;

    // Load CIA Metadata
    if (cia_header.meta_size) {
        result = LoadMetadata(file_data, GetMetadataOffset());
        if (result != Loader::ResultStatus::Success)
            return result;
    }

    return Loader::ResultStatus::Success;
}

/*
** load precompiled chunk
*/
Proto* luaU_undump (lua_State* L, ZIO* Z, Mbuffer* buff, const char* name,
                    size_t nameLength)
{
    LoadState S;
    if (*name=='@' || *name=='=') {
        S.name=name+1;
        S.nameLength = nameLength -1;
    } else if (*name==LUA_SIGNATURE[0]) {
        S.name="binary string";
        S.nameLength = strlen(S.name);
    } else {
        S.name=name;
        S.nameLength = nameLength;
    }
    S.L=L;
    S.Z=Z;
    S.b=buff;
    LoadHeader(&S);
    return LoadFunction(&S,luaS_newliteral(L,"=?"));
}