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