← Back to branch summary

~smartboyhw/wubi/bug-1080090-new

« back to all changes in this revision

Viewing changes to src/grubutil/makerom/.svn/text-base/LzmaDecode.c.svn-base

  • Committer: Howard Chan
  • Date: 2012-11-20 10:16:05 UTC
  • Revision ID: smartboyhw@gmail.com-20121120101605-qfmjfsdynpzg9an9
https://launchpad.net/bugs/1080090
Added images

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/grubutil/makerom/.svn/text-base/LzmaDecode.c.svn-base
1
 
/*
2
 
  LzmaDecode.c
3
 
  LZMA Decoder (optimized for Speed version)
4
 
  
5
 
  LZMA SDK 4.40 Copyright (c) 1999-2006 Igor Pavlov (2006-05-01)
6
 
  http://www.7-zip.org/
7
 
 
8
 
  LZMA SDK is licensed under two licenses:
9
 
  1) GNU Lesser General Public License (GNU LGPL)
10
 
  2) Common Public License (CPL)
11
 
  It means that you can select one of these two licenses and 
12
 
  follow rules of that license.
13
 
 
14
 
  SPECIAL EXCEPTION:
15
 
  Igor Pavlov, as the author of this Code, expressly permits you to 
16
 
  statically or dynamically link your Code (or bind by name) to the 
17
 
  interfaces of this file without subjecting your linked Code to the 
18
 
  terms of the CPL or GNU LGPL. Any modifications or additions 
19
 
  to this file, however, are subject to the LGPL or CPL terms.
20
 
*/
21
 
 
22
 
#include "LzmaDecode.h"
23
 
 
24
 
#define kNumTopBits 24
25
 
#define kTopValue ((UInt32)1 << kNumTopBits)
26
 
 
27
 
#define kNumBitModelTotalBits 11
28
 
#define kBitModelTotal (1 << kNumBitModelTotalBits)
29
 
#define kNumMoveBits 5
30
 
 
31
 
#define RC_READ_BYTE (*Buffer++)
32
 
 
33
 
#define RC_INIT2 Code = 0; Range = 0xFFFFFFFF; \
34
 
  { int i; for(i = 0; i < 5; i++) { RC_TEST; Code = (Code << 8) | RC_READ_BYTE; }}
35
 
 
36
 
#ifdef _LZMA_IN_CB
37
 
 
38
 
#define RC_TEST { if (Buffer == BufferLim) \
39
 
  { SizeT size; int result = InCallback->Read(InCallback, &Buffer, &size); if (result != LZMA_RESULT_OK) return result; \
40
 
  BufferLim = Buffer + size; if (size == 0) return LZMA_RESULT_DATA_ERROR; }}
41
 
 
42
 
#define RC_INIT Buffer = BufferLim = 0; RC_INIT2
43
 
 
44
 
#else
45
 
 
46
 
#define RC_TEST { if (Buffer == BufferLim) return LZMA_RESULT_DATA_ERROR; }
47
 
 
48
 
#define RC_INIT(buffer, bufferSize) Buffer = buffer; BufferLim = buffer + bufferSize; RC_INIT2
49
 
 
50
 
#endif
51
 
 
52
 
#define RC_NORMALIZE if (Range < kTopValue) { RC_TEST; Range <<= 8; Code = (Code << 8) | RC_READ_BYTE; }
53
 
 
54
 
#define IfBit0(p) RC_NORMALIZE; bound = (Range >> kNumBitModelTotalBits) * *(p); if (Code < bound)
55
 
#define UpdateBit0(p) Range = bound; *(p) += (kBitModelTotal - *(p)) >> kNumMoveBits;
56
 
#define UpdateBit1(p) Range -= bound; Code -= bound; *(p) -= (*(p)) >> kNumMoveBits;
57
 
 
58
 
#define RC_GET_BIT2(p, mi, A0, A1) IfBit0(p) \
59
 
  { UpdateBit0(p); mi <<= 1; A0; } else \
60
 
  { UpdateBit1(p); mi = (mi + mi) + 1; A1; } 
61
 
  
62
 
#define RC_GET_BIT(p, mi) RC_GET_BIT2(p, mi, ; , ;)               
63
 
 
64
 
#define RangeDecoderBitTreeDecode(probs, numLevels, res) \
65
 
  { int i = numLevels; res = 1; \
66
 
  do { CProb *p = probs + res; RC_GET_BIT(p, res) } while(--i != 0); \
67
 
  res -= (1 << numLevels); }
68
 
 
69
 
 
70
 
#define kNumPosBitsMax 4
71
 
#define kNumPosStatesMax (1 << kNumPosBitsMax)
72
 
 
73
 
#define kLenNumLowBits 3
74
 
#define kLenNumLowSymbols (1 << kLenNumLowBits)
75
 
#define kLenNumMidBits 3
76
 
#define kLenNumMidSymbols (1 << kLenNumMidBits)
77
 
#define kLenNumHighBits 8
78
 
#define kLenNumHighSymbols (1 << kLenNumHighBits)
79
 
 
80
 
#define LenChoice 0
81
 
#define LenChoice2 (LenChoice + 1)
82
 
#define LenLow (LenChoice2 + 1)
83
 
#define LenMid (LenLow + (kNumPosStatesMax << kLenNumLowBits))
84
 
#define LenHigh (LenMid + (kNumPosStatesMax << kLenNumMidBits))
85
 
#define kNumLenProbs (LenHigh + kLenNumHighSymbols) 
86
 
 
87
 
 
88
 
#define kNumStates 12
89
 
#define kNumLitStates 7
90
 
 
91
 
#define kStartPosModelIndex 4
92
 
#define kEndPosModelIndex 14
93
 
#define kNumFullDistances (1 << (kEndPosModelIndex >> 1))
94
 
 
95
 
#define kNumPosSlotBits 6
96
 
#define kNumLenToPosStates 4
97
 
 
98
 
#define kNumAlignBits 4
99
 
#define kAlignTableSize (1 << kNumAlignBits)
100
 
 
101
 
#define kMatchMinLen 2
102
 
 
103
 
#define IsMatch 0
104
 
#define IsRep (IsMatch + (kNumStates << kNumPosBitsMax))
105
 
#define IsRepG0 (IsRep + kNumStates)
106
 
#define IsRepG1 (IsRepG0 + kNumStates)
107
 
#define IsRepG2 (IsRepG1 + kNumStates)
108
 
#define IsRep0Long (IsRepG2 + kNumStates)
109
 
#define PosSlot (IsRep0Long + (kNumStates << kNumPosBitsMax))
110
 
#define SpecPos (PosSlot + (kNumLenToPosStates << kNumPosSlotBits))
111
 
#define Align (SpecPos + kNumFullDistances - kEndPosModelIndex)
112
 
#define LenCoder (Align + kAlignTableSize)
113
 
#define RepLenCoder (LenCoder + kNumLenProbs)
114
 
#define Literal (RepLenCoder + kNumLenProbs)
115
 
 
116
 
#if Literal != LZMA_BASE_SIZE
117
 
StopCompilingDueBUG
118
 
#endif
119
 
 
120
 
int LzmaDecodeProperties(CLzmaProperties *propsRes, const unsigned char *propsData, int size)
121
 
{
122
 
  unsigned char prop0;
123
 
  if (size < LZMA_PROPERTIES_SIZE)
124
 
    return LZMA_RESULT_DATA_ERROR;
125
 
  prop0 = propsData[0];
126
 
  if (prop0 >= (9 * 5 * 5))
127
 
    return LZMA_RESULT_DATA_ERROR;
128
 
  {
129
 
    for (propsRes->pb = 0; prop0 >= (9 * 5); propsRes->pb++, prop0 -= (9 * 5));
130
 
    for (propsRes->lp = 0; prop0 >= 9; propsRes->lp++, prop0 -= 9);
131
 
    propsRes->lc = prop0;
132
 
    /*
133
 
    unsigned char remainder = (unsigned char)(prop0 / 9);
134
 
    propsRes->lc = prop0 % 9;
135
 
    propsRes->pb = remainder / 5;
136
 
    propsRes->lp = remainder % 5;
137
 
    */
138
 
  }
139
 
 
140
 
  #ifdef _LZMA_OUT_READ
141
 
  {
142
 
    int i;
143
 
    propsRes->DictionarySize = 0;
144
 
    for (i = 0; i < 4; i++)
145
 
      propsRes->DictionarySize += (UInt32)(propsData[1 + i]) << (i * 8);
146
 
    if (propsRes->DictionarySize == 0)
147
 
      propsRes->DictionarySize = 1;
148
 
  }
149
 
  #endif
150
 
  return LZMA_RESULT_OK;
151
 
}
152
 
 
153
 
#define kLzmaStreamWasFinishedId (-1)
154
 
 
155
 
int LzmaDecode(CLzmaDecoderState *vs,
156
 
    #ifdef _LZMA_IN_CB
157
 
    ILzmaInCallback *InCallback,
158
 
    #else
159
 
    const unsigned char *inStream, SizeT inSize, SizeT *inSizeProcessed,
160
 
    #endif
161
 
    unsigned char *outStream, SizeT outSize, SizeT *outSizeProcessed)
162
 
{
163
 
  CProb *p = vs->Probs;
164
 
  SizeT nowPos = 0;
165
 
  Byte previousByte = 0;
166
 
  UInt32 posStateMask = (1 << (vs->Properties.pb)) - 1;
167
 
  UInt32 literalPosMask = (1 << (vs->Properties.lp)) - 1;
168
 
  int lc = vs->Properties.lc;
169
 
 
170
 
  #ifdef _LZMA_OUT_READ
171
 
  
172
 
  UInt32 Range = vs->Range;
173
 
  UInt32 Code = vs->Code;
174
 
  #ifdef _LZMA_IN_CB
175
 
  const Byte *Buffer = vs->Buffer;
176
 
  const Byte *BufferLim = vs->BufferLim;
177
 
  #else
178
 
  const Byte *Buffer = inStream;
179
 
  const Byte *BufferLim = inStream + inSize;
180
 
  #endif
181
 
  int state = vs->State;
182
 
  UInt32 rep0 = vs->Reps[0], rep1 = vs->Reps[1], rep2 = vs->Reps[2], rep3 = vs->Reps[3];
183
 
  int len = vs->RemainLen;
184
 
  UInt32 globalPos = vs->GlobalPos;
185
 
  UInt32 distanceLimit = vs->DistanceLimit;
186
 
 
187
 
  Byte *dictionary = vs->Dictionary;
188
 
  UInt32 dictionarySize = vs->Properties.DictionarySize;
189
 
  UInt32 dictionaryPos = vs->DictionaryPos;
190
 
 
191
 
  Byte tempDictionary[4];
192
 
 
193
 
  #ifndef _LZMA_IN_CB
194
 
  *inSizeProcessed = 0;
195
 
  #endif
196
 
  *outSizeProcessed = 0;
197
 
  if (len == kLzmaStreamWasFinishedId)
198
 
    return LZMA_RESULT_OK;
199
 
 
200
 
  if (dictionarySize == 0)
201
 
  {
202
 
    dictionary = tempDictionary;
203
 
    dictionarySize = 1;
204
 
    tempDictionary[0] = vs->TempDictionary[0];
205
 
  }
206
 
 
207
 
  if (len == kLzmaNeedInitId)
208
 
  {
209
 
    {
210
 
      UInt32 numProbs = Literal + ((UInt32)LZMA_LIT_SIZE << (lc + vs->Properties.lp));
211
 
      UInt32 i;
212
 
      for (i = 0; i < numProbs; i++)
213
 
        p[i] = kBitModelTotal >> 1; 
214
 
      rep0 = rep1 = rep2 = rep3 = 1;
215
 
      state = 0;
216
 
      globalPos = 0;
217
 
      distanceLimit = 0;
218
 
      dictionaryPos = 0;
219
 
      dictionary[dictionarySize - 1] = 0;
220
 
      #ifdef _LZMA_IN_CB
221
 
      RC_INIT;
222
 
      #else
223
 
      RC_INIT(inStream, inSize);
224
 
      #endif
225
 
    }
226
 
    len = 0;
227
 
  }
228
 
  while(len != 0 && nowPos < outSize)
229
 
  {
230
 
    UInt32 pos = dictionaryPos - rep0;
231
 
    if (pos >= dictionarySize)
232
 
      pos += dictionarySize;
233
 
    outStream[nowPos++] = dictionary[dictionaryPos] = dictionary[pos];
234
 
    if (++dictionaryPos == dictionarySize)
235
 
      dictionaryPos = 0;
236
 
    len--;
237
 
  }
238
 
  if (dictionaryPos == 0)
239
 
    previousByte = dictionary[dictionarySize - 1];
240
 
  else
241
 
    previousByte = dictionary[dictionaryPos - 1];
242
 
 
243
 
  #else /* if !_LZMA_OUT_READ */
244
 
 
245
 
  int state = 0;
246
 
  UInt32 rep0 = 1, rep1 = 1, rep2 = 1, rep3 = 1;
247
 
  int len = 0;
248
 
  const Byte *Buffer;
249
 
  const Byte *BufferLim;
250
 
  UInt32 Range;
251
 
  UInt32 Code;
252
 
 
253
 
  #ifndef _LZMA_IN_CB
254
 
  *inSizeProcessed = 0;
255
 
  #endif
256
 
  *outSizeProcessed = 0;
257
 
 
258
 
  {
259
 
    UInt32 i;
260
 
    UInt32 numProbs = Literal + ((UInt32)LZMA_LIT_SIZE << (lc + vs->Properties.lp));
261
 
    for (i = 0; i < numProbs; i++)
262
 
      p[i] = kBitModelTotal >> 1;
263
 
  }
264
 
  
265
 
  #ifdef _LZMA_IN_CB
266
 
  RC_INIT;
267
 
  #else
268
 
  RC_INIT(inStream, inSize);
269
 
  #endif
270
 
 
271
 
  #endif /* _LZMA_OUT_READ */
272
 
 
273
 
  while(nowPos < outSize)
274
 
  {
275
 
    CProb *prob;
276
 
    UInt32 bound;
277
 
    int posState = (int)(
278
 
        (nowPos 
279
 
        #ifdef _LZMA_OUT_READ
280
 
        + globalPos
281
 
        #endif
282
 
        )
283
 
        & posStateMask);
284
 
 
285
 
    prob = p + IsMatch + (state << kNumPosBitsMax) + posState;
286
 
    IfBit0(prob)
287
 
    {
288
 
      int symbol = 1;
289
 
      UpdateBit0(prob)
290
 
      prob = p + Literal + (LZMA_LIT_SIZE * 
291
 
        (((
292
 
        (nowPos 
293
 
        #ifdef _LZMA_OUT_READ
294
 
        + globalPos
295
 
        #endif
296
 
        )
297
 
        & literalPosMask) << lc) + (previousByte >> (8 - lc))));
298
 
 
299
 
      if (state >= kNumLitStates)
300
 
      {
301
 
        int matchByte;
302
 
        #ifdef _LZMA_OUT_READ
303
 
        UInt32 pos = dictionaryPos - rep0;
304
 
        if (pos >= dictionarySize)
305
 
          pos += dictionarySize;
306
 
        matchByte = dictionary[pos];
307
 
        #else
308
 
        matchByte = outStream[nowPos - rep0];
309
 
        #endif
310
 
        do
311
 
        {
312
 
          int bit;
313
 
          CProb *probLit;
314
 
          matchByte <<= 1;
315
 
          bit = (matchByte & 0x100);
316
 
          probLit = prob + 0x100 + bit + symbol;
317
 
          RC_GET_BIT2(probLit, symbol, if (bit != 0) break, if (bit == 0) break)
318
 
        }
319
 
        while (symbol < 0x100);
320
 
      }
321
 
      while (symbol < 0x100)
322
 
      {
323
 
        CProb *probLit = prob + symbol;
324
 
        RC_GET_BIT(probLit, symbol)
325
 
      }
326
 
      previousByte = (Byte)symbol;
327
 
 
328
 
      outStream[nowPos++] = previousByte;
329
 
      #ifdef _LZMA_OUT_READ
330
 
      if (distanceLimit < dictionarySize)
331
 
        distanceLimit++;
332
 
 
333
 
      dictionary[dictionaryPos] = previousByte;
334
 
      if (++dictionaryPos == dictionarySize)
335
 
        dictionaryPos = 0;
336
 
      #endif
337
 
      if (state < 4) state = 0;
338
 
      else if (state < 10) state -= 3;
339
 
      else state -= 6;
340
 
    }
341
 
    else             
342
 
    {
343
 
      UpdateBit1(prob);
344
 
      prob = p + IsRep + state;
345
 
      IfBit0(prob)
346
 
      {
347
 
        UpdateBit0(prob);
348
 
        rep3 = rep2;
349
 
        rep2 = rep1;
350
 
        rep1 = rep0;
351
 
        state = state < kNumLitStates ? 0 : 3;
352
 
        prob = p + LenCoder;
353
 
      }
354
 
      else
355
 
      {
356
 
        UpdateBit1(prob);
357
 
        prob = p + IsRepG0 + state;
358
 
        IfBit0(prob)
359
 
        {
360
 
          UpdateBit0(prob);
361
 
          prob = p + IsRep0Long + (state << kNumPosBitsMax) + posState;
362
 
          IfBit0(prob)
363
 
          {
364
 
            #ifdef _LZMA_OUT_READ
365
 
            UInt32 pos;
366
 
            #endif
367
 
            UpdateBit0(prob);
368
 
            
369
 
            #ifdef _LZMA_OUT_READ
370
 
            if (distanceLimit == 0)
371
 
            #else
372
 
            if (nowPos == 0)
373
 
            #endif
374
 
              return LZMA_RESULT_DATA_ERROR;
375
 
            
376
 
            state = state < kNumLitStates ? 9 : 11;
377
 
            #ifdef _LZMA_OUT_READ
378
 
            pos = dictionaryPos - rep0;
379
 
            if (pos >= dictionarySize)
380
 
              pos += dictionarySize;
381
 
            previousByte = dictionary[pos];
382
 
            dictionary[dictionaryPos] = previousByte;
383
 
            if (++dictionaryPos == dictionarySize)
384
 
              dictionaryPos = 0;
385
 
            #else
386
 
            previousByte = outStream[nowPos - rep0];
387
 
            #endif
388
 
            outStream[nowPos++] = previousByte;
389
 
            #ifdef _LZMA_OUT_READ
390
 
            if (distanceLimit < dictionarySize)
391
 
              distanceLimit++;
392
 
            #endif
393
 
 
394
 
            continue;
395
 
          }
396
 
          else
397
 
          {
398
 
            UpdateBit1(prob);
399
 
          }
400
 
        }
401
 
        else
402
 
        {
403
 
          UInt32 distance;
404
 
          UpdateBit1(prob);
405
 
          prob = p + IsRepG1 + state;
406
 
          IfBit0(prob)
407
 
          {
408
 
            UpdateBit0(prob);
409
 
            distance = rep1;
410
 
          }
411
 
          else 
412
 
          {
413
 
            UpdateBit1(prob);
414
 
            prob = p + IsRepG2 + state;
415
 
            IfBit0(prob)
416
 
            {
417
 
              UpdateBit0(prob);
418
 
              distance = rep2;
419
 
            }
420
 
            else
421
 
            {
422
 
              UpdateBit1(prob);
423
 
              distance = rep3;
424
 
              rep3 = rep2;
425
 
            }
426
 
            rep2 = rep1;
427
 
          }
428
 
          rep1 = rep0;
429
 
          rep0 = distance;
430
 
        }
431
 
        state = state < kNumLitStates ? 8 : 11;
432
 
        prob = p + RepLenCoder;
433
 
      }
434
 
      {
435
 
        int numBits, offset;
436
 
        CProb *probLen = prob + LenChoice;
437
 
        IfBit0(probLen)
438
 
        {
439
 
          UpdateBit0(probLen);
440
 
          probLen = prob + LenLow + (posState << kLenNumLowBits);
441
 
          offset = 0;
442
 
          numBits = kLenNumLowBits;
443
 
        }
444
 
        else
445
 
        {
446
 
          UpdateBit1(probLen);
447
 
          probLen = prob + LenChoice2;
448
 
          IfBit0(probLen)
449
 
          {
450
 
            UpdateBit0(probLen);
451
 
            probLen = prob + LenMid + (posState << kLenNumMidBits);
452
 
            offset = kLenNumLowSymbols;
453
 
            numBits = kLenNumMidBits;
454
 
          }
455
 
          else
456
 
          {
457
 
            UpdateBit1(probLen);
458
 
            probLen = prob + LenHigh;
459
 
            offset = kLenNumLowSymbols + kLenNumMidSymbols;
460
 
            numBits = kLenNumHighBits;
461
 
          }
462
 
        }
463
 
        RangeDecoderBitTreeDecode(probLen, numBits, len);
464
 
        len += offset;
465
 
      }
466
 
 
467
 
      if (state < 4)
468
 
      {
469
 
        int posSlot;
470
 
        state += kNumLitStates;
471
 
        prob = p + PosSlot +
472
 
            ((len < kNumLenToPosStates ? len : kNumLenToPosStates - 1) << 
473
 
            kNumPosSlotBits);
474
 
        RangeDecoderBitTreeDecode(prob, kNumPosSlotBits, posSlot);
475
 
        if (posSlot >= kStartPosModelIndex)
476
 
        {
477
 
          int numDirectBits = ((posSlot >> 1) - 1);
478
 
          rep0 = (2 | ((UInt32)posSlot & 1));
479
 
          if (posSlot < kEndPosModelIndex)
480
 
          {
481
 
            rep0 <<= numDirectBits;
482
 
            prob = p + SpecPos + rep0 - posSlot - 1;
483
 
          }
484
 
          else
485
 
          {
486
 
            numDirectBits -= kNumAlignBits;
487
 
            do
488
 
            {
489
 
              RC_NORMALIZE
490
 
              Range >>= 1;
491
 
              rep0 <<= 1;
492
 
              if (Code >= Range)
493
 
              {
494
 
                Code -= Range;
495
 
                rep0 |= 1;
496
 
              }
497
 
            }
498
 
            while (--numDirectBits != 0);
499
 
            prob = p + Align;
500
 
            rep0 <<= kNumAlignBits;
501
 
            numDirectBits = kNumAlignBits;
502
 
          }
503
 
          {
504
 
            int i = 1;
505
 
            int mi = 1;
506
 
            do
507
 
            {
508
 
              CProb *prob3 = prob + mi;
509
 
              RC_GET_BIT2(prob3, mi, ; , rep0 |= i);
510
 
              i <<= 1;
511
 
            }
512
 
            while(--numDirectBits != 0);
513
 
          }
514
 
        }
515
 
        else
516
 
          rep0 = posSlot;
517
 
        if (++rep0 == (UInt32)(0))
518
 
        {
519
 
          /* it's for stream version */
520
 
          len = kLzmaStreamWasFinishedId;
521
 
          break;
522
 
        }
523
 
      }
524
 
 
525
 
      len += kMatchMinLen;
526
 
      #ifdef _LZMA_OUT_READ
527
 
      if (rep0 > distanceLimit) 
528
 
      #else
529
 
      if (rep0 > nowPos)
530
 
      #endif
531
 
        return LZMA_RESULT_DATA_ERROR;
532
 
 
533
 
      #ifdef _LZMA_OUT_READ
534
 
      if (dictionarySize - distanceLimit > (UInt32)len)
535
 
        distanceLimit += len;
536
 
      else
537
 
        distanceLimit = dictionarySize;
538
 
      #endif
539
 
 
540
 
      do
541
 
      {
542
 
        #ifdef _LZMA_OUT_READ
543
 
        UInt32 pos = dictionaryPos - rep0;
544
 
        if (pos >= dictionarySize)
545
 
          pos += dictionarySize;
546
 
        previousByte = dictionary[pos];
547
 
        dictionary[dictionaryPos] = previousByte;
548
 
        if (++dictionaryPos == dictionarySize)
549
 
          dictionaryPos = 0;
550
 
        #else
551
 
        previousByte = outStream[nowPos - rep0];
552
 
        #endif
553
 
        len--;
554
 
        outStream[nowPos++] = previousByte;
555
 
      }
556
 
      while(len != 0 && nowPos < outSize);
557
 
    }
558
 
  }
559
 
  RC_NORMALIZE;
560
 
 
561
 
  #ifdef _LZMA_OUT_READ
562
 
  vs->Range = Range;
563
 
  vs->Code = Code;
564
 
  vs->DictionaryPos = dictionaryPos;
565
 
  vs->GlobalPos = globalPos + (UInt32)nowPos;
566
 
  vs->DistanceLimit = distanceLimit;
567
 
  vs->Reps[0] = rep0;
568
 
  vs->Reps[1] = rep1;
569
 
  vs->Reps[2] = rep2;
570
 
  vs->Reps[3] = rep3;
571
 
  vs->State = state;
572
 
  vs->RemainLen = len;
573
 
  vs->TempDictionary[0] = tempDictionary[0];
574
 
  #endif
575
 
 
576
 
  #ifdef _LZMA_IN_CB
577
 
  vs->Buffer = Buffer;
578
 
  vs->BufferLim = BufferLim;
579
 
  #else
580
 
  *inSizeProcessed = (SizeT)(Buffer - inStream);
581
 
  #endif
582
 
  *outSizeProcessed = nowPos;
583
 
  return LZMA_RESULT_OK;
584
 
}