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