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