]>
Commit | Line | Data |
---|---|---|
1 | //$Id$ | |
2 | ||
3 | // Author: Anders Vestbo <mailto:vestbo@fi.uib.no> | |
4 | //*-- Copyright © ASV | |
5 | ||
6 | #include "AliL3StandardIncludes.h" | |
7 | ||
8 | #include "AliL3DataHandler.h" | |
9 | #include "AliL3Logging.h" | |
10 | #include "AliL3TransBit.h" | |
11 | #include "AliL3Transform.h" | |
12 | ||
13 | #if GCCVERSION == 3 | |
14 | using namespace std; | |
15 | #endif | |
16 | ||
17 | //_____________________________________________________________ | |
18 | // AliL3DataHandler | |
19 | // | |
20 | // HLT Binary file handler. | |
21 | // | |
22 | // This class have more or less the same functionality as AliL3MemHandler, | |
23 | // except that it handles 8 bit ADC-values. Reading and writing is done in the same way | |
24 | // as illustrated in example 1) and 2) in AliL3MemHandler. | |
25 | // | |
26 | // For converting 10 bit data files to 8 bit data files, do: | |
27 | // | |
28 | // AliL3MemHandler *file = new AliL3DataHandler(); | |
29 | // file->Init(slice,patch); | |
30 | // file->SetBinaryInput(inputfile); //10 bit data file | |
31 | // file->SetBinaryOutput(outputfile); //8 bit data file | |
32 | // file->Convert10to8Bit(); | |
33 | // file->CloseBinaryInput(); | |
34 | // file->CloseBinaryOutput(); | |
35 | // delete file; | |
36 | // | |
37 | // Compress data format | |
38 | // -------------------- | |
39 | // | |
40 | // The data is RLE encoded, using _8_bit representation of the ADC-values. | |
41 | // Conversion is done in the class AliL3TransBit. | |
42 | // | |
43 | // In the beginning of every row, the row number if written and the number of pads | |
44 | // containing data on that row. For every pad with data the pad number is written, | |
45 | // and then comes the ADC-values on that pad. When a serie of zeros occure, a zero | |
46 | // is written followed by the number of zeros. If the number of zeros is more than | |
47 | // 255 (8 bit), another 8 bit word is written for the remaining. At the end of one | |
48 | // pad, 2 zeros are written. Example: | |
49 | // | |
50 | // ROW NPADSWITHDATA PAD 0 NZEROS ADC ADC ADC ADC 0 NZEROS ADC ADC 0 0 | |
51 | // | |
52 | // Everything is written using 8 bit; | |
53 | // (ROW < 176, PAD < 200, ADC < 255, if(NZEROS > 255) write 2 words;) | |
54 | ||
55 | ClassImp(AliL3DataHandler) | |
56 | ||
57 | AliL3DataHandler::AliL3DataHandler() | |
58 | { | |
59 | fBitTransformer = 0; | |
60 | LOG(AliL3Log::kInformational,"AliL3DataHandler::AliL3DataHandler","Data format") | |
61 | <<"8 bit data handler initialized"<<ENDLOG; | |
62 | } | |
63 | ||
64 | AliL3DataHandler::~AliL3DataHandler() | |
65 | { | |
66 | if(fBitTransformer) | |
67 | delete fBitTransformer; | |
68 | } | |
69 | ||
70 | void AliL3DataHandler::Convert10to8Bit() | |
71 | { | |
72 | //Convert from 10 bit data in inputfile, to 8 bit data written to outputfile. | |
73 | ||
74 | if(!fInBinary) | |
75 | { | |
76 | LOG(AliL3Log::kError,"AliL3DataHandler::Convert10to8Bit","File") | |
77 | <<AliL3Log::kHex<<"Pointer to input file : "<<(Int_t)fInBinary<<ENDLOG; | |
78 | return; | |
79 | } | |
80 | if(!fOutBinary) | |
81 | { | |
82 | LOG(AliL3Log::kError,"AliL3DataHandler::Convert10to8Bit","File") | |
83 | <<AliL3Log::kHex<<"Pointer to output file : "<<(Int_t)fOutBinary<<ENDLOG; | |
84 | return; | |
85 | } | |
86 | ||
87 | ||
88 | //Initialize the bit transformation class: | |
89 | fBitTransformer = new AliL3TransBit_v1(); | |
90 | Int_t b0=10; // original number of bits | |
91 | Int_t b1=8; // compressed | |
92 | fBitTransformer->SetBits(b0,b1); | |
93 | fBitTransformer->FindOptimumX0(); | |
94 | fBitTransformer->Update(); | |
95 | ||
96 | AliL3MemHandler *memory = new AliL3MemHandler(); | |
97 | memory->Init(fSlice,fPatch); | |
98 | memory->SetBinaryInput(fInBinary); | |
99 | UInt_t nrow; | |
100 | AliL3DigitRowData *data = (AliL3DigitRowData*)memory->CompBinary2Memory(nrow); | |
101 | ||
102 | Memory2CompBinary(nrow,data); | |
103 | ||
104 | delete memory; | |
105 | } | |
106 | ||
107 | Bool_t AliL3DataHandler::Memory2CompBinary(UInt_t nrow,AliL3DigitRowData *data) | |
108 | { | |
109 | //Compress data by RLE, and write to a binary file. | |
110 | ||
111 | UInt_t size = GetCompMemorySize(nrow,data); | |
112 | Byte_t *comp = Allocate(size); | |
113 | Memory2CompMemory(nrow,data,comp); | |
114 | if(!CompMemory2CompBinary(nrow,comp,size)) | |
115 | { | |
116 | LOG(AliL3Log::kError,"AliL3DataHandler::Memory2CompBinary","File") | |
117 | <<"Error writing to file "<<ENDLOG; | |
118 | return 0; | |
119 | } | |
120 | Free(); | |
121 | return kTRUE; | |
122 | } | |
123 | ||
124 | AliL3DigitRowData *AliL3DataHandler::CompBinary2Memory(UInt_t &nrow) | |
125 | { | |
126 | //Read RLE compressed binary file, unpack it and return pointer to it. | |
127 | ||
128 | AliL3MemHandler *memory = new AliL3MemHandler(); | |
129 | memory->SetBinaryInput(fInBinary); | |
130 | Byte_t *comp = memory->Allocate(); | |
131 | ||
132 | if(!CompBinary2CompMemory(nrow,comp)) | |
133 | { | |
134 | LOG(AliL3Log::kError,"AliL3DataHandler::CompBinary2Memory","File") | |
135 | <<"Error reading from file "<<ENDLOG; | |
136 | return 0; | |
137 | } | |
138 | ||
139 | UInt_t size = GetMemorySize(nrow,comp); | |
140 | AliL3DigitRowData *data = (AliL3DigitRowData*)Allocate(size); | |
141 | CompMemory2Memory(nrow,data,comp); | |
142 | delete memory; | |
143 | return data; | |
144 | } | |
145 | ||
146 | void AliL3DataHandler::Write(Byte_t *comp,UInt_t &index,UShort_t value) | |
147 | { | |
148 | //Write one value (=1 byte) to array comp. | |
149 | ||
150 | if(value > 255) | |
151 | { | |
152 | LOG(AliL3Log::kFatal,"AliL3DataHandler::Write","Bitnumbers") | |
153 | <<"Value too big for storing in 1 byte, something is wrong: "<<value<<" "<<index<<ENDLOG; | |
154 | } | |
155 | comp[index] = (Byte_t)value; | |
156 | index++; | |
157 | } | |
158 | ||
159 | Short_t AliL3DataHandler::Read(Byte_t *comp,UInt_t &index) | |
160 | { | |
161 | //Read one value (=1 byte) from array comp | |
162 | ||
163 | Short_t value = (Short_t)comp[index]; | |
164 | index++; | |
165 | return value; | |
166 | } | |
167 | ||
168 | Short_t AliL3DataHandler::Test(Byte_t *comp,UInt_t index) | |
169 | { | |
170 | //Check the value (=1 byte) in array comp, but not read. | |
171 | ||
172 | Short_t value = (Short_t)comp[index]; | |
173 | return value; | |
174 | } | |
175 | ||
176 | Bool_t AliL3DataHandler::Memory2CompMemory(UInt_t nrow,AliL3DigitRowData *data,Byte_t *comp) | |
177 | { | |
178 | //Perform RLE. | |
179 | ||
180 | if(!data) | |
181 | { | |
182 | LOG(AliL3Log::kError,"AliL3DataHandler::Memory2CompMemory","Data") | |
183 | <<AliL3Log::kHex<<" Pointer to data = "<<(Int_t)data<<ENDLOG; | |
184 | return 0; | |
185 | } | |
186 | if(!comp) | |
187 | { | |
188 | LOG(AliL3Log::kError,"AliL3DataHandler::Memory2CompMemory","Data") | |
189 | <<AliL3Log::kHex<<" Pointer to compressed data = "<<(Int_t)comp<<ENDLOG; | |
190 | return 0; | |
191 | } | |
192 | ||
193 | AliL3DigitRowData *rowPt = data; | |
194 | ||
195 | UInt_t index = 0; | |
196 | Int_t npads[200]; | |
197 | ||
198 | for(UInt_t i=0; i<nrow; i++) | |
199 | { | |
200 | //Write the row number: | |
201 | UShort_t value = rowPt->fRow; | |
202 | Write(comp,index,value); | |
203 | ||
204 | UShort_t number_of_pads=0; | |
205 | UShort_t max_pad = 0; | |
206 | ||
207 | for(Int_t j=0; j<200; j++) | |
208 | npads[j]=0; | |
209 | for(UInt_t dig=0; dig<rowPt->fNDigit; dig++) | |
210 | { | |
211 | if(rowPt->fDigitData[dig].fPad < 200) | |
212 | npads[rowPt->fDigitData[dig].fPad]++; | |
213 | } | |
214 | for(Int_t j=0; j<200; j++) | |
215 | { | |
216 | if(npads[j]) | |
217 | { | |
218 | number_of_pads++; | |
219 | max_pad = j; | |
220 | } | |
221 | } | |
222 | ||
223 | //Write the number of pads on this row: | |
224 | Write(comp,index,number_of_pads); | |
225 | UInt_t digit=0; | |
226 | ||
227 | for(UShort_t pad=0; pad <= max_pad; pad++) | |
228 | { | |
229 | ||
230 | if(digit >= rowPt->fNDigit || rowPt->fDigitData[digit].fPad != pad) | |
231 | continue; | |
232 | ||
233 | //Write the current pad: | |
234 | Write(comp,index,pad); | |
235 | ||
236 | if(digit < rowPt->fNDigit && rowPt->fDigitData[digit].fPad == pad) | |
237 | { | |
238 | if(rowPt->fDigitData[digit].fTime > 0) | |
239 | { | |
240 | //If first time!=0, write the number of following zeros, | |
241 | //and then the first timebin: | |
242 | Write(comp,index,0); | |
243 | ||
244 | //Check if we have to use more than 1 byte to write the zeros: | |
245 | Int_t number_of_zero_intervals=0; | |
246 | if(rowPt->fDigitData[digit].fTime >= 255) | |
247 | { | |
248 | number_of_zero_intervals++; | |
249 | Write(comp,index,255); | |
250 | if(rowPt->fDigitData[digit].fTime >= 2*255) | |
251 | { | |
252 | cerr<<"AliL3DataHandler::Memory2CompMemory : Should not happen "<<(Int_t)rowPt->fDigitData[digit].fTime<<endl; | |
253 | Write(comp,index,255); | |
254 | number_of_zero_intervals++; | |
255 | } | |
256 | } | |
257 | Write(comp,index,(rowPt->fDigitData[digit].fTime - number_of_zero_intervals*255)); | |
258 | } | |
259 | } | |
260 | ||
261 | while(digit < rowPt->fNDigit && rowPt->fDigitData[digit].fPad == pad) | |
262 | { | |
263 | UShort_t charge = rowPt->fDigitData[digit].fCharge; | |
264 | ||
265 | if(fBitTransformer) | |
266 | charge = fBitTransformer->Get0to1(charge); //Transform 10 to 8 bit. | |
267 | ||
268 | //Check for saturation: | |
269 | if(charge>255) | |
270 | { | |
271 | LOG(AliL3Log::kWarning,"AliL3DataHandler::Memory2CompMemory","Digit") | |
272 | <<"ADC-value saturated : "<<charge<<ENDLOG; | |
273 | charge=255; | |
274 | } | |
275 | ||
276 | //Write the charge: | |
277 | Write(comp,index,charge); | |
278 | ||
279 | //Check if the next digit is zero: | |
280 | if(digit+1 < rowPt->fNDigit && rowPt->fDigitData[digit+1].fPad == pad) | |
281 | { | |
282 | if(rowPt->fDigitData[digit].fTime + 1 != rowPt->fDigitData[digit+1].fTime) | |
283 | { | |
284 | Write(comp,index,0); | |
285 | UShort_t nzero = rowPt->fDigitData[digit+1].fTime - (rowPt->fDigitData[digit].fTime + 1); | |
286 | ||
287 | //Check if we have to use more than one byte to write the zeros: | |
288 | Int_t number_of_zero_intervals=0; | |
289 | if(nzero >= 255) | |
290 | { | |
291 | number_of_zero_intervals++; | |
292 | Write(comp,index,255); | |
293 | if(nzero >= 2*255) | |
294 | { | |
295 | cerr<<"AliL3DataHandler::Memory2CompMemory : Should not happen "<<(Int_t)rowPt->fDigitData[digit].fTime<<endl; | |
296 | Write(comp,index,255); | |
297 | number_of_zero_intervals++; | |
298 | } | |
299 | } | |
300 | Write(comp,index,(nzero - number_of_zero_intervals*255)); | |
301 | } | |
302 | } | |
303 | digit++; | |
304 | } | |
305 | ||
306 | //This is the end of the pad, state it with 2 zeros: | |
307 | Write(comp,index,0); | |
308 | Write(comp,index,0); | |
309 | } | |
310 | ||
311 | UpdateRowPointer(rowPt); | |
312 | ||
313 | } | |
314 | ||
315 | return index * sizeof(Byte_t); | |
316 | ||
317 | } | |
318 | ||
319 | UInt_t AliL3DataHandler::GetCompMemorySize(UInt_t nrow,AliL3DigitRowData *data) | |
320 | { | |
321 | //Calculate the size (in bytes) of RLE data. | |
322 | ||
323 | if(!data) | |
324 | { | |
325 | LOG(AliL3Log::kError,"AliL3DataHandler::GetCompMemorySize","Data") | |
326 | <<AliL3Log::kHex<<" Data pointer = "<<(Int_t)data<<ENDLOG; | |
327 | return 0; | |
328 | } | |
329 | ||
330 | AliL3DigitRowData *rowPt = data; | |
331 | ||
332 | UInt_t index = 0; | |
333 | Int_t npads[200]; | |
334 | ||
335 | for(UInt_t i=0;i<nrow;i++) | |
336 | { | |
337 | //Write the row number: | |
338 | index++; | |
339 | ||
340 | UShort_t max_pad=0; | |
341 | UShort_t number_of_pads = 0; | |
342 | ||
343 | for(Int_t j=0; j<200; j++) | |
344 | npads[j]=0; | |
345 | ||
346 | for(UInt_t dig=0; dig<rowPt->fNDigit; dig++) | |
347 | { | |
348 | if(rowPt->fDigitData[dig].fPad <200) | |
349 | npads[rowPt->fDigitData[dig].fPad]++; | |
350 | } | |
351 | for(Int_t j=0; j<200; j++) | |
352 | { | |
353 | if(npads[j]) | |
354 | { | |
355 | number_of_pads++; | |
356 | max_pad = j; | |
357 | } | |
358 | } | |
359 | ||
360 | //Write the number of pads on this row: | |
361 | index++; | |
362 | ||
363 | UInt_t digit=0; | |
364 | for(UShort_t pad=0; pad <= max_pad; pad++) | |
365 | { | |
366 | if(digit>=rowPt->fNDigit || rowPt->fDigitData[digit].fPad != pad) | |
367 | continue; | |
368 | ||
369 | //Write the current pad: | |
370 | index++; | |
371 | ||
372 | ||
373 | if(digit<rowPt->fNDigit && rowPt->fDigitData[digit].fPad == pad) | |
374 | { | |
375 | if(rowPt->fDigitData[digit].fTime > 0) | |
376 | { | |
377 | //If first time!=0, write the number of following zeros, | |
378 | //and then the first timebin: | |
379 | ||
380 | index++; | |
381 | index++; | |
382 | ||
383 | //Check if we have to use more than 1 byte to write the zeros: | |
384 | if(rowPt->fDigitData[digit].fTime >= 255) | |
385 | index++; | |
386 | if(rowPt->fDigitData[digit].fTime >= 2*255) | |
387 | index++; | |
388 | } | |
389 | } | |
390 | ||
391 | while(digit < rowPt->fNDigit && rowPt->fDigitData[digit].fPad == pad) | |
392 | { | |
393 | //Write the charge: | |
394 | index++; | |
395 | ||
396 | //Check if the next digit is zero: | |
397 | if(digit+1 < rowPt->fNDigit && rowPt->fDigitData[digit+1].fPad == pad) | |
398 | { | |
399 | if(rowPt->fDigitData[digit].fTime +1 != rowPt->fDigitData[digit+1].fTime) | |
400 | { | |
401 | index++; | |
402 | index++; | |
403 | ||
404 | //Check if we have to use more than 1 byte to write the zeros: | |
405 | UInt_t nzeros = rowPt->fDigitData[digit+1].fTime - rowPt->fDigitData[digit].fTime + 1; | |
406 | if(nzeros >= 255) | |
407 | index++; | |
408 | if(nzeros >= 2*255) | |
409 | index++; | |
410 | } | |
411 | } | |
412 | digit++; | |
413 | } | |
414 | ||
415 | //Mark the end of the pad with 2 zeros: | |
416 | index++; | |
417 | index++; | |
418 | } | |
419 | ||
420 | UpdateRowPointer(rowPt); | |
421 | } | |
422 | ||
423 | return index * sizeof(Byte_t); | |
424 | ||
425 | } | |
426 | ||
427 | UInt_t AliL3DataHandler::CompMemory2Memory(UInt_t nrow,AliL3DigitRowData *data,Byte_t *comp) | |
428 | { | |
429 | //Uncompress RLE data. | |
430 | ||
431 | if(!data) | |
432 | { | |
433 | LOG(AliL3Log::kError,"AliL3DataHandler::CompMemory2Memory","Array") | |
434 | <<AliL3Log::kHex<<"Pointer to data: "<<(Int_t)data<<ENDLOG; | |
435 | return 0; | |
436 | } | |
437 | if(!comp) | |
438 | { | |
439 | LOG(AliL3Log::kError,"AliL3DataHandler::CompMemory2Memory","Array") | |
440 | <<AliL3Log::kHex<<"Pointer to compressed data: "<<(Int_t)data<<ENDLOG; | |
441 | return 0; | |
442 | } | |
443 | ||
444 | Int_t outsize=0; | |
445 | ||
446 | AliL3DigitRowData *rowPt = data; | |
447 | UInt_t index=0; | |
448 | ||
449 | UShort_t pad,time,charge; | |
450 | for(UInt_t i=0; i<nrow; i++) | |
451 | { | |
452 | UInt_t ndigit=0; | |
453 | ||
454 | //Read the row: | |
455 | rowPt->fRow = Read(comp,index); | |
456 | ||
457 | //Read the number of pads: | |
458 | UShort_t npads = Read(comp,index); | |
459 | ||
460 | for(UShort_t p=0; p<npads; p++) | |
461 | { | |
462 | //Read the current pad: | |
463 | pad = Read(comp,index); | |
464 | ||
465 | time = 0; | |
466 | ||
467 | //Check for zeros: | |
468 | if(Test(comp,index) == 0) //Zeros | |
469 | { | |
470 | //Read the first zero | |
471 | Read(comp,index); | |
472 | ||
473 | ||
474 | if(Test(comp,index) == 0)//end of pad. | |
475 | { | |
476 | time = Read(comp,index); | |
477 | continue; | |
478 | } | |
479 | if( (time = Read(comp,index)) == 255 ) | |
480 | if( (time += Read(comp,index)) == 2*255) | |
481 | time += Read(comp,index); | |
482 | } | |
483 | ||
484 | while(1) | |
485 | { | |
486 | while( (charge = Read(comp,index)) != 0) | |
487 | { | |
488 | if(time >= AliL3Transform::GetNTimeBins()) | |
489 | cerr<<"AliL3DataHandler::CompMemory2Memory : Time out of range "<<time<<endl; | |
490 | rowPt->fDigitData[ndigit].fPad = pad; | |
491 | rowPt->fDigitData[ndigit].fTime = time; | |
492 | rowPt->fDigitData[ndigit].fCharge = charge; | |
493 | ndigit++; | |
494 | if(Test(comp,index) != 0) | |
495 | time++; | |
496 | } | |
497 | if(Test(comp,index) == 0) | |
498 | { | |
499 | Read(comp,index); //end of pad | |
500 | break; | |
501 | } | |
502 | UShort_t time_shift; | |
503 | if( (time_shift = Read(comp,index)) == 255) | |
504 | if( (time_shift += Read(comp,index)) == 2*255) | |
505 | time_shift += Read(comp,index); | |
506 | time += time_shift; | |
507 | ||
508 | } | |
509 | } | |
510 | rowPt->fNDigit = ndigit; | |
511 | UpdateRowPointer(rowPt); | |
512 | outsize += sizeof(AliL3DigitData)*ndigit + sizeof(AliL3DigitRowData); | |
513 | } | |
514 | ||
515 | return outsize; | |
516 | } | |
517 | ||
518 | UInt_t AliL3DataHandler::GetMemorySize(UInt_t nrow,Byte_t *comp) | |
519 | { | |
520 | //Calculate size (in bytes) of unpacked data. | |
521 | ||
522 | UInt_t index=0; | |
523 | Int_t outsize=0; | |
524 | ||
525 | for(UInt_t i=0; i<nrow; i++) | |
526 | { | |
527 | UInt_t ndigit=0;//Digits on this row. | |
528 | ||
529 | //Row number: | |
530 | Read(comp,index); | |
531 | ||
532 | UShort_t npad = Read(comp,index); | |
533 | ||
534 | for(UShort_t pad=0; pad<npad; pad++) | |
535 | { | |
536 | //Read the pad number: | |
537 | Read(comp,index); | |
538 | ||
539 | //Check for zeros: | |
540 | if(Test(comp,index)==0) //Zeros are coming | |
541 | { | |
542 | Read(comp,index); | |
543 | if(Test(comp,index) == 0) | |
544 | { | |
545 | Read(comp,index); //This was the end of pad. | |
546 | continue; | |
547 | } | |
548 | if(Read(comp,index) == 255) //There can be up to 3 bytes with zero coding. | |
549 | if(Read(comp,index) == 255) | |
550 | Read(comp,index); | |
551 | } | |
552 | ||
553 | while(1) | |
554 | { | |
555 | while(Read(comp,index) != 0) ndigit++; | |
556 | ||
557 | if(Test(comp,index) == 0) | |
558 | { | |
559 | Read(comp,index); //2 zeros = end of pad. | |
560 | break; | |
561 | } | |
562 | if(Read(comp,index) == 255) //There can be up to 3 bytes with zero coding. | |
563 | if(Read(comp,index) == 255) | |
564 | Read(comp,index); | |
565 | ||
566 | } | |
567 | ||
568 | } | |
569 | Int_t size = sizeof(AliL3DigitData)*ndigit + sizeof(AliL3DigitRowData); | |
570 | outsize += size; | |
571 | } | |
572 | return outsize; | |
573 | } | |
574 | ||
575 | Bool_t AliL3DataHandler::CompBinary2CompMemory(UInt_t &nrow,Byte_t *comp) | |
576 | { | |
577 | //Read RLE data from binary file into array comp. | |
578 | rewind(fInBinary); | |
579 | UInt_t size = GetFileSize() - 2; | |
580 | Byte_t type; | |
581 | if(fread(&type,1,1,fInBinary)!=1) return kFALSE; | |
582 | if(type > 0) | |
583 | { | |
584 | LOG(AliL3Log::kError,"AliL3DataHandler::CompBinary2CompMemory","Filetype") | |
585 | <<"Inputfile does not seem to contain 8 bit data : "<<type<<ENDLOG; | |
586 | return kFALSE; | |
587 | } | |
588 | if(fread(&nrow,1,1,fInBinary)!=1) return kFALSE; | |
589 | if(fread(comp,size,1,fInBinary)!=1) return kFALSE; | |
590 | ||
591 | return kTRUE; | |
592 | } | |
593 | ||
594 | Bool_t AliL3DataHandler::CompMemory2CompBinary(UInt_t nrow,Byte_t *comp,UInt_t size) | |
595 | { | |
596 | //Write RLE data in comp to binary file. | |
597 | //In order to distinguish these files from 10 bit data, | |
598 | //a zero is written to the beginning of the file. | |
599 | ||
600 | Byte_t length = (Byte_t)nrow; | |
601 | Byte_t type = 0; | |
602 | if(fwrite(&type,1,1,fOutBinary)!=1) return kFALSE; //Write a zero, to mark that this file contains 8 bit data. | |
603 | if(fwrite(&length,1,1,fOutBinary)!=1) return kFALSE; | |
604 | if(fwrite(comp,size,1,fOutBinary)!=1) return kFALSE; | |
605 | return kTRUE; | |
606 | } |