intrax8: Pass macroblock coordinates to ff_intrax8_decode_picture
[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
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 unilitialized'
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;                               // 3bits
255         mask = sm & 0xff;
256         sm >>= 8;                               // 1bit
257
258         (*run)   = (sm & 0xff) + (e & (mask));  // 6bits
259         (*level) = (sm >> 8)   + (e & (~mask)); // 5bits
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     MpegEncContext *const s = w->s;
483     int t;
484 #define B(x, y) s->block[0][w->idsp.idct_permutation[(x) + (y) * 8]]
485 #define T(x)  ((x) * dc_level + 0x8000) >> 16;
486     switch (direction) {
487     case 0:
488         t        = T(3811); // h
489         B(1, 0) -= t;
490         B(0, 1) -= t;
491
492         t        = T(487); // e
493         B(2, 0) -= t;
494         B(0, 2) -= t;
495
496         t        = T(506); // f
497         B(3, 0) -= t;
498         B(0, 3) -= t;
499
500         t        = T(135); // c
501         B(4, 0) -= t;
502         B(0, 4) -= t;
503         B(2, 1) += t;
504         B(1, 2) += t;
505         B(3, 1) += t;
506         B(1, 3) += t;
507
508         t        = T(173); // d
509         B(5, 0) -= t;
510         B(0, 5) -= t;
511
512         t        = T(61); // b
513         B(6, 0) -= t;
514         B(0, 6) -= t;
515         B(5, 1) += t;
516         B(1, 5) += t;
517
518         t        = T(42); // a
519         B(7, 0) -= t;
520         B(0, 7) -= t;
521         B(4, 1) += t;
522         B(1, 4) += t;
523         B(4, 4) += t;
524
525         t        = T(1084); // g
526         B(1, 1) += t;
527
528         s->block_last_index[0] = FFMAX(s->block_last_index[0], 7 * 8);
529         break;
530     case 1:
531         B(0, 1) -= T(6269);
532         B(0, 3) -= T(708);
533         B(0, 5) -= T(172);
534         B(0, 7) -= T(73);
535
536         s->block_last_index[0] = FFMAX(s->block_last_index[0], 7 * 8);
537         break;
538     case 2:
539         B(1, 0) -= T(6269);
540         B(3, 0) -= T(708);
541         B(5, 0) -= T(172);
542         B(7, 0) -= T(73);
543
544         s->block_last_index[0] = FFMAX(s->block_last_index[0], 7);
545         break;
546     }
547 #undef B
548 #undef T
549 }
550
551 static void dsp_x8_put_solidcolor(const uint8_t pix, uint8_t *dst,
552                                   const int linesize)
553 {
554     int k;
555     for (k = 0; k < 8; k++) {
556         memset(dst, pix, 8);
557         dst += linesize;
558     }
559 }
560
561 static const int16_t quant_table[64] = {
562     256, 256, 256, 256, 256, 256, 259, 262,
563     265, 269, 272, 275, 278, 282, 285, 288,
564     292, 295, 299, 303, 306, 310, 314, 317,
565     321, 325, 329, 333, 337, 341, 345, 349,
566     353, 358, 362, 366, 371, 375, 379, 384,
567     389, 393, 398, 403, 408, 413, 417, 422,
568     428, 433, 438, 443, 448, 454, 459, 465,
569     470, 476, 482, 488, 493, 499, 505, 511,
570 };
571
572 static int x8_decode_intra_mb(IntraX8Context *const w, const int chroma)
573 {
574     MpegEncContext *const s = w->s;
575
576     uint8_t *scantable;
577     int final, run, level;
578     int ac_mode, dc_mode, est_run, dc_level;
579     int pos, n;
580     int zeros_only;
581     int use_quant_matrix;
582     int sign;
583
584     assert(w->orient < 12);
585     w->bdsp.clear_block(s->block[0]);
586
587     if (chroma)
588         dc_mode = 2;
589     else
590         dc_mode = !!w->est_run; // 0, 1
591
592     if (x8_get_dc_rlf(w, dc_mode, &dc_level, &final))
593         return -1;
594     n          = 0;
595     zeros_only = 0;
596     if (!final) { // decode ac
597         use_quant_matrix = w->use_quant_matrix;
598         if (chroma) {
599             ac_mode = 1;
600             est_run = 64; // not used
601         } else {
602             if (w->raw_orient < 3)
603                 use_quant_matrix = 0;
604
605             if (w->raw_orient > 4) {
606                 ac_mode = 0;
607                 est_run = 64;
608             } else {
609                 if (w->est_run > 1) {
610                     ac_mode = 2;
611                     est_run = w->est_run;
612                 } else {
613                     ac_mode = 3;
614                     est_run = 64;
615                 }
616             }
617         }
618         x8_select_ac_table(w, ac_mode);
619         /* scantable_selector[12] = { 0, 2, 0, 1, 1, 1, 0, 2, 2, 0, 1, 2 }; <-
620          * -> 10'01' 00'10' 10'00' 01'01' 01'00' 10'00 => 0x928548 */
621         scantable = w->scantable[(0x928548 >> (2 * w->orient)) & 3].permutated;
622         pos       = 0;
623         do {
624             n++;
625             if (n >= est_run) {
626                 ac_mode = 3;
627                 x8_select_ac_table(w, 3);
628             }
629
630             x8_get_ac_rlf(w, ac_mode, &run, &level, &final);
631
632             pos += run + 1;
633             if (pos > 63) {
634                 // this also handles vlc error in x8_get_ac_rlf
635                 return -1;
636             }
637             level  = (level + 1) * w->dquant;
638             level += w->qsum;
639
640             sign  = -get_bits1(w->gb);
641             level = (level ^ sign) - sign;
642
643             if (use_quant_matrix)
644                 level = (level * quant_table[pos]) >> 8;
645
646             s->block[0][scantable[pos]] = level;
647         } while (!final);
648
649         s->block_last_index[0] = pos;
650     } else { // DC only
651         s->block_last_index[0] = 0;
652         if (w->flat_dc && ((unsigned) (dc_level + 1)) < 3) { // [-1; 1]
653             int32_t divide_quant = !chroma ? w->divide_quant_dc_luma
654                                            : w->divide_quant_dc_chroma;
655             int32_t dc_quant     = !chroma ? w->quant
656                                            : w->quant_dc_chroma;
657
658             // original intent dc_level += predicted_dc/quant;
659             // but it got lost somewhere in the rounding
660             dc_level += (w->predicted_dc * divide_quant + (1 << 12)) >> 13;
661
662             dsp_x8_put_solidcolor(av_clip_uint8((dc_level * dc_quant + 4) >> 3),
663                                   w->dest[chroma],
664                                   w->frame->linesize[!!chroma]);
665
666             goto block_placed;
667         }
668         zeros_only = (dc_level == 0);
669     }
670     if (!chroma)
671         s->block[0][0] = dc_level * w->quant;
672     else
673         s->block[0][0] = dc_level * w->quant_dc_chroma;
674
675     // there is !zero_only check in the original, but dc_level check is enough
676     if ((unsigned int) (dc_level + 1) >= 3 && (w->edges & 3) != 3) {
677         int direction;
678         /* ac_comp_direction[orient] = { 0, 3, 3, 1, 1, 0, 0, 0, 2, 2, 2, 1 }; <-
679          * -> 01'10' 10'10' 00'00' 00'01' 01'11' 11'00 => 0x6A017C */
680         direction = (0x6A017C >> (w->orient * 2)) & 3;
681         if (direction != 3) {
682             // modify block_last[]
683             x8_ac_compensation(w, direction, s->block[0][0]);
684         }
685     }
686
687     if (w->flat_dc) {
688         dsp_x8_put_solidcolor(w->predicted_dc, w->dest[chroma],
689                               w->frame->linesize[!!chroma]);
690     } else {
691         w->dsp.spatial_compensation[w->orient](w->scratchpad,
692                                                w->dest[chroma],
693                                                w->frame->linesize[!!chroma]);
694     }
695     if (!zeros_only)
696         w->idsp.idct_add(w->dest[chroma],
697                          w->frame->linesize[!!chroma],
698                          s->block[0]);
699
700 block_placed:
701     if (!chroma)
702         x8_update_predictions(w, w->orient, n);
703
704     if (w->loopfilter) {
705         uint8_t *ptr = w->dest[chroma];
706         int linesize = w->frame->linesize[!!chroma];
707
708         if (!((w->edges & 2) || (zeros_only && (w->orient | 4) == 4)))
709             w->dsp.h_loop_filter(ptr, linesize, w->quant);
710
711         if (!((w->edges & 1) || (zeros_only && (w->orient | 8) == 8)))
712             w->dsp.v_loop_filter(ptr, linesize, w->quant);
713     }
714     return 0;
715 }
716
717 // FIXME maybe merge with ff_*
718 static void x8_init_block_index(IntraX8Context *w, AVFrame *frame)
719 {
720     // not parent codec linesize as this would be wrong for field pics
721     // not that IntraX8 has interlacing support ;)
722     const int linesize   = frame->linesize[0];
723     const int uvlinesize = frame->linesize[1];
724
725     w->dest[0] = frame->data[0];
726     w->dest[1] = frame->data[1];
727     w->dest[2] = frame->data[2];
728
729     w->dest[0] +=  w->mb_y         * linesize   << 3;
730     // chroma blocks are on add rows
731     w->dest[1] += (w->mb_y & (~1)) * uvlinesize << 2;
732     w->dest[2] += (w->mb_y & (~1)) * uvlinesize << 2;
733 }
734
735 av_cold int ff_intrax8_common_init(AVCodecContext *avctx,
736                                    IntraX8Context *w, IDCTDSPContext *idsp,
737                                    int mb_width, int mb_height,
738                                    MpegEncContext *const s)
739 {
740     int ret = x8_vlc_init();
741     if (ret < 0)
742         return ret;
743
744     w->avctx = avctx;
745     w->idsp = *idsp;
746     w->mb_width  = mb_width;
747     w->mb_height = mb_height;
748     w->s = s;
749
750     // two rows, 2 blocks per cannon mb
751     w->prediction_table = av_mallocz(w->mb_width * 2 * 2);
752     if (!w->prediction_table)
753         return AVERROR(ENOMEM);
754
755     ff_init_scantable(w->idsp.idct_permutation, &w->scantable[0],
756                       ff_wmv1_scantable[0]);
757     ff_init_scantable(w->idsp.idct_permutation, &w->scantable[1],
758                       ff_wmv1_scantable[2]);
759     ff_init_scantable(w->idsp.idct_permutation, &w->scantable[2],
760                       ff_wmv1_scantable[3]);
761
762     ff_intrax8dsp_init(&w->dsp);
763     ff_blockdsp_init(&w->bdsp, avctx);
764
765     return 0;
766 }
767
768 av_cold void ff_intrax8_common_end(IntraX8Context *w)
769 {
770     av_freep(&w->prediction_table);
771 }
772
773 int ff_intrax8_decode_picture(IntraX8Context *const w, Picture *pict,
774                               GetBitContext *gb, int *mb_x, int *mb_y,
775                               int dquant, int quant_offset, int loopfilter)
776 {
777     MpegEncContext *const s = w->s;
778     int mb_xy;
779     assert(s);
780
781     w->gb     = gb;
782     w->dquant = dquant;
783     w->quant  = dquant >> 1;
784     w->qsum   = quant_offset;
785     w->frame  = pict->f;
786     w->loopfilter = loopfilter;
787     w->use_quant_matrix = get_bits1(w->gb);
788
789     w->mb_x = *mb_x;
790     w->mb_y = *mb_y;
791
792     w->divide_quant_dc_luma = ((1 << 16) + (w->quant >> 1)) / w->quant;
793     if (w->quant < 5) {
794         w->quant_dc_chroma        = w->quant;
795         w->divide_quant_dc_chroma = w->divide_quant_dc_luma;
796     } else {
797         w->quant_dc_chroma        = w->quant + ((w->quant + 3) >> 3);
798         w->divide_quant_dc_chroma = ((1 << 16) + (w->quant_dc_chroma >> 1)) / w->quant_dc_chroma;
799     }
800     x8_reset_vlc_tables(w);
801
802     for (w->mb_y = 0; w->mb_y < w->mb_height * 2; w->mb_y++) {
803         x8_init_block_index(w, w->frame);
804         mb_xy = (w->mb_y >> 1) * (w->mb_width + 1);
805         for (w->mb_x = 0; w->mb_x < w->mb_width * 2; w->mb_x++) {
806             x8_get_prediction(w);
807             if (x8_setup_spatial_predictor(w, 0))
808                 goto error;
809             if (x8_decode_intra_mb(w, 0))
810                 goto error;
811
812             if (w->mb_x & w->mb_y & 1) {
813                 x8_get_prediction_chroma(w);
814
815                 /* when setting up chroma, no vlc is read,
816                  * so no error condition can be reached */
817                 x8_setup_spatial_predictor(w, 1);
818                 if (x8_decode_intra_mb(w, 1))
819                     goto error;
820
821                 x8_setup_spatial_predictor(w, 2);
822                 if (x8_decode_intra_mb(w, 2))
823                     goto error;
824
825                 w->dest[1] += 8;
826                 w->dest[2] += 8;
827
828                 /* emulate MB info in the relevant tables */
829                 s->mbskip_table[mb_xy]                 = 0;
830                 s->mbintra_table[mb_xy]                = 1;
831                 pict->qscale_table[mb_xy] = w->quant;
832                 mb_xy++;
833             }
834             w->dest[0] += 8;
835         }
836         if (w->mb_y & 1)
837             ff_mpeg_draw_horiz_band(s, (w->mb_y - 1) * 8, 16);
838     }
839
840 error:
841     *mb_x = w->mb_x;
842     *mb_y = w->mb_y;
843
844     return 0;
845 }