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