← Back to branch summary

~vcs-imports/openbox4/trunk

« back to all changes in this revision

Viewing changes to firmware_1.x/tools/nb4-unsquash/brcm-lzma/BitTreeCoder.h

  • Committer: psolyca
  • Date: 2013-03-06 17:34:30 UTC
  • Revision ID: svn-v4:3124532d-43cb-4037-9335-164a1c69beb7:trunk:284
Reorganisation du depot

Show diffs side-by-side

added added

removed removed

Lines of Context:
firmware_1.x/tools/nb4-unsquash/brcm-lzma/BitTreeCoder.h
 
1
#ifndef __BITTREECODER_H
 
2
#define __BITTREECODER_H
 
3
 
 
4
#include "AriBitCoder.h"
 
5
#include "RCDefs.h"
 
6
 
 
7
//BRCM modification start
 
8
#ifdef _HOST_TOOL
 
9
#include "stdio.h"
 
10
#include "stdlib.h"
 
11
#include "malloc.h" 
 
12
#endif
 
13
 
 
14
#ifdef _CFE_
 
15
#include "lib_malloc.h"
 
16
#include "lib_printf.h"
 
17
#define malloc(x) KMALLOC(x, 0)
 
18
#endif
 
19
 
 
20
#ifdef __KERNEL__
 
21
#include <linux/kernel.h>
 
22
#include <linux/vmalloc.h>
 
23
#include <linux/slab.h>
 
24
#define printf printk
 
25
//#define malloc(x) kmalloc(x,GFP_KERNEL)
 
26
#define malloc(x) vmalloc(x)
 
27
#define free(x) vfree(x)
 
28
#endif
 
29
//BRCM modification end
 
30
 
 
31
//////////////////////////
 
32
// CBitTreeDecoder
 
33
 
 
34
typedef struct CBitTreeDecoder
 
35
{
 
36
  UINT32       m_NumBitLevels;
 
37
  CBitDecoder *m_Models;
 
38
} CBitTreeDecoder;
 
39
 
 
40
//  ~CBitTreeDecoder() { free(m_Models); }
 
41
INLINE void BitTreeDecoderInit(CBitTreeDecoder *bitTreeDecoder, UINT32 aNumBitLevels)
 
42
  {
 
43
    int i;
 
44
    bitTreeDecoder->m_NumBitLevels = aNumBitLevels;
 
45
    bitTreeDecoder->m_Models       = (CBitDecoder *)malloc( sizeof(CBitDecoder) * (1 << bitTreeDecoder->m_NumBitLevels));
 
46
    //BRCM modification
 
47
    //printf("malloc in BitTreeDecoderInit=%d\n",sizeof(CBitDecoder) * (1 << bitTreeDecoder->m_NumBitLevels));
 
48
    if (!bitTreeDecoder->m_Models) {
 
49
            printf("Error in allocating memory for bitTreeDecoder!\n");
 
50
            return;
 
51
    }       
 
52
    for(i = 1; i < (1 << aNumBitLevels); i++)
 
53
      BitDecoderInit(&bitTreeDecoder->m_Models[i]);
 
54
  }
 
55
INLINE UINT32 BitTreeDecode(ISequentialInStream *in_stream, CBitTreeDecoder *bitTreeDecoder, CRangeDecoder *aRangeDecoder)
 
56
  {
 
57
    UINT32 aModelIndex = 1;
 
58
    UINT32 aRange = aRangeDecoder->m_Range;
 
59
    UINT32 aCode = aRangeDecoder->m_Code;
 
60
    UINT32 aBitIndex;
 
61
    for(aBitIndex = bitTreeDecoder->m_NumBitLevels; aBitIndex > 0; aBitIndex--)
 
62
    {
 
63
      RC_GETBIT(kNumMoveBits, bitTreeDecoder->m_Models[aModelIndex], aModelIndex)
 
64
    }
 
65
    aRangeDecoder->m_Range = aRange;
 
66
    aRangeDecoder->m_Code = aCode;
 
67
    return aModelIndex - (1 << bitTreeDecoder->m_NumBitLevels);
 
68
  }
 
69
 
 
70
 
 
71
////////////////////////////////
 
72
// CReverseBitTreeDecoder2
 
73
 
 
74
typedef struct CReverseBitTreeDecoder2
 
75
{
 
76
  UINT32       m_NumBitLevels;
 
77
  CBitDecoder *m_Models;
 
78
} CReverseBitTreeDecoder2;
 
79
 
 
80
//  CReverseBitTreeDecoder2(): m_Models(0) { }
 
81
//  ~CReverseBitTreeDecoder2() { free(m_Models); }
 
82
INLINE BOOL ReverseBitTreeDecoder2Create(CReverseBitTreeDecoder2 *reverseBitTreeDecoder2, UINT32 aNumBitLevels)
 
83
  {
 
84
    reverseBitTreeDecoder2->m_NumBitLevels = aNumBitLevels;
 
85
    reverseBitTreeDecoder2->m_Models       = (CBitDecoder *)malloc( sizeof(CBitDecoder) * (1 << reverseBitTreeDecoder2->m_NumBitLevels));
 
86
    //printf("malloc in ReverseBitTreeDecoder2Create=%d\n",sizeof(CBitDecoder) * (1 << reverseBitTreeDecoder2->m_NumBitLevels));
 
87
    if (!reverseBitTreeDecoder2->m_Models) {
 
88
            printf("Error in allocating memory for reverseBitTreeDecoder2!\n");
 
89
            return 0;
 
90
    }       
 
91
    return (reverseBitTreeDecoder2->m_Models != 0);
 
92
  }
 
93
INLINE void ReverseBitTreeDecoder2Init(CReverseBitTreeDecoder2 *reverseBitTreeDecoder2)
 
94
  {
 
95
    UINT32 aNumModels = 1 << reverseBitTreeDecoder2->m_NumBitLevels;
 
96
    UINT32 i;
 
97
    for(i = 1; i < aNumModels; i++)
 
98
      BitDecoderInit(&reverseBitTreeDecoder2->m_Models[i]);
 
99
  }
 
100
INLINE UINT32 ReverseBitTreeDecoder2Decode(ISequentialInStream *in_stream, CReverseBitTreeDecoder2 *reverseBitTreeDecoder2, CRangeDecoder *aRangeDecoder)
 
101
  {
 
102
    UINT32 aModelIndex = 1;
 
103
    UINT32 aSymbol = 0;
 
104
    UINT32 aRange = aRangeDecoder->m_Range;
 
105
    UINT32 aCode = aRangeDecoder->m_Code;
 
106
    UINT32 aBitIndex;
 
107
    for(aBitIndex = 0; aBitIndex < reverseBitTreeDecoder2->m_NumBitLevels; aBitIndex++)
 
108
    {
 
109
      RC_GETBIT2(kNumMoveBits, reverseBitTreeDecoder2->m_Models[aModelIndex], aModelIndex, ; , aSymbol |= (1 << aBitIndex))
 
110
    }
 
111
    aRangeDecoder->m_Range = aRange;
 
112
    aRangeDecoder->m_Code = aCode;
 
113
    return aSymbol;
 
114
  }
 
115
 
 
116
 
 
117
////////////////////////////
 
118
// CReverseBitTreeDecoder
 
119
 
 
120
typedef struct CReverseBitTreeDecoder
 
121
{
 
122
  UINT32        m_NumBitLevels;
 
123
  CBitDecoder  *m_Models;
 
124
} CReverseBitTreeDecoder;
 
125
 
 
126
//    CReverseBitTreeDecoder(): m_Models(0) { }
 
127
//    ~CReverseBitTreeDecoder() { free(m_Models); }
 
128
INLINE void ReverseBitTreeDecoderInit(CReverseBitTreeDecoder *reverseBitTreeDecoder, UINT32 aNumBitLevels)
 
129
  {
 
130
    int i;
 
131
    reverseBitTreeDecoder->m_NumBitLevels = aNumBitLevels;
 
132
    reverseBitTreeDecoder->m_Models       = (CBitDecoder *)malloc( sizeof(CBitDecoder) * (1 << reverseBitTreeDecoder->m_NumBitLevels));
 
133
    //printf("malloc in ReverseBitTreeDecoderInit=%d\n",sizeof(CBitDecoder) * (1 << reverseBitTreeDecoder->m_NumBitLevels));
 
134
    if (!reverseBitTreeDecoder->m_Models) {
 
135
            printf("Error in allocating memory for reverseBitTreeDecoder!\n");
 
136
            return;
 
137
    }       
 
138
    for(i = 1; i < (1 << reverseBitTreeDecoder->m_NumBitLevels); i++)
 
139
      BitDecoderInit(&reverseBitTreeDecoder->m_Models[i]);
 
140
  }
 
141
 
 
142
INLINE UINT32 ReverseBitTreeDecoderDecode(ISequentialInStream *in_stream, CReverseBitTreeDecoder *reverseBitTreeDecoder, CRangeDecoder *aRangeDecoder)
 
143
  {
 
144
    UINT32 aModelIndex = 1;
 
145
    UINT32 aSymbol = 0;
 
146
    UINT32 aRange = aRangeDecoder->m_Range;
 
147
    UINT32 aCode = aRangeDecoder->m_Code;
 
148
    UINT32 aBitIndex;
 
149
    for(aBitIndex = 0; aBitIndex < reverseBitTreeDecoder->m_NumBitLevels; aBitIndex++)
 
150
    {
 
151
      RC_GETBIT2(kNumMoveBits, reverseBitTreeDecoder->m_Models[aModelIndex], aModelIndex, ; , aSymbol |= (1 << aBitIndex))
 
152
    }
 
153
    aRangeDecoder->m_Range = aRange;
 
154
    aRangeDecoder->m_Code = aCode;
 
155
    return aSymbol;
 
156
  }
 
157
 
 
158
 
 
159
 
 
160
#endif