FFmpeg
cavsdec.c
Go to the documentation of this file.
1 /*
2  * Chinese AVS video (AVS1-P2, JiZhun profile) decoder.
3  * Copyright (c) 2006 Stefan Gehrer <stefan.gehrer@gmx.de>
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 /**
23  * @file
24  * Chinese AVS video (AVS1-P2, JiZhun profile) decoder
25  * @author Stefan Gehrer <stefan.gehrer@gmx.de>
26  */
27 
28 #include "libavutil/avassert.h"
29 #include "avcodec.h"
30 #include "get_bits.h"
31 #include "golomb.h"
32 #include "cavs.h"
33 #include "internal.h"
34 #include "mpeg12data.h"
35 
36 static const uint8_t mv_scan[4] = {
37  MV_FWD_X0, MV_FWD_X1,
38  MV_FWD_X2, MV_FWD_X3
39 };
40 
41 static const uint8_t cbp_tab[64][2] = {
42  { 63, 0 }, { 15, 15 }, { 31, 63 }, { 47, 31 }, { 0, 16 }, { 14, 32 }, { 13, 47 }, { 11, 13 },
43  { 7, 14 }, { 5, 11 }, { 10, 12 }, { 8, 5 }, { 12, 10 }, { 61, 7 }, { 4, 48 }, { 55, 3 },
44  { 1, 2 }, { 2, 8 }, { 59, 4 }, { 3, 1 }, { 62, 61 }, { 9, 55 }, { 6, 59 }, { 29, 62 },
45  { 45, 29 }, { 51, 27 }, { 23, 23 }, { 39, 19 }, { 27, 30 }, { 46, 28 }, { 53, 9 }, { 30, 6 },
46  { 43, 60 }, { 37, 21 }, { 60, 44 }, { 16, 26 }, { 21, 51 }, { 28, 35 }, { 19, 18 }, { 35, 20 },
47  { 42, 24 }, { 26, 53 }, { 44, 17 }, { 32, 37 }, { 58, 39 }, { 24, 45 }, { 20, 58 }, { 17, 43 },
48  { 18, 42 }, { 48, 46 }, { 22, 36 }, { 33, 33 }, { 25, 34 }, { 49, 40 }, { 40, 52 }, { 36, 49 },
49  { 34, 50 }, { 50, 56 }, { 52, 25 }, { 54, 22 }, { 41, 54 }, { 56, 57 }, { 38, 41 }, { 57, 38 }
50 };
51 
52 static const uint8_t scan3x3[4] = { 4, 5, 7, 8 };
53 
54 static const uint8_t dequant_shift[64] = {
55  14, 14, 14, 14, 14, 14, 14, 14,
56  13, 13, 13, 13, 13, 13, 13, 13,
57  13, 12, 12, 12, 12, 12, 12, 12,
58  11, 11, 11, 11, 11, 11, 11, 11,
59  11, 10, 10, 10, 10, 10, 10, 10,
60  10, 9, 9, 9, 9, 9, 9, 9,
61  9, 8, 8, 8, 8, 8, 8, 8,
62  7, 7, 7, 7, 7, 7, 7, 7
63 };
64 
65 static const uint16_t dequant_mul[64] = {
66  32768, 36061, 38968, 42495, 46341, 50535, 55437, 60424,
67  32932, 35734, 38968, 42495, 46177, 50535, 55109, 59933,
68  65535, 35734, 38968, 42577, 46341, 50617, 55027, 60097,
69  32809, 35734, 38968, 42454, 46382, 50576, 55109, 60056,
70  65535, 35734, 38968, 42495, 46320, 50515, 55109, 60076,
71  65535, 35744, 38968, 42495, 46341, 50535, 55099, 60087,
72  65535, 35734, 38973, 42500, 46341, 50535, 55109, 60097,
73  32771, 35734, 38965, 42497, 46341, 50535, 55109, 60099
74 };
75 
76 #define EOB 0, 0, 0
77 
78 static const struct dec_2dvlc intra_dec[7] = {
79  {
80  { //level / run / table_inc
81  { 1, 1, 1 }, { -1, 1, 1 }, { 1, 2, 1 }, { -1, 2, 1 }, { 1, 3, 1 }, { -1, 3, 1 },
82  { 1, 4, 1 }, { -1, 4, 1 }, { 1, 5, 1 }, { -1, 5, 1 }, { 1, 6, 1 }, { -1, 6, 1 },
83  { 1, 7, 1 }, { -1, 7, 1 }, { 1, 8, 1 }, { -1, 8, 1 }, { 1, 9, 1 }, { -1, 9, 1 },
84  { 1, 10, 1 }, { -1, 10, 1 }, { 1, 11, 1 }, { -1, 11, 1 }, { 2, 1, 2 }, { -2, 1, 2 },
85  { 1, 12, 1 }, { -1, 12, 1 }, { 1, 13, 1 }, { -1, 13, 1 }, { 1, 14, 1 }, { -1, 14, 1 },
86  { 1, 15, 1 }, { -1, 15, 1 }, { 2, 2, 2 }, { -2, 2, 2 }, { 1, 16, 1 }, { -1, 16, 1 },
87  { 1, 17, 1 }, { -1, 17, 1 }, { 3, 1, 3 }, { -3, 1, 3 }, { 1, 18, 1 }, { -1, 18, 1 },
88  { 1, 19, 1 }, { -1, 19, 1 }, { 2, 3, 2 }, { -2, 3, 2 }, { 1, 20, 1 }, { -1, 20, 1 },
89  { 1, 21, 1 }, { -1, 21, 1 }, { 2, 4, 2 }, { -2, 4, 2 }, { 1, 22, 1 }, { -1, 22, 1 },
90  { 2, 5, 2 }, { -2, 5, 2 }, { 1, 23, 1 }, { -1, 23, 1 }, { EOB }
91  },
92  //level_add
93  { 0, 4, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, -1, -1, -1 },
94  2, //golomb_order
95  0, //inc_limit
96  23, //max_run
97  },
98  {
99  { //level / run
100  { 1, 1, 0 }, { -1, 1, 0 }, { 1, 2, 0 }, { -1, 2, 0 }, { 2, 1, 1 }, { -2, 1, 1 },
101  { 1, 3, 0 }, { -1, 3, 0 }, { EOB }, { 1, 4, 0 }, { -1, 4, 0 }, { 1, 5, 0 },
102  { -1, 5, 0 }, { 1, 6, 0 }, { -1, 6, 0 }, { 3, 1, 2 }, { -3, 1, 2 }, { 2, 2, 1 },
103  { -2, 2, 1 }, { 1, 7, 0 }, { -1, 7, 0 }, { 1, 8, 0 }, { -1, 8, 0 }, { 1, 9, 0 },
104  { -1, 9, 0 }, { 2, 3, 1 }, { -2, 3, 1 }, { 4, 1, 2 }, { -4, 1, 2 }, { 1, 10, 0 },
105  { -1, 10, 0 }, { 1, 11, 0 }, { -1, 11, 0 }, { 2, 4, 1 }, { -2, 4, 1 }, { 3, 2, 2 },
106  { -3, 2, 2 }, { 1, 12, 0 }, { -1, 12, 0 }, { 2, 5, 1 }, { -2, 5, 1 }, { 5, 1, 3 },
107  { -5, 1, 3 }, { 1, 13, 0 }, { -1, 13, 0 }, { 2, 6, 1 }, { -2, 6, 1 }, { 1, 14, 0 },
108  { -1, 14, 0 }, { 2, 7, 1 }, { -2, 7, 1 }, { 2, 8, 1 }, { -2, 8, 1 }, { 3, 3, 2 },
109  { -3, 3, 2 }, { 6, 1, 3 }, { -6, 1, 3 }, { 1, 15, 0 }, { -1, 15, 0 }
110  },
111  //level_add
112  { 0, 7, 4, 4, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 },
113  2, //golomb_order
114  1, //inc_limit
115  15, //max_run
116  },
117  {
118  { //level / run
119  { 1, 1, 0 }, { -1, 1, 0 }, { 2, 1, 0 }, { -2, 1, 0 }, { 1, 2, 0 }, { -1, 2, 0 },
120  { 3, 1, 1 }, { -3, 1, 1 }, { EOB }, { 1, 3, 0 }, { -1, 3, 0 }, { 2, 2, 0 },
121  { -2, 2, 0 }, { 4, 1, 1 }, { -4, 1, 1 }, { 1, 4, 0 }, { -1, 4, 0 }, { 5, 1, 2 },
122  { -5, 1, 2 }, { 1, 5, 0 }, { -1, 5, 0 }, { 3, 2, 1 }, { -3, 2, 1 }, { 2, 3, 0 },
123  { -2, 3, 0 }, { 1, 6, 0 }, { -1, 6, 0 }, { 6, 1, 2 }, { -6, 1, 2 }, { 2, 4, 0 },
124  { -2, 4, 0 }, { 1, 7, 0 }, { -1, 7, 0 }, { 4, 2, 1 }, { -4, 2, 1 }, { 7, 1, 2 },
125  { -7, 1, 2 }, { 3, 3, 1 }, { -3, 3, 1 }, { 2, 5, 0 }, { -2, 5, 0 }, { 1, 8, 0 },
126  { -1, 8, 0 }, { 2, 6, 0 }, { -2, 6, 0 }, { 8, 1, 3 }, { -8, 1, 3 }, { 1, 9, 0 },
127  { -1, 9, 0 }, { 5, 2, 2 }, { -5, 2, 2 }, { 3, 4, 1 }, { -3, 4, 1 }, { 2, 7, 0 },
128  { -2, 7, 0 }, { 9, 1, 3 }, { -9, 1, 3 }, { 1, 10, 0 }, { -1, 10, 0 }
129  },
130  //level_add
131  { 0, 10, 6, 4, 4, 3, 3, 3, 2, 2, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 },
132  2, //golomb_order
133  2, //inc_limit
134  10, //max_run
135  },
136  {
137  { //level / run
138  { 1, 1, 0 }, { -1, 1, 0 }, { 2, 1, 0 }, { -2, 1, 0 }, { 3, 1, 0 }, { -3, 1, 0 },
139  { 1, 2, 0 }, { -1, 2, 0 }, { EOB }, { 4, 1, 0 }, { -4, 1, 0 }, { 5, 1, 1 },
140  { -5, 1, 1 }, { 2, 2, 0 }, { -2, 2, 0 }, { 1, 3, 0 }, { -1, 3, 0 }, { 6, 1, 1 },
141  { -6, 1, 1 }, { 3, 2, 0 }, { -3, 2, 0 }, { 7, 1, 1 }, { -7, 1, 1 }, { 1, 4, 0 },
142  { -1, 4, 0 }, { 8, 1, 2 }, { -8, 1, 2 }, { 2, 3, 0 }, { -2, 3, 0 }, { 4, 2, 0 },
143  { -4, 2, 0 }, { 1, 5, 0 }, { -1, 5, 0 }, { 9, 1, 2 }, { -9, 1, 2 }, { 5, 2, 1 },
144  { -5, 2, 1 }, { 2, 4, 0 }, { -2, 4, 0 }, { 10, 1, 2 }, {-10, 1, 2 }, { 3, 3, 0 },
145  { -3, 3, 0 }, { 1, 6, 0 }, { -1, 6, 0 }, { 11, 1, 3 }, {-11, 1, 3 }, { 6, 2, 1 },
146  { -6, 2, 1 }, { 1, 7, 0 }, { -1, 7, 0 }, { 2, 5, 0 }, { -2, 5, 0 }, { 3, 4, 0 },
147  { -3, 4, 0 }, { 12, 1, 3 }, {-12, 1, 3 }, { 4, 3, 0 }, { -4, 3, 0 }
148  },
149  //level_add
150  { 0, 13, 7, 5, 4, 3, 2, 2, -1, -1, -1 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 },
151  2, //golomb_order
152  4, //inc_limit
153  7, //max_run
154  },
155  {
156  { //level / run
157  { 1, 1, 0 }, { -1, 1, 0 }, { 2, 1, 0 }, { -2, 1, 0 }, { 3, 1, 0 }, { -3, 1, 0 },
158  { EOB }, { 4, 1, 0 }, { -4, 1, 0 }, { 5, 1, 0 }, { -5, 1, 0 }, { 6, 1, 0 },
159  { -6, 1, 0 }, { 1, 2, 0 }, { -1, 2, 0 }, { 7, 1, 0 }, { -7, 1, 0 }, { 8, 1, 1 },
160  { -8, 1, 1 }, { 2, 2, 0 }, { -2, 2, 0 }, { 9, 1, 1 }, { -9, 1, 1 }, { 10, 1, 1 },
161  {-10, 1, 1 }, { 1, 3, 0 }, { -1, 3, 0 }, { 3, 2, 0 }, { -3, 2, 0 }, { 11, 1, 2 },
162  {-11, 1, 2 }, { 4, 2, 0 }, { -4, 2, 0 }, { 12, 1, 2 }, {-12, 1, 2 }, { 13, 1, 2 },
163  {-13, 1, 2 }, { 5, 2, 0 }, { -5, 2, 0 }, { 1, 4, 0 }, { -1, 4, 0 }, { 2, 3, 0 },
164  { -2, 3, 0 }, { 14, 1, 2 }, {-14, 1, 2 }, { 6, 2, 0 }, { -6, 2, 0 }, { 15, 1, 2 },
165  {-15, 1, 2 }, { 16, 1, 2 }, {-16, 1, 2 }, { 3, 3, 0 }, { -3, 3, 0 }, { 1, 5, 0 },
166  { -1, 5, 0 }, { 7, 2, 0 }, { -7, 2, 0 }, { 17, 1, 2 }, {-17, 1, 2 }
167  },
168  //level_add
169  { 0,18, 8, 4, 2, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 },
170  2, //golomb_order
171  7, //inc_limit
172  5, //max_run
173  },
174  {
175  { //level / run
176  { EOB }, { 1, 1, 0 }, { -1, 1, 0 }, { 2, 1, 0 }, { -2, 1, 0 }, { 3, 1, 0 },
177  { -3, 1, 0 }, { 4, 1, 0 }, { -4, 1, 0 }, { 5, 1, 0 }, { -5, 1, 0 }, { 6, 1, 0 },
178  { -6, 1, 0 }, { 7, 1, 0 }, { -7, 1, 0 }, { 8, 1, 0 }, { -8, 1, 0 }, { 9, 1, 0 },
179  { -9, 1, 0 }, { 10, 1, 0 }, {-10, 1, 0 }, { 1, 2, 0 }, { -1, 2, 0 }, { 11, 1, 1 },
180  {-11, 1, 1 }, { 12, 1, 1 }, {-12, 1, 1 }, { 13, 1, 1 }, {-13, 1, 1 }, { 2, 2, 0 },
181  { -2, 2, 0 }, { 14, 1, 1 }, {-14, 1, 1 }, { 15, 1, 1 }, {-15, 1, 1 }, { 3, 2, 0 },
182  { -3, 2, 0 }, { 16, 1, 1 }, {-16, 1, 1 }, { 1, 3, 0 }, { -1, 3, 0 }, { 17, 1, 1 },
183  {-17, 1, 1 }, { 4, 2, 0 }, { -4, 2, 0 }, { 18, 1, 1 }, {-18, 1, 1 }, { 5, 2, 0 },
184  { -5, 2, 0 }, { 19, 1, 1 }, {-19, 1, 1 }, { 20, 1, 1 }, {-20, 1, 1 }, { 6, 2, 0 },
185  { -6, 2, 0 }, { 21, 1, 1 }, {-21, 1, 1 }, { 2, 3, 0 }, { -2, 3, 0 }
186  },
187  //level_add
188  { 0, 22, 7, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 },
189  2, //golomb_order
190  10, //inc_limit
191  3, //max_run
192  },
193  {
194  { //level / run
195  { EOB }, { 1, 1, 0 }, { -1, 1, 0 }, { 2, 1, 0 }, { -2, 1, 0 }, { 3, 1, 0 },
196  { -3, 1, 0 }, { 4, 1, 0 }, { -4, 1, 0 }, { 5, 1, 0 }, { -5, 1, 0 }, { 6, 1, 0 },
197  { -6, 1, 0 }, { 7, 1, 0 }, { -7, 1, 0 }, { 8, 1, 0 }, { -8, 1, 0 }, { 9, 1, 0 },
198  { -9, 1, 0 }, { 10, 1, 0 }, {-10, 1, 0 }, { 11, 1, 0 }, {-11, 1, 0 }, { 12, 1, 0 },
199  {-12, 1, 0 }, { 13, 1, 0 }, {-13, 1, 0 }, { 14, 1, 0 }, {-14, 1, 0 }, { 15, 1, 0 },
200  {-15, 1, 0 }, { 16, 1, 0 }, {-16, 1, 0 }, { 1, 2, 0 }, { -1, 2, 0 }, { 17, 1, 0 },
201  {-17, 1, 0 }, { 18, 1, 0 }, {-18, 1, 0 }, { 19, 1, 0 }, {-19, 1, 0 }, { 20, 1, 0 },
202  {-20, 1, 0 }, { 21, 1, 0 }, {-21, 1, 0 }, { 2, 2, 0 }, { -2, 2, 0 }, { 22, 1, 0 },
203  {-22, 1, 0 }, { 23, 1, 0 }, {-23, 1, 0 }, { 24, 1, 0 }, {-24, 1, 0 }, { 25, 1, 0 },
204  {-25, 1, 0 }, { 3, 2, 0 }, { -3, 2, 0 }, { 26, 1, 0 }, {-26, 1, 0 }
205  },
206  //level_add
207  { 0, 27, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 },
208  2, //golomb_order
209  INT_MAX, //inc_limit
210  2, //max_run
211  }
212 };
213 
214 static const struct dec_2dvlc inter_dec[7] = {
215  {
216  { //level / run
217  { 1, 1, 1 }, { -1, 1, 1 }, { 1, 2, 1 }, { -1, 2, 1 }, { 1, 3, 1 }, { -1, 3, 1 },
218  { 1, 4, 1 }, { -1, 4, 1 }, { 1, 5, 1 }, { -1, 5, 1 }, { 1, 6, 1 }, { -1, 6, 1 },
219  { 1, 7, 1 }, { -1, 7, 1 }, { 1, 8, 1 }, { -1, 8, 1 }, { 1, 9, 1 }, { -1, 9, 1 },
220  { 1, 10, 1 }, { -1, 10, 1 }, { 1, 11, 1 }, { -1, 11, 1 }, { 1, 12, 1 }, { -1, 12, 1 },
221  { 1, 13, 1 }, { -1, 13, 1 }, { 2, 1, 2 }, { -2, 1, 2 }, { 1, 14, 1 }, { -1, 14, 1 },
222  { 1, 15, 1 }, { -1, 15, 1 }, { 1, 16, 1 }, { -1, 16, 1 }, { 1, 17, 1 }, { -1, 17, 1 },
223  { 1, 18, 1 }, { -1, 18, 1 }, { 1, 19, 1 }, { -1, 19, 1 }, { 3, 1, 3 }, { -3, 1, 3 },
224  { 1, 20, 1 }, { -1, 20, 1 }, { 1, 21, 1 }, { -1, 21, 1 }, { 2, 2, 2 }, { -2, 2, 2 },
225  { 1, 22, 1 }, { -1, 22, 1 }, { 1, 23, 1 }, { -1, 23, 1 }, { 1, 24, 1 }, { -1, 24, 1 },
226  { 1, 25, 1 }, { -1, 25, 1 }, { 1, 26, 1 }, { -1, 26, 1 }, { EOB }
227  },
228  //level_add
229  { 0, 4, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2 },
230  3, //golomb_order
231  0, //inc_limit
232  26 //max_run
233  },
234  {
235  { //level / run
236  { 1, 1, 0 }, { -1, 1, 0 }, { EOB }, { 1, 2, 0 }, { -1, 2, 0 }, { 1, 3, 0 },
237  { -1, 3, 0 }, { 1, 4, 0 }, { -1, 4, 0 }, { 1, 5, 0 }, { -1, 5, 0 }, { 1, 6, 0 },
238  { -1, 6, 0 }, { 2, 1, 1 }, { -2, 1, 1 }, { 1, 7, 0 }, { -1, 7, 0 }, { 1, 8, 0 },
239  { -1, 8, 0 }, { 1, 9, 0 }, { -1, 9, 0 }, { 1, 10, 0 }, { -1, 10, 0 }, { 2, 2, 1 },
240  { -2, 2, 1 }, { 1, 11, 0 }, { -1, 11, 0 }, { 1, 12, 0 }, { -1, 12, 0 }, { 3, 1, 2 },
241  { -3, 1, 2 }, { 1, 13, 0 }, { -1, 13, 0 }, { 1, 14, 0 }, { -1, 14, 0 }, { 2, 3, 1 },
242  { -2, 3, 1 }, { 1, 15, 0 }, { -1, 15, 0 }, { 2, 4, 1 }, { -2, 4, 1 }, { 1, 16, 0 },
243  { -1, 16, 0 }, { 2, 5, 1 }, { -2, 5, 1 }, { 1, 17, 0 }, { -1, 17, 0 }, { 4, 1, 3 },
244  { -4, 1, 3 }, { 2, 6, 1 }, { -2, 6, 1 }, { 1, 18, 0 }, { -1, 18, 0 }, { 1, 19, 0 },
245  { -1, 19, 0 }, { 2, 7, 1 }, { -2, 7, 1 }, { 3, 2, 2 }, { -3, 2, 2 }
246  },
247  //level_add
248  { 0, 5, 4, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, -1, -1, -1, -1, -1, -1, -1 },
249  2, //golomb_order
250  1, //inc_limit
251  19 //max_run
252  },
253  {
254  { //level / run
255  { 1, 1, 0 }, { -1, 1, 0 }, { EOB }, { 1, 2, 0 }, { -1, 2, 0 }, { 2, 1, 0 },
256  { -2, 1, 0 }, { 1, 3, 0 }, { -1, 3, 0 }, { 1, 4, 0 }, { -1, 4, 0 }, { 3, 1, 1 },
257  { -3, 1, 1 }, { 2, 2, 0 }, { -2, 2, 0 }, { 1, 5, 0 }, { -1, 5, 0 }, { 1, 6, 0 },
258  { -1, 6, 0 }, { 1, 7, 0 }, { -1, 7, 0 }, { 2, 3, 0 }, { -2, 3, 0 }, { 4, 1, 2 },
259  { -4, 1, 2 }, { 1, 8, 0 }, { -1, 8, 0 }, { 3, 2, 1 }, { -3, 2, 1 }, { 2, 4, 0 },
260  { -2, 4, 0 }, { 1, 9, 0 }, { -1, 9, 0 }, { 1, 10, 0 }, { -1, 10, 0 }, { 5, 1, 2 },
261  { -5, 1, 2 }, { 2, 5, 0 }, { -2, 5, 0 }, { 1, 11, 0 }, { -1, 11, 0 }, { 2, 6, 0 },
262  { -2, 6, 0 }, { 1, 12, 0 }, { -1, 12, 0 }, { 3, 3, 1 }, { -3, 3, 1 }, { 6, 1, 2 },
263  { -6, 1, 2 }, { 4, 2, 2 }, { -4, 2, 2 }, { 1, 13, 0 }, { -1, 13, 0 }, { 2, 7, 0 },
264  { -2, 7, 0 }, { 3, 4, 1 }, { -3, 4, 1 }, { 1, 14, 0 }, { -1, 14, 0 }
265  },
266  //level_add
267  { 0, 7, 5, 4, 4, 3, 3, 3, 2, 2, 2, 2, 2, 2, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 },
268  2, //golomb_order
269  2, //inc_limit
270  14 //max_run
271  },
272  {
273  { //level / run
274  { 1, 1, 0 }, { -1, 1, 0 }, { EOB }, { 2, 1, 0 }, { -2, 1, 0 }, { 1, 2, 0 },
275  { -1, 2, 0 }, { 3, 1, 0 }, { -3, 1, 0 }, { 1, 3, 0 }, { -1, 3, 0 }, { 2, 2, 0 },
276  { -2, 2, 0 }, { 4, 1, 1 }, { -4, 1, 1 }, { 1, 4, 0 }, { -1, 4, 0 }, { 5, 1, 1 },
277  { -5, 1, 1 }, { 1, 5, 0 }, { -1, 5, 0 }, { 3, 2, 0 }, { -3, 2, 0 }, { 2, 3, 0 },
278  { -2, 3, 0 }, { 1, 6, 0 }, { -1, 6, 0 }, { 6, 1, 1 }, { -6, 1, 1 }, { 2, 4, 0 },
279  { -2, 4, 0 }, { 1, 7, 0 }, { -1, 7, 0 }, { 4, 2, 1 }, { -4, 2, 1 }, { 7, 1, 2 },
280  { -7, 1, 2 }, { 3, 3, 0 }, { -3, 3, 0 }, { 1, 8, 0 }, { -1, 8, 0 }, { 2, 5, 0 },
281  { -2, 5, 0 }, { 8, 1, 2 }, { -8, 1, 2 }, { 1, 9, 0 }, { -1, 9, 0 }, { 3, 4, 0 },
282  { -3, 4, 0 }, { 2, 6, 0 }, { -2, 6, 0 }, { 5, 2, 1 }, { -5, 2, 1 }, { 1, 10, 0 },
283  { -1, 10, 0 }, { 9, 1, 2 }, { -9, 1, 2 }, { 4, 3, 1 }, { -4, 3, 1 }
284  },
285  //level_add
286  { 0,10, 6, 5, 4, 3, 3, 2, 2, 2, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 },
287  2, //golomb_order
288  3, //inc_limit
289  10 //max_run
290  },
291  {
292  { //level / run
293  { 1, 1, 0 }, { -1, 1, 0 }, { EOB }, { 2, 1, 0 }, { -2, 1, 0 }, { 3, 1, 0 },
294  { -3, 1, 0 }, { 1, 2, 0 }, { -1, 2, 0 }, { 4, 1, 0 }, { -4, 1, 0 }, { 5, 1, 0 },
295  { -5, 1, 0 }, { 2, 2, 0 }, { -2, 2, 0 }, { 1, 3, 0 }, { -1, 3, 0 }, { 6, 1, 0 },
296  { -6, 1, 0 }, { 3, 2, 0 }, { -3, 2, 0 }, { 7, 1, 1 }, { -7, 1, 1 }, { 1, 4, 0 },
297  { -1, 4, 0 }, { 8, 1, 1 }, { -8, 1, 1 }, { 2, 3, 0 }, { -2, 3, 0 }, { 4, 2, 0 },
298  { -4, 2, 0 }, { 1, 5, 0 }, { -1, 5, 0 }, { 9, 1, 1 }, { -9, 1, 1 }, { 5, 2, 0 },
299  { -5, 2, 0 }, { 2, 4, 0 }, { -2, 4, 0 }, { 1, 6, 0 }, { -1, 6, 0 }, { 10, 1, 2 },
300  {-10, 1, 2 }, { 3, 3, 0 }, { -3, 3, 0 }, { 11, 1, 2 }, {-11, 1, 2 }, { 1, 7, 0 },
301  { -1, 7, 0 }, { 6, 2, 0 }, { -6, 2, 0 }, { 3, 4, 0 }, { -3, 4, 0 }, { 2, 5, 0 },
302  { -2, 5, 0 }, { 12, 1, 2 }, {-12, 1, 2 }, { 4, 3, 0 }, { -4, 3, 0 }
303  },
304  //level_add
305  { 0, 13, 7, 5, 4, 3, 2, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 },
306  2, //golomb_order
307  6, //inc_limit
308  7 //max_run
309  },
310  {
311  { //level / run
312  { EOB }, { 1, 1, 0 }, { -1, 1, 0 }, { 2, 1, 0 }, { -2, 1, 0 }, { 3, 1, 0 },
313  { -3, 1, 0 }, { 4, 1, 0 }, { -4, 1, 0 }, { 5, 1, 0 }, { -5, 1, 0 }, { 1, 2, 0 },
314  { -1, 2, 0 }, { 6, 1, 0 }, { -6, 1, 0 }, { 7, 1, 0 }, { -7, 1, 0 }, { 8, 1, 0 },
315  { -8, 1, 0 }, { 2, 2, 0 }, { -2, 2, 0 }, { 9, 1, 0 }, { -9, 1, 0 }, { 1, 3, 0 },
316  { -1, 3, 0 }, { 10, 1, 1 }, { -10, 1, 1 }, { 3, 2, 0 }, { -3, 2, 0 }, { 11, 1, 1 },
317  { -11, 1, 1 }, { 4, 2, 0 }, { -4, 2, 0 }, { 12, 1, 1 }, { -12, 1, 1 }, { 1, 4, 0 },
318  { -1, 4, 0 }, { 2, 3, 0 }, { -2, 3, 0 }, { 13, 1, 1 }, { -13, 1, 1 }, { 5, 2, 0 },
319  { -5, 2, 0 }, { 14, 1, 1 }, { -14, 1, 1 }, { 6, 2, 0 }, { -6, 2, 0 }, { 1, 5, 0 },
320  { -1, 5, 0 }, { 15, 1, 1 }, { -15, 1, 1 }, { 3, 3, 0 }, { -3, 3, 0 }, { 16, 1, 1 },
321  { -16, 1, 1 }, { 2, 4, 0 }, { -2, 4, 0 }, { 7, 2, 0 }, { -7, 2, 0 }
322  },
323  //level_add
324  { 0, 17, 8, 4, 3, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 },
325  2, //golomb_order
326  9, //inc_limit
327  5 //max_run
328  },
329  {
330  { //level / run
331  { EOB }, { 1, 1, 0 }, { -1, 1, 0 }, { 2, 1, 0 }, { -2, 1, 0 }, { 3, 1, 0 },
332  { -3, 1, 0 }, { 4, 1, 0 }, { -4, 1, 0 }, { 5, 1, 0 }, { -5, 1, 0 }, { 6, 1, 0 },
333  { -6, 1, 0 }, { 7, 1, 0 }, { -7, 1, 0 }, { 1, 2, 0 }, { -1, 2, 0 }, { 8, 1, 0 },
334  { -8, 1, 0 }, { 9, 1, 0 }, { -9, 1, 0 }, { 10, 1, 0 }, { -10, 1, 0 }, { 11, 1, 0 },
335  { -11, 1, 0 }, { 12, 1, 0 }, { -12, 1, 0 }, { 2, 2, 0 }, { -2, 2, 0 }, { 13, 1, 0 },
336  { -13, 1, 0 }, { 1, 3, 0 }, { -1, 3, 0 }, { 14, 1, 0 }, { -14, 1, 0 }, { 15, 1, 0 },
337  { -15, 1, 0 }, { 3, 2, 0 }, { -3, 2, 0 }, { 16, 1, 0 }, { -16, 1, 0 }, { 17, 1, 0 },
338  { -17, 1, 0 }, { 18, 1, 0 }, { -18, 1, 0 }, { 4, 2, 0 }, { -4, 2, 0 }, { 19, 1, 0 },
339  { -19, 1, 0 }, { 20, 1, 0 }, { -20, 1, 0 }, { 2, 3, 0 }, { -2, 3, 0 }, { 1, 4, 0 },
340  { -1, 4, 0 }, { 5, 2, 0 }, { -5, 2, 0 }, { 21, 1, 0 }, { -21, 1, 0 }
341  },
342  //level_add
343  { 0, 22, 6, 3, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 },
344  2, //golomb_order
345  INT_MAX, //inc_limit
346  4 //max_run
347  }
348 };
349 
350 static const struct dec_2dvlc chroma_dec[5] = {
351  {
352  { //level / run
353  { 1, 1, 1 }, { -1, 1, 1 }, { 1, 2, 1 }, { -1, 2, 1 }, { 1, 3, 1 }, { -1, 3, 1 },
354  { 1, 4, 1 }, { -1, 4, 1 }, { 1, 5, 1 }, { -1, 5, 1 }, { 1, 6, 1 }, { -1, 6, 1 },
355  { 1, 7, 1 }, { -1, 7, 1 }, { 2, 1, 2 }, { -2, 1, 2 }, { 1, 8, 1 }, { -1, 8, 1 },
356  { 1, 9, 1 }, { -1, 9, 1 }, { 1, 10, 1 }, { -1, 10, 1 }, { 1, 11, 1 }, { -1, 11, 1 },
357  { 1, 12, 1 }, { -1, 12, 1 }, { 1, 13, 1 }, { -1, 13, 1 }, { 1, 14, 1 }, { -1, 14, 1 },
358  { 1, 15, 1 }, { -1, 15, 1 }, { 3, 1, 3 }, { -3, 1, 3 }, { 1, 16, 1 }, { -1, 16, 1 },
359  { 1, 17, 1 }, { -1, 17, 1 }, { 1, 18, 1 }, { -1, 18, 1 }, { 1, 19, 1 }, { -1, 19, 1 },
360  { 1, 20, 1 }, { -1, 20, 1 }, { 1, 21, 1 }, { -1, 21, 1 }, { 1, 22, 1 }, { -1, 22, 1 },
361  { 2, 2, 2 }, { -2, 2, 2 }, { 1, 23, 1 }, { -1, 23, 1 }, { 1, 24, 1 }, { -1, 24, 1 },
362  { 1, 25, 1 }, { -1, 25, 1 }, { 4, 1, 3 }, { -4, 1, 3 }, { EOB }
363  },
364  //level_add
365  { 0, 5, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, -1 },
366  2, //golomb_order
367  0, //inc_limit
368  25 //max_run
369  },
370  {
371  { //level / run
372  { EOB }, { 1, 1, 0 }, { -1, 1, 0 }, { 1, 2, 0 }, { -1, 2, 0 }, { 2, 1, 1 },
373  { -2, 1, 1 }, { 1, 3, 0 }, { -1, 3, 0 }, { 1, 4, 0 }, { -1, 4, 0 }, { 1, 5, 0 },
374  { -1, 5, 0 }, { 1, 6, 0 }, { -1, 6, 0 }, { 3, 1, 2 }, { -3, 1, 2 }, { 1, 7, 0 },
375  { -1, 7, 0 }, { 1, 8, 0 }, { -1, 8, 0 }, { 2, 2, 1 }, { -2, 2, 1 }, { 1, 9, 0 },
376  { -1, 9, 0 }, { 1, 10, 0 }, { -1, 10, 0 }, { 1, 11, 0 }, { -1, 11, 0 }, { 4, 1, 2 },
377  { -4, 1, 2 }, { 1, 12, 0 }, { -1, 12, 0 }, { 1, 13, 0 }, { -1, 13, 0 }, { 1, 14, 0 },
378  { -1, 14, 0 }, { 2, 3, 1 }, { -2, 3, 1 }, { 1, 15, 0 }, { -1, 15, 0 }, { 2, 4, 1 },
379  { -2, 4, 1 }, { 5, 1, 3 }, { -5, 1, 3 }, { 3, 2, 2 }, { -3, 2, 2 }, { 1, 16, 0 },
380  { -1, 16, 0 }, { 1, 17, 0 }, { -1, 17, 0 }, { 1, 18, 0 }, { -1, 18, 0 }, { 2, 5, 1 },
381  { -2, 5, 1 }, { 1, 19, 0 }, { -1, 19, 0 }, { 1, 20, 0 }, { -1, 20, 0 }
382  },
383  //level_add
384  { 0, 6, 4, 3, 3, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, -1, -1, -1, -1, -1, -1 },
385  0, //golomb_order
386  1, //inc_limit
387  20 //max_run
388  },
389  {
390  { //level / run
391  { 1, 1, 0 }, { -1, 1, 0 }, { EOB }, { 2, 1, 0 }, { -2, 1, 0 }, { 1, 2, 0 },
392  { -1, 2, 0 }, { 3, 1, 1 }, { -3, 1, 1 }, { 1, 3, 0 }, { -1, 3, 0 }, { 4, 1, 1 },
393  { -4, 1, 1 }, { 2, 2, 0 }, { -2, 2, 0 }, { 1, 4, 0 }, { -1, 4, 0 }, { 5, 1, 2 },
394  { -5, 1, 2 }, { 1, 5, 0 }, { -1, 5, 0 }, { 3, 2, 1 }, { -3, 2, 1 }, { 2, 3, 0 },
395  { -2, 3, 0 }, { 1, 6, 0 }, { -1, 6, 0 }, { 6, 1, 2 }, { -6, 1, 2 }, { 1, 7, 0 },
396  { -1, 7, 0 }, { 2, 4, 0 }, { -2, 4, 0 }, { 7, 1, 2 }, { -7, 1, 2 }, { 1, 8, 0 },
397  { -1, 8, 0 }, { 4, 2, 1 }, { -4, 2, 1 }, { 1, 9, 0 }, { -1, 9, 0 }, { 3, 3, 1 },
398  { -3, 3, 1 }, { 2, 5, 0 }, { -2, 5, 0 }, { 2, 6, 0 }, { -2, 6, 0 }, { 8, 1, 2 },
399  { -8, 1, 2 }, { 1, 10, 0 }, { -1, 10, 0 }, { 1, 11, 0 }, { -1, 11, 0 }, { 9, 1, 2 },
400  { -9, 1, 2 }, { 5, 2, 2 }, { -5, 2, 2 }, { 3, 4, 1 }, { -3, 4, 1 },
401  },
402  //level_add
403  { 0,10, 6, 4, 4, 3, 3, 2, 2, 2, 2, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 },
404  1, //golomb_order
405  2, //inc_limit
406  11 //max_run
407  },
408  {
409  { //level / run
410  { EOB }, { 1, 1, 0 }, { -1, 1, 0 }, { 2, 1, 0 }, { -2, 1, 0 }, { 3, 1, 0 },
411  { -3, 1, 0 }, { 4, 1, 0 }, { -4, 1, 0 }, { 1, 2, 0 }, { -1, 2, 0 }, { 5, 1, 1 },
412  { -5, 1, 1 }, { 2, 2, 0 }, { -2, 2, 0 }, { 6, 1, 1 }, { -6, 1, 1 }, { 1, 3, 0 },
413  { -1, 3, 0 }, { 7, 1, 1 }, { -7, 1, 1 }, { 3, 2, 0 }, { -3, 2, 0 }, { 8, 1, 1 },
414  { -8, 1, 1 }, { 1, 4, 0 }, { -1, 4, 0 }, { 2, 3, 0 }, { -2, 3, 0 }, { 9, 1, 1 },
415  { -9, 1, 1 }, { 4, 2, 0 }, { -4, 2, 0 }, { 1, 5, 0 }, { -1, 5, 0 }, { 10, 1, 1 },
416  {-10, 1, 1 }, { 3, 3, 0 }, { -3, 3, 0 }, { 5, 2, 1 }, { -5, 2, 1 }, { 2, 4, 0 },
417  { -2, 4, 0 }, { 11, 1, 1 }, {-11, 1, 1 }, { 1, 6, 0 }, { -1, 6, 0 }, { 12, 1, 1 },
418  {-12, 1, 1 }, { 1, 7, 0 }, { -1, 7, 0 }, { 6, 2, 1 }, { -6, 2, 1 }, { 13, 1, 1 },
419  {-13, 1, 1 }, { 2, 5, 0 }, { -2, 5, 0 }, { 1, 8, 0 }, { -1, 8, 0 },
420  },
421  //level_add
422  { 0, 14, 7, 4, 3, 3, 2, 2, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 },
423  1, //golomb_order
424  4, //inc_limit
425  8 //max_run
426  },
427  {
428  { //level / run
429  { EOB }, { 1, 1, 0 }, { -1, 1, 0 }, { 2, 1, 0 }, { -2, 1, 0 }, { 3, 1, 0 },
430  { -3, 1, 0 }, { 4, 1, 0 }, { -4, 1, 0 }, { 5, 1, 0 }, { -5, 1, 0 }, { 6, 1, 0 },
431  { -6, 1, 0 }, { 7, 1, 0 }, { -7, 1, 0 }, { 8, 1, 0 }, { -8, 1, 0 }, { 1, 2, 0 },
432  { -1, 2, 0 }, { 9, 1, 0 }, { -9, 1, 0 }, { 10, 1, 0 }, { -10, 1, 0 }, { 11, 1, 0 },
433  { -11, 1, 0 }, { 2, 2, 0 }, { -2, 2, 0 }, { 12, 1, 0 }, { -12, 1, 0 }, { 13, 1, 0 },
434  { -13, 1, 0 }, { 3, 2, 0 }, { -3, 2, 0 }, { 14, 1, 0 }, { -14, 1, 0 }, { 1, 3, 0 },
435  { -1, 3, 0 }, { 15, 1, 0 }, { -15, 1, 0 }, { 4, 2, 0 }, { -4, 2, 0 }, { 16, 1, 0 },
436  { -16, 1, 0 }, { 17, 1, 0 }, { -17, 1, 0 }, { 5, 2, 0 }, { -5, 2, 0 }, { 1, 4, 0 },
437  { -1, 4, 0 }, { 2, 3, 0 }, { -2, 3, 0 }, { 18, 1, 0 }, { -18, 1, 0 }, { 6, 2, 0 },
438  { -6, 2, 0 }, { 19, 1, 0 }, { -19, 1, 0 }, { 1, 5, 0 }, { -1, 5, 0 },
439  },
440  //level_add
441  { 0, 20, 7, 3, 2, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 },
442  0, //golomb_order
443  INT_MAX, //inc_limit
444  5, //max_run
445  }
446 };
447 
448 #undef EOB
449 
450 /*****************************************************************************
451  *
452  * motion vector prediction
453  *
454  ****************************************************************************/
455 
456 static inline void store_mvs(AVSContext *h)
457 {
458  h->col_mv[h->mbidx * 4 + 0] = h->mv[MV_FWD_X0];
459  h->col_mv[h->mbidx * 4 + 1] = h->mv[MV_FWD_X1];
460  h->col_mv[h->mbidx * 4 + 2] = h->mv[MV_FWD_X2];
461  h->col_mv[h->mbidx * 4 + 3] = h->mv[MV_FWD_X3];
462 }
463 
464 static inline void mv_pred_direct(AVSContext *h, cavs_vector *pmv_fw,
465  cavs_vector *col_mv)
466 {
467  cavs_vector *pmv_bw = pmv_fw + MV_BWD_OFFS;
468  unsigned den = h->direct_den[col_mv->ref];
469  int m = FF_SIGNBIT(col_mv->x);
470 
471  pmv_fw->dist = h->dist[1];
472  pmv_bw->dist = h->dist[0];
473  pmv_fw->ref = 1;
474  pmv_bw->ref = 0;
475  /* scale the co-located motion vector according to its temporal span */
476  pmv_fw->x = (((den + (den * col_mv->x * pmv_fw->dist ^ m) - m - 1) >> 14) ^ m) - m;
477  pmv_bw->x = m - (((den + (den * col_mv->x * pmv_bw->dist ^ m) - m - 1) >> 14) ^ m);
478  m = FF_SIGNBIT(col_mv->y);
479  pmv_fw->y = (((den + (den * col_mv->y * pmv_fw->dist ^ m) - m - 1) >> 14) ^ m) - m;
480  pmv_bw->y = m - (((den + (den * col_mv->y * pmv_bw->dist ^ m) - m - 1) >> 14) ^ m);
481 }
482 
483 static inline void mv_pred_sym(AVSContext *h, cavs_vector *src,
484  enum cavs_block size)
485 {
486  cavs_vector *dst = src + MV_BWD_OFFS;
487 
488  /* backward mv is the scaled and negated forward mv */
489  dst->x = -((src->x * h->sym_factor + 256) >> 9);
490  dst->y = -((src->y * h->sym_factor + 256) >> 9);
491  dst->ref = 0;
492  dst->dist = h->dist[0];
493  set_mvs(dst, size);
494 }
495 
496 /*****************************************************************************
497  *
498  * residual data decoding
499  *
500  ****************************************************************************/
501 
502 /** kth-order exponential golomb code */
503 static inline int get_ue_code(GetBitContext *gb, int order)
504 {
505  unsigned ret = get_ue_golomb(gb);
506  if (ret >= ((1U<<31)>>order)) {
507  av_log(NULL, AV_LOG_ERROR, "get_ue_code: value too larger\n");
508  return AVERROR_INVALIDDATA;
509  }
510  if (order) {
511  return (ret<<order) + get_bits(gb, order);
512  }
513  return ret;
514 }
515 
516 static inline int dequant(AVSContext *h, int16_t *level_buf, uint8_t *run_buf,
517  int16_t *dst, int mul, int shift, int coeff_num)
518 {
519  int round = 1 << (shift - 1);
520  int pos = -1;
521  const uint8_t *scantab = h->scantable.permutated;
522 
523  /* inverse scan and dequantization */
524  while (--coeff_num >= 0) {
525  pos += run_buf[coeff_num];
526  if (pos > 63) {
527  av_log(h->avctx, AV_LOG_ERROR,
528  "position out of block bounds at pic %d MB(%d,%d)\n",
529  h->cur.poc, h->mbx, h->mby);
530  return AVERROR_INVALIDDATA;
531  }
532  dst[scantab[pos]] = (level_buf[coeff_num] * mul + round) >> shift;
533  }
534  return 0;
535 }
536 
537 /**
538  * decode coefficients from one 8x8 block, dequantize, inverse transform
539  * and add them to sample block
540  * @param r pointer to 2D VLC table
541  * @param esc_golomb_order escape codes are k-golomb with this order k
542  * @param qp quantizer
543  * @param dst location of sample block
544  * @param stride line stride in frame buffer
545  */
546 static int decode_residual_block(AVSContext *h, GetBitContext *gb,
547  const struct dec_2dvlc *r, int esc_golomb_order,
548  int qp, uint8_t *dst, ptrdiff_t stride)
549 {
550  int i, esc_code, level, mask, ret;
551  unsigned int level_code, run;
552  int16_t level_buf[65];
553  uint8_t run_buf[65];
554  int16_t *block = h->block;
555 
556  for (i = 0; i < 65; i++) {
557  level_code = get_ue_code(gb, r->golomb_order);
558  if (level_code >= ESCAPE_CODE) {
559  run = ((level_code - ESCAPE_CODE) >> 1) + 1;
560  if(run > 64) {
561  av_log(h->avctx, AV_LOG_ERROR, "run %d is too large\n", run);
562  return AVERROR_INVALIDDATA;
563  }
564  esc_code = get_ue_code(gb, esc_golomb_order);
565  if (esc_code < 0 || esc_code > 32767) {
566  av_log(h->avctx, AV_LOG_ERROR, "esc_code invalid\n");
567  return AVERROR_INVALIDDATA;
568  }
569 
570  level = esc_code + (run > r->max_run ? 1 : r->level_add[run]);
571  while (level > r->inc_limit)
572  r++;
573  mask = -(level_code & 1);
574  level = (level ^ mask) - mask;
575  } else {
576  level = r->rltab[level_code][0];
577  if (!level) //end of block signal
578  break;
579  run = r->rltab[level_code][1];
580  r += r->rltab[level_code][2];
581  }
582  level_buf[i] = level;
583  run_buf[i] = run;
584  }
585  if ((ret = dequant(h, level_buf, run_buf, block, dequant_mul[qp],
586  dequant_shift[qp], i)) < 0)
587  return ret;
588  h->cdsp.cavs_idct8_add(dst, block, stride);
589  h->bdsp.clear_block(block);
590  return 0;
591 }
592 
593 
594 static inline int decode_residual_chroma(AVSContext *h)
595 {
596  if (h->cbp & (1 << 4)) {
597  int ret = decode_residual_block(h, &h->gb, chroma_dec, 0,
598  ff_cavs_chroma_qp[h->qp], h->cu, h->c_stride);
599  if (ret < 0)
600  return ret;
601  }
602  if (h->cbp & (1 << 5)) {
603  int ret = decode_residual_block(h, &h->gb, chroma_dec, 0,
604  ff_cavs_chroma_qp[h->qp], h->cv, h->c_stride);
605  if (ret < 0)
606  return ret;
607  }
608  return 0;
609 }
610 
611 static inline int decode_residual_inter(AVSContext *h)
612 {
613  int block;
614 
615  /* get coded block pattern */
616  int cbp = get_ue_golomb(&h->gb);
617  if (cbp > 63U) {
618  av_log(h->avctx, AV_LOG_ERROR, "illegal inter cbp %d\n", cbp);
619  return AVERROR_INVALIDDATA;
620  }
621  h->cbp = cbp_tab[cbp][1];
622 
623  /* get quantizer */
624  if (h->cbp && !h->qp_fixed)
625  h->qp = (h->qp + (unsigned)get_se_golomb(&h->gb)) & 63;
626  for (block = 0; block < 4; block++)
627  if (h->cbp & (1 << block))
628  decode_residual_block(h, &h->gb, inter_dec, 0, h->qp,
629  h->cy + h->luma_scan[block], h->l_stride);
630  decode_residual_chroma(h);
631 
632  return 0;
633 }
634 
635 /*****************************************************************************
636  *
637  * macroblock level
638  *
639  ****************************************************************************/
640 
641 static inline void set_mv_intra(AVSContext *h)
642 {
643  h->mv[MV_FWD_X0] = ff_cavs_intra_mv;
644  set_mvs(&h->mv[MV_FWD_X0], BLK_16X16);
645  h->mv[MV_BWD_X0] = ff_cavs_intra_mv;
646  set_mvs(&h->mv[MV_BWD_X0], BLK_16X16);
647  if (h->cur.f->pict_type != AV_PICTURE_TYPE_B)
648  h->col_type_base[h->mbidx] = I_8X8;
649 }
650 
651 static int decode_mb_i(AVSContext *h, int cbp_code)
652 {
653  GetBitContext *gb = &h->gb;
654  unsigned pred_mode_uv;
655  int block;
656  uint8_t top[18];
657  uint8_t *left = NULL;
658  uint8_t *d;
659  int ret;
660 
661  ff_cavs_init_mb(h);
662 
663  /* get intra prediction modes from stream */
664  for (block = 0; block < 4; block++) {
665  int nA, nB, predpred;
666  int pos = scan3x3[block];
667 
668  nA = h->pred_mode_Y[pos - 1];
669  nB = h->pred_mode_Y[pos - 3];
670  predpred = FFMIN(nA, nB);
671  if (predpred == NOT_AVAIL) // if either is not available
672  predpred = INTRA_L_LP;
673  if (!get_bits1(gb)) {
674  int rem_mode = get_bits(gb, 2);
675  predpred = rem_mode + (rem_mode >= predpred);
676  }
677  h->pred_mode_Y[pos] = predpred;
678  }
679  pred_mode_uv = get_ue_golomb_31(gb);
680  if (pred_mode_uv > 6) {
681  av_log(h->avctx, AV_LOG_ERROR, "illegal intra chroma pred mode\n");
682  return AVERROR_INVALIDDATA;
683  }
684  ff_cavs_modify_mb_i(h, &pred_mode_uv);
685 
686  /* get coded block pattern */
687  if (h->cur.f->pict_type == AV_PICTURE_TYPE_I)
688  cbp_code = get_ue_golomb(gb);
689  if (cbp_code > 63U) {
690  av_log(h->avctx, AV_LOG_ERROR, "illegal intra cbp\n");
691  return AVERROR_INVALIDDATA;
692  }
693  h->cbp = cbp_tab[cbp_code][0];
694  if (h->cbp && !h->qp_fixed)
695  h->qp = (h->qp + (unsigned)get_se_golomb(gb)) & 63; //qp_delta
696 
697  /* luma intra prediction interleaved with residual decode/transform/add */
698  for (block = 0; block < 4; block++) {
699  d = h->cy + h->luma_scan[block];
700  ff_cavs_load_intra_pred_luma(h, top, &left, block);
701  h->intra_pred_l[h->pred_mode_Y[scan3x3[block]]]
702  (d, top, left, h->l_stride);
703  if (h->cbp & (1<<block)) {
704  ret = decode_residual_block(h, gb, intra_dec, 1, h->qp, d, h->l_stride);
705  if (ret < 0)
706  return ret;
707  }
708  }
709 
710  /* chroma intra prediction */
711  ff_cavs_load_intra_pred_chroma(h);
712  h->intra_pred_c[pred_mode_uv](h->cu, &h->top_border_u[h->mbx * 10],
713  h->left_border_u, h->c_stride);
714  h->intra_pred_c[pred_mode_uv](h->cv, &h->top_border_v[h->mbx * 10],
715  h->left_border_v, h->c_stride);
716 
717  ret = decode_residual_chroma(h);
718  if (ret < 0)
719  return ret;
720  ff_cavs_filter(h, I_8X8);
721  set_mv_intra(h);
722  return 0;
723 }
724 
725 static inline void set_intra_mode_default(AVSContext *h)
726 {
727  if (h->stream_revision > 0) {
728  h->pred_mode_Y[3] = h->pred_mode_Y[6] = NOT_AVAIL;
729  h->top_pred_Y[h->mbx * 2 + 0] = h->top_pred_Y[h->mbx * 2 + 1] = NOT_AVAIL;
730  } else {
731  h->pred_mode_Y[3] = h->pred_mode_Y[6] = INTRA_L_LP;
732  h->top_pred_Y[h->mbx * 2 + 0] = h->top_pred_Y[h->mbx * 2 + 1] = INTRA_L_LP;
733  }
734 }
735 
736 static void decode_mb_p(AVSContext *h, enum cavs_mb mb_type)
737 {
738  GetBitContext *gb = &h->gb;
739  int ref[4];
740 
741  ff_cavs_init_mb(h);
742  switch (mb_type) {
743  case P_SKIP:
744  ff_cavs_mv(h, MV_FWD_X0, MV_FWD_C2, MV_PRED_PSKIP, BLK_16X16, 0);
745  break;
746  case P_16X16:
747  ref[0] = h->ref_flag ? 0 : get_bits1(gb);
748  ff_cavs_mv(h, MV_FWD_X0, MV_FWD_C2, MV_PRED_MEDIAN, BLK_16X16, ref[0]);
749  break;
750  case P_16X8:
751  ref[0] = h->ref_flag ? 0 : get_bits1(gb);
752  ref[2] = h->ref_flag ? 0 : get_bits1(gb);
753  ff_cavs_mv(h, MV_FWD_X0, MV_FWD_C2, MV_PRED_TOP, BLK_16X8, ref[0]);
754  ff_cavs_mv(h, MV_FWD_X2, MV_FWD_A1, MV_PRED_LEFT, BLK_16X8, ref[2]);
755  break;
756  case P_8X16:
757  ref[0] = h->ref_flag ? 0 : get_bits1(gb);
758  ref[1] = h->ref_flag ? 0 : get_bits1(gb);
759  ff_cavs_mv(h, MV_FWD_X0, MV_FWD_B3, MV_PRED_LEFT, BLK_8X16, ref[0]);
760  ff_cavs_mv(h, MV_FWD_X1, MV_FWD_C2, MV_PRED_TOPRIGHT, BLK_8X16, ref[1]);
761  break;
762  case P_8X8:
763  ref[0] = h->ref_flag ? 0 : get_bits1(gb);
764  ref[1] = h->ref_flag ? 0 : get_bits1(gb);
765  ref[2] = h->ref_flag ? 0 : get_bits1(gb);
766  ref[3] = h->ref_flag ? 0 : get_bits1(gb);
767  ff_cavs_mv(h, MV_FWD_X0, MV_FWD_B3, MV_PRED_MEDIAN, BLK_8X8, ref[0]);
768  ff_cavs_mv(h, MV_FWD_X1, MV_FWD_C2, MV_PRED_MEDIAN, BLK_8X8, ref[1]);
769  ff_cavs_mv(h, MV_FWD_X2, MV_FWD_X1, MV_PRED_MEDIAN, BLK_8X8, ref[2]);
770  ff_cavs_mv(h, MV_FWD_X3, MV_FWD_X0, MV_PRED_MEDIAN, BLK_8X8, ref[3]);
771  }
772  ff_cavs_inter(h, mb_type);
773  set_intra_mode_default(h);
774  store_mvs(h);
775  if (mb_type != P_SKIP)
776  decode_residual_inter(h);
777  ff_cavs_filter(h, mb_type);
778  h->col_type_base[h->mbidx] = mb_type;
779 }
780 
781 static int decode_mb_b(AVSContext *h, enum cavs_mb mb_type)
782 {
783  int block;
784  enum cavs_sub_mb sub_type[4];
785  int flags;
786 
787  ff_cavs_init_mb(h);
788 
789  /* reset all MVs */
790  h->mv[MV_FWD_X0] = ff_cavs_dir_mv;
791  set_mvs(&h->mv[MV_FWD_X0], BLK_16X16);
792  h->mv[MV_BWD_X0] = ff_cavs_dir_mv;
793  set_mvs(&h->mv[MV_BWD_X0], BLK_16X16);
794  switch (mb_type) {
795  case B_SKIP:
796  case B_DIRECT:
797  if (!h->col_type_base[h->mbidx]) {
798  /* intra MB at co-location, do in-plane prediction */
799  ff_cavs_mv(h, MV_FWD_X0, MV_FWD_C2, MV_PRED_BSKIP, BLK_16X16, 1);
800  ff_cavs_mv(h, MV_BWD_X0, MV_BWD_C2, MV_PRED_BSKIP, BLK_16X16, 0);
801  } else
802  /* direct prediction from co-located P MB, block-wise */
803  for (block = 0; block < 4; block++)
804  mv_pred_direct(h, &h->mv[mv_scan[block]],
805  &h->col_mv[h->mbidx * 4 + block]);
806  break;
807  case B_FWD_16X16:
808  ff_cavs_mv(h, MV_FWD_X0, MV_FWD_C2, MV_PRED_MEDIAN, BLK_16X16, 1);
809  break;
810  case B_SYM_16X16:
811  ff_cavs_mv(h, MV_FWD_X0, MV_FWD_C2, MV_PRED_MEDIAN, BLK_16X16, 1);
812  mv_pred_sym(h, &h->mv[MV_FWD_X0], BLK_16X16);
813  break;
814  case B_BWD_16X16:
815  ff_cavs_mv(h, MV_BWD_X0, MV_BWD_C2, MV_PRED_MEDIAN, BLK_16X16, 0);
816  break;
817  case B_8X8:
818 #define TMP_UNUSED_INX 7
819  flags = 0;
820  for (block = 0; block < 4; block++)
821  sub_type[block] = get_bits(&h->gb, 2);
822  for (block = 0; block < 4; block++) {
823  switch (sub_type[block]) {
824  case B_SUB_DIRECT:
825  if (!h->col_type_base[h->mbidx]) {
826  /* intra MB at co-location, do in-plane prediction */
827  if(flags==0) {
828  // if col-MB is a Intra MB, current Block size is 16x16.
829  // AVS standard section 9.9.1
830  if(block>0){
831  h->mv[TMP_UNUSED_INX ] = h->mv[MV_FWD_X0 ];
832  h->mv[TMP_UNUSED_INX + MV_BWD_OFFS] = h->mv[MV_FWD_X0 + MV_BWD_OFFS];
833  }
834  ff_cavs_mv(h, MV_FWD_X0, MV_FWD_C2,
835  MV_PRED_BSKIP, BLK_8X8, 1);
836  ff_cavs_mv(h, MV_FWD_X0+MV_BWD_OFFS,
837  MV_FWD_C2+MV_BWD_OFFS,
838  MV_PRED_BSKIP, BLK_8X8, 0);
839  if(block>0) {
840  flags = mv_scan[block];
841  h->mv[flags ] = h->mv[MV_FWD_X0 ];
842  h->mv[flags + MV_BWD_OFFS] = h->mv[MV_FWD_X0 + MV_BWD_OFFS];
843  h->mv[MV_FWD_X0 ] = h->mv[TMP_UNUSED_INX ];
844  h->mv[MV_FWD_X0 + MV_BWD_OFFS] = h->mv[TMP_UNUSED_INX + MV_BWD_OFFS];
845  } else
846  flags = MV_FWD_X0;
847  } else {
848  h->mv[mv_scan[block] ] = h->mv[flags ];
849  h->mv[mv_scan[block] + MV_BWD_OFFS] = h->mv[flags + MV_BWD_OFFS];
850  }
851  } else
852  mv_pred_direct(h, &h->mv[mv_scan[block]],
853  &h->col_mv[h->mbidx * 4 + block]);
854  break;
855  case B_SUB_FWD:
856  ff_cavs_mv(h, mv_scan[block], mv_scan[block] - 3,
857  MV_PRED_MEDIAN, BLK_8X8, 1);
858  break;
859  case B_SUB_SYM:
860  ff_cavs_mv(h, mv_scan[block], mv_scan[block] - 3,
861  MV_PRED_MEDIAN, BLK_8X8, 1);
862  mv_pred_sym(h, &h->mv[mv_scan[block]], BLK_8X8);
863  break;
864  }
865  }
866 #undef TMP_UNUSED_INX
867  for (block = 0; block < 4; block++) {
868  if (sub_type[block] == B_SUB_BWD)
869  ff_cavs_mv(h, mv_scan[block] + MV_BWD_OFFS,
870  mv_scan[block] + MV_BWD_OFFS - 3,
871  MV_PRED_MEDIAN, BLK_8X8, 0);
872  }
873  break;
874  default:
875  if (mb_type <= B_SYM_16X16) {
876  av_log(h->avctx, AV_LOG_ERROR, "Invalid mb_type %d in B frame\n", mb_type);
877  return AVERROR_INVALIDDATA;
878  }
879  av_assert2(mb_type < B_8X8);
880  flags = ff_cavs_partition_flags[mb_type];
881  if (mb_type & 1) { /* 16x8 macroblock types */
882  if (flags & FWD0)
883  ff_cavs_mv(h, MV_FWD_X0, MV_FWD_C2, MV_PRED_TOP, BLK_16X8, 1);
884  if (flags & SYM0)
885  mv_pred_sym(h, &h->mv[MV_FWD_X0], BLK_16X8);
886  if (flags & FWD1)
887  ff_cavs_mv(h, MV_FWD_X2, MV_FWD_A1, MV_PRED_LEFT, BLK_16X8, 1);
888  if (flags & SYM1)
889  mv_pred_sym(h, &h->mv[MV_FWD_X2], BLK_16X8);
890  if (flags & BWD0)
891  ff_cavs_mv(h, MV_BWD_X0, MV_BWD_C2, MV_PRED_TOP, BLK_16X8, 0);
892  if (flags & BWD1)
893  ff_cavs_mv(h, MV_BWD_X2, MV_BWD_A1, MV_PRED_LEFT, BLK_16X8, 0);
894  } else { /* 8x16 macroblock types */
895  if (flags & FWD0)
896  ff_cavs_mv(h, MV_FWD_X0, MV_FWD_B3, MV_PRED_LEFT, BLK_8X16, 1);
897  if (flags & SYM0)
898  mv_pred_sym(h, &h->mv[MV_FWD_X0], BLK_8X16);
899  if (flags & FWD1)
900  ff_cavs_mv(h, MV_FWD_X1, MV_FWD_C2, MV_PRED_TOPRIGHT, BLK_8X16, 1);
901  if (flags & SYM1)
902  mv_pred_sym(h, &h->mv[MV_FWD_X1], BLK_8X16);
903  if (flags & BWD0)
904  ff_cavs_mv(h, MV_BWD_X0, MV_BWD_B3, MV_PRED_LEFT, BLK_8X16, 0);
905  if (flags & BWD1)
906  ff_cavs_mv(h, MV_BWD_X1, MV_BWD_C2, MV_PRED_TOPRIGHT, BLK_8X16, 0);
907  }
908  }
909  ff_cavs_inter(h, mb_type);
910  set_intra_mode_default(h);
911  if (mb_type != B_SKIP)
912  decode_residual_inter(h);
913  ff_cavs_filter(h, mb_type);
914 
915  return 0;
916 }
917 
918 /*****************************************************************************
919  *
920  * slice level
921  *
922  ****************************************************************************/
923 
924 static inline int decode_slice_header(AVSContext *h, GetBitContext *gb)
925 {
926  if (h->stc > 0xAF)
927  av_log(h->avctx, AV_LOG_ERROR, "unexpected start code 0x%02x\n", h->stc);
928 
929  if (h->stc >= h->mb_height) {
930  av_log(h->avctx, AV_LOG_ERROR, "stc 0x%02x is too large\n", h->stc);
931  return AVERROR_INVALIDDATA;
932  }
933 
934  h->mby = h->stc;
935  h->mbidx = h->mby * h->mb_width;
936 
937  /* mark top macroblocks as unavailable */
938  h->flags &= ~(B_AVAIL | C_AVAIL);
939  if (!h->pic_qp_fixed) {
940  h->qp_fixed = get_bits1(gb);
941  h->qp = get_bits(gb, 6);
942  }
943  /* inter frame or second slice can have weighting params */
944  if ((h->cur.f->pict_type != AV_PICTURE_TYPE_I) ||
945  (!h->pic_structure && h->mby >= h->mb_width / 2))
946  if (get_bits1(gb)) { //slice_weighting_flag
947  av_log(h->avctx, AV_LOG_ERROR,
948  "weighted prediction not yet supported\n");
949  }
950  return 0;
951 }
952 
953 static inline int check_for_slice(AVSContext *h)
954 {
955  GetBitContext *gb = &h->gb;
956  int align;
957 
958  if (h->mbx)
959  return 0;
960  align = (-get_bits_count(gb)) & 7;
961  /* check for stuffing byte */
962  if (!align && (show_bits(gb, 8) == 0x80))
963  align = 8;
964  if ((show_bits_long(gb, 24 + align) & 0xFFFFFF) == 0x000001) {
965  skip_bits_long(gb, 24 + align);
966  h->stc = get_bits(gb, 8);
967  if (h->stc >= h->mb_height)
968  return 0;
969  decode_slice_header(h, gb);
970  return 1;
971  }
972  return 0;
973 }
974 
975 /*****************************************************************************
976  *
977  * frame level
978  *
979  ****************************************************************************/
980 
981 static int decode_pic(AVSContext *h)
982 {
983  int ret;
984  int skip_count = -1;
985  enum cavs_mb mb_type;
986 
987  if (!h->top_qp) {
988  av_log(h->avctx, AV_LOG_ERROR, "No sequence header decoded yet\n");
989  return AVERROR_INVALIDDATA;
990  }
991 
992  av_frame_unref(h->cur.f);
993 
994  skip_bits(&h->gb, 16);//bbv_dwlay
995  if (h->stc == PIC_PB_START_CODE) {
996  h->cur.f->pict_type = get_bits(&h->gb, 2) + AV_PICTURE_TYPE_I;
997  if (h->cur.f->pict_type > AV_PICTURE_TYPE_B) {
998  av_log(h->avctx, AV_LOG_ERROR, "illegal picture type\n");
999  return AVERROR_INVALIDDATA;
1000  }
1001  /* make sure we have the reference frames we need */
1002  if (!h->DPB[0].f->data[0] ||
1003  (!h->DPB[1].f->data[0] && h->cur.f->pict_type == AV_PICTURE_TYPE_B))
1004  return AVERROR_INVALIDDATA;
1005  } else {
1006  h->cur.f->pict_type = AV_PICTURE_TYPE_I;
1007  if (get_bits1(&h->gb))
1008  skip_bits(&h->gb, 24);//time_code
1009  /* old sample clips were all progressive and no low_delay,
1010  bump stream revision if detected otherwise */
1011  if (h->low_delay || !(show_bits(&h->gb, 9) & 1))
1012  h->stream_revision = 1;
1013  /* similarly test top_field_first and repeat_first_field */
1014  else if (show_bits(&h->gb, 11) & 3)
1015  h->stream_revision = 1;
1016  if (h->stream_revision > 0)
1017  skip_bits(&h->gb, 1); //marker_bit
1018  }
1019 
1020  ret = ff_get_buffer(h->avctx, h->cur.f, h->cur.f->pict_type == AV_PICTURE_TYPE_B ?
1021  0 : AV_GET_BUFFER_FLAG_REF);
1022  if (ret < 0)
1023  return ret;
1024 
1025  if (!h->edge_emu_buffer) {
1026  int alloc_size = FFALIGN(FFABS(h->cur.f->linesize[0]) + 32, 32);
1027  h->edge_emu_buffer = av_mallocz(alloc_size * 2 * 24);
1028  if (!h->edge_emu_buffer)
1029  return AVERROR(ENOMEM);
1030  }
1031 
1032  if ((ret = ff_cavs_init_pic(h)) < 0)
1033  return ret;
1034  h->cur.poc = get_bits(&h->gb, 8) * 2;
1035 
1036  /* get temporal distances and MV scaling factors */
1037  if (h->cur.f->pict_type != AV_PICTURE_TYPE_B) {
1038  h->dist[0] = (h->cur.poc - h->DPB[0].poc) & 511;
1039  } else {
1040  h->dist[0] = (h->DPB[0].poc - h->cur.poc) & 511;
1041  }
1042  h->dist[1] = (h->cur.poc - h->DPB[1].poc) & 511;
1043  h->scale_den[0] = h->dist[0] ? 512/h->dist[0] : 0;
1044  h->scale_den[1] = h->dist[1] ? 512/h->dist[1] : 0;
1045  if (h->cur.f->pict_type == AV_PICTURE_TYPE_B) {
1046  h->sym_factor = h->dist[0] * h->scale_den[1];
1047  if (FFABS(h->sym_factor) > 32768) {
1048  av_log(h->avctx, AV_LOG_ERROR, "sym_factor %d too large\n", h->sym_factor);
1049  return AVERROR_INVALIDDATA;
1050  }
1051  } else {
1052  h->direct_den[0] = h->dist[0] ? 16384 / h->dist[0] : 0;
1053  h->direct_den[1] = h->dist[1] ? 16384 / h->dist[1] : 0;
1054  }
1055 
1056  if (h->low_delay)
1057  get_ue_golomb(&h->gb); //bbv_check_times
1058  h->progressive = get_bits1(&h->gb);
1059  h->pic_structure = 1;
1060  if (!h->progressive)
1061  h->pic_structure = get_bits1(&h->gb);
1062  if (!h->pic_structure && h->stc == PIC_PB_START_CODE)
1063  skip_bits1(&h->gb); //advanced_pred_mode_disable
1064  skip_bits1(&h->gb); //top_field_first
1065  skip_bits1(&h->gb); //repeat_first_field
1066  h->pic_qp_fixed =
1067  h->qp_fixed = get_bits1(&h->gb);
1068  h->qp = get_bits(&h->gb, 6);
1069  if (h->cur.f->pict_type == AV_PICTURE_TYPE_I) {
1070  if (!h->progressive && !h->pic_structure)
1071  skip_bits1(&h->gb);//what is this?
1072  skip_bits(&h->gb, 4); //reserved bits
1073  } else {
1074  if (!(h->cur.f->pict_type == AV_PICTURE_TYPE_B && h->pic_structure == 1))
1075  h->ref_flag = get_bits1(&h->gb);
1076  skip_bits(&h->gb, 4); //reserved bits
1077  h->skip_mode_flag = get_bits1(&h->gb);
1078  }
1079  h->loop_filter_disable = get_bits1(&h->gb);
1080  if (!h->loop_filter_disable && get_bits1(&h->gb)) {
1081  h->alpha_offset = get_se_golomb(&h->gb);
1082  h->beta_offset = get_se_golomb(&h->gb);
1083  if ( h->alpha_offset < -64 || h->alpha_offset > 64
1084  || h-> beta_offset < -64 || h-> beta_offset > 64) {
1085  h->alpha_offset = h->beta_offset = 0;
1086  return AVERROR_INVALIDDATA;
1087  }
1088  } else {
1089  h->alpha_offset = h->beta_offset = 0;
1090  }
1091 
1092  ret = 0;
1093  if (h->cur.f->pict_type == AV_PICTURE_TYPE_I) {
1094  do {
1095  check_for_slice(h);
1096  ret = decode_mb_i(h, 0);
1097  if (ret < 0)
1098  break;
1099  } while (ff_cavs_next_mb(h));
1100  } else if (h->cur.f->pict_type == AV_PICTURE_TYPE_P) {
1101  do {
1102  if (check_for_slice(h))
1103  skip_count = -1;
1104  if (h->skip_mode_flag && (skip_count < 0)) {
1105  if (get_bits_left(&h->gb) < 1) {
1106  ret = AVERROR_INVALIDDATA;
1107  break;
1108  }
1109  skip_count = get_ue_golomb(&h->gb);
1110  }
1111  if (h->skip_mode_flag && skip_count--) {
1112  decode_mb_p(h, P_SKIP);
1113  } else {
1114  if (get_bits_left(&h->gb) < 1) {
1115  ret = AVERROR_INVALIDDATA;
1116  break;
1117  }
1118  mb_type = get_ue_golomb(&h->gb) + P_SKIP + h->skip_mode_flag;
1119  if (mb_type > P_8X8)
1120  ret = decode_mb_i(h, mb_type - P_8X8 - 1);
1121  else
1122  decode_mb_p(h, mb_type);
1123  }
1124  if (ret < 0)
1125  break;
1126  } while (ff_cavs_next_mb(h));
1127  } else { /* AV_PICTURE_TYPE_B */
1128  do {
1129  if (check_for_slice(h))
1130  skip_count = -1;
1131  if (h->skip_mode_flag && (skip_count < 0)) {
1132  if (get_bits_left(&h->gb) < 1) {
1133  ret = AVERROR_INVALIDDATA;
1134  break;
1135  }
1136  skip_count = get_ue_golomb(&h->gb);
1137  }
1138  if (h->skip_mode_flag && skip_count--) {
1139  ret = decode_mb_b(h, B_SKIP);
1140  } else {
1141  if (get_bits_left(&h->gb) < 1) {
1142  ret = AVERROR_INVALIDDATA;
1143  break;
1144  }
1145  mb_type = get_ue_golomb(&h->gb) + B_SKIP + h->skip_mode_flag;
1146  if (mb_type > B_8X8)
1147  ret = decode_mb_i(h, mb_type - B_8X8 - 1);
1148  else
1149  ret = decode_mb_b(h, mb_type);
1150  }
1151  if (ret < 0)
1152  break;
1153  } while (ff_cavs_next_mb(h));
1154  }
1155  emms_c();
1156  if (ret >= 0 && h->cur.f->pict_type != AV_PICTURE_TYPE_B) {
1157  av_frame_unref(h->DPB[1].f);
1158  FFSWAP(AVSFrame, h->cur, h->DPB[1]);
1159  FFSWAP(AVSFrame, h->DPB[0], h->DPB[1]);
1160  }
1161  return ret;
1162 }
1163 
1164 /*****************************************************************************
1165  *
1166  * headers and interface
1167  *
1168  ****************************************************************************/
1169 
1170 static int decode_seq_header(AVSContext *h)
1171 {
1172  int frame_rate_code;
1173  int width, height;
1174  int ret;
1175 
1176  h->profile = get_bits(&h->gb, 8);
1177  h->level = get_bits(&h->gb, 8);
1178  skip_bits1(&h->gb); //progressive sequence
1179 
1180  width = get_bits(&h->gb, 14);
1181  height = get_bits(&h->gb, 14);
1182  if ((h->width || h->height) && (h->width != width || h->height != height)) {
1183  avpriv_report_missing_feature(h->avctx,
1184  "Width/height changing in CAVS");
1185  return AVERROR_PATCHWELCOME;
1186  }
1187  if (width <= 0 || height <= 0) {
1188  av_log(h->avctx, AV_LOG_ERROR, "Dimensions invalid\n");
1189  return AVERROR_INVALIDDATA;
1190  }
1191  skip_bits(&h->gb, 2); //chroma format
1192  skip_bits(&h->gb, 3); //sample_precision
1193  h->aspect_ratio = get_bits(&h->gb, 4);
1194  frame_rate_code = get_bits(&h->gb, 4);
1195  if (frame_rate_code == 0 || frame_rate_code > 13) {
1196  av_log(h->avctx, AV_LOG_WARNING,
1197  "frame_rate_code %d is invalid\n", frame_rate_code);
1198  frame_rate_code = 1;
1199  }
1200 
1201  skip_bits(&h->gb, 18); //bit_rate_lower
1202  skip_bits1(&h->gb); //marker_bit
1203  skip_bits(&h->gb, 12); //bit_rate_upper
1204  h->low_delay = get_bits1(&h->gb);
1205 
1206  ret = ff_set_dimensions(h->avctx, width, height);
1207  if (ret < 0)
1208  return ret;
1209 
1210  h->width = width;
1211  h->height = height;
1212  h->mb_width = (h->width + 15) >> 4;
1213  h->mb_height = (h->height + 15) >> 4;
1214  h->avctx->framerate = ff_mpeg12_frame_rate_tab[frame_rate_code];
1215  if (!h->top_qp)
1216  return ff_cavs_init_top_lines(h);
1217  return 0;
1218 }
1219 
1220 static void cavs_flush(AVCodecContext * avctx)
1221 {
1222  AVSContext *h = avctx->priv_data;
1223  h->got_keyframe = 0;
1224 }
1225 
1226 static int cavs_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
1227  AVPacket *avpkt)
1228 {
1229  AVSContext *h = avctx->priv_data;
1230  const uint8_t *buf = avpkt->data;
1231  int buf_size = avpkt->size;
1232  uint32_t stc = -1;
1233  int input_size, ret;
1234  const uint8_t *buf_end;
1235  const uint8_t *buf_ptr;
1236  int frame_start = 0;
1237 
1238  if (buf_size == 0) {
1239  if (!h->low_delay && h->DPB[0].f->data[0]) {
1240  *got_frame = 1;
1241  av_frame_move_ref(data, h->DPB[0].f);
1242  }
1243  return 0;
1244  }
1245 
1246  h->stc = 0;
1247 
1248  buf_ptr = buf;
1249  buf_end = buf + buf_size;
1250  for(;;) {
1251  buf_ptr = avpriv_find_start_code(buf_ptr, buf_end, &stc);
1252  if ((stc & 0xFFFFFE00) || buf_ptr == buf_end) {
1253  if (!h->stc)
1254  av_log(h->avctx, AV_LOG_WARNING, "no frame decoded\n");
1255  return FFMAX(0, buf_ptr - buf);
1256  }
1257  input_size = (buf_end - buf_ptr) * 8;
1258  switch (stc) {
1259  case CAVS_START_CODE:
1260  init_get_bits(&h->gb, buf_ptr, input_size);
1261  decode_seq_header(h);
1262  break;
1263  case PIC_I_START_CODE:
1264  if (!h->got_keyframe) {
1265  av_frame_unref(h->DPB[0].f);
1266  av_frame_unref(h->DPB[1].f);
1267  h->got_keyframe = 1;
1268  }
1269  case PIC_PB_START_CODE:
1270  if (frame_start > 1)
1271  return AVERROR_INVALIDDATA;
1272  frame_start ++;
1273  if (*got_frame)
1274  av_frame_unref(data);
1275  *got_frame = 0;
1276  if (!h->got_keyframe)
1277  break;
1278  init_get_bits(&h->gb, buf_ptr, input_size);
1279  h->stc = stc;
1280  if (decode_pic(h))
1281  break;
1282  *got_frame = 1;
1283  if (h->cur.f->pict_type != AV_PICTURE_TYPE_B) {
1284  if (h->DPB[!h->low_delay].f->data[0]) {
1285  if ((ret = av_frame_ref(data, h->DPB[!h->low_delay].f)) < 0)
1286  return ret;
1287  } else {
1288  *got_frame = 0;
1289  }
1290  } else {
1291  av_frame_move_ref(data, h->cur.f);
1292  }
1293  break;
1294  case EXT_START_CODE:
1295  //mpeg_decode_extension(avctx, buf_ptr, input_size);
1296  break;
1297  case USER_START_CODE:
1298  //mpeg_decode_user_data(avctx, buf_ptr, input_size);
1299  break;
1300  default:
1301  if (stc <= SLICE_MAX_START_CODE) {
1302  init_get_bits(&h->gb, buf_ptr, input_size);
1303  decode_slice_header(h, &h->gb);
1304  }
1305  break;
1306  }
1307  }
1308 }
1309 
1310 const AVCodec ff_cavs_decoder = {
1311  .name = "cavs",
1312  .long_name = NULL_IF_CONFIG_SMALL("Chinese AVS (Audio Video Standard) (AVS1-P2, JiZhun profile)"),
1313  .type = AVMEDIA_TYPE_VIDEO,
1314  .id = AV_CODEC_ID_CAVS,
1315  .priv_data_size = sizeof(AVSContext),
1316  .init = ff_cavs_init,
1317  .close = ff_cavs_end,
1318  .decode = cavs_decode_frame,
1319  .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,
1320  .flush = cavs_flush,
1321 };
BLK_16X16
@ BLK_16X16
Definition: cavs.h:116
cavs_mb
cavs_mb
Definition: cavs.h:63
AVCodec
AVCodec.
Definition: codec.h:202
stride
int stride
Definition: mace.c:144
skip_bits_long
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
Definition: get_bits.h:292
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
level
uint8_t level
Definition: svq3.c:204
MV_PRED_PSKIP
@ MV_PRED_PSKIP
Definition: cavs.h:111
show_bits_long
static unsigned int show_bits_long(GetBitContext *s, int n)
Show 0-32 bits.
Definition: get_bits.h:603
ff_cavs_partition_flags
const uint8_t ff_cavs_partition_flags[30]
Definition: cavsdata.c:24
ff_cavs_decoder
const AVCodec ff_cavs_decoder
Definition: cavsdec.c:1310
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:850
r
const char * r
Definition: vf_curves.c:116
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
ff_cavs_chroma_qp
const uint8_t ff_cavs_chroma_qp[64]
Definition: cavsdata.c:57
MV_BWD_C2
@ MV_BWD_C2
Definition: cavs.h:136
SYM1
#define SYM1
Definition: cavs.h:56
chroma_dec
static const struct dec_2dvlc chroma_dec[5]
Definition: cavsdec.c:350
MV_BWD_X0
@ MV_BWD_X0
Definition: cavs.h:138
EXT_START_CODE
#define EXT_START_CODE
Definition: cavs.h:35
SLICE_MAX_START_CODE
#define SLICE_MAX_START_CODE
Definition: cavs.h:34
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:220
MV_FWD_X0
@ MV_FWD_X0
Definition: cavs.h:128
FWD0
#define FWD0
Definition: cavs.h:51
get_ue_golomb
static int get_ue_golomb(GetBitContext *gb)
Read an unsigned Exp-Golomb code in the range 0 to 8190.
Definition: golomb.h:55
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:373
data
const char data[16]
Definition: mxf.c:143
B_SUB_FWD
@ B_SUB_FWD
Definition: cavs.h:80
ff_cavs_init
av_cold int ff_cavs_init(AVCodecContext *avctx)
Definition: cavs.c:796
scan3x3
static const uint8_t scan3x3[4]
Definition: cavsdec.c:52
BLK_8X8
@ BLK_8X8
Definition: cavs.h:119
ff_cavs_dir_mv
const cavs_vector ff_cavs_dir_mv
mark block as "no prediction from this direction" e.g.
Definition: cavsdata.c:66
cavs_block
cavs_block
Definition: cavs.h:115
avpriv_find_start_code
const uint8_t * avpriv_find_start_code(const uint8_t *p, const uint8_t *end, uint32_t *state)
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
ff_cavs_modify_mb_i
void ff_cavs_modify_mb_i(AVSContext *h, int *pred_mode_uv)
Definition: cavs.c:365
decode_residual_chroma
static int decode_residual_chroma(AVSContext *h)
Definition: cavsdec.c:594
ff_cavs_load_intra_pred_chroma
void ff_cavs_load_intra_pred_chroma(AVSContext *h)
Definition: cavs.c:238
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:660
init
static int init
Definition: av_tx.c:47
ff_cavs_init_pic
int ff_cavs_init_pic(AVSContext *h)
Definition: cavs.c:725
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:468
golomb.h
exp golomb vlc stuff
set_mvs
static void set_mvs(cavs_vector *mv, enum cavs_block size)
Definition: cavs.h:252
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:380
ff_cavs_intra_mv
const cavs_vector ff_cavs_intra_mv
mark block as using intra prediction
Definition: cavsdata.c:69
U
#define U(x)
Definition: vp56_arith.h:37
cavs_vector::x
int16_t x
Definition: cavs.h:146
GetBitContext
Definition: get_bits.h:62
MV_BWD_A1
@ MV_BWD_A1
Definition: cavs.h:137
dequant
static int dequant(AVSContext *h, int16_t *level_buf, uint8_t *run_buf, int16_t *dst, int mul, int shift, int coeff_num)
Definition: cavsdec.c:516
cavs_vector::dist
int16_t dist
Definition: cavs.h:148
P_16X8
@ P_16X8
Definition: cavs.h:67
B_AVAIL
#define B_AVAIL
Definition: cavs.h:42
avassert.h
EOB
#define EOB
Definition: cavsdec.c:76
frame_start
static int frame_start(MpegEncContext *s)
Definition: mpegvideo_enc.c:1641
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
I_8X8
@ I_8X8
Definition: cavs.h:64
mask
static const uint16_t mask[17]
Definition: lzw.c:38
mv_scan
static const uint8_t mv_scan[4]
Definition: cavsdec.c:36
decode
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
MV_BWD_X1
@ MV_BWD_X1
Definition: cavs.h:139
width
#define width
MV_BWD_X2
@ MV_BWD_X2
Definition: cavs.h:141
BWD0
#define BWD0
Definition: cavs.h:53
ff_cavs_init_top_lines
int ff_cavs_init_top_lines(AVSContext *h)
some predictions require data from the top-neighbouring macroblock.
Definition: cavs.c:761
MV_PRED_BSKIP
@ MV_PRED_BSKIP
Definition: cavs.h:112
BLK_16X8
@ BLK_16X8
Definition: cavs.h:117
decode_seq_header
static int decode_seq_header(AVSContext *h)
Definition: cavsdec.c:1170
AV_GET_BUFFER_FLAG_REF
#define AV_GET_BUFFER_FLAG_REF
The decoder will keep a reference to the frame and may reuse it later.
Definition: avcodec.h:361
cavs_flush
static void cavs_flush(AVCodecContext *avctx)
Definition: cavsdec.c:1220
decode_slice_header
static int decode_slice_header(AVSContext *h, GetBitContext *gb)
Definition: cavsdec.c:924
decode_mb_p
static void decode_mb_p(AVSContext *h, enum cavs_mb mb_type)
Definition: cavsdec.c:736
get_bits.h
set_mv_intra
static void set_mv_intra(AVSContext *h)
Definition: cavsdec.c:641
decode_residual_block
static int decode_residual_block(AVSContext *h, GetBitContext *gb, const struct dec_2dvlc *r, int esc_golomb_order, int qp, uint8_t *dst, ptrdiff_t stride)
decode coefficients from one 8x8 block, dequantize, inverse transform and add them to sample block
Definition: cavsdec.c:546
MV_PRED_TOPRIGHT
@ MV_PRED_TOPRIGHT
Definition: cavs.h:110
PIC_PB_START_CODE
#define PIC_PB_START_CODE
Definition: cavs.h:39
MV_FWD_B3
@ MV_FWD_B3
Definition: cavs.h:125
MV_BWD_OFFS
#define MV_BWD_OFFS
Definition: cavs.h:60
get_se_golomb
static int get_se_golomb(GetBitContext *gb)
read signed exp golomb code.
Definition: golomb.h:241
B_SUB_BWD
@ B_SUB_BWD
Definition: cavs.h:81
dequant_mul
static const uint16_t dequant_mul[64]
Definition: cavsdec.c:65
mul
static float mul(float src0, float src1)
Definition: dnn_backend_native_layer_mathbinary.c:39
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:65
check_for_slice
static int check_for_slice(AVSContext *h)
Definition: cavsdec.c:953
INTRA_L_LP
@ INTRA_L_LP
Definition: cavs.h:88
flush
static void flush(AVCodecContext *avctx)
Definition: aacdec_template.c:593
NULL
#define NULL
Definition: coverity.c:32
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
run
uint8_t run
Definition: svq3.c:203
TMP_UNUSED_INX
#define TMP_UNUSED_INX
P_16X16
@ P_16X16
Definition: cavs.h:66
mv_pred_direct
static void mv_pred_direct(AVSContext *h, cavs_vector *pmv_fw, cavs_vector *col_mv)
Definition: cavsdec.c:464
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:499
src
#define src
Definition: vp8dsp.c:255
PIC_I_START_CODE
#define PIC_I_START_CODE
Definition: cavs.h:38
CAVS_START_CODE
#define CAVS_START_CODE
Definition: cavs.h:37
cavs_decode_frame
static int cavs_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: cavsdec.c:1226
decode_pic
static int decode_pic(AVSContext *h)
Definition: cavsdec.c:981
ff_cavs_mv
void ff_cavs_mv(AVSContext *h, enum cavs_mv_loc nP, enum cavs_mv_loc nC, enum cavs_mv_pred mode, enum cavs_block size, int ref)
Definition: cavs.c:577
FF_SIGNBIT
#define FF_SIGNBIT(x)
Definition: internal.h:103
B_SYM_16X16
@ B_SYM_16X16
Definition: cavs.h:74
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1652
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
AVPacket::size
int size
Definition: packet.h:374
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
av_frame_ref
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
Definition: frame.c:325
cbp_tab
static const uint8_t cbp_tab[64][2]
Definition: cavsdec.c:41
store_mvs
static void store_mvs(AVSContext *h)
Definition: cavsdec.c:456
MV_FWD_A1
@ MV_FWD_A1
Definition: cavs.h:127
size
int size
Definition: twinvq_data.h:10344
MV_PRED_MEDIAN
@ MV_PRED_MEDIAN
Definition: cavs.h:107
BWD1
#define BWD1
Definition: cavs.h:54
avpriv_report_missing_feature
void avpriv_report_missing_feature(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
USER_START_CODE
#define USER_START_CODE
Definition: cavs.h:36
ff_cavs_end
av_cold int ff_cavs_end(AVCodecContext *avctx)
Definition: cavs.c:842
C_AVAIL
#define C_AVAIL
Definition: cavs.h:43
height
#define height
P_8X8
@ P_8X8
Definition: cavs.h:69
skip_bits1
static void skip_bits1(GetBitContext *s)
Definition: get_bits.h:539
intra_dec
static const struct dec_2dvlc intra_dec[7]
Definition: cavsdec.c:78
BLK_8X16
@ BLK_8X16
Definition: cavs.h:118
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:64
MV_FWD_X3
@ MV_FWD_X3
Definition: cavs.h:132
ff_cavs_load_intra_pred_luma
void ff_cavs_load_intra_pred_luma(AVSContext *h, uint8_t *top, uint8_t **left, int block)
Definition: cavs.c:187
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:271
round
static av_always_inline av_const double round(double x)
Definition: libm.h:444
show_bits
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
Definition: get_bits.h:447
decode_mb_b
static int decode_mb_b(AVSContext *h, enum cavs_mb mb_type)
Definition: cavsdec.c:781
get_ue_code
static int get_ue_code(GetBitContext *gb, int order)
kth-order exponential golomb code
Definition: cavsdec.c:503
AV_CODEC_ID_CAVS
@ AV_CODEC_ID_CAVS
Definition: codec_id.h:137
MV_PRED_TOP
@ MV_PRED_TOP
Definition: cavs.h:109
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
av_frame_move_ref
void av_frame_move_ref(AVFrame *dst, AVFrame *src)
Move everything contained in src to dst and reset src.
Definition: frame.c:462
cavs_vector::y
int16_t y
Definition: cavs.h:147
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:435
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:263
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:209
MV_FWD_X2
@ MV_FWD_X2
Definition: cavs.h:131
MV_FWD_C2
@ MV_FWD_C2
Definition: cavs.h:126
avcodec.h
ff_cavs_init_mb
void ff_cavs_init_mb(AVSContext *h)
initialise predictors for motion vectors and intra prediction
Definition: cavs.c:639
ff_mpeg12_frame_rate_tab
const AVRational ff_mpeg12_frame_rate_tab[]
Definition: mpeg12framerate.c:24
ret
ret
Definition: filter_design.txt:187
FFSWAP
#define FFSWAP(type, a, b)
Definition: macros.h:52
dec_2dvlc
Definition: cavs.h:152
B_SKIP
@ B_SKIP
Definition: cavs.h:70
pos
unsigned int pos
Definition: spdifenc.c:412
B_FWD_16X16
@ B_FWD_16X16
Definition: cavs.h:72
left
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2] ... the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so ...,+,-,+,-,+,+,-,+,-,+,... hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32 - hcoeff[1] - hcoeff[2] - ... a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2} an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||......... intra?||||:Block01 :yes no||||:Block02 :....... ..........||||:Block03 ::y DC ::ref index:||||:Block04 ::cb DC ::motion x :||||......... :cr DC ::motion y :||||....... ..........|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------ ------------ ------------|||Y subbands||Cb subbands||Cr subbands||||--- ---||--- ---||--- ---|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------ ------------ ------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction ------------|\ Dequantization ------------------- \||Reference frames|\ IDWT|------- -------|Motion \|||Frame 0||Frame 1||Compensation . OBMC v -------|------- -------|--------------. \------> Frame n output Frame Frame<----------------------------------/|...|------------------- Range Coder:============Binary Range Coder:------------------- The implemented range coder is an adapted version based upon "Range encoding: an algorithm for removing redundancy from a digitised message." by G. N. N. Martin. The symbols encoded by the Snow range coder are bits(0|1). The associated probabilities are not fix but change depending on the symbol mix seen so far. bit seen|new state ---------+----------------------------------------------- 0|256 - state_transition_table[256 - old_state];1|state_transition_table[old_state];state_transition_table={ 0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:------------------------- FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1. the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled left
Definition: snow.txt:386
mpeg12data.h
ff_cavs_inter
void ff_cavs_inter(AVSContext *h, enum cavs_mb mb_type)
Definition: cavs.c:496
AVCodecContext
main external API structure.
Definition: avcodec.h:383
cavs_sub_mb
cavs_sub_mb
Definition: cavs.h:78
get_ue_golomb_31
static int get_ue_golomb_31(GetBitContext *gb)
read unsigned exp golomb code, constraint to a max of 31.
Definition: golomb.h:122
AV_PICTURE_TYPE_B
@ AV_PICTURE_TYPE_B
Bi-dir predicted.
Definition: avutil.h:276
B_BWD_16X16
@ B_BWD_16X16
Definition: cavs.h:73
B_SUB_SYM
@ B_SUB_SYM
Definition: cavs.h:82
ref
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:107
AV_CODEC_CAP_DELAY
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
Definition: codec.h:82
decode_mb_i
static int decode_mb_i(AVSContext *h, int cbp_code)
Definition: cavsdec.c:651
shift
static int shift(int a, int b)
Definition: sonic.c:83
cavs_vector
Definition: cavs.h:145
AVSContext
Definition: cavs.h:165
AV_PICTURE_TYPE_P
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:275
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
cavs_vector::ref
int16_t ref
Definition: cavs.h:149
ff_set_dimensions
int ff_set_dimensions(AVCodecContext *s, int width, int height)
Check that the provided frame dimensions are valid and set them on the codec context.
Definition: utils.c:86
mv_pred_sym
static void mv_pred_sym(AVSContext *h, cavs_vector *src, enum cavs_block size)
Definition: cavsdec.c:483
ff_cavs_next_mb
int ff_cavs_next_mb(AVSContext *h)
save predictors for later macroblocks and increase macroblock address
Definition: cavs.c:680
B_8X8
@ B_8X8
Definition: cavs.h:75
decode_residual_inter
static int decode_residual_inter(AVSContext *h)
Definition: cavsdec.c:611
ESCAPE_CODE
#define ESCAPE_CODE
Definition: cavs.h:49
MV_BWD_B3
@ MV_BWD_B3
Definition: cavs.h:135
P_8X16
@ P_8X16
Definition: cavs.h:68
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
set_intra_mode_default
static void set_intra_mode_default(AVSContext *h)
Definition: cavsdec.c:725
AVPacket
This structure stores compressed data.
Definition: packet.h:350
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:410
MV_PRED_LEFT
@ MV_PRED_LEFT
Definition: cavs.h:108
d
d
Definition: ffmpeg_filter.c:153
B_SUB_DIRECT
@ B_SUB_DIRECT
Definition: cavs.h:79
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:561
cavs.h
block
The exact code depends on how similar the blocks are and how related they are to the block
Definition: filter_design.txt:207
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
inter_dec
static const struct dec_2dvlc inter_dec[7]
Definition: cavsdec.c:214
ff_cavs_filter
void ff_cavs_filter(AVSContext *h, enum cavs_mb mb_type)
in-loop deblocking filter for a single macroblock
Definition: cavs.c:111
MV_FWD_X1
@ MV_FWD_X1
Definition: cavs.h:129
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
h
h
Definition: vp9dsp_template.c:2038
FWD1
#define FWD1
Definition: cavs.h:52
dequant_shift
static const uint8_t dequant_shift[64]
Definition: cavsdec.c:54
B_DIRECT
@ B_DIRECT
Definition: cavs.h:71
AVSFrame
Definition: cavs.h:160
SYM0
#define SYM0
Definition: cavs.h:55
NOT_AVAIL
#define NOT_AVAIL
Definition: cavs.h:45
P_SKIP
@ P_SKIP
Definition: cavs.h:65
Generated on Wed Aug 24 2022 21:37:28 for FFmpeg by   doxygen 1.8.17