← Back to branch summary

~ubuntu-branches/debian/sid/mame/sid

« back to all changes in this revision

Viewing changes to src/lib/lib7z/Lzma86Enc.c

  • Committer: Package Import Robot
  • Author(s): Jordi Mallach, Emmanuel Kasper, Jordi Mallach
  • Date: 2012-06-05 20:02:23 UTC
  • mfrom: (0.3.1) (0.1.4)
  • Revision ID: package-import@ubuntu.com-20120605200223-gnlpogjrg6oqe9md
Tags: 0.146-1
[ Emmanuel Kasper ]
* New upstream release
* Drop patch to fix man pages section and patches to link with flac 
  and jpeg system lib: all this has been pushed upstream by Cesare Falco
* Add DM-Upload-Allowed: yes field.

[ Jordi Mallach ]
* Create a "gnu" TARGETOS stanza that defines NO_AFFINITY_NP.
* Stop setting TARGETOS to "unix" in d/rules. It should be autodetected,
  and set to the appropriate value.
* mame_manpage_section.patch: Change mame's manpage section to 6 (games),
  in the TH declaration.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/lib/lib7z/Lzma86Enc.c
 
1
/* Lzma86Enc.c -- LZMA + x86 (BCJ) Filter Encoder
 
2
2009-08-14 : Igor Pavlov : Public domain */
 
3
 
 
4
#include <string.h>
 
5
 
 
6
#include "Lzma86.h"
 
7
 
 
8
#include "Alloc.h"
 
9
#include "Bra.h"
 
10
#include "LzmaEnc.h"
 
11
 
 
12
#define SZE_OUT_OVERFLOW SZE_DATA_ERROR
 
13
 
 
14
static void *SzAlloc(void *p, size_t size) { p = p; return MyAlloc(size); }
 
15
static void SzFree(void *p, void *address) { p = p; MyFree(address); }
 
16
 
 
17
int Lzma86_Encode(Byte *dest, size_t *destLen, const Byte *src, size_t srcLen,
 
18
    int level, UInt32 dictSize, int filterMode)
 
19
{
 
20
  ISzAlloc g_Alloc = { SzAlloc, SzFree };
 
21
  size_t outSize2 = *destLen;
 
22
  Byte *filteredStream;
 
23
  Bool useFilter;
 
24
  int mainResult = SZ_ERROR_OUTPUT_EOF;
 
25
  CLzmaEncProps props;
 
26
  LzmaEncProps_Init(&props);
 
27
  props.level = level;
 
28
  props.dictSize = dictSize;
 
29
 
 
30
  *destLen = 0;
 
31
  if (outSize2 < LZMA86_HEADER_SIZE)
 
32
    return SZ_ERROR_OUTPUT_EOF;
 
33
 
 
34
  {
 
35
    int i;
 
36
    UInt64 t = srcLen;
 
37
    for (i = 0; i < 8; i++, t >>= 8)
 
38
      dest[LZMA86_SIZE_OFFSET + i] = (Byte)t;
 
39
  }
 
40
 
 
41
  filteredStream = 0;
 
42
  useFilter = (filterMode != SZ_FILTER_NO);
 
43
  if (useFilter)
 
44
  {
 
45
    if (srcLen != 0)
 
46
    {
 
47
      filteredStream = (Byte *)MyAlloc(srcLen);
 
48
      if (filteredStream == 0)
 
49
        return SZ_ERROR_MEM;
 
50
      memcpy(filteredStream, src, srcLen);
 
51
    }
 
52
    {
 
53
      UInt32 x86State;
 
54
      x86_Convert_Init(x86State);
 
55
      x86_Convert(filteredStream, srcLen, 0, &x86State, 1);
 
56
    }
 
57
  }
 
58
 
 
59
  {
 
60
    size_t minSize = 0;
 
61
    Bool bestIsFiltered = False;
 
62
 
 
63
    /* passes for SZ_FILTER_AUTO:
 
64
        0 - BCJ + LZMA
 
65
        1 - LZMA
 
66
        2 - BCJ + LZMA agaian, if pass 0 (BCJ + LZMA) is better.
 
67
    */
 
68
    int numPasses = (filterMode == SZ_FILTER_AUTO) ? 3 : 1;
 
69
 
 
70
    int i;
 
71
    for (i = 0; i < numPasses; i++)
 
72
    {
 
73
      size_t outSizeProcessed = outSize2 - LZMA86_HEADER_SIZE;
 
74
      size_t outPropsSize = 5;
 
75
      SRes curRes;
 
76
      Bool curModeIsFiltered = (numPasses > 1 && i == numPasses - 1);
 
77
      if (curModeIsFiltered && !bestIsFiltered)
 
78
        break;
 
79
      if (useFilter && i == 0)
 
80
        curModeIsFiltered = True;
 
81
 
 
82
      curRes = LzmaEncode(dest + LZMA86_HEADER_SIZE, &outSizeProcessed,
 
83
          curModeIsFiltered ? filteredStream : src, srcLen,
 
84
          &props, dest + 1, &outPropsSize, 0,
 
85
          NULL, &g_Alloc, &g_Alloc);
 
86
 
 
87
      if (curRes != SZ_ERROR_OUTPUT_EOF)
 
88
      {
 
89
        if (curRes != SZ_OK)
 
90
        {
 
91
          mainResult = curRes;
 
92
          break;
 
93
        }
 
94
        if (outSizeProcessed <= minSize || mainResult != SZ_OK)
 
95
        {
 
96
          minSize = outSizeProcessed;
 
97
          bestIsFiltered = curModeIsFiltered;
 
98
          mainResult = SZ_OK;
 
99
        }
 
100
      }
 
101
    }
 
102
    dest[0] = (bestIsFiltered ? 1 : 0);
 
103
    *destLen = LZMA86_HEADER_SIZE + minSize;
 
104
  }
 
105
  if (useFilter)
 
106
    MyFree(filteredStream);
 
107
  return mainResult;
 
108
}