annotate bitstream.h @ 9408:e74131a0652d libavcodec

Document the 'size' parameter of set_put_bits_buffer_size().
author stefano
date Sat, 11 Apr 2009 21:04:26 +0000
parents 0129a71aae90
children 4cb7c65fc775
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
3699
c537a97eec66 Add official LGPL license headers to the files that were missing them.
diego
parents: 3675
diff changeset
1 /*
c537a97eec66 Add official LGPL license headers to the files that were missing them.
diego
parents: 3675
diff changeset
2 * copyright (c) 2004 Michael Niedermayer <michaelni@gmx.at>
c537a97eec66 Add official LGPL license headers to the files that were missing them.
diego
parents: 3675
diff changeset
3 *
3947
c8c591fe26f8 Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents: 3760
diff changeset
4 * This file is part of FFmpeg.
c8c591fe26f8 Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents: 3760
diff changeset
5 *
c8c591fe26f8 Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents: 3760
diff changeset
6 * FFmpeg is free software; you can redistribute it and/or
3699
c537a97eec66 Add official LGPL license headers to the files that were missing them.
diego
parents: 3675
diff changeset
7 * modify it under the terms of the GNU Lesser General Public
c537a97eec66 Add official LGPL license headers to the files that were missing them.
diego
parents: 3675
diff changeset
8 * 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: 3760
diff changeset
9 * version 2.1 of the License, or (at your option) any later version.
3699
c537a97eec66 Add official LGPL license headers to the files that were missing them.
diego
parents: 3675
diff changeset
10 *
3947
c8c591fe26f8 Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents: 3760
diff changeset
11 * FFmpeg is distributed in the hope that it will be useful,
3699
c537a97eec66 Add official LGPL license headers to the files that were missing them.
diego
parents: 3675
diff changeset
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
c537a97eec66 Add official LGPL license headers to the files that were missing them.
diego
parents: 3675
diff changeset
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
c537a97eec66 Add official LGPL license headers to the files that were missing them.
diego
parents: 3675
diff changeset
14 * Lesser General Public License for more details.
c537a97eec66 Add official LGPL license headers to the files that were missing them.
diego
parents: 3675
diff changeset
15 *
c537a97eec66 Add official LGPL license headers to the files that were missing them.
diego
parents: 3675
diff changeset
16 * 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: 3760
diff changeset
17 * License along with FFmpeg; if not, write to the Free Software
3699
c537a97eec66 Add official LGPL license headers to the files that were missing them.
diego
parents: 3675
diff changeset
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
c537a97eec66 Add official LGPL license headers to the files that were missing them.
diego
parents: 3675
diff changeset
19 */
c537a97eec66 Add official LGPL license headers to the files that were missing them.
diego
parents: 3675
diff changeset
20
1106
1e39f273ecd6 per file doxy
michaelni
parents: 1083
diff changeset
21 /**
8718
e9d9d946f213 Use full internal pathname in doxygen @file directives.
diego
parents: 8666
diff changeset
22 * @file libavcodec/bitstream.h
2398
582e635cfa08 common.c -> bitstream.c (and the single non bitstream func -> utils.c)
michael
parents: 2391
diff changeset
23 * bitstream api header.
1106
1e39f273ecd6 per file doxy
michaelni
parents: 1083
diff changeset
24 */
1e39f273ecd6 per file doxy
michaelni
parents: 1083
diff changeset
25
7760
c4a4495715dd Globally rename the header inclusion guard names.
stefano
parents: 7731
diff changeset
26 #ifndef AVCODEC_BITSTREAM_H
c4a4495715dd Globally rename the header inclusion guard names.
stefano
parents: 7731
diff changeset
27 #define AVCODEC_BITSTREAM_H
64
5aa6292a1660 win32 fixes
glantau
parents: 21
diff changeset
28
5162
4394344397d8 include all prerequisites in header files
mru
parents: 5127
diff changeset
29 #include <stdint.h>
4394344397d8 include all prerequisites in header files
mru
parents: 5127
diff changeset
30 #include <stdlib.h>
4394344397d8 include all prerequisites in header files
mru
parents: 5127
diff changeset
31 #include <assert.h>
6763
f7cbb7733146 Use full path for #includes from another directory.
diego
parents: 6325
diff changeset
32 #include "libavutil/bswap.h"
f7cbb7733146 Use full path for #includes from another directory.
diego
parents: 6325
diff changeset
33 #include "libavutil/common.h"
f7cbb7733146 Use full path for #includes from another directory.
diego
parents: 6325
diff changeset
34 #include "libavutil/intreadwrite.h"
f7cbb7733146 Use full path for #includes from another directory.
diego
parents: 6325
diff changeset
35 #include "libavutil/log.h"
9098
66f1dba43a01 Add a get_sbits_long() function.
jbr
parents: 9095
diff changeset
36 #include "mathops.h"
3648
c44d798b06b5 move some functions to bitstream.h to avoid conflicts
aurel
parents: 3638
diff changeset
37
3649
3335f51b6cd3 force usage of ALT_BITSTREAM_READER where needed
aurel
parents: 3648
diff changeset
38 #if defined(ALT_BITSTREAM_READER_LE) && !defined(ALT_BITSTREAM_READER)
5462
michael
parents: 5408
diff changeset
39 # define ALT_BITSTREAM_READER
3649
3335f51b6cd3 force usage of ALT_BITSTREAM_READER where needed
aurel
parents: 3648
diff changeset
40 #endif
3335f51b6cd3 force usage of ALT_BITSTREAM_READER where needed
aurel
parents: 3648
diff changeset
41
234
5fc0c3af3fe4 alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents: 213
diff changeset
42 //#define ALT_BITSTREAM_WRITER
235
41f0ef2cd942 aligned bitstream writer (1% slower on p3 but perhaps its faster on p4?)
michaelni
parents: 234
diff changeset
43 //#define ALIGNED_BITSTREAM_WRITER
3628
ce878aa023fe prevent bitstream reader to be overriden
michael
parents: 3454
diff changeset
44 #if !defined(LIBMPEG2_BITSTREAM_READER) && !defined(A32_BITSTREAM_READER) && !defined(ALT_BITSTREAM_READER)
8590
7a463923ecd1 Change semantic of CONFIG_*, HAVE_* and ARCH_*.
aurel
parents: 8498
diff changeset
45 # if ARCH_ARM
3650
a74c0aaf9832 use the A32_BITSTREAM_READER by default on ARM (faster)
aurel
parents: 3649
diff changeset
46 # define A32_BITSTREAM_READER
a74c0aaf9832 use the A32_BITSTREAM_READER by default on ARM (faster)
aurel
parents: 3649
diff changeset
47 # else
5462
michael
parents: 5408
diff changeset
48 # define ALT_BITSTREAM_READER
520
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
49 //#define LIBMPEG2_BITSTREAM_READER
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
50 //#define A32_BITSTREAM_READER
3650
a74c0aaf9832 use the A32_BITSTREAM_READER by default on ARM (faster)
aurel
parents: 3649
diff changeset
51 # endif
3628
ce878aa023fe prevent bitstream reader to be overriden
michael
parents: 3454
diff changeset
52 #endif
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2894
diff changeset
53
2578
91e094c9dcdc make reverse[] non static
michael
parents: 2502
diff changeset
54 extern const uint8_t ff_reverse[256];
91e094c9dcdc make reverse[] non static
michael
parents: 2502
diff changeset
55
8590
7a463923ecd1 Change semantic of CONFIG_*, HAVE_* and ARCH_*.
aurel
parents: 8498
diff changeset
56 #if ARCH_X86
525
985187bc2fa3 c std doesnt like negative shifts -> use asm
michaelni
parents: 522
diff changeset
57 // avoid +32 for shift optimization (gcc should do that ...)
985187bc2fa3 c std doesnt like negative shifts -> use asm
michaelni
parents: 522
diff changeset
58 static inline int32_t NEG_SSR32( int32_t a, int8_t s){
8031
eebc7209c47f Convert asm keyword into __asm__.
flameeyes
parents: 7760
diff changeset
59 __asm__ ("sarl %1, %0\n\t"
525
985187bc2fa3 c std doesnt like negative shifts -> use asm
michaelni
parents: 522
diff changeset
60 : "+r" (a)
985187bc2fa3 c std doesnt like negative shifts -> use asm
michaelni
parents: 522
diff changeset
61 : "ic" ((uint8_t)(-s))
985187bc2fa3 c std doesnt like negative shifts -> use asm
michaelni
parents: 522
diff changeset
62 );
985187bc2fa3 c std doesnt like negative shifts -> use asm
michaelni
parents: 522
diff changeset
63 return a;
985187bc2fa3 c std doesnt like negative shifts -> use asm
michaelni
parents: 522
diff changeset
64 }
985187bc2fa3 c std doesnt like negative shifts -> use asm
michaelni
parents: 522
diff changeset
65 static inline uint32_t NEG_USR32(uint32_t a, int8_t s){
8031
eebc7209c47f Convert asm keyword into __asm__.
flameeyes
parents: 7760
diff changeset
66 __asm__ ("shrl %1, %0\n\t"
525
985187bc2fa3 c std doesnt like negative shifts -> use asm
michaelni
parents: 522
diff changeset
67 : "+r" (a)
985187bc2fa3 c std doesnt like negative shifts -> use asm
michaelni
parents: 522
diff changeset
68 : "ic" ((uint8_t)(-s))
985187bc2fa3 c std doesnt like negative shifts -> use asm
michaelni
parents: 522
diff changeset
69 );
985187bc2fa3 c std doesnt like negative shifts -> use asm
michaelni
parents: 522
diff changeset
70 return a;
985187bc2fa3 c std doesnt like negative shifts -> use asm
michaelni
parents: 522
diff changeset
71 }
520
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
72 #else
708
1aa1cbb8c3c1 indenting preprocessor stuff, as its completly unreadable otherwise
michaelni
parents: 706
diff changeset
73 # define NEG_SSR32(a,s) ((( int32_t)(a))>>(32-(s)))
1aa1cbb8c3c1 indenting preprocessor stuff, as its completly unreadable otherwise
michaelni
parents: 706
diff changeset
74 # define NEG_USR32(a,s) (((uint32_t)(a))>>(32-(s)))
520
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
75 #endif
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
76
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
77 /* bit output */
986e461dc072 Initial revision
glantau
parents:
diff changeset
78
1895
e5687117cc7f * removing casualties of battle of the wits and English language
romansh
parents: 1886
diff changeset
79 /* buf and buf_end must be present and used by every alternative writer. */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
80 typedef struct PutBitContext {
234
5fc0c3af3fe4 alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents: 213
diff changeset
81 #ifdef ALT_BITSTREAM_WRITER
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
82 uint8_t *buf, *buf_end;
234
5fc0c3af3fe4 alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents: 213
diff changeset
83 int index;
5fc0c3af3fe4 alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents: 213
diff changeset
84 #else
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
85 uint32_t bit_buf;
238
99a9f903f0e3 optimized the normal bitstream writer, its faster than the alternative one on p3 now ... lets hope its at least not slower on p4 & k7
michaelni
parents: 235
diff changeset
86 int bit_left;
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
87 uint8_t *buf, *buf_ptr, *buf_end;
234
5fc0c3af3fe4 alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents: 213
diff changeset
88 #endif
8746
2c296d925b70 Add size_in_bits to PutBitContext
michael
parents: 8718
diff changeset
89 int size_in_bits;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
90 } PutBitContext;
986e461dc072 Initial revision
glantau
parents:
diff changeset
91
9389
0d7c2dee6b4d Doxygenate init_put_bits().
stefano
parents: 9320
diff changeset
92 /**
0d7c2dee6b4d Doxygenate init_put_bits().
stefano
parents: 9320
diff changeset
93 * Initializes the PutBitContext \p s.
0d7c2dee6b4d Doxygenate init_put_bits().
stefano
parents: 9320
diff changeset
94 *
0d7c2dee6b4d Doxygenate init_put_bits().
stefano
parents: 9320
diff changeset
95 * @param buffer the buffer where to put bits
0d7c2dee6b4d Doxygenate init_put_bits().
stefano
parents: 9320
diff changeset
96 * @param buffer_size the size in bytes of \p buffer
0d7c2dee6b4d Doxygenate init_put_bits().
stefano
parents: 9320
diff changeset
97 */
1875
45a1592dadca * moving some of the commonly used bit reading/writing functions
romansh
parents: 1845
diff changeset
98 static inline void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
45a1592dadca * moving some of the commonly used bit reading/writing functions
romansh
parents: 1845
diff changeset
99 {
2894
26f8974c3d66 fix some pointer to intger without cast warnings (patch by Michel Bardiaux)
aurel
parents: 2889
diff changeset
100 if(buffer_size < 0) {
26f8974c3d66 fix some pointer to intger without cast warnings (patch by Michel Bardiaux)
aurel
parents: 2889
diff changeset
101 buffer_size = 0;
26f8974c3d66 fix some pointer to intger without cast warnings (patch by Michel Bardiaux)
aurel
parents: 2889
diff changeset
102 buffer = NULL;
26f8974c3d66 fix some pointer to intger without cast warnings (patch by Michel Bardiaux)
aurel
parents: 2889
diff changeset
103 }
2889
64231191674b precautionary checks
michael
parents: 2885
diff changeset
104
8746
2c296d925b70 Add size_in_bits to PutBitContext
michael
parents: 8718
diff changeset
105 s->size_in_bits= 8*buffer_size;
1875
45a1592dadca * moving some of the commonly used bit reading/writing functions
romansh
parents: 1845
diff changeset
106 s->buf = buffer;
45a1592dadca * moving some of the commonly used bit reading/writing functions
romansh
parents: 1845
diff changeset
107 s->buf_end = s->buf + buffer_size;
45a1592dadca * moving some of the commonly used bit reading/writing functions
romansh
parents: 1845
diff changeset
108 #ifdef ALT_BITSTREAM_WRITER
45a1592dadca * moving some of the commonly used bit reading/writing functions
romansh
parents: 1845
diff changeset
109 s->index=0;
45a1592dadca * moving some of the commonly used bit reading/writing functions
romansh
parents: 1845
diff changeset
110 ((uint32_t*)(s->buf))[0]=0;
45a1592dadca * moving some of the commonly used bit reading/writing functions
romansh
parents: 1845
diff changeset
111 // memset(buffer, 0, buffer_size);
45a1592dadca * moving some of the commonly used bit reading/writing functions
romansh
parents: 1845
diff changeset
112 #else
45a1592dadca * moving some of the commonly used bit reading/writing functions
romansh
parents: 1845
diff changeset
113 s->buf_ptr = s->buf;
45a1592dadca * moving some of the commonly used bit reading/writing functions
romansh
parents: 1845
diff changeset
114 s->bit_left=32;
45a1592dadca * moving some of the commonly used bit reading/writing functions
romansh
parents: 1845
diff changeset
115 s->bit_buf=0;
45a1592dadca * moving some of the commonly used bit reading/writing functions
romansh
parents: 1845
diff changeset
116 #endif
45a1592dadca * moving some of the commonly used bit reading/writing functions
romansh
parents: 1845
diff changeset
117 }
45a1592dadca * moving some of the commonly used bit reading/writing functions
romansh
parents: 1845
diff changeset
118
9390
79651ce180f2 Doxygenate put_bits_count() documentation.
stefano
parents: 9389
diff changeset
119 /**
9395
14e8350b27b4 Clarify documentation for put_bits_count().
stefano
parents: 9392
diff changeset
120 * Returns the total number of bits written to the bitstream.
9390
79651ce180f2 Doxygenate put_bits_count() documentation.
stefano
parents: 9389
diff changeset
121 */
1875
45a1592dadca * moving some of the commonly used bit reading/writing functions
romansh
parents: 1845
diff changeset
122 static inline int put_bits_count(PutBitContext *s)
45a1592dadca * moving some of the commonly used bit reading/writing functions
romansh
parents: 1845
diff changeset
123 {
45a1592dadca * moving some of the commonly used bit reading/writing functions
romansh
parents: 1845
diff changeset
124 #ifdef ALT_BITSTREAM_WRITER
45a1592dadca * moving some of the commonly used bit reading/writing functions
romansh
parents: 1845
diff changeset
125 return s->index;
45a1592dadca * moving some of the commonly used bit reading/writing functions
romansh
parents: 1845
diff changeset
126 #else
45a1592dadca * moving some of the commonly used bit reading/writing functions
romansh
parents: 1845
diff changeset
127 return (s->buf_ptr - s->buf) * 8 + 32 - s->bit_left;
45a1592dadca * moving some of the commonly used bit reading/writing functions
romansh
parents: 1845
diff changeset
128 #endif
45a1592dadca * moving some of the commonly used bit reading/writing functions
romansh
parents: 1845
diff changeset
129 }
234
5fc0c3af3fe4 alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents: 213
diff changeset
130
9391
e9c4b9d95da2 Doxygenate flush_put_bits() documentation.
stefano
parents: 9390
diff changeset
131 /**
e9c4b9d95da2 Doxygenate flush_put_bits() documentation.
stefano
parents: 9390
diff changeset
132 * Pads the end of the output stream with zeros.
e9c4b9d95da2 Doxygenate flush_put_bits() documentation.
stefano
parents: 9390
diff changeset
133 */
1875
45a1592dadca * moving some of the commonly used bit reading/writing functions
romansh
parents: 1845
diff changeset
134 static inline void flush_put_bits(PutBitContext *s)
45a1592dadca * moving some of the commonly used bit reading/writing functions
romansh
parents: 1845
diff changeset
135 {
45a1592dadca * moving some of the commonly used bit reading/writing functions
romansh
parents: 1845
diff changeset
136 #ifdef ALT_BITSTREAM_WRITER
45a1592dadca * moving some of the commonly used bit reading/writing functions
romansh
parents: 1845
diff changeset
137 align_put_bits(s);
45a1592dadca * moving some of the commonly used bit reading/writing functions
romansh
parents: 1845
diff changeset
138 #else
7690
9445f9c69004 Little-endian bitstream writer
bwolowiec
parents: 7279
diff changeset
139 #ifndef BITSTREAM_WRITER_LE
1875
45a1592dadca * moving some of the commonly used bit reading/writing functions
romansh
parents: 1845
diff changeset
140 s->bit_buf<<= s->bit_left;
7690
9445f9c69004 Little-endian bitstream writer
bwolowiec
parents: 7279
diff changeset
141 #endif
1875
45a1592dadca * moving some of the commonly used bit reading/writing functions
romansh
parents: 1845
diff changeset
142 while (s->bit_left < 32) {
45a1592dadca * moving some of the commonly used bit reading/writing functions
romansh
parents: 1845
diff changeset
143 /* XXX: should test end of buffer */
7690
9445f9c69004 Little-endian bitstream writer
bwolowiec
parents: 7279
diff changeset
144 #ifdef BITSTREAM_WRITER_LE
9445f9c69004 Little-endian bitstream writer
bwolowiec
parents: 7279
diff changeset
145 *s->buf_ptr++=s->bit_buf;
9445f9c69004 Little-endian bitstream writer
bwolowiec
parents: 7279
diff changeset
146 s->bit_buf>>=8;
9445f9c69004 Little-endian bitstream writer
bwolowiec
parents: 7279
diff changeset
147 #else
1875
45a1592dadca * moving some of the commonly used bit reading/writing functions
romansh
parents: 1845
diff changeset
148 *s->buf_ptr++=s->bit_buf >> 24;
45a1592dadca * moving some of the commonly used bit reading/writing functions
romansh
parents: 1845
diff changeset
149 s->bit_buf<<=8;
7690
9445f9c69004 Little-endian bitstream writer
bwolowiec
parents: 7279
diff changeset
150 #endif
1875
45a1592dadca * moving some of the commonly used bit reading/writing functions
romansh
parents: 1845
diff changeset
151 s->bit_left+=8;
45a1592dadca * moving some of the commonly used bit reading/writing functions
romansh
parents: 1845
diff changeset
152 }
45a1592dadca * moving some of the commonly used bit reading/writing functions
romansh
parents: 1845
diff changeset
153 s->bit_left=32;
45a1592dadca * moving some of the commonly used bit reading/writing functions
romansh
parents: 1845
diff changeset
154 s->bit_buf=0;
45a1592dadca * moving some of the commonly used bit reading/writing functions
romansh
parents: 1845
diff changeset
155 #endif
45a1592dadca * moving some of the commonly used bit reading/writing functions
romansh
parents: 1845
diff changeset
156 }
45a1592dadca * moving some of the commonly used bit reading/writing functions
romansh
parents: 1845
diff changeset
157
9392
a5bc2084bd6a Document align_put_bits().
stefano
parents: 9391
diff changeset
158 /**
a5bc2084bd6a Document align_put_bits().
stefano
parents: 9391
diff changeset
159 * Pads the bitstream with zeros up to the next byte boundary.
a5bc2084bd6a Document align_put_bits().
stefano
parents: 9391
diff changeset
160 */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
161 void align_put_bits(PutBitContext *s);
9407
0129a71aae90 Document ff_put_string().
stefano
parents: 9405
diff changeset
162
0129a71aae90 Document ff_put_string().
stefano
parents: 9405
diff changeset
163 /**
0129a71aae90 Document ff_put_string().
stefano
parents: 9405
diff changeset
164 * Puts the string \p s in the bitstream.
0129a71aae90 Document ff_put_string().
stefano
parents: 9405
diff changeset
165 *
0129a71aae90 Document ff_put_string().
stefano
parents: 9405
diff changeset
166 * @param terminate_string 0-terminates the written string if value is 1
0129a71aae90 Document ff_put_string().
stefano
parents: 9405
diff changeset
167 */
9405
9fc81340a5a8 Rename the 'put_zero' parameter of ff_put_string() to
stefano
parents: 9404
diff changeset
168 void ff_put_string(PutBitContext * pbc, const char *s, int terminate_string);
9403
12fe11381b21 Doxygenate ff_copy_bits().
stefano
parents: 9402
diff changeset
169
12fe11381b21 Doxygenate ff_copy_bits().
stefano
parents: 9402
diff changeset
170 /**
12fe11381b21 Doxygenate ff_copy_bits().
stefano
parents: 9402
diff changeset
171 * Copies the content of \p src to the bitstream.
12fe11381b21 Doxygenate ff_copy_bits().
stefano
parents: 9402
diff changeset
172 *
12fe11381b21 Doxygenate ff_copy_bits().
stefano
parents: 9402
diff changeset
173 * @param length the number of bits of \p src to copy
12fe11381b21 Doxygenate ff_copy_bits().
stefano
parents: 9402
diff changeset
174 */
6325
michael
parents: 6099
diff changeset
175 void ff_copy_bits(PutBitContext *pb, const uint8_t *src, int length);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
176
986e461dc072 Initial revision
glantau
parents:
diff changeset
177 /* bit input */
1895
e5687117cc7f * removing casualties of battle of the wits and English language
romansh
parents: 1886
diff changeset
178 /* buffer, buffer_end and size_in_bits must be present and used by every reader */
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
179 typedef struct GetBitContext {
1083
b923be2fc4b5 * using const buffers for reading
kabi
parents: 1079
diff changeset
180 const uint8_t *buffer, *buffer_end;
192
1e5f64be86fc another bitstream reader code (faster on intel cpus) - patch by Michael Niedermayer <michaelni@gmx.at>
uid46427
parents: 151
diff changeset
181 #ifdef ALT_BITSTREAM_READER
1e5f64be86fc another bitstream reader code (faster on intel cpus) - patch by Michael Niedermayer <michaelni@gmx.at>
uid46427
parents: 151
diff changeset
182 int index;
520
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
183 #elif defined LIBMPEG2_BITSTREAM_READER
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
184 uint8_t *buffer_ptr;
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
185 uint32_t cache;
520
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
186 int bit_count;
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
187 #elif defined A32_BITSTREAM_READER
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
188 uint32_t *buffer_ptr;
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
189 uint32_t cache0;
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
190 uint32_t cache1;
520
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
191 int bit_count;
192
1e5f64be86fc another bitstream reader code (faster on intel cpus) - patch by Michael Niedermayer <michaelni@gmx.at>
uid46427
parents: 151
diff changeset
192 #endif
1025
1f9afd8b9131 GetBitContext.size is allways multiplied by 8 -> use size_in_bits to avoid useless *8 in a few inner loops
michaelni
parents: 994
diff changeset
193 int size_in_bits;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
194 } GetBitContext;
986e461dc072 Initial revision
glantau
parents:
diff changeset
195
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
196 #define VLC_TYPE int16_t
520
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
197
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
198 typedef struct VLC {
986e461dc072 Initial revision
glantau
parents:
diff changeset
199 int bits;
1112
54be6aece1be more cosmetics so that doxygen output is readable ...
michaelni
parents: 1106
diff changeset
200 VLC_TYPE (*table)[2]; ///< code, bits
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
201 int table_size, table_allocated;
986e461dc072 Initial revision
glantau
parents:
diff changeset
202 } VLC;
986e461dc072 Initial revision
glantau
parents:
diff changeset
203
542
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 535
diff changeset
204 typedef struct RL_VLC_ELEM {
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 535
diff changeset
205 int16_t level;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 535
diff changeset
206 int8_t len;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 535
diff changeset
207 uint8_t run;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 535
diff changeset
208 } RL_VLC_ELEM;
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 535
diff changeset
209
9402
9a1c34f662e4 Factorize declaration for the two variants of put_bits().
stefano
parents: 9395
diff changeset
210 static inline void put_bits(PutBitContext *s, int n, unsigned int value)
238
99a9f903f0e3 optimized the normal bitstream writer, its faster than the alternative one on p3 now ... lets hope its at least not slower on p4 & k7
michaelni
parents: 235
diff changeset
211 #ifndef ALT_BITSTREAM_WRITER
99a9f903f0e3 optimized the normal bitstream writer, its faster than the alternative one on p3 now ... lets hope its at least not slower on p4 & k7
michaelni
parents: 235
diff changeset
212 {
99a9f903f0e3 optimized the normal bitstream writer, its faster than the alternative one on p3 now ... lets hope its at least not slower on p4 & k7
michaelni
parents: 235
diff changeset
213 unsigned int bit_buf;
99a9f903f0e3 optimized the normal bitstream writer, its faster than the alternative one on p3 now ... lets hope its at least not slower on p4 & k7
michaelni
parents: 235
diff changeset
214 int bit_left;
99a9f903f0e3 optimized the normal bitstream writer, its faster than the alternative one on p3 now ... lets hope its at least not slower on p4 & k7
michaelni
parents: 235
diff changeset
215
99a9f903f0e3 optimized the normal bitstream writer, its faster than the alternative one on p3 now ... lets hope its at least not slower on p4 & k7
michaelni
parents: 235
diff changeset
216 // printf("put_bits=%d %x\n", n, value);
99a9f903f0e3 optimized the normal bitstream writer, its faster than the alternative one on p3 now ... lets hope its at least not slower on p4 & k7
michaelni
parents: 235
diff changeset
217 assert(n == 32 || value < (1U << n));
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2894
diff changeset
218
238
99a9f903f0e3 optimized the normal bitstream writer, its faster than the alternative one on p3 now ... lets hope its at least not slower on p4 & k7
michaelni
parents: 235
diff changeset
219 bit_buf = s->bit_buf;
99a9f903f0e3 optimized the normal bitstream writer, its faster than the alternative one on p3 now ... lets hope its at least not slower on p4 & k7
michaelni
parents: 235
diff changeset
220 bit_left = s->bit_left;
99a9f903f0e3 optimized the normal bitstream writer, its faster than the alternative one on p3 now ... lets hope its at least not slower on p4 & k7
michaelni
parents: 235
diff changeset
221
99a9f903f0e3 optimized the normal bitstream writer, its faster than the alternative one on p3 now ... lets hope its at least not slower on p4 & k7
michaelni
parents: 235
diff changeset
222 // printf("n=%d value=%x cnt=%d buf=%x\n", n, value, bit_cnt, bit_buf);
99a9f903f0e3 optimized the normal bitstream writer, its faster than the alternative one on p3 now ... lets hope its at least not slower on p4 & k7
michaelni
parents: 235
diff changeset
223 /* XXX: optimize */
7690
9445f9c69004 Little-endian bitstream writer
bwolowiec
parents: 7279
diff changeset
224 #ifdef BITSTREAM_WRITER_LE
9445f9c69004 Little-endian bitstream writer
bwolowiec
parents: 7279
diff changeset
225 bit_buf |= value << (32 - bit_left);
9445f9c69004 Little-endian bitstream writer
bwolowiec
parents: 7279
diff changeset
226 if (n >= bit_left) {
8590
7a463923ecd1 Change semantic of CONFIG_*, HAVE_* and ARCH_*.
aurel
parents: 8498
diff changeset
227 #if !HAVE_FAST_UNALIGNED
7690
9445f9c69004 Little-endian bitstream writer
bwolowiec
parents: 7279
diff changeset
228 if (3 & (intptr_t) s->buf_ptr) {
8666
e013ec85260b Use AV_WL32/AV_WB32 in bitstream.h
reimar
parents: 8590
diff changeset
229 AV_WL32(s->buf_ptr, bit_buf);
7690
9445f9c69004 Little-endian bitstream writer
bwolowiec
parents: 7279
diff changeset
230 } else
9445f9c69004 Little-endian bitstream writer
bwolowiec
parents: 7279
diff changeset
231 #endif
9445f9c69004 Little-endian bitstream writer
bwolowiec
parents: 7279
diff changeset
232 *(uint32_t *)s->buf_ptr = le2me_32(bit_buf);
9445f9c69004 Little-endian bitstream writer
bwolowiec
parents: 7279
diff changeset
233 s->buf_ptr+=4;
9445f9c69004 Little-endian bitstream writer
bwolowiec
parents: 7279
diff changeset
234 bit_buf = (bit_left==32)?0:value >> bit_left;
9445f9c69004 Little-endian bitstream writer
bwolowiec
parents: 7279
diff changeset
235 bit_left+=32;
9445f9c69004 Little-endian bitstream writer
bwolowiec
parents: 7279
diff changeset
236 }
9445f9c69004 Little-endian bitstream writer
bwolowiec
parents: 7279
diff changeset
237 bit_left-=n;
9445f9c69004 Little-endian bitstream writer
bwolowiec
parents: 7279
diff changeset
238 #else
238
99a9f903f0e3 optimized the normal bitstream writer, its faster than the alternative one on p3 now ... lets hope its at least not slower on p4 & k7
michaelni
parents: 235
diff changeset
239 if (n < bit_left) {
99a9f903f0e3 optimized the normal bitstream writer, its faster than the alternative one on p3 now ... lets hope its at least not slower on p4 & k7
michaelni
parents: 235
diff changeset
240 bit_buf = (bit_buf<<n) | value;
99a9f903f0e3 optimized the normal bitstream writer, its faster than the alternative one on p3 now ... lets hope its at least not slower on p4 & k7
michaelni
parents: 235
diff changeset
241 bit_left-=n;
99a9f903f0e3 optimized the normal bitstream writer, its faster than the alternative one on p3 now ... lets hope its at least not slower on p4 & k7
michaelni
parents: 235
diff changeset
242 } else {
2979
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
243 bit_buf<<=bit_left;
238
99a9f903f0e3 optimized the normal bitstream writer, its faster than the alternative one on p3 now ... lets hope its at least not slower on p4 & k7
michaelni
parents: 235
diff changeset
244 bit_buf |= value >> (n - bit_left);
8590
7a463923ecd1 Change semantic of CONFIG_*, HAVE_* and ARCH_*.
aurel
parents: 8498
diff changeset
245 #if !HAVE_FAST_UNALIGNED
1965
f74f306c30b5 vis detection patch by (James Morrison <ja2morri at csclub dot uwaterloo dot ca>)
michael
parents: 1964
diff changeset
246 if (3 & (intptr_t) s->buf_ptr) {
8666
e013ec85260b Use AV_WL32/AV_WB32 in bitstream.h
reimar
parents: 8590
diff changeset
247 AV_WB32(s->buf_ptr, bit_buf);
891
d3fc77a6d57e Add some rudimentary support for sparc64
philipjsg
parents: 880
diff changeset
248 } else
d3fc77a6d57e Add some rudimentary support for sparc64
philipjsg
parents: 880
diff changeset
249 #endif
1064
b32afefe7d33 * UINTX -> uintx_t INTX -> intx_t
kabi
parents: 1059
diff changeset
250 *(uint32_t *)s->buf_ptr = be2me_32(bit_buf);
238
99a9f903f0e3 optimized the normal bitstream writer, its faster than the alternative one on p3 now ... lets hope its at least not slower on p4 & k7
michaelni
parents: 235
diff changeset
251 //printf("bitbuf = %08x\n", bit_buf);
99a9f903f0e3 optimized the normal bitstream writer, its faster than the alternative one on p3 now ... lets hope its at least not slower on p4 & k7
michaelni
parents: 235
diff changeset
252 s->buf_ptr+=4;
2979
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
253 bit_left+=32 - n;
238
99a9f903f0e3 optimized the normal bitstream writer, its faster than the alternative one on p3 now ... lets hope its at least not slower on p4 & k7
michaelni
parents: 235
diff changeset
254 bit_buf = value;
99a9f903f0e3 optimized the normal bitstream writer, its faster than the alternative one on p3 now ... lets hope its at least not slower on p4 & k7
michaelni
parents: 235
diff changeset
255 }
7690
9445f9c69004 Little-endian bitstream writer
bwolowiec
parents: 7279
diff changeset
256 #endif
238
99a9f903f0e3 optimized the normal bitstream writer, its faster than the alternative one on p3 now ... lets hope its at least not slower on p4 & k7
michaelni
parents: 235
diff changeset
257
99a9f903f0e3 optimized the normal bitstream writer, its faster than the alternative one on p3 now ... lets hope its at least not slower on p4 & k7
michaelni
parents: 235
diff changeset
258 s->bit_buf = bit_buf;
99a9f903f0e3 optimized the normal bitstream writer, its faster than the alternative one on p3 now ... lets hope its at least not slower on p4 & k7
michaelni
parents: 235
diff changeset
259 s->bit_left = bit_left;
99a9f903f0e3 optimized the normal bitstream writer, its faster than the alternative one on p3 now ... lets hope its at least not slower on p4 & k7
michaelni
parents: 235
diff changeset
260 }
9402
9a1c34f662e4 Factorize declaration for the two variants of put_bits().
stefano
parents: 9395
diff changeset
261 #else /* ALT_BITSTREAM_WRITER defined */
234
5fc0c3af3fe4 alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents: 213
diff changeset
262 {
708
1aa1cbb8c3c1 indenting preprocessor stuff, as its completly unreadable otherwise
michaelni
parents: 706
diff changeset
263 # ifdef ALIGNED_BITSTREAM_WRITER
8590
7a463923ecd1 Change semantic of CONFIG_*, HAVE_* and ARCH_*.
aurel
parents: 8498
diff changeset
264 # if ARCH_X86
8031
eebc7209c47f Convert asm keyword into __asm__.
flameeyes
parents: 7760
diff changeset
265 __asm__ volatile(
2979
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
266 "movl %0, %%ecx \n\t"
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
267 "xorl %%eax, %%eax \n\t"
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
268 "shrdl %%cl, %1, %%eax \n\t"
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
269 "shrl %%cl, %1 \n\t"
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
270 "movl %0, %%ecx \n\t"
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
271 "shrl $3, %%ecx \n\t"
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
272 "andl $0xFFFFFFFC, %%ecx \n\t"
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
273 "bswapl %1 \n\t"
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
274 "orl %1, (%2, %%ecx) \n\t"
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
275 "bswapl %%eax \n\t"
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
276 "addl %3, %0 \n\t"
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
277 "movl %%eax, 4(%2, %%ecx) \n\t"
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
278 : "=&r" (s->index), "=&r" (value)
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
279 : "r" (s->buf), "r" (n), "0" (s->index), "1" (value<<(-n))
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
280 : "%eax", "%ecx"
235
41f0ef2cd942 aligned bitstream writer (1% slower on p3 but perhaps its faster on p4?)
michaelni
parents: 234
diff changeset
281 );
708
1aa1cbb8c3c1 indenting preprocessor stuff, as its completly unreadable otherwise
michaelni
parents: 706
diff changeset
282 # else
235
41f0ef2cd942 aligned bitstream writer (1% slower on p3 but perhaps its faster on p4?)
michaelni
parents: 234
diff changeset
283 int index= s->index;
41f0ef2cd942 aligned bitstream writer (1% slower on p3 but perhaps its faster on p4?)
michaelni
parents: 234
diff changeset
284 uint32_t *ptr= ((uint32_t *)s->buf)+(index>>5);
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2894
diff changeset
285
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2894
diff changeset
286 value<<= 32-n;
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2894
diff changeset
287
235
41f0ef2cd942 aligned bitstream writer (1% slower on p3 but perhaps its faster on p4?)
michaelni
parents: 234
diff changeset
288 ptr[0] |= be2me_32(value>>(index&31));
41f0ef2cd942 aligned bitstream writer (1% slower on p3 but perhaps its faster on p4?)
michaelni
parents: 234
diff changeset
289 ptr[1] = be2me_32(value<<(32-(index&31)));
41f0ef2cd942 aligned bitstream writer (1% slower on p3 but perhaps its faster on p4?)
michaelni
parents: 234
diff changeset
290 //if(n>24) printf("%d %d\n", n, value);
41f0ef2cd942 aligned bitstream writer (1% slower on p3 but perhaps its faster on p4?)
michaelni
parents: 234
diff changeset
291 index+= n;
41f0ef2cd942 aligned bitstream writer (1% slower on p3 but perhaps its faster on p4?)
michaelni
parents: 234
diff changeset
292 s->index= index;
708
1aa1cbb8c3c1 indenting preprocessor stuff, as its completly unreadable otherwise
michaelni
parents: 706
diff changeset
293 # endif
1aa1cbb8c3c1 indenting preprocessor stuff, as its completly unreadable otherwise
michaelni
parents: 706
diff changeset
294 # else //ALIGNED_BITSTREAM_WRITER
8590
7a463923ecd1 Change semantic of CONFIG_*, HAVE_* and ARCH_*.
aurel
parents: 8498
diff changeset
295 # if ARCH_X86
8031
eebc7209c47f Convert asm keyword into __asm__.
flameeyes
parents: 7760
diff changeset
296 __asm__ volatile(
2979
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
297 "movl $7, %%ecx \n\t"
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
298 "andl %0, %%ecx \n\t"
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
299 "addl %3, %%ecx \n\t"
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
300 "negl %%ecx \n\t"
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
301 "shll %%cl, %1 \n\t"
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
302 "bswapl %1 \n\t"
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
303 "movl %0, %%ecx \n\t"
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
304 "shrl $3, %%ecx \n\t"
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
305 "orl %1, (%%ecx, %2) \n\t"
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
306 "addl %3, %0 \n\t"
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
307 "movl $0, 4(%%ecx, %2) \n\t"
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
308 : "=&r" (s->index), "=&r" (value)
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
309 : "r" (s->buf), "r" (n), "0" (s->index), "1" (value)
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
310 : "%ecx"
234
5fc0c3af3fe4 alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents: 213
diff changeset
311 );
708
1aa1cbb8c3c1 indenting preprocessor stuff, as its completly unreadable otherwise
michaelni
parents: 706
diff changeset
312 # else
234
5fc0c3af3fe4 alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents: 213
diff changeset
313 int index= s->index;
5fc0c3af3fe4 alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents: 213
diff changeset
314 uint32_t *ptr= (uint32_t*)(((uint8_t *)s->buf)+(index>>3));
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2894
diff changeset
315
234
5fc0c3af3fe4 alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents: 213
diff changeset
316 ptr[0] |= be2me_32(value<<(32-n-(index&7) ));
5fc0c3af3fe4 alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents: 213
diff changeset
317 ptr[1] = 0;
5fc0c3af3fe4 alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents: 213
diff changeset
318 //if(n>24) printf("%d %d\n", n, value);
5fc0c3af3fe4 alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents: 213
diff changeset
319 index+= n;
5fc0c3af3fe4 alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents: 213
diff changeset
320 s->index= index;
708
1aa1cbb8c3c1 indenting preprocessor stuff, as its completly unreadable otherwise
michaelni
parents: 706
diff changeset
321 # endif
1aa1cbb8c3c1 indenting preprocessor stuff, as its completly unreadable otherwise
michaelni
parents: 706
diff changeset
322 # endif //!ALIGNED_BITSTREAM_WRITER
234
5fc0c3af3fe4 alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents: 213
diff changeset
323 }
5fc0c3af3fe4 alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents: 213
diff changeset
324 #endif
5fc0c3af3fe4 alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents: 213
diff changeset
325
7260
3ec34b551aae bitstream: move put_sbits() from flacenc.c to bitstream.h and use it
ramiro
parents: 7254
diff changeset
326 static inline void put_sbits(PutBitContext *pb, int bits, int32_t val)
3ec34b551aae bitstream: move put_sbits() from flacenc.c to bitstream.h and use it
ramiro
parents: 7254
diff changeset
327 {
3ec34b551aae bitstream: move put_sbits() from flacenc.c to bitstream.h and use it
ramiro
parents: 7254
diff changeset
328 assert(bits >= 0 && bits <= 31);
3ec34b551aae bitstream: move put_sbits() from flacenc.c to bitstream.h and use it
ramiro
parents: 7254
diff changeset
329
3ec34b551aae bitstream: move put_sbits() from flacenc.c to bitstream.h and use it
ramiro
parents: 7254
diff changeset
330 put_bits(pb, bits, val & ((1<<bits)-1));
3ec34b551aae bitstream: move put_sbits() from flacenc.c to bitstream.h and use it
ramiro
parents: 7254
diff changeset
331 }
3ec34b551aae bitstream: move put_sbits() from flacenc.c to bitstream.h and use it
ramiro
parents: 7254
diff changeset
332
234
5fc0c3af3fe4 alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents: 213
diff changeset
333
5fc0c3af3fe4 alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents: 213
diff changeset
334 static inline uint8_t* pbBufPtr(PutBitContext *s)
5fc0c3af3fe4 alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents: 213
diff changeset
335 {
5fc0c3af3fe4 alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents: 213
diff changeset
336 #ifdef ALT_BITSTREAM_WRITER
2979
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
337 return s->buf + (s->index>>3);
234
5fc0c3af3fe4 alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents: 213
diff changeset
338 #else
2979
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
339 return s->buf_ptr;
234
5fc0c3af3fe4 alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents: 213
diff changeset
340 #endif
5fc0c3af3fe4 alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents: 213
diff changeset
341 }
5fc0c3af3fe4 alternative bitstream writer (disabled by default, uncomment #define ALT_BISTREAM_WRITER in common.h if u want to try it)
michaelni
parents: 213
diff changeset
342
1799
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1795
diff changeset
343 /**
9404
72d354a91367 Add documentation for skip_put_bytes().
stefano
parents: 9403
diff changeset
344 * Skips the given number of bytes.
1799
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1795
diff changeset
345 * PutBitContext must be flushed & aligned to a byte boundary before calling this.
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1795
diff changeset
346 */
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1795
diff changeset
347 static inline void skip_put_bytes(PutBitContext *s, int n){
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1795
diff changeset
348 assert((put_bits_count(s)&7)==0);
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1795
diff changeset
349 #ifdef ALT_BITSTREAM_WRITER
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1795
diff changeset
350 FIXME may need some cleaning of the buffer
2979
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
351 s->index += n<<3;
1799
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1795
diff changeset
352 #else
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1795
diff changeset
353 assert(s->bit_left==32);
2979
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
354 s->buf_ptr += n;
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2894
diff changeset
355 #endif
1799
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1795
diff changeset
356 }
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1795
diff changeset
357
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1795
diff changeset
358 /**
5127
4dbe6578f811 misc spelling fixes
diego
parents: 5071
diff changeset
359 * Skips the given number of bits.
4dbe6578f811 misc spelling fixes
diego
parents: 5071
diff changeset
360 * Must only be used if the actual values in the bitstream do not matter.
9320
fec13de9a1f2 Add a notice telling that the behavior of skip_put_bits() is undefined
stefano
parents: 9098
diff changeset
361 * If \p n is 0 the behavior is undefined.
2502
f5fe61bd08ac support skiping some bitstream encoding
michael
parents: 2467
diff changeset
362 */
f5fe61bd08ac support skiping some bitstream encoding
michael
parents: 2467
diff changeset
363 static inline void skip_put_bits(PutBitContext *s, int n){
f5fe61bd08ac support skiping some bitstream encoding
michael
parents: 2467
diff changeset
364 #ifdef ALT_BITSTREAM_WRITER
f5fe61bd08ac support skiping some bitstream encoding
michael
parents: 2467
diff changeset
365 s->index += n;
f5fe61bd08ac support skiping some bitstream encoding
michael
parents: 2467
diff changeset
366 #else
f5fe61bd08ac support skiping some bitstream encoding
michael
parents: 2467
diff changeset
367 s->bit_left -= n;
f5fe61bd08ac support skiping some bitstream encoding
michael
parents: 2467
diff changeset
368 s->buf_ptr-= s->bit_left>>5;
f5fe61bd08ac support skiping some bitstream encoding
michael
parents: 2467
diff changeset
369 s->bit_left &= 31;
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2894
diff changeset
370 #endif
2502
f5fe61bd08ac support skiping some bitstream encoding
michael
parents: 2467
diff changeset
371 }
f5fe61bd08ac support skiping some bitstream encoding
michael
parents: 2467
diff changeset
372
f5fe61bd08ac support skiping some bitstream encoding
michael
parents: 2467
diff changeset
373 /**
1799
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1795
diff changeset
374 * Changes the end of the buffer.
9408
e74131a0652d Document the 'size' parameter of set_put_bits_buffer_size().
stefano
parents: 9407
diff changeset
375 *
e74131a0652d Document the 'size' parameter of set_put_bits_buffer_size().
stefano
parents: 9407
diff changeset
376 * @param size the new size in bytes of the buffer where to put bits
1799
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1795
diff changeset
377 */
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1795
diff changeset
378 static inline void set_put_bits_buffer_size(PutBitContext *s, int size){
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1795
diff changeset
379 s->buf_end= s->buf + size;
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1795
diff changeset
380 }
95612d423fde multithreaded/SMP motion estimation
michael
parents: 1795
diff changeset
381
520
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
382 /* Bitstream reader API docs:
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
383 name
7731
4604ce2ea3ad Fix typo.
stefano
parents: 7690
diff changeset
384 arbitrary name which is used as prefix for the internal variables
520
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
385
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
386 gb
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
387 getbitcontext
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
388
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
389 OPEN_READER(name, gb)
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
390 loads gb into local variables
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
391
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
392 CLOSE_READER(name, gb)
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
393 stores local vars in gb
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
394
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
395 UPDATE_CACHE(name, gb)
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
396 refills the internal cache from the bitstream
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
397 after this call at least MIN_CACHE_BITS will be available,
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
398
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
399 GET_CACHE(name, gb)
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
400 will output the contents of the internal cache, next bit is MSB of 32 or 64 bit (FIXME 64bit)
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
401
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
402 SHOW_UBITS(name, gb, num)
2764
2b37bcabe608 spelling fixes
diego
parents: 2672
diff changeset
403 will return the next num bits
520
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
404
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
405 SHOW_SBITS(name, gb, num)
2764
2b37bcabe608 spelling fixes
diego
parents: 2672
diff changeset
406 will return the next num bits and do sign extension
520
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
407
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
408 SKIP_BITS(name, gb, num)
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
409 will skip over the next num bits
2764
2b37bcabe608 spelling fixes
diego
parents: 2672
diff changeset
410 note, this is equivalent to SKIP_CACHE; SKIP_COUNTER
520
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
411
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
412 SKIP_CACHE(name, gb, num)
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
413 will remove the next num bits from the cache (note SKIP_COUNTER MUST be called before UPDATE_CACHE / CLOSE_READER)
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
414
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
415 SKIP_COUNTER(name, gb, num)
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
416 will increment the internal bit counter (see SKIP_CACHE & SKIP_BITS)
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
417
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
418 LAST_SKIP_CACHE(name, gb, num)
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
419 will remove the next num bits from the cache if it is needed for UPDATE_CACHE otherwise it will do nothing
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
420
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
421 LAST_SKIP_BITS(name, gb, num)
2764
2b37bcabe608 spelling fixes
diego
parents: 2672
diff changeset
422 is equivalent to SKIP_LAST_CACHE; SKIP_COUNTER
520
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
423
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
424 for examples see get_bits, show_bits, skip_bits, get_vlc
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
425 */
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
426
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
427 #ifdef ALT_BITSTREAM_READER
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
428 # define MIN_CACHE_BITS 25
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
429
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
430 # define OPEN_READER(name, gb)\
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
431 int name##_index= (gb)->index;\
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
432 int name##_cache= 0;\
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
433
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
434 # define CLOSE_READER(name, gb)\
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
435 (gb)->index= name##_index;\
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
436
2663
b33be8b00488 LE bitstream reader based upon a patch by (Balatoni Denes <dbalatoni programozo hu)
michael
parents: 2615
diff changeset
437 # ifdef ALT_BITSTREAM_READER_LE
b33be8b00488 LE bitstream reader based upon a patch by (Balatoni Denes <dbalatoni programozo hu)
michael
parents: 2615
diff changeset
438 # define UPDATE_CACHE(name, gb)\
5512
28dcc5cd79d2 * getting rid of code duplication
romansh
parents: 5509
diff changeset
439 name##_cache= AV_RL32( ((const uint8_t *)(gb)->buffer)+(name##_index>>3) ) >> (name##_index&0x07);\
2663
b33be8b00488 LE bitstream reader based upon a patch by (Balatoni Denes <dbalatoni programozo hu)
michael
parents: 2615
diff changeset
440
b33be8b00488 LE bitstream reader based upon a patch by (Balatoni Denes <dbalatoni programozo hu)
michael
parents: 2615
diff changeset
441 # define SKIP_CACHE(name, gb, num)\
b33be8b00488 LE bitstream reader based upon a patch by (Balatoni Denes <dbalatoni programozo hu)
michael
parents: 2615
diff changeset
442 name##_cache >>= (num);
b33be8b00488 LE bitstream reader based upon a patch by (Balatoni Denes <dbalatoni programozo hu)
michael
parents: 2615
diff changeset
443 # else
520
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
444 # define UPDATE_CACHE(name, gb)\
5512
28dcc5cd79d2 * getting rid of code duplication
romansh
parents: 5509
diff changeset
445 name##_cache= AV_RB32( ((const uint8_t *)(gb)->buffer)+(name##_index>>3) ) << (name##_index&0x07);\
520
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
446
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
447 # define SKIP_CACHE(name, gb, num)\
2663
b33be8b00488 LE bitstream reader based upon a patch by (Balatoni Denes <dbalatoni programozo hu)
michael
parents: 2615
diff changeset
448 name##_cache <<= (num);
b33be8b00488 LE bitstream reader based upon a patch by (Balatoni Denes <dbalatoni programozo hu)
michael
parents: 2615
diff changeset
449 # endif
520
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
450
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
451 // FIXME name?
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
452 # define SKIP_COUNTER(name, gb, num)\
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
453 name##_index += (num);\
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
454
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
455 # define SKIP_BITS(name, gb, num)\
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
456 {\
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
457 SKIP_CACHE(name, gb, num)\
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
458 SKIP_COUNTER(name, gb, num)\
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
459 }\
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
460
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
461 # define LAST_SKIP_BITS(name, gb, num) SKIP_COUNTER(name, gb, num)
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
462 # define LAST_SKIP_CACHE(name, gb, num) ;
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
463
2663
b33be8b00488 LE bitstream reader based upon a patch by (Balatoni Denes <dbalatoni programozo hu)
michael
parents: 2615
diff changeset
464 # ifdef ALT_BITSTREAM_READER_LE
b33be8b00488 LE bitstream reader based upon a patch by (Balatoni Denes <dbalatoni programozo hu)
michael
parents: 2615
diff changeset
465 # define SHOW_UBITS(name, gb, num)\
b33be8b00488 LE bitstream reader based upon a patch by (Balatoni Denes <dbalatoni programozo hu)
michael
parents: 2615
diff changeset
466 ((name##_cache) & (NEG_USR32(0xffffffff,num)))
4005
3ccdff1e5221 fix SHOW_SBITS for ALT_BITSTREAM_READER_LE, patch by Gregory Montoir %cyx A users P sourceforge P net%
bcoudurier
parents: 3947
diff changeset
467
3ccdff1e5221 fix SHOW_SBITS for ALT_BITSTREAM_READER_LE, patch by Gregory Montoir %cyx A users P sourceforge P net%
bcoudurier
parents: 3947
diff changeset
468 # define SHOW_SBITS(name, gb, num)\
3ccdff1e5221 fix SHOW_SBITS for ALT_BITSTREAM_READER_LE, patch by Gregory Montoir %cyx A users P sourceforge P net%
bcoudurier
parents: 3947
diff changeset
469 NEG_SSR32((name##_cache)<<(32-(num)), num)
2663
b33be8b00488 LE bitstream reader based upon a patch by (Balatoni Denes <dbalatoni programozo hu)
michael
parents: 2615
diff changeset
470 # else
520
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
471 # define SHOW_UBITS(name, gb, num)\
525
985187bc2fa3 c std doesnt like negative shifts -> use asm
michaelni
parents: 522
diff changeset
472 NEG_USR32(name##_cache, num)
520
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
473
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
474 # define SHOW_SBITS(name, gb, num)\
525
985187bc2fa3 c std doesnt like negative shifts -> use asm
michaelni
parents: 522
diff changeset
475 NEG_SSR32(name##_cache, num)
4005
3ccdff1e5221 fix SHOW_SBITS for ALT_BITSTREAM_READER_LE, patch by Gregory Montoir %cyx A users P sourceforge P net%
bcoudurier
parents: 3947
diff changeset
476 # endif
520
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
477
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
478 # define GET_CACHE(name, gb)\
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
479 ((uint32_t)name##_cache)
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
480
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
481 static inline int get_bits_count(GetBitContext *s){
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
482 return s->index;
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
483 }
3629
2ab6ec6259b1 move align_get_bits() to .h to avoid conflicts between different bitstream readers in different codecs
michael
parents: 3628
diff changeset
484
2ab6ec6259b1 move align_get_bits() to .h to avoid conflicts between different bitstream readers in different codecs
michael
parents: 3628
diff changeset
485 static inline void skip_bits_long(GetBitContext *s, int n){
3633
f9660d3a9975 2nd try of skip_bits_long() for the ALT reader
michael
parents: 3632
diff changeset
486 s->index += n;
3629
2ab6ec6259b1 move align_get_bits() to .h to avoid conflicts between different bitstream readers in different codecs
michael
parents: 3628
diff changeset
487 }
2ab6ec6259b1 move align_get_bits() to .h to avoid conflicts between different bitstream readers in different codecs
michael
parents: 3628
diff changeset
488
520
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
489 #elif defined LIBMPEG2_BITSTREAM_READER
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
490 //libmpeg2 like reader
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
491
1263
9fce515e9894 libmpeg2 style bitstream reader 17 vs 16 bit bugfix
michaelni
parents: 1261
diff changeset
492 # define MIN_CACHE_BITS 17
520
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
493
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
494 # define OPEN_READER(name, gb)\
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
495 int name##_bit_count=(gb)->bit_count;\
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
496 int name##_cache= (gb)->cache;\
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
497 uint8_t * name##_buffer_ptr=(gb)->buffer_ptr;\
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
498
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
499 # define CLOSE_READER(name, gb)\
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
500 (gb)->bit_count= name##_bit_count;\
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
501 (gb)->cache= name##_cache;\
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
502 (gb)->buffer_ptr= name##_buffer_ptr;\
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
503
1254
604661d34c68 bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents: 1226
diff changeset
504 # define UPDATE_CACHE(name, gb)\
604661d34c68 bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents: 1226
diff changeset
505 if(name##_bit_count >= 0){\
7254
e100cf54e11e Bitstream: use AV_RB16() in LIBMPEG2_BITSTREAM_READER
mru
parents: 6936
diff changeset
506 name##_cache+= AV_RB16(name##_buffer_ptr) << name##_bit_count; \
520
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
507 name##_buffer_ptr+=2;\
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
508 name##_bit_count-= 16;\
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
509 }\
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
510
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
511 # define SKIP_CACHE(name, gb, num)\
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
512 name##_cache <<= (num);\
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
513
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
514 # define SKIP_COUNTER(name, gb, num)\
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
515 name##_bit_count += (num);\
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
516
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
517 # define SKIP_BITS(name, gb, num)\
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
518 {\
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
519 SKIP_CACHE(name, gb, num)\
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
520 SKIP_COUNTER(name, gb, num)\
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
521 }\
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
522
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
523 # define LAST_SKIP_BITS(name, gb, num) SKIP_BITS(name, gb, num)
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
524 # define LAST_SKIP_CACHE(name, gb, num) SKIP_CACHE(name, gb, num)
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
525
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
526 # define SHOW_UBITS(name, gb, num)\
525
985187bc2fa3 c std doesnt like negative shifts -> use asm
michaelni
parents: 522
diff changeset
527 NEG_USR32(name##_cache, num)
520
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
528
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
529 # define SHOW_SBITS(name, gb, num)\
525
985187bc2fa3 c std doesnt like negative shifts -> use asm
michaelni
parents: 522
diff changeset
530 NEG_SSR32(name##_cache, num)
520
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
531
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
532 # define GET_CACHE(name, gb)\
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
533 ((uint32_t)name##_cache)
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
534
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
535 static inline int get_bits_count(GetBitContext *s){
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
536 return (s->buffer_ptr - s->buffer)*8 - 16 + s->bit_count;
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
537 }
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
538
3633
f9660d3a9975 2nd try of skip_bits_long() for the ALT reader
michael
parents: 3632
diff changeset
539 static inline void skip_bits_long(GetBitContext *s, int n){
f9660d3a9975 2nd try of skip_bits_long() for the ALT reader
michael
parents: 3632
diff changeset
540 OPEN_READER(re, s)
f9660d3a9975 2nd try of skip_bits_long() for the ALT reader
michael
parents: 3632
diff changeset
541 re_bit_count += n;
f9660d3a9975 2nd try of skip_bits_long() for the ALT reader
michael
parents: 3632
diff changeset
542 re_buffer_ptr += 2*(re_bit_count>>4);
f9660d3a9975 2nd try of skip_bits_long() for the ALT reader
michael
parents: 3632
diff changeset
543 re_bit_count &= 15;
f9660d3a9975 2nd try of skip_bits_long() for the ALT reader
michael
parents: 3632
diff changeset
544 re_cache = ((re_buffer_ptr[-2]<<8) + re_buffer_ptr[-1]) << (16+re_bit_count);
f9660d3a9975 2nd try of skip_bits_long() for the ALT reader
michael
parents: 3632
diff changeset
545 UPDATE_CACHE(re, s)
f9660d3a9975 2nd try of skip_bits_long() for the ALT reader
michael
parents: 3632
diff changeset
546 CLOSE_READER(re, s)
f9660d3a9975 2nd try of skip_bits_long() for the ALT reader
michael
parents: 3632
diff changeset
547 }
f9660d3a9975 2nd try of skip_bits_long() for the ALT reader
michael
parents: 3632
diff changeset
548
520
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
549 #elif defined A32_BITSTREAM_READER
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
550
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
551 # define MIN_CACHE_BITS 32
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
552
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
553 # define OPEN_READER(name, gb)\
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
554 int name##_bit_count=(gb)->bit_count;\
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
555 uint32_t name##_cache0= (gb)->cache0;\
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
556 uint32_t name##_cache1= (gb)->cache1;\
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
557 uint32_t * name##_buffer_ptr=(gb)->buffer_ptr;\
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
558
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
559 # define CLOSE_READER(name, gb)\
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
560 (gb)->bit_count= name##_bit_count;\
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
561 (gb)->cache0= name##_cache0;\
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
562 (gb)->cache1= name##_cache1;\
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
563 (gb)->buffer_ptr= name##_buffer_ptr;\
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
564
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
565 # define UPDATE_CACHE(name, gb)\
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
566 if(name##_bit_count > 0){\
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
567 const uint32_t next= be2me_32( *name##_buffer_ptr );\
525
985187bc2fa3 c std doesnt like negative shifts -> use asm
michaelni
parents: 522
diff changeset
568 name##_cache0 |= NEG_USR32(next,name##_bit_count);\
520
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
569 name##_cache1 |= next<<name##_bit_count;\
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
570 name##_buffer_ptr++;\
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
571 name##_bit_count-= 32;\
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
572 }\
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
573
8590
7a463923ecd1 Change semantic of CONFIG_*, HAVE_* and ARCH_*.
aurel
parents: 8498
diff changeset
574 #if ARCH_X86
520
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
575 # define SKIP_CACHE(name, gb, num)\
8031
eebc7209c47f Convert asm keyword into __asm__.
flameeyes
parents: 7760
diff changeset
576 __asm__(\
2979
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
577 "shldl %2, %1, %0 \n\t"\
bfabfdf9ce55 COSMETICS: tabs --> spaces, some prettyprinting
diego
parents: 2967
diff changeset
578 "shll %2, %1 \n\t"\
520
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
579 : "+r" (name##_cache0), "+r" (name##_cache1)\
3638
62b3b622f798 Fix A32_BITSTREAM_READER compilation on x86
aurel
parents: 3633
diff changeset
580 : "Ic" ((uint8_t)(num))\
520
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
581 );
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
582 #else
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
583 # define SKIP_CACHE(name, gb, num)\
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
584 name##_cache0 <<= (num);\
525
985187bc2fa3 c std doesnt like negative shifts -> use asm
michaelni
parents: 522
diff changeset
585 name##_cache0 |= NEG_USR32(name##_cache1,num);\
520
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
586 name##_cache1 <<= (num);
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
587 #endif
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
588
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
589 # define SKIP_COUNTER(name, gb, num)\
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
590 name##_bit_count += (num);\
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
591
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
592 # define SKIP_BITS(name, gb, num)\
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
593 {\
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
594 SKIP_CACHE(name, gb, num)\
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
595 SKIP_COUNTER(name, gb, num)\
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
596 }\
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
597
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
598 # define LAST_SKIP_BITS(name, gb, num) SKIP_BITS(name, gb, num)
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
599 # define LAST_SKIP_CACHE(name, gb, num) SKIP_CACHE(name, gb, num)
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
600
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
601 # define SHOW_UBITS(name, gb, num)\
525
985187bc2fa3 c std doesnt like negative shifts -> use asm
michaelni
parents: 522
diff changeset
602 NEG_USR32(name##_cache0, num)
520
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
603
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
604 # define SHOW_SBITS(name, gb, num)\
525
985187bc2fa3 c std doesnt like negative shifts -> use asm
michaelni
parents: 522
diff changeset
605 NEG_SSR32(name##_cache0, num)
520
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
606
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
607 # define GET_CACHE(name, gb)\
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
608 (name##_cache0)
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
609
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
610 static inline int get_bits_count(GetBitContext *s){
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
611 return ((uint8_t*)s->buffer_ptr - s->buffer)*8 - 32 + s->bit_count;
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
612 }
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
613
3629
2ab6ec6259b1 move align_get_bits() to .h to avoid conflicts between different bitstream readers in different codecs
michael
parents: 3628
diff changeset
614 static inline void skip_bits_long(GetBitContext *s, int n){
2ab6ec6259b1 move align_get_bits() to .h to avoid conflicts between different bitstream readers in different codecs
michael
parents: 3628
diff changeset
615 OPEN_READER(re, s)
2ab6ec6259b1 move align_get_bits() to .h to avoid conflicts between different bitstream readers in different codecs
michael
parents: 3628
diff changeset
616 re_bit_count += n;
3631
40f753fc46a4 3rd try :)
michael
parents: 3630
diff changeset
617 re_buffer_ptr += re_bit_count>>5;
3629
2ab6ec6259b1 move align_get_bits() to .h to avoid conflicts between different bitstream readers in different codecs
michael
parents: 3628
diff changeset
618 re_bit_count &= 31;
3630
8e284a5ec5e1 2nd try for a skip_bits_long() for the A32 reader
michael
parents: 3629
diff changeset
619 re_cache0 = be2me_32( re_buffer_ptr[-1] ) << re_bit_count;
8e284a5ec5e1 2nd try for a skip_bits_long() for the A32 reader
michael
parents: 3629
diff changeset
620 re_cache1 = 0;
3629
2ab6ec6259b1 move align_get_bits() to .h to avoid conflicts between different bitstream readers in different codecs
michael
parents: 3628
diff changeset
621 UPDATE_CACHE(re, s)
2ab6ec6259b1 move align_get_bits() to .h to avoid conflicts between different bitstream readers in different codecs
michael
parents: 3628
diff changeset
622 CLOSE_READER(re, s)
2ab6ec6259b1 move align_get_bits() to .h to avoid conflicts between different bitstream readers in different codecs
michael
parents: 3628
diff changeset
623 }
2ab6ec6259b1 move align_get_bits() to .h to avoid conflicts between different bitstream readers in different codecs
michael
parents: 3628
diff changeset
624
192
1e5f64be86fc another bitstream reader code (faster on intel cpus) - patch by Michael Niedermayer <michaelni@gmx.at>
uid46427
parents: 151
diff changeset
625 #endif
20
907b67420d84 inlineing common case of get_bits() -> gives 2speedup. more optim coming soon...
arpi_esp
parents: 10
diff changeset
626
1257
6defe392d5d2 libmpeg2 style bitstream reader fixes
michaelni
parents: 1254
diff changeset
627 /**
6defe392d5d2 libmpeg2 style bitstream reader fixes
michaelni
parents: 1254
diff changeset
628 * read mpeg1 dc style vlc (sign bit + mantisse with no MSB).
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2894
diff changeset
629 * if MSB not set it is negative
1257
6defe392d5d2 libmpeg2 style bitstream reader fixes
michaelni
parents: 1254
diff changeset
630 * @param n length in bits
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2894
diff changeset
631 * @author BERO
1257
6defe392d5d2 libmpeg2 style bitstream reader fixes
michaelni
parents: 1254
diff changeset
632 */
1254
604661d34c68 bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents: 1226
diff changeset
633 static inline int get_xbits(GetBitContext *s, int n){
3244
b9a0ca749833 get_xbits() optimization
michael
parents: 3024
diff changeset
634 register int sign;
1254
604661d34c68 bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents: 1226
diff changeset
635 register int32_t cache;
604661d34c68 bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents: 1226
diff changeset
636 OPEN_READER(re, s)
604661d34c68 bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents: 1226
diff changeset
637 UPDATE_CACHE(re, s)
604661d34c68 bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents: 1226
diff changeset
638 cache = GET_CACHE(re,s);
3244
b9a0ca749833 get_xbits() optimization
michael
parents: 3024
diff changeset
639 sign=(~cache)>>31;
1254
604661d34c68 bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents: 1226
diff changeset
640 LAST_SKIP_BITS(re, s, n)
604661d34c68 bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents: 1226
diff changeset
641 CLOSE_READER(re, s)
3244
b9a0ca749833 get_xbits() optimization
michael
parents: 3024
diff changeset
642 return (NEG_USR32(sign ^ cache, n) ^ sign) - sign;
1254
604661d34c68 bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents: 1226
diff changeset
643 }
604661d34c68 bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents: 1226
diff changeset
644
604661d34c68 bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents: 1226
diff changeset
645 static inline int get_sbits(GetBitContext *s, int n){
604661d34c68 bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents: 1226
diff changeset
646 register int tmp;
604661d34c68 bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents: 1226
diff changeset
647 OPEN_READER(re, s)
604661d34c68 bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents: 1226
diff changeset
648 UPDATE_CACHE(re, s)
604661d34c68 bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents: 1226
diff changeset
649 tmp= SHOW_SBITS(re, s, n);
604661d34c68 bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents: 1226
diff changeset
650 LAST_SKIP_BITS(re, s, n)
604661d34c68 bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents: 1226
diff changeset
651 CLOSE_READER(re, s)
604661d34c68 bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents: 1226
diff changeset
652 return tmp;
604661d34c68 bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents: 1226
diff changeset
653 }
604661d34c68 bitstream reader optimize patch by (BERO <bero at geocities dot co dot jp>)
michaelni
parents: 1226
diff changeset
654
1257
6defe392d5d2 libmpeg2 style bitstream reader fixes
michaelni
parents: 1254
diff changeset
655 /**
4548
8abb0317d1eb fix comment, get/show_bits(0) does not work
stefang
parents: 4288
diff changeset
656 * reads 1-17 bits.
2764
2b37bcabe608 spelling fixes
diego
parents: 2672
diff changeset
657 * Note, the alt bitstream reader can read up to 25 bits, but the libmpeg2 reader can't
1257
6defe392d5d2 libmpeg2 style bitstream reader fixes
michaelni
parents: 1254
diff changeset
658 */
20
907b67420d84 inlineing common case of get_bits() -> gives 2speedup. more optim coming soon...
arpi_esp
parents: 10
diff changeset
659 static inline unsigned int get_bits(GetBitContext *s, int n){
520
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
660 register int tmp;
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
661 OPEN_READER(re, s)
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
662 UPDATE_CACHE(re, s)
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
663 tmp= SHOW_UBITS(re, s, n);
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
664 LAST_SKIP_BITS(re, s, n)
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
665 CLOSE_READER(re, s)
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
666 return tmp;
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
667 }
192
1e5f64be86fc another bitstream reader code (faster on intel cpus) - patch by Michael Niedermayer <michaelni@gmx.at>
uid46427
parents: 151
diff changeset
668
1257
6defe392d5d2 libmpeg2 style bitstream reader fixes
michaelni
parents: 1254
diff changeset
669 /**
4548
8abb0317d1eb fix comment, get/show_bits(0) does not work
stefang
parents: 4288
diff changeset
670 * shows 1-17 bits.
2764
2b37bcabe608 spelling fixes
diego
parents: 2672
diff changeset
671 * Note, the alt bitstream reader can read up to 25 bits, but the libmpeg2 reader can't
1257
6defe392d5d2 libmpeg2 style bitstream reader fixes
michaelni
parents: 1254
diff changeset
672 */
520
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
673 static inline unsigned int show_bits(GetBitContext *s, int n){
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
674 register int tmp;
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
675 OPEN_READER(re, s)
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
676 UPDATE_CACHE(re, s)
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
677 tmp= SHOW_UBITS(re, s, n);
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
678 // CLOSE_READER(re, s)
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
679 return tmp;
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
680 }
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
681
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
682 static inline void skip_bits(GetBitContext *s, int n){
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
683 //Note gcc seems to optimize this to s->index+=n for the ALT_READER :))
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
684 OPEN_READER(re, s)
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
685 UPDATE_CACHE(re, s)
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
686 LAST_SKIP_BITS(re, s, n)
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
687 CLOSE_READER(re, s)
20
907b67420d84 inlineing common case of get_bits() -> gives 2speedup. more optim coming soon...
arpi_esp
parents: 10
diff changeset
688 }
907b67420d84 inlineing common case of get_bits() -> gives 2speedup. more optim coming soon...
arpi_esp
parents: 10
diff changeset
689
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 20
diff changeset
690 static inline unsigned int get_bits1(GetBitContext *s){
192
1e5f64be86fc another bitstream reader code (faster on intel cpus) - patch by Michael Niedermayer <michaelni@gmx.at>
uid46427
parents: 151
diff changeset
691 #ifdef ALT_BITSTREAM_READER
1e5f64be86fc another bitstream reader code (faster on intel cpus) - patch by Michael Niedermayer <michaelni@gmx.at>
uid46427
parents: 151
diff changeset
692 int index= s->index;
193
b691dd3e9088 aligned bitstream support (optional) - patch by ichael Niedermayer <michaelni@gmx.at>
arpi_esp
parents: 192
diff changeset
693 uint8_t result= s->buffer[ index>>3 ];
2663
b33be8b00488 LE bitstream reader based upon a patch by (Balatoni Denes <dbalatoni programozo hu)
michael
parents: 2615
diff changeset
694 #ifdef ALT_BITSTREAM_READER_LE
b33be8b00488 LE bitstream reader based upon a patch by (Balatoni Denes <dbalatoni programozo hu)
michael
parents: 2615
diff changeset
695 result>>= (index&0x07);
b33be8b00488 LE bitstream reader based upon a patch by (Balatoni Denes <dbalatoni programozo hu)
michael
parents: 2615
diff changeset
696 result&= 1;
b33be8b00488 LE bitstream reader based upon a patch by (Balatoni Denes <dbalatoni programozo hu)
michael
parents: 2615
diff changeset
697 #else
199
0f1dba8fc617 (commited by michael / arpi was crazy enough to give me his password)
arpi_esp
parents: 193
diff changeset
698 result<<= (index&0x07);
0f1dba8fc617 (commited by michael / arpi was crazy enough to give me his password)
arpi_esp
parents: 193
diff changeset
699 result>>= 8 - 1;
2663
b33be8b00488 LE bitstream reader based upon a patch by (Balatoni Denes <dbalatoni programozo hu)
michael
parents: 2615
diff changeset
700 #endif
192
1e5f64be86fc another bitstream reader code (faster on intel cpus) - patch by Michael Niedermayer <michaelni@gmx.at>
uid46427
parents: 151
diff changeset
701 index++;
1e5f64be86fc another bitstream reader code (faster on intel cpus) - patch by Michael Niedermayer <michaelni@gmx.at>
uid46427
parents: 151
diff changeset
702 s->index= index;
520
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
703
192
1e5f64be86fc another bitstream reader code (faster on intel cpus) - patch by Michael Niedermayer <michaelni@gmx.at>
uid46427
parents: 151
diff changeset
704 return result;
1e5f64be86fc another bitstream reader code (faster on intel cpus) - patch by Michael Niedermayer <michaelni@gmx.at>
uid46427
parents: 151
diff changeset
705 #else
520
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
706 return get_bits(s, 1);
192
1e5f64be86fc another bitstream reader code (faster on intel cpus) - patch by Michael Niedermayer <michaelni@gmx.at>
uid46427
parents: 151
diff changeset
707 #endif
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 20
diff changeset
708 }
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 20
diff changeset
709
520
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
710 static inline unsigned int show_bits1(GetBitContext *s){
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
711 return show_bits(s, 1);
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 20
diff changeset
712 }
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 20
diff changeset
713
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 20
diff changeset
714 static inline void skip_bits1(GetBitContext *s){
520
19a5e2a81e1a new bitstream reader API (old get_bits() based one is emulated and will still be supported in the future cuz its simpler)
michaelni
parents: 517
diff changeset
715 skip_bits(s, 1);
21
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 20
diff changeset
716 }
20e680e7a490 get_bits() specialization, gives 4\speedup
arpi_esp
parents: 20
diff changeset
717
1875
45a1592dadca * moving some of the commonly used bit reading/writing functions
romansh
parents: 1845
diff changeset
718 /**
3648
c44d798b06b5 move some functions to bitstream.h to avoid conflicts
aurel
parents: 3638
diff changeset
719 * reads 0-32 bits.
c44d798b06b5 move some functions to bitstream.h to avoid conflicts
aurel
parents: 3638
diff changeset
720 */
c44d798b06b5 move some functions to bitstream.h to avoid conflicts
aurel
parents: 3638
diff changeset
721 static inline unsigned int get_bits_long(GetBitContext *s, int n){
c44d798b06b5 move some functions to bitstream.h to avoid conflicts
aurel
parents: 3638
diff changeset
722 if(n<=17) return get_bits(s, n);
c44d798b06b5 move some functions to bitstream.h to avoid conflicts
aurel
parents: 3638
diff changeset
723 else{
3760
dbe7b99efdbf Fix get_bits_long to work with ALT_BITSTREAM_READER_LE.
reimar
parents: 3699
diff changeset
724 #ifdef ALT_BITSTREAM_READER_LE
dbe7b99efdbf Fix get_bits_long to work with ALT_BITSTREAM_READER_LE.
reimar
parents: 3699
diff changeset
725 int ret= get_bits(s, 16);
dbe7b99efdbf Fix get_bits_long to work with ALT_BITSTREAM_READER_LE.
reimar
parents: 3699
diff changeset
726 return ret | (get_bits(s, n-16) << 16);
dbe7b99efdbf Fix get_bits_long to work with ALT_BITSTREAM_READER_LE.
reimar
parents: 3699
diff changeset
727 #else
3648
c44d798b06b5 move some functions to bitstream.h to avoid conflicts
aurel
parents: 3638
diff changeset
728 int ret= get_bits(s, 16) << (n-16);
c44d798b06b5 move some functions to bitstream.h to avoid conflicts
aurel
parents: 3638
diff changeset
729 return ret | get_bits(s, n-16);
3760
dbe7b99efdbf Fix get_bits_long to work with ALT_BITSTREAM_READER_LE.
reimar
parents: 3699
diff changeset
730 #endif
3648
c44d798b06b5 move some functions to bitstream.h to avoid conflicts
aurel
parents: 3638
diff changeset
731 }
c44d798b06b5 move some functions to bitstream.h to avoid conflicts
aurel
parents: 3638
diff changeset
732 }
c44d798b06b5 move some functions to bitstream.h to avoid conflicts
aurel
parents: 3638
diff changeset
733
c44d798b06b5 move some functions to bitstream.h to avoid conflicts
aurel
parents: 3638
diff changeset
734 /**
9098
66f1dba43a01 Add a get_sbits_long() function.
jbr
parents: 9095
diff changeset
735 * reads 0-32 bits as a signed integer.
66f1dba43a01 Add a get_sbits_long() function.
jbr
parents: 9095
diff changeset
736 */
66f1dba43a01 Add a get_sbits_long() function.
jbr
parents: 9095
diff changeset
737 static inline int get_sbits_long(GetBitContext *s, int n) {
66f1dba43a01 Add a get_sbits_long() function.
jbr
parents: 9095
diff changeset
738 return sign_extend(get_bits_long(s, n), n);
66f1dba43a01 Add a get_sbits_long() function.
jbr
parents: 9095
diff changeset
739 }
66f1dba43a01 Add a get_sbits_long() function.
jbr
parents: 9095
diff changeset
740
66f1dba43a01 Add a get_sbits_long() function.
jbr
parents: 9095
diff changeset
741 /**
3648
c44d798b06b5 move some functions to bitstream.h to avoid conflicts
aurel
parents: 3638
diff changeset
742 * shows 0-32 bits.
c44d798b06b5 move some functions to bitstream.h to avoid conflicts
aurel
parents: 3638
diff changeset
743 */
c44d798b06b5 move some functions to bitstream.h to avoid conflicts
aurel
parents: 3638
diff changeset
744 static inline unsigned int show_bits_long(GetBitContext *s, int n){
c44d798b06b5 move some functions to bitstream.h to avoid conflicts
aurel
parents: 3638
diff changeset
745 if(n<=17) return show_bits(s, n);
c44d798b06b5 move some functions to bitstream.h to avoid conflicts
aurel
parents: 3638
diff changeset
746 else{
c44d798b06b5 move some functions to bitstream.h to avoid conflicts
aurel
parents: 3638
diff changeset
747 GetBitContext gb= *s;
9095
50e847b72cdd Simplify show_bits_long and copy the GetBitsContext around only once instead of twice.
reimar
parents: 8746
diff changeset
748 return get_bits_long(&gb, n);
3648
c44d798b06b5 move some functions to bitstream.h to avoid conflicts
aurel
parents: 3638
diff changeset
749 }
c44d798b06b5 move some functions to bitstream.h to avoid conflicts
aurel
parents: 3638
diff changeset
750 }
c44d798b06b5 move some functions to bitstream.h to avoid conflicts
aurel
parents: 3638
diff changeset
751
c44d798b06b5 move some functions to bitstream.h to avoid conflicts
aurel
parents: 3638
diff changeset
752 static inline int check_marker(GetBitContext *s, const char *msg)
c44d798b06b5 move some functions to bitstream.h to avoid conflicts
aurel
parents: 3638
diff changeset
753 {
c44d798b06b5 move some functions to bitstream.h to avoid conflicts
aurel
parents: 3638
diff changeset
754 int bit= get_bits1(s);
c44d798b06b5 move some functions to bitstream.h to avoid conflicts
aurel
parents: 3638
diff changeset
755 if(!bit)
c44d798b06b5 move some functions to bitstream.h to avoid conflicts
aurel
parents: 3638
diff changeset
756 av_log(NULL, AV_LOG_INFO, "Marker bit missing %s\n", msg);
c44d798b06b5 move some functions to bitstream.h to avoid conflicts
aurel
parents: 3638
diff changeset
757
c44d798b06b5 move some functions to bitstream.h to avoid conflicts
aurel
parents: 3638
diff changeset
758 return bit;
c44d798b06b5 move some functions to bitstream.h to avoid conflicts
aurel
parents: 3638
diff changeset
759 }
c44d798b06b5 move some functions to bitstream.h to avoid conflicts
aurel
parents: 3638
diff changeset
760
c44d798b06b5 move some functions to bitstream.h to avoid conflicts
aurel
parents: 3638
diff changeset
761 /**
1875
45a1592dadca * moving some of the commonly used bit reading/writing functions
romansh
parents: 1845
diff changeset
762 * init GetBitContext.
45a1592dadca * moving some of the commonly used bit reading/writing functions
romansh
parents: 1845
diff changeset
763 * @param buffer bitstream buffer, must be FF_INPUT_BUFFER_PADDING_SIZE bytes larger then the actual read bits
45a1592dadca * moving some of the commonly used bit reading/writing functions
romansh
parents: 1845
diff changeset
764 * because some optimized bitstream readers read 32 or 64 bit at once and could read over the end
45a1592dadca * moving some of the commonly used bit reading/writing functions
romansh
parents: 1845
diff changeset
765 * @param bit_size the size of the buffer in bits
45a1592dadca * moving some of the commonly used bit reading/writing functions
romansh
parents: 1845
diff changeset
766 */
45a1592dadca * moving some of the commonly used bit reading/writing functions
romansh
parents: 1845
diff changeset
767 static inline void init_get_bits(GetBitContext *s,
45a1592dadca * moving some of the commonly used bit reading/writing functions
romansh
parents: 1845
diff changeset
768 const uint8_t *buffer, int bit_size)
45a1592dadca * moving some of the commonly used bit reading/writing functions
romansh
parents: 1845
diff changeset
769 {
2889
64231191674b precautionary checks
michael
parents: 2885
diff changeset
770 int buffer_size= (bit_size+7)>>3;
2894
26f8974c3d66 fix some pointer to intger without cast warnings (patch by Michel Bardiaux)
aurel
parents: 2889
diff changeset
771 if(buffer_size < 0 || bit_size < 0) {
26f8974c3d66 fix some pointer to intger without cast warnings (patch by Michel Bardiaux)
aurel
parents: 2889
diff changeset
772 buffer_size = bit_size = 0;
26f8974c3d66 fix some pointer to intger without cast warnings (patch by Michel Bardiaux)
aurel
parents: 2889
diff changeset
773 buffer = NULL;
26f8974c3d66 fix some pointer to intger without cast warnings (patch by Michel Bardiaux)
aurel
parents: 2889
diff changeset
774 }
1875
45a1592dadca * moving some of the commonly used bit reading/writing functions
romansh
parents: 1845
diff changeset
775
45a1592dadca * moving some of the commonly used bit reading/writing functions
romansh
parents: 1845
diff changeset
776 s->buffer= buffer;
45a1592dadca * moving some of the commonly used bit reading/writing functions
romansh
parents: 1845
diff changeset
777 s->size_in_bits= bit_size;
45a1592dadca * moving some of the commonly used bit reading/writing functions
romansh
parents: 1845
diff changeset
778 s->buffer_end= buffer + buffer_size;
45a1592dadca * moving some of the commonly used bit reading/writing functions
romansh
parents: 1845
diff changeset
779 #ifdef ALT_BITSTREAM_READER
45a1592dadca * moving some of the commonly used bit reading/writing functions
romansh
parents: 1845
diff changeset
780 s->index=0;
45a1592dadca * moving some of the commonly used bit reading/writing functions
romansh
parents: 1845
diff changeset
781 #elif defined LIBMPEG2_BITSTREAM_READER
3633
f9660d3a9975 2nd try of skip_bits_long() for the ALT reader
michael
parents: 3632
diff changeset
782 s->buffer_ptr = (uint8_t*)((intptr_t)buffer&(~1));
f9660d3a9975 2nd try of skip_bits_long() for the ALT reader
michael
parents: 3632
diff changeset
783 s->bit_count = 16 + 8*((intptr_t)buffer&1);
f9660d3a9975 2nd try of skip_bits_long() for the ALT reader
michael
parents: 3632
diff changeset
784 skip_bits_long(s, 0);
3632
25ceb2cc950d make A32 reader align its ptr during init no matter what missaligned mess is given to it
michael
parents: 3631
diff changeset
785 #elif defined A32_BITSTREAM_READER
25ceb2cc950d make A32 reader align its ptr during init no matter what missaligned mess is given to it
michael
parents: 3631
diff changeset
786 s->buffer_ptr = (uint32_t*)((intptr_t)buffer&(~3));
25ceb2cc950d make A32 reader align its ptr during init no matter what missaligned mess is given to it
michael
parents: 3631
diff changeset
787 s->bit_count = 32 + 8*((intptr_t)buffer&3);
25ceb2cc950d make A32 reader align its ptr during init no matter what missaligned mess is given to it
michael
parents: 3631
diff changeset
788 skip_bits_long(s, 0);
1875
45a1592dadca * moving some of the commonly used bit reading/writing functions
romansh
parents: 1845
diff changeset
789 #endif
45a1592dadca * moving some of the commonly used bit reading/writing functions
romansh
parents: 1845
diff changeset
790 }
45a1592dadca * moving some of the commonly used bit reading/writing functions
romansh
parents: 1845
diff changeset
791
3675
bce9f52584c3 inline align_get_bits()
mru
parents: 3666
diff changeset
792 static inline void align_get_bits(GetBitContext *s)
3629
2ab6ec6259b1 move align_get_bits() to .h to avoid conflicts between different bitstream readers in different codecs
michael
parents: 3628
diff changeset
793 {
2ab6ec6259b1 move align_get_bits() to .h to avoid conflicts between different bitstream readers in different codecs
michael
parents: 3628
diff changeset
794 int n= (-get_bits_count(s)) & 7;
2ab6ec6259b1 move align_get_bits() to .h to avoid conflicts between different bitstream readers in different codecs
michael
parents: 3628
diff changeset
795 if(n) skip_bits(s, n);
2ab6ec6259b1 move align_get_bits() to .h to avoid conflicts between different bitstream readers in different codecs
michael
parents: 3628
diff changeset
796 }
2ab6ec6259b1 move align_get_bits() to .h to avoid conflicts between different bitstream readers in different codecs
michael
parents: 3628
diff changeset
797
5071
0d503c12092b add init_vlc_sparse(). faster than init_vlc() if there are lots of holes in the tables.
lorenm
parents: 4875
diff changeset
798 #define init_vlc(vlc, nb_bits, nb_codes,\
0d503c12092b add init_vlc_sparse(). faster than init_vlc() if there are lots of holes in the tables.
lorenm
parents: 4875
diff changeset
799 bits, bits_wrap, bits_size,\
0d503c12092b add init_vlc_sparse(). faster than init_vlc() if there are lots of holes in the tables.
lorenm
parents: 4875
diff changeset
800 codes, codes_wrap, codes_size,\
0d503c12092b add init_vlc_sparse(). faster than init_vlc() if there are lots of holes in the tables.
lorenm
parents: 4875
diff changeset
801 flags)\
0d503c12092b add init_vlc_sparse(). faster than init_vlc() if there are lots of holes in the tables.
lorenm
parents: 4875
diff changeset
802 init_vlc_sparse(vlc, nb_bits, nb_codes,\
0d503c12092b add init_vlc_sparse(). faster than init_vlc() if there are lots of holes in the tables.
lorenm
parents: 4875
diff changeset
803 bits, bits_wrap, bits_size,\
0d503c12092b add init_vlc_sparse(). faster than init_vlc() if there are lots of holes in the tables.
lorenm
parents: 4875
diff changeset
804 codes, codes_wrap, codes_size,\
0d503c12092b add init_vlc_sparse(). faster than init_vlc() if there are lots of holes in the tables.
lorenm
parents: 4875
diff changeset
805 NULL, 0, 0, flags)
0d503c12092b add init_vlc_sparse(). faster than init_vlc() if there are lots of holes in the tables.
lorenm
parents: 4875
diff changeset
806
0d503c12092b add init_vlc_sparse(). faster than init_vlc() if there are lots of holes in the tables.
lorenm
parents: 4875
diff changeset
807 int init_vlc_sparse(VLC *vlc, int nb_bits, int nb_codes,
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
808 const void *bits, int bits_wrap, int bits_size,
2370
26560d4fdb1f Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents: 2318
diff changeset
809 const void *codes, int codes_wrap, int codes_size,
5071
0d503c12092b add init_vlc_sparse(). faster than init_vlc() if there are lots of holes in the tables.
lorenm
parents: 4875
diff changeset
810 const void *symbols, int symbols_wrap, int symbols_size,
2663
b33be8b00488 LE bitstream reader based upon a patch by (Balatoni Denes <dbalatoni programozo hu)
michael
parents: 2615
diff changeset
811 int flags);
6935
24e01f7cc819 Make init_vlc* support proper static tables instead of this broken beyond
michael
parents: 6763
diff changeset
812 #define INIT_VLC_USE_STATIC 1 ///< VERY strongly deprecated and forbidden
2663
b33be8b00488 LE bitstream reader based upon a patch by (Balatoni Denes <dbalatoni programozo hu)
michael
parents: 2615
diff changeset
813 #define INIT_VLC_LE 2
6935
24e01f7cc819 Make init_vlc* support proper static tables instead of this broken beyond
michael
parents: 6763
diff changeset
814 #define INIT_VLC_USE_NEW_STATIC 4
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
815 void free_vlc(VLC *vlc);
986e461dc072 Initial revision
glantau
parents:
diff changeset
816
6936
97798862a414 Little helper macro to make the use of INIT_VLC_USE_NEW_STATIC easier.
michael
parents: 6935
diff changeset
817 #define INIT_VLC_STATIC(vlc, bits, a,b,c,d,e,f,g, static_size)\
97798862a414 Little helper macro to make the use of INIT_VLC_USE_NEW_STATIC easier.
michael
parents: 6935
diff changeset
818 {\
97798862a414 Little helper macro to make the use of INIT_VLC_USE_NEW_STATIC easier.
michael
parents: 6935
diff changeset
819 static VLC_TYPE table[static_size][2];\
97798862a414 Little helper macro to make the use of INIT_VLC_USE_NEW_STATIC easier.
michael
parents: 6935
diff changeset
820 (vlc)->table= table;\
97798862a414 Little helper macro to make the use of INIT_VLC_USE_NEW_STATIC easier.
michael
parents: 6935
diff changeset
821 (vlc)->table_allocated= static_size;\
97798862a414 Little helper macro to make the use of INIT_VLC_USE_NEW_STATIC easier.
michael
parents: 6935
diff changeset
822 init_vlc(vlc, bits, a,b,c,d,e,f,g, INIT_VLC_USE_NEW_STATIC);\
97798862a414 Little helper macro to make the use of INIT_VLC_USE_NEW_STATIC easier.
michael
parents: 6935
diff changeset
823 }
97798862a414 Little helper macro to make the use of INIT_VLC_USE_NEW_STATIC easier.
michael
parents: 6935
diff changeset
824
97798862a414 Little helper macro to make the use of INIT_VLC_USE_NEW_STATIC easier.
michael
parents: 6935
diff changeset
825
1025
1f9afd8b9131 GetBitContext.size is allways multiplied by 8 -> use size_in_bits to avoid useless *8 in a few inner loops
michaelni
parents: 994
diff changeset
826 /**
1f9afd8b9131 GetBitContext.size is allways multiplied by 8 -> use size_in_bits to avoid useless *8 in a few inner loops
michaelni
parents: 994
diff changeset
827 *
1f9afd8b9131 GetBitContext.size is allways multiplied by 8 -> use size_in_bits to avoid useless *8 in a few inner loops
michaelni
parents: 994
diff changeset
828 * if the vlc code is invalid and max_depth=1 than no bits will be removed
1f9afd8b9131 GetBitContext.size is allways multiplied by 8 -> use size_in_bits to avoid useless *8 in a few inner loops
michaelni
parents: 994
diff changeset
829 * if the vlc code is invalid and max_depth>1 than the number of bits removed
1f9afd8b9131 GetBitContext.size is allways multiplied by 8 -> use size_in_bits to avoid useless *8 in a few inner loops
michaelni
parents: 994
diff changeset
830 * is undefined
1f9afd8b9131 GetBitContext.size is allways multiplied by 8 -> use size_in_bits to avoid useless *8 in a few inner loops
michaelni
parents: 994
diff changeset
831 */
529
f1f4d3d755f8 get_vlc() optimization
michaelni
parents: 525
diff changeset
832 #define GET_VLC(code, name, gb, table, bits, max_depth)\
f1f4d3d755f8 get_vlc() optimization
michaelni
parents: 525
diff changeset
833 {\
f1f4d3d755f8 get_vlc() optimization
michaelni
parents: 525
diff changeset
834 int n, index, nb_bits;\
f1f4d3d755f8 get_vlc() optimization
michaelni
parents: 525
diff changeset
835 \
f1f4d3d755f8 get_vlc() optimization
michaelni
parents: 525
diff changeset
836 index= SHOW_UBITS(name, gb, bits);\
f1f4d3d755f8 get_vlc() optimization
michaelni
parents: 525
diff changeset
837 code = table[index][0];\
f1f4d3d755f8 get_vlc() optimization
michaelni
parents: 525
diff changeset
838 n = table[index][1];\
f1f4d3d755f8 get_vlc() optimization
michaelni
parents: 525
diff changeset
839 \
f1f4d3d755f8 get_vlc() optimization
michaelni
parents: 525
diff changeset
840 if(max_depth > 1 && n < 0){\
f1f4d3d755f8 get_vlc() optimization
michaelni
parents: 525
diff changeset
841 LAST_SKIP_BITS(name, gb, bits)\
f1f4d3d755f8 get_vlc() optimization
michaelni
parents: 525
diff changeset
842 UPDATE_CACHE(name, gb)\
f1f4d3d755f8 get_vlc() optimization
michaelni
parents: 525
diff changeset
843 \
f1f4d3d755f8 get_vlc() optimization
michaelni
parents: 525
diff changeset
844 nb_bits = -n;\
f1f4d3d755f8 get_vlc() optimization
michaelni
parents: 525
diff changeset
845 \
535
7f1b09bb34c6 dont trash table in GET_VLC
michaelni
parents: 534
diff changeset
846 index= SHOW_UBITS(name, gb, nb_bits) + code;\
529
f1f4d3d755f8 get_vlc() optimization
michaelni
parents: 525
diff changeset
847 code = table[index][0];\
f1f4d3d755f8 get_vlc() optimization
michaelni
parents: 525
diff changeset
848 n = table[index][1];\
f1f4d3d755f8 get_vlc() optimization
michaelni
parents: 525
diff changeset
849 if(max_depth > 2 && n < 0){\
f1f4d3d755f8 get_vlc() optimization
michaelni
parents: 525
diff changeset
850 LAST_SKIP_BITS(name, gb, nb_bits)\
f1f4d3d755f8 get_vlc() optimization
michaelni
parents: 525
diff changeset
851 UPDATE_CACHE(name, gb)\
f1f4d3d755f8 get_vlc() optimization
michaelni
parents: 525
diff changeset
852 \
f1f4d3d755f8 get_vlc() optimization
michaelni
parents: 525
diff changeset
853 nb_bits = -n;\
f1f4d3d755f8 get_vlc() optimization
michaelni
parents: 525
diff changeset
854 \
535
7f1b09bb34c6 dont trash table in GET_VLC
michaelni
parents: 534
diff changeset
855 index= SHOW_UBITS(name, gb, nb_bits) + code;\
529
f1f4d3d755f8 get_vlc() optimization
michaelni
parents: 525
diff changeset
856 code = table[index][0];\
f1f4d3d755f8 get_vlc() optimization
michaelni
parents: 525
diff changeset
857 n = table[index][1];\
f1f4d3d755f8 get_vlc() optimization
michaelni
parents: 525
diff changeset
858 }\
f1f4d3d755f8 get_vlc() optimization
michaelni
parents: 525
diff changeset
859 }\
f1f4d3d755f8 get_vlc() optimization
michaelni
parents: 525
diff changeset
860 SKIP_BITS(name, gb, n)\
f1f4d3d755f8 get_vlc() optimization
michaelni
parents: 525
diff changeset
861 }
f1f4d3d755f8 get_vlc() optimization
michaelni
parents: 525
diff changeset
862
2615
0d88e3f89379 avoid UPDATE_CACHE() in GET_RL_VLC() if not needed
michael
parents: 2614
diff changeset
863 #define GET_RL_VLC(level, run, name, gb, table, bits, max_depth, need_update)\
542
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 535
diff changeset
864 {\
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 535
diff changeset
865 int n, index, nb_bits;\
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 535
diff changeset
866 \
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 535
diff changeset
867 index= SHOW_UBITS(name, gb, bits);\
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 535
diff changeset
868 level = table[index].level;\
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 535
diff changeset
869 n = table[index].len;\
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 535
diff changeset
870 \
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 535
diff changeset
871 if(max_depth > 1 && n < 0){\
2615
0d88e3f89379 avoid UPDATE_CACHE() in GET_RL_VLC() if not needed
michael
parents: 2614
diff changeset
872 SKIP_BITS(name, gb, bits)\
0d88e3f89379 avoid UPDATE_CACHE() in GET_RL_VLC() if not needed
michael
parents: 2614
diff changeset
873 if(need_update){\
0d88e3f89379 avoid UPDATE_CACHE() in GET_RL_VLC() if not needed
michael
parents: 2614
diff changeset
874 UPDATE_CACHE(name, gb)\
0d88e3f89379 avoid UPDATE_CACHE() in GET_RL_VLC() if not needed
michael
parents: 2614
diff changeset
875 }\
542
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 535
diff changeset
876 \
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 535
diff changeset
877 nb_bits = -n;\
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 535
diff changeset
878 \
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 535
diff changeset
879 index= SHOW_UBITS(name, gb, nb_bits) + level;\
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 535
diff changeset
880 level = table[index].level;\
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 535
diff changeset
881 n = table[index].len;\
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 535
diff changeset
882 }\
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 535
diff changeset
883 run= table[index].run;\
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 535
diff changeset
884 SKIP_BITS(name, gb, n)\
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 535
diff changeset
885 }
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 535
diff changeset
886
193
b691dd3e9088 aligned bitstream support (optional) - patch by ichael Niedermayer <michaelni@gmx.at>
arpi_esp
parents: 192
diff changeset
887
1079
89e233c2ef45 get_vlc2() "docs"
michaelni
parents: 1064
diff changeset
888 /**
89e233c2ef45 get_vlc2() "docs"
michaelni
parents: 1064
diff changeset
889 * parses a vlc code, faster then get_vlc()
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2894
diff changeset
890 * @param bits is the number of bits which will be read at once, must be
1079
89e233c2ef45 get_vlc2() "docs"
michaelni
parents: 1064
diff changeset
891 * identical to nb_bits in init_vlc()
4795
522e52c630bd typos/grammar
diego
parents: 4600
diff changeset
892 * @param max_depth is the number of times bits bits must be read to completely
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2894
diff changeset
893 * read the longest vlc code
1079
89e233c2ef45 get_vlc2() "docs"
michaelni
parents: 1064
diff changeset
894 * = (max_vlc_length + bits - 1) / bits
89e233c2ef45 get_vlc2() "docs"
michaelni
parents: 1064
diff changeset
895 */
4283
d6f83e2f8804 rename always_inline to av_always_inline and move to common.h
mru
parents: 4116
diff changeset
896 static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE (*table)[2],
550
b746a7d75ce6 Force inlining on get_vlc2.
mellum
parents: 542
diff changeset
897 int bits, int max_depth)
531
f5d7fcc81787 get_vlc() optimizations
michaelni
parents: 529
diff changeset
898 {
f5d7fcc81787 get_vlc() optimizations
michaelni
parents: 529
diff changeset
899 int code;
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2894
diff changeset
900
531
f5d7fcc81787 get_vlc() optimizations
michaelni
parents: 529
diff changeset
901 OPEN_READER(re, s)
f5d7fcc81787 get_vlc() optimizations
michaelni
parents: 529
diff changeset
902 UPDATE_CACHE(re, s)
f5d7fcc81787 get_vlc() optimizations
michaelni
parents: 529
diff changeset
903
f5d7fcc81787 get_vlc() optimizations
michaelni
parents: 529
diff changeset
904 GET_VLC(code, re, s, table, bits, max_depth)
f5d7fcc81787 get_vlc() optimizations
michaelni
parents: 529
diff changeset
905
f5d7fcc81787 get_vlc() optimizations
michaelni
parents: 529
diff changeset
906 CLOSE_READER(re, s)
f5d7fcc81787 get_vlc() optimizations
michaelni
parents: 529
diff changeset
907 return code;
f5d7fcc81787 get_vlc() optimizations
michaelni
parents: 529
diff changeset
908 }
f5d7fcc81787 get_vlc() optimizations
michaelni
parents: 529
diff changeset
909
1147
dcb20b7598ed bitstream tracing support
michaelni
parents: 1139
diff changeset
910 //#define TRACE
dcb20b7598ed bitstream tracing support
michaelni
parents: 1139
diff changeset
911
dcb20b7598ed bitstream tracing support
michaelni
parents: 1139
diff changeset
912 #ifdef TRACE
dcb20b7598ed bitstream tracing support
michaelni
parents: 1139
diff changeset
913 static inline void print_bin(int bits, int n){
dcb20b7598ed bitstream tracing support
michaelni
parents: 1139
diff changeset
914 int i;
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2894
diff changeset
915
1147
dcb20b7598ed bitstream tracing support
michaelni
parents: 1139
diff changeset
916 for(i=n-1; i>=0; i--){
2438
e98b5e0de86b compile with TRACE define patch by (Loic <lll+ffmpeg m4x org>)
michael
parents: 2398
diff changeset
917 av_log(NULL, AV_LOG_DEBUG, "%d", (bits>>i)&1);
1147
dcb20b7598ed bitstream tracing support
michaelni
parents: 1139
diff changeset
918 }
dcb20b7598ed bitstream tracing support
michaelni
parents: 1139
diff changeset
919 for(i=n; i<24; i++)
2438
e98b5e0de86b compile with TRACE define patch by (Loic <lll+ffmpeg m4x org>)
michael
parents: 2398
diff changeset
920 av_log(NULL, AV_LOG_DEBUG, " ");
1147
dcb20b7598ed bitstream tracing support
michaelni
parents: 1139
diff changeset
921 }
dcb20b7598ed bitstream tracing support
michaelni
parents: 1139
diff changeset
922
2438
e98b5e0de86b compile with TRACE define patch by (Loic <lll+ffmpeg m4x org>)
michael
parents: 2398
diff changeset
923 static inline int get_bits_trace(GetBitContext *s, int n, char *file, const char *func, int line){
1147
dcb20b7598ed bitstream tracing support
michaelni
parents: 1139
diff changeset
924 int r= get_bits(s, n);
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2894
diff changeset
925
1147
dcb20b7598ed bitstream tracing support
michaelni
parents: 1139
diff changeset
926 print_bin(r, n);
2438
e98b5e0de86b compile with TRACE define patch by (Loic <lll+ffmpeg m4x org>)
michael
parents: 2398
diff changeset
927 av_log(NULL, AV_LOG_DEBUG, "%5d %2d %3d bit @%5d in %s %s:%d\n", r, n, r, get_bits_count(s)-n, file, func, line);
1147
dcb20b7598ed bitstream tracing support
michaelni
parents: 1139
diff changeset
928 return r;
dcb20b7598ed bitstream tracing support
michaelni
parents: 1139
diff changeset
929 }
2438
e98b5e0de86b compile with TRACE define patch by (Loic <lll+ffmpeg m4x org>)
michael
parents: 2398
diff changeset
930 static inline int get_vlc_trace(GetBitContext *s, VLC_TYPE (*table)[2], int bits, int max_depth, char *file, const char *func, int line){
1147
dcb20b7598ed bitstream tracing support
michaelni
parents: 1139
diff changeset
931 int show= show_bits(s, 24);
dcb20b7598ed bitstream tracing support
michaelni
parents: 1139
diff changeset
932 int pos= get_bits_count(s);
dcb20b7598ed bitstream tracing support
michaelni
parents: 1139
diff changeset
933 int r= get_vlc2(s, table, bits, max_depth);
dcb20b7598ed bitstream tracing support
michaelni
parents: 1139
diff changeset
934 int len= get_bits_count(s) - pos;
dcb20b7598ed bitstream tracing support
michaelni
parents: 1139
diff changeset
935 int bits2= show>>(24-len);
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2894
diff changeset
936
1147
dcb20b7598ed bitstream tracing support
michaelni
parents: 1139
diff changeset
937 print_bin(bits2, len);
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2894
diff changeset
938
2438
e98b5e0de86b compile with TRACE define patch by (Loic <lll+ffmpeg m4x org>)
michael
parents: 2398
diff changeset
939 av_log(NULL, AV_LOG_DEBUG, "%5d %2d %3d vlc @%5d in %s %s:%d\n", bits2, len, r, pos, file, func, line);
1147
dcb20b7598ed bitstream tracing support
michaelni
parents: 1139
diff changeset
940 return r;
dcb20b7598ed bitstream tracing support
michaelni
parents: 1139
diff changeset
941 }
2438
e98b5e0de86b compile with TRACE define patch by (Loic <lll+ffmpeg m4x org>)
michael
parents: 2398
diff changeset
942 static inline int get_xbits_trace(GetBitContext *s, int n, char *file, const char *func, int line){
1273
a979fab41ed8 ASV1 codec
michaelni
parents: 1263
diff changeset
943 int show= show_bits(s, n);
a979fab41ed8 ASV1 codec
michaelni
parents: 1263
diff changeset
944 int r= get_xbits(s, n);
2967
ef2149182f1c COSMETICS: Remove all trailing whitespace.
diego
parents: 2894
diff changeset
945
1273
a979fab41ed8 ASV1 codec
michaelni
parents: 1263
diff changeset
946 print_bin(show, n);
2438
e98b5e0de86b compile with TRACE define patch by (Loic <lll+ffmpeg m4x org>)
michael
parents: 2398
diff changeset
947 av_log(NULL, AV_LOG_DEBUG, "%5d %2d %3d xbt @%5d in %s %s:%d\n", show, n, r, get_bits_count(s)-n, file, func, line);
1273
a979fab41ed8 ASV1 codec
michaelni
parents: 1263
diff changeset
948 return r;
a979fab41ed8 ASV1 codec
michaelni
parents: 1263
diff changeset
949 }
1147
dcb20b7598ed bitstream tracing support
michaelni
parents: 1139
diff changeset
950
dcb20b7598ed bitstream tracing support
michaelni
parents: 1139
diff changeset
951 #define get_bits(s, n) get_bits_trace(s, n, __FILE__, __PRETTY_FUNCTION__, __LINE__)
dcb20b7598ed bitstream tracing support
michaelni
parents: 1139
diff changeset
952 #define get_bits1(s) get_bits_trace(s, 1, __FILE__, __PRETTY_FUNCTION__, __LINE__)
1273
a979fab41ed8 ASV1 codec
michaelni
parents: 1263
diff changeset
953 #define get_xbits(s, n) get_xbits_trace(s, n, __FILE__, __PRETTY_FUNCTION__, __LINE__)
1152
michaelni
parents: 1147
diff changeset
954 #define get_vlc(s, vlc) get_vlc_trace(s, (vlc)->table, (vlc)->bits, 3, __FILE__, __PRETTY_FUNCTION__, __LINE__)
1147
dcb20b7598ed bitstream tracing support
michaelni
parents: 1139
diff changeset
955 #define get_vlc2(s, tab, bits, max) get_vlc_trace(s, tab, bits, max, __FILE__, __PRETTY_FUNCTION__, __LINE__)
dcb20b7598ed bitstream tracing support
michaelni
parents: 1139
diff changeset
956
4600
6ac364a4ce2b Supply context to tprintf
mbardiaux
parents: 4548
diff changeset
957 #define tprintf(p, ...) av_log(p, AV_LOG_DEBUG, __VA_ARGS__)
1170
4710976004a5 #ifdef TRACE printf() -> tprintf()
michaelni
parents: 1152
diff changeset
958
4710976004a5 #ifdef TRACE printf() -> tprintf()
michaelni
parents: 1152
diff changeset
959 #else //TRACE
4600
6ac364a4ce2b Supply context to tprintf
mbardiaux
parents: 4548
diff changeset
960 #define tprintf(p, ...) {}
1170
4710976004a5 #ifdef TRACE printf() -> tprintf()
michaelni
parents: 1152
diff changeset
961 #endif
542
d55978a3c369 rl vlc decoding optimizations
michaelni
parents: 535
diff changeset
962
2467
0b3697268285 make decode012() static inline
michael
parents: 2464
diff changeset
963 static inline int decode012(GetBitContext *gb){
2464
ab390f13c7f5 dont duplicate decode012()
michael
parents: 2438
diff changeset
964 int n;
ab390f13c7f5 dont duplicate decode012()
michael
parents: 2438
diff changeset
965 n = get_bits1(gb);
ab390f13c7f5 dont duplicate decode012()
michael
parents: 2438
diff changeset
966 if (n == 0)
ab390f13c7f5 dont duplicate decode012()
michael
parents: 2438
diff changeset
967 return 0;
ab390f13c7f5 dont duplicate decode012()
michael
parents: 2438
diff changeset
968 else
ab390f13c7f5 dont duplicate decode012()
michael
parents: 2438
diff changeset
969 return get_bits1(gb) + 1;
ab390f13c7f5 dont duplicate decode012()
michael
parents: 2438
diff changeset
970 }
ab390f13c7f5 dont duplicate decode012()
michael
parents: 2438
diff changeset
971
6099
a2b438bcb1d2 Make decode210() common function.
kostya
parents: 5830
diff changeset
972 static inline int decode210(GetBitContext *gb){
a2b438bcb1d2 Make decode210() common function.
kostya
parents: 5830
diff changeset
973 if (get_bits1(gb))
a2b438bcb1d2 Make decode210() common function.
kostya
parents: 5830
diff changeset
974 return 0;
a2b438bcb1d2 Make decode210() common function.
kostya
parents: 5830
diff changeset
975 else
a2b438bcb1d2 Make decode210() common function.
kostya
parents: 5830
diff changeset
976 return 2 - get_bits1(gb);
a2b438bcb1d2 Make decode210() common function.
kostya
parents: 5830
diff changeset
977 }
a2b438bcb1d2 Make decode210() common function.
kostya
parents: 5830
diff changeset
978
7760
c4a4495715dd Globally rename the header inclusion guard names.
stefano
parents: 7731
diff changeset
979 #endif /* AVCODEC_BITSTREAM_H */