hevc: Add names for reserved NAL unit types
[libav.git] / libavcodec / intrax8.c
1 /*
2 * This file is part of Libav.
3 *
4 * Libav is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
8 *
9 * Libav is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with Libav; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17 */
18
19 /**
20 * @file
21 * @brief IntraX8 (J-Frame) subdecoder, used by WMV2 and VC-1
22 */
23
24 #include "avcodec.h"
25 #include "get_bits.h"
26 #include "idctdsp.h"
27 #include "msmpeg4data.h"
28 #include "intrax8huf.h"
29 #include "intrax8.h"
30 #include "intrax8dsp.h"
31 #include "mpegutils.h"
32
33 #define MAX_TABLE_DEPTH(table_bits, max_bits) \
34 ((max_bits + table_bits - 1) / table_bits)
35
36 #define DC_VLC_BITS 9
37 #define AC_VLC_BITS 9
38 #define OR_VLC_BITS 7
39
40 #define DC_VLC_MTD MAX_TABLE_DEPTH(DC_VLC_BITS, MAX_DC_VLC_BITS)
41 #define AC_VLC_MTD MAX_TABLE_DEPTH(AC_VLC_BITS, MAX_AC_VLC_BITS)
42 #define OR_VLC_MTD MAX_TABLE_DEPTH(OR_VLC_BITS, MAX_OR_VLC_BITS)
43
44 static VLC j_ac_vlc[2][2][8]; // [quant < 13], [intra / inter], [select]
45 static VLC j_dc_vlc[2][8]; // [quant], [select]
46 static VLC j_orient_vlc[2][4]; // [quant], [select]
47
48 static av_cold int x8_vlc_init(void)
49 {
50 int i;
51 int offset = 0;
52 int sizeidx = 0;
53 static const uint16_t sizes[8 * 4 + 8 * 2 + 2 + 4] = {
54 576, 548, 582, 618, 546, 616, 560, 642,
55 584, 582, 704, 664, 512, 544, 656, 640,
56 512, 648, 582, 566, 532, 614, 596, 648,
57 586, 552, 584, 590, 544, 578, 584, 624,
58
59 528, 528, 526, 528, 536, 528, 526, 544,
60 544, 512, 512, 528, 528, 544, 512, 544,
61
62 128, 128, 128, 128, 128, 128,
63 };
64
65 static VLC_TYPE table[28150][2];
66
67 // set ac tables
68 #define init_ac_vlc(dst, src) \
69 do { \
70 dst.table = &table[offset]; \
71 dst.table_allocated = sizes[sizeidx]; \
72 offset += sizes[sizeidx++]; \
73 init_vlc(&dst, AC_VLC_BITS, 77, &src[1], 4, 2, &src[0], 4, 2, \
74 INIT_VLC_USE_NEW_STATIC); \
75 } while(0)
76
77 for (i = 0; i < 8; i++) {
78 init_ac_vlc(j_ac_vlc[0][0][i], x8_ac0_highquant_table[i][0]);
79 init_ac_vlc(j_ac_vlc[0][1][i], x8_ac1_highquant_table[i][0]);
80 init_ac_vlc(j_ac_vlc[1][0][i], x8_ac0_lowquant_table[i][0]);
81 init_ac_vlc(j_ac_vlc[1][1][i], x8_ac1_lowquant_table[i][0]);
82 }
83 #undef init_ac_vlc
84
85 // set dc tables
86 #define init_dc_vlc(dst, src) \
87 do { \
88 dst.table = &table[offset]; \
89 dst.table_allocated = sizes[sizeidx]; \
90 offset += sizes[sizeidx++]; \
91 init_vlc(&dst, DC_VLC_BITS, 34, &src[1], 4, 2, &src[0], 4, 2, \
92 INIT_VLC_USE_NEW_STATIC); \
93 } while(0)
94
95 for (i = 0; i < 8; i++) {
96 init_dc_vlc(j_dc_vlc[0][i], x8_dc_highquant_table[i][0]);
97 init_dc_vlc(j_dc_vlc[1][i], x8_dc_lowquant_table[i][0]);
98 }
99 #undef init_dc_vlc
100
101 // set orient tables
102 #define init_or_vlc(dst, src) \
103 do { \
104 dst.table = &table[offset]; \
105 dst.table_allocated = sizes[sizeidx]; \
106 offset += sizes[sizeidx++]; \
107 init_vlc(&dst, OR_VLC_BITS, 12, &src[1], 4, 2, &src[0], 4, 2, \
108 INIT_VLC_USE_NEW_STATIC); \
109 } while(0)
110
111 for (i = 0; i < 2; i++)
112 init_or_vlc(j_orient_vlc[0][i], x8_orient_highquant_table[i][0]);
113 for (i = 0; i < 4; i++)
114 init_or_vlc(j_orient_vlc[1][i], x8_orient_lowquant_table[i][0]);
115 #undef init_or_vlc
116
117 if (offset != sizeof(table) / sizeof(VLC_TYPE) / 2) {
118 av_log(NULL, AV_LOG_ERROR, "table size %zd does not match needed %i\n",
119 sizeof(table) / sizeof(VLC_TYPE) / 2, offset);
120 return AVERROR_INVALIDDATA;
121 }
122
123 return 0;
124 }
125
126 static void x8_reset_vlc_tables(IntraX8Context *w)
127 {
128 memset(w->j_dc_vlc, 0, sizeof(w->j_dc_vlc));
129 memset(w->j_ac_vlc, 0, sizeof(w->j_ac_vlc));
130 w->j_orient_vlc = NULL;
131 }
132
133 static inline void x8_select_ac_table(IntraX8Context *const w, int mode)
134 {
135 int table_index;
136
137 assert(mode < 4);
138
139 if (w->j_ac_vlc[mode])
140 return;
141
142 table_index = get_bits(w->gb, 3);
143 // 2 modes use same tables
144 w->j_ac_vlc[mode] = &j_ac_vlc[w->quant < 13][mode >> 1][table_index];
145
146 assert(w->j_ac_vlc[mode]);
147 }
148
149 static inline int x8_get_orient_vlc(IntraX8Context *w)
150 {
151 if (!w->j_orient_vlc) {
152 int table_index = get_bits(w->gb, 1 + (w->quant < 13));
153 w->j_orient_vlc = &j_orient_vlc[w->quant < 13][table_index];
154 }
155 assert(w->j_orient_vlc);
156 assert(w->j_orient_vlc->table);
157
158 return get_vlc2(w->gb, w->j_orient_vlc->table, OR_VLC_BITS, OR_VLC_MTD);
159 }
160
161 #define extra_bits(eb) (eb) // 3 bits
162 #define extra_run (0xFF << 8) // 1 bit
163 #define extra_level (0x00 << 8) // 1 bit
164 #define run_offset(r) ((r) << 16) // 6 bits
165 #define level_offset(l) ((l) << 24) // 5 bits
166 static const uint32_t ac_decode_table[] = {
167 /* 46 */ extra_bits(3) | extra_run | run_offset(16) | level_offset(0),
168 /* 47 */ extra_bits(3) | extra_run | run_offset(24) | level_offset(0),
169 /* 48 */ extra_bits(2) | extra_run | run_offset(4) | level_offset(1),
170 /* 49 */ extra_bits(3) | extra_run | run_offset(8) | level_offset(1),
171
172 /* 50 */ extra_bits(5) | extra_run | run_offset(32) | level_offset(0),
173 /* 51 */ extra_bits(4) | extra_run | run_offset(16) | level_offset(1),
174
175 /* 52 */ extra_bits(2) | extra_level | run_offset(0) | level_offset(4),
176 /* 53 */ extra_bits(2) | extra_level | run_offset(0) | level_offset(8),
177 /* 54 */ extra_bits(2) | extra_level | run_offset(0) | level_offset(12),
178 /* 55 */ extra_bits(3) | extra_level | run_offset(0) | level_offset(16),
179 /* 56 */ extra_bits(3) | extra_level | run_offset(0) | level_offset(24),
180
181 /* 57 */ extra_bits(2) | extra_level | run_offset(1) | level_offset(3),
182 /* 58 */ extra_bits(3) | extra_level | run_offset(1) | level_offset(7),
183
184 /* 59 */ extra_bits(2) | extra_run | run_offset(16) | level_offset(0),
185 /* 60 */ extra_bits(2) | extra_run | run_offset(20) | level_offset(0),
186 /* 61 */ extra_bits(2) | extra_run | run_offset(24) | level_offset(0),
187 /* 62 */ extra_bits(2) | extra_run | run_offset(28) | level_offset(0),
188 /* 63 */ extra_bits(4) | extra_run | run_offset(32) | level_offset(0),
189 /* 64 */ extra_bits(4) | extra_run | run_offset(48) | level_offset(0),
190
191 /* 65 */ extra_bits(2) | extra_run | run_offset(4) | level_offset(1),
192 /* 66 */ extra_bits(3) | extra_run | run_offset(8) | level_offset(1),
193 /* 67 */ extra_bits(4) | extra_run | run_offset(16) | level_offset(1),
194
195 /* 68 */ extra_bits(2) | extra_level | run_offset(0) | level_offset(4),
196 /* 69 */ extra_bits(3) | extra_level | run_offset(0) | level_offset(8),
197 /* 70 */ extra_bits(4) | extra_level | run_offset(0) | level_offset(16),
198
199 /* 71 */ extra_bits(2) | extra_level | run_offset(1) | level_offset(3),
200 /* 72 */ extra_bits(3) | extra_level | run_offset(1) | level_offset(7),
201 };
202 #undef extra_bits
203 #undef extra_run
204 #undef extra_level
205 #undef run_offset
206 #undef level_offset
207
208 static void x8_get_ac_rlf(IntraX8Context *const w, const int mode,
209 int *const run, int *const level, int *const final)
210 {
211 int i, e;
212
213 // x8_select_ac_table(w, mode);
214 i = get_vlc2(w->gb, w->j_ac_vlc[mode]->table, AC_VLC_BITS, AC_VLC_MTD);
215
216 if (i < 46) { // [0-45]
217 int t, l;
218 if (i < 0) {
219 *level =
220 *final = // prevent 'may be used uninitialized'
221 *run = 64; // this would cause error exit in the ac loop
222 return;
223 }
224
225 /*
226 * i == 0-15 r = 0-15 l = 0; r = i & %01111
227 * i == 16-19 r = 0-3 l = 1; r = i & %00011
228 * i == 20-21 r = 0-1 l = 2; r = i & %00001
229 * i == 22 r = 0 l = 3; r = i & %00000
230 */
231
232 *final =
233 t = i > 22;
234 i -= 23 * t;
235
236 /* l = lut_l[i / 2] = { 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 2, 3 }[i >> 1];
237 * 11 10'01 01'00 00'00 00'00 00'00 00 => 0xE50000 */
238 l = (0xE50000 >> (i & 0x1E)) & 3; // 0x1E or ~1 or (i >> 1 << 1)
239
240 /* t = lut_mask[l] = { 0x0f, 0x03, 0x01, 0x00 }[l];
241 * as i < 256 the higher bits do not matter */
242 t = 0x01030F >> (l << 3);
243
244 *run = i & t;
245 *level = l;
246 } else if (i < 73) { // [46-72]
247 uint32_t sm;
248 uint32_t mask;
249
250 i -= 46;
251 sm = ac_decode_table[i];
252
253 e = get_bits(w->gb, sm & 0xF);
254 sm >>= 8; // 3 bits
255 mask = sm & 0xff;
256 sm >>= 8; // 1 bit
257
258 *run = (sm & 0xff) + (e & mask); // 6 bits
259 *level = (sm >> 8) + (e & ~mask); // 5 bits
260 *final = i > (58 - 46);
261 } else if (i < 75) { // [73-74]
262 static const uint8_t crazy_mix_runlevel[32] = {
263 0x22, 0x32, 0x33, 0x53, 0x23, 0x42, 0x43, 0x63,
264 0x24, 0x52, 0x34, 0x73, 0x25, 0x62, 0x44, 0x83,
265 0x26, 0x72, 0x35, 0x54, 0x27, 0x82, 0x45, 0x64,
266 0x28, 0x92, 0x36, 0x74, 0x29, 0xa2, 0x46, 0x84,
267 };
268
269 *final = !(i & 1);
270 e = get_bits(w->gb, 5); // get the extra bits
271 *run = crazy_mix_runlevel[e] >> 4;
272 *level = crazy_mix_runlevel[e] & 0x0F;
273 } else {
274 *level = get_bits(w->gb, 7 - 3 * (i & 1));
275 *run = get_bits(w->gb, 6);
276 *final = get_bits1(w->gb);
277 }
278 return;
279 }
280
281 /* static const uint8_t dc_extra_sbits[] = {
282 * 0, 1, 1, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7,
283 * }; */
284 static const uint8_t dc_index_offset[] = {
285 0, 1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
286 };
287
288 static int x8_get_dc_rlf(IntraX8Context *const w, const int mode,
289 int *const level, int *const final)
290 {
291 int i, e, c;
292
293 assert(mode < 3);
294 if (!w->j_dc_vlc[mode]) {
295 int table_index = get_bits(w->gb, 3);
296 // 4 modes, same table
297 w->j_dc_vlc[mode] = &j_dc_vlc[w->quant < 13][table_index];
298 }
299 assert(w->j_dc_vlc);
300 assert(w->j_dc_vlc[mode]->table);
301
302 i = get_vlc2(w->gb, w->j_dc_vlc[mode]->table, DC_VLC_BITS, DC_VLC_MTD);
303
304 /* (i >= 17) { i -= 17; final =1; } */
305 c = i > 16;
306 *final = c;
307 i -= 17 * c;
308
309 if (i <= 0) {
310 *level = 0;
311 return -i;
312 }
313 c = (i + 1) >> 1; // hackish way to calculate dc_extra_sbits[]
314 c -= c > 1;
315
316 e = get_bits(w->gb, c); // get the extra bits
317 i = dc_index_offset[i] + (e >> 1);
318
319 e = -(e & 1); // 0, 0xffffff
320 *level = (i ^ e) - e; // (i ^ 0) - 0, (i ^ 0xff) - (-1)
321 return 0;
322 }
323
324 // end of huffman
325
326 static int x8_setup_spatial_predictor(IntraX8Context *const w, const int chroma)
327 {
328 int range;
329 int sum;
330 int quant;
331
332 w->dsp.setup_spatial_compensation(w->dest[chroma], w->scratchpad,
333 w->frame->linesize[chroma > 0],
334 &range, &sum, w->edges);
335 if (chroma) {
336 w->orient = w->chroma_orient;
337 quant = w->quant_dc_chroma;
338 } else {
339 quant = w->quant;
340 }
341
342 w->flat_dc = 0;
343 if (range < quant || range < 3) {
344 w->orient = 0;
345
346 // yep you read right, a +-1 idct error may break decoding!
347 if (range < 3) {
348 w->flat_dc = 1;
349 sum += 9;
350 // ((1 << 17) + 9) / (8 + 8 + 1 + 2) = 6899
351 w->predicted_dc = sum * 6899 >> 17;
352 }
353 }
354 if (chroma)
355 return 0;
356
357 assert(w->orient < 3);
358 if (range < 2 * w->quant) {
359 if ((w->edges & 3) == 0) {
360 if (w->orient == 1)
361 w->orient = 11;
362 if (w->orient == 2)
363 w->orient = 10;
364 } else {
365 w->orient = 0;
366 }
367 w->raw_orient = 0;
368 } else {
369 static const uint8_t prediction_table[3][12] = {
370 { 0, 8, 4, 10, 11, 2, 6, 9, 1, 3, 5, 7 },
371 { 4, 0, 8, 11, 10, 3, 5, 2, 6, 9, 1, 7 },
372 { 8, 0, 4, 10, 11, 1, 7, 2, 6, 9, 3, 5 },
373 };
374 w->raw_orient = x8_get_orient_vlc(w);
375 if (w->raw_orient < 0)
376 return -1;
377 assert(w->raw_orient < 12);
378 assert(w->orient < 3);
379 w->orient = prediction_table[w->orient][w->raw_orient];
380 }
381 return 0;
382 }
383
384 static void x8_update_predictions(IntraX8Context *const w, const int orient,
385 const int est_run)
386 {
387 w->prediction_table[w->mb_x * 2 + (w->mb_y & 1)] = (est_run << 2) + 1 * (orient == 4) + 2 * (orient == 8);
388 /*
389 * y = 2n + 0 -> // 0 2 4
390 * y = 2n + 1 -> // 1 3 5
391 */
392 }
393
394 static void x8_get_prediction_chroma(IntraX8Context *const w)
395 {
396 w->edges = 1 * !(w->mb_x >> 1);
397 w->edges |= 2 * !(w->mb_y >> 1);
398 w->edges |= 4 * (w->mb_x >= (2 * w->mb_width - 1)); // mb_x for chroma would always be odd
399
400 w->raw_orient = 0;
401 // lut_co[8] = {inv,4,8,8, inv,4,8,8} <- => {1,1,0,0;1,1,0,0} => 0xCC
402 if (w->edges & 3) {
403 w->chroma_orient = 4 << ((0xCC >> w->edges) & 1);
404 return;
405 }
406 // block[x - 1][y | 1 - 1)]
407 w->chroma_orient = (w->prediction_table[2 * w->mb_x - 2] & 0x03) << 2;
408 }
409
410 static void x8_get_prediction(IntraX8Context *const w)
411 {
412 int a, b, c, i;
413
414 w->edges = 1 * !w->mb_x;
415 w->edges |= 2 * !w->mb_y;
416 w->edges |= 4 * (w->mb_x >= (2 * w->mb_width - 1));
417
418 switch (w->edges & 3) {
419 case 0:
420 break;
421 case 1:
422 // take the one from the above block[0][y - 1]
423 w->est_run = w->prediction_table[!(w->mb_y & 1)] >> 2;
424 w->orient = 1;
425 return;
426 case 2:
427 // take the one from the previous block[x - 1][0]
428 w->est_run = w->prediction_table[2 * w->mb_x - 2] >> 2;
429 w->orient = 2;
430 return;
431 case 3:
432 w->est_run = 16;
433 w->orient = 0;
434 return;
435 }
436 // no edge cases
437 b = w->prediction_table[2 * w->mb_x + !(w->mb_y & 1)]; // block[x ][y - 1]
438 a = w->prediction_table[2 * w->mb_x - 2 + (w->mb_y & 1)]; // block[x - 1][y ]
439 c = w->prediction_table[2 * w->mb_x - 2 + !(w->mb_y & 1)]; // block[x - 1][y - 1]
440
441 w->est_run = FFMIN(b, a);
442 /* This condition has nothing to do with w->edges, even if it looks
443 * similar it would trigger if e.g. x = 3; y = 2;
444 * I guess somebody wrote something wrong and it became standard. */
445 if ((w->mb_x & w->mb_y) != 0)
446 w->est_run = FFMIN(c, w->est_run);
447 w->est_run >>= 2;
448
449 a &= 3;
450 b &= 3;
451 c &= 3;
452
453 i = (0xFFEAF4C4 >> (2 * b + 8 * a)) & 3;
454 if (i != 3)
455 w->orient = i;
456 else
457 w->orient = (0xFFEAD8 >> (2 * c + 8 * (w->quant > 12))) & 3;
458 /*
459 * lut1[b][a] = {
460 * ->{ 0, 1, 0, pad },
461 * { 0, 1, X, pad },
462 * { 2, 2, 2, pad }
463 * }
464 * pad 2 2 2;
465 * pad X 1 0;
466 * pad 0 1 0 <-
467 * -> 11 10 '10 10 '11 11'01 00 '11 00'01 00 => 0xEAF4C4
468 *
469 * lut2[q>12][c] = {
470 * ->{ 0, 2, 1, pad},
471 * { 2, 2, 2, pad}
472 * }
473 * pad 2 2 2;
474 * pad 1 2 0 <-
475 * -> 11 10'10 10 '11 01'10 00 => 0xEAD8
476 */
477 }
478
479 static void x8_ac_compensation(IntraX8Context *const w, const int direction,
480 const int dc_level)
481 {
482 int t;
483 #define B(x, y) w->block[0][w->idsp.idct_permutation[(x) + (y) * 8]]
484 #define T(x) ((x) * dc_level + 0x8000) >> 16;
485 switch (direction) {
486 case 0:
487 t = T(3811); // h
488 B(1, 0) -= t;
489 B(0, 1) -= t;
490
491 t = T(487); // e
492 B(2, 0) -= t;
493 B(0, 2) -= t;
494
495 t = T(506); // f
496 B(3, 0) -= t;
497 B(0, 3) -= t;
498
499 t = T(135); // c
500 B(4, 0) -= t;
501 B(0, 4) -= t;
502 B(2, 1) += t;
503 B(1, 2) += t;
504 B(3, 1) += t;
505 B(1, 3) += t;
506
507 t = T(173); // d
508 B(5, 0) -= t;
509 B(0, 5) -= t;
510
511 t = T(61); // b
512 B(6, 0) -= t;
513 B(0, 6) -= t;
514 B(5, 1) += t;
515 B(1, 5) += t;
516
517 t = T(42); // a
518 B(7, 0) -= t;
519 B(0, 7) -= t;
520 B(4, 1) += t;
521 B(1, 4) += t;
522 B(4, 4) += t;
523
524 t = T(1084); // g
525 B(1, 1) += t;
526
527 w->block_last_index[0] = FFMAX(w->block_last_index[0], 7 * 8);
528 break;
529 case 1:
530 B(0, 1) -= T(6269);
531 B(0, 3) -= T(708);
532 B(0, 5) -= T(172);
533 B(0, 7) -= T(73);
534
535 w->block_last_index[0] = FFMAX(w->block_last_index[0], 7 * 8);
536 break;
537 case 2:
538 B(1, 0) -= T(6269);
539 B(3, 0) -= T(708);
540 B(5, 0) -= T(172);
541 B(7, 0) -= T(73);
542
543 w->block_last_index[0] = FFMAX(w->block_last_index[0], 7);
544 break;
545 }
546 #undef B
547 #undef T
548 }
549
550 static void dsp_x8_put_solidcolor(const uint8_t pix, uint8_t *dst,
551 const ptrdiff_t linesize)
552 {
553 int k;
554 for (k = 0; k < 8; k++) {
555 memset(dst, pix, 8);
556 dst += linesize;
557 }
558 }
559
560 static const int16_t quant_table[64] = {
561 256, 256, 256, 256, 256, 256, 259, 262,
562 265, 269, 272, 275, 278, 282, 285, 288,
563 292, 295, 299, 303, 306, 310, 314, 317,
564 321, 325, 329, 333, 337, 341, 345, 349,
565 353, 358, 362, 366, 371, 375, 379, 384,
566 389, 393, 398, 403, 408, 413, 417, 422,
567 428, 433, 438, 443, 448, 454, 459, 465,
568 470, 476, 482, 488, 493, 499, 505, 511,
569 };
570
571 static int x8_decode_intra_mb(IntraX8Context *const w, const int chroma)
572 {
573 uint8_t *scantable;
574 int final, run, level;
575 int ac_mode, dc_mode, est_run, dc_level;
576 int pos, n;
577 int zeros_only;
578 int use_quant_matrix;
579 int sign;
580
581 assert(w->orient < 12);
582 w->bdsp.clear_block(w->block[0]);
583
584 if (chroma)
585 dc_mode = 2;
586 else
587 dc_mode = !!w->est_run; // 0, 1
588
589 if (x8_get_dc_rlf(w, dc_mode, &dc_level, &final))
590 return -1;
591 n = 0;
592 zeros_only = 0;
593 if (!final) { // decode ac
594 use_quant_matrix = w->use_quant_matrix;
595 if (chroma) {
596 ac_mode = 1;
597 est_run = 64; // not used
598 } else {
599 if (w->raw_orient < 3)
600 use_quant_matrix = 0;
601
602 if (w->raw_orient > 4) {
603 ac_mode = 0;
604 est_run = 64;
605 } else {
606 if (w->est_run > 1) {
607 ac_mode = 2;
608 est_run = w->est_run;
609 } else {
610 ac_mode = 3;
611 est_run = 64;
612 }
613 }
614 }
615 x8_select_ac_table(w, ac_mode);
616 /* scantable_selector[12] = { 0, 2, 0, 1, 1, 1, 0, 2, 2, 0, 1, 2 }; <-
617 * -> 10'01' 00'10' 10'00' 01'01' 01'00' 10'00 => 0x928548 */
618 scantable = w->scantable[(0x928548 >> (2 * w->orient)) & 3].permutated;
619 pos = 0;
620 do {
621 n++;
622 if (n >= est_run) {
623 ac_mode = 3;
624 x8_select_ac_table(w, 3);
625 }
626
627 x8_get_ac_rlf(w, ac_mode, &run, &level, &final);
628
629 pos += run + 1;
630 if (pos > 63) {
631 // this also handles vlc error in x8_get_ac_rlf
632 return -1;
633 }
634 level = (level + 1) * w->dquant;
635 level += w->qsum;
636
637 sign = -get_bits1(w->gb);
638 level = (level ^ sign) - sign;
639
640 if (use_quant_matrix)
641 level = (level * quant_table[pos]) >> 8;
642
643 w->block[0][scantable[pos]] = level;
644 } while (!final);
645
646 w->block_last_index[0] = pos;
647 } else { // DC only
648 w->block_last_index[0] = 0;
649 if (w->flat_dc && ((unsigned) (dc_level + 1)) < 3) { // [-1; 1]
650 int32_t divide_quant = !chroma ? w->divide_quant_dc_luma
651 : w->divide_quant_dc_chroma;
652 int32_t dc_quant = !chroma ? w->quant
653 : w->quant_dc_chroma;
654
655 // original intent dc_level += predicted_dc/quant;
656 // but it got lost somewhere in the rounding
657 dc_level += (w->predicted_dc * divide_quant + (1 << 12)) >> 13;
658
659 dsp_x8_put_solidcolor(av_clip_uint8((dc_level * dc_quant + 4) >> 3),
660 w->dest[chroma],
661 w->frame->linesize[!!chroma]);
662
663 goto block_placed;
664 }
665 zeros_only = dc_level == 0;
666 }
667 if (!chroma)
668 w->block[0][0] = dc_level * w->quant;
669 else
670 w->block[0][0] = dc_level * w->quant_dc_chroma;
671
672 // there is !zero_only check in the original, but dc_level check is enough
673 if ((unsigned int) (dc_level + 1) >= 3 && (w->edges & 3) != 3) {
674 int direction;
675 /* ac_comp_direction[orient] = { 0, 3, 3, 1, 1, 0, 0, 0, 2, 2, 2, 1 }; <-
676 * -> 01'10' 10'10' 00'00' 00'01' 01'11' 11'00 => 0x6A017C */
677 direction = (0x6A017C >> (w->orient * 2)) & 3;
678 if (direction != 3) {
679 // modify block_last[]
680 x8_ac_compensation(w, direction, w->block[0][0]);
681 }
682 }
683
684 if (w->flat_dc) {
685 dsp_x8_put_solidcolor(w->predicted_dc, w->dest[chroma],
686 w->frame->linesize[!!chroma]);
687 } else {
688 w->dsp.spatial_compensation[w->orient](w->scratchpad,
689 w->dest[chroma],
690 w->frame->linesize[!!chroma]);
691 }
692 if (!zeros_only)
693 w->idsp.idct_add(w->dest[chroma],
694 w->frame->linesize[!!chroma],
695 w->block[0]);
696
697 block_placed:
698 if (!chroma)
699 x8_update_predictions(w, w->orient, n);
700
701 if (w->loopfilter) {
702 uint8_t *ptr = w->dest[chroma];
703 ptrdiff_t linesize = w->frame->linesize[!!chroma];
704
705 if (!((w->edges & 2) || (zeros_only && (w->orient | 4) == 4)))
706 w->dsp.h_loop_filter(ptr, linesize, w->quant);
707
708 if (!((w->edges & 1) || (zeros_only && (w->orient | 8) == 8)))
709 w->dsp.v_loop_filter(ptr, linesize, w->quant);
710 }
711 return 0;
712 }
713
714 // FIXME maybe merge with ff_*
715 static void x8_init_block_index(IntraX8Context *w, AVFrame *frame)
716 {
717 // not parent codec linesize as this would be wrong for field pics
718 // not that IntraX8 has interlacing support ;)
719 const ptrdiff_t linesize = frame->linesize[0];
720 const ptrdiff_t uvlinesize = frame->linesize[1];
721
722 w->dest[0] = frame->data[0];
723 w->dest[1] = frame->data[1];
724 w->dest[2] = frame->data[2];
725
726 w->dest[0] += w->mb_y * linesize << 3;
727 // chroma blocks are on add rows
728 w->dest[1] += (w->mb_y & ~1) * uvlinesize << 2;
729 w->dest[2] += (w->mb_y & ~1) * uvlinesize << 2;
730 }
731
732 av_cold int ff_intrax8_common_init(AVCodecContext *avctx,
733 IntraX8Context *w, IDCTDSPContext *idsp,
734 int16_t (*block)[64],
735 int block_last_index[12],
736 int mb_width, int mb_height)
737 {
738 int ret = x8_vlc_init();
739 if (ret < 0)
740 return ret;
741
742 w->avctx = avctx;
743 w->idsp = *idsp;
744 w->mb_width = mb_width;
745 w->mb_height = mb_height;
746 w->block = block;
747 w->block_last_index = block_last_index;
748
749 // two rows, 2 blocks per cannon mb
750 w->prediction_table = av_mallocz(w->mb_width * 2 * 2);
751 if (!w->prediction_table)
752 return AVERROR(ENOMEM);
753
754 ff_init_scantable(w->idsp.idct_permutation, &w->scantable[0],
755 ff_wmv1_scantable[0]);
756 ff_init_scantable(w->idsp.idct_permutation, &w->scantable[1],
757 ff_wmv1_scantable[2]);
758 ff_init_scantable(w->idsp.idct_permutation, &w->scantable[2],
759 ff_wmv1_scantable[3]);
760
761 ff_intrax8dsp_init(&w->dsp);
762 ff_blockdsp_init(&w->bdsp);
763
764 return 0;
765 }
766
767 av_cold void ff_intrax8_common_end(IntraX8Context *w)
768 {
769 av_freep(&w->prediction_table);
770 }
771
772 int ff_intrax8_decode_picture(IntraX8Context *w, Picture *pict,
773 GetBitContext *gb, int *mb_x, int *mb_y,
774 int dquant, int quant_offset,
775 int loopfilter, int lowdelay)
776 {
777 int mb_xy;
778
779 w->gb = gb;
780 w->dquant = dquant;
781 w->quant = dquant >> 1;
782 w->qsum = quant_offset;
783 w->frame = pict->f;
784 w->loopfilter = loopfilter;
785 w->use_quant_matrix = get_bits1(w->gb);
786
787 w->mb_x = *mb_x;
788 w->mb_y = *mb_y;
789
790 w->divide_quant_dc_luma = ((1 << 16) + (w->quant >> 1)) / w->quant;
791 if (w->quant < 5) {
792 w->quant_dc_chroma = w->quant;
793 w->divide_quant_dc_chroma = w->divide_quant_dc_luma;
794 } else {
795 w->quant_dc_chroma = w->quant + ((w->quant + 3) >> 3);
796 w->divide_quant_dc_chroma = ((1 << 16) + (w->quant_dc_chroma >> 1)) / w->quant_dc_chroma;
797 }
798 x8_reset_vlc_tables(w);
799
800 for (w->mb_y = 0; w->mb_y < w->mb_height * 2; w->mb_y++) {
801 x8_init_block_index(w, w->frame);
802 mb_xy = (w->mb_y >> 1) * (w->mb_width + 1);
803 for (w->mb_x = 0; w->mb_x < w->mb_width * 2; w->mb_x++) {
804 x8_get_prediction(w);
805 if (x8_setup_spatial_predictor(w, 0))
806 goto error;
807 if (x8_decode_intra_mb(w, 0))
808 goto error;
809
810 if (w->mb_x & w->mb_y & 1) {
811 x8_get_prediction_chroma(w);
812
813 /* when setting up chroma, no vlc is read,
814 * so no error condition can be reached */
815 x8_setup_spatial_predictor(w, 1);
816 if (x8_decode_intra_mb(w, 1))
817 goto error;
818
819 x8_setup_spatial_predictor(w, 2);
820 if (x8_decode_intra_mb(w, 2))
821 goto error;
822
823 w->dest[1] += 8;
824 w->dest[2] += 8;
825
826 pict->qscale_table[mb_xy] = w->quant;
827 mb_xy++;
828 }
829 w->dest[0] += 8;
830 }
831 if (w->mb_y & 1)
832 ff_draw_horiz_band(w->avctx, w->frame, w->frame,
833 (w->mb_y - 1) * 8, 16,
834 PICT_FRAME, 0, lowdelay);
835 }
836
837 error:
838 *mb_x = w->mb_x;
839 *mb_y = w->mb_y;
840
841 return 0;
842 }