1 /*****************************************************************************
2 * This file is part of Kvazaar HEVC encoder.
3 *
4 * Copyright (c) 2021, Tampere University, ITU/ISO/IEC, project contributors
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without modification,
8 * are permitted provided that the following conditions are met:
9 *
10 * * Redistributions of source code must retain the above copyright notice, this
11 * list of conditions and the following disclaimer.
12 *
13 * * Redistributions in binary form must reproduce the above copyright notice, this
14 * list of conditions and the following disclaimer in the documentation and/or
15 * other materials provided with the distribution.
16 *
17 * * Neither the name of the Tampere University or ITU/ISO/IEC nor the names of its
18 * contributors may be used to endorse or promote products derived from
19 * this software without specific prior written permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
23 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
24 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
25 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
26 * INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
27 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION HOWEVER CAUSED AND ON
28 * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30 * INCLUDING NEGLIGENCE OR OTHERWISE ARISING IN ANY WAY OUT OF THE USE OF THIS
31 ****************************************************************************/
32
33 #include "cabac.h"
34
35 #include "encoder.h"
36 #include "encoderstate.h"
37 #include "extras/crypto.h"
38 #include "kvazaar.h"
39
40 const uint8_t kvz_g_auc_next_state_mps[128] =
41 {
42 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
43 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
44 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
45 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65,
46 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81,
47 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97,
48 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113,
49 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 124, 125, 126, 127
50 };
51
52 const uint8_t kvz_g_auc_next_state_lps[128] =
53 {
54 1, 0, 0, 1, 2, 3, 4, 5, 4, 5, 8, 9, 8, 9, 10, 11,
55 12, 13, 14, 15, 16, 17, 18, 19, 18, 19, 22, 23, 22, 23, 24, 25,
56 26, 27, 26, 27, 30, 31, 30, 31, 32, 33, 32, 33, 36, 37, 36, 37,
57 38, 39, 38, 39, 42, 43, 42, 43, 44, 45, 44, 45, 46, 47, 48, 49,
58 48, 49, 50, 51, 52, 53, 52, 53, 54, 55, 54, 55, 56, 57, 58, 59,
59 58, 59, 60, 61, 60, 61, 60, 61, 62, 63, 64, 65, 64, 65, 66, 67,
60 66, 67, 66, 67, 68, 69, 68, 69, 70, 71, 70, 71, 70, 71, 72, 73,
61 72, 73, 72, 73, 74, 75, 74, 75, 74, 75, 76, 77, 76, 77, 126, 127
62 };
63
64 const uint8_t kvz_g_auc_lpst_table[64][4] =
65 {
66 {128, 176, 208, 240}, {128, 167, 197, 227}, {128, 158, 187, 216}, {123, 150, 178, 205}, {116, 142, 169, 195},
67 {111, 135, 160, 185}, {105, 128, 152, 175}, {100, 122, 144, 166}, { 95, 116, 137, 158}, { 90, 110, 130, 150},
68 { 85, 104, 123, 142}, { 81, 99, 117, 135}, { 77, 94, 111, 128}, { 73, 89, 105, 122}, { 69, 85, 100, 116},
69 { 66, 80, 95, 110}, { 62, 76, 90, 104}, { 59, 72, 86, 99}, { 56, 69, 81, 94}, { 53, 65, 77, 89},
70 { 51, 62, 73, 85}, { 48, 59, 69, 80}, { 46, 56, 66, 76}, { 43, 53, 63, 72}, { 41, 50, 59, 69},
71 { 39, 48, 56, 65}, { 37, 45, 54, 62}, { 35, 43, 51, 59}, { 33, 41, 48, 56}, { 32, 39, 46, 53},
72 { 30, 37, 43, 50}, { 29, 35, 41, 48}, { 27, 33, 39, 45}, { 26, 31, 37, 43}, { 24, 30, 35, 41},
73 { 23, 28, 33, 39}, { 22, 27, 32, 37}, { 21, 26, 30, 35}, { 20, 24, 29, 33}, { 19, 23, 27, 31},
74 { 18, 22, 26, 30}, { 17, 21, 25, 28}, { 16, 20, 23, 27}, { 15, 19, 22, 25}, { 14, 18, 21, 24},
75 { 14, 17, 20, 23}, { 13, 16, 19, 22}, { 12, 15, 18, 21}, { 12, 14, 17, 20}, { 11, 14, 16, 19},
76 { 11, 13, 15, 18}, { 10, 12, 15, 17}, { 10, 12, 14, 16}, { 9, 11, 13, 15}, { 9, 11, 12, 14},
77 { 8, 10, 12, 14}, { 8, 9, 11, 13}, { 7, 9, 11, 12}, { 7, 9, 10, 12}, { 7, 8, 10, 11},
78 { 6, 8, 9, 11}, { 6, 7, 9, 10}, { 6, 7, 8, 9}, { 2, 2, 2, 2}
79 };
80
81 const uint8_t kvz_g_auc_renorm_table[32] =
82 {
83 6, 5, 4, 4, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 2, 2,
84 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
85 };
86
87 /**
88 * \brief Initialize struct cabac_data.
89 */
kvz_cabac_start(cabac_data_t * const data)90 void kvz_cabac_start(cabac_data_t * const data)
91 {
92 data->low = 0;
93 data->range = 510;
94 data->bits_left = 23;
95 data->num_buffered_bytes = 0;
96 data->buffered_byte = 0xff;
97 data->only_count = 0; // By default, write bits out
98 }
99
100 /**
101 * \brief
102 */
kvz_cabac_encode_bin(cabac_data_t * const data,const uint32_t bin_value)103 void kvz_cabac_encode_bin(cabac_data_t * const data, const uint32_t bin_value)
104 {
105 uint32_t lps;
106
107
108 lps = kvz_g_auc_lpst_table[CTX_STATE(data->cur_ctx)][(data->range >> 6) & 3];
109 data->range -= lps;
110
111 // Not the Most Probable Symbol?
112 if ((bin_value ? 1 : 0) != CTX_MPS(data->cur_ctx)) {
113 int num_bits = kvz_g_auc_renorm_table[lps >> 3];
114 data->low = (data->low + data->range) << num_bits;
115 data->range = lps << num_bits;
116
117 CTX_UPDATE_LPS(data->cur_ctx);
118
119 data->bits_left -= num_bits;
120 } else {
121 CTX_UPDATE_MPS(data->cur_ctx);
122 if (data->range >= 256) return;
123
124 data->low <<= 1;
125 data->range <<= 1;
126 data->bits_left--;
127 }
128
129 if (data->bits_left < 12) {
130 kvz_cabac_write(data);
131 }
132 }
133
134 /**
135 * \brief
136 */
kvz_cabac_write(cabac_data_t * const data)137 void kvz_cabac_write(cabac_data_t * const data)
138 {
139 uint32_t lead_byte = data->low >> (24 - data->bits_left);
140 data->bits_left += 8;
141 data->low &= 0xffffffffu >> data->bits_left;
142
143 // Binary counter mode
144 if(data->only_count) {
145 data->num_buffered_bytes++;
146 return;
147 }
148
149 if (lead_byte == 0xff) {
150 data->num_buffered_bytes++;
151 } else {
152 if (data->num_buffered_bytes > 0) {
153 uint32_t carry = lead_byte >> 8;
154 uint32_t byte = data->buffered_byte + carry;
155 data->buffered_byte = lead_byte & 0xff;
156 kvz_bitstream_put_byte(data->stream, byte);
157
158 byte = (0xff + carry) & 0xff;
159 while (data->num_buffered_bytes > 1) {
160 kvz_bitstream_put_byte(data->stream, byte);
161 data->num_buffered_bytes--;
162 }
163 } else {
164 data->num_buffered_bytes = 1;
165 data->buffered_byte = lead_byte;
166 }
167 }
168 }
169
170 /**
171 * \brief
172 */
kvz_cabac_finish(cabac_data_t * const data)173 void kvz_cabac_finish(cabac_data_t * const data)
174 {
175 assert(data->bits_left <= 32);
176
177 if (data->low >> (32 - data->bits_left)) {
178 kvz_bitstream_put_byte(data->stream, data->buffered_byte + 1);
179 while (data->num_buffered_bytes > 1) {
180 kvz_bitstream_put_byte(data->stream, 0);
181 data->num_buffered_bytes--;
182 }
183 data->low -= 1 << (32 - data->bits_left);
184 } else {
185 if (data->num_buffered_bytes > 0) {
186 kvz_bitstream_put_byte(data->stream, data->buffered_byte);
187 }
188 while (data->num_buffered_bytes > 1) {
189 kvz_bitstream_put_byte(data->stream, 0xff);
190 data->num_buffered_bytes--;
191 }
192 }
193
194 {
195 uint8_t bits = (uint8_t)(24 - data->bits_left);
196 kvz_bitstream_put(data->stream, data->low >> 8, bits);
197 }
198 }
199
200 /*!
201 \brief Encode terminating bin
202 \param binValue bin value
203 */
kvz_cabac_encode_bin_trm(cabac_data_t * const data,const uint8_t bin_value)204 void kvz_cabac_encode_bin_trm(cabac_data_t * const data, const uint8_t bin_value)
205 {
206 data->range -= 2;
207 if(bin_value) {
208 data->low += data->range;
209 data->low <<= 7;
210 data->range = 2 << 7;
211 data->bits_left -= 7;
212 } else if (data->range >= 256) {
213 return;
214 } else {
215 data->low <<= 1;
216 data->range <<= 1;
217 data->bits_left--;
218 }
219
220 if (data->bits_left < 12) {
221 kvz_cabac_write(data);
222 }
223 }
224
225 /**
226 * \brief
227 */
kvz_cabac_encode_bin_ep(cabac_data_t * const data,const uint32_t bin_value)228 void kvz_cabac_encode_bin_ep(cabac_data_t * const data, const uint32_t bin_value)
229 {
230 data->low <<= 1;
231 if (bin_value) {
232 data->low += data->range;
233 }
234 data->bits_left--;
235
236 if (data->bits_left < 12) {
237 kvz_cabac_write(data);
238 }
239 }
240
241 /**
242 * \brief
243 */
kvz_cabac_encode_bins_ep(cabac_data_t * const data,uint32_t bin_values,int num_bins)244 void kvz_cabac_encode_bins_ep(cabac_data_t * const data, uint32_t bin_values, int num_bins)
245 {
246 uint32_t pattern;
247
248 while (num_bins > 8) {
249 num_bins -= 8;
250 pattern = bin_values >> num_bins;
251 data->low <<= 8;
252 data->low += data->range * pattern;
253 bin_values -= pattern << num_bins;
254 data->bits_left -= 8;
255
256 if(data->bits_left < 12) {
257 kvz_cabac_write(data);
258 }
259 }
260
261 data->low <<= num_bins;
262 data->low += data->range * bin_values;
263 data->bits_left -= num_bins;
264
265 if (data->bits_left < 12) {
266 kvz_cabac_write(data);
267 }
268 }
269
270 /**
271 * \brief Coding of coeff_abs_level_minus3.
272 * \param symbol Value of coeff_abs_level_minus3.
273 * \param r_param Reference to Rice parameter.
274 */
kvz_cabac_write_coeff_remain(cabac_data_t * const cabac,const uint32_t symbol,const uint32_t r_param)275 void kvz_cabac_write_coeff_remain(cabac_data_t * const cabac, const uint32_t symbol, const uint32_t r_param)
276 {
277 int32_t code_number = symbol;
278 uint32_t length;
279
280 if (code_number < (3 << r_param)) {
281 length = code_number >> r_param;
282 CABAC_BINS_EP(cabac, (1 << (length + 1)) - 2 , length + 1, "coeff_abs_level_remaining");
283 CABAC_BINS_EP(cabac, (code_number % (1 << r_param)), r_param, "coeff_abs_level_remaining");
284 } else {
285 length = r_param;
286 code_number = code_number - (3 << r_param);
287 while (code_number >= (1 << length)) {
288 code_number -= 1 << length;
289 ++length;
290 }
291 CABAC_BINS_EP(cabac, (1 << (3 + length + 1 - r_param)) - 2, 3 + length + 1 - r_param, "coeff_abs_level_remaining");
292 CABAC_BINS_EP(cabac, code_number, length, "coeff_abs_level_remaining");
293 }
294 }
295
kvz_cabac_write_coeff_remain_encry(struct encoder_state_t * const state,cabac_data_t * const cabac,const uint32_t symbol,const uint32_t r_param,int32_t base_level)296 void kvz_cabac_write_coeff_remain_encry(struct encoder_state_t * const state, cabac_data_t * const cabac,const uint32_t symbol, const uint32_t r_param, int32_t base_level)
297 {
298 int32_t codeNumber = (int32_t)symbol;
299 uint32_t length;
300
301 if (codeNumber < (3 << r_param)) {
302 length = codeNumber>>r_param;
303 CABAC_BINS_EP(cabac, (1 << (length + 1)) - 2 , length + 1, "coeff_abs_level_remaining");
304 //m_pcBinIf->encodeBinsEP( (1<<(length+1))-2 , length+1);
305 uint32_t Suffix = (codeNumber%(1<<r_param));
306
307 if(!r_param)
308 CABAC_BINS_EP(cabac, Suffix, r_param, "coeff_abs_level_remaining");
309 //m_pcBinIf->encodeBinsEP(Suffix, r_param);
310 if(r_param==1) {
311 if(!(( base_level ==2 )&& (codeNumber==4 || codeNumber==5) ) ) {
312 uint32_t key = kvz_crypto_get_key(state->crypto_hdl, 1);
313 state->crypto_prev_pos = ( Suffix + ( state->crypto_prev_pos^key ) ) & 1;
314 CABAC_BINS_EP(cabac, state->crypto_prev_pos, 1, "coeff_abs_level_remaining");
315 //m_pcBinIf->encodeBinsEP(m_prev_pos, 1);
316 } else {
317 CABAC_BINS_EP(cabac, Suffix, 1, "coeff_abs_level_remaining");
318 //m_pcBinIf->encodeBinsEP(Suffix, 1);
319 }
320 }
321 else
322 if(r_param==2) {
323 if( base_level ==1) {
324 uint32_t key = kvz_crypto_get_key(state->crypto_hdl, 2);
325 state->crypto_prev_pos = ( Suffix + ( state->crypto_prev_pos^key ) ) & 3;
326 CABAC_BINS_EP(cabac, state->crypto_prev_pos, 2, "coeff_abs_level_remaining");
327 //m_pcBinIf->encodeBinsEP(m_prev_pos, 2);
328 } else
329 if( base_level ==2) {
330 if(codeNumber<=7 || codeNumber>=12) {
331 uint32_t key = kvz_crypto_get_key(state->crypto_hdl, 2);
332 state->crypto_prev_pos = ( Suffix + ( state->crypto_prev_pos^key ) ) & 3;
333 CABAC_BINS_EP(cabac, state->crypto_prev_pos, 2, "coeff_abs_level_remaining");
334 //m_pcBinIf->encodeBinsEP(m_prev_pos, 2);
335 }
336 else
337 if(codeNumber<10) {
338 uint32_t key = kvz_crypto_get_key(state->crypto_hdl, 1);
339 state->crypto_prev_pos = (( (Suffix&1) + ( state->crypto_prev_pos^key )) & 1);
340 CABAC_BINS_EP(cabac, state->crypto_prev_pos, 2, "coeff_abs_level_remaining");
341 //m_pcBinIf->encodeBinsEP(m_prev_pos, 2);
342 } else
343 CABAC_BINS_EP(cabac, Suffix, 2, "coeff_abs_level_remaining");
344 //m_pcBinIf->encodeBinsEP(Suffix, 2);
345 } else { //base_level=3
346 if(codeNumber<=7 || codeNumber>11) {
347 uint32_t key = kvz_crypto_get_key(state->crypto_hdl, 2);
348 state->crypto_prev_pos = (Suffix + ( state->crypto_prev_pos^key ) ) & 3;
349 CABAC_BINS_EP(cabac, state->crypto_prev_pos, 2, "coeff_abs_level_remaining");
350 //m_pcBinIf->encodeBinsEP(m_prev_pos, 2);
351 } else {
352 uint32_t key = kvz_crypto_get_key(state->crypto_hdl, 1);
353 state->crypto_prev_pos = ((Suffix&2))+(( (Suffix&1) + ( state->crypto_prev_pos^key)) & 1);
354 CABAC_BINS_EP(cabac, state->crypto_prev_pos, 2, "coeff_abs_level_remaining");
355 //m_pcBinIf->encodeBinsEP(m_prev_pos, 2);
356 }
357 }
358 } else
359 if(r_param==3) {
360 if( base_level ==1) {
361 uint32_t key = kvz_crypto_get_key(state->crypto_hdl, 3);
362 state->crypto_prev_pos = ( Suffix + ( state->crypto_prev_pos^key ) ) & 7;
363 CABAC_BINS_EP(cabac, state->crypto_prev_pos, 3, "coeff_abs_level_remaining");
364 //m_pcBinIf->encodeBinsEP(m_prev_pos, 3);
365 }
366 else if( base_level ==2) {
367 if(codeNumber<=15 || codeNumber>23) {
368 uint32_t key = kvz_crypto_get_key(state->crypto_hdl, 3);
369 state->crypto_prev_pos = ( Suffix + ( state->crypto_prev_pos^key ) ) & 7;
370 CABAC_BINS_EP(cabac, state->crypto_prev_pos, 3, "coeff_abs_level_remaining");
371 //m_pcBinIf->encodeBinsEP(m_prev_pos, 3);
372 } else
373 if(codeNumber<=19){
374 uint32_t key = kvz_crypto_get_key(state->crypto_hdl, 2);
375 state->crypto_prev_pos = ((Suffix&4))+(( (Suffix&3) + (state->crypto_prev_pos^key )) & 3);
376 CABAC_BINS_EP(cabac, state->crypto_prev_pos, 3, "coeff_abs_level_remaining");
377 //m_pcBinIf->encodeBinsEP(m_prev_pos, 3);
378 } else
379 if(codeNumber<=21){
380 uint32_t key = kvz_crypto_get_key(state->crypto_hdl, 1);
381 state->crypto_prev_pos = 4+(( (Suffix&1) + ( state->crypto_prev_pos^key )) & 1);
382 CABAC_BINS_EP(cabac, state->crypto_prev_pos, 3, "coeff_abs_level_remaining");
383 //m_pcBinIf->encodeBinsEP(m_prev_pos, 3);
384 } else
385 CABAC_BINS_EP(cabac, Suffix, 3, "coeff_abs_level_remaining");
386 // m_pcBinIf->encodeBinsEP(Suffix, 3);
387 } else {//base_level=3
388 CABAC_BINS_EP(cabac, Suffix, 3, "coeff_abs_level_remaining");
389 //m_pcBinIf->encodeBinsEP(Suffix, 3);
390 if(codeNumber<=15 || codeNumber>23) {
391 uint32_t key = kvz_crypto_get_key(state->crypto_hdl, 3);
392 state->crypto_prev_pos = (Suffix + ( state->crypto_prev_pos^key ) ) & 7;
393 CABAC_BINS_EP(cabac, state->crypto_prev_pos, 3, "coeff_abs_level_remaining");
394 //m_pcBinIf->encodeBinsEP(m_prev_pos, 3);
395 } else
396 if(codeNumber<=19) {
397 uint32_t key = kvz_crypto_get_key(state->crypto_hdl, 2);
398 state->crypto_prev_pos = (( (Suffix&3) + ( state->crypto_prev_pos^key )) &3);
399 CABAC_BINS_EP(cabac, state->crypto_prev_pos, 3, "coeff_abs_level_remaining");
400 //m_pcBinIf->encodeBinsEP(m_prev_pos, 3);
401 } else
402 if(codeNumber<=23) {
403 uint32_t key = kvz_crypto_get_key(state->crypto_hdl, 1);
404 state->crypto_prev_pos = (Suffix&6)+(( (Suffix&1) + (state->crypto_prev_pos^key )) & 1);
405 CABAC_BINS_EP(cabac, state->crypto_prev_pos, 3, "coeff_abs_level_remaining");
406 //m_pcBinIf->encodeBinsEP(m_prev_pos, 3);
407 }
408 }
409 } else
410 if(r_param==4) {
411 if( base_level ==1) {
412 uint32_t key = kvz_crypto_get_key(state->crypto_hdl, 4);
413 state->crypto_prev_pos = ( Suffix + ( state->crypto_prev_pos^key ) ) & 15;
414 CABAC_BINS_EP(cabac, state->crypto_prev_pos, 4, "coeff_abs_level_remaining");
415 //m_pcBinIf->encodeBinsEP(m_prev_pos, 4);
416 } else
417 if( base_level ==2) {
418 if(codeNumber<=31 || codeNumber>47) {
419 uint32_t key = kvz_crypto_get_key(state->crypto_hdl, 4);
420 state->crypto_prev_pos = ( Suffix + ( state->crypto_prev_pos^key ) ) & 15;
421 CABAC_BINS_EP(cabac, state->crypto_prev_pos, r_param, "coeff_abs_level_remaining");
422 //m_pcBinIf->encodeBinsEP(m_prev_pos, r_param);
423 } else
424 if(codeNumber<=39) {
425 uint32_t key = kvz_crypto_get_key(state->crypto_hdl, 3);
426 state->crypto_prev_pos = (( (Suffix&7) + ( state->crypto_prev_pos^key )) & 7);
427 CABAC_BINS_EP(cabac, state->crypto_prev_pos, 4, "coeff_abs_level_remaining");
428 //m_pcBinIf->encodeBinsEP(m_prev_pos, 4);
429 } else
430 if(codeNumber<=43) {
431 uint32_t key = kvz_crypto_get_key(state->crypto_hdl, 2);
432 state->crypto_prev_pos = 8+(( (Suffix&3) + ( state->crypto_prev_pos^key )) & 3);
433 CABAC_BINS_EP(cabac, state->crypto_prev_pos, 4, "coeff_abs_level_remaining");
434 //m_pcBinIf->encodeBinsEP(m_prev_pos, 4);
435 } else
436 if(codeNumber<=45){
437 uint32_t key = kvz_crypto_get_key(state->crypto_hdl, 1);
438 state->crypto_prev_pos = 12+(( (Suffix&1) + ( state->crypto_prev_pos^key )) & 1);
439 CABAC_BINS_EP(cabac, state->crypto_prev_pos, 4, "coeff_abs_level_remaining");
440 //m_pcBinIf->encodeBinsEP(m_prev_pos, 4);
441 } else
442 CABAC_BINS_EP(cabac, Suffix, 4, "coeff_abs_level_remaining");
443 //m_pcBinIf->encodeBinsEP(Suffix, 4);
444 } else {//base_level=3
445 if(codeNumber<=31 || codeNumber>47) {
446 uint32_t key = kvz_crypto_get_key(state->crypto_hdl, 4);
447 state->crypto_prev_pos = (Suffix + ( state->crypto_prev_pos^key ) ) & 15;
448 CABAC_BINS_EP(cabac, state->crypto_prev_pos, r_param, "coeff_abs_level_remaining");
449 //m_pcBinIf->encodeBinsEP(m_prev_pos, r_param);
450 } else
451 if(codeNumber<=39) {
452 uint32_t key = kvz_crypto_get_key(state->crypto_hdl, 3);
453 state->crypto_prev_pos = (( (Suffix&7) + ( state->crypto_prev_pos^key )) & 7);
454 CABAC_BINS_EP(cabac, state->crypto_prev_pos, 4, "coeff_abs_level_remaining");
455 //m_pcBinIf->encodeBinsEP(m_prev_pos, 4);
456 } else
457 if(codeNumber<=43) {
458 uint32_t key = kvz_crypto_get_key(state->crypto_hdl, 2);
459 state->crypto_prev_pos = 8+(( (Suffix&3) + ( state->crypto_prev_pos^key )) & 3);
460 CABAC_BINS_EP(cabac, state->crypto_prev_pos, 4, "coeff_abs_level_remaining");
461 //m_pcBinIf->encodeBinsEP(m_prev_pos, 4);
462 } else
463 if(codeNumber<=47) {
464 uint32_t key = kvz_crypto_get_key(state->crypto_hdl, 1);
465 state->crypto_prev_pos = (Suffix&14)+(( (Suffix&1) + (state->crypto_prev_pos^key )) & 1);
466 CABAC_BINS_EP(cabac, state->crypto_prev_pos, 4, "coeff_abs_level_remaining");
467 //m_pcBinIf->encodeBinsEP(m_prev_pos, 4);
468 }
469 }
470 }
471 } else {
472 length = r_param;
473 codeNumber = codeNumber - ( 3 << r_param);
474 while (codeNumber >= (1<<length)) {
475 codeNumber -= (1<<(length));
476 ++length;
477 }
478 CABAC_BINS_EP(cabac, (1 << (3 + length + 1 - r_param)) - 2, 3 + length + 1 - r_param, "coeff_abs_level_remaining");
479 //m_pcBinIf->encodeBinsEP((1<<(COEF_REMAIN_BIN_REDUCTION+length+1-r_param))-2,COEF_REMAIN_BIN_REDUCTION+length+1-r_param);
480 uint32_t Suffix = codeNumber;
481 uint32_t key = kvz_crypto_get_key(state->crypto_hdl, length);
482 uint32_t mask = ( (1<<length ) -1 );
483 state->crypto_prev_pos = ( Suffix + ( state->crypto_prev_pos^key ) ) & mask;
484 CABAC_BINS_EP(cabac, state->crypto_prev_pos, length, "coeff_abs_level_remaining");
485 //m_pcBinIf->encodeBinsEP(m_prev_pos,length);
486 }
487 }
488 /**
489 * \brief
490 */
kvz_cabac_write_unary_max_symbol(cabac_data_t * const data,cabac_ctx_t * const ctx,uint32_t symbol,const int32_t offset,const uint32_t max_symbol)491 void kvz_cabac_write_unary_max_symbol(cabac_data_t * const data, cabac_ctx_t * const ctx, uint32_t symbol, const int32_t offset, const uint32_t max_symbol)
492 {
493 int8_t code_last = max_symbol > symbol;
494
495 assert(symbol <= max_symbol);
496
497 if (!max_symbol) return;
498
499 data->cur_ctx = &ctx[0];
500 CABAC_BIN(data, symbol, "ums");
501
502 if (!symbol) return;
503
504 while (--symbol) {
505 data->cur_ctx = &ctx[offset];
506 CABAC_BIN(data, 1, "ums");
507 }
508 if (code_last) {
509 data->cur_ctx = &ctx[offset];
510 CABAC_BIN(data, 0, "ums");
511 }
512 }
513
514 /**
515 * This can be used for Truncated Rice binarization with cRiceParam=0.
516 */
kvz_cabac_write_unary_max_symbol_ep(cabac_data_t * const data,unsigned int symbol,const unsigned int max_symbol)517 void kvz_cabac_write_unary_max_symbol_ep(cabac_data_t * const data, unsigned int symbol, const unsigned int max_symbol)
518 {
519 /*if (symbol == 0) {
520 CABAC_BIN_EP(data, 0, "ums_ep");
521 } else {
522 // Make a bit-string of (symbol) times 1 and a single 0, except when
523 // symbol == max_symbol.
524 unsigned bins = ((1 << symbol) - 1) << (symbol < max_symbol);
525 CABAC_BINS_EP(data, bins, symbol + (symbol < max_symbol), "ums_ep");
526 }*/
527
528 int8_t code_last = max_symbol > symbol;
529
530 assert(symbol <= max_symbol);
531
532 CABAC_BIN_EP(data, symbol ? 1 : 0, "ums_ep");
533
534 if (!symbol) return;
535
536 while (--symbol) {
537 CABAC_BIN_EP(data, 1, "ums_ep");
538 }
539 if (code_last) {
540 CABAC_BIN_EP(data, 0, "ums_ep");
541 }
542 }
543
544 /**
545 * \brief
546 */
kvz_cabac_write_ep_ex_golomb(encoder_state_t * const state,cabac_data_t * const data,uint32_t symbol,uint32_t count)547 void kvz_cabac_write_ep_ex_golomb(encoder_state_t * const state,
548 cabac_data_t * const data,
549 uint32_t symbol,
550 uint32_t count)
551 {
552 uint32_t bins = 0;
553 int32_t num_bins = 0;
554
555 while (symbol >= (uint32_t)(1 << count)) {
556 bins = 2 * bins + 1;
557 ++num_bins;
558 symbol -= 1 << count;
559 ++count;
560 }
561 bins = 2 * bins;
562 ++num_bins;
563
564 bins = (bins << count) | symbol;
565 num_bins += count;
566 if (!data->only_count) {
567 if (state->encoder_control->cfg.crypto_features & KVZ_CRYPTO_MVs) {
568 uint32_t key, mask;
569 key = kvz_crypto_get_key(state->crypto_hdl, num_bins>>1);
570 mask = ( (1<<(num_bins >>1) ) -1 );
571 state->crypto_prev_pos = ( bins + ( state->crypto_prev_pos^key ) ) & mask;
572 bins = ( (bins >> (num_bins >>1) ) << (num_bins >>1) ) | state->crypto_prev_pos;
573 }
574 }
575 kvz_cabac_encode_bins_ep(data, bins, num_bins);
576 }
577