TinyLzmaDecompress.c 22 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505
  1. // TinyLZMA
  2. // Source from https://github.com/WangXuan95/TinyLzma
  3. #include <stdlib.h> // this code only use malloc and free
  4. #include "TinyLzmaDecompress.h"
  5. // the code only use these basic types :
  6. // int : as return code
  7. // uint8_t : as compressed and uncompressed data, as LZMA state
  8. // uint16_t : as probabilities of range coder
  9. // uint32_t : as generic integers
  10. // size_t : as data length
  11. #define RET_IF_ERROR(expression) { \
  12. int res = (expression); \
  13. if (res != R_OK) \
  14. return res; \
  15. }
  16. /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  17. // common useful functions
  18. /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  19. static uint32_t bitsReverse (uint32_t bits, uint32_t bit_count) {
  20. uint32_t revbits = 0;
  21. for (; bit_count>0; bit_count--) {
  22. revbits <<= 1;
  23. revbits |= (bits & 1);
  24. bits >>= 1;
  25. }
  26. return revbits;
  27. }
  28. /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  29. // Range Decoder
  30. /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  31. #define RANGE_CODE_NORMALIZE_THRESHOLD (1 << 24)
  32. #define RANGE_CODE_MOVE_BITS 5
  33. #define RANGE_CODE_N_BIT_MODEL_TOTAL_BITS 11
  34. #define RANGE_CODE_BIT_MODEL_TOTAL (1 << RANGE_CODE_N_BIT_MODEL_TOTAL_BITS)
  35. #define RANGE_CODE_HALF_PROBABILITY (RANGE_CODE_BIT_MODEL_TOTAL >> 1)
  36. typedef struct {
  37. uint32_t code;
  38. uint32_t range;
  39. const uint8_t *p_src;
  40. const uint8_t *p_src_limit;
  41. uint8_t overflow;
  42. } RangeDecoder_t;
  43. static void rangeDecodeNormalize (RangeDecoder_t *d) {
  44. if (d->range < RANGE_CODE_NORMALIZE_THRESHOLD) {
  45. if (d->p_src != d->p_src_limit) {
  46. d->range <<= 8;
  47. d->code <<= 8;
  48. d->code |= (uint32_t)(*(d->p_src));
  49. d->p_src ++;
  50. } else {
  51. d->overflow = 1;
  52. }
  53. }
  54. }
  55. static RangeDecoder_t newRangeDecoder (const uint8_t *p_src, size_t src_len) {
  56. RangeDecoder_t coder;
  57. coder.code = 0;
  58. coder.range = 0;
  59. coder.p_src = p_src;
  60. coder.p_src_limit = p_src + src_len;
  61. coder.overflow = 0;
  62. rangeDecodeNormalize(&coder);
  63. rangeDecodeNormalize(&coder);
  64. rangeDecodeNormalize(&coder);
  65. rangeDecodeNormalize(&coder);
  66. rangeDecodeNormalize(&coder);
  67. coder.range = 0xFFFFFFFF;
  68. return coder;
  69. }
  70. static uint32_t rangeDecodeIntByFixedProb (RangeDecoder_t *d, uint32_t bit_count) {
  71. uint32_t val=0, b;
  72. for (; bit_count>0; bit_count--) {
  73. rangeDecodeNormalize(d);
  74. d->range >>= 1;
  75. d->code -= d->range;
  76. b = !(1 & (d->code >> 31));
  77. if (!b)
  78. d->code += d->range;
  79. val <<= 1;
  80. val |= b;
  81. }
  82. return val;
  83. }
  84. static uint32_t rangeDecodeBit (RangeDecoder_t *d, uint16_t *p_prob) {
  85. uint32_t prob = *p_prob;
  86. uint32_t bound;
  87. rangeDecodeNormalize(d);
  88. bound = (d->range >> RANGE_CODE_N_BIT_MODEL_TOTAL_BITS) * prob;
  89. if (d->code < bound) {
  90. d->range = bound;
  91. *p_prob = (uint16_t)(prob + ((RANGE_CODE_BIT_MODEL_TOTAL - prob) >> RANGE_CODE_MOVE_BITS));
  92. return 0;
  93. } else {
  94. d->range -= bound;
  95. d->code -= bound;
  96. *p_prob = (uint16_t)(prob - (prob >> RANGE_CODE_MOVE_BITS));
  97. return 1;
  98. }
  99. }
  100. static uint32_t rangeDecodeInt (RangeDecoder_t *d, uint16_t *p_prob, uint32_t bit_count) {
  101. uint32_t val = 1;
  102. uint32_t i;
  103. for (i=0; i<bit_count; i++) {
  104. if ( ! rangeDecodeBit(d, p_prob+val-1) ) { // get bit 0
  105. val <<= 1;
  106. } else { // get bit 1
  107. val <<= 1;
  108. val |= 1;
  109. }
  110. }
  111. return val & ((1<<bit_count)-1) ;
  112. }
  113. static uint32_t rangeDecodeByteMatched (RangeDecoder_t *d, uint16_t *p_prob, uint32_t match_byte) {
  114. uint32_t i, val = 1, off0 = 0x100, off1; // off0 and off1 can only be 0x000 or 0x100
  115. for (i=0; i<8; i++) {
  116. match_byte <<= 1;
  117. off1 = off0;
  118. off0 &= match_byte;
  119. if ( ! rangeDecodeBit(d, (p_prob+(off0+off1+val-1))) ) { // get bit 0
  120. val <<= 1;
  121. off0 ^= off1;
  122. } else { // get bit 1
  123. val <<= 1;
  124. val |= 1;
  125. }
  126. }
  127. return val & 0xFF;
  128. }
  129. /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  130. // LZMA Decoder
  131. /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  132. typedef enum { // packet_type
  133. PKT_LIT,
  134. PKT_MATCH,
  135. PKT_SHORTREP,
  136. PKT_REP0, // LONGREP0
  137. PKT_REP1, // LONGREP1
  138. PKT_REP2, // LONGREP2
  139. PKT_REP3 // LONGREP3
  140. } PACKET_t;
  141. static uint8_t stateTransition (uint8_t state, PACKET_t type) {
  142. switch (state) {
  143. case 0 : return (type==PKT_LIT) ? 0 : (type==PKT_MATCH) ? 7 : (type==PKT_SHORTREP) ? 9 : 8;
  144. case 1 : return (type==PKT_LIT) ? 0 : (type==PKT_MATCH) ? 7 : (type==PKT_SHORTREP) ? 9 : 8;
  145. case 2 : return (type==PKT_LIT) ? 0 : (type==PKT_MATCH) ? 7 : (type==PKT_SHORTREP) ? 9 : 8;
  146. case 3 : return (type==PKT_LIT) ? 0 : (type==PKT_MATCH) ? 7 : (type==PKT_SHORTREP) ? 9 : 8;
  147. case 4 : return (type==PKT_LIT) ? 1 : (type==PKT_MATCH) ? 7 : (type==PKT_SHORTREP) ? 9 : 8;
  148. case 5 : return (type==PKT_LIT) ? 2 : (type==PKT_MATCH) ? 7 : (type==PKT_SHORTREP) ? 9 : 8;
  149. case 6 : return (type==PKT_LIT) ? 3 : (type==PKT_MATCH) ? 7 : (type==PKT_SHORTREP) ? 9 : 8;
  150. case 7 : return (type==PKT_LIT) ? 4 : (type==PKT_MATCH) ? 10 : (type==PKT_SHORTREP) ? 11 : 11;
  151. case 8 : return (type==PKT_LIT) ? 5 : (type==PKT_MATCH) ? 10 : (type==PKT_SHORTREP) ? 11 : 11;
  152. case 9 : return (type==PKT_LIT) ? 6 : (type==PKT_MATCH) ? 10 : (type==PKT_SHORTREP) ? 11 : 11;
  153. case 10 : return (type==PKT_LIT) ? 4 : (type==PKT_MATCH) ? 10 : (type==PKT_SHORTREP) ? 11 : 11;
  154. case 11 : return (type==PKT_LIT) ? 5 : (type==PKT_MATCH) ? 10 : (type==PKT_SHORTREP) ? 11 : 11;
  155. default : return 0xFF; // 0xFF is invalid state which will never appear
  156. }
  157. }
  158. #define N_STATES 12
  159. #define N_LIT_STATES 7
  160. #define MAX_LC 8 // max value of lc is 8, see LZMA specification
  161. #define N_PREV_BYTE_LC_MSBS (1 << MAX_LC)
  162. #define MAX_LP 4 // max value of lp is 4, see LZMA specification
  163. #define N_LIT_POS_STATES (1 << MAX_LP)
  164. #define MAX_PB 4 // max value of pb is 4, see LZMA specification
  165. #define N_POS_STATES (1 << MAX_PB)
  166. #define INIT_PROBS(probs) { \
  167. uint16_t *p = (uint16_t*)(probs); \
  168. uint16_t *q = p + (sizeof(probs) / sizeof(uint16_t)); \
  169. for (; p<q; p++) \
  170. *p = RANGE_CODE_HALF_PROBABILITY; \
  171. } // all probabilities are init to 50% (half probability)
  172. #define INIT_PROBS_LITERAL(probs) { \
  173. uint16_t *p = (uint16_t*)(probs); \
  174. uint16_t *q = p + (N_PREV_BYTE_LC_MSBS*N_LIT_POS_STATES*3*(1<<8)); \
  175. for (; p<q; p++) \
  176. *p = RANGE_CODE_HALF_PROBABILITY; \
  177. } // all probabilities are init to 50% (half probability)
  178. static int lzmaDecode (const uint8_t *p_src, size_t src_len, uint8_t *p_dst, size_t *p_dst_len, uint8_t lc, uint8_t lp, uint8_t pb) {
  179. const uint32_t lc_shift = (8 - lc);
  180. const uint32_t lc_mask = (1 << lc) - 1;
  181. const uint32_t lp_mask = (1 << lp) - 1;
  182. const uint32_t pb_mask = (1 << pb) - 1;
  183. uint8_t state = 0; // valid value : 0~12
  184. size_t pos = 0; // position of uncompressed data (p_dst)
  185. uint32_t rep0 = 1;
  186. uint32_t rep1 = 1;
  187. uint32_t rep2 = 1;
  188. uint32_t rep3 = 1;
  189. RangeDecoder_t coder = newRangeDecoder(p_src, src_len);
  190. // probability arrays ---------------------------------------
  191. uint16_t probs_is_match [N_STATES] [N_POS_STATES] ;
  192. uint16_t probs_is_rep [N_STATES] ;
  193. uint16_t probs_is_rep0 [N_STATES] ;
  194. uint16_t probs_is_rep0_long [N_STATES] [N_POS_STATES] ;
  195. uint16_t probs_is_rep1 [N_STATES] ;
  196. uint16_t probs_is_rep2 [N_STATES] ;
  197. uint16_t probs_dist_slot [4] [(1<<6)-1];
  198. uint16_t probs_dist_special [10] [(1<<5)-1];
  199. uint16_t probs_dist_align [(1<<4)-1];
  200. uint16_t probs_len_choice [2];
  201. uint16_t probs_len_choice2 [2];
  202. uint16_t probs_len_low [2] [N_POS_STATES] [(1<<3)-1];
  203. uint16_t probs_len_mid [2] [N_POS_STATES] [(1<<3)-1];
  204. uint16_t probs_len_high [2] [(1<<8)-1];
  205. // uint16_t probs_literal [N_PREV_BYTE_LC_MSBS] [N_LIT_POS_STATES] [3*(1<<8)];
  206. uint16_t (*probs_literal) [N_LIT_POS_STATES] [3*(1<<8)];
  207. probs_literal = (uint16_t (*) [N_LIT_POS_STATES] [3*(1<<8)]) malloc (sizeof(uint16_t) * N_PREV_BYTE_LC_MSBS * N_LIT_POS_STATES * 3*(1<<8)); // since this array is quiet large (3145728 items, 6MB), we need to use malloc
  208. if (probs_literal == 0)
  209. return R_ERR_MEMORY_RUNOUT;
  210. INIT_PROBS(probs_is_match);
  211. INIT_PROBS(probs_is_rep);
  212. INIT_PROBS(probs_is_rep0);
  213. INIT_PROBS(probs_is_rep0_long);
  214. INIT_PROBS(probs_is_rep1);
  215. INIT_PROBS(probs_is_rep2);
  216. INIT_PROBS(probs_dist_slot);
  217. INIT_PROBS(probs_dist_special);
  218. INIT_PROBS(probs_dist_align);
  219. INIT_PROBS(probs_len_choice);
  220. INIT_PROBS(probs_len_choice2);
  221. INIT_PROBS(probs_len_low);
  222. INIT_PROBS(probs_len_mid);
  223. INIT_PROBS(probs_len_high);
  224. //INIT_PROBS(probs_literal);
  225. INIT_PROBS_LITERAL(probs_literal);
  226. while (pos < *p_dst_len) { // main loop
  227. const uint32_t pos_state = pb_mask & (uint32_t)pos;
  228. if (coder.overflow)
  229. return R_ERR_INPUT_OVERFLOW;
  230. if ( !rangeDecodeBit(&coder, &probs_is_match[state][pos_state]) ) { // decoded bit sequence = 0 (packet LIT)
  231. const uint32_t literal_pos_state = lp_mask & (uint32_t)pos;
  232. uint32_t prev_byte_lc_msbs = 0;
  233. uint32_t curr_byte;
  234. if (pos > 0)
  235. prev_byte_lc_msbs = lc_mask & (p_dst[pos-1] >> lc_shift);
  236. if (state < N_LIT_STATES) {
  237. curr_byte = rangeDecodeInt(&coder, probs_literal[prev_byte_lc_msbs][literal_pos_state], 8);
  238. } else {
  239. if (pos < (size_t)rep0)
  240. return R_ERR_DATA;
  241. curr_byte = rangeDecodeByteMatched(&coder, probs_literal[prev_byte_lc_msbs][literal_pos_state], p_dst[pos-rep0]);
  242. }
  243. //printf("[LZMAd] @%08lx PKT_LIT decoded_byte=%02x state=%d\n", pos, curr_byte, state);
  244. if (pos == *p_dst_len)
  245. return R_ERR_OUTPUT_OVERFLOW;
  246. p_dst[pos] = (uint8_t)curr_byte;
  247. pos ++;
  248. state = stateTransition(state, PKT_LIT);
  249. } else { // decoded bit sequence = 1 (packet MATCH, SHORTREP, or LONGREP*)
  250. uint32_t dist=0, len=0;
  251. if ( !rangeDecodeBit(&coder, &probs_is_rep[state]) ) { // decoded bit sequence = 10 (packet MATCH)
  252. rep3 = rep2;
  253. rep2 = rep1;
  254. rep1 = rep0;
  255. //printf("[LZMAd] @%08lx PKT_MATCH state=%d\n", pos, state);
  256. state = stateTransition(state, PKT_MATCH);
  257. } else if ( !rangeDecodeBit(&coder, &probs_is_rep0[state]) ) { // decoded bit sequence = 110 (packet SHORTREP or LONGREP0)
  258. dist = rep0;
  259. if ( !rangeDecodeBit(&coder, &probs_is_rep0_long[state][pos_state]) ) { // decoded bit sequence = 1100 (packet SHORTREP)
  260. len = 1;
  261. //printf("[LZMAd] @%08lx PKT_SHORTREP state=%d\n", pos, state);
  262. state = stateTransition(state, PKT_SHORTREP);
  263. } else { // decoded bit sequence = 1101 (packet LONGREP0)
  264. //printf("[LZMAd] @%08lx PKT_REP0 state=%d\n", pos, state);
  265. state = stateTransition(state, PKT_REP0);
  266. }
  267. } else if ( !rangeDecodeBit(&coder, &probs_is_rep1[state]) ) { // decoded bit sequence = 1110 (packet LONGREP1)
  268. dist = rep1;
  269. rep1 = rep0;
  270. //printf("[LZMAd] @%08lx PKT_REP1 state=%d\n", pos, state);
  271. state = stateTransition(state, PKT_REP1);
  272. } else if ( !rangeDecodeBit(&coder, &probs_is_rep2[state]) ) { // decoded bit sequence = 11110 (packet LONGREP2)
  273. dist = rep2;
  274. rep2 = rep1;
  275. rep1 = rep0;
  276. //printf("[LZMAd] @%08lx PKT_REP2 state=%d\n", pos, state);
  277. state = stateTransition(state, PKT_REP2);
  278. } else { // decoded bit sequence = 11111 (packet LONGREP3)
  279. dist = rep3;
  280. rep3 = rep2;
  281. rep2 = rep1;
  282. rep1 = rep0;
  283. //printf("[LZMAd] @%08lx PKT_REP3 state=%d\n", pos, state);
  284. state = stateTransition(state, PKT_REP3);
  285. }
  286. if (len == 0) { // unknown length, need to decode
  287. if ( !rangeDecodeBit(&coder, &probs_len_choice [dist==0]) )
  288. len = 2 + rangeDecodeInt(&coder, probs_len_low[dist==0][pos_state], 3); // len = 2~9
  289. else if ( !rangeDecodeBit(&coder, &probs_len_choice2[dist==0]) )
  290. len = 10 + rangeDecodeInt(&coder, probs_len_mid[dist==0][pos_state], 3); // len = 10~17
  291. else
  292. len = 18 + rangeDecodeInt(&coder,probs_len_high[dist==0], 8); // len = 18~273
  293. //printf("[LZMAd] len = %u\n", len);
  294. }
  295. if (dist == 0) { // unknown distance, need to decode
  296. const uint32_t len_min5_minus2 = (len>5) ? 3 : (len-2);
  297. uint32_t dist_slot;
  298. uint32_t mid_bcnt = 0;
  299. uint32_t low_bcnt = 0;
  300. uint32_t low_bits = 0;
  301. dist_slot = rangeDecodeInt(&coder, probs_dist_slot[len_min5_minus2], 6); // decode distance slot (0~63)
  302. if (dist_slot >=14) { // dist slot = 14~63
  303. dist = (2 | (dist_slot & 1)); // high 2 bits of dist
  304. mid_bcnt = (dist_slot >> 1) - 5;
  305. low_bcnt = 4;
  306. } else if (dist_slot >=4 ) { // dist slot = 4~13
  307. dist = (2 | (dist_slot & 1)); // high 2 bits of dist
  308. low_bcnt = (dist_slot >> 1) - 1;
  309. } else { // dist slot = 0~3
  310. dist = dist_slot;
  311. }
  312. dist <<= mid_bcnt;
  313. dist |= rangeDecodeIntByFixedProb(&coder, mid_bcnt);
  314. if (dist_slot >=14) // dist slot = 14~63
  315. low_bits = rangeDecodeInt(&coder, probs_dist_align , low_bcnt);
  316. else if (dist_slot >=4 ) // dist slot = 4~13
  317. low_bits = rangeDecodeInt(&coder, probs_dist_special[dist_slot-4], low_bcnt);
  318. low_bits = bitsReverse(low_bits, low_bcnt);
  319. dist <<= low_bcnt;
  320. dist |= low_bits;
  321. if (dist == 0xFFFFFFFF) {
  322. //printf("[LZMAd] meet end marker\n");
  323. break;
  324. }
  325. dist ++;
  326. //printf("[LZMAd] dist_slot = %u dist = %u\n", dist_slot, dist);
  327. }
  328. rep0 = dist;
  329. if (dist > pos || dist == 0)
  330. return R_ERR_DATA;
  331. for (; len>0; len--) {
  332. if (pos == *p_dst_len)
  333. return R_ERR_OUTPUT_OVERFLOW;
  334. p_dst[pos] = p_dst[pos-dist];
  335. pos ++;
  336. }
  337. }
  338. }
  339. free(probs_literal);
  340. *p_dst_len = pos;
  341. return R_OK;
  342. }
  343. /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  344. // LZMA decompress (include parsing ".lzma" format's header)
  345. /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  346. #define LZMA_HEADER_LEN 13
  347. #define LZMA_DIC_MIN (1 << 12)
  348. static int parseLzmaHeader (const uint8_t *p_src, uint8_t *p_lc, uint8_t *p_lp, uint8_t *p_pb, uint32_t *p_dict_len, size_t *p_uncompressed_len, uint32_t *p_uncompressed_len_known) {
  349. uint8_t byte0 = p_src[0];
  350. *p_dict_len = ((uint32_t)p_src[1] ) | ((uint32_t)p_src[2] <<8) | ((uint32_t)p_src[3] <<16) | ((uint32_t)p_src[4] <<24) ;
  351. if (*p_dict_len < LZMA_DIC_MIN)
  352. *p_dict_len = LZMA_DIC_MIN;
  353. if (p_src[5] == 0xFF && p_src[6] == 0xFF && p_src[7] == 0xFF && p_src[8] == 0xFF && p_src[9] == 0xFF && p_src[10] == 0xFF && p_src[11] == 0xFF && p_src[12] == 0xFF) {
  354. *p_uncompressed_len_known = 0;
  355. } else {
  356. uint32_t i;
  357. *p_uncompressed_len_known = 1;
  358. *p_uncompressed_len = 0;
  359. for (i=0; i<8; i++) {
  360. if (i < sizeof(size_t)) {
  361. *p_uncompressed_len |= (((size_t)p_src[5+i]) << (i<<3)); // get (sizeof(size_t)) bytes from p_src, and put it to (*p_uncompressed_len)
  362. } else if (p_src[5+i] > 0) {
  363. return R_ERR_OUTPUT_OVERFLOW; // uncompressed length overflow from the machine's memory address limit
  364. }
  365. }
  366. }
  367. *p_lc = (uint8_t)(byte0 % 9);
  368. byte0 /= 9;
  369. *p_lp = (uint8_t)(byte0 % 5);
  370. *p_pb = (uint8_t)(byte0 / 5);
  371. if (*p_lc > MAX_LC || *p_lp > MAX_LP || *p_pb > MAX_PB)
  372. return R_ERR_UNSUPPORTED;
  373. return R_OK;
  374. }
  375. int tinyLzmaDecompress (const uint8_t *p_src, size_t src_len, uint8_t *p_dst, size_t *p_dst_len) {
  376. uint8_t lc, lp, pb; // lc=0~8 lp=0~4 pb=0~4
  377. uint32_t dict_len, uncompressed_len_known;
  378. size_t uncompressed_len = 0;
  379. if (src_len < LZMA_HEADER_LEN)
  380. return R_ERR_INPUT_OVERFLOW;
  381. RET_IF_ERROR( parseLzmaHeader(p_src, &lc, &lp, &pb, &dict_len, &uncompressed_len, &uncompressed_len_known) )
  382. //printf("[LZMAd] lc=%d lp=%d pb=%d dict_len=%u\n", lc, lp, pb, dict_len);
  383. if (uncompressed_len_known) {
  384. if (uncompressed_len > *p_dst_len)
  385. return R_ERR_OUTPUT_OVERFLOW;
  386. *p_dst_len = uncompressed_len;
  387. //printf("[LZMAd] uncompressed length = %lu (parsed from header)\n" , *p_dst_len);
  388. } else {
  389. //printf("[LZMAd] uncompressed length is not in header, decoding using output buffer length = %lu\n" , *p_dst_len);
  390. }
  391. RET_IF_ERROR( lzmaDecode(p_src+LZMA_HEADER_LEN, src_len-LZMA_HEADER_LEN, p_dst, p_dst_len, lc, lp, pb) );
  392. if (uncompressed_len_known && uncompressed_len != *p_dst_len)
  393. return R_ERR_OUTPUT_LEN_MISMATCH;
  394. return R_OK;
  395. }