annotate cabac.c @ 11560:8a4984c5cacc libavcodec

Define AVMediaType enum, and use it instead of enum CodecType, which is deprecated and will be dropped at the next major bump.
author stefano
date Tue, 30 Mar 2010 23:30:55 +0000
parents 0dce4fe6e6f3
children 7dd2a45249a9
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: 3036
diff changeset
5 * This file is part of FFmpeg.
c8c591fe26f8 Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents: 3036
diff changeset
6 *
c8c591fe26f8 Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents: 3036
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: 3036
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: 3036
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: 3036
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 */
michaelni
parents:
diff changeset
21
michaelni
parents:
diff changeset
22 /**
8718
e9d9d946f213 Use full internal pathname in doxygen @file directives.
diego
parents: 6763
diff changeset
23 * @file libavcodec/cabac.c
1287
michaelni
parents:
diff changeset
24 * Context Adaptive Binary Arithmetic Coder.
michaelni
parents:
diff changeset
25 */
michaelni
parents:
diff changeset
26
michaelni
parents:
diff changeset
27 #include <string.h>
michaelni
parents:
diff changeset
28
6763
f7cbb7733146 Use full path for #includes from another directory.
diego
parents: 6171
diff changeset
29 #include "libavutil/common.h"
9428
0dce4fe6e6f3 Rename bitstream.h to get_bits.h.
stefano
parents: 9388
diff changeset
30 #include "get_bits.h"
1287
michaelni
parents:
diff changeset
31 #include "cabac.h"
michaelni
parents:
diff changeset
32
3991
72bae00a317f make lps_range a global table its constant anyway (saves 1 addition for accessing it)
michael
parents: 3984
diff changeset
33 static const uint8_t lps_range[64][4]= {
1287
michaelni
parents:
diff changeset
34 {128,176,208,240}, {128,167,197,227}, {128,158,187,216}, {123,150,178,205},
michaelni
parents:
diff changeset
35 {116,142,169,195}, {111,135,160,185}, {105,128,152,175}, {100,122,144,166},
michaelni
parents:
diff changeset
36 { 95,116,137,158}, { 90,110,130,150}, { 85,104,123,142}, { 81, 99,117,135},
michaelni
parents:
diff changeset
37 { 77, 94,111,128}, { 73, 89,105,122}, { 69, 85,100,116}, { 66, 80, 95,110},
michaelni
parents:
diff changeset
38 { 62, 76, 90,104}, { 59, 72, 86, 99}, { 56, 69, 81, 94}, { 53, 65, 77, 89},
michaelni
parents:
diff changeset
39 { 51, 62, 73, 85}, { 48, 59, 69, 80}, { 46, 56, 66, 76}, { 43, 53, 63, 72},
michaelni
parents:
diff changeset
40 { 41, 50, 59, 69}, { 39, 48, 56, 65}, { 37, 45, 54, 62}, { 35, 43, 51, 59},
michaelni
parents:
diff changeset
41 { 33, 41, 48, 56}, { 32, 39, 46, 53}, { 30, 37, 43, 50}, { 29, 35, 41, 48},
michaelni
parents:
diff changeset
42 { 27, 33, 39, 45}, { 26, 31, 37, 43}, { 24, 30, 35, 41}, { 23, 28, 33, 39},
michaelni
parents:
diff changeset
43 { 22, 27, 32, 37}, { 21, 26, 30, 35}, { 20, 24, 29, 33}, { 19, 23, 27, 31},
michaelni
parents:
diff changeset
44 { 18, 22, 26, 30}, { 17, 21, 25, 28}, { 16, 20, 23, 27}, { 15, 19, 22, 25},
michaelni
parents:
diff changeset
45 { 14, 18, 21, 24}, { 14, 17, 20, 23}, { 13, 16, 19, 22}, { 12, 15, 18, 21},
michaelni
parents:
diff changeset
46 { 12, 14, 17, 20}, { 11, 14, 16, 19}, { 11, 13, 15, 18}, { 10, 12, 15, 17},
michaelni
parents:
diff changeset
47 { 10, 12, 14, 16}, { 9, 11, 13, 15}, { 9, 11, 12, 14}, { 8, 10, 12, 14},
michaelni
parents:
diff changeset
48 { 8, 9, 11, 13}, { 7, 9, 11, 12}, { 7, 9, 10, 12}, { 7, 8, 10, 11},
michaelni
parents:
diff changeset
49 { 6, 8, 9, 11}, { 6, 7, 9, 10}, { 6, 7, 8, 9}, { 2, 2, 2, 2},
michaelni
parents:
diff changeset
50 };
michaelni
parents:
diff changeset
51
4014
b2582438effe dehack *ps_state indexing in the branchless decoder
michael
parents: 3993
diff changeset
52 uint8_t ff_h264_mlps_state[4*64];
4039
866a83726985 Kill a warning with MSVC
gpoirier
parents: 4024
diff changeset
53 uint8_t ff_h264_lps_range[4*2*64];
3993
8b7c59b7af01 make state transition tables global as they are constant and the code is slightly faster that way
michael
parents: 3991
diff changeset
54 uint8_t ff_h264_lps_state[2*64];
8b7c59b7af01 make state transition tables global as they are constant and the code is slightly faster that way
michael
parents: 3991
diff changeset
55 uint8_t ff_h264_mps_state[2*64];
3991
72bae00a317f make lps_range a global table its constant anyway (saves 1 addition for accessing it)
michael
parents: 3984
diff changeset
56
3993
8b7c59b7af01 make state transition tables global as they are constant and the code is slightly faster that way
michael
parents: 3991
diff changeset
57 static const uint8_t mps_state[64]= {
1287
michaelni
parents:
diff changeset
58 1, 2, 3, 4, 5, 6, 7, 8,
michaelni
parents:
diff changeset
59 9,10,11,12,13,14,15,16,
michaelni
parents:
diff changeset
60 17,18,19,20,21,22,23,24,
michaelni
parents:
diff changeset
61 25,26,27,28,29,30,31,32,
michaelni
parents:
diff changeset
62 33,34,35,36,37,38,39,40,
michaelni
parents:
diff changeset
63 41,42,43,44,45,46,47,48,
michaelni
parents:
diff changeset
64 49,50,51,52,53,54,55,56,
michaelni
parents:
diff changeset
65 57,58,59,60,61,62,62,63,
michaelni
parents:
diff changeset
66 };
michaelni
parents:
diff changeset
67
3993
8b7c59b7af01 make state transition tables global as they are constant and the code is slightly faster that way
michael
parents: 3991
diff changeset
68 static const uint8_t lps_state[64]= {
1287
michaelni
parents:
diff changeset
69 0, 0, 1, 2, 2, 4, 4, 5,
michaelni
parents:
diff changeset
70 6, 7, 8, 9, 9,11,11,12,
michaelni
parents:
diff changeset
71 13,13,15,15,16,16,18,18,
michaelni
parents:
diff changeset
72 19,19,21,21,22,22,23,24,
michaelni
parents:
diff changeset
73 24,25,26,26,27,27,28,29,
michaelni
parents:
diff changeset
74 29,30,30,30,31,32,32,33,
michaelni
parents:
diff changeset
75 33,33,34,34,35,35,35,36,
michaelni
parents:
diff changeset
76 36,36,37,37,37,38,38,63,
michaelni
parents:
diff changeset
77 };
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
78 #if 0
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
79 const uint8_t ff_h264_norm_shift_old[128]= {
3964
162bea01a5d4 decrease ff_h264_norm_shift[] size
michael
parents: 3956
diff changeset
80 7,6,5,5,4,4,4,4,3,3,3,3,3,3,3,3,
2323
1c39d9786efd optimization
michael
parents: 2116
diff changeset
81 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
1c39d9786efd optimization
michael
parents: 2116
diff changeset
82 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
1c39d9786efd optimization
michael
parents: 2116
diff changeset
83 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
3964
162bea01a5d4 decrease ff_h264_norm_shift[] size
michael
parents: 3956
diff changeset
84 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
162bea01a5d4 decrease ff_h264_norm_shift[] size
michael
parents: 3956
diff changeset
85 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
162bea01a5d4 decrease ff_h264_norm_shift[] size
michael
parents: 3956
diff changeset
86 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
162bea01a5d4 decrease ff_h264_norm_shift[] size
michael
parents: 3956
diff changeset
87 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
2323
1c39d9786efd optimization
michael
parents: 2116
diff changeset
88 };
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
89 #endif
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
90 const uint8_t ff_h264_norm_shift[512]= {
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
91 9,8,7,7,6,6,6,6,5,5,5,5,5,5,5,5,
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
92 4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,
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
93 3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,
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
94 3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,
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 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
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
96 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
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
97 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
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
98 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
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
99 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
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
100 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
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
101 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
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
102 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
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
103 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
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
104 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
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
105 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
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
106 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
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
107 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
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
108 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
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
109 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
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
110 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
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
111 };
2323
1c39d9786efd optimization
michael
parents: 2116
diff changeset
112
1287
michaelni
parents:
diff changeset
113 /**
michaelni
parents:
diff changeset
114 *
michaelni
parents:
diff changeset
115 * @param buf_size size of buf in bits
michaelni
parents:
diff changeset
116 */
michaelni
parents:
diff changeset
117 void ff_init_cabac_encoder(CABACContext *c, uint8_t *buf, int buf_size){
1522
79dddc5cd990 removed the obsolete and unused parameters of init_put_bits
alex
parents: 1300
diff changeset
118 init_put_bits(&c->pb, buf, buf_size);
1287
michaelni
parents:
diff changeset
119
michaelni
parents:
diff changeset
120 c->low= 0;
michaelni
parents:
diff changeset
121 c->range= 0x1FE;
michaelni
parents:
diff changeset
122 c->outstanding_count= 0;
michaelni
parents:
diff changeset
123 #ifdef STRICT_LIMITS
michaelni
parents:
diff changeset
124 c->sym_count =0;
michaelni
parents:
diff changeset
125 #endif
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2420
diff changeset
126
1287
michaelni
parents:
diff changeset
127 c->pb.bit_left++; //avoids firstBitFlag
michaelni
parents:
diff changeset
128 }
michaelni
parents:
diff changeset
129
michaelni
parents:
diff changeset
130 /**
michaelni
parents:
diff changeset
131 *
michaelni
parents:
diff changeset
132 * @param buf_size size of buf in bits
michaelni
parents:
diff changeset
133 */
2024
f65d87bfdd5a some of the warning fixes by (Michael Roitzsch <mroi at users dot sourceforge dot net>)
michael
parents: 1908
diff changeset
134 void ff_init_cabac_decoder(CABACContext *c, const uint8_t *buf, int buf_size){
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2420
diff changeset
135 c->bytestream_start=
1287
michaelni
parents:
diff changeset
136 c->bytestream= buf;
2116
48d9f86fb047 overread fix
michael
parents: 2024
diff changeset
137 c->bytestream_end= buf + buf_size;
1287
michaelni
parents:
diff changeset
138
2323
1c39d9786efd optimization
michael
parents: 2116
diff changeset
139 #if CABAC_BITS == 16
1c39d9786efd optimization
michael
parents: 2116
diff changeset
140 c->low = (*c->bytestream++)<<18;
1c39d9786efd optimization
michael
parents: 2116
diff changeset
141 c->low+= (*c->bytestream++)<<10;
1c39d9786efd optimization
michael
parents: 2116
diff changeset
142 #else
1c39d9786efd optimization
michael
parents: 2116
diff changeset
143 c->low = (*c->bytestream++)<<10;
1c39d9786efd optimization
michael
parents: 2116
diff changeset
144 #endif
1c39d9786efd optimization
michael
parents: 2116
diff changeset
145 c->low+= ((*c->bytestream++)<<2) + 2;
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
146 c->range= 0x1FE;
1287
michaelni
parents:
diff changeset
147 }
michaelni
parents:
diff changeset
148
3993
8b7c59b7af01 make state transition tables global as they are constant and the code is slightly faster that way
michael
parents: 3991
diff changeset
149 void ff_init_cabac_states(CABACContext *c){
1287
michaelni
parents:
diff changeset
150 int i, j;
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2420
diff changeset
151
3993
8b7c59b7af01 make state transition tables global as they are constant and the code is slightly faster that way
michael
parents: 3991
diff changeset
152 for(i=0; i<64; i++){
1287
michaelni
parents:
diff changeset
153 for(j=0; j<4; j++){ //FIXME check if this is worth the 1 shift we save
4039
866a83726985 Kill a warning with MSVC
gpoirier
parents: 4024
diff changeset
154 ff_h264_lps_range[j*2*64+2*i+0]=
866a83726985 Kill a warning with MSVC
gpoirier
parents: 4024
diff changeset
155 ff_h264_lps_range[j*2*64+2*i+1]= lps_range[i][j];
1287
michaelni
parents:
diff changeset
156 }
michaelni
parents:
diff changeset
157
4014
b2582438effe dehack *ps_state indexing in the branchless decoder
michael
parents: 3993
diff changeset
158 ff_h264_mlps_state[128+2*i+0]=
3993
8b7c59b7af01 make state transition tables global as they are constant and the code is slightly faster that way
michael
parents: 3991
diff changeset
159 ff_h264_mps_state[2*i+0]= 2*mps_state[i]+0;
4014
b2582438effe dehack *ps_state indexing in the branchless decoder
michael
parents: 3993
diff changeset
160 ff_h264_mlps_state[128+2*i+1]=
3993
8b7c59b7af01 make state transition tables global as they are constant and the code is slightly faster that way
michael
parents: 3991
diff changeset
161 ff_h264_mps_state[2*i+1]= 2*mps_state[i]+1;
1287
michaelni
parents:
diff changeset
162
1908
e20fd60b215c h264 - progressive I frame CABAC support patch by (Laurent Aimar <fenrir at via dot ecp dot fr>)
michael
parents: 1522
diff changeset
163 if( i ){
3984
bb186452e7da BRANCHLESS_CABAD --> BRANCHLESS_CABAC_DECODER
diego
parents: 3976
diff changeset
164 #ifdef BRANCHLESS_CABAC_DECODER
4014
b2582438effe dehack *ps_state indexing in the branchless decoder
michael
parents: 3993
diff changeset
165 ff_h264_mlps_state[128-2*i-1]= 2*lps_state[i]+0;
b2582438effe dehack *ps_state indexing in the branchless decoder
michael
parents: 3993
diff changeset
166 ff_h264_mlps_state[128-2*i-2]= 2*lps_state[i]+1;
3974
93746612bc78 optimize branchless C CABAC decoder
michael
parents: 3964
diff changeset
167 }else{
4014
b2582438effe dehack *ps_state indexing in the branchless decoder
michael
parents: 3993
diff changeset
168 ff_h264_mlps_state[128-2*i-1]= 1;
b2582438effe dehack *ps_state indexing in the branchless decoder
michael
parents: 3993
diff changeset
169 ff_h264_mlps_state[128-2*i-2]= 0;
3974
93746612bc78 optimize branchless C CABAC decoder
michael
parents: 3964
diff changeset
170 #else
3993
8b7c59b7af01 make state transition tables global as they are constant and the code is slightly faster that way
michael
parents: 3991
diff changeset
171 ff_h264_lps_state[2*i+0]= 2*lps_state[i]+0;
8b7c59b7af01 make state transition tables global as they are constant and the code is slightly faster that way
michael
parents: 3991
diff changeset
172 ff_h264_lps_state[2*i+1]= 2*lps_state[i]+1;
1287
michaelni
parents:
diff changeset
173 }else{
3993
8b7c59b7af01 make state transition tables global as they are constant and the code is slightly faster that way
michael
parents: 3991
diff changeset
174 ff_h264_lps_state[2*i+0]= 1;
8b7c59b7af01 make state transition tables global as they are constant and the code is slightly faster that way
michael
parents: 3991
diff changeset
175 ff_h264_lps_state[2*i+1]= 0;
3974
93746612bc78 optimize branchless C CABAC decoder
michael
parents: 3964
diff changeset
176 #endif
1287
michaelni
parents:
diff changeset
177 }
michaelni
parents:
diff changeset
178 }
michaelni
parents:
diff changeset
179 }
michaelni
parents:
diff changeset
180
6164
ecaf5226e9b0 Consistently use TEST as the preprocessor condition to enable test code.
diego
parents: 5934
diff changeset
181 #ifdef TEST
1287
michaelni
parents:
diff changeset
182 #define SIZE 10240
2420
842e5e7f3b7a fixing selftest
michael
parents: 2398
diff changeset
183
9199
ea0e5e9a520f Replace random() usage in test programs by av_lfg_*().
diego
parents: 8718
diff changeset
184 #include "libavutil/lfg.h"
2420
842e5e7f3b7a fixing selftest
michael
parents: 2398
diff changeset
185 #include "avcodec.h"
6171
1c0477262c72 Fix test program compilation: Add missing #include and update the call
diego
parents: 6164
diff changeset
186 #include "cabac.h"
2420
842e5e7f3b7a fixing selftest
michael
parents: 2398
diff changeset
187
5934
bd5f4dc81fbe main() --> main(void)
diego
parents: 5380
diff changeset
188 int main(void){
1287
michaelni
parents:
diff changeset
189 CABACContext c;
michaelni
parents:
diff changeset
190 uint8_t b[9*SIZE];
1290
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
191 uint8_t r[9*SIZE];
1287
michaelni
parents:
diff changeset
192 int i;
1290
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
193 uint8_t state[10]= {0};
9388
2313bf51945b cosmetics: Rename prn variable to prng (Pseudo Random Number Generator).
diego
parents: 9199
diff changeset
194 AVLFG prng;
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2420
diff changeset
195
9388
2313bf51945b cosmetics: Rename prn variable to prng (Pseudo Random Number Generator).
diego
parents: 9199
diff changeset
196 av_lfg_init(&prng, 1);
1287
michaelni
parents:
diff changeset
197 ff_init_cabac_encoder(&c, b, SIZE);
6171
1c0477262c72 Fix test program compilation: Add missing #include and update the call
diego
parents: 6164
diff changeset
198 ff_init_cabac_states(&c);
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2420
diff changeset
199
1287
michaelni
parents:
diff changeset
200 for(i=0; i<SIZE; i++){
9388
2313bf51945b cosmetics: Rename prn variable to prng (Pseudo Random Number Generator).
diego
parents: 9199
diff changeset
201 r[i] = av_lfg_get(&prng) % 7;
1287
michaelni
parents:
diff changeset
202 }
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2420
diff changeset
203
1287
michaelni
parents:
diff changeset
204 for(i=0; i<SIZE; i++){
michaelni
parents:
diff changeset
205 START_TIMER
1290
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
206 put_cabac_bypass(&c, r[i]&1);
1287
michaelni
parents:
diff changeset
207 STOP_TIMER("put_cabac_bypass")
michaelni
parents:
diff changeset
208 }
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2420
diff changeset
209
1287
michaelni
parents:
diff changeset
210 for(i=0; i<SIZE; i++){
michaelni
parents:
diff changeset
211 START_TIMER
1290
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
212 put_cabac(&c, state, r[i]&1);
1287
michaelni
parents:
diff changeset
213 STOP_TIMER("put_cabac")
michaelni
parents:
diff changeset
214 }
michaelni
parents:
diff changeset
215
1290
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
216 for(i=0; i<SIZE; i++){
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
217 START_TIMER
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
218 put_cabac_u(&c, state, r[i], 6, 3, i&1);
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
219 STOP_TIMER("put_cabac_u")
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2420
diff changeset
220 }
1290
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
221
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
222 for(i=0; i<SIZE; i++){
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
223 START_TIMER
1298
5bc3184810dc cleanup
michaelni
parents: 1290
diff changeset
224 put_cabac_ueg(&c, state, r[i], 3, 0, 1, 2);
1290
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
225 STOP_TIMER("put_cabac_ueg")
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2420
diff changeset
226 }
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2420
diff changeset
227
1287
michaelni
parents:
diff changeset
228 put_cabac_terminate(&c, 1);
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2420
diff changeset
229
1287
michaelni
parents:
diff changeset
230 ff_init_cabac_decoder(&c, b, SIZE);
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2420
diff changeset
231
1290
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
232 memset(state, 0, sizeof(state));
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2420
diff changeset
233
1287
michaelni
parents:
diff changeset
234 for(i=0; i<SIZE; i++){
michaelni
parents:
diff changeset
235 START_TIMER
1290
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
236 if( (r[i]&1) != get_cabac_bypass(&c) )
2420
842e5e7f3b7a fixing selftest
michael
parents: 2398
diff changeset
237 av_log(NULL, AV_LOG_ERROR, "CABAC bypass failure at %d\n", i);
1287
michaelni
parents:
diff changeset
238 STOP_TIMER("get_cabac_bypass")
michaelni
parents:
diff changeset
239 }
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2420
diff changeset
240
1287
michaelni
parents:
diff changeset
241 for(i=0; i<SIZE; i++){
michaelni
parents:
diff changeset
242 START_TIMER
1290
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
243 if( (r[i]&1) != get_cabac(&c, state) )
2420
842e5e7f3b7a fixing selftest
michael
parents: 2398
diff changeset
244 av_log(NULL, AV_LOG_ERROR, "CABAC failure at %d\n", i);
1287
michaelni
parents:
diff changeset
245 STOP_TIMER("get_cabac")
michaelni
parents:
diff changeset
246 }
2420
842e5e7f3b7a fixing selftest
michael
parents: 2398
diff changeset
247 #if 0
1290
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
248 for(i=0; i<SIZE; i++){
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
249 START_TIMER
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
250 if( r[i] != get_cabac_u(&c, state, (i&1) ? 6 : 7, 3, i&1) )
2420
842e5e7f3b7a fixing selftest
michael
parents: 2398
diff changeset
251 av_log(NULL, AV_LOG_ERROR, "CABAC unary (truncated) binarization failure at %d\n", i);
1290
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
252 STOP_TIMER("get_cabac_u")
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
253 }
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
254
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
255 for(i=0; i<SIZE; i++){
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
256 START_TIMER
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
257 if( r[i] != get_cabac_ueg(&c, state, 3, 0, 1, 2))
2420
842e5e7f3b7a fixing selftest
michael
parents: 2398
diff changeset
258 av_log(NULL, AV_LOG_ERROR, "CABAC unary (truncated) binarization failure at %d\n", i);
1290
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
259 STOP_TIMER("get_cabac_ueg")
dae280b939ca (truncated) unary binerization
michaelni
parents: 1287
diff changeset
260 }
2420
842e5e7f3b7a fixing selftest
michael
parents: 2398
diff changeset
261 #endif
1287
michaelni
parents:
diff changeset
262 if(!get_cabac_terminate(&c))
2420
842e5e7f3b7a fixing selftest
michael
parents: 2398
diff changeset
263 av_log(NULL, AV_LOG_ERROR, "where's the Terminator?\n");
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2420
diff changeset
264
1287
michaelni
parents:
diff changeset
265 return 0;
michaelni
parents:
diff changeset
266 }
michaelni
parents:
diff changeset
267
6164
ecaf5226e9b0 Consistently use TEST as the preprocessor condition to enable test code.
diego
parents: 5934
diff changeset
268 #endif /* TEST */