current/Global/Exporters.pas

unit Exporters;

interface

procedure ExportDatFile(ConnectionID, FileID: Integer; filename: String);
procedure ExportRawFiles(ConnectionID, FileID: Integer; filename: String);
procedure ExportRawFile(ConnectionID, FileID, DatOffset: Integer; filename: String);
function ExportConverted(ConnectionID, FileID: Integer; filename: String): Integer;


implementation

uses
  Classes, SysUtils, TypeDefs, ConnectionManager, OniImgClass;

type
  TExportHandler = function(ConnectionID, FileID: Integer; filename: String): Integer;
  TExportHandlers = record
    Ext:     String[4];
    needed:  Boolean;
    Handler: TExportHandler;
  end;

var
  ExportHandlers: array of TExportHandlers;


procedure ExportDatFile(ConnectionID, FileID: Integer; filename: String);
var
  filestream: TFileStream;
begin
  if FileExists(filename) then
  begin
    // Overwrite???
  end;
  filestream := TFileStream.Create(filename, fmCreate);
  ConManager.Connection[ConnectionID].LoadDatFile(FileID, TStream(filestream));
  filestream.Free;
end;


procedure ExportRawFiles(ConnectionID, FileID: Integer; filename: String);
var
  i: Integer;
  rawlist: TRawDataList;
begin
  rawlist := ConManager.Connection[ConnectionID].GetRawList(fileid);
  if Length(rawlist) > 0 then
    for i := 0 to High(rawlist) do
      ExportRawFile(ConnectionID, FileID, rawlist[i].SrcOffset, filename);
end;


procedure ExportRawFile(ConnectionID, FileID, DatOffset: Integer; filename: String);
var
  filestream: TFileStream;
begin
  if FileExists(filename + '.raw0x' + IntToHex(DatOffset, 8)) then
  begin
    // Overwrite???
  end;
  filestream := TFileStream.Create(filename + '.raw0x' + IntToHex(DatOffset, 8), fmCreate);
  ConManager.Connection[ConnectionID].LoadRawFile(FileID, DatOffset, TStream(filestream));
  filestream.Free;
end;

function ExportConverted(ConnectionID, FileID: Integer; filename: String): Integer;
var
  i: Integer;
  fileinfo: TFileInfo;
begin
  fileinfo := ConManager.Connection[ConnectionID].GetFileInfo(FileID);
  if Length(ExportHandlers) > 0 then
    for i := 0 to High(ExportHandlers) do
      if ExportHandlers[i].Ext = fileinfo.Extension then
        Result := ExportHandlers[i].Handler(ConnectionID, FileID, filename);
end;


function ExportSNDD(ConnectionID, FileID: Integer; filename: String): Integer;
type
  TDatData = packed record
    {0x00}
    _fileid:         Integer;
    level:           Integer;
    FormatSize:      Integer;
    AudioFormat:     Word;
    NumChannels:     Word;
    {0x10}
    SampleRate:      Integer;
    ByteRate:        Integer;
    BlockAlign:      Word;
    BitsPerSample:   Word;
    {0x1C}
    SizeExtHeader:   Word;
    SamplesPerBlock: Word;
    NumCoefficients: Word;
    Coefficients:    array[0..6] of Integer;
    {0x3E}
    Duration:        Word;
    {0x40}
    RawSize:         Integer;
    RawPos:          Integer;
  end;
var
  filestream: TFileStream;
  DatData:     TDatData;
  i: Integer;

  //Wave Header Stuff
  ASCII_RIFF:   LongWord; //"RIFF"
  WAVE_Len:     Integer;
  ASCII_WAVE:   LongWord; //"WAVE"
  ASCII_FMT:    LongWord; //"fmt "
  WAVE_FMT_Len: Integer;
  ASCII_DATA:   LongWord; //"data"
  WAVE_DataLen:  Integer;
begin
  Result := 0;
  ConManager.Connection[ConnectionID].LoadDatFilePart(FileID, 0, SizeOf(DatData), @DatData);
  with DatData do
  begin
    //Initializing Header vars
    ASCII_RIFF   := 1179011410; // 'RIFF'
    WAVE_Len     := RAWSize + 70;
    ASCII_WAVE   := 1163280727;  // 'WAVE'
    ASCII_FMT    := 544501094;   // 'fmt '
    WAVE_FMT_Len := 50;          // 50 bytes
    ASCII_DATA   := 1635017060;  // 'data'
    WAVE_DataLen := RAWSize;

    if FileExists(filename+'.wav') then
    begin
      // Overwrite???
    end;

    //Now start packing this into a neat wave...
    filestream := TFileStream.Create(filename + '.wav', fmCreate);
    filestream.Write(ASCII_RIFF, SizeOf(ASCII_RIFF));
    filestream.Write(WAVE_Len, SizeOf(WAVE_Len));
    filestream.Write(ASCII_WAVE, SizeOf(ASCII_WAVE));
    filestream.Write(ASCII_FMT, SizeOf(ASCII_FMT));
    filestream.Write(WAVE_FMT_Len, SizeOf(WAVE_FMT_Len));
    filestream.Write(AudioFormat, SizeOf(AudioFormat));
    filestream.Write(NumChannels, SizeOf(NumChannels));
    filestream.Write(Samplerate, SizeOf(Samplerate));
    filestream.Write(ByteRate, SizeOf(ByteRate));
    filestream.Write(BlockAlign, SizeOf(BlockAlign));
    filestream.Write(BitsPerSample, SizeOf(BitsPerSample));
    filestream.Write(SizeExtHeader, SizeOf(SizeExtHeader));
    filestream.Write(SamplesPerBlock, SizeOf(SamplesPerBlock));
    filestream.Write(NumCoefficients, SizeOf(NumCoefficients));
    for i := 0 to High(Coefficients) do
      filestream.Write(Coefficients[i], SizeOf(Coefficients[i]));
    filestream.Write(ASCII_DATA, SizeOf(ASCII_DATA));
    filestream.Write(WAVE_DataLen, SizeOf(WAVE_DataLen));
    ConManager.Connection[ConnectionID].LoadRawFile(FileID, $44, TStream(filestream));
    filestream.Free;
  end;
end;


function ExportTRAC(ConnectionID, FileID: Integer; filename: String): Integer;
var
  link: Integer;
  linkcount: Word;
  i: Integer;
begin
  Result := 0;

  ConManager.Connection[ConnectionID].LoadDatFilePart(FileID, $18, SizeOf(link), @link);
  link := link div 256;

  ConManager.Connection[ConnectionID].LoadDatFilePart(FileID, $1E, SizeOf(linkcount), @linkcount);
  for i := 1 to linkcount do
  begin
    ConManager.Connection[ConnectionID].LoadDatFilePart(FileID, $20 + (i - 1) * 12 + 8, SizeOf(link), @link);
    link := link div 256;
  end;
end;


function ExportTXAN(ConnectionID, FileID: Integer; filename: String): Integer;
var
  loop_speed, unknown: Word;
  linkcount: Integer;
  link: Integer;
  i: Byte;
begin
  Result := 0;

  ConManager.Connection[ConnectionID].LoadDatFilePart(FileID, $14, SizeOf(loop_speed), @loop_speed);
  ConManager.Connection[ConnectionID].LoadDatFilePart(FileID, $16, SizeOf(unknown), @unknown);

  ConManager.Connection[ConnectionID].LoadDatFilePart(FileID, $1C, SizeOf(linkcount), @linkcount);
  for i := 0 to linkcount - 1 do
  begin
    ConManager.Connection[ConnectionID].LoadDatFilePart(FileID, $20 + i * 4, SizeOf(link), @link);
    link := link div 256;
    if link = 0 then
      link := fileid - 1;
  end;
end;


function ExportImage(ConnectionID, FileID: Integer; filename: String): Integer;
var
  img: TOniImage;
begin
  Result := 0;

  if FileExists(filename+'.bmp') then
  begin
    // Overwrite???
  end;

  img := TOniImage.Create;
  img.Load(ConnectionID, FileID);
  img.WriteToBMP(filename+'.bmp');
  img.Free;
end;


procedure InsertExportHandler(ext: String; needed: Boolean; handler: TExportHandler);
begin
  SetLength(ExportHandlers, Length(ExportHandlers) + 1);
  ExportHandlers[High(ExportHandlers)].Ext := ext;
  ExportHandlers[High(ExportHandlers)].needed := needed;
  ExportHandlers[High(ExportHandlers)].handler := handler;
end;

{
  ExportHandlers: array[1..3] of TExportHandlers = (
//    (Ext:'ABNA'; needed:False),
//    (Ext:'AGDB'; needed:False),
    (Ext: 'SNDD'; needed: True; Handler: ExportSNDD),
//    (Ext:'TRAC'; needed:True; Handler:ExportTRAC),
//    (Ext:'TXAN'; needed:True; Handler:ExportTXAN),
    (Ext:'TXMB'; needed:True; Handler:ExportImage),
    (Ext:'TXMP'; needed:True; Handler:ExportImage)
);
}

initialization
//  InsertExportHandler('ABNA', False, ABNA);
//  InsertExportHandler('AGDB', False, AGDB);
  InsertExportHandler('SNDD', True, ExportSNDD);
  InsertExportHandler('TXMB', True, ExportImage);
  InsertExportHandler('TXMP', True, ExportImage);
end.
Revision:	113
Committed:	Sun Feb 25 17:20:22 2007 UTC (18 years, 8 months ago) by alloc
Content type:	text/x-pascal
File size:	7764 byte(s)
Log Message:
#	Content
1	unit Exporters;
2
3	interface
4
5	procedure ExportDatFile(ConnectionID, FileID: Integer; filename: String);
6	procedure ExportRawFiles(ConnectionID, FileID: Integer; filename: String);
7	procedure ExportRawFile(ConnectionID, FileID, DatOffset: Integer; filename: String);
8	function ExportConverted(ConnectionID, FileID: Integer; filename: String): Integer;
9
10
11	implementation
12
13	uses
14	Classes, SysUtils, TypeDefs, ConnectionManager, OniImgClass;
15
16	type
17	TExportHandler = function(ConnectionID, FileID: Integer; filename: String): Integer;
18	TExportHandlers = record
19	Ext: String[4];
20	needed: Boolean;
21	Handler: TExportHandler;
22	end;
23
24	var
25	ExportHandlers: array of TExportHandlers;
26
27
28	procedure ExportDatFile(ConnectionID, FileID: Integer; filename: String);
29	var
30	filestream: TFileStream;
31	begin
32	if FileExists(filename) then
33	begin
34	// Overwrite???
35	end;
36	filestream := TFileStream.Create(filename, fmCreate);
37	ConManager.Connection[ConnectionID].LoadDatFile(FileID, TStream(filestream));
38	filestream.Free;
39	end;
40
41
42	procedure ExportRawFiles(ConnectionID, FileID: Integer; filename: String);
43	var
44	i: Integer;
45	rawlist: TRawDataList;
46	begin
47	rawlist := ConManager.Connection[ConnectionID].GetRawList(fileid);
48	if Length(rawlist) > 0 then
49	for i := 0 to High(rawlist) do
50	ExportRawFile(ConnectionID, FileID, rawlist[i].SrcOffset, filename);
51	end;
52
53
54	procedure ExportRawFile(ConnectionID, FileID, DatOffset: Integer; filename: String);
55	var
56	filestream: TFileStream;
57	begin
58	if FileExists(filename + '.raw0x' + IntToHex(DatOffset, 8)) then
59	begin
60	// Overwrite???
61	end;
62	filestream := TFileStream.Create(filename + '.raw0x' + IntToHex(DatOffset, 8), fmCreate);
63	ConManager.Connection[ConnectionID].LoadRawFile(FileID, DatOffset, TStream(filestream));
64	filestream.Free;
65	end;
66
67	function ExportConverted(ConnectionID, FileID: Integer; filename: String): Integer;
68	var
69	i: Integer;
70	fileinfo: TFileInfo;
71	begin
72	fileinfo := ConManager.Connection[ConnectionID].GetFileInfo(FileID);
73	if Length(ExportHandlers) > 0 then
74	for i := 0 to High(ExportHandlers) do
75	if ExportHandlers[i].Ext = fileinfo.Extension then
76	Result := ExportHandlers[i].Handler(ConnectionID, FileID, filename);
77	end;
78
79
80
81
82	function ExportSNDD(ConnectionID, FileID: Integer; filename: String): Integer;
83	type
84	TDatData = packed record
85	{0x00}
86	_fileid: Integer;
87	level: Integer;
88	FormatSize: Integer;
89	AudioFormat: Word;
90	NumChannels: Word;
91	{0x10}
92	SampleRate: Integer;
93	ByteRate: Integer;
94	BlockAlign: Word;
95	BitsPerSample: Word;
96	{0x1C}
97	SizeExtHeader: Word;
98	SamplesPerBlock: Word;
99	NumCoefficients: Word;
100	Coefficients: array[0..6] of Integer;
101	{0x3E}
102	Duration: Word;
103	{0x40}
104	RawSize: Integer;
105	RawPos: Integer;
106	end;
107	var
108	filestream: TFileStream;
109	DatData: TDatData;
110	i: Integer;
111
112	//Wave Header Stuff
113	ASCII_RIFF: LongWord; //"RIFF"
114	WAVE_Len: Integer;
115	ASCII_WAVE: LongWord; //"WAVE"
116	ASCII_FMT: LongWord; //"fmt "
117	WAVE_FMT_Len: Integer;
118	ASCII_DATA: LongWord; //"data"
119	WAVE_DataLen: Integer;
120	begin
121	Result := 0;
122	ConManager.Connection[ConnectionID].LoadDatFilePart(FileID, 0, SizeOf(DatData), @DatData);
123	with DatData do
124	begin
125	//Initializing Header vars
126	ASCII_RIFF := 1179011410; // 'RIFF'
127	WAVE_Len := RAWSize + 70;
128	ASCII_WAVE := 1163280727; // 'WAVE'
129	ASCII_FMT := 544501094; // 'fmt '
130	WAVE_FMT_Len := 50; // 50 bytes
131	ASCII_DATA := 1635017060; // 'data'
132	WAVE_DataLen := RAWSize;
133
134	if FileExists(filename+'.wav') then
135	begin
136	// Overwrite???
137	end;
138
139	//Now start packing this into a neat wave...
140	filestream := TFileStream.Create(filename + '.wav', fmCreate);
141	filestream.Write(ASCII_RIFF, SizeOf(ASCII_RIFF));
142	filestream.Write(WAVE_Len, SizeOf(WAVE_Len));
143	filestream.Write(ASCII_WAVE, SizeOf(ASCII_WAVE));
144	filestream.Write(ASCII_FMT, SizeOf(ASCII_FMT));
145	filestream.Write(WAVE_FMT_Len, SizeOf(WAVE_FMT_Len));
146	filestream.Write(AudioFormat, SizeOf(AudioFormat));
147	filestream.Write(NumChannels, SizeOf(NumChannels));
148	filestream.Write(Samplerate, SizeOf(Samplerate));
149	filestream.Write(ByteRate, SizeOf(ByteRate));
150	filestream.Write(BlockAlign, SizeOf(BlockAlign));
151	filestream.Write(BitsPerSample, SizeOf(BitsPerSample));
152	filestream.Write(SizeExtHeader, SizeOf(SizeExtHeader));
153	filestream.Write(SamplesPerBlock, SizeOf(SamplesPerBlock));
154	filestream.Write(NumCoefficients, SizeOf(NumCoefficients));
155	for i := 0 to High(Coefficients) do
156	filestream.Write(Coefficients[i], SizeOf(Coefficients[i]));
157	filestream.Write(ASCII_DATA, SizeOf(ASCII_DATA));
158	filestream.Write(WAVE_DataLen, SizeOf(WAVE_DataLen));
159	ConManager.Connection[ConnectionID].LoadRawFile(FileID, $44, TStream(filestream));
160	filestream.Free;
161	end;
162	end;
163
164
165
166
167	function ExportTRAC(ConnectionID, FileID: Integer; filename: String): Integer;
168	var
169	link: Integer;
170	linkcount: Word;
171	i: Integer;
172	begin
173	Result := 0;
174
175	ConManager.Connection[ConnectionID].LoadDatFilePart(FileID, $18, SizeOf(link), @link);
176	link := link div 256;
177
178	ConManager.Connection[ConnectionID].LoadDatFilePart(FileID, $1E, SizeOf(linkcount), @linkcount);
179	for i := 1 to linkcount do
180	begin
181	ConManager.Connection[ConnectionID].LoadDatFilePart(FileID, $20 + (i - 1) * 12 + 8, SizeOf(link), @link);
182	link := link div 256;
183	end;
184	end;
185
186
187
188
189	function ExportTXAN(ConnectionID, FileID: Integer; filename: String): Integer;
190	var
191	loop_speed, unknown: Word;
192	linkcount: Integer;
193	link: Integer;
194	i: Byte;
195	begin
196	Result := 0;
197
198	ConManager.Connection[ConnectionID].LoadDatFilePart(FileID, $14, SizeOf(loop_speed), @loop_speed);
199	ConManager.Connection[ConnectionID].LoadDatFilePart(FileID, $16, SizeOf(unknown), @unknown);
200
201	ConManager.Connection[ConnectionID].LoadDatFilePart(FileID, $1C, SizeOf(linkcount), @linkcount);
202	for i := 0 to linkcount - 1 do
203	begin
204	ConManager.Connection[ConnectionID].LoadDatFilePart(FileID, $20 + i * 4, SizeOf(link), @link);
205	link := link div 256;
206	if link = 0 then
207	link := fileid - 1;
208	end;
209	end;
210
211
212
213
214	function ExportImage(ConnectionID, FileID: Integer; filename: String): Integer;
215	var
216	img: TOniImage;
217	begin
218	Result := 0;
219
220	if FileExists(filename+'.bmp') then
221	begin
222	// Overwrite???
223	end;
224
225	img := TOniImage.Create;
226	img.Load(ConnectionID, FileID);
227	img.WriteToBMP(filename+'.bmp');
228	img.Free;
229	end;
230
231
232
233	procedure InsertExportHandler(ext: String; needed: Boolean; handler: TExportHandler);
234	begin
235	SetLength(ExportHandlers, Length(ExportHandlers) + 1);
236	ExportHandlers[High(ExportHandlers)].Ext := ext;
237	ExportHandlers[High(ExportHandlers)].needed := needed;
238	ExportHandlers[High(ExportHandlers)].handler := handler;
239	end;
240
241	{
242	ExportHandlers: array[1..3] of TExportHandlers = (
243	// (Ext:'ABNA'; needed:False),
244	// (Ext:'AGDB'; needed:False),
245	(Ext: 'SNDD'; needed: True; Handler: ExportSNDD),
246	// (Ext:'TRAC'; needed:True; Handler:ExportTRAC),
247	// (Ext:'TXAN'; needed:True; Handler:ExportTXAN),
248	(Ext:'TXMB'; needed:True; Handler:ExportImage),
249	(Ext:'TXMP'; needed:True; Handler:ExportImage)
250	);
251	}
252
253	initialization
254	// InsertExportHandler('ABNA', False, ABNA);
255	// InsertExportHandler('AGDB', False, AGDB);
256	InsertExportHandler('SNDD', True, ExportSNDD);
257	InsertExportHandler('TXMB', True, ExportImage);
258	InsertExportHandler('TXMP', True, ExportImage);
259	end.