]> git.proxmox.com Git - mirror_edk2.git/blame - EdkModulePkg/Library/BaseUefiTianoDecompressLib/BaseUefiTianoDecompressLib.c
projects / mirror_edk2.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Initial import.
[mirror_edk2.git] / EdkModulePkg / Library / BaseUefiTianoDecompressLib / BaseUefiTianoDecompressLib.c
CommitLineData
878ddf1f 1/*++\r
2\r
3Copyright (c) 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 BaseUefiTianoDecompressLib.c\r
15\r
16Abstract:\r
17\r
18 UEFI and Tiano Decompress Library \r
19\r
20--*/\r
21\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\r
200 for (Index = 1; Index <= 16; Index++) {\r
201 Count[Index] = 0;\r
202 }\r
203\r
204 for (Index = 0; Index < NumOfChar; Index++) {\r
205 Count[BitLen[Index]]++;\r
206 }\r
207\r
208 Start[1] = 0;\r
209\r
210 for (Index = 1; Index <= 16; Index++) {\r
211 Start[Index + 1] = (UINT16) (Start[Index] + (Count[Index] << (16 - Index)));\r
212 }\r
213\r
214 if (Start[17] != 0) {\r
215 /*(1U << 16)*/\r
216 return (UINT16) BAD_TABLE;\r
217 }\r
218\r
219 JuBits = (UINT16) (16 - TableBits);\r
220\r
221 for (Index = 1; Index <= TableBits; Index++) {\r
222 Start[Index] >>= JuBits;\r
223 Weight[Index] = (UINT16) (1U << (TableBits - Index));\r
224 }\r
225\r
226 while (Index <= 16) {\r
227 Weight[Index] = (UINT16) (1U << (16 - Index));\r
228 Index++;\r
229 }\r
230\r
231 Index = (UINT16) (Start[TableBits + 1] >> JuBits);\r
232\r
233 if (Index != 0) {\r
234 Index3 = (UINT16) (1U << TableBits);\r
235 while (Index != Index3) {\r
236 Table[Index++] = 0;\r
237 }\r
238 }\r
239\r
240 Avail = NumOfChar;\r
241 Mask = (UINT16) (1U << (15 - TableBits));\r
242\r
243 for (Char = 0; Char < NumOfChar; Char++) {\r
244\r
245 Len = BitLen[Char];\r
246 if (Len == 0) {\r
247 continue;\r
248 }\r
249\r
250 NextCode = (UINT16) (Start[Len] + Weight[Len]);\r
251\r
252 if (Len <= TableBits) {\r
253\r
254 for (Index = Start[Len]; Index < NextCode; Index++) {\r
255 Table[Index] = Char;\r
256 }\r
257\r
258 } else {\r
259\r
260 Index3 = Start[Len];\r
261 Pointer = &Table[Index3 >> JuBits];\r
262 Index = (UINT16) (Len - TableBits);\r
263\r
264 while (Index != 0) {\r
265 if (*Pointer == 0) {\r
266 Sd->mRight[Avail] = Sd->mLeft[Avail] = 0;\r
267 *Pointer = Avail++;\r
268 }\r
269\r
270 if (Index3 & Mask) {\r
271 Pointer = &Sd->mRight[*Pointer];\r
272 } else {\r
273 Pointer = &Sd->mLeft[*Pointer];\r
274 }\r
275\r
276 Index3 <<= 1;\r
277 Index--;\r
278 }\r
279\r
280 *Pointer = Char;\r
281\r
282 }\r
283\r
284 Start[Len] = NextCode;\r
285 }\r
286 //\r
287 // Succeeds\r
288 //\r
289 return 0;\r
290}\r
291\r
292UINT32\r
293DecodeP (\r
294 IN SCRATCH_DATA *Sd\r
295 )\r
296/*++\r
297\r
298Routine Description:\r
299\r
300 Decodes a position value.\r
301\r
302Arguments:\r
303\r
304 Sd - the global scratch data\r
305\r
306Returns:\r
307\r
308 The position value decoded.\r
309\r
310--*/\r
311{\r
312 UINT16 Val;\r
313 UINT32 Mask;\r
314 UINT32 Pos;\r
315\r
316 Val = Sd->mPTTable[Sd->mBitBuf >> (BITBUFSIZ - 8)];\r
317\r
318 if (Val >= MAXNP) {\r
319 Mask = 1U << (BITBUFSIZ - 1 - 8);\r
320\r
321 do {\r
322\r
323 if (Sd->mBitBuf & Mask) {\r
324 Val = Sd->mRight[Val];\r
325 } else {\r
326 Val = Sd->mLeft[Val];\r
327 }\r
328\r
329 Mask >>= 1;\r
330 } while (Val >= MAXNP);\r
331 }\r
332 //\r
333 // Advance what we have read\r
334 //\r
335 FillBuf (Sd, Sd->mPTLen[Val]);\r
336\r
337 Pos = Val;\r
338 if (Val > 1) {\r
339 Pos = (UINT32) ((1U << (Val - 1)) + GetBits (Sd, (UINT16) (Val - 1)));\r
340 }\r
341\r
342 return Pos;\r
343}\r
344\r
345UINT16\r
346ReadPTLen (\r
347 IN SCRATCH_DATA *Sd,\r
348 IN UINT16 nn,\r
349 IN UINT16 nbit,\r
350 IN UINT16 Special\r
351 )\r
352/*++\r
353\r
354Routine Description:\r
355\r
356 Reads code lengths for the Extra Set or the Position Set\r
357\r
358Arguments:\r
359\r
360 Sd - The global scratch data\r
361 nn - Number of symbols\r
362 nbit - Number of bits needed to represent nn\r
363 Special - The special symbol that needs to be taken care of \r
364\r
365Returns:\r
366\r
367 0 - OK.\r
368 BAD_TABLE - Table is corrupted.\r
369\r
370--*/\r
371{\r
372 UINT16 Number;\r
373 UINT16 CharC;\r
374 volatile UINT16 Index;\r
375 UINT32 Mask;\r
376\r
377 Number = (UINT16) GetBits (Sd, nbit);\r
378\r
379 if (Number == 0) {\r
380 CharC = (UINT16) GetBits (Sd, nbit);\r
381\r
382 for (Index = 0; Index < 256; Index++) {\r
383 Sd->mPTTable[Index] = CharC;\r
384 }\r
385\r
386 for (Index = 0; Index < nn; Index++) {\r
387 Sd->mPTLen[Index] = 0;\r
388 }\r
389\r
390 return 0;\r
391 }\r
392\r
393 Index = 0;\r
394\r
395 while (Index < Number) {\r
396\r
397 CharC = (UINT16) (Sd->mBitBuf >> (BITBUFSIZ - 3));\r
398\r
399 if (CharC == 7) {\r
400 Mask = 1U << (BITBUFSIZ - 1 - 3);\r
401 while (Mask & Sd->mBitBuf) {\r
402 Mask >>= 1;\r
403 CharC += 1;\r
404 }\r
405 }\r
406\r
407 FillBuf (Sd, (UINT16) ((CharC < 7) ? 3 : CharC - 3));\r
408\r
409 Sd->mPTLen[Index++] = (UINT8) CharC;\r
410\r
411 if (Index == Special) {\r
412 CharC = (UINT16) GetBits (Sd, 2);\r
413 while ((INT16) (--CharC) >= 0) {\r
414 Sd->mPTLen[Index++] = 0;\r
415 }\r
416 }\r
417 }\r
418\r
419 while (Index < nn) {\r
420 Sd->mPTLen[Index++] = 0;\r
421 }\r
422\r
423 return MakeTable (Sd, nn, Sd->mPTLen, 8, Sd->mPTTable);\r
424}\r
425\r
426VOID\r
427ReadCLen (\r
428 SCRATCH_DATA *Sd\r
429 )\r
430/*++\r
431\r
432Routine Description:\r
433\r
434 Reads code lengths for Char&Len Set.\r
435\r
436Arguments:\r
437\r
438 Sd - the global scratch data\r
439\r
440Returns: (VOID)\r
441\r
442--*/\r
443{\r
444 UINT16 Number;\r
445 UINT16 CharC;\r
446 volatile UINT16 Index;\r
447 UINT32 Mask;\r
448\r
449 Number = (UINT16) GetBits (Sd, CBIT);\r
450\r
451 if (Number == 0) {\r
452 CharC = (UINT16) GetBits (Sd, CBIT);\r
453\r
454 for (Index = 0; Index < NC; Index++) {\r
455 Sd->mCLen[Index] = 0;\r
456 }\r
457\r
458 for (Index = 0; Index < 4096; Index++) {\r
459 Sd->mCTable[Index] = CharC;\r
460 }\r
461\r
462 return ;\r
463 }\r
464\r
465 Index = 0;\r
466 while (Index < Number) {\r
467\r
468 CharC = Sd->mPTTable[Sd->mBitBuf >> (BITBUFSIZ - 8)];\r
469 if (CharC >= NT) {\r
470 Mask = 1U << (BITBUFSIZ - 1 - 8);\r
471\r
472 do {\r
473\r
474 if (Mask & Sd->mBitBuf) {\r
475 CharC = Sd->mRight[CharC];\r
476 } else {\r
477 CharC = Sd->mLeft[CharC];\r
478 }\r
479\r
480 Mask >>= 1;\r
481\r
482 } while (CharC >= NT);\r
483 }\r
484 //\r
485 // Advance what we have read\r
486 //\r
487 FillBuf (Sd, Sd->mPTLen[CharC]);\r
488\r
489 if (CharC <= 2) {\r
490\r
491 if (CharC == 0) {\r
492 CharC = 1;\r
493 } else if (CharC == 1) {\r
494 CharC = (UINT16) (GetBits (Sd, 4) + 3);\r
495 } else if (CharC == 2) {\r
496 CharC = (UINT16) (GetBits (Sd, CBIT) + 20);\r
497 }\r
498\r
499 while ((INT16) (--CharC) >= 0) {\r
500 Sd->mCLen[Index++] = 0;\r
501 }\r
502\r
503 } else {\r
504\r
505 Sd->mCLen[Index++] = (UINT8) (CharC - 2);\r
506\r
507 }\r
508 }\r
509\r
510 while (Index < NC) {\r
511 Sd->mCLen[Index++] = 0;\r
512 }\r
513\r
514 MakeTable (Sd, NC, Sd->mCLen, 12, Sd->mCTable);\r
515\r
516 return ;\r
517}\r
518\r
519UINT16\r
520DecodeC (\r
521 SCRATCH_DATA *Sd\r
522 )\r
523/*++\r
524\r
525Routine Description:\r
526\r
527 Decode a character/length value.\r
528\r
529Arguments:\r
530\r
531 Sd - The global scratch data.\r
532\r
533Returns:\r
534\r
535 The value decoded.\r
536\r
537--*/\r
538{\r
539 UINT16 Index2;\r
540 UINT32 Mask;\r
541\r
542 if (Sd->mBlockSize == 0) {\r
543 //\r
544 // Starting a new block\r
545 //\r
546 Sd->mBlockSize = (UINT16) GetBits (Sd, 16);\r
547 Sd->mBadTableFlag = ReadPTLen (Sd, NT, TBIT, 3);\r
548 if (Sd->mBadTableFlag != 0) {\r
549 return 0;\r
550 }\r
551\r
552 ReadCLen (Sd);\r
553\r
554 Sd->mBadTableFlag = ReadPTLen (Sd, MAXNP, Sd->mPBit, (UINT16) (-1));\r
555 if (Sd->mBadTableFlag != 0) {\r
556 return 0;\r
557 }\r
558 }\r
559\r
560 Sd->mBlockSize--;\r
561 Index2 = Sd->mCTable[Sd->mBitBuf >> (BITBUFSIZ - 12)];\r
562\r
563 if (Index2 >= NC) {\r
564 Mask = 1U << (BITBUFSIZ - 1 - 12);\r
565\r
566 do {\r
567 if (Sd->mBitBuf & Mask) {\r
568 Index2 = Sd->mRight[Index2];\r
569 } else {\r
570 Index2 = Sd->mLeft[Index2];\r
571 }\r
572\r
573 Mask >>= 1;\r
574 } while (Index2 >= NC);\r
575 }\r
576 //\r
577 // Advance what we have read\r
578 //\r
579 FillBuf (Sd, Sd->mCLen[Index2]);\r
580\r
581 return Index2;\r
582}\r
583\r
584VOID\r
585Decode (\r
586 SCRATCH_DATA *Sd\r
587 )\r
588/*++\r
589\r
590Routine Description:\r
591\r
592 Decode the source data and put the resulting data into the destination buffer.\r
593\r
594Arguments:\r
595\r
596 Sd - The global scratch data\r
597\r
598Returns: (VOID)\r
599\r
600 --*/\r
601{\r
602 UINT16 BytesRemain;\r
603 UINT32 DataIdx;\r
604 UINT16 CharC;\r
605\r
606 BytesRemain = (UINT16) (-1);\r
607\r
608 DataIdx = 0;\r
609\r
610 for (;;) {\r
611 CharC = DecodeC (Sd);\r
612 if (Sd->mBadTableFlag != 0) {\r
613 return ;\r
614 }\r
615\r
616 if (CharC < 256) {\r
617 //\r
618 // Process an Original character\r
619 //\r
620 if (Sd->mOutBuf >= Sd->mOrigSize) {\r
621 return ;\r
622 } else {\r
623 Sd->mDstBase[Sd->mOutBuf++] = (UINT8) CharC;\r
624 }\r
625\r
626 } else {\r
627 //\r
628 // Process a Pointer\r
629 //\r
630 CharC = (UINT16) (CharC - (UINT8_MAX + 1 - THRESHOLD));\r
631\r
632 BytesRemain = CharC;\r
633\r
634 DataIdx = Sd->mOutBuf - DecodeP (Sd) - 1;\r
635\r
636 BytesRemain--;\r
637 while ((INT16) (BytesRemain) >= 0) {\r
638 Sd->mDstBase[Sd->mOutBuf++] = Sd->mDstBase[DataIdx++];\r
639 if (Sd->mOutBuf >= Sd->mOrigSize) {\r
640 return ;\r
641 }\r
642\r
643 BytesRemain--;\r
644 }\r
645 }\r
646 }\r
647\r
648 return ;\r
649}\r
650\r
651RETURN_STATUS\r
652EFIAPI\r
653UefiDecompressGetInfo (\r
654 IN CONST VOID *Source,\r
655 IN UINT32 SourceSize,\r
656 OUT UINT32 *DestinationSize,\r
657 OUT UINT32 *ScratchSize\r
658 )\r
659/*++\r
660\r
661Routine Description:\r
662\r
663 The internal implementation of *_DECOMPRESS_PROTOCOL.GetInfo().\r
664\r
665Arguments:\r
666\r
667 Source - The source buffer containing the compressed data.\r
668 SourceSize - The size of source buffer\r
669 DestinationSize - The size of destination buffer.\r
670 ScratchSize - The size of scratch buffer.\r
671\r
672Returns:\r
673\r
674 RETURN_SUCCESS - The size of destination buffer and the size of scratch buffer are successull retrieved.\r
675 RETURN_INVALID_PARAMETER - The source data is corrupted\r
676\r
677--*/\r
678{\r
679 UINT32 CompressedSize;\r
680\r
681 ASSERT (Source != NULL);\r
682 ASSERT (DestinationSize != NULL);\r
683 ASSERT (ScratchSize != NULL);\r
684\r
685 *ScratchSize = sizeof (SCRATCH_DATA);\r
686\r
687 if (SourceSize < 8) {\r
688 return RETURN_INVALID_PARAMETER;\r
689 }\r
690\r
691 CopyMem (&CompressedSize, Source, sizeof (UINT32));\r
692 CopyMem (DestinationSize, (VOID *)((UINT8 *)Source + 4), sizeof (UINT32));\r
693\r
694 if (SourceSize < (CompressedSize + 8)) {\r
695 return RETURN_INVALID_PARAMETER;\r
696 }\r
697\r
698 return RETURN_SUCCESS;\r
699}\r
700\r
701RETURN_STATUS\r
702EFIAPI\r
703UefiTianoDecompress (\r
704 IN CONST VOID *Source,\r
705 IN OUT VOID *Destination,\r
706 IN OUT VOID *Scratch,\r
707 IN UINT32 Version\r
708 )\r
709/*++\r
710\r
711Routine Description:\r
712\r
713 The internal implementation of *_DECOMPRESS_PROTOCOL.Decompress().\r
714\r
715Arguments:\r
716\r
717 Source - The source buffer containing the compressed data.\r
718 Destination - The destination buffer to store the decompressed data\r
719 Scratch - The buffer used internally by the decompress routine. This buffer is needed to store intermediate data.\r
720 Version - 1 for UEFI Decompress algoruthm, 2 for Tiano Decompess algorithm\r
721\r
722Returns:\r
723\r
724 RETURN_SUCCESS - Decompression is successfull\r
725 RETURN_INVALID_PARAMETER - The source data is corrupted\r
726\r
727--*/\r
728{\r
729 volatile UINT32 Index;\r
730 UINT32 CompSize;\r
731 UINT32 OrigSize;\r
732 SCRATCH_DATA *Sd;\r
733 CONST UINT8 *Src;\r
734 UINT8 *Dst;\r
735\r
736 ASSERT (Source != NULL);\r
737 ASSERT (Destination != NULL);\r
738 ASSERT (Scratch != NULL);\r
739\r
740 Src = Source;\r
741 Dst = Destination;\r
742\r
743 Sd = (SCRATCH_DATA *) Scratch;\r
744\r
745 CompSize = Src[0] + (Src[1] << 8) + (Src[2] << 16) + (Src[3] << 24);\r
746 OrigSize = Src[4] + (Src[5] << 8) + (Src[6] << 16) + (Src[7] << 24);\r
747\r
748 //\r
749 // If compressed file size is 0, return\r
750 //\r
751 if (OrigSize == 0) {\r
752 return RETURN_SUCCESS;\r
753 }\r
754\r
755 Src = Src + 8;\r
756\r
757 for (Index = 0; Index < sizeof (SCRATCH_DATA); Index++) {\r
758 ((UINT8 *) Sd)[Index] = 0;\r
759 }\r
760 //\r
761 // The length of the field 'Position Set Code Length Array Size' in Block Header.\r
762 // For EFI 1.1 de/compression algorithm(Version 1), mPBit = 4\r
763 // For Tiano de/compression algorithm(Version 2), mPBit = 5\r
764 //\r
765 switch (Version) {\r
766 case 1 :\r
767 Sd->mPBit = 4;\r
768 break;\r
769 case 2 :\r
770 Sd->mPBit = 5;\r
771 break;\r
772 default:\r
773 ASSERT (FALSE);\r
774 }\r
775 Sd->mSrcBase = (UINT8 *)Src;\r
776 Sd->mDstBase = Dst;\r
777 Sd->mCompSize = CompSize;\r
778 Sd->mOrigSize = OrigSize;\r
779\r
780 //\r
781 // Fill the first BITBUFSIZ bits\r
782 //\r
783 FillBuf (Sd, BITBUFSIZ);\r
784\r
785 //\r
786 // Decompress it\r
787 //\r
788 Decode (Sd);\r
789\r
790 if (Sd->mBadTableFlag != 0) {\r
791 //\r
792 // Something wrong with the source\r
793 //\r
794 return RETURN_INVALID_PARAMETER;\r
795 }\r
796\r
797 return RETURN_SUCCESS;\r
798}\r
799\r
800RETURN_STATUS\r
801EFIAPI\r
802UefiDecompress (\r
803 IN CONST VOID *Source,\r
804 IN OUT VOID *Destination,\r
805 IN OUT VOID *Scratch\r
806 )\r
807/*++\r
808\r
809Routine Description:\r
810\r
811 The internal implementation of *_DECOMPRESS_PROTOCOL.Decompress().\r
812\r
813Arguments:\r
814\r
815 Source - The source buffer containing the compressed data.\r
816 Destination - The destination buffer to store the decompressed data\r
817 Scratch - The buffer used internally by the decompress routine. This buffer is needed to store intermediate data.\r
818\r
819Returns:\r
820\r
821 RETURN_SUCCESS - Decompression is successfull\r
822 RETURN_INVALID_PARAMETER - The source data is corrupted\r
823\r
824--*/\r
825{\r
826 return UefiTianoDecompress (Source, Destination, Scratch, 1);\r
827}\r
828\r
829RETURN_STATUS\r
830EFIAPI\r
831TianoDecompressGetInfo (\r
832 IN CONST VOID *Source,\r
833 IN UINT32 SourceSize,\r
834 OUT UINT32 *DestinationSize,\r
835 OUT UINT32 *ScratchSize\r
836 )\r
837/*++\r
838\r
839Routine Description:\r
840\r
841 The internal implementation of *_DECOMPRESS_PROTOCOL.GetInfo().\r
842\r
843Arguments:\r
844\r
845 Source - The source buffer containing the compressed data.\r
846 SourceSize - The size of source buffer\r
847 DestinationSize - The size of destination buffer.\r
848 ScratchSize - The size of scratch buffer.\r
849\r
850Returns:\r
851\r
852 RETURN_SUCCESS - The size of destination buffer and the size of scratch buffer are successull retrieved.\r
853 RETURN_INVALID_PARAMETER - The source data is corrupted\r
854\r
855--*/\r
856{\r
857 return UefiDecompressGetInfo (Source, SourceSize, DestinationSize, ScratchSize);\r
858}\r
859\r
860RETURN_STATUS\r
861EFIAPI\r
862TianoDecompress (\r
863 IN CONST VOID *Source,\r
864 IN OUT VOID *Destination,\r
865 IN OUT VOID *Scratch\r
866 )\r
867/*++\r
868\r
869Routine Description:\r
870\r
871 The internal implementation of *_DECOMPRESS_PROTOCOL.Decompress().\r
872\r
873Arguments:\r
874\r
875 Source - The source buffer containing the compressed data.\r
876 Destination - The destination buffer to store the decompressed data\r
877 Scratch - The buffer used internally by the decompress routine. This buffer is needed to store intermediate data.\r
878\r
879Returns:\r
880\r
881 RETURN_SUCCESS - Decompression is successfull\r
882 RETURN_INVALID_PARAMETER - The source data is corrupted\r
883\r
884--*/\r
885{\r
886 return UefiTianoDecompress (Source, Destination, Scratch, 2);\r
887}\r
EFI Development Kit II mirror for PVE