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