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