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 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 };
AVSContext::top_border_v
uint8_t * top_border_v
Definition: cavs.h:227
show_bits_long
static unsigned int show_bits_long(GetBitContext *s, int n)
Show 0-32 bits.
Definition: get_bits.h:602
AVSContext::pic_structure
int pic_structure
Definition: cavs.h:183
AVSContext::top_border_u
uint8_t * top_border_u
Definition: cavs.h:227
ff_cavs_modify_mb_i
void ff_cavs_modify_mb_i(AVSContext *h, int *pred_mode_uv)
Definition: cavs.c:365
NULL
#define NULL
Definition: coverity.c:32
AVCodecContext::framerate
AVRational framerate
Definition: avcodec.h:2062
chroma_dec
static const struct dec_2dvlc chroma_dec[5]
Definition: cavsdec.c:350
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
B_8X8
Definition: cavs.h:75
SLICE_MAX_START_CODE
#define SLICE_MAX_START_CODE
Definition: cavs.h:34
AVSContext::got_keyframe
int got_keyframe
Definition: cavs.h:243
AVSContext::avctx
AVCodecContext * avctx
Definition: cavs.h:166
dec_2dvlc::inc_limit
int inc_limit
Definition: cavs.h:156
shift
static int shift(int a, int b)
Definition: sonic.c:82
AVSContext::edge_emu_buffer
uint8_t * edge_emu_buffer
Definition: cavs.h:241
h
h
Definition: vp9dsp_template.c:2038
AVSContext::direct_den
int direct_den[2]
for scaling in direct B block
Definition: cavs.h:238
data
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
flush
static void flush(AVCodecContext *avctx)
Definition: aacdec_template.c:592
AVSContext::cbp
int cbp
Definition: cavs.h:222
get_se_golomb
static int get_se_golomb(GetBitContext *gb)
read signed exp golomb code.
Definition: golomb.h:241
ff_cavs_intra_mv
const cavs_vector ff_cavs_intra_mv
mark block as using intra prediction
Definition: cavsdata.c:69
ret
ret
Definition: filter_design.txt:187
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
I_8X8
Definition: cavs.h:64
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:106
skip_bits_long
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
Definition: get_bits.h:291
cavs_vector::x
int16_t x
Definition: cavs.h:146
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
dequant_shift
static const uint8_t dequant_shift[64]
Definition: cavsdec.c:54
BlockDSPContext::clear_block
void(* clear_block)(int16_t *block)
Definition: blockdsp.h:36
ff_cavs_end
av_cold int ff_cavs_end(AVCodecContext *avctx)
Definition: cavs.c:842
AVSContext::mbidx
int mbidx
macroblock coordinates
Definition: cavs.h:188
BWD1
#define BWD1
Definition: cavs.h:54
scan3x3
static const uint8_t scan3x3[4]
Definition: cavsdec.c:52
ff_cavs_chroma_qp
const uint8_t ff_cavs_chroma_qp[64]
Definition: cavsdata.c:57
AVSContext::col_mv
cavs_vector * col_mv
Definition: cavs.h:209
AVSFrame::poc
int poc
Definition: cavs.h:162
B_DIRECT
Definition: cavs.h:71
SYM1
#define SYM1
Definition: cavs.h:56
AVPacket::size
int size
Definition: packet.h:364
ff_cavs_init_mb
void ff_cavs_init_mb(AVSContext *h)
initialise predictors for motion vectors and intra prediction
Definition: cavs.c:639
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:582
P_8X16
Definition: cavs.h:68
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:237
AVSContext::qp
int qp
Definition: cavs.h:219
ScanTable::permutated
uint8_t permutated[64]
Definition: idctdsp.h:33
run
uint8_t run
Definition: svq3.c:205
AVSContext::loop_filter_disable
int loop_filter_disable
Definition: cavs.h:185
AVCodec
AVCodec.
Definition: codec.h:190
decode
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
decode_seq_header
static int decode_seq_header(AVSContext *h)
Definition: cavsdec.c:1170
cavs_mb
cavs_mb
Definition: cavs.h:63
MV_BWD_OFFS
#define MV_BWD_OFFS
Definition: cavs.h:60
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:75
AVSContext::mbx
int mbx
Definition: cavs.h:188
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
AVSContext::scantable
ScanTable scantable
Definition: cavs.h:223
FWD1
#define FWD1
Definition: cavs.h:52
CAVSDSPContext::cavs_idct8_add
void(* cavs_idct8_add)(uint8_t *dst, int16_t *block, ptrdiff_t stride)
Definition: cavsdsp.h:37
set_mv_intra
static void set_mv_intra(AVSContext *h)
Definition: cavsdec.c:641
block
The exact code depends on how similar the blocks are and how related they are to the block
Definition: filter_design.txt:207
uint8_t
uint8_t
Definition: audio_convert.c:194
AVSContext::ref_flag
int ref_flag
Definition: cavs.h:187
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:64
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
AVSContext::top_qp
uint8_t * top_qp
Definition: cavs.h:193
dec_2dvlc::rltab
int8_t rltab[59][3]
Definition: cavs.h:153
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:443
mv_scan
static const uint8_t mv_scan[4]
Definition: cavsdec.c:36
AVSContext::mv
cavs_vector mv[2 *4 *3]
mv motion vector cache 0: D3 B2 B3 C2 4: A1 X0 X1 - 8: A3 X2 X3 -
Definition: cavs.h:207
AVSContext::width
int width
Definition: cavs.h:180
PIC_I_START_CODE
#define PIC_I_START_CODE
Definition: cavs.h:38
height
#define height
AVPacket::data
uint8_t * data
Definition: packet.h:363
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:219
dec_2dvlc::golomb_order
int8_t golomb_order
Definition: cavs.h:155
get_bits.h
bitstream reader API header.
cavs_flush
static void cavs_flush(AVCodecContext *avctx)
Definition: cavsdec.c:1220
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
size
ptrdiff_t size
Definition: opengl_enc.c:100
AVSContext::dist
int dist[2]
temporal distances from current frame to ref frames
Definition: cavs.h:175
AVSContext::mby
int mby
Definition: cavs.h:188
decode_residual_chroma
static int decode_residual_chroma(AVSContext *h)
Definition: cavsdec.c:594
AVSContext::gb
GetBitContext gb
Definition: cavs.h:172
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:48
AVSContext::cy
uint8_t * cy
Definition: cavs.h:191
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
avpriv_find_start_code
const uint8_t * avpriv_find_start_code(const uint8_t *p, const uint8_t *end, uint32_t *state)
U
#define U(x)
Definition: vp56_arith.h:37
src
#define src
Definition: vp8dsp.c:255
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:849
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
AVSContext::cu
uint8_t * cu
Definition: cavs.h:191
P_8X8
Definition: cavs.h:69
AVSContext::scale_den
int scale_den[2]
for scaling neighbouring MVs
Definition: cavs.h:239
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
decode_pic
static int decode_pic(AVSContext *h)
Definition: cavsdec.c:981
AVSContext::progressive
int progressive
Definition: cavs.h:182
AVSContext::cur
AVSFrame cur
currently decoded frame
Definition: cavs.h:173
mask
static const uint16_t mask[17]
Definition: lzw.c:38
ff_cavs_next_mb
int ff_cavs_next_mb(AVSContext *h)
save predictors for later macroblocks and increase macroblock address
Definition: cavs.c:680
FF_SIGNBIT
#define FF_SIGNBIT(x)
Definition: internal.h:99
B_SUB_FWD
Definition: cavs.h:80
ff_cavs_inter
void ff_cavs_inter(AVSContext *h, enum cavs_mb mb_type)
Definition: cavs.c:496
AVSContext::cdsp
CAVSDSPContext cdsp
Definition: cavs.h:171
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:115
r
const char * r
Definition: vf_curves.c:116
pos
unsigned int pos
Definition: spdifenc.c:412
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
cbp_tab
static const uint8_t cbp_tab[64][2]
Definition: cavsdec.c:41
C_AVAIL
#define C_AVAIL
Definition: cavs.h:43
avassert.h
simple assert() macros that are a bit more flexible than ISO C assert().
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
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:197
round
static av_always_inline av_const double round(double x)
Definition: libm.h:444
FFMAX
#define FFMAX(a, b)
Definition: common.h:103
P_16X8
Definition: cavs.h:67
mul
static float mul(float src0, float src1)
Definition: dnn_backend_native_layer_mathbinary.c:40
AVSContext::skip_mode_flag
int skip_mode_flag
select between skip_count or one skip_flag per MB
Definition: cavs.h:184
AVSContext::DPB
AVSFrame DPB[2]
reference frames
Definition: cavs.h:174
B_AVAIL
#define B_AVAIL
Definition: cavs.h:42
EOB
#define EOB
Definition: cavsdec.c:76
dequant_mul
static const uint16_t dequant_mul[64]
Definition: cavsdec.c:65
SYM0
#define SYM0
Definition: cavs.h:55
AVSContext::cv
uint8_t * cv
current MB sample pointers
Definition: cavs.h:191
ff_cavs_load_intra_pred_chroma
void ff_cavs_load_intra_pred_chroma(AVSContext *h)
Definition: cavs.c:238
check_for_slice
static int check_for_slice(AVSContext *h)
Definition: cavsdec.c:953
AVSContext::stream_revision
int stream_revision
0 for samples from 2006, 1 for rm52j encoder
Definition: cavs.h:181
AVSContext::pic_qp_fixed
int pic_qp_fixed
Definition: cavs.h:221
BLK_8X16
Definition: cavs.h:118
AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
AVFrame::pict_type
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:397
NOT_AVAIL
#define NOT_AVAIL
Definition: cavs.h:45
ff_cavs_init
av_cold int ff_cavs_init(AVCodecContext *avctx)
Definition: cavs.c:796
FFMIN
#define FFMIN(a, b)
Definition: common.h:105
ff_cavs_decoder
AVCodec ff_cavs_decoder
Definition: cavsdec.c:1310
cavs_sub_mb
cavs_sub_mb
Definition: cavs.h:78
cavs_vector::dist
int16_t dist
Definition: cavs.h:148
AVSContext::left_border_u
uint8_t left_border_u[10]
Definition: cavs.h:228
AVSContext::intra_pred_c
void(* intra_pred_c[7])(uint8_t *d, uint8_t *top, uint8_t *left, ptrdiff_t stride)
Definition: cavs.h:233
width
#define width
ff_cavs_partition_flags
const uint8_t ff_cavs_partition_flags[30]
Definition: cavsdata.c:24
AVSContext::block
int16_t * block
Definition: cavs.h:244
ESCAPE_CODE
#define ESCAPE_CODE
Definition: cavs.h:49
show_bits
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
Definition: get_bits.h:446
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
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
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
EXT_START_CODE
#define EXT_START_CODE
Definition: cavs.h:35
B_SUB_SYM
Definition: cavs.h:82
AVSContext::left_border_v
uint8_t left_border_v[10]
Definition: cavs.h:228
AVSContext::level
int level
Definition: cavs.h:177
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
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
TMP_UNUSED_INX
#define TMP_UNUSED_INX
BLK_16X8
Definition: cavs.h:117
dec_2dvlc::max_run
int8_t max_run
Definition: cavs.h:157
mv_pred_direct
static void mv_pred_direct(AVSContext *h, cavs_vector *pmv_fw, cavs_vector *col_mv)
Definition: cavsdec.c:464
cavs_vector
Definition: cavs.h:145
avcodec.h
Libavcodec external API header.
BWD0
#define BWD0
Definition: cavs.h:53
decode_mb_b
static int decode_mb_b(AVSContext *h, enum cavs_mb mb_type)
Definition: cavsdec.c:781
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
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:345
AVCodecContext
main external API structure.
Definition: avcodec.h:531
AVSContext::sym_factor
int sym_factor
for scaling in symmetrical B block
Definition: cavs.h:237
USER_START_CODE
#define USER_START_CODE
Definition: cavs.h:36
AVSContext::pred_mode_Y
int pred_mode_Y[3 *3]
luma pred mode cache 0: – B2 B3 3: A1 X0 X1 6: A3 X2 X3
Definition: cavs.h:215
mpeg12data.h
MPEG-1/2 tables.
cavs_block
cavs_block
Definition: cavs.h:115
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1884
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:206
frame_start
static int frame_start(MpegEncContext *s)
Definition: mpegvideo_enc.c:1774
B_SUB_BWD
Definition: cavs.h:81
AVSContext::top_pred_Y
int * top_pred_Y
Definition: cavs.h:216
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
skip_bits1
static void skip_bits1(GetBitContext *s)
Definition: get_bits.h:538
cavs_decode_frame
static int cavs_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: cavsdec.c:1226
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:467
CAVS_START_CODE
#define CAVS_START_CODE
Definition: cavs.h:37
intra_dec
static const struct dec_2dvlc intra_dec[7]
Definition: cavsdec.c:78
cavs_vector::ref
int16_t ref
Definition: cavs.h:149
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:659
dec_2dvlc::level_add
int8_t level_add[27]
Definition: cavs.h:154
AVSContext::height
int height
Definition: cavs.h:180
AVSContext::alpha_offset
int alpha_offset
Definition: cavs.h:186
P_16X16
Definition: cavs.h:66
store_mvs
static void store_mvs(AVSContext *h)
Definition: cavsdec.c:456
AVSContext::profile
int profile
Definition: cavs.h:177
AVSContext::c_stride
ptrdiff_t c_stride
Definition: cavs.h:217
PIC_PB_START_CODE
#define PIC_PB_START_CODE
Definition: cavs.h:39
AVSContext::stc
int stc
last start code
Definition: cavs.h:190
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:553
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.
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:561
AVSContext::bdsp
BlockDSPContext bdsp
Definition: cavs.h:167
AV_CODEC_ID_CAVS
Definition: codec_id.h:136
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:328
level
uint8_t level
Definition: svq3.c:206
stride
GLint GLenum GLboolean GLsizei stride
Definition: opengl_enc.c:104
internal.h
common internal api header.
ref
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:107
AVSContext::qp_fixed
int qp_fixed
Definition: cavs.h:220
AVSFrame
Definition: cavs.h:160
mv_pred_sym
static void mv_pred_sym(AVSContext *h, cavs_vector *src, enum cavs_block size)
Definition: cavsdec.c:483
AV_PICTURE_TYPE_B
Bi-dir predicted.
Definition: avutil.h:276
AVSContext::flags
int flags
availability flags of neighbouring macroblocks
Definition: cavs.h:189
AVSContext::l_stride
ptrdiff_t l_stride
Definition: cavs.h:217
P_SKIP
Definition: cavs.h:65
AVSContext::luma_scan
int luma_scan[4]
Definition: cavs.h:218
get_ue_code
static int get_ue_code(GetBitContext *gb, int order)
kth-order exponential golomb code
Definition: cavsdec.c:503
AVSContext::mb_height
int mb_height
Definition: cavs.h:179
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:558
AVSContext::beta_offset
int beta_offset
Definition: cavs.h:186
ff_cavs_init_pic
int ff_cavs_init_pic(AVSContext *h)
Definition: cavs.c:725
inter_dec
static const struct dec_2dvlc inter_dec[7]
Definition: cavsdec.c:214
decode_mb_i
static int decode_mb_i(AVSContext *h, int cbp_code)
Definition: cavsdec.c:651
BLK_8X8
Definition: cavs.h:119
dec_2dvlc
Definition: cavs.h:152
FWD0
#define FWD0
Definition: cavs.h:51
AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
set_mvs
static void set_mvs(cavs_vector *mv, enum cavs_block size)
Definition: cavs.h:252
B_SKIP
Definition: cavs.h:70
AVSContext::aspect_ratio
int aspect_ratio
Definition: cavs.h:178
decode_residual_inter
static int decode_residual_inter(AVSContext *h)
Definition: cavsdec.c:611
FFSWAP
#define FFSWAP(type, a, b)
Definition: common.h:108
set_intra_mode_default
static void set_intra_mode_default(AVSContext *h)
Definition: cavsdec.c:725
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
cavs_vector::y
int16_t y
Definition: cavs.h:147
AVSContext::intra_pred_l
void(* intra_pred_l[8])(uint8_t *d, uint8_t *top, uint8_t *left, ptrdiff_t stride)
Definition: cavs.h:232
golomb.h
exp golomb vlc stuff
AVPacket
This structure stores compressed data.
Definition: packet.h:340
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:514
AVSContext::mb_width
int mb_width
Definition: cavs.h:179
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:50
AVSFrame::f
AVFrame * f
Definition: cavs.h:161
i
int i
Definition: input.c:407
AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:275
AVSContext::low_delay
int low_delay
Definition: cavs.h:176
AVSContext::col_type_base
uint8_t * col_type_base
Definition: cavs.h:234
ff_mpeg12_frame_rate_tab
const AVRational ff_mpeg12_frame_rate_tab[]
Definition: mpeg12framerate.c:24
Generated on Sun Feb 28 2021 19:21:40 for FFmpeg by   doxygen 1.8.11