lavc/libaribb24: protect handled value with parenthesis in RGB_TO_BGR
[ffmpeg.git] / libavcodec / dirac_arith.h
1 /*
2  * Copyright (C) 2007 Marco Gerards <marco@gnu.org>
3  * Copyright (C) 2009 David Conrad
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21
22 /**
23  * @file
24  * Arithmetic decoder for Dirac
25  * @author Marco Gerards <marco@gnu.org>
26  */
27
28 #ifndef AVCODEC_DIRAC_ARITH_H
29 #define AVCODEC_DIRAC_ARITH_H
30
31 #include "libavutil/x86/asm.h"
32 #include "bytestream.h"
33 #include "get_bits.h"
34
35 enum dirac_arith_contexts {
36     CTX_ZPZN_F1,
37     CTX_ZPNN_F1,
38     CTX_NPZN_F1,
39     CTX_NPNN_F1,
40     CTX_ZP_F2,
41     CTX_ZP_F3,
42     CTX_ZP_F4,
43     CTX_ZP_F5,
44     CTX_ZP_F6,
45     CTX_NP_F2,
46     CTX_NP_F3,
47     CTX_NP_F4,
48     CTX_NP_F5,
49     CTX_NP_F6,
50     CTX_COEFF_DATA,
51     CTX_SIGN_NEG,
52     CTX_SIGN_ZERO,
53     CTX_SIGN_POS,
54     CTX_ZERO_BLOCK,
55     CTX_DELTA_Q_F,
56     CTX_DELTA_Q_DATA,
57     CTX_DELTA_Q_SIGN,
58
59     DIRAC_CTX_COUNT
60 };
61
62 // Dirac resets the arith decoder between decoding various types of data,
63 // so many contexts are never used simultaneously. Thus, we can reduce
64 // the number of contexts needed by reusing them.
65 #define CTX_SB_F1        CTX_ZP_F5
66 #define CTX_SB_DATA      0
67 #define CTX_PMODE_REF1   0
68 #define CTX_PMODE_REF2   1
69 #define CTX_GLOBAL_BLOCK 2
70 #define CTX_MV_F1        CTX_ZP_F2
71 #define CTX_MV_DATA      0
72 #define CTX_DC_F1        CTX_ZP_F5
73 #define CTX_DC_DATA      0
74
75 typedef struct {
76     unsigned low;
77     uint16_t range;
78     int16_t  counter;
79
80     const uint8_t *bytestream;
81     const uint8_t *bytestream_end;
82
83     uint16_t contexts[DIRAC_CTX_COUNT];
84     int error;
85     int overread;
86 } DiracArith;
87
88 extern const uint8_t ff_dirac_next_ctx[DIRAC_CTX_COUNT];
89 extern const uint16_t ff_dirac_prob[256];
90 extern int16_t ff_dirac_prob_branchless[256][2];
91
92 static inline void renorm(DiracArith *c)
93 {
94 #if HAVE_FAST_CLZ
95     int shift = 14 - av_log2_16bit(c->range-1) + ((c->range-1)>>15);
96
97     c->low    <<= shift;
98     c->range  <<= shift;
99     c->counter += shift;
100 #else
101     while (c->range <= 0x4000) {
102         c->low   <<= 1;
103         c->range <<= 1;
104         c->counter++;
105     }
106 #endif
107 }
108
109 static inline void refill(DiracArith *c)
110 {
111     int counter = c->counter;
112
113     if (counter >= 0) {
114         int new = bytestream_get_be16(&c->bytestream);
115
116         // the spec defines overread bits to be 1, and streams rely on this
117         if (c->bytestream > c->bytestream_end) {
118             new |= 0xff;
119             if (c->bytestream > c->bytestream_end+1)
120                 new |= 0xff00;
121
122             c->bytestream = c->bytestream_end;
123             c->overread ++;
124             if (c->overread > 4)
125                 c->error = AVERROR_INVALIDDATA;
126         }
127
128         c->low += new << counter;
129         counter -= 16;
130     }
131     c->counter = counter;
132 }
133
134 static inline int dirac_get_arith_bit(DiracArith *c, int ctx)
135 {
136     int prob_zero = c->contexts[ctx];
137     int range_times_prob, bit;
138     unsigned low = c->low;
139     int    range = c->range;
140
141     range_times_prob = (c->range * prob_zero) >> 16;
142
143 #if ARCH_X86 && HAVE_FAST_CMOV && HAVE_INLINE_ASM && HAVE_6REGS
144     low   -= range_times_prob << 16;
145     range -= range_times_prob;
146     bit = 0;
147     __asm__(
148         "cmpl   %5, %4 \n\t"
149         "setae  %b0    \n\t"
150         "cmovb  %3, %2 \n\t"
151         "cmovb  %5, %1 \n\t"
152         : "+q"(bit), "+r"(range), "+r"(low)
153         : "r"(c->low), "r"(c->low>>16),
154           "r"(range_times_prob)
155     );
156 #else
157     bit = (low >> 16) >= range_times_prob;
158     if (bit) {
159         low   -= range_times_prob << 16;
160         range -= range_times_prob;
161     } else {
162         range  = range_times_prob;
163     }
164 #endif
165
166     c->contexts[ctx] += ff_dirac_prob_branchless[prob_zero>>8][bit];
167     c->low   = low;
168     c->range = range;
169
170     renorm(c);
171     refill(c);
172     return bit;
173 }
174
175 static inline int dirac_get_arith_uint(DiracArith *c, int follow_ctx, int data_ctx)
176 {
177     int ret = 1;
178     while (!dirac_get_arith_bit(c, follow_ctx)) {
179         if (ret >= 0x40000000) {
180             av_log(NULL, AV_LOG_ERROR, "dirac_get_arith_uint overflow\n");
181             c->error = AVERROR_INVALIDDATA;
182             return -1;
183         }
184         ret <<= 1;
185         ret += dirac_get_arith_bit(c, data_ctx);
186         follow_ctx = ff_dirac_next_ctx[follow_ctx];
187     }
188     return ret-1;
189 }
190
191 static inline int dirac_get_arith_int(DiracArith *c, int follow_ctx, int data_ctx)
192 {
193     int ret = dirac_get_arith_uint(c, follow_ctx, data_ctx);
194     if (ret && dirac_get_arith_bit(c, data_ctx+1))
195         ret = -ret;
196     return ret;
197 }
198
199 void ff_dirac_init_arith_tables(void);
200 void ff_dirac_init_arith_decoder(DiracArith *c, GetBitContext *gb, int length);
201
202 #endif /* AVCODEC_DIRAC_ARITH_H */