annotate cabac.h @ 5830:1d83e9c34641 libavcodec

Add FFMPEG_ prefix to all multiple inclusion guards.
author diego
date Wed, 17 Oct 2007 09:37:46 +0000
parents bc467895b8c9
children 94f4e36639ae
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
1287
michaelni
parents:
diff changeset
1 /*
michaelni
parents:
diff changeset
2 * H.26L/H.264/AVC/JVT/14496-10/... encoder/decoder
michaelni
parents:
diff changeset
3 * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
michaelni
parents:
diff changeset
4 *
3947
c8c591fe26f8 Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents: 3946
diff changeset
5 * This file is part of FFmpeg.
c8c591fe26f8 Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents: 3946
diff changeset
6 *
c8c591fe26f8 Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents: 3946
diff changeset
7 * FFmpeg is free software; you can redistribute it and/or
1287
michaelni
parents:
diff changeset
8 * modify it under the terms of the GNU Lesser General Public
michaelni
parents:
diff changeset
9 * License as published by the Free Software Foundation; either
3947
c8c591fe26f8 Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents: 3946
diff changeset
10 * version 2.1 of the License, or (at your option) any later version.
1287
michaelni
parents:
diff changeset
11 *
3947
c8c591fe26f8 Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents: 3946
diff changeset
12 * FFmpeg is distributed in the hope that it will be useful,
1287
michaelni
parents:
diff changeset
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
michaelni
parents:
diff changeset
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
michaelni
parents:
diff changeset
15 * Lesser General Public License for more details.
michaelni
parents:
diff changeset
16 *
michaelni
parents:
diff changeset
17 * You should have received a copy of the GNU Lesser General Public
3947
c8c591fe26f8 Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents: 3946
diff changeset
18 * License along with FFmpeg; if not, write to the Free Software
3036
0b546eab515d Update licensing information: The FSF changed postal address.
diego
parents: 2967
diff changeset
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
1287
michaelni
parents:
diff changeset
20 */
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2736
diff changeset
21
1287
michaelni
parents:
diff changeset
22 /**
michaelni
parents:
diff changeset
23 * @file cabac.h
michaelni
parents:
diff changeset
24 * Context Adaptive Binary Arithmetic Coder.
michaelni
parents:
diff changeset
25 */
michaelni
parents:
diff changeset
26
5830
1d83e9c34641 Add FFMPEG_ prefix to all multiple inclusion guards.
diego
parents: 5813
diff changeset
27 #ifndef FFMPEG_CABAC_H
1d83e9c34641 Add FFMPEG_ prefix to all multiple inclusion guards.
diego
parents: 5813
diff changeset
28 #define FFMPEG_CABAC_H
4975
9a6a0818e93f split h264.c to move parser in its own file
aurel
parents: 4908
diff changeset
29
9a6a0818e93f split h264.c to move parser in its own file
aurel
parents: 4908
diff changeset
30 #include "bitstream.h"
1287
michaelni
parents:
diff changeset
31
3284
a224d9752912 don't force asserts in release builds. 2% faster h264.
lorenm
parents: 3036
diff changeset
32 //#undef NDEBUG
1287
michaelni
parents:
diff changeset
33 #include <assert.h>
4064
d3afe4505951 CABAC assembler optimizations ported to AMD64
reimar
parents: 4051
diff changeset
34 #ifdef ARCH_X86
d3afe4505951 CABAC assembler optimizations ported to AMD64
reimar
parents: 4051
diff changeset
35 #include "x86_cpu.h"
d3afe4505951 CABAC assembler optimizations ported to AMD64
reimar
parents: 4051
diff changeset
36 #endif
1287
michaelni
parents:
diff changeset
37
3948
3edbf131ee44 refill cabac variables in 16bit steps, 3% faster get_cabac()
michael
parents: 3947
diff changeset
38 #define CABAC_BITS 16
2323
1c39d9786efd optimization
michael
parents: 2116
diff changeset
39 #define CABAC_MASK ((1<<CABAC_BITS)-1)
3984
bb186452e7da BRANCHLESS_CABAD --> BRANCHLESS_CABAC_DECODER
diego
parents: 3982
diff changeset
40 #define BRANCHLESS_CABAC_DECODER 1
4039
866a83726985 Kill a warning with MSVC
gpoirier
parents: 4037
diff changeset
41 //#define ARCH_X86_DISABLED 1
2323
1c39d9786efd optimization
michael
parents: 2116
diff changeset
42
1287
michaelni
parents:
diff changeset
43 typedef struct CABACContext{
michaelni
parents:
diff changeset
44 int low;
michaelni
parents:
diff changeset
45 int range;
michaelni
parents:
diff changeset
46 int outstanding_count;
michaelni
parents:
diff changeset
47 #ifdef STRICT_LIMITS
michaelni
parents:
diff changeset
48 int symCount;
michaelni
parents:
diff changeset
49 #endif
2024
f65d87bfdd5a some of the warning fixes by (Michael Roitzsch <mroi at users dot sourceforge dot net>)
michael
parents: 1787
diff changeset
50 const uint8_t *bytestream_start;
f65d87bfdd5a some of the warning fixes by (Michael Roitzsch <mroi at users dot sourceforge dot net>)
michael
parents: 1787
diff changeset
51 const uint8_t *bytestream;
2116
48d9f86fb047 overread fix
michael
parents: 2024
diff changeset
52 const uint8_t *bytestream_end;
1287
michaelni
parents:
diff changeset
53 PutBitContext pb;
michaelni
parents:
diff changeset
54 }CABACContext;
michaelni
parents:
diff changeset
55
4014
b2582438effe dehack *ps_state indexing in the branchless decoder
michael
parents: 4012
diff changeset
56 extern uint8_t ff_h264_mlps_state[4*64];
4039
866a83726985 Kill a warning with MSVC
gpoirier
parents: 4037
diff changeset
57 extern uint8_t ff_h264_lps_range[4*2*64]; ///< rangeTabLPS
3993
8b7c59b7af01 make state transition tables global as they are constant and the code is slightly faster that way
michael
parents: 3992
diff changeset
58 extern uint8_t ff_h264_mps_state[2*64]; ///< transIdxMPS
8b7c59b7af01 make state transition tables global as they are constant and the code is slightly faster that way
michael
parents: 3992
diff changeset
59 extern uint8_t ff_h264_lps_state[2*64]; ///< transIdxLPS
4024
d550343b5dac shift CABACContext.range right, this reduces the number of shifts needed in get_cabac() and is slightly faster on P3 (and should be much faster on P4 as the P4 except the more recent variants lacks an integer shifter and so shifts have ~10 times longer latency then simple operations like adds)
michael
parents: 4014
diff changeset
60 extern const uint8_t ff_h264_norm_shift[512];
2323
1c39d9786efd optimization
michael
parents: 2116
diff changeset
61
1287
michaelni
parents:
diff changeset
62
michaelni
parents:
diff changeset
63 void ff_init_cabac_encoder(CABACContext *c, uint8_t *buf, int buf_size);
2024
f65d87bfdd5a some of the warning fixes by (Michael Roitzsch <mroi at users dot sourceforge dot net>)
michael
parents: 1787
diff changeset
64 void ff_init_cabac_decoder(CABACContext *c, const uint8_t *buf, int buf_size);
3993
8b7c59b7af01 make state transition tables global as they are constant and the code is slightly faster that way
michael
parents: 3992
diff changeset
65 void ff_init_cabac_states(CABACContext *c);
1287
michaelni
parents:
diff changeset
66
michaelni
parents:
diff changeset
67
michaelni
parents:
diff changeset
68 static inline void put_cabac_bit(CABACContext *c, int b){
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2736
diff changeset
69 put_bits(&c->pb, 1, b);
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2736
diff changeset
70 for(;c->outstanding_count; c->outstanding_count--){
1287
michaelni
parents:
diff changeset
71 put_bits(&c->pb, 1, 1-b);
michaelni
parents:
diff changeset
72 }
michaelni
parents:
diff changeset
73 }
michaelni
parents:
diff changeset
74
michaelni
parents:
diff changeset
75 static inline void renorm_cabac_encoder(CABACContext *c){
michaelni
parents:
diff changeset
76 while(c->range < 0x100){
michaelni
parents:
diff changeset
77 //FIXME optimize
michaelni
parents:
diff changeset
78 if(c->low<0x100){
michaelni
parents:
diff changeset
79 put_cabac_bit(c, 0);
michaelni
parents:
diff changeset
80 }else if(c->low<0x200){
michaelni
parents:
diff changeset
81 c->outstanding_count++;
michaelni
parents:
diff changeset
82 c->low -= 0x100;
michaelni
parents:
diff changeset
83 }else{
michaelni
parents:
diff changeset
84 put_cabac_bit(c, 1);
michaelni
parents:
diff changeset
85 c->low -= 0x200;
michaelni
parents:
diff changeset
86 }
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2736
diff changeset
87
1287
michaelni
parents:
diff changeset
88 c->range+= c->range;
michaelni
parents:
diff changeset
89 c->low += c->low;
michaelni
parents:
diff changeset
90 }
michaelni
parents:
diff changeset
91 }
michaelni
parents:
diff changeset
92
5811
2926fc2a0396 Disable unused code; fixes several gcc warnings:
diego
parents: 5754
diff changeset
93 #if 0
3928
987fffdf6ae7 don't try to inline cabac functions. gcc ignored the hint anyway, and forcing it would make h264 slower.
lorenm
parents: 3642
diff changeset
94 static void put_cabac(CABACContext *c, uint8_t * const state, int bit){
4024
d550343b5dac shift CABACContext.range right, this reduces the number of shifts needed in get_cabac() and is slightly faster on P3 (and should be much faster on P4 as the P4 except the more recent variants lacks an integer shifter and so shifts have ~10 times longer latency then simple operations like adds)
michael
parents: 4014
diff changeset
95 int RangeLPS= ff_h264_lps_range[2*(c->range&0xC0) + *state];
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2736
diff changeset
96
1287
michaelni
parents:
diff changeset
97 if(bit == ((*state)&1)){
michaelni
parents:
diff changeset
98 c->range -= RangeLPS;
3993
8b7c59b7af01 make state transition tables global as they are constant and the code is slightly faster that way
michael
parents: 3992
diff changeset
99 *state= ff_h264_mps_state[*state];
1287
michaelni
parents:
diff changeset
100 }else{
michaelni
parents:
diff changeset
101 c->low += c->range - RangeLPS;
michaelni
parents:
diff changeset
102 c->range = RangeLPS;
3993
8b7c59b7af01 make state transition tables global as they are constant and the code is slightly faster that way
michael
parents: 3992
diff changeset
103 *state= ff_h264_lps_state[*state];
1287
michaelni
parents:
diff changeset
104 }
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2736
diff changeset
105
1287
michaelni
parents:
diff changeset
106 renorm_cabac_encoder(c);
michaelni
parents:
diff changeset
107
michaelni
parents:
diff changeset
108 #ifdef STRICT_LIMITS
michaelni
parents:
diff changeset
109 c->symCount++;
michaelni
parents:
diff changeset
110 #endif
michaelni
parents:
diff changeset
111 }
michaelni
parents:
diff changeset
112
3928
987fffdf6ae7 don't try to inline cabac functions. gcc ignored the hint anyway, and forcing it would make h264 slower.
lorenm
parents: 3642
diff changeset
113 static void put_cabac_static(CABACContext *c, int RangeLPS, int bit){
1287
michaelni
parents:
diff changeset
114 assert(c->range > RangeLPS);
michaelni
parents:
diff changeset
115
michaelni
parents:
diff changeset
116 if(!bit){
michaelni
parents:
diff changeset
117 c->range -= RangeLPS;
michaelni
parents:
diff changeset
118 }else{
michaelni
parents:
diff changeset
119 c->low += c->range - RangeLPS;
michaelni
parents:
diff changeset
120 c->range = RangeLPS;
michaelni
parents:
diff changeset
121 }
michaelni
parents:
diff changeset
122
michaelni
parents:
diff changeset
123 renorm_cabac_encoder(c);
michaelni
parents:
diff changeset
124
michaelni
parents:
diff changeset
125 #ifdef STRICT_LIMITS
michaelni
parents:
diff changeset
126 c->symCount++;
michaelni
parents:
diff changeset
127 #endif
michaelni
parents:
diff changeset
128 }
michaelni
parents:
diff changeset
129
1290
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
130 /**
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
131 * @param bit 0 -> write zero bit, !=0 write one bit
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
132 */
3928
987fffdf6ae7 don't try to inline cabac functions. gcc ignored the hint anyway, and forcing it would make h264 slower.
lorenm
parents: 3642
diff changeset
133 static void put_cabac_bypass(CABACContext *c, int bit){
1287
michaelni
parents:
diff changeset
134 c->low += c->low;
michaelni
parents:
diff changeset
135
michaelni
parents:
diff changeset
136 if(bit){
michaelni
parents:
diff changeset
137 c->low += c->range;
michaelni
parents:
diff changeset
138 }
michaelni
parents:
diff changeset
139 //FIXME optimize
michaelni
parents:
diff changeset
140 if(c->low<0x200){
michaelni
parents:
diff changeset
141 put_cabac_bit(c, 0);
michaelni
parents:
diff changeset
142 }else if(c->low<0x400){
michaelni
parents:
diff changeset
143 c->outstanding_count++;
michaelni
parents:
diff changeset
144 c->low -= 0x200;
michaelni
parents:
diff changeset
145 }else{
michaelni
parents:
diff changeset
146 put_cabac_bit(c, 1);
michaelni
parents:
diff changeset
147 c->low -= 0x400;
michaelni
parents:
diff changeset
148 }
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2736
diff changeset
149
1287
michaelni
parents:
diff changeset
150 #ifdef STRICT_LIMITS
michaelni
parents:
diff changeset
151 c->symCount++;
michaelni
parents:
diff changeset
152 #endif
michaelni
parents:
diff changeset
153 }
michaelni
parents:
diff changeset
154
1300
e18667d1e94d FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv)
michaelni
parents: 1298
diff changeset
155 /**
e18667d1e94d FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv)
michaelni
parents: 1298
diff changeset
156 *
e18667d1e94d FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv)
michaelni
parents: 1298
diff changeset
157 * @return the number of bytes written
e18667d1e94d FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv)
michaelni
parents: 1298
diff changeset
158 */
3928
987fffdf6ae7 don't try to inline cabac functions. gcc ignored the hint anyway, and forcing it would make h264 slower.
lorenm
parents: 3642
diff changeset
159 static int put_cabac_terminate(CABACContext *c, int bit){
1287
michaelni
parents:
diff changeset
160 c->range -= 2;
michaelni
parents:
diff changeset
161
michaelni
parents:
diff changeset
162 if(!bit){
michaelni
parents:
diff changeset
163 renorm_cabac_encoder(c);
michaelni
parents:
diff changeset
164 }else{
michaelni
parents:
diff changeset
165 c->low += c->range;
michaelni
parents:
diff changeset
166 c->range= 2;
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2736
diff changeset
167
1287
michaelni
parents:
diff changeset
168 renorm_cabac_encoder(c);
michaelni
parents:
diff changeset
169
michaelni
parents:
diff changeset
170 assert(c->low <= 0x1FF);
michaelni
parents:
diff changeset
171 put_cabac_bit(c, c->low>>9);
michaelni
parents:
diff changeset
172 put_bits(&c->pb, 2, ((c->low>>7)&3)|1);
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2736
diff changeset
173
1287
michaelni
parents:
diff changeset
174 flush_put_bits(&c->pb); //FIXME FIXME FIXME XXX wrong
michaelni
parents:
diff changeset
175 }
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2736
diff changeset
176
1287
michaelni
parents:
diff changeset
177 #ifdef STRICT_LIMITS
michaelni
parents:
diff changeset
178 c->symCount++;
michaelni
parents:
diff changeset
179 #endif
1300
e18667d1e94d FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv)
michaelni
parents: 1298
diff changeset
180
1787
752b51a3c8ed get_bit_count -> put_bits_count
alex
parents: 1301
diff changeset
181 return (put_bits_count(&c->pb)+7)>>3;
1287
michaelni
parents:
diff changeset
182 }
michaelni
parents:
diff changeset
183
1290
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
184 /**
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
185 * put (truncated) unary binarization.
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
186 */
3928
987fffdf6ae7 don't try to inline cabac functions. gcc ignored the hint anyway, and forcing it would make h264 slower.
lorenm
parents: 3642
diff changeset
187 static void put_cabac_u(CABACContext *c, uint8_t * state, int v, int max, int max_index, int truncated){
1290
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
188 int i;
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2736
diff changeset
189
1290
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
190 assert(v <= max);
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2736
diff changeset
191
1290
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
192 #if 1
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
193 for(i=0; i<v; i++){
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
194 put_cabac(c, state, 1);
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
195 if(i < max_index) state++;
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
196 }
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
197 if(truncated==0 || v<max)
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
198 put_cabac(c, state, 0);
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
199 #else
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
200 if(v <= max_index){
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
201 for(i=0; i<v; i++){
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
202 put_cabac(c, state+i, 1);
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
203 }
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
204 if(truncated==0 || v<max)
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
205 put_cabac(c, state+i, 0);
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
206 }else{
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
207 for(i=0; i<=max_index; i++){
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
208 put_cabac(c, state+i, 1);
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
209 }
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
210 for(; i<v; i++){
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
211 put_cabac(c, state+max_index, 1);
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
212 }
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
213 if(truncated==0 || v<max)
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
214 put_cabac(c, state+max_index, 0);
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
215 }
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
216 #endif
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
217 }
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
218
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
219 /**
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
220 * put unary exp golomb k-th order binarization.
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
221 */
3928
987fffdf6ae7 don't try to inline cabac functions. gcc ignored the hint anyway, and forcing it would make h264 slower.
lorenm
parents: 3642
diff changeset
222 static void put_cabac_ueg(CABACContext *c, uint8_t * state, int v, int max, int is_signed, int k, int max_index){
1290
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
223 int i;
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2736
diff changeset
224
1290
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
225 if(v==0)
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
226 put_cabac(c, state, 0);
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
227 else{
1298
5bc3184810dc cleanup
michaelni
parents: 1290
diff changeset
228 const int sign= v < 0;
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2736
diff changeset
229
4001
34fdffe98bd0 Rename ABS macro to FFABS.
diego
parents: 3999
diff changeset
230 if(is_signed) v= FFABS(v);
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2736
diff changeset
231
1290
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
232 if(v<max){
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
233 for(i=0; i<v; i++){
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
234 put_cabac(c, state, 1);
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
235 if(i < max_index) state++;
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
236 }
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
237
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
238 put_cabac(c, state, 0);
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
239 }else{
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
240 int m= 1<<k;
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
241
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
242 for(i=0; i<max; i++){
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
243 put_cabac(c, state, 1);
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
244 if(i < max_index) state++;
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
245 }
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
246
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
247 v -= max;
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
248 while(v >= m){ //FIXME optimize
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
249 put_cabac_bypass(c, 1);
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
250 v-= m;
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
251 m+= m;
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
252 }
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
253 put_cabac_bypass(c, 0);
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
254 while(m>>=1){
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
255 put_cabac_bypass(c, v&m);
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
256 }
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
257 }
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
258
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
259 if(is_signed)
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
260 put_cabac_bypass(c, sign);
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
261 }
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
262 }
5811
2926fc2a0396 Disable unused code; fixes several gcc warnings:
diego
parents: 5754
diff changeset
263 #endif /* 0 */
1290
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
264
2323
1c39d9786efd optimization
michael
parents: 2116
diff changeset
265 static void refill(CABACContext *c){
1c39d9786efd optimization
michael
parents: 2116
diff changeset
266 #if CABAC_BITS == 16
3946
michael
parents: 3943
diff changeset
267 c->low+= (c->bytestream[0]<<9) + (c->bytestream[1]<<1);
2323
1c39d9786efd optimization
michael
parents: 2116
diff changeset
268 #else
1c39d9786efd optimization
michael
parents: 2116
diff changeset
269 c->low+= c->bytestream[0]<<1;
1c39d9786efd optimization
michael
parents: 2116
diff changeset
270 #endif
1c39d9786efd optimization
michael
parents: 2116
diff changeset
271 c->low -= CABAC_MASK;
1c39d9786efd optimization
michael
parents: 2116
diff changeset
272 c->bytestream+= CABAC_BITS/8;
1c39d9786efd optimization
michael
parents: 2116
diff changeset
273 }
1c39d9786efd optimization
michael
parents: 2116
diff changeset
274
5813
bc467895b8c9 10l: refill2() is not unused, it is used conditionally.
diego
parents: 5811
diff changeset
275 #if ! ( defined(ARCH_X86) && defined(HAVE_7REGS) && defined(HAVE_EBX_AVAILABLE) && !defined(BROKEN_RELOCATIONS) )
2323
1c39d9786efd optimization
michael
parents: 2116
diff changeset
276 static void refill2(CABACContext *c){
1c39d9786efd optimization
michael
parents: 2116
diff changeset
277 int i, x;
1c39d9786efd optimization
michael
parents: 2116
diff changeset
278
1c39d9786efd optimization
michael
parents: 2116
diff changeset
279 x= c->low ^ (c->low-1);
4024
d550343b5dac shift CABACContext.range right, this reduces the number of shifts needed in get_cabac() and is slightly faster on P3 (and should be much faster on P4 as the P4 except the more recent variants lacks an integer shifter and so shifts have ~10 times longer latency then simple operations like adds)
michael
parents: 4014
diff changeset
280 i= 7 - ff_h264_norm_shift[x>>(CABAC_BITS-1)];
2323
1c39d9786efd optimization
michael
parents: 2116
diff changeset
281
1c39d9786efd optimization
michael
parents: 2116
diff changeset
282 x= -CABAC_MASK;
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2736
diff changeset
283
2323
1c39d9786efd optimization
michael
parents: 2116
diff changeset
284 #if CABAC_BITS == 16
1c39d9786efd optimization
michael
parents: 2116
diff changeset
285 x+= (c->bytestream[0]<<9) + (c->bytestream[1]<<1);
1c39d9786efd optimization
michael
parents: 2116
diff changeset
286 #else
1c39d9786efd optimization
michael
parents: 2116
diff changeset
287 x+= c->bytestream[0]<<1;
1c39d9786efd optimization
michael
parents: 2116
diff changeset
288 #endif
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2736
diff changeset
289
2323
1c39d9786efd optimization
michael
parents: 2116
diff changeset
290 c->low += x<<i;
1c39d9786efd optimization
michael
parents: 2116
diff changeset
291 c->bytestream+= CABAC_BITS/8;
1c39d9786efd optimization
michael
parents: 2116
diff changeset
292 }
5811
2926fc2a0396 Disable unused code; fixes several gcc warnings:
diego
parents: 5754
diff changeset
293 #endif
2323
1c39d9786efd optimization
michael
parents: 2116
diff changeset
294
1287
michaelni
parents:
diff changeset
295 static inline void renorm_cabac_decoder(CABACContext *c){
4024
d550343b5dac shift CABACContext.range right, this reduces the number of shifts needed in get_cabac() and is slightly faster on P3 (and should be much faster on P4 as the P4 except the more recent variants lacks an integer shifter and so shifts have ~10 times longer latency then simple operations like adds)
michael
parents: 4014
diff changeset
296 while(c->range < 0x100){
1287
michaelni
parents:
diff changeset
297 c->range+= c->range;
michaelni
parents:
diff changeset
298 c->low+= c->low;
2323
1c39d9786efd optimization
michael
parents: 2116
diff changeset
299 if(!(c->low & CABAC_MASK))
1c39d9786efd optimization
michael
parents: 2116
diff changeset
300 refill(c);
1287
michaelni
parents:
diff changeset
301 }
michaelni
parents:
diff changeset
302 }
michaelni
parents:
diff changeset
303
2323
1c39d9786efd optimization
michael
parents: 2116
diff changeset
304 static inline void renorm_cabac_decoder_once(CABACContext *c){
3951
751bfc30df72 disable benchmarking code
michael
parents: 3950
diff changeset
305 #ifdef ARCH_X86_DISABLED
3943
811a9b0d9f32 several x86 renorm_cabac_decoder_once optimizations
michael
parents: 3928
diff changeset
306 int temp;
811a9b0d9f32 several x86 renorm_cabac_decoder_once optimizations
michael
parents: 3928
diff changeset
307 #if 0
3950
900d21b85dd6 renorm_cabac_decoder_once START/STOP_TIMER scores for athlon
michael
parents: 3948
diff changeset
308 //P3:683 athlon:475
3943
811a9b0d9f32 several x86 renorm_cabac_decoder_once optimizations
michael
parents: 3928
diff changeset
309 asm(
4024
d550343b5dac shift CABACContext.range right, this reduces the number of shifts needed in get_cabac() and is slightly faster on P3 (and should be much faster on P4 as the P4 except the more recent variants lacks an integer shifter and so shifts have ~10 times longer latency then simple operations like adds)
michael
parents: 4014
diff changeset
310 "lea -0x100(%0), %2 \n\t"
3943
811a9b0d9f32 several x86 renorm_cabac_decoder_once optimizations
michael
parents: 3928
diff changeset
311 "shr $31, %2 \n\t" //FIXME 31->63 for x86-64
811a9b0d9f32 several x86 renorm_cabac_decoder_once optimizations
michael
parents: 3928
diff changeset
312 "shl %%cl, %0 \n\t"
811a9b0d9f32 several x86 renorm_cabac_decoder_once optimizations
michael
parents: 3928
diff changeset
313 "shl %%cl, %1 \n\t"
811a9b0d9f32 several x86 renorm_cabac_decoder_once optimizations
michael
parents: 3928
diff changeset
314 : "+r"(c->range), "+r"(c->low), "+c"(temp)
811a9b0d9f32 several x86 renorm_cabac_decoder_once optimizations
michael
parents: 3928
diff changeset
315 );
811a9b0d9f32 several x86 renorm_cabac_decoder_once optimizations
michael
parents: 3928
diff changeset
316 #elif 0
3950
900d21b85dd6 renorm_cabac_decoder_once START/STOP_TIMER scores for athlon
michael
parents: 3948
diff changeset
317 //P3:680 athlon:474
3943
811a9b0d9f32 several x86 renorm_cabac_decoder_once optimizations
michael
parents: 3928
diff changeset
318 asm(
4024
d550343b5dac shift CABACContext.range right, this reduces the number of shifts needed in get_cabac() and is slightly faster on P3 (and should be much faster on P4 as the P4 except the more recent variants lacks an integer shifter and so shifts have ~10 times longer latency then simple operations like adds)
michael
parents: 4014
diff changeset
319 "cmp $0x100, %0 \n\t"
3943
811a9b0d9f32 several x86 renorm_cabac_decoder_once optimizations
michael
parents: 3928
diff changeset
320 "setb %%cl \n\t" //FIXME 31->63 for x86-64
811a9b0d9f32 several x86 renorm_cabac_decoder_once optimizations
michael
parents: 3928
diff changeset
321 "shl %%cl, %0 \n\t"
811a9b0d9f32 several x86 renorm_cabac_decoder_once optimizations
michael
parents: 3928
diff changeset
322 "shl %%cl, %1 \n\t"
811a9b0d9f32 several x86 renorm_cabac_decoder_once optimizations
michael
parents: 3928
diff changeset
323 : "+r"(c->range), "+r"(c->low), "+c"(temp)
811a9b0d9f32 several x86 renorm_cabac_decoder_once optimizations
michael
parents: 3928
diff changeset
324 );
811a9b0d9f32 several x86 renorm_cabac_decoder_once optimizations
michael
parents: 3928
diff changeset
325 #elif 1
811a9b0d9f32 several x86 renorm_cabac_decoder_once optimizations
michael
parents: 3928
diff changeset
326 int temp2;
3950
900d21b85dd6 renorm_cabac_decoder_once START/STOP_TIMER scores for athlon
michael
parents: 3948
diff changeset
327 //P3:665 athlon:517
3943
811a9b0d9f32 several x86 renorm_cabac_decoder_once optimizations
michael
parents: 3928
diff changeset
328 asm(
4024
d550343b5dac shift CABACContext.range right, this reduces the number of shifts needed in get_cabac() and is slightly faster on P3 (and should be much faster on P4 as the P4 except the more recent variants lacks an integer shifter and so shifts have ~10 times longer latency then simple operations like adds)
michael
parents: 4014
diff changeset
329 "lea -0x100(%0), %%eax \n\t"
3943
811a9b0d9f32 several x86 renorm_cabac_decoder_once optimizations
michael
parents: 3928
diff changeset
330 "cdq \n\t"
811a9b0d9f32 several x86 renorm_cabac_decoder_once optimizations
michael
parents: 3928
diff changeset
331 "mov %0, %%eax \n\t"
811a9b0d9f32 several x86 renorm_cabac_decoder_once optimizations
michael
parents: 3928
diff changeset
332 "and %%edx, %0 \n\t"
811a9b0d9f32 several x86 renorm_cabac_decoder_once optimizations
michael
parents: 3928
diff changeset
333 "and %1, %%edx \n\t"
811a9b0d9f32 several x86 renorm_cabac_decoder_once optimizations
michael
parents: 3928
diff changeset
334 "add %%eax, %0 \n\t"
811a9b0d9f32 several x86 renorm_cabac_decoder_once optimizations
michael
parents: 3928
diff changeset
335 "add %%edx, %1 \n\t"
811a9b0d9f32 several x86 renorm_cabac_decoder_once optimizations
michael
parents: 3928
diff changeset
336 : "+r"(c->range), "+r"(c->low), "+a"(temp), "+d"(temp2)
811a9b0d9f32 several x86 renorm_cabac_decoder_once optimizations
michael
parents: 3928
diff changeset
337 );
811a9b0d9f32 several x86 renorm_cabac_decoder_once optimizations
michael
parents: 3928
diff changeset
338 #elif 0
811a9b0d9f32 several x86 renorm_cabac_decoder_once optimizations
michael
parents: 3928
diff changeset
339 int temp2;
3950
900d21b85dd6 renorm_cabac_decoder_once START/STOP_TIMER scores for athlon
michael
parents: 3948
diff changeset
340 //P3:673 athlon:509
3943
811a9b0d9f32 several x86 renorm_cabac_decoder_once optimizations
michael
parents: 3928
diff changeset
341 asm(
4024
d550343b5dac shift CABACContext.range right, this reduces the number of shifts needed in get_cabac() and is slightly faster on P3 (and should be much faster on P4 as the P4 except the more recent variants lacks an integer shifter and so shifts have ~10 times longer latency then simple operations like adds)
michael
parents: 4014
diff changeset
342 "cmp $0x100, %0 \n\t"
3943
811a9b0d9f32 several x86 renorm_cabac_decoder_once optimizations
michael
parents: 3928
diff changeset
343 "sbb %%edx, %%edx \n\t"
811a9b0d9f32 several x86 renorm_cabac_decoder_once optimizations
michael
parents: 3928
diff changeset
344 "mov %0, %%eax \n\t"
811a9b0d9f32 several x86 renorm_cabac_decoder_once optimizations
michael
parents: 3928
diff changeset
345 "and %%edx, %0 \n\t"
811a9b0d9f32 several x86 renorm_cabac_decoder_once optimizations
michael
parents: 3928
diff changeset
346 "and %1, %%edx \n\t"
811a9b0d9f32 several x86 renorm_cabac_decoder_once optimizations
michael
parents: 3928
diff changeset
347 "add %%eax, %0 \n\t"
811a9b0d9f32 several x86 renorm_cabac_decoder_once optimizations
michael
parents: 3928
diff changeset
348 "add %%edx, %1 \n\t"
811a9b0d9f32 several x86 renorm_cabac_decoder_once optimizations
michael
parents: 3928
diff changeset
349 : "+r"(c->range), "+r"(c->low), "+a"(temp), "+d"(temp2)
811a9b0d9f32 several x86 renorm_cabac_decoder_once optimizations
michael
parents: 3928
diff changeset
350 );
811a9b0d9f32 several x86 renorm_cabac_decoder_once optimizations
michael
parents: 3928
diff changeset
351 #else
811a9b0d9f32 several x86 renorm_cabac_decoder_once optimizations
michael
parents: 3928
diff changeset
352 int temp2;
3950
900d21b85dd6 renorm_cabac_decoder_once START/STOP_TIMER scores for athlon
michael
parents: 3948
diff changeset
353 //P3:677 athlon:511
3943
811a9b0d9f32 several x86 renorm_cabac_decoder_once optimizations
michael
parents: 3928
diff changeset
354 asm(
4024
d550343b5dac shift CABACContext.range right, this reduces the number of shifts needed in get_cabac() and is slightly faster on P3 (and should be much faster on P4 as the P4 except the more recent variants lacks an integer shifter and so shifts have ~10 times longer latency then simple operations like adds)
michael
parents: 4014
diff changeset
355 "cmp $0x100, %0 \n\t"
3943
811a9b0d9f32 several x86 renorm_cabac_decoder_once optimizations
michael
parents: 3928
diff changeset
356 "lea (%0, %0), %%eax \n\t"
811a9b0d9f32 several x86 renorm_cabac_decoder_once optimizations
michael
parents: 3928
diff changeset
357 "lea (%1, %1), %%edx \n\t"
811a9b0d9f32 several x86 renorm_cabac_decoder_once optimizations
michael
parents: 3928
diff changeset
358 "cmovb %%eax, %0 \n\t"
811a9b0d9f32 several x86 renorm_cabac_decoder_once optimizations
michael
parents: 3928
diff changeset
359 "cmovb %%edx, %1 \n\t"
811a9b0d9f32 several x86 renorm_cabac_decoder_once optimizations
michael
parents: 3928
diff changeset
360 : "+r"(c->range), "+r"(c->low), "+a"(temp), "+d"(temp2)
811a9b0d9f32 several x86 renorm_cabac_decoder_once optimizations
michael
parents: 3928
diff changeset
361 );
811a9b0d9f32 several x86 renorm_cabac_decoder_once optimizations
michael
parents: 3928
diff changeset
362 #endif
811a9b0d9f32 several x86 renorm_cabac_decoder_once optimizations
michael
parents: 3928
diff changeset
363 #else
3950
900d21b85dd6 renorm_cabac_decoder_once START/STOP_TIMER scores for athlon
michael
parents: 3948
diff changeset
364 //P3:675 athlon:476
4024
d550343b5dac shift CABACContext.range right, this reduces the number of shifts needed in get_cabac() and is slightly faster on P3 (and should be much faster on P4 as the P4 except the more recent variants lacks an integer shifter and so shifts have ~10 times longer latency then simple operations like adds)
michael
parents: 4014
diff changeset
365 int shift= (uint32_t)(c->range - 0x100)>>31;
3642
0efda682253c tweak cabac. 0.5% faster h264.
lorenm
parents: 3284
diff changeset
366 c->range<<= shift;
0efda682253c tweak cabac. 0.5% faster h264.
lorenm
parents: 3284
diff changeset
367 c->low <<= shift;
3943
811a9b0d9f32 several x86 renorm_cabac_decoder_once optimizations
michael
parents: 3928
diff changeset
368 #endif
2323
1c39d9786efd optimization
michael
parents: 2116
diff changeset
369 if(!(c->low & CABAC_MASK))
1c39d9786efd optimization
michael
parents: 2116
diff changeset
370 refill(c);
1c39d9786efd optimization
michael
parents: 2116
diff changeset
371 }
1c39d9786efd optimization
michael
parents: 2116
diff changeset
372
4908
777f250df232 Fix multiple "¡Æinline/static¡Ç is not at beginning of declaration" warnings.
diego
parents: 4882
diff changeset
373 static av_always_inline int get_cabac_inline(CABACContext *c, uint8_t * const state){
3642
0efda682253c tweak cabac. 0.5% faster h264.
lorenm
parents: 3284
diff changeset
374 //FIXME gcc generates duplicate load/stores for c->low and c->range
3969
fc6e0942353b first try of a handwritten get_cabac() for x86, this is 10-20% faster on P3 depening on if you try to subtract the START/STOP_TIMER overhead
michael
parents: 3967
diff changeset
375 #define LOW "0"
fc6e0942353b first try of a handwritten get_cabac() for x86, this is 10-20% faster on P3 depening on if you try to subtract the START/STOP_TIMER overhead
michael
parents: 3967
diff changeset
376 #define RANGE "4"
4064
d3afe4505951 CABAC assembler optimizations ported to AMD64
reimar
parents: 4051
diff changeset
377 #ifdef ARCH_X86_64
d3afe4505951 CABAC assembler optimizations ported to AMD64
reimar
parents: 4051
diff changeset
378 #define BYTESTART "16"
d3afe4505951 CABAC assembler optimizations ported to AMD64
reimar
parents: 4051
diff changeset
379 #define BYTE "24"
d3afe4505951 CABAC assembler optimizations ported to AMD64
reimar
parents: 4051
diff changeset
380 #define BYTEEND "32"
d3afe4505951 CABAC assembler optimizations ported to AMD64
reimar
parents: 4051
diff changeset
381 #else
3993
8b7c59b7af01 make state transition tables global as they are constant and the code is slightly faster that way
michael
parents: 3992
diff changeset
382 #define BYTESTART "12"
8b7c59b7af01 make state transition tables global as they are constant and the code is slightly faster that way
michael
parents: 3992
diff changeset
383 #define BYTE "16"
8b7c59b7af01 make state transition tables global as they are constant and the code is slightly faster that way
michael
parents: 3992
diff changeset
384 #define BYTEEND "20"
4064
d3afe4505951 CABAC assembler optimizations ported to AMD64
reimar
parents: 4051
diff changeset
385 #endif
5547
81226e690378 CONFIG_7REGS -> HAVE_7REGS
ramiro
parents: 5408
diff changeset
386 #if defined(ARCH_X86) && defined(HAVE_7REGS) && defined(HAVE_EBX_AVAILABLE) && !defined(BROKEN_RELOCATIONS)
4044
5ccdefd60f61 Fix PIC compilation, some defines were under #ifdef !PIC but used
diego
parents: 4043
diff changeset
387 int bit;
5ccdefd60f61 Fix PIC compilation, some defines were under #ifdef !PIC but used
diego
parents: 4043
diff changeset
388
3984
bb186452e7da BRANCHLESS_CABAD --> BRANCHLESS_CABAC_DECODER
diego
parents: 3982
diff changeset
389 #ifndef BRANCHLESS_CABAC_DECODER
3969
fc6e0942353b first try of a handwritten get_cabac() for x86, this is 10-20% faster on P3 depening on if you try to subtract the START/STOP_TIMER overhead
michael
parents: 3967
diff changeset
390 asm volatile(
4035
b7f31a32bb30 cosmetic (%%eax->%0)
michael
parents: 4034
diff changeset
391 "movzbl (%1), %0 \n\t"
3969
fc6e0942353b first try of a handwritten get_cabac() for x86, this is 10-20% faster on P3 depening on if you try to subtract the START/STOP_TIMER overhead
michael
parents: 3967
diff changeset
392 "movl "RANGE "(%2), %%ebx \n\t"
fc6e0942353b first try of a handwritten get_cabac() for x86, this is 10-20% faster on P3 depening on if you try to subtract the START/STOP_TIMER overhead
michael
parents: 3967
diff changeset
393 "movl "RANGE "(%2), %%edx \n\t"
4024
d550343b5dac shift CABACContext.range right, this reduces the number of shifts needed in get_cabac() and is slightly faster on P3 (and should be much faster on P4 as the P4 except the more recent variants lacks an integer shifter and so shifts have ~10 times longer latency then simple operations like adds)
michael
parents: 4014
diff changeset
394 "andl $0xC0, %%ebx \n\t"
4035
b7f31a32bb30 cosmetic (%%eax->%0)
michael
parents: 4034
diff changeset
395 "movzbl "MANGLE(ff_h264_lps_range)"(%0, %%ebx, 2), %%esi\n\t"
3969
fc6e0942353b first try of a handwritten get_cabac() for x86, this is 10-20% faster on P3 depening on if you try to subtract the START/STOP_TIMER overhead
michael
parents: 3967
diff changeset
396 "movl "LOW "(%2), %%ebx \n\t"
fc6e0942353b first try of a handwritten get_cabac() for x86, this is 10-20% faster on P3 depening on if you try to subtract the START/STOP_TIMER overhead
michael
parents: 3967
diff changeset
397 //eax:state ebx:low, edx:range, esi:RangeLPS
fc6e0942353b first try of a handwritten get_cabac() for x86, this is 10-20% faster on P3 depening on if you try to subtract the START/STOP_TIMER overhead
michael
parents: 3967
diff changeset
398 "subl %%esi, %%edx \n\t"
4024
d550343b5dac shift CABACContext.range right, this reduces the number of shifts needed in get_cabac() and is slightly faster on P3 (and should be much faster on P4 as the P4 except the more recent variants lacks an integer shifter and so shifts have ~10 times longer latency then simple operations like adds)
michael
parents: 4014
diff changeset
399 "movl %%edx, %%ecx \n\t"
d550343b5dac shift CABACContext.range right, this reduces the number of shifts needed in get_cabac() and is slightly faster on P3 (and should be much faster on P4 as the P4 except the more recent variants lacks an integer shifter and so shifts have ~10 times longer latency then simple operations like adds)
michael
parents: 4014
diff changeset
400 "shll $17, %%ecx \n\t"
d550343b5dac shift CABACContext.range right, this reduces the number of shifts needed in get_cabac() and is slightly faster on P3 (and should be much faster on P4 as the P4 except the more recent variants lacks an integer shifter and so shifts have ~10 times longer latency then simple operations like adds)
michael
parents: 4014
diff changeset
401 "cmpl %%ecx, %%ebx \n\t"
3969
fc6e0942353b first try of a handwritten get_cabac() for x86, this is 10-20% faster on P3 depening on if you try to subtract the START/STOP_TIMER overhead
michael
parents: 3967
diff changeset
402 " ja 1f \n\t"
3999
6cbad3675632 slightly faster on P3 slightly slower on athlon and probably faster on P4
michael
parents: 3996
diff changeset
403
6cbad3675632 slightly faster on P3 slightly slower on athlon and probably faster on P4
michael
parents: 3996
diff changeset
404 #if 1
6cbad3675632 slightly faster on P3 slightly slower on athlon and probably faster on P4
michael
parents: 3996
diff changeset
405 //athlon:4067 P3:4110
4024
d550343b5dac shift CABACContext.range right, this reduces the number of shifts needed in get_cabac() and is slightly faster on P3 (and should be much faster on P4 as the P4 except the more recent variants lacks an integer shifter and so shifts have ~10 times longer latency then simple operations like adds)
michael
parents: 4014
diff changeset
406 "lea -0x100(%%edx), %%ecx \n\t"
3999
6cbad3675632 slightly faster on P3 slightly slower on athlon and probably faster on P4
michael
parents: 3996
diff changeset
407 "shr $31, %%ecx \n\t"
6cbad3675632 slightly faster on P3 slightly slower on athlon and probably faster on P4
michael
parents: 3996
diff changeset
408 "shl %%cl, %%edx \n\t"
6cbad3675632 slightly faster on P3 slightly slower on athlon and probably faster on P4
michael
parents: 3996
diff changeset
409 "shl %%cl, %%ebx \n\t"
6cbad3675632 slightly faster on P3 slightly slower on athlon and probably faster on P4
michael
parents: 3996
diff changeset
410 #else
6cbad3675632 slightly faster on P3 slightly slower on athlon and probably faster on P4
michael
parents: 3996
diff changeset
411 //athlon:4057 P3:4130
4024
d550343b5dac shift CABACContext.range right, this reduces the number of shifts needed in get_cabac() and is slightly faster on P3 (and should be much faster on P4 as the P4 except the more recent variants lacks an integer shifter and so shifts have ~10 times longer latency then simple operations like adds)
michael
parents: 4014
diff changeset
412 "cmp $0x100, %%edx \n\t" //FIXME avoidable
3969
fc6e0942353b first try of a handwritten get_cabac() for x86, this is 10-20% faster on P3 depening on if you try to subtract the START/STOP_TIMER overhead
michael
parents: 3967
diff changeset
413 "setb %%cl \n\t"
fc6e0942353b first try of a handwritten get_cabac() for x86, this is 10-20% faster on P3 depening on if you try to subtract the START/STOP_TIMER overhead
michael
parents: 3967
diff changeset
414 "shl %%cl, %%edx \n\t"
fc6e0942353b first try of a handwritten get_cabac() for x86, this is 10-20% faster on P3 depening on if you try to subtract the START/STOP_TIMER overhead
michael
parents: 3967
diff changeset
415 "shl %%cl, %%ebx \n\t"
3999
6cbad3675632 slightly faster on P3 slightly slower on athlon and probably faster on P4
michael
parents: 3996
diff changeset
416 #endif
4035
b7f31a32bb30 cosmetic (%%eax->%0)
michael
parents: 4034
diff changeset
417 "movzbl "MANGLE(ff_h264_mps_state)"(%0), %%ecx \n\t"
3969
fc6e0942353b first try of a handwritten get_cabac() for x86, this is 10-20% faster on P3 depening on if you try to subtract the START/STOP_TIMER overhead
michael
parents: 3967
diff changeset
418 "movb %%cl, (%1) \n\t"
fc6e0942353b first try of a handwritten get_cabac() for x86, this is 10-20% faster on P3 depening on if you try to subtract the START/STOP_TIMER overhead
michael
parents: 3967
diff changeset
419 //eax:state ebx:low, edx:range, esi:RangeLPS
fc6e0942353b first try of a handwritten get_cabac() for x86, this is 10-20% faster on P3 depening on if you try to subtract the START/STOP_TIMER overhead
michael
parents: 3967
diff changeset
420 "test %%bx, %%bx \n\t"
fc6e0942353b first try of a handwritten get_cabac() for x86, this is 10-20% faster on P3 depening on if you try to subtract the START/STOP_TIMER overhead
michael
parents: 3967
diff changeset
421 " jnz 2f \n\t"
4064
d3afe4505951 CABAC assembler optimizations ported to AMD64
reimar
parents: 4051
diff changeset
422 "mov "BYTE "(%2), %%"REG_S" \n\t"
3969
fc6e0942353b first try of a handwritten get_cabac() for x86, this is 10-20% faster on P3 depening on if you try to subtract the START/STOP_TIMER overhead
michael
parents: 3967
diff changeset
423 "subl $0xFFFF, %%ebx \n\t"
4064
d3afe4505951 CABAC assembler optimizations ported to AMD64
reimar
parents: 4051
diff changeset
424 "movzwl (%%"REG_S"), %%ecx \n\t"
3969
fc6e0942353b first try of a handwritten get_cabac() for x86, this is 10-20% faster on P3 depening on if you try to subtract the START/STOP_TIMER overhead
michael
parents: 3967
diff changeset
425 "bswap %%ecx \n\t"
fc6e0942353b first try of a handwritten get_cabac() for x86, this is 10-20% faster on P3 depening on if you try to subtract the START/STOP_TIMER overhead
michael
parents: 3967
diff changeset
426 "shrl $15, %%ecx \n\t"
4064
d3afe4505951 CABAC assembler optimizations ported to AMD64
reimar
parents: 4051
diff changeset
427 "add $2, %%"REG_S" \n\t"
3969
fc6e0942353b first try of a handwritten get_cabac() for x86, this is 10-20% faster on P3 depening on if you try to subtract the START/STOP_TIMER overhead
michael
parents: 3967
diff changeset
428 "addl %%ecx, %%ebx \n\t"
4064
d3afe4505951 CABAC assembler optimizations ported to AMD64
reimar
parents: 4051
diff changeset
429 "mov %%"REG_S", "BYTE "(%2) \n\t"
3969
fc6e0942353b first try of a handwritten get_cabac() for x86, this is 10-20% faster on P3 depening on if you try to subtract the START/STOP_TIMER overhead
michael
parents: 3967
diff changeset
430 "jmp 2f \n\t"
fc6e0942353b first try of a handwritten get_cabac() for x86, this is 10-20% faster on P3 depening on if you try to subtract the START/STOP_TIMER overhead
michael
parents: 3967
diff changeset
431 "1: \n\t"
fc6e0942353b first try of a handwritten get_cabac() for x86, this is 10-20% faster on P3 depening on if you try to subtract the START/STOP_TIMER overhead
michael
parents: 3967
diff changeset
432 //eax:state ebx:low, edx:range, esi:RangeLPS
4024
d550343b5dac shift CABACContext.range right, this reduces the number of shifts needed in get_cabac() and is slightly faster on P3 (and should be much faster on P4 as the P4 except the more recent variants lacks an integer shifter and so shifts have ~10 times longer latency then simple operations like adds)
michael
parents: 4014
diff changeset
433 "subl %%ecx, %%ebx \n\t"
3969
fc6e0942353b first try of a handwritten get_cabac() for x86, this is 10-20% faster on P3 depening on if you try to subtract the START/STOP_TIMER overhead
michael
parents: 3967
diff changeset
434 "movl %%esi, %%edx \n\t"
3979
ce16f66a48ad reading 8bit mem into a 8bit register needs 2 uops on P4, 8bit->32bit with zero extension needs just 1
michael
parents: 3978
diff changeset
435 "movzbl " MANGLE(ff_h264_norm_shift) "(%%esi), %%ecx \n\t"
3969
fc6e0942353b first try of a handwritten get_cabac() for x86, this is 10-20% faster on P3 depening on if you try to subtract the START/STOP_TIMER overhead
michael
parents: 3967
diff changeset
436 "shll %%cl, %%ebx \n\t"
fc6e0942353b first try of a handwritten get_cabac() for x86, this is 10-20% faster on P3 depening on if you try to subtract the START/STOP_TIMER overhead
michael
parents: 3967
diff changeset
437 "shll %%cl, %%edx \n\t"
4035
b7f31a32bb30 cosmetic (%%eax->%0)
michael
parents: 4034
diff changeset
438 "movzbl "MANGLE(ff_h264_lps_state)"(%0), %%ecx \n\t"
4024
d550343b5dac shift CABACContext.range right, this reduces the number of shifts needed in get_cabac() and is slightly faster on P3 (and should be much faster on P4 as the P4 except the more recent variants lacks an integer shifter and so shifts have ~10 times longer latency then simple operations like adds)
michael
parents: 4014
diff changeset
439 "movb %%cl, (%1) \n\t"
4064
d3afe4505951 CABAC assembler optimizations ported to AMD64
reimar
parents: 4051
diff changeset
440 "add $1, %0 \n\t"
3969
fc6e0942353b first try of a handwritten get_cabac() for x86, this is 10-20% faster on P3 depening on if you try to subtract the START/STOP_TIMER overhead
michael
parents: 3967
diff changeset
441 "test %%bx, %%bx \n\t"
fc6e0942353b first try of a handwritten get_cabac() for x86, this is 10-20% faster on P3 depening on if you try to subtract the START/STOP_TIMER overhead
michael
parents: 3967
diff changeset
442 " jnz 2f \n\t"
fc6e0942353b first try of a handwritten get_cabac() for x86, this is 10-20% faster on P3 depening on if you try to subtract the START/STOP_TIMER overhead
michael
parents: 3967
diff changeset
443
4064
d3afe4505951 CABAC assembler optimizations ported to AMD64
reimar
parents: 4051
diff changeset
444 "mov "BYTE "(%2), %%"REG_c" \n\t"
d3afe4505951 CABAC assembler optimizations ported to AMD64
reimar
parents: 4051
diff changeset
445 "movzwl (%%"REG_c"), %%esi \n\t"
3969
fc6e0942353b first try of a handwritten get_cabac() for x86, this is 10-20% faster on P3 depening on if you try to subtract the START/STOP_TIMER overhead
michael
parents: 3967
diff changeset
446 "bswap %%esi \n\t"
fc6e0942353b first try of a handwritten get_cabac() for x86, this is 10-20% faster on P3 depening on if you try to subtract the START/STOP_TIMER overhead
michael
parents: 3967
diff changeset
447 "shrl $15, %%esi \n\t"
fc6e0942353b first try of a handwritten get_cabac() for x86, this is 10-20% faster on P3 depening on if you try to subtract the START/STOP_TIMER overhead
michael
parents: 3967
diff changeset
448 "subl $0xFFFF, %%esi \n\t"
4064
d3afe4505951 CABAC assembler optimizations ported to AMD64
reimar
parents: 4051
diff changeset
449 "add $2, %%"REG_c" \n\t"
d3afe4505951 CABAC assembler optimizations ported to AMD64
reimar
parents: 4051
diff changeset
450 "mov %%"REG_c", "BYTE "(%2) \n\t"
3969
fc6e0942353b first try of a handwritten get_cabac() for x86, this is 10-20% faster on P3 depening on if you try to subtract the START/STOP_TIMER overhead
michael
parents: 3967
diff changeset
451
fc6e0942353b first try of a handwritten get_cabac() for x86, this is 10-20% faster on P3 depening on if you try to subtract the START/STOP_TIMER overhead
michael
parents: 3967
diff changeset
452 "leal -1(%%ebx), %%ecx \n\t"
fc6e0942353b first try of a handwritten get_cabac() for x86, this is 10-20% faster on P3 depening on if you try to subtract the START/STOP_TIMER overhead
michael
parents: 3967
diff changeset
453 "xorl %%ebx, %%ecx \n\t"
4024
d550343b5dac shift CABACContext.range right, this reduces the number of shifts needed in get_cabac() and is slightly faster on P3 (and should be much faster on P4 as the P4 except the more recent variants lacks an integer shifter and so shifts have ~10 times longer latency then simple operations like adds)
michael
parents: 4014
diff changeset
454 "shrl $15, %%ecx \n\t"
3979
ce16f66a48ad reading 8bit mem into a 8bit register needs 2 uops on P4, 8bit->32bit with zero extension needs just 1
michael
parents: 3978
diff changeset
455 "movzbl " MANGLE(ff_h264_norm_shift) "(%%ecx), %%ecx \n\t"
3994
2734b228fc87 use ecx instead of cl (no speed change on P3 but might avoid partial register stalls on some cpus)
michael
parents: 3993
diff changeset
456 "neg %%ecx \n\t"
2734b228fc87 use ecx instead of cl (no speed change on P3 but might avoid partial register stalls on some cpus)
michael
parents: 3993
diff changeset
457 "add $7, %%ecx \n\t"
3969
fc6e0942353b first try of a handwritten get_cabac() for x86, this is 10-20% faster on P3 depening on if you try to subtract the START/STOP_TIMER overhead
michael
parents: 3967
diff changeset
458
fc6e0942353b first try of a handwritten get_cabac() for x86, this is 10-20% faster on P3 depening on if you try to subtract the START/STOP_TIMER overhead
michael
parents: 3967
diff changeset
459 "shll %%cl , %%esi \n\t"
fc6e0942353b first try of a handwritten get_cabac() for x86, this is 10-20% faster on P3 depening on if you try to subtract the START/STOP_TIMER overhead
michael
parents: 3967
diff changeset
460 "addl %%esi, %%ebx \n\t"
fc6e0942353b first try of a handwritten get_cabac() for x86, this is 10-20% faster on P3 depening on if you try to subtract the START/STOP_TIMER overhead
michael
parents: 3967
diff changeset
461 "2: \n\t"
fc6e0942353b first try of a handwritten get_cabac() for x86, this is 10-20% faster on P3 depening on if you try to subtract the START/STOP_TIMER overhead
michael
parents: 3967
diff changeset
462 "movl %%edx, "RANGE "(%2) \n\t"
fc6e0942353b first try of a handwritten get_cabac() for x86, this is 10-20% faster on P3 depening on if you try to subtract the START/STOP_TIMER overhead
michael
parents: 3967
diff changeset
463 "movl %%ebx, "LOW "(%2) \n\t"
5408
20bea6a9950c cosmetics: misc typo fixes
diego
parents: 5215
diff changeset
464 :"=&a"(bit) //FIXME this is fragile gcc either runs out of registers or miscompiles it (for example if "+a"(bit) or "+m"(*state) is used
3969
fc6e0942353b first try of a handwritten get_cabac() for x86, this is 10-20% faster on P3 depening on if you try to subtract the START/STOP_TIMER overhead
michael
parents: 3967
diff changeset
465 :"r"(state), "r"(c)
4064
d3afe4505951 CABAC assembler optimizations ported to AMD64
reimar
parents: 4051
diff changeset
466 : "%"REG_c, "%ebx", "%edx", "%"REG_S, "memory"
3969
fc6e0942353b first try of a handwritten get_cabac() for x86, this is 10-20% faster on P3 depening on if you try to subtract the START/STOP_TIMER overhead
michael
parents: 3967
diff changeset
467 );
3982
af16271634c2 moving another bit&1 out, this is as fast as with it in there, but it makes more sense with it outside of the loop
michael
parents: 3981
diff changeset
468 bit&=1;
4002
ec426fa57dfe adds some useful comments after some of the #else, #elseif,
gpoirier
parents: 4001
diff changeset
469 #else /* BRANCHLESS_CABAC_DECODER */
4046
8bbc695c9603 factorize get_cabac asm (0.5% slower but its much cleaner)
michael
parents: 4044
diff changeset
470
8bbc695c9603 factorize get_cabac asm (0.5% slower but its much cleaner)
michael
parents: 4044
diff changeset
471
4418
4cceb7c877af rename CMOV_IS_FAST to HAVE_FAST_CMOV and simplify configure
mru
parents: 4345
diff changeset
472 #if defined HAVE_FAST_CMOV
4046
8bbc695c9603 factorize get_cabac asm (0.5% slower but its much cleaner)
michael
parents: 4044
diff changeset
473 #define BRANCHLESS_GET_CABAC_UPDATE(ret, cabac, statep, low, lowword, range, tmp, tmpbyte)\
8bbc695c9603 factorize get_cabac asm (0.5% slower but its much cleaner)
michael
parents: 4044
diff changeset
474 "mov "tmp" , %%ecx \n\t"\
8bbc695c9603 factorize get_cabac asm (0.5% slower but its much cleaner)
michael
parents: 4044
diff changeset
475 "shl $17 , "tmp" \n\t"\
8bbc695c9603 factorize get_cabac asm (0.5% slower but its much cleaner)
michael
parents: 4044
diff changeset
476 "cmp "low" , "tmp" \n\t"\
8bbc695c9603 factorize get_cabac asm (0.5% slower but its much cleaner)
michael
parents: 4044
diff changeset
477 "cmova %%ecx , "range" \n\t"\
8bbc695c9603 factorize get_cabac asm (0.5% slower but its much cleaner)
michael
parents: 4044
diff changeset
478 "sbb %%ecx , %%ecx \n\t"\
8bbc695c9603 factorize get_cabac asm (0.5% slower but its much cleaner)
michael
parents: 4044
diff changeset
479 "and %%ecx , "tmp" \n\t"\
8bbc695c9603 factorize get_cabac asm (0.5% slower but its much cleaner)
michael
parents: 4044
diff changeset
480 "sub "tmp" , "low" \n\t"\
8bbc695c9603 factorize get_cabac asm (0.5% slower but its much cleaner)
michael
parents: 4044
diff changeset
481 "xor %%ecx , "ret" \n\t"
4418
4cceb7c877af rename CMOV_IS_FAST to HAVE_FAST_CMOV and simplify configure
mru
parents: 4345
diff changeset
482 #else /* HAVE_FAST_CMOV */
4046
8bbc695c9603 factorize get_cabac asm (0.5% slower but its much cleaner)
michael
parents: 4044
diff changeset
483 #define BRANCHLESS_GET_CABAC_UPDATE(ret, cabac, statep, low, lowword, range, tmp, tmpbyte)\
8bbc695c9603 factorize get_cabac asm (0.5% slower but its much cleaner)
michael
parents: 4044
diff changeset
484 "mov "tmp" , %%ecx \n\t"\
8bbc695c9603 factorize get_cabac asm (0.5% slower but its much cleaner)
michael
parents: 4044
diff changeset
485 "shl $17 , "tmp" \n\t"\
8bbc695c9603 factorize get_cabac asm (0.5% slower but its much cleaner)
michael
parents: 4044
diff changeset
486 "sub "low" , "tmp" \n\t"\
8bbc695c9603 factorize get_cabac asm (0.5% slower but its much cleaner)
michael
parents: 4044
diff changeset
487 "sar $31 , "tmp" \n\t" /*lps_mask*/\
8bbc695c9603 factorize get_cabac asm (0.5% slower but its much cleaner)
michael
parents: 4044
diff changeset
488 "sub %%ecx , "range" \n\t" /*RangeLPS - range*/\
8bbc695c9603 factorize get_cabac asm (0.5% slower but its much cleaner)
michael
parents: 4044
diff changeset
489 "and "tmp" , "range" \n\t" /*(RangeLPS - range)&lps_mask*/\
8bbc695c9603 factorize get_cabac asm (0.5% slower but its much cleaner)
michael
parents: 4044
diff changeset
490 "add %%ecx , "range" \n\t" /*new range*/\
8bbc695c9603 factorize get_cabac asm (0.5% slower but its much cleaner)
michael
parents: 4044
diff changeset
491 "shl $17 , %%ecx \n\t"\
8bbc695c9603 factorize get_cabac asm (0.5% slower but its much cleaner)
michael
parents: 4044
diff changeset
492 "and "tmp" , %%ecx \n\t"\
8bbc695c9603 factorize get_cabac asm (0.5% slower but its much cleaner)
michael
parents: 4044
diff changeset
493 "sub %%ecx , "low" \n\t"\
8bbc695c9603 factorize get_cabac asm (0.5% slower but its much cleaner)
michael
parents: 4044
diff changeset
494 "xor "tmp" , "ret" \n\t"
4418
4cceb7c877af rename CMOV_IS_FAST to HAVE_FAST_CMOV and simplify configure
mru
parents: 4345
diff changeset
495 #endif /* HAVE_FAST_CMOV */
3975
6cc9eb5ee5e3 x86 branchless cabac decoder
michael
parents: 3974
diff changeset
496
6cc9eb5ee5e3 x86 branchless cabac decoder
michael
parents: 3974
diff changeset
497
4046
8bbc695c9603 factorize get_cabac asm (0.5% slower but its much cleaner)
michael
parents: 4044
diff changeset
498 #define BRANCHLESS_GET_CABAC(ret, cabac, statep, low, lowword, range, tmp, tmpbyte)\
8bbc695c9603 factorize get_cabac asm (0.5% slower but its much cleaner)
michael
parents: 4044
diff changeset
499 "movzbl "statep" , "ret" \n\t"\
8bbc695c9603 factorize get_cabac asm (0.5% slower but its much cleaner)
michael
parents: 4044
diff changeset
500 "mov "range" , "tmp" \n\t"\
8bbc695c9603 factorize get_cabac asm (0.5% slower but its much cleaner)
michael
parents: 4044
diff changeset
501 "and $0xC0 , "range" \n\t"\
8bbc695c9603 factorize get_cabac asm (0.5% slower but its much cleaner)
michael
parents: 4044
diff changeset
502 "movzbl "MANGLE(ff_h264_lps_range)"("ret", "range", 2), "range" \n\t"\
8bbc695c9603 factorize get_cabac asm (0.5% slower but its much cleaner)
michael
parents: 4044
diff changeset
503 "sub "range" , "tmp" \n\t"\
8bbc695c9603 factorize get_cabac asm (0.5% slower but its much cleaner)
michael
parents: 4044
diff changeset
504 BRANCHLESS_GET_CABAC_UPDATE(ret, cabac, statep, low, lowword, range, tmp, tmpbyte)\
8bbc695c9603 factorize get_cabac asm (0.5% slower but its much cleaner)
michael
parents: 4044
diff changeset
505 "movzbl " MANGLE(ff_h264_norm_shift) "("range"), %%ecx \n\t"\
8bbc695c9603 factorize get_cabac asm (0.5% slower but its much cleaner)
michael
parents: 4044
diff changeset
506 "shl %%cl , "range" \n\t"\
8bbc695c9603 factorize get_cabac asm (0.5% slower but its much cleaner)
michael
parents: 4044
diff changeset
507 "movzbl "MANGLE(ff_h264_mlps_state)"+128("ret"), "tmp" \n\t"\
8bbc695c9603 factorize get_cabac asm (0.5% slower but its much cleaner)
michael
parents: 4044
diff changeset
508 "mov "tmpbyte" , "statep" \n\t"\
8bbc695c9603 factorize get_cabac asm (0.5% slower but its much cleaner)
michael
parents: 4044
diff changeset
509 "shl %%cl , "low" \n\t"\
8bbc695c9603 factorize get_cabac asm (0.5% slower but its much cleaner)
michael
parents: 4044
diff changeset
510 "test "lowword" , "lowword" \n\t"\
8bbc695c9603 factorize get_cabac asm (0.5% slower but its much cleaner)
michael
parents: 4044
diff changeset
511 " jnz 1f \n\t"\
4064
d3afe4505951 CABAC assembler optimizations ported to AMD64
reimar
parents: 4051
diff changeset
512 "mov "BYTE"("cabac"), %%"REG_c" \n\t"\
d3afe4505951 CABAC assembler optimizations ported to AMD64
reimar
parents: 4051
diff changeset
513 "movzwl (%%"REG_c") , "tmp" \n\t"\
4046
8bbc695c9603 factorize get_cabac asm (0.5% slower but its much cleaner)
michael
parents: 4044
diff changeset
514 "bswap "tmp" \n\t"\
8bbc695c9603 factorize get_cabac asm (0.5% slower but its much cleaner)
michael
parents: 4044
diff changeset
515 "shr $15 , "tmp" \n\t"\
8bbc695c9603 factorize get_cabac asm (0.5% slower but its much cleaner)
michael
parents: 4044
diff changeset
516 "sub $0xFFFF , "tmp" \n\t"\
4064
d3afe4505951 CABAC assembler optimizations ported to AMD64
reimar
parents: 4051
diff changeset
517 "add $2 , %%"REG_c" \n\t"\
d3afe4505951 CABAC assembler optimizations ported to AMD64
reimar
parents: 4051
diff changeset
518 "mov %%"REG_c" , "BYTE "("cabac") \n\t"\
4046
8bbc695c9603 factorize get_cabac asm (0.5% slower but its much cleaner)
michael
parents: 4044
diff changeset
519 "lea -1("low") , %%ecx \n\t"\
8bbc695c9603 factorize get_cabac asm (0.5% slower but its much cleaner)
michael
parents: 4044
diff changeset
520 "xor "low" , %%ecx \n\t"\
8bbc695c9603 factorize get_cabac asm (0.5% slower but its much cleaner)
michael
parents: 4044
diff changeset
521 "shr $15 , %%ecx \n\t"\
8bbc695c9603 factorize get_cabac asm (0.5% slower but its much cleaner)
michael
parents: 4044
diff changeset
522 "movzbl " MANGLE(ff_h264_norm_shift) "(%%ecx), %%ecx \n\t"\
8bbc695c9603 factorize get_cabac asm (0.5% slower but its much cleaner)
michael
parents: 4044
diff changeset
523 "neg %%ecx \n\t"\
8bbc695c9603 factorize get_cabac asm (0.5% slower but its much cleaner)
michael
parents: 4044
diff changeset
524 "add $7 , %%ecx \n\t"\
8bbc695c9603 factorize get_cabac asm (0.5% slower but its much cleaner)
michael
parents: 4044
diff changeset
525 "shl %%cl , "tmp" \n\t"\
8bbc695c9603 factorize get_cabac asm (0.5% slower but its much cleaner)
michael
parents: 4044
diff changeset
526 "add "tmp" , "low" \n\t"\
8bbc695c9603 factorize get_cabac asm (0.5% slower but its much cleaner)
michael
parents: 4044
diff changeset
527 "1: \n\t"
3975
6cc9eb5ee5e3 x86 branchless cabac decoder
michael
parents: 3974
diff changeset
528
4046
8bbc695c9603 factorize get_cabac asm (0.5% slower but its much cleaner)
michael
parents: 4044
diff changeset
529 asm volatile(
8bbc695c9603 factorize get_cabac asm (0.5% slower but its much cleaner)
michael
parents: 4044
diff changeset
530 "movl "RANGE "(%2), %%esi \n\t"
8bbc695c9603 factorize get_cabac asm (0.5% slower but its much cleaner)
michael
parents: 4044
diff changeset
531 "movl "LOW "(%2), %%ebx \n\t"
8bbc695c9603 factorize get_cabac asm (0.5% slower but its much cleaner)
michael
parents: 4044
diff changeset
532 BRANCHLESS_GET_CABAC("%0", "%2", "(%1)", "%%ebx", "%%bx", "%%esi", "%%edx", "%%dl")
8bbc695c9603 factorize get_cabac asm (0.5% slower but its much cleaner)
michael
parents: 4044
diff changeset
533 "movl %%esi, "RANGE "(%2) \n\t"
8bbc695c9603 factorize get_cabac asm (0.5% slower but its much cleaner)
michael
parents: 4044
diff changeset
534 "movl %%ebx, "LOW "(%2) \n\t"
3975
6cc9eb5ee5e3 x86 branchless cabac decoder
michael
parents: 3974
diff changeset
535
6cc9eb5ee5e3 x86 branchless cabac decoder
michael
parents: 3974
diff changeset
536 :"=&a"(bit)
6cc9eb5ee5e3 x86 branchless cabac decoder
michael
parents: 3974
diff changeset
537 :"r"(state), "r"(c)
4064
d3afe4505951 CABAC assembler optimizations ported to AMD64
reimar
parents: 4051
diff changeset
538 : "%"REG_c, "%ebx", "%edx", "%esi", "memory"
3975
6cc9eb5ee5e3 x86 branchless cabac decoder
michael
parents: 3974
diff changeset
539 );
3981
9854f686ba79 move the &1 out of the asm so gcc can optimize it away in inlined cases (yes this is slightly faster)
michael
parents: 3980
diff changeset
540 bit&=1;
4002
ec426fa57dfe adds some useful comments after some of the #else, #elseif,
gpoirier
parents: 4001
diff changeset
541 #endif /* BRANCHLESS_CABAC_DECODER */
5547
81226e690378 CONFIG_7REGS -> HAVE_7REGS
ramiro
parents: 5408
diff changeset
542 #else /* defined(ARCH_X86) && defined(HAVE_7REGS) && defined(HAVE_EBX_AVAILABLE) && !defined(BROKEN_RELOCATIONS) */
3642
0efda682253c tweak cabac. 0.5% faster h264.
lorenm
parents: 3284
diff changeset
543 int s = *state;
4039
866a83726985 Kill a warning with MSVC
gpoirier
parents: 4037
diff changeset
544 int RangeLPS= ff_h264_lps_range[2*(c->range&0xC0) + s];
5083
ce36118abbbb rename attribute_unused to av_unused and moves its declaration to common.h
benoit
parents: 4975
diff changeset
545 int bit, lps_mask av_unused;
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2736
diff changeset
546
1287
michaelni
parents:
diff changeset
547 c->range -= RangeLPS;
3984
bb186452e7da BRANCHLESS_CABAD --> BRANCHLESS_CABAC_DECODER
diego
parents: 3982
diff changeset
548 #ifndef BRANCHLESS_CABAC_DECODER
4345
88967250d718 replace a few hardcoded numbers with their correct named ones
michael
parents: 4283
diff changeset
549 if(c->low < (c->range<<(CABAC_BITS+1))){
3642
0efda682253c tweak cabac. 0.5% faster h264.
lorenm
parents: 3284
diff changeset
550 bit= s&1;
3993
8b7c59b7af01 make state transition tables global as they are constant and the code is slightly faster that way
michael
parents: 3992
diff changeset
551 *state= ff_h264_mps_state[s];
2323
1c39d9786efd optimization
michael
parents: 2116
diff changeset
552 renorm_cabac_decoder_once(c);
1287
michaelni
parents:
diff changeset
553 }else{
4024
d550343b5dac shift CABACContext.range right, this reduces the number of shifts needed in get_cabac() and is slightly faster on P3 (and should be much faster on P4 as the P4 except the more recent variants lacks an integer shifter and so shifts have ~10 times longer latency then simple operations like adds)
michael
parents: 4014
diff changeset
554 bit= ff_h264_norm_shift[RangeLPS];
4345
88967250d718 replace a few hardcoded numbers with their correct named ones
michael
parents: 4283
diff changeset
555 c->low -= (c->range<<(CABAC_BITS+1));
3993
8b7c59b7af01 make state transition tables global as they are constant and the code is slightly faster that way
michael
parents: 3992
diff changeset
556 *state= ff_h264_lps_state[s];
3956
0910f2844f9a branchless renormalization (1% faster get_cabac) old branchless renormalization wasnt faster because gcc was scared of the shift variable (missusing bit variable now)
michael
parents: 3955
diff changeset
557 c->range = RangeLPS<<bit;
0910f2844f9a branchless renormalization (1% faster get_cabac) old branchless renormalization wasnt faster because gcc was scared of the shift variable (missusing bit variable now)
michael
parents: 3955
diff changeset
558 c->low <<= bit;
0910f2844f9a branchless renormalization (1% faster get_cabac) old branchless renormalization wasnt faster because gcc was scared of the shift variable (missusing bit variable now)
michael
parents: 3955
diff changeset
559 bit= (s&1)^1;
0910f2844f9a branchless renormalization (1% faster get_cabac) old branchless renormalization wasnt faster because gcc was scared of the shift variable (missusing bit variable now)
michael
parents: 3955
diff changeset
560
4345
88967250d718 replace a few hardcoded numbers with their correct named ones
michael
parents: 4283
diff changeset
561 if(!(c->low & CABAC_MASK)){
2323
1c39d9786efd optimization
michael
parents: 2116
diff changeset
562 refill2(c);
3956
0910f2844f9a branchless renormalization (1% faster get_cabac) old branchless renormalization wasnt faster because gcc was scared of the shift variable (missusing bit variable now)
michael
parents: 3955
diff changeset
563 }
1287
michaelni
parents:
diff changeset
564 }
4002
ec426fa57dfe adds some useful comments after some of the #else, #elseif,
gpoirier
parents: 4001
diff changeset
565 #else /* BRANCHLESS_CABAC_DECODER */
4345
88967250d718 replace a few hardcoded numbers with their correct named ones
michael
parents: 4283
diff changeset
566 lps_mask= ((c->range<<(CABAC_BITS+1)) - c->low)>>31;
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2736
diff changeset
567
4345
88967250d718 replace a few hardcoded numbers with their correct named ones
michael
parents: 4283
diff changeset
568 c->low -= (c->range<<(CABAC_BITS+1)) & lps_mask;
2323
1c39d9786efd optimization
michael
parents: 2116
diff changeset
569 c->range += (RangeLPS - c->range) & lps_mask;
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2736
diff changeset
570
3974
93746612bc78 optimize branchless C CABAC decoder
michael
parents: 3972
diff changeset
571 s^=lps_mask;
4014
b2582438effe dehack *ps_state indexing in the branchless decoder
michael
parents: 4012
diff changeset
572 *state= (ff_h264_mlps_state+128)[s];
3974
93746612bc78 optimize branchless C CABAC decoder
michael
parents: 3972
diff changeset
573 bit= s&1;
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2736
diff changeset
574
4024
d550343b5dac shift CABACContext.range right, this reduces the number of shifts needed in get_cabac() and is slightly faster on P3 (and should be much faster on P4 as the P4 except the more recent variants lacks an integer shifter and so shifts have ~10 times longer latency then simple operations like adds)
michael
parents: 4014
diff changeset
575 lps_mask= ff_h264_norm_shift[c->range];
2323
1c39d9786efd optimization
michael
parents: 2116
diff changeset
576 c->range<<= lps_mask;
1c39d9786efd optimization
michael
parents: 2116
diff changeset
577 c->low <<= lps_mask;
1c39d9786efd optimization
michael
parents: 2116
diff changeset
578 if(!(c->low & CABAC_MASK))
1c39d9786efd optimization
michael
parents: 2116
diff changeset
579 refill2(c);
4002
ec426fa57dfe adds some useful comments after some of the #else, #elseif,
gpoirier
parents: 4001
diff changeset
580 #endif /* BRANCHLESS_CABAC_DECODER */
5547
81226e690378 CONFIG_7REGS -> HAVE_7REGS
ramiro
parents: 5408
diff changeset
581 #endif /* defined(ARCH_X86) && defined(HAVE_7REGS) && defined(HAVE_EBX_AVAILABLE) && !defined(BROKEN_RELOCATIONS) */
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2736
diff changeset
582 return bit;
1287
michaelni
parents:
diff changeset
583 }
michaelni
parents:
diff changeset
584
4579
03f7feb14dd3 use av_noinline instead of __attribute((noinline))
aurel
parents: 4418
diff changeset
585 static int av_noinline get_cabac_noinline(CABACContext *c, uint8_t * const state){
4008
b636f3d59283 prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents: 4002
diff changeset
586 return get_cabac_inline(c,state);
b636f3d59283 prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents: 4002
diff changeset
587 }
b636f3d59283 prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents: 4002
diff changeset
588
b636f3d59283 prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents: 4002
diff changeset
589 static int get_cabac(CABACContext *c, uint8_t * const state){
b636f3d59283 prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents: 4002
diff changeset
590 return get_cabac_inline(c,state);
b636f3d59283 prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents: 4002
diff changeset
591 }
b636f3d59283 prevent "mb level" get_cabac() calls from being inlined (3% faster decode_mb_cabac() on P3)
michael
parents: 4002
diff changeset
592
3928
987fffdf6ae7 don't try to inline cabac functions. gcc ignored the hint anyway, and forcing it would make h264 slower.
lorenm
parents: 3642
diff changeset
593 static int get_cabac_bypass(CABACContext *c){
4040
9eaea06c5ba6 optimize sign decoding code in decode_residual()
michael
parents: 4039
diff changeset
594 #if 0 //not faster
9eaea06c5ba6 optimize sign decoding code in decode_residual()
michael
parents: 4039
diff changeset
595 int bit;
9eaea06c5ba6 optimize sign decoding code in decode_residual()
michael
parents: 4039
diff changeset
596 asm volatile(
9eaea06c5ba6 optimize sign decoding code in decode_residual()
michael
parents: 4039
diff changeset
597 "movl "RANGE "(%1), %%ebx \n\t"
9eaea06c5ba6 optimize sign decoding code in decode_residual()
michael
parents: 4039
diff changeset
598 "movl "LOW "(%1), %%eax \n\t"
9eaea06c5ba6 optimize sign decoding code in decode_residual()
michael
parents: 4039
diff changeset
599 "shl $17, %%ebx \n\t"
9eaea06c5ba6 optimize sign decoding code in decode_residual()
michael
parents: 4039
diff changeset
600 "add %%eax, %%eax \n\t"
9eaea06c5ba6 optimize sign decoding code in decode_residual()
michael
parents: 4039
diff changeset
601 "sub %%ebx, %%eax \n\t"
9eaea06c5ba6 optimize sign decoding code in decode_residual()
michael
parents: 4039
diff changeset
602 "cdq \n\t"
9eaea06c5ba6 optimize sign decoding code in decode_residual()
michael
parents: 4039
diff changeset
603 "and %%edx, %%ebx \n\t"
9eaea06c5ba6 optimize sign decoding code in decode_residual()
michael
parents: 4039
diff changeset
604 "add %%ebx, %%eax \n\t"
9eaea06c5ba6 optimize sign decoding code in decode_residual()
michael
parents: 4039
diff changeset
605 "test %%ax, %%ax \n\t"
9eaea06c5ba6 optimize sign decoding code in decode_residual()
michael
parents: 4039
diff changeset
606 " jnz 1f \n\t"
4064
d3afe4505951 CABAC assembler optimizations ported to AMD64
reimar
parents: 4051
diff changeset
607 "movl "BYTE "(%1), %%"REG_b" \n\t"
4040
9eaea06c5ba6 optimize sign decoding code in decode_residual()
michael
parents: 4039
diff changeset
608 "subl $0xFFFF, %%eax \n\t"
4064
d3afe4505951 CABAC assembler optimizations ported to AMD64
reimar
parents: 4051
diff changeset
609 "movzwl (%%"REG_b"), %%ecx \n\t"
4040
9eaea06c5ba6 optimize sign decoding code in decode_residual()
michael
parents: 4039
diff changeset
610 "bswap %%ecx \n\t"
9eaea06c5ba6 optimize sign decoding code in decode_residual()
michael
parents: 4039
diff changeset
611 "shrl $15, %%ecx \n\t"
4064
d3afe4505951 CABAC assembler optimizations ported to AMD64
reimar
parents: 4051
diff changeset
612 "addl $2, %%"REG_b" \n\t"
4040
9eaea06c5ba6 optimize sign decoding code in decode_residual()
michael
parents: 4039
diff changeset
613 "addl %%ecx, %%eax \n\t"
4064
d3afe4505951 CABAC assembler optimizations ported to AMD64
reimar
parents: 4051
diff changeset
614 "movl %%"REG_b", "BYTE "(%1) \n\t"
4040
9eaea06c5ba6 optimize sign decoding code in decode_residual()
michael
parents: 4039
diff changeset
615 "1: \n\t"
9eaea06c5ba6 optimize sign decoding code in decode_residual()
michael
parents: 4039
diff changeset
616 "movl %%eax, "LOW "(%1) \n\t"
9eaea06c5ba6 optimize sign decoding code in decode_residual()
michael
parents: 4039
diff changeset
617
9eaea06c5ba6 optimize sign decoding code in decode_residual()
michael
parents: 4039
diff changeset
618 :"=&d"(bit)
9eaea06c5ba6 optimize sign decoding code in decode_residual()
michael
parents: 4039
diff changeset
619 :"r"(c)
4064
d3afe4505951 CABAC assembler optimizations ported to AMD64
reimar
parents: 4051
diff changeset
620 : "%eax", "%"REG_b, "%ecx", "memory"
4040
9eaea06c5ba6 optimize sign decoding code in decode_residual()
michael
parents: 4039
diff changeset
621 );
9eaea06c5ba6 optimize sign decoding code in decode_residual()
michael
parents: 4039
diff changeset
622 return bit+1;
9eaea06c5ba6 optimize sign decoding code in decode_residual()
michael
parents: 4039
diff changeset
623 #else
4024
d550343b5dac shift CABACContext.range right, this reduces the number of shifts needed in get_cabac() and is slightly faster on P3 (and should be much faster on P4 as the P4 except the more recent variants lacks an integer shifter and so shifts have ~10 times longer latency then simple operations like adds)
michael
parents: 4014
diff changeset
624 int range;
1287
michaelni
parents:
diff changeset
625 c->low += c->low;
michaelni
parents:
diff changeset
626
2323
1c39d9786efd optimization
michael
parents: 2116
diff changeset
627 if(!(c->low & CABAC_MASK))
1c39d9786efd optimization
michael
parents: 2116
diff changeset
628 refill(c);
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2736
diff changeset
629
4345
88967250d718 replace a few hardcoded numbers with their correct named ones
michael
parents: 4283
diff changeset
630 range= c->range<<(CABAC_BITS+1);
4024
d550343b5dac shift CABACContext.range right, this reduces the number of shifts needed in get_cabac() and is slightly faster on P3 (and should be much faster on P4 as the P4 except the more recent variants lacks an integer shifter and so shifts have ~10 times longer latency then simple operations like adds)
michael
parents: 4014
diff changeset
631 if(c->low < range){
1287
michaelni
parents:
diff changeset
632 return 0;
michaelni
parents:
diff changeset
633 }else{
4024
d550343b5dac shift CABACContext.range right, this reduces the number of shifts needed in get_cabac() and is slightly faster on P3 (and should be much faster on P4 as the P4 except the more recent variants lacks an integer shifter and so shifts have ~10 times longer latency then simple operations like adds)
michael
parents: 4014
diff changeset
634 c->low -= range;
1287
michaelni
parents:
diff changeset
635 return 1;
michaelni
parents:
diff changeset
636 }
4040
9eaea06c5ba6 optimize sign decoding code in decode_residual()
michael
parents: 4039
diff changeset
637 #endif
1287
michaelni
parents:
diff changeset
638 }
4040
9eaea06c5ba6 optimize sign decoding code in decode_residual()
michael
parents: 4039
diff changeset
639
9eaea06c5ba6 optimize sign decoding code in decode_residual()
michael
parents: 4039
diff changeset
640
4283
d6f83e2f8804 rename always_inline to av_always_inline and move to common.h
mru
parents: 4241
diff changeset
641 static av_always_inline int get_cabac_bypass_sign(CABACContext *c, int val){
4241
92f773cfebf5 PIC fix
michael
parents: 4113
diff changeset
642 #if defined(ARCH_X86) && !(defined(PIC) && defined(__GNUC__))
4040
9eaea06c5ba6 optimize sign decoding code in decode_residual()
michael
parents: 4039
diff changeset
643 asm volatile(
9eaea06c5ba6 optimize sign decoding code in decode_residual()
michael
parents: 4039
diff changeset
644 "movl "RANGE "(%1), %%ebx \n\t"
9eaea06c5ba6 optimize sign decoding code in decode_residual()
michael
parents: 4039
diff changeset
645 "movl "LOW "(%1), %%eax \n\t"
9eaea06c5ba6 optimize sign decoding code in decode_residual()
michael
parents: 4039
diff changeset
646 "shl $17, %%ebx \n\t"
9eaea06c5ba6 optimize sign decoding code in decode_residual()
michael
parents: 4039
diff changeset
647 "add %%eax, %%eax \n\t"
9eaea06c5ba6 optimize sign decoding code in decode_residual()
michael
parents: 4039
diff changeset
648 "sub %%ebx, %%eax \n\t"
9eaea06c5ba6 optimize sign decoding code in decode_residual()
michael
parents: 4039
diff changeset
649 "cdq \n\t"
9eaea06c5ba6 optimize sign decoding code in decode_residual()
michael
parents: 4039
diff changeset
650 "and %%edx, %%ebx \n\t"
9eaea06c5ba6 optimize sign decoding code in decode_residual()
michael
parents: 4039
diff changeset
651 "add %%ebx, %%eax \n\t"
9eaea06c5ba6 optimize sign decoding code in decode_residual()
michael
parents: 4039
diff changeset
652 "xor %%edx, %%ecx \n\t"
9eaea06c5ba6 optimize sign decoding code in decode_residual()
michael
parents: 4039
diff changeset
653 "sub %%edx, %%ecx \n\t"
9eaea06c5ba6 optimize sign decoding code in decode_residual()
michael
parents: 4039
diff changeset
654 "test %%ax, %%ax \n\t"
9eaea06c5ba6 optimize sign decoding code in decode_residual()
michael
parents: 4039
diff changeset
655 " jnz 1f \n\t"
4064
d3afe4505951 CABAC assembler optimizations ported to AMD64
reimar
parents: 4051
diff changeset
656 "mov "BYTE "(%1), %%"REG_b" \n\t"
4040
9eaea06c5ba6 optimize sign decoding code in decode_residual()
michael
parents: 4039
diff changeset
657 "subl $0xFFFF, %%eax \n\t"
4064
d3afe4505951 CABAC assembler optimizations ported to AMD64
reimar
parents: 4051
diff changeset
658 "movzwl (%%"REG_b"), %%edx \n\t"
4040
9eaea06c5ba6 optimize sign decoding code in decode_residual()
michael
parents: 4039
diff changeset
659 "bswap %%edx \n\t"
9eaea06c5ba6 optimize sign decoding code in decode_residual()
michael
parents: 4039
diff changeset
660 "shrl $15, %%edx \n\t"
4064
d3afe4505951 CABAC assembler optimizations ported to AMD64
reimar
parents: 4051
diff changeset
661 "add $2, %%"REG_b" \n\t"
4040
9eaea06c5ba6 optimize sign decoding code in decode_residual()
michael
parents: 4039
diff changeset
662 "addl %%edx, %%eax \n\t"
4064
d3afe4505951 CABAC assembler optimizations ported to AMD64
reimar
parents: 4051
diff changeset
663 "mov %%"REG_b", "BYTE "(%1) \n\t"
4040
9eaea06c5ba6 optimize sign decoding code in decode_residual()
michael
parents: 4039
diff changeset
664 "1: \n\t"
9eaea06c5ba6 optimize sign decoding code in decode_residual()
michael
parents: 4039
diff changeset
665 "movl %%eax, "LOW "(%1) \n\t"
9eaea06c5ba6 optimize sign decoding code in decode_residual()
michael
parents: 4039
diff changeset
666
9eaea06c5ba6 optimize sign decoding code in decode_residual()
michael
parents: 4039
diff changeset
667 :"+c"(val)
9eaea06c5ba6 optimize sign decoding code in decode_residual()
michael
parents: 4039
diff changeset
668 :"r"(c)
4064
d3afe4505951 CABAC assembler optimizations ported to AMD64
reimar
parents: 4051
diff changeset
669 : "%eax", "%"REG_b, "%edx", "memory"
4040
9eaea06c5ba6 optimize sign decoding code in decode_residual()
michael
parents: 4039
diff changeset
670 );
9eaea06c5ba6 optimize sign decoding code in decode_residual()
michael
parents: 4039
diff changeset
671 return val;
9eaea06c5ba6 optimize sign decoding code in decode_residual()
michael
parents: 4039
diff changeset
672 #else
9eaea06c5ba6 optimize sign decoding code in decode_residual()
michael
parents: 4039
diff changeset
673 int range, mask;
9eaea06c5ba6 optimize sign decoding code in decode_residual()
michael
parents: 4039
diff changeset
674 c->low += c->low;
9eaea06c5ba6 optimize sign decoding code in decode_residual()
michael
parents: 4039
diff changeset
675
9eaea06c5ba6 optimize sign decoding code in decode_residual()
michael
parents: 4039
diff changeset
676 if(!(c->low & CABAC_MASK))
9eaea06c5ba6 optimize sign decoding code in decode_residual()
michael
parents: 4039
diff changeset
677 refill(c);
9eaea06c5ba6 optimize sign decoding code in decode_residual()
michael
parents: 4039
diff changeset
678
4345
88967250d718 replace a few hardcoded numbers with their correct named ones
michael
parents: 4283
diff changeset
679 range= c->range<<(CABAC_BITS+1);
4040
9eaea06c5ba6 optimize sign decoding code in decode_residual()
michael
parents: 4039
diff changeset
680 c->low -= range;
9eaea06c5ba6 optimize sign decoding code in decode_residual()
michael
parents: 4039
diff changeset
681 mask= c->low >> 31;
9eaea06c5ba6 optimize sign decoding code in decode_residual()
michael
parents: 4039
diff changeset
682 range &= mask;
9eaea06c5ba6 optimize sign decoding code in decode_residual()
michael
parents: 4039
diff changeset
683 c->low += range;
9eaea06c5ba6 optimize sign decoding code in decode_residual()
michael
parents: 4039
diff changeset
684 return (val^mask)-mask;
9eaea06c5ba6 optimize sign decoding code in decode_residual()
michael
parents: 4039
diff changeset
685 #endif
9eaea06c5ba6 optimize sign decoding code in decode_residual()
michael
parents: 4039
diff changeset
686 }
9eaea06c5ba6 optimize sign decoding code in decode_residual()
michael
parents: 4039
diff changeset
687
4037
53be304c7f54 x86 asm version of the decode significance loop (not 8x8) of decode_residual() 5% faster decode_residual() on P3
michael
parents: 4035
diff changeset
688 //FIXME the x86 code from this file should be moved into i386/h264 or cabac something.c/h (note ill kill you if you move my code away from under my fingers before iam finished with it!)
5127
4dbe6578f811 misc spelling fixes
diego
parents: 5083
diff changeset
689 //FIXME use some macros to avoid duplicatin get_cabac (cannot be done yet as that would make optimization work hard)
5547
81226e690378 CONFIG_7REGS -> HAVE_7REGS
ramiro
parents: 5408
diff changeset
690 #if defined(ARCH_X86) && defined(HAVE_7REGS) && defined(HAVE_EBX_AVAILABLE) && !defined(BROKEN_RELOCATIONS)
4037
53be304c7f54 x86 asm version of the decode significance loop (not 8x8) of decode_residual() 5% faster decode_residual() on P3
michael
parents: 4035
diff changeset
691 static int decode_significance_x86(CABACContext *c, int max_coeff, uint8_t *significant_coeff_ctx_base, int *index){
53be304c7f54 x86 asm version of the decode significance loop (not 8x8) of decode_residual() 5% faster decode_residual() on P3
michael
parents: 4035
diff changeset
692 void *end= significant_coeff_ctx_base + max_coeff - 1;
53be304c7f54 x86 asm version of the decode significance loop (not 8x8) of decode_residual() 5% faster decode_residual() on P3
michael
parents: 4035
diff changeset
693 int minusstart= -(int)significant_coeff_ctx_base;
4049
8c1a5ed03a00 another instruction less in decode_significance_x86() -> 1% faster ion P3
michael
parents: 4048
diff changeset
694 int minusindex= 4-(int)index;
4037
53be304c7f54 x86 asm version of the decode significance loop (not 8x8) of decode_residual() 5% faster decode_residual() on P3
michael
parents: 4035
diff changeset
695 int coeff_count;
53be304c7f54 x86 asm version of the decode significance loop (not 8x8) of decode_residual() 5% faster decode_residual() on P3
michael
parents: 4035
diff changeset
696 asm volatile(
53be304c7f54 x86 asm version of the decode significance loop (not 8x8) of decode_residual() 5% faster decode_residual() on P3
michael
parents: 4035
diff changeset
697 "movl "RANGE "(%3), %%esi \n\t"
53be304c7f54 x86 asm version of the decode significance loop (not 8x8) of decode_residual() 5% faster decode_residual() on P3
michael
parents: 4035
diff changeset
698 "movl "LOW "(%3), %%ebx \n\t"
53be304c7f54 x86 asm version of the decode significance loop (not 8x8) of decode_residual() 5% faster decode_residual() on P3
michael
parents: 4035
diff changeset
699
53be304c7f54 x86 asm version of the decode significance loop (not 8x8) of decode_residual() 5% faster decode_residual() on P3
michael
parents: 4035
diff changeset
700 "2: \n\t"
53be304c7f54 x86 asm version of the decode significance loop (not 8x8) of decode_residual() 5% faster decode_residual() on P3
michael
parents: 4035
diff changeset
701
4047
61a4e7218a45 reordering instructions a little in decode_significance_x86() -> 2 instructions less / 1% faster decode_residual on P3
michael
parents: 4046
diff changeset
702 BRANCHLESS_GET_CABAC("%%edx", "%3", "(%1)", "%%ebx", "%%bx", "%%esi", "%%eax", "%%al")
4037
53be304c7f54 x86 asm version of the decode significance loop (not 8x8) of decode_residual() 5% faster decode_residual() on P3
michael
parents: 4035
diff changeset
703
4047
61a4e7218a45 reordering instructions a little in decode_significance_x86() -> 2 instructions less / 1% faster decode_residual on P3
michael
parents: 4046
diff changeset
704 "test $1, %%edx \n\t"
4037
53be304c7f54 x86 asm version of the decode significance loop (not 8x8) of decode_residual() 5% faster decode_residual() on P3
michael
parents: 4035
diff changeset
705 " jz 3f \n\t"
53be304c7f54 x86 asm version of the decode significance loop (not 8x8) of decode_residual() 5% faster decode_residual() on P3
michael
parents: 4035
diff changeset
706
4047
61a4e7218a45 reordering instructions a little in decode_significance_x86() -> 2 instructions less / 1% faster decode_residual on P3
michael
parents: 4046
diff changeset
707 BRANCHLESS_GET_CABAC("%%edx", "%3", "61(%1)", "%%ebx", "%%bx", "%%esi", "%%eax", "%%al")
61a4e7218a45 reordering instructions a little in decode_significance_x86() -> 2 instructions less / 1% faster decode_residual on P3
michael
parents: 4046
diff changeset
708
4064
d3afe4505951 CABAC assembler optimizations ported to AMD64
reimar
parents: 4051
diff changeset
709 "mov %2, %%"REG_a" \n\t"
4037
53be304c7f54 x86 asm version of the decode significance loop (not 8x8) of decode_residual() 5% faster decode_residual() on P3
michael
parents: 4035
diff changeset
710 "movl %4, %%ecx \n\t"
4064
d3afe4505951 CABAC assembler optimizations ported to AMD64
reimar
parents: 4051
diff changeset
711 "add %1, %%"REG_c" \n\t"
d3afe4505951 CABAC assembler optimizations ported to AMD64
reimar
parents: 4051
diff changeset
712 "movl %%ecx, (%%"REG_a") \n\t"
4037
53be304c7f54 x86 asm version of the decode significance loop (not 8x8) of decode_residual() 5% faster decode_residual() on P3
michael
parents: 4035
diff changeset
713
4047
61a4e7218a45 reordering instructions a little in decode_significance_x86() -> 2 instructions less / 1% faster decode_residual on P3
michael
parents: 4046
diff changeset
714 "test $1, %%edx \n\t"
4037
53be304c7f54 x86 asm version of the decode significance loop (not 8x8) of decode_residual() 5% faster decode_residual() on P3
michael
parents: 4035
diff changeset
715 " jnz 4f \n\t"
53be304c7f54 x86 asm version of the decode significance loop (not 8x8) of decode_residual() 5% faster decode_residual() on P3
michael
parents: 4035
diff changeset
716
4064
d3afe4505951 CABAC assembler optimizations ported to AMD64
reimar
parents: 4051
diff changeset
717 "add $4, %%"REG_a" \n\t"
d3afe4505951 CABAC assembler optimizations ported to AMD64
reimar
parents: 4051
diff changeset
718 "mov %%"REG_a", %2 \n\t"
4048
bf6791303fa0 1 instruction less
michael
parents: 4047
diff changeset
719
4037
53be304c7f54 x86 asm version of the decode significance loop (not 8x8) of decode_residual() 5% faster decode_residual() on P3
michael
parents: 4035
diff changeset
720 "3: \n\t"
4064
d3afe4505951 CABAC assembler optimizations ported to AMD64
reimar
parents: 4051
diff changeset
721 "add $1, %1 \n\t"
d3afe4505951 CABAC assembler optimizations ported to AMD64
reimar
parents: 4051
diff changeset
722 "cmp %5, %1 \n\t"
4037
53be304c7f54 x86 asm version of the decode significance loop (not 8x8) of decode_residual() 5% faster decode_residual() on P3
michael
parents: 4035
diff changeset
723 " jb 2b \n\t"
4064
d3afe4505951 CABAC assembler optimizations ported to AMD64
reimar
parents: 4051
diff changeset
724 "mov %2, %%"REG_a" \n\t"
4037
53be304c7f54 x86 asm version of the decode significance loop (not 8x8) of decode_residual() 5% faster decode_residual() on P3
michael
parents: 4035
diff changeset
725 "movl %4, %%ecx \n\t"
4064
d3afe4505951 CABAC assembler optimizations ported to AMD64
reimar
parents: 4051
diff changeset
726 "add %1, %%"REG_c" \n\t"
d3afe4505951 CABAC assembler optimizations ported to AMD64
reimar
parents: 4051
diff changeset
727 "movl %%ecx, (%%"REG_a") \n\t"
4037
53be304c7f54 x86 asm version of the decode significance loop (not 8x8) of decode_residual() 5% faster decode_residual() on P3
michael
parents: 4035
diff changeset
728 "4: \n\t"
4064
d3afe4505951 CABAC assembler optimizations ported to AMD64
reimar
parents: 4051
diff changeset
729 "add %6, %%eax \n\t"
4037
53be304c7f54 x86 asm version of the decode significance loop (not 8x8) of decode_residual() 5% faster decode_residual() on P3
michael
parents: 4035
diff changeset
730 "shr $2, %%eax \n\t"
53be304c7f54 x86 asm version of the decode significance loop (not 8x8) of decode_residual() 5% faster decode_residual() on P3
michael
parents: 4035
diff changeset
731
53be304c7f54 x86 asm version of the decode significance loop (not 8x8) of decode_residual() 5% faster decode_residual() on P3
michael
parents: 4035
diff changeset
732 "movl %%esi, "RANGE "(%3) \n\t"
53be304c7f54 x86 asm version of the decode significance loop (not 8x8) of decode_residual() 5% faster decode_residual() on P3
michael
parents: 4035
diff changeset
733 "movl %%ebx, "LOW "(%3) \n\t"
53be304c7f54 x86 asm version of the decode significance loop (not 8x8) of decode_residual() 5% faster decode_residual() on P3
michael
parents: 4035
diff changeset
734 :"=&a"(coeff_count), "+r"(significant_coeff_ctx_base), "+m"(index)\
53be304c7f54 x86 asm version of the decode significance loop (not 8x8) of decode_residual() 5% faster decode_residual() on P3
michael
parents: 4035
diff changeset
735 :"r"(c), "m"(minusstart), "m"(end), "m"(minusindex)\
4064
d3afe4505951 CABAC assembler optimizations ported to AMD64
reimar
parents: 4051
diff changeset
736 : "%"REG_c, "%ebx", "%edx", "%esi", "memory"\
4037
53be304c7f54 x86 asm version of the decode significance loop (not 8x8) of decode_residual() 5% faster decode_residual() on P3
michael
parents: 4035
diff changeset
737 );
53be304c7f54 x86 asm version of the decode significance loop (not 8x8) of decode_residual() 5% faster decode_residual() on P3
michael
parents: 4035
diff changeset
738 return coeff_count;
53be304c7f54 x86 asm version of the decode significance loop (not 8x8) of decode_residual() 5% faster decode_residual() on P3
michael
parents: 4035
diff changeset
739 }
4051
19f07b651d79 decode_significance_8x8_x86()
michael
parents: 4050
diff changeset
740
19f07b651d79 decode_significance_8x8_x86()
michael
parents: 4050
diff changeset
741 static int decode_significance_8x8_x86(CABACContext *c, uint8_t *significant_coeff_ctx_base, int *index, uint8_t *sig_off){
19f07b651d79 decode_significance_8x8_x86()
michael
parents: 4050
diff changeset
742 int minusindex= 4-(int)index;
19f07b651d79 decode_significance_8x8_x86()
michael
parents: 4050
diff changeset
743 int coeff_count;
4064
d3afe4505951 CABAC assembler optimizations ported to AMD64
reimar
parents: 4051
diff changeset
744 long last=0;
4051
19f07b651d79 decode_significance_8x8_x86()
michael
parents: 4050
diff changeset
745 asm volatile(
19f07b651d79 decode_significance_8x8_x86()
michael
parents: 4050
diff changeset
746 "movl "RANGE "(%3), %%esi \n\t"
19f07b651d79 decode_significance_8x8_x86()
michael
parents: 4050
diff changeset
747 "movl "LOW "(%3), %%ebx \n\t"
19f07b651d79 decode_significance_8x8_x86()
michael
parents: 4050
diff changeset
748
4064
d3afe4505951 CABAC assembler optimizations ported to AMD64
reimar
parents: 4051
diff changeset
749 "mov %1, %%"REG_D" \n\t"
4051
19f07b651d79 decode_significance_8x8_x86()
michael
parents: 4050
diff changeset
750 "2: \n\t"
19f07b651d79 decode_significance_8x8_x86()
michael
parents: 4050
diff changeset
751
4064
d3afe4505951 CABAC assembler optimizations ported to AMD64
reimar
parents: 4051
diff changeset
752 "mov %6, %%"REG_a" \n\t"
d3afe4505951 CABAC assembler optimizations ported to AMD64
reimar
parents: 4051
diff changeset
753 "movzbl (%%"REG_a", %%"REG_D"), %%edi \n\t"
d3afe4505951 CABAC assembler optimizations ported to AMD64
reimar
parents: 4051
diff changeset
754 "add %5, %%"REG_D" \n\t"
4051
19f07b651d79 decode_significance_8x8_x86()
michael
parents: 4050
diff changeset
755
4064
d3afe4505951 CABAC assembler optimizations ported to AMD64
reimar
parents: 4051
diff changeset
756 BRANCHLESS_GET_CABAC("%%edx", "%3", "(%%"REG_D")", "%%ebx", "%%bx", "%%esi", "%%eax", "%%al")
4051
19f07b651d79 decode_significance_8x8_x86()
michael
parents: 4050
diff changeset
757
19f07b651d79 decode_significance_8x8_x86()
michael
parents: 4050
diff changeset
758 "mov %1, %%edi \n\t"
19f07b651d79 decode_significance_8x8_x86()
michael
parents: 4050
diff changeset
759 "test $1, %%edx \n\t"
19f07b651d79 decode_significance_8x8_x86()
michael
parents: 4050
diff changeset
760 " jz 3f \n\t"
19f07b651d79 decode_significance_8x8_x86()
michael
parents: 4050
diff changeset
761
19f07b651d79 decode_significance_8x8_x86()
michael
parents: 4050
diff changeset
762 "movzbl "MANGLE(last_coeff_flag_offset_8x8)"(%%edi), %%edi\n\t"
4064
d3afe4505951 CABAC assembler optimizations ported to AMD64
reimar
parents: 4051
diff changeset
763 "add %5, %%"REG_D" \n\t"
4051
19f07b651d79 decode_significance_8x8_x86()
michael
parents: 4050
diff changeset
764
4064
d3afe4505951 CABAC assembler optimizations ported to AMD64
reimar
parents: 4051
diff changeset
765 BRANCHLESS_GET_CABAC("%%edx", "%3", "15(%%"REG_D")", "%%ebx", "%%bx", "%%esi", "%%eax", "%%al")
4051
19f07b651d79 decode_significance_8x8_x86()
michael
parents: 4050
diff changeset
766
4064
d3afe4505951 CABAC assembler optimizations ported to AMD64
reimar
parents: 4051
diff changeset
767 "mov %2, %%"REG_a" \n\t"
4051
19f07b651d79 decode_significance_8x8_x86()
michael
parents: 4050
diff changeset
768 "mov %1, %%edi \n\t"
4064
d3afe4505951 CABAC assembler optimizations ported to AMD64
reimar
parents: 4051
diff changeset
769 "movl %%edi, (%%"REG_a") \n\t"
4051
19f07b651d79 decode_significance_8x8_x86()
michael
parents: 4050
diff changeset
770
19f07b651d79 decode_significance_8x8_x86()
michael
parents: 4050
diff changeset
771 "test $1, %%edx \n\t"
19f07b651d79 decode_significance_8x8_x86()
michael
parents: 4050
diff changeset
772 " jnz 4f \n\t"
19f07b651d79 decode_significance_8x8_x86()
michael
parents: 4050
diff changeset
773
4064
d3afe4505951 CABAC assembler optimizations ported to AMD64
reimar
parents: 4051
diff changeset
774 "add $4, %%"REG_a" \n\t"
d3afe4505951 CABAC assembler optimizations ported to AMD64
reimar
parents: 4051
diff changeset
775 "mov %%"REG_a", %2 \n\t"
4051
19f07b651d79 decode_significance_8x8_x86()
michael
parents: 4050
diff changeset
776
19f07b651d79 decode_significance_8x8_x86()
michael
parents: 4050
diff changeset
777 "3: \n\t"
19f07b651d79 decode_significance_8x8_x86()
michael
parents: 4050
diff changeset
778 "addl $1, %%edi \n\t"
19f07b651d79 decode_significance_8x8_x86()
michael
parents: 4050
diff changeset
779 "mov %%edi, %1 \n\t"
19f07b651d79 decode_significance_8x8_x86()
michael
parents: 4050
diff changeset
780 "cmpl $63, %%edi \n\t"
19f07b651d79 decode_significance_8x8_x86()
michael
parents: 4050
diff changeset
781 " jb 2b \n\t"
4064
d3afe4505951 CABAC assembler optimizations ported to AMD64
reimar
parents: 4051
diff changeset
782 "mov %2, %%"REG_a" \n\t"
d3afe4505951 CABAC assembler optimizations ported to AMD64
reimar
parents: 4051
diff changeset
783 "movl %%edi, (%%"REG_a") \n\t"
4051
19f07b651d79 decode_significance_8x8_x86()
michael
parents: 4050
diff changeset
784 "4: \n\t"
19f07b651d79 decode_significance_8x8_x86()
michael
parents: 4050
diff changeset
785 "addl %4, %%eax \n\t"
19f07b651d79 decode_significance_8x8_x86()
michael
parents: 4050
diff changeset
786 "shr $2, %%eax \n\t"
19f07b651d79 decode_significance_8x8_x86()
michael
parents: 4050
diff changeset
787
19f07b651d79 decode_significance_8x8_x86()
michael
parents: 4050
diff changeset
788 "movl %%esi, "RANGE "(%3) \n\t"
19f07b651d79 decode_significance_8x8_x86()
michael
parents: 4050
diff changeset
789 "movl %%ebx, "LOW "(%3) \n\t"
19f07b651d79 decode_significance_8x8_x86()
michael
parents: 4050
diff changeset
790 :"=&a"(coeff_count),"+m"(last), "+m"(index)\
19f07b651d79 decode_significance_8x8_x86()
michael
parents: 4050
diff changeset
791 :"r"(c), "m"(minusindex), "m"(significant_coeff_ctx_base), "m"(sig_off)\
4064
d3afe4505951 CABAC assembler optimizations ported to AMD64
reimar
parents: 4051
diff changeset
792 : "%"REG_c, "%ebx", "%edx", "%esi", "%"REG_D, "memory"\
4051
19f07b651d79 decode_significance_8x8_x86()
michael
parents: 4050
diff changeset
793 );
19f07b651d79 decode_significance_8x8_x86()
michael
parents: 4050
diff changeset
794 return coeff_count;
19f07b651d79 decode_significance_8x8_x86()
michael
parents: 4050
diff changeset
795 }
5547
81226e690378 CONFIG_7REGS -> HAVE_7REGS
ramiro
parents: 5408
diff changeset
796 #endif /* defined(ARCH_X86) && && defined(HAVE_7REGS) && defined(HAVE_EBX_AVAILABLE) && !defined(BROKEN_RELOCATIONS) */
1287
michaelni
parents:
diff changeset
797
1300
e18667d1e94d FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv)
michaelni
parents: 1298
diff changeset
798 /**
e18667d1e94d FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv)
michaelni
parents: 1298
diff changeset
799 *
e18667d1e94d FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv)
michaelni
parents: 1298
diff changeset
800 * @return the number of bytes read or 0 if no end
e18667d1e94d FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv)
michaelni
parents: 1298
diff changeset
801 */
3928
987fffdf6ae7 don't try to inline cabac functions. gcc ignored the hint anyway, and forcing it would make h264 slower.
lorenm
parents: 3642
diff changeset
802 static int get_cabac_terminate(CABACContext *c){
4024
d550343b5dac shift CABACContext.range right, this reduces the number of shifts needed in get_cabac() and is slightly faster on P3 (and should be much faster on P4 as the P4 except the more recent variants lacks an integer shifter and so shifts have ~10 times longer latency then simple operations like adds)
michael
parents: 4014
diff changeset
803 c->range -= 2;
4345
88967250d718 replace a few hardcoded numbers with their correct named ones
michael
parents: 4283
diff changeset
804 if(c->low < c->range<<(CABAC_BITS+1)){
2323
1c39d9786efd optimization
michael
parents: 2116
diff changeset
805 renorm_cabac_decoder_once(c);
1287
michaelni
parents:
diff changeset
806 return 0;
michaelni
parents:
diff changeset
807 }else{
1300
e18667d1e94d FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv)
michaelni
parents: 1298
diff changeset
808 return c->bytestream - c->bytestream_start;
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2736
diff changeset
809 }
1287
michaelni
parents:
diff changeset
810 }
michaelni
parents:
diff changeset
811
5811
2926fc2a0396 Disable unused code; fixes several gcc warnings:
diego
parents: 5754
diff changeset
812 #if 0
1290
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
813 /**
5686
9ad4e94cc5b8 cosmetics: typo
diego
parents: 5547
diff changeset
814 * Get (truncated) unary binarization.
1290
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
815 */
3928
987fffdf6ae7 don't try to inline cabac functions. gcc ignored the hint anyway, and forcing it would make h264 slower.
lorenm
parents: 3642
diff changeset
816 static int get_cabac_u(CABACContext *c, uint8_t * state, int max, int max_index, int truncated){
1290
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
817 int i;
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2736
diff changeset
818
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2736
diff changeset
819 for(i=0; i<max; i++){
1290
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
820 if(get_cabac(c, state)==0)
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
821 return i;
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2736
diff changeset
822
1290
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
823 if(i< max_index) state++;
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
824 }
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
825
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
826 return truncated ? max : -1;
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
827 }
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
828
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
829 /**
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
830 * get unary exp golomb k-th order binarization.
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
831 */
3928
987fffdf6ae7 don't try to inline cabac functions. gcc ignored the hint anyway, and forcing it would make h264 slower.
lorenm
parents: 3642
diff changeset
832 static int get_cabac_ueg(CABACContext *c, uint8_t * state, int max, int is_signed, int k, int max_index){
1290
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
833 int i, v;
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
834 int m= 1<<k;
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2736
diff changeset
835
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2736
diff changeset
836 if(get_cabac(c, state)==0)
1290
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
837 return 0;
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2736
diff changeset
838
1290
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
839 if(0 < max_index) state++;
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2736
diff changeset
840
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2736
diff changeset
841 for(i=1; i<max; i++){
1290
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
842 if(get_cabac(c, state)==0){
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
843 if(is_signed && get_cabac_bypass(c)){
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
844 return -i;
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
845 }else
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
846 return i;
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
847 }
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
848
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
849 if(i < max_index) state++;
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
850 }
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2736
diff changeset
851
1290
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
852 while(get_cabac_bypass(c)){
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
853 i+= m;
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
854 m+= m;
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
855 }
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2736
diff changeset
856
1290
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
857 v=0;
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
858 while(m>>=1){
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
859 v+= v + get_cabac_bypass(c);
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
860 }
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
861 i += v;
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
862
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
863 if(is_signed && get_cabac_bypass(c)){
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
864 return -i;
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
865 }else
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
866 return i;
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
867 }
5811
2926fc2a0396 Disable unused code; fixes several gcc warnings:
diego
parents: 5754
diff changeset
868 #endif /* 0 */
4975
9a6a0818e93f split h264.c to move parser in its own file
aurel
parents: 4908
diff changeset
869
5830
1d83e9c34641 Add FFMPEG_ prefix to all multiple inclusion guards.
diego
parents: 5813
diff changeset
870 #endif /* FFMPEG_CABAC_H */