]> git.proxmox.com Git - mirror_edk2.git/blame_incremental - DuetPkg/EfiLdr/TianoDecompress.c
projects / mirror_edk2.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Needed to fix defaulting / to be \ as it is required by EFI Simple File System.
[mirror_edk2.git] / DuetPkg / EfiLdr / TianoDecompress.c
... / ...
CommitLineData
1/*++\r
2\r
3Copyright (c) 2004 - 2006, Intel Corporation \r
4All rights reserved. This program and the accompanying materials \r
5are licensed and made available under the terms and conditions of the BSD License \r
6which accompanies this distribution. The full text of the license may be found at \r
7http://opensource.org/licenses/bsd-license.php \r
8 \r
9THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, \r
10WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. \r
11\r
12Module Name:\r
13\r
14 Decompress.c\r
15\r
16Abstract:\r
17\r
18 Decompressor. Algorithm Ported from OPSD code (Decomp.asm)\r
19 \r
20--*/\r
21#include <TianoDecompress.h>\r
22//\r
23// Decompression algorithm begins here\r
24//\r
25#define BITBUFSIZ 32\r
26#define MAXMATCH 256\r
27#define THRESHOLD 3\r
28#define CODE_BIT 16\r
29#define BAD_TABLE - 1\r
30\r
31//\r
32// C: Char&Len Set; P: Position Set; T: exTra Set\r
33//\r
34#define NC (0xff + MAXMATCH + 2 - THRESHOLD)\r
35#define CBIT 9\r
36#define MAXPBIT 5\r
37#define TBIT 5\r
38#define MAXNP ((1U << MAXPBIT) - 1)\r
39#define NT (CODE_BIT + 3)\r
40#if NT > MAXNP\r
41#define NPT NT\r
42#else\r
43#define NPT MAXNP\r
44#endif\r
45\r
46typedef struct {\r
47 UINT8 *mSrcBase; // Starting address of compressed data\r
48 UINT8 *mDstBase; // Starting address of decompressed data\r
49 UINT32 mOutBuf;\r
50 UINT32 mInBuf;\r
51\r
52 UINT16 mBitCount;\r
53 UINT32 mBitBuf;\r
54 UINT32 mSubBitBuf;\r
55 UINT16 mBlockSize;\r
56 UINT32 mCompSize;\r
57 UINT32 mOrigSize;\r
58\r
59 UINT16 mBadTableFlag;\r
60\r
61 UINT16 mLeft[2 * NC - 1];\r
62 UINT16 mRight[2 * NC - 1];\r
63 UINT8 mCLen[NC];\r
64 UINT8 mPTLen[NPT];\r
65 UINT16 mCTable[4096];\r
66 UINT16 mPTTable[256];\r
67\r
68 //\r
69 // The length of the field 'Position Set Code Length Array Size' in Block Header.\r
70 // For EFI 1.1 de/compression algorithm, mPBit = 4\r
71 // For Tiano de/compression algorithm, mPBit = 5\r
72 //\r
73 UINT8 mPBit;\r
74} SCRATCH_DATA;\r
75\r
76VOID\r
77FillBuf (\r
78 IN SCRATCH_DATA *Sd,\r
79 IN UINT16 NumOfBits\r
80 )\r
81/*++\r
82\r
83Routine Description:\r
84\r
85 Shift mBitBuf NumOfBits left. Read in NumOfBits of bits from source.\r
86\r
87Arguments:\r
88\r
89 Sd - The global scratch data\r
90 NumOfBits - The number of bits to shift and read.\r
91\r
92Returns: (VOID)\r
93\r
94--*/\r
95{\r
96 Sd->mBitBuf = (UINT32) (Sd->mBitBuf << NumOfBits);\r
97\r
98 while (NumOfBits > Sd->mBitCount) {\r
99\r
100 Sd->mBitBuf |= (UINT32) (Sd->mSubBitBuf << (NumOfBits = (UINT16) (NumOfBits - Sd->mBitCount)));\r
101\r
102 if (Sd->mCompSize > 0) {\r
103 //\r
104 // Get 1 byte into SubBitBuf\r
105 //\r
106 Sd->mCompSize--;\r
107 Sd->mSubBitBuf = 0;\r
108 Sd->mSubBitBuf = Sd->mSrcBase[Sd->mInBuf++];\r
109 Sd->mBitCount = 8;\r
110\r
111 } else {\r
112 //\r
113 // No more bits from the source, just pad zero bit.\r
114 //\r
115 Sd->mSubBitBuf = 0;\r
116 Sd->mBitCount = 8;\r
117\r
118 }\r
119 }\r
120\r
121 Sd->mBitCount = (UINT16) (Sd->mBitCount - NumOfBits);\r
122 Sd->mBitBuf |= Sd->mSubBitBuf >> Sd->mBitCount;\r
123}\r
124\r
125UINT32\r
126GetBits (\r
127 IN SCRATCH_DATA *Sd,\r
128 IN UINT16 NumOfBits\r
129 )\r
130/*++\r
131\r
132Routine Description:\r
133\r
134 Get NumOfBits of bits out from mBitBuf. Fill mBitBuf with subsequent \r
135 NumOfBits of bits from source. Returns NumOfBits of bits that are \r
136 popped out.\r
137\r
138Arguments:\r
139\r
140 Sd - The global scratch data.\r
141 NumOfBits - The number of bits to pop and read.\r
142\r
143Returns:\r
144\r
145 The bits that are popped out.\r
146\r
147--*/\r
148{\r
149 UINT32 OutBits;\r
150\r
151 OutBits = (UINT32) (Sd->mBitBuf >> (BITBUFSIZ - NumOfBits));\r
152\r
153 FillBuf (Sd, NumOfBits);\r
154\r
155 return OutBits;\r
156}\r
157\r
158UINT16\r
159MakeTable (\r
160 IN SCRATCH_DATA *Sd,\r
161 IN UINT16 NumOfChar,\r
162 IN UINT8 *BitLen,\r
163 IN UINT16 TableBits,\r
164 OUT UINT16 *Table\r
165 )\r
166/*++\r
167\r
168Routine Description:\r
169\r
170 Creates Huffman Code mapping table according to code length array.\r
171\r
172Arguments:\r
173\r
174 Sd - The global scratch data\r
175 NumOfChar - Number of symbols in the symbol set\r
176 BitLen - Code length array\r
177 TableBits - The width of the mapping table\r
178 Table - The table\r
179 \r
180Returns:\r
181 \r
182 0 - OK.\r
183 BAD_TABLE - The table is corrupted.\r
184\r
185--*/\r
186{\r
187 UINT16 Count[17];\r
188 UINT16 Weight[17];\r
189 UINT16 Start[18];\r
190 UINT16 *Pointer;\r
191 UINT16 Index3;\r
192 volatile UINT16 Index;\r
193 UINT16 Len;\r
194 UINT16 Char;\r
195 UINT16 JuBits;\r
196 UINT16 Avail;\r
197 UINT16 NextCode;\r
198 UINT16 Mask;\r
199 UINT16 WordOfStart;\r
200 UINT16 WordOfCount;\r
201\r
202 for (Index = 1; Index <= 16; Index++) {\r
203 Count[Index] = 0;\r
204 } \r
205\r
206 for (Index = 0; Index < NumOfChar; Index++) {\r
207 Count[BitLen[Index]]++;\r
208 }\r
209\r
210 Start[1] = 0;\r
211\r
212 for (Index = 1; Index <= 16; Index++) {\r
213 WordOfStart = Start[Index];\r
214 WordOfCount = Count[Index];\r
215 Start[Index + 1] = (UINT16) (WordOfStart + (WordOfCount << (16 - Index)));\r
216 }\r
217\r
218 if (Start[17] != 0) {\r
219 /*(1U << 16)*/\r
220 return (UINT16) BAD_TABLE;\r
221 }\r
222\r
223 JuBits = (UINT16) (16 - TableBits);\r
224\r
225 for (Index = 1; Index <= TableBits; Index++) {\r
226 Start[Index] >>= JuBits;\r
227 Weight[Index] = (UINT16) (1U << (TableBits - Index));\r
228 }\r
229\r
230 while (Index <= 16) {\r
231 Weight[Index] = (UINT16) (1U << (16 - Index));\r
232 Index++;\r
233 }\r
234\r
235 Index = (UINT16) (Start[TableBits + 1] >> JuBits);\r
236\r
237 if (Index != 0) {\r
238 Index3 = (UINT16) (1U << TableBits);\r
239 while (Index != Index3) {\r
240 Table[Index++] = 0;\r
241 }\r
242 }\r
243\r
244 Avail = NumOfChar;\r
245 Mask = (UINT16) (1U << (15 - TableBits));\r
246\r
247 for (Char = 0; Char < NumOfChar; Char++) {\r
248\r
249 Len = BitLen[Char];\r
250 if (Len == 0) {\r
251 continue;\r
252 }\r
253\r
254 NextCode = (UINT16) (Start[Len] + Weight[Len]);\r
255\r
256 if (Len <= TableBits) {\r
257\r
258 for (Index = Start[Len]; Index < NextCode; Index++) {\r
259 Table[Index] = Char;\r
260 }\r
261\r
262 } else {\r
263\r
264 Index3 = Start[Len];\r
265 Pointer = &Table[Index3 >> JuBits];\r
266 Index = (UINT16) (Len - TableBits);\r
267\r
268 while (Index != 0) {\r
269 if (*Pointer == 0) {\r
270 Sd->mRight[Avail] = Sd->mLeft[Avail] = 0;\r
271 *Pointer = Avail++;\r
272 }\r
273\r
274 if (Index3 & Mask) {\r
275 Pointer = &Sd->mRight[*Pointer];\r
276 } else {\r
277 Pointer = &Sd->mLeft[*Pointer];\r
278 }\r
279\r
280 Index3 <<= 1;\r
281 Index--;\r
282 }\r
283\r
284 *Pointer = Char;\r
285\r
286 }\r
287\r
288 Start[Len] = NextCode;\r
289 }\r
290 //\r
291 // Succeeds\r
292 //\r
293 return 0;\r
294}\r
295\r
296UINT32\r
297DecodeP (\r
298 IN SCRATCH_DATA *Sd\r
299 )\r
300/*++\r
301\r
302Routine Description:\r
303\r
304 Decodes a position value.\r
305\r
306Arguments:\r
307\r
308 Sd - the global scratch data\r
309\r
310Returns:\r
311\r
312 The position value decoded.\r
313\r
314--*/\r
315{\r
316 UINT16 Val;\r
317 UINT32 Mask;\r
318 UINT32 Pos;\r
319\r
320 Val = Sd->mPTTable[Sd->mBitBuf >> (BITBUFSIZ - 8)];\r
321\r
322 if (Val >= MAXNP) {\r
323 Mask = 1U << (BITBUFSIZ - 1 - 8);\r
324\r
325 do {\r
326\r
327 if (Sd->mBitBuf & Mask) {\r
328 Val = Sd->mRight[Val];\r
329 } else {\r
330 Val = Sd->mLeft[Val];\r
331 }\r
332\r
333 Mask >>= 1;\r
334 } while (Val >= MAXNP);\r
335 }\r
336 //\r
337 // Advance what we have read\r
338 //\r
339 FillBuf (Sd, Sd->mPTLen[Val]);\r
340\r
341 Pos = Val;\r
342 if (Val > 1) {\r
343 Pos = (UINT32) ((1U << (Val - 1)) + GetBits (Sd, (UINT16) (Val - 1)));\r
344 }\r
345\r
346 return Pos;\r
347}\r
348\r
349UINT16\r
350ReadPTLen (\r
351 IN SCRATCH_DATA *Sd,\r
352 IN UINT16 nn,\r
353 IN UINT16 nbit,\r
354 IN UINT16 Special\r
355 )\r
356/*++\r
357\r
358Routine Description:\r
359\r
360 Reads code lengths for the Extra Set or the Position Set\r
361\r
362Arguments:\r
363\r
364 Sd - The global scratch data\r
365 nn - Number of symbols\r
366 nbit - Number of bits needed to represent nn\r
367 Special - The special symbol that needs to be taken care of \r
368\r
369Returns:\r
370\r
371 0 - OK.\r
372 BAD_TABLE - Table is corrupted.\r
373\r
374--*/\r
375{\r
376 UINT16 Number;\r
377 UINT16 CharC;\r
378 volatile UINT16 Index;\r
379 UINT32 Mask;\r
380\r
381 Number = (UINT16) GetBits (Sd, nbit);\r
382\r
383 if (Number == 0) {\r
384 CharC = (UINT16) GetBits (Sd, nbit);\r
385\r
386 for (Index = 0; Index < 256; Index++) {\r
387 Sd->mPTTable[Index] = CharC;\r
388 }\r
389\r
390 for (Index = 0; Index < nn; Index++) {\r
391 Sd->mPTLen[Index] = 0;\r
392 }\r
393\r
394 return 0;\r
395 }\r
396\r
397 Index = 0;\r
398\r
399 while (Index < Number) {\r
400\r
401 CharC = (UINT16) (Sd->mBitBuf >> (BITBUFSIZ - 3));\r
402\r
403 if (CharC == 7) {\r
404 Mask = 1U << (BITBUFSIZ - 1 - 3);\r
405 while (Mask & Sd->mBitBuf) {\r
406 Mask >>= 1;\r
407 CharC += 1;\r
408 }\r
409 }\r
410\r
411 FillBuf (Sd, (UINT16) ((CharC < 7) ? 3 : CharC - 3));\r
412\r
413 Sd->mPTLen[Index++] = (UINT8) CharC;\r
414\r
415 if (Index == Special) {\r
416 CharC = (UINT16) GetBits (Sd, 2);\r
417 while ((INT16) (--CharC) >= 0) {\r
418 Sd->mPTLen[Index++] = 0;\r
419 }\r
420 }\r
421 }\r
422\r
423 while (Index < nn) {\r
424 Sd->mPTLen[Index++] = 0;\r
425 }\r
426\r
427 return MakeTable (Sd, nn, Sd->mPTLen, 8, Sd->mPTTable);\r
428}\r
429\r
430VOID\r
431ReadCLen (\r
432 SCRATCH_DATA *Sd\r
433 )\r
434/*++\r
435\r
436Routine Description:\r
437\r
438 Reads code lengths for Char&Len Set.\r
439\r
440Arguments:\r
441\r
442 Sd - the global scratch data\r
443\r
444Returns: (VOID)\r
445\r
446--*/\r
447{\r
448 UINT16 Number;\r
449 UINT16 CharC;\r
450 volatile UINT16 Index;\r
451 UINT32 Mask;\r
452\r
453 Number = (UINT16) GetBits (Sd, CBIT);\r
454\r
455 if (Number == 0) {\r
456 CharC = (UINT16) GetBits (Sd, CBIT);\r
457\r
458 for (Index = 0; Index < NC; Index++) {\r
459 Sd->mCLen[Index] = 0;\r
460 }\r
461\r
462 for (Index = 0; Index < 4096; Index++) {\r
463 Sd->mCTable[Index] = CharC;\r
464 }\r
465\r
466 return ;\r
467 }\r
468\r
469 Index = 0;\r
470 while (Index < Number) {\r
471\r
472 CharC = Sd->mPTTable[Sd->mBitBuf >> (BITBUFSIZ - 8)];\r
473 if (CharC >= NT) {\r
474 Mask = 1U << (BITBUFSIZ - 1 - 8);\r
475\r
476 do {\r
477\r
478 if (Mask & Sd->mBitBuf) {\r
479 CharC = Sd->mRight[CharC];\r
480 } else {\r
481 CharC = Sd->mLeft[CharC];\r
482 }\r
483\r
484 Mask >>= 1;\r
485\r
486 } while (CharC >= NT);\r
487 }\r
488 //\r
489 // Advance what we have read\r
490 //\r
491 FillBuf (Sd, Sd->mPTLen[CharC]);\r
492\r
493 if (CharC <= 2) {\r
494\r
495 if (CharC == 0) {\r
496 CharC = 1;\r
497 } else if (CharC == 1) {\r
498 CharC = (UINT16) (GetBits (Sd, 4) + 3);\r
499 } else if (CharC == 2) {\r
500 CharC = (UINT16) (GetBits (Sd, CBIT) + 20);\r
501 }\r
502\r
503 while ((INT16) (--CharC) >= 0) {\r
504 Sd->mCLen[Index++] = 0;\r
505 }\r
506\r
507 } else {\r
508\r
509 Sd->mCLen[Index++] = (UINT8) (CharC - 2);\r
510\r
511 }\r
512 }\r
513\r
514 while (Index < NC) {\r
515 Sd->mCLen[Index++] = 0;\r
516 }\r
517\r
518 MakeTable (Sd, NC, Sd->mCLen, 12, Sd->mCTable);\r
519\r
520 return ;\r
521}\r
522\r
523UINT16\r
524DecodeC (\r
525 SCRATCH_DATA *Sd\r
526 )\r
527/*++\r
528\r
529Routine Description:\r
530\r
531 Decode a character/length value.\r
532\r
533Arguments:\r
534\r
535 Sd - The global scratch data.\r
536\r
537Returns:\r
538\r
539 The value decoded.\r
540\r
541--*/\r
542{\r
543 UINT16 Index2;\r
544 UINT32 Mask;\r
545\r
546 if (Sd->mBlockSize == 0) {\r
547 //\r
548 // Starting a new block\r
549 //\r
550 Sd->mBlockSize = (UINT16) GetBits (Sd, 16);\r
551 Sd->mBadTableFlag = ReadPTLen (Sd, NT, TBIT, 3);\r
552 if (Sd->mBadTableFlag != 0) {\r
553 return 0;\r
554 }\r
555\r
556 ReadCLen (Sd);\r
557\r
558 Sd->mBadTableFlag = ReadPTLen (Sd, MAXNP, Sd->mPBit, (UINT16) (-1));\r
559 if (Sd->mBadTableFlag != 0) {\r
560 return 0;\r
561 }\r
562 }\r
563\r
564 Sd->mBlockSize--;\r
565 Index2 = Sd->mCTable[Sd->mBitBuf >> (BITBUFSIZ - 12)];\r
566\r
567 if (Index2 >= NC) {\r
568 Mask = 1U << (BITBUFSIZ - 1 - 12);\r
569\r
570 do {\r
571 if (Sd->mBitBuf & Mask) {\r
572 Index2 = Sd->mRight[Index2];\r
573 } else {\r
574 Index2 = Sd->mLeft[Index2];\r
575 }\r
576\r
577 Mask >>= 1;\r
578 } while (Index2 >= NC);\r
579 }\r
580 //\r
581 // Advance what we have read\r
582 //\r
583 FillBuf (Sd, Sd->mCLen[Index2]);\r
584\r
585 return Index2;\r
586}\r
587\r
588VOID\r
589Decode (\r
590 SCRATCH_DATA *Sd\r
591 )\r
592/*++\r
593\r
594Routine Description:\r
595\r
596 Decode the source data and put the resulting data into the destination buffer.\r
597\r
598Arguments:\r
599\r
600 Sd - The global scratch data\r
601\r
602Returns: (VOID)\r
603\r
604 --*/\r
605{\r
606 UINT16 BytesRemain;\r
607 UINT32 DataIdx;\r
608 UINT16 CharC;\r
609\r
610 BytesRemain = (UINT16) (-1);\r
611\r
612 DataIdx = 0;\r
613\r
614 for (;;) {\r
615 CharC = DecodeC (Sd);\r
616 if (Sd->mBadTableFlag != 0) {\r
617 goto Done ;\r
618 }\r
619\r
620 if (CharC < 256) {\r
621 //\r
622 // Process an Original character\r
623 //\r
624 if (Sd->mOutBuf >= Sd->mOrigSize) {\r
625 goto Done ;\r
626 } else {\r
627 Sd->mDstBase[Sd->mOutBuf++] = (UINT8) CharC;\r
628 }\r
629\r
630 } else {\r
631 //\r
632 // Process a Pointer\r
633 //\r
634 CharC = (UINT16) (CharC - (BIT8 - THRESHOLD));\r
635\r
636 BytesRemain = CharC;\r
637\r
638 DataIdx = Sd->mOutBuf - DecodeP (Sd) - 1;\r
639\r
640 BytesRemain--;\r
641 while ((INT16) (BytesRemain) >= 0) {\r
642 Sd->mDstBase[Sd->mOutBuf++] = Sd->mDstBase[DataIdx++];\r
643 if (Sd->mOutBuf >= Sd->mOrigSize) {\r
644 goto Done ;\r
645 }\r
646\r
647 BytesRemain--;\r
648 }\r
649 }\r
650 }\r
651\r
652Done:\r
653 return ;\r
654}\r
655\r
656EFI_STATUS\r
657GetInfo (\r
658 IN VOID *Source,\r
659 IN UINT32 SrcSize,\r
660 OUT UINT32 *DstSize,\r
661 OUT UINT32 *ScratchSize\r
662 )\r
663/*++\r
664\r
665Routine Description:\r
666\r
667 The internal implementation of *_DECOMPRESS_PROTOCOL.GetInfo().\r
668\r
669Arguments:\r
670\r
671 Source - The source buffer containing the compressed data.\r
672 SrcSize - The size of source buffer\r
673 DstSize - The size of destination buffer.\r
674 ScratchSize - The size of scratch buffer.\r
675\r
676Returns:\r
677\r
678 EFI_SUCCESS - The size of destination buffer and the size of scratch buffer are successull retrieved.\r
679 EFI_INVALID_PARAMETER - The source data is corrupted\r
680\r
681--*/\r
682{\r
683 UINT8 *Src;\r
684\r
685 *ScratchSize = sizeof (SCRATCH_DATA);\r
686\r
687 Src = Source;\r
688 if (SrcSize < 8) {\r
689 return EFI_INVALID_PARAMETER;\r
690 }\r
691\r
692 *DstSize = Src[4] + (Src[5] << 8) + (Src[6] << 16) + (Src[7] << 24);\r
693 return EFI_SUCCESS;\r
694}\r
695\r
696EFI_STATUS\r
697Decompress (\r
698 IN VOID *Source,\r
699 IN UINT32 SrcSize,\r
700 IN OUT VOID *Destination,\r
701 IN UINT32 DstSize,\r
702 IN OUT VOID *Scratch,\r
703 IN UINT32 ScratchSize,\r
704 IN UINT8 Version\r
705 )\r
706/*++\r
707\r
708Routine Description:\r
709\r
710 The internal implementation of *_DECOMPRESS_PROTOCOL.Decompress().\r
711\r
712Arguments:\r
713\r
714 Source - The source buffer containing the compressed data.\r
715 SrcSize - The size of source buffer\r
716 Destination - The destination buffer to store the decompressed data\r
717 DstSize - The size of destination buffer.\r
718 Scratch - The buffer used internally by the decompress routine. This buffer is needed to store intermediate data.\r
719 ScratchSize - The size of scratch buffer.\r
720 Version - The version of de/compression algorithm.\r
721 Version 1 for EFI 1.1 de/compression algorithm.\r
722 Version 2 for Tiano de/compression algorithm.\r
723\r
724Returns:\r
725\r
726 EFI_SUCCESS - Decompression is successfull\r
727 EFI_INVALID_PARAMETER - The source data is corrupted\r
728\r
729--*/\r
730{\r
731 UINT32 CompSize;\r
732 UINT32 OrigSize;\r
733 EFI_STATUS Status;\r
734 SCRATCH_DATA *Sd;\r
735 UINT8 *Src;\r
736 UINT8 *Dst;\r
737 volatile UINT32 Index;\r
738 \r
739 Status = EFI_SUCCESS;\r
740 Src = Source;\r
741 Dst = Destination;\r
742\r
743 if (ScratchSize < sizeof (SCRATCH_DATA)) {\r
744 return EFI_INVALID_PARAMETER;\r
745 }\r
746\r
747 Sd = (SCRATCH_DATA *) Scratch;\r
748\r
749 if (SrcSize < 8) {\r
750 return EFI_INVALID_PARAMETER;\r
751 }\r
752\r
753 CompSize = Src[0] + (Src[1] << 8) + (Src[2] << 16) + (Src[3] << 24);\r
754 OrigSize = Src[4] + (Src[5] << 8) + (Src[6] << 16) + (Src[7] << 24);\r
755\r
756 //\r
757 // If compressed file size is 0, return\r
758 //\r
759 if (OrigSize == 0) {\r
760 return Status;\r
761 }\r
762\r
763 if (SrcSize < CompSize + 8) {\r
764 return EFI_INVALID_PARAMETER;\r
765 }\r
766\r
767 if (DstSize != OrigSize) {\r
768 return EFI_INVALID_PARAMETER;\r
769 }\r
770\r
771 Src = Src + 8;\r
772\r
773 for (Index = 0; Index < sizeof (SCRATCH_DATA); Index++) {\r
774 ((UINT8 *) Sd)[Index] = 0;\r
775 }\r
776 \r
777 //\r
778 // The length of the field 'Position Set Code Length Array Size' in Block Header.\r
779 // For EFI 1.1 de/compression algorithm(Version 1), mPBit = 4\r
780 // For Tiano de/compression algorithm(Version 2), mPBit = 5\r
781 //\r
782 switch (Version) {\r
783 case 1:\r
784 Sd->mPBit = 4;\r
785 break;\r
786\r
787 case 2:\r
788 Sd->mPBit = 5;\r
789 break;\r
790\r
791 default:\r
792 //\r
793 // Currently, only have 2 versions\r
794 //\r
795 return EFI_INVALID_PARAMETER;\r
796 }\r
797\r
798 Sd->mSrcBase = Src;\r
799 Sd->mDstBase = Dst;\r
800 Sd->mCompSize = CompSize;\r
801 Sd->mOrigSize = OrigSize;\r
802\r
803 //\r
804 // Fill the first BITBUFSIZ bits\r
805 //\r
806 FillBuf (Sd, BITBUFSIZ);\r
807\r
808 //\r
809 // Decompress it\r
810 //\r
811 Decode (Sd);\r
812\r
813 if (Sd->mBadTableFlag != 0) {\r
814 //\r
815 // Something wrong with the source\r
816 //\r
817 Status = EFI_INVALID_PARAMETER;\r
818 }\r
819\r
820 return Status;\r
821}\r
822\r
823EFI_STATUS\r
824EFIAPI\r
825EfiGetInfo (\r
826 IN VOID *Source,\r
827 IN UINT32 SrcSize,\r
828 OUT UINT32 *DstSize,\r
829 OUT UINT32 *ScratchSize\r
830 )\r
831/*++\r
832\r
833Routine Description:\r
834\r
835 The implementation is same as that of EFI_DECOMPRESS_PROTOCOL.GetInfo().\r
836\r
837Arguments:\r
838\r
839 This - The protocol instance pointer\r
840 Source - The source buffer containing the compressed data.\r
841 SrcSize - The size of source buffer\r
842 DstSize - The size of destination buffer.\r
843 ScratchSize - The size of scratch buffer.\r
844\r
845Returns:\r
846\r
847 EFI_SUCCESS - The size of destination buffer and the size of scratch buffer are successull retrieved.\r
848 EFI_INVALID_PARAMETER - The source data is corrupted\r
849\r
850--*/\r
851{\r
852 return GetInfo (\r
853 Source,\r
854 SrcSize,\r
855 DstSize,\r
856 ScratchSize\r
857 );\r
858}\r
859\r
860EFI_STATUS\r
861EFIAPI\r
862EfiDecompress (\r
863 IN VOID *Source,\r
864 IN UINT32 SrcSize,\r
865 IN OUT VOID *Destination,\r
866 IN UINT32 DstSize,\r
867 IN OUT VOID *Scratch,\r
868 IN UINT32 ScratchSize\r
869 )\r
870/*++\r
871\r
872Routine Description:\r
873\r
874 The implementation is same as that of EFI_DECOMPRESS_PROTOCOL.Decompress().\r
875\r
876Arguments:\r
877\r
878 This - The protocol instance pointer\r
879 Source - The source buffer containing the compressed data.\r
880 SrcSize - The size of source buffer\r
881 Destination - The destination buffer to store the decompressed data\r
882 DstSize - The size of destination buffer.\r
883 Scratch - The buffer used internally by the decompress routine. This buffer is needed to store intermediate data.\r
884 ScratchSize - The size of scratch buffer.\r
885\r
886Returns:\r
887\r
888 EFI_SUCCESS - Decompression is successfull\r
889 EFI_INVALID_PARAMETER - The source data is corrupted\r
890\r
891--*/\r
892{\r
893 //\r
894 // For EFI 1.1 de/compression algorithm, the version is 1.\r
895 //\r
896 return Decompress (\r
897 Source,\r
898 SrcSize,\r
899 Destination,\r
900 DstSize,\r
901 Scratch,\r
902 ScratchSize,\r
903 1\r
904 );\r
905}\r
906\r
907EFI_STATUS\r
908EFIAPI\r
909TianoGetInfo (\r
910 IN VOID *Source,\r
911 IN UINT32 SrcSize,\r
912 OUT UINT32 *DstSize,\r
913 OUT UINT32 *ScratchSize\r
914 )\r
915/*++\r
916\r
917Routine Description:\r
918\r
919 The implementation is same as that of EFI_TIANO_DECOMPRESS_PROTOCOL.GetInfo().\r
920\r
921Arguments:\r
922\r
923 This - The protocol instance pointer\r
924 Source - The source buffer containing the compressed data.\r
925 SrcSize - The size of source buffer\r
926 DstSize - The size of destination buffer.\r
927 ScratchSize - The size of scratch buffer.\r
928\r
929Returns:\r
930\r
931 EFI_SUCCESS - The size of destination buffer and the size of scratch buffer are successull retrieved.\r
932 EFI_INVALID_PARAMETER - The source data is corrupted\r
933\r
934--*/\r
935{\r
936 return GetInfo (\r
937 Source,\r
938 SrcSize,\r
939 DstSize,\r
940 ScratchSize\r
941 );\r
942}\r
943\r
944EFI_STATUS\r
945EFIAPI\r
946TianoDecompress (\r
947 IN VOID *Source,\r
948 IN UINT32 SrcSize,\r
949 IN OUT VOID *Destination,\r
950 IN UINT32 DstSize,\r
951 IN OUT VOID *Scratch,\r
952 IN UINT32 ScratchSize\r
953 )\r
954/*++\r
955\r
956Routine Description:\r
957\r
958 The implementation is same as that of EFI_TIANO_DECOMPRESS_PROTOCOL.Decompress().\r
959\r
960Arguments:\r
961\r
962 This - The protocol instance pointer\r
963 Source - The source buffer containing the compressed data.\r
964 SrcSize - The size of source buffer\r
965 Destination - The destination buffer to store the decompressed data\r
966 DstSize - The size of destination buffer.\r
967 Scratch - The buffer used internally by the decompress routine. This buffer is needed to store intermediate data.\r
968 ScratchSize - The size of scratch buffer.\r
969\r
970Returns:\r
971\r
972 EFI_SUCCESS - Decompression is successfull\r
973 EFI_INVALID_PARAMETER - The source data is corrupted\r
974\r
975--*/\r
976{\r
977 //\r
978 // For Tiano de/compression algorithm, the version is 2.\r
979 //\r
980 return Decompress (\r
981 Source,\r
982 SrcSize,\r
983 Destination,\r
984 DstSize,\r
985 Scratch,\r
986 ScratchSize,\r
987 2\r
988 );\r
989}\r
990\r
EFI Development Kit II mirror for PVE