Debian Codegraph @

src/gen10_vdenc_vp9.c

raw
1 /*
2 * Copyright © 2018 Intel Corporation
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the
6 * "Software"), to deal in the Software without restriction, including
7 * without limitation the rights to use, copy, modify, merge, publish,
8 * distribute, sub license, and/or sell copies of the Software, and to
9 * permit persons to whom the Software is furnished to do so, subject to
10 * the following conditions:
11 *
12 * The above copyright notice and this permission notice (including the
13 * next paragraph) shall be included in all copies or substantial portions
14 * of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
17 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
18 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
19 * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
20 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
21 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
22 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
23 *
24 * Authors:
25 * Xiang Haihao <[email protected]>
26 *
27 */
28
29 #include <stdio.h>
30 #include <stdlib.h>
31 #include <string.h>
32 #include <math.h>
33 #include <assert.h>
34
35 #include "intel_batchbuffer.h"
36 #include "i965_defines.h"
37 #include "i965_structs.h"
38 #include "i965_drv_video.h"
39 #include "i965_encoder.h"
40 #include "i965_encoder_utils.h"
41 #include "intel_media.h"
42 #include "i965_encoder_common.h"
43 #include "gen10_vdenc_common.h"
44 #include "gen10_hcp_common.h"
45 #include "gen10_huc_common.h"
46 #include "gen10_vdenc_vp9.h"
47
48 static const uint32_t gen10_vdenc_vp9_dys[][4] = {
49 #include "shaders/brc/cnl/vp9_dys.g10b"
50 };
51
52 static struct i965_kernel vdenc_vp9_kernels_dys[1] = {
53 {
54 "dys",
55 0,
56 gen10_vdenc_vp9_dys,
57 sizeof(gen10_vdenc_vp9_dys),
58 NULL
59 },
60 };
61
62 static const uint32_t gen10_vdenc_vp9_streamin[][4] = {
63 #include "shaders/brc/cnl/vp9_vdenc_hme_vp9_streamin.g10b"
64 };
65
66 static struct i965_kernel vdenc_vp9_kernels_streamin[1] = {
67 {
68 "streamin",
69 0,
70 gen10_vdenc_vp9_streamin,
71 sizeof(gen10_vdenc_vp9_streamin),
72 NULL
73 },
74 };
75
76 static const uint32_t vdenc_vp9_huc_prob_dmem_data[320] = {
77 0x00000000, 0x00000000, 0x00000000, 0x00000003, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
78 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000100, 0x00000000, 0x00000000,
79 0x00000001, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000001,
80 0x00000004, 0x00000004, 0x00000001, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
81 0x00000000, 0x00000000, 0x00000000, 0x01000000, 0x0000ff00, 0x00000000, 0x00000000, 0x00000000,
82 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000001, 0x00000000, 0x00000000, 0x00000001,
83 0x00540049, 0x00000060, 0x00000072, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
84 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
85 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
86 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
87 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
88 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
89 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
90 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
91 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
92 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
93 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
94 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
95 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
96 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
97 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
98 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
99 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
100 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
101 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
102 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
103 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
104 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
105 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
106 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
107 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
108 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
109 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
110 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
111 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
112 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
113 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
114 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
115 0x00000000, 0x00000000, 0x00000000, 0x02b80078, 0x00000001, 0x00000000, 0x00000000, 0x00000000,
116 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000
117 };
118
119 static const uint8_t vdenc_vp9_key_frame_default_probs[2048] = {
120 0x64, 0x42, 0x14, 0x98, 0x0f, 0x65, 0x03, 0x88, 0x25, 0x05, 0x34, 0x0d, 0x00, 0x00, 0x00, 0x00,
121 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
122 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
123 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
124 0xc3, 0x1d, 0xb7, 0x54, 0x31, 0x88, 0x08, 0x2a, 0x47, 0x1f, 0x6b, 0xa9, 0x23, 0x63, 0x9f, 0x11,
125 0x52, 0x8c, 0x08, 0x42, 0x72, 0x02, 0x2c, 0x4c, 0x01, 0x13, 0x20, 0x28, 0x84, 0xc9, 0x1d, 0x72,
126 0xbb, 0x0d, 0x5b, 0x9d, 0x07, 0x4b, 0x7f, 0x03, 0x3a, 0x5f, 0x01, 0x1c, 0x2f, 0x45, 0x8e, 0xdd,
127 0x2a, 0x7a, 0xc9, 0x0f, 0x5b, 0x9f, 0x06, 0x43, 0x79, 0x01, 0x2a, 0x4d, 0x01, 0x11, 0x1f, 0x66,
128 0x94, 0xe4, 0x43, 0x75, 0xcc, 0x11, 0x52, 0x9a, 0x06, 0x3b, 0x72, 0x02, 0x27, 0x4b, 0x01, 0x0f,
129 0x1d, 0x9c, 0x39, 0xe9, 0x77, 0x39, 0xd4, 0x3a, 0x30, 0xa3, 0x1d, 0x28, 0x7c, 0x0c, 0x1e, 0x51,
130 0x03, 0x0c, 0x1f, 0xbf, 0x6b, 0xe2, 0x7c, 0x75, 0xcc, 0x19, 0x63, 0x9b, 0x1d, 0x94, 0xd2, 0x25,
131 0x7e, 0xc2, 0x08, 0x5d, 0x9d, 0x02, 0x44, 0x76, 0x01, 0x27, 0x45, 0x01, 0x11, 0x21, 0x29, 0x97,
132 0xd5, 0x1b, 0x7b, 0xc1, 0x03, 0x52, 0x90, 0x01, 0x3a, 0x69, 0x01, 0x20, 0x3c, 0x01, 0x0d, 0x1a,
133 0x3b, 0x9f, 0xdc, 0x17, 0x7e, 0xc6, 0x04, 0x58, 0x97, 0x01, 0x42, 0x72, 0x01, 0x26, 0x47, 0x01,
134 0x12, 0x22, 0x72, 0x88, 0xe8, 0x33, 0x72, 0xcf, 0x0b, 0x53, 0x9b, 0x03, 0x38, 0x69, 0x01, 0x21,
135 0x41, 0x01, 0x11, 0x22, 0x95, 0x41, 0xea, 0x79, 0x39, 0xd7, 0x3d, 0x31, 0xa6, 0x1c, 0x24, 0x72,
136 0x0c, 0x19, 0x4c, 0x03, 0x10, 0x2a, 0xd6, 0x31, 0xdc, 0x84, 0x3f, 0xbc, 0x2a, 0x41, 0x89, 0x55,
137 0x89, 0xdd, 0x68, 0x83, 0xd8, 0x31, 0x6f, 0xc0, 0x15, 0x57, 0x9b, 0x02, 0x31, 0x57, 0x01, 0x10,
138 0x1c, 0x59, 0xa3, 0xe6, 0x5a, 0x89, 0xdc, 0x1d, 0x64, 0xb7, 0x0a, 0x46, 0x87, 0x02, 0x2a, 0x51,
139 0x01, 0x11, 0x21, 0x6c, 0xa7, 0xed, 0x37, 0x85, 0xde, 0x0f, 0x61, 0xb3, 0x04, 0x48, 0x87, 0x01,
140 0x2d, 0x55, 0x01, 0x13, 0x26, 0x7c, 0x92, 0xf0, 0x42, 0x7c, 0xe0, 0x11, 0x58, 0xaf, 0x04, 0x3a,
141 0x7a, 0x01, 0x24, 0x4b, 0x01, 0x12, 0x25, 0x8d, 0x4f, 0xf1, 0x7e, 0x46, 0xe3, 0x42, 0x3a, 0xb6,
142 0x1e, 0x2c, 0x88, 0x0c, 0x22, 0x60, 0x02, 0x14, 0x2f, 0xe5, 0x63, 0xf9, 0x8f, 0x6f, 0xeb, 0x2e,
143 0x6d, 0xc0, 0x52, 0x9e, 0xec, 0x5e, 0x92, 0xe0, 0x19, 0x75, 0xbf, 0x09, 0x57, 0x95, 0x03, 0x38,
144 0x63, 0x01, 0x21, 0x39, 0x53, 0xa7, 0xed, 0x44, 0x91, 0xde, 0x0a, 0x67, 0xb1, 0x02, 0x48, 0x83,
145 0x01, 0x29, 0x4f, 0x01, 0x14, 0x27, 0x63, 0xa7, 0xef, 0x2f, 0x8d, 0xe0, 0x0a, 0x68, 0xb2, 0x02,
146 0x49, 0x85, 0x01, 0x2c, 0x55, 0x01, 0x16, 0x2f, 0x7f, 0x91, 0xf3, 0x47, 0x81, 0xe4, 0x11, 0x5d,
147 0xb1, 0x03, 0x3d, 0x7c, 0x01, 0x29, 0x54, 0x01, 0x15, 0x34, 0x9d, 0x4e, 0xf4, 0x8c, 0x48, 0xe7,
148 0x45, 0x3a, 0xb8, 0x1f, 0x2c, 0x89, 0x0e, 0x26, 0x69, 0x08, 0x17, 0x3d, 0x7d, 0x22, 0xbb, 0x34,
149 0x29, 0x85, 0x06, 0x1f, 0x38, 0x25, 0x6d, 0x99, 0x33, 0x66, 0x93, 0x17, 0x57, 0x80, 0x08, 0x43,
150 0x65, 0x01, 0x29, 0x3f, 0x01, 0x13, 0x1d, 0x1f, 0x9a, 0xb9, 0x11, 0x7f, 0xaf, 0x06, 0x60, 0x91,
151 0x02, 0x49, 0x72, 0x01, 0x33, 0x52, 0x01, 0x1c, 0x2d, 0x17, 0xa3, 0xc8, 0x0a, 0x83, 0xb9, 0x02,
152 0x5d, 0x94, 0x01, 0x43, 0x6f, 0x01, 0x29, 0x45, 0x01, 0x0e, 0x18, 0x1d, 0xb0, 0xd9, 0x0c, 0x91,
153 0xc9, 0x03, 0x65, 0x9c, 0x01, 0x45, 0x6f, 0x01, 0x27, 0x3f, 0x01, 0x0e, 0x17, 0x39, 0xc0, 0xe9,
154 0x19, 0x9a, 0xd7, 0x06, 0x6d, 0xa7, 0x03, 0x4e, 0x76, 0x01, 0x30, 0x45, 0x01, 0x15, 0x1d, 0xca,
155 0x69, 0xf5, 0x6c, 0x6a, 0xd8, 0x12, 0x5a, 0x90, 0x21, 0xac, 0xdb, 0x40, 0x95, 0xce, 0x0e, 0x75,
156 0xb1, 0x05, 0x5a, 0x8d, 0x02, 0x3d, 0x5f, 0x01, 0x25, 0x39, 0x21, 0xb3, 0xdc, 0x0b, 0x8c, 0xc6,
157 0x01, 0x59, 0x94, 0x01, 0x3c, 0x68, 0x01, 0x21, 0x39, 0x01, 0x0c, 0x15, 0x1e, 0xb5, 0xdd, 0x08,
158 0x8d, 0xc6, 0x01, 0x57, 0x91, 0x01, 0x3a, 0x64, 0x01, 0x1f, 0x37, 0x01, 0x0c, 0x14, 0x20, 0xba,
159 0xe0, 0x07, 0x8e, 0xc6, 0x01, 0x56, 0x8f, 0x01, 0x3a, 0x64, 0x01, 0x1f, 0x37, 0x01, 0x0c, 0x16,
160 0x39, 0xc0, 0xe3, 0x14, 0x8f, 0xcc, 0x03, 0x60, 0x9a, 0x01, 0x44, 0x70, 0x01, 0x2a, 0x45, 0x01,
161 0x13, 0x20, 0xd4, 0x23, 0xd7, 0x71, 0x2f, 0xa9, 0x1d, 0x30, 0x69, 0x4a, 0x81, 0xcb, 0x6a, 0x78,
162 0xcb, 0x31, 0x6b, 0xb2, 0x13, 0x54, 0x90, 0x04, 0x32, 0x54, 0x01, 0x0f, 0x19, 0x47, 0xac, 0xd9,
163 0x2c, 0x8d, 0xd1, 0x0f, 0x66, 0xad, 0x06, 0x4c, 0x85, 0x02, 0x33, 0x59, 0x01, 0x18, 0x2a, 0x40,
164 0xb9, 0xe7, 0x1f, 0x94, 0xd8, 0x08, 0x67, 0xaf, 0x03, 0x4a, 0x83, 0x01, 0x2e, 0x51, 0x01, 0x12,
165 0x1e, 0x41, 0xc4, 0xeb, 0x19, 0x9d, 0xdd, 0x05, 0x69, 0xae, 0x01, 0x43, 0x78, 0x01, 0x26, 0x45,
166 0x01, 0x0f, 0x1e, 0x41, 0xcc, 0xee, 0x1e, 0x9c, 0xe0, 0x07, 0x6b, 0xb1, 0x02, 0x46, 0x7c, 0x01,
167 0x2a, 0x49, 0x01, 0x12, 0x22, 0xe1, 0x56, 0xfb, 0x90, 0x68, 0xeb, 0x2a, 0x63, 0xb5, 0x55, 0xaf,
168 0xef, 0x70, 0xa5, 0xe5, 0x1d, 0x88, 0xc8, 0x0c, 0x67, 0xa2, 0x06, 0x4d, 0x7b, 0x02, 0x35, 0x54,
169 0x4b, 0xb7, 0xef, 0x1e, 0x9b, 0xdd, 0x03, 0x6a, 0xab, 0x01, 0x4a, 0x80, 0x01, 0x2c, 0x4c, 0x01,
170 0x11, 0x1c, 0x49, 0xb9, 0xf0, 0x1b, 0x9f, 0xde, 0x02, 0x6b, 0xac, 0x01, 0x4b, 0x7f, 0x01, 0x2a,
171 0x49, 0x01, 0x11, 0x1d, 0x3e, 0xbe, 0xee, 0x15, 0x9f, 0xde, 0x02, 0x6b, 0xac, 0x01, 0x48, 0x7a,
172 0x01, 0x28, 0x47, 0x01, 0x12, 0x20, 0x3d, 0xc7, 0xf0, 0x1b, 0xa1, 0xe2, 0x04, 0x71, 0xb4, 0x01,
173 0x4c, 0x81, 0x01, 0x2e, 0x50, 0x01, 0x17, 0x29, 0x07, 0x1b, 0x99, 0x05, 0x1e, 0x5f, 0x01, 0x10,
174 0x1e, 0x32, 0x4b, 0x7f, 0x39, 0x4b, 0x7c, 0x1b, 0x43, 0x6c, 0x0a, 0x36, 0x56, 0x01, 0x21, 0x34,
175 0x01, 0x0c, 0x12, 0x2b, 0x7d, 0x97, 0x1a, 0x6c, 0x94, 0x07, 0x53, 0x7a, 0x02, 0x3b, 0x59, 0x01,
176 0x26, 0x3c, 0x01, 0x11, 0x1b, 0x17, 0x90, 0xa3, 0x0d, 0x70, 0x9a, 0x02, 0x4b, 0x75, 0x01, 0x32,
177 0x51, 0x01, 0x1f, 0x33, 0x01, 0x0e, 0x17, 0x12, 0xa2, 0xb9, 0x06, 0x7b, 0xab, 0x01, 0x4e, 0x7d,
178 0x01, 0x33, 0x56, 0x01, 0x1f, 0x36, 0x01, 0x0e, 0x17, 0x0f, 0xc7, 0xe3, 0x03, 0x96, 0xcc, 0x01,
179 0x5b, 0x92, 0x01, 0x37, 0x5f, 0x01, 0x1e, 0x35, 0x01, 0x0b, 0x14, 0x13, 0x37, 0xf0, 0x13, 0x3b,
180 0xc4, 0x03, 0x34, 0x69, 0x29, 0xa6, 0xcf, 0x68, 0x99, 0xc7, 0x1f, 0x7b, 0xb5, 0x0e, 0x65, 0x98,
181 0x05, 0x48, 0x6a, 0x01, 0x24, 0x34, 0x23, 0xb0, 0xd3, 0x0c, 0x83, 0xbe, 0x02, 0x58, 0x90, 0x01,
182 0x3c, 0x65, 0x01, 0x24, 0x3c, 0x01, 0x10, 0x1c, 0x1c, 0xb7, 0xd5, 0x08, 0x86, 0xbf, 0x01, 0x56,
183 0x8e, 0x01, 0x38, 0x60, 0x01, 0x1e, 0x35, 0x01, 0x0c, 0x14, 0x14, 0xbe, 0xd7, 0x04, 0x87, 0xc0,
184 0x01, 0x54, 0x8b, 0x01, 0x35, 0x5b, 0x01, 0x1c, 0x31, 0x01, 0x0b, 0x14, 0x0d, 0xc4, 0xd8, 0x02,
185 0x89, 0xc0, 0x01, 0x56, 0x8f, 0x01, 0x39, 0x63, 0x01, 0x20, 0x38, 0x01, 0x0d, 0x18, 0xd3, 0x1d,
186 0xd9, 0x60, 0x2f, 0x9c, 0x16, 0x2b, 0x57, 0x4e, 0x78, 0xc1, 0x6f, 0x74, 0xba, 0x2e, 0x66, 0xa4,
187 0x0f, 0x50, 0x80, 0x02, 0x31, 0x4c, 0x01, 0x12, 0x1c, 0x47, 0xa1, 0xcb, 0x2a, 0x84, 0xc0, 0x0a,
188 0x62, 0x96, 0x03, 0x45, 0x6d, 0x01, 0x2c, 0x46, 0x01, 0x12, 0x1d, 0x39, 0xba, 0xd3, 0x1e, 0x8c,
189 0xc4, 0x04, 0x5d, 0x92, 0x01, 0x3e, 0x66, 0x01, 0x26, 0x41, 0x01, 0x10, 0x1b, 0x2f, 0xc7, 0xd9,
190 0x0e, 0x91, 0xc4, 0x01, 0x58, 0x8e, 0x01, 0x39, 0x62, 0x01, 0x24, 0x3e, 0x01, 0x0f, 0x1a, 0x1a,
191 0xdb, 0xe5, 0x05, 0x9b, 0xcf, 0x01, 0x5e, 0x97, 0x01, 0x3c, 0x68, 0x01, 0x24, 0x3e, 0x01, 0x10,
192 0x1c, 0xe9, 0x1d, 0xf8, 0x92, 0x2f, 0xdc, 0x2b, 0x34, 0x8c, 0x64, 0xa3, 0xe8, 0xb3, 0xa1, 0xde,
193 0x3f, 0x8e, 0xcc, 0x25, 0x71, 0xae, 0x1a, 0x59, 0x89, 0x12, 0x44, 0x61, 0x55, 0xb5, 0xe6, 0x20,
194 0x92, 0xd1, 0x07, 0x64, 0xa4, 0x03, 0x47, 0x79, 0x01, 0x2d, 0x4d, 0x01, 0x12, 0x1e, 0x41, 0xbb,
195 0xe6, 0x14, 0x94, 0xcf, 0x02, 0x61, 0x9f, 0x01, 0x44, 0x74, 0x01, 0x28, 0x46, 0x01, 0x0e, 0x1d,
196 0x28, 0xc2, 0xe3, 0x08, 0x93, 0xcc, 0x01, 0x5e, 0x9b, 0x01, 0x41, 0x70, 0x01, 0x27, 0x42, 0x01,
197 0x0e, 0x1a, 0x10, 0xd0, 0xe4, 0x03, 0x97, 0xcf, 0x01, 0x62, 0xa0, 0x01, 0x43, 0x75, 0x01, 0x29,
198 0x4a, 0x01, 0x11, 0x1f, 0x11, 0x26, 0x8c, 0x07, 0x22, 0x50, 0x01, 0x11, 0x1d, 0x25, 0x4b, 0x80,
199 0x29, 0x4c, 0x80, 0x1a, 0x42, 0x74, 0x0c, 0x34, 0x5e, 0x02, 0x20, 0x37, 0x01, 0x0a, 0x10, 0x32,
200 0x7f, 0x9a, 0x25, 0x6d, 0x98, 0x10, 0x52, 0x79, 0x05, 0x3b, 0x55, 0x01, 0x23, 0x36, 0x01, 0x0d,
201 0x14, 0x28, 0x8e, 0xa7, 0x11, 0x6e, 0x9d, 0x02, 0x47, 0x70, 0x01, 0x2c, 0x48, 0x01, 0x1b, 0x2d,
202 0x01, 0x0b, 0x11, 0x1e, 0xaf, 0xbc, 0x09, 0x7c, 0xa9, 0x01, 0x4a, 0x74, 0x01, 0x30, 0x4e, 0x01,
203 0x1e, 0x31, 0x01, 0x0b, 0x12, 0x0a, 0xde, 0xdf, 0x02, 0x96, 0xc2, 0x01, 0x53, 0x80, 0x01, 0x30,
204 0x4f, 0x01, 0x1b, 0x2d, 0x01, 0x0b, 0x11, 0x24, 0x29, 0xeb, 0x1d, 0x24, 0xc1, 0x0a, 0x1b, 0x6f,
205 0x55, 0xa5, 0xde, 0xb1, 0xa2, 0xd7, 0x6e, 0x87, 0xc3, 0x39, 0x71, 0xa8, 0x17, 0x53, 0x78, 0x0a,
206 0x31, 0x3d, 0x55, 0xbe, 0xdf, 0x24, 0x8b, 0xc8, 0x05, 0x5a, 0x92, 0x01, 0x3c, 0x67, 0x01, 0x26,
207 0x41, 0x01, 0x12, 0x1e, 0x48, 0xca, 0xdf, 0x17, 0x8d, 0xc7, 0x02, 0x56, 0x8c, 0x01, 0x38, 0x61,
208 0x01, 0x24, 0x3d, 0x01, 0x10, 0x1b, 0x37, 0xda, 0xe1, 0x0d, 0x91, 0xc8, 0x01, 0x56, 0x8d, 0x01,
209 0x39, 0x63, 0x01, 0x23, 0x3d, 0x01, 0x0d, 0x16, 0x0f, 0xeb, 0xd4, 0x01, 0x84, 0xb8, 0x01, 0x54,
210 0x8b, 0x01, 0x39, 0x61, 0x01, 0x22, 0x38, 0x01, 0x0e, 0x17, 0xb5, 0x15, 0xc9, 0x3d, 0x25, 0x7b,
211 0x0a, 0x26, 0x47, 0x2f, 0x6a, 0xac, 0x5f, 0x68, 0xad, 0x2a, 0x5d, 0x9f, 0x12, 0x4d, 0x83, 0x04,
212 0x32, 0x51, 0x01, 0x11, 0x17, 0x3e, 0x93, 0xc7, 0x2c, 0x82, 0xbd, 0x1c, 0x66, 0x9a, 0x12, 0x4b,
213 0x73, 0x02, 0x2c, 0x41, 0x01, 0x0c, 0x13, 0x37, 0x99, 0xd2, 0x18, 0x82, 0xc2, 0x03, 0x5d, 0x92,
214 0x01, 0x3d, 0x61, 0x01, 0x1f, 0x32, 0x01, 0x0a, 0x10, 0x31, 0xba, 0xdf, 0x11, 0x94, 0xcc, 0x01,
215 0x60, 0x8e, 0x01, 0x35, 0x53, 0x01, 0x1a, 0x2c, 0x01, 0x0b, 0x11, 0x0d, 0xd9, 0xd4, 0x02, 0x88,
216 0xb4, 0x01, 0x4e, 0x7c, 0x01, 0x32, 0x53, 0x01, 0x1d, 0x31, 0x01, 0x0e, 0x17, 0xc5, 0x0d, 0xf7,
217 0x52, 0x11, 0xde, 0x19, 0x11, 0xa2, 0x7e, 0xba, 0xf7, 0xea, 0xbf, 0xf3, 0xb0, 0xb1, 0xea, 0x68,
218 0x9e, 0xdc, 0x42, 0x80, 0xba, 0x37, 0x5a, 0x89, 0x6f, 0xc5, 0xf2, 0x2e, 0x9e, 0xdb, 0x09, 0x68,
219 0xab, 0x02, 0x41, 0x7d, 0x01, 0x2c, 0x50, 0x01, 0x11, 0x5b, 0x68, 0xd0, 0xf5, 0x27, 0xa8, 0xe0,
220 0x03, 0x6d, 0xa2, 0x01, 0x4f, 0x7c, 0x01, 0x32, 0x66, 0x01, 0x2b, 0x66, 0x54, 0xdc, 0xf6, 0x1f,
221 0xb1, 0xe7, 0x02, 0x73, 0xb4, 0x01, 0x4f, 0x86, 0x01, 0x37, 0x4d, 0x01, 0x3c, 0x4f, 0x2b, 0xf3,
222 0xf0, 0x08, 0xb4, 0xd9, 0x01, 0x73, 0xa6, 0x01, 0x54, 0x79, 0x01, 0x33, 0x43, 0x01, 0x10, 0x06,
223 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
224 0xc0, 0x80, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
225 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
226 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
227 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
228 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
229 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x9e, 0x61, 0x5e, 0x5d,
230 0x18, 0x63, 0x55, 0x77, 0x2c, 0x3e, 0x3b, 0x43, 0x95, 0x35, 0x35, 0x5e, 0x14, 0x30, 0x53, 0x35,
231 0x18, 0x34, 0x12, 0x12, 0x96, 0x28, 0x27, 0x4e, 0x0c, 0x1a, 0x43, 0x21, 0x0b, 0x18, 0x07, 0x05,
232 0xae, 0x23, 0x31, 0x44, 0x0b, 0x1b, 0x39, 0x0f, 0x09, 0x0c, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00,
233 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
234 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
235 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
236 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
237 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
238 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
239 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
240 0x90, 0x0b, 0x36, 0x9d, 0xc3, 0x82, 0x2e, 0x3a, 0x6c, 0x76, 0x0f, 0x7b, 0x94, 0x83, 0x65, 0x2c,
241 0x5d, 0x83, 0x71, 0x0c, 0x17, 0xbc, 0xe2, 0x8e, 0x1a, 0x20, 0x7d, 0x78, 0x0b, 0x32, 0x7b, 0xa3,
242 0x87, 0x40, 0x4d, 0x67, 0x71, 0x09, 0x24, 0x9b, 0x6f, 0x9d, 0x20, 0x2c, 0xa1, 0x74, 0x09, 0x37,
243 0xb0, 0x4c, 0x60, 0x25, 0x3d, 0x95, 0x73, 0x09, 0x1c, 0x8d, 0xa1, 0xa7, 0x15, 0x19, 0xc1, 0x78,
244 0x0c, 0x20, 0x91, 0xc3, 0x8e, 0x20, 0x26, 0x56, 0x74, 0x0c, 0x40, 0x78, 0x8c, 0x7d, 0x31, 0x73,
245 0x79, 0x66, 0x13, 0x42, 0xa2, 0xb6, 0x7a, 0x23, 0x3b, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
246 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
247 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
248 };
249
250 static const uint8_t vdenc_vp9_inter_default_probs[2048] = {
251 0x64, 0x42, 0x14, 0x98, 0x0f, 0x65, 0x03, 0x88, 0x25, 0x05, 0x34, 0x0d, 0x00, 0x00, 0x00, 0x00,
252 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
253 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
254 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
255 0xc3, 0x1d, 0xb7, 0x54, 0x31, 0x88, 0x08, 0x2a, 0x47, 0x1f, 0x6b, 0xa9, 0x23, 0x63, 0x9f, 0x11,
256 0x52, 0x8c, 0x08, 0x42, 0x72, 0x02, 0x2c, 0x4c, 0x01, 0x13, 0x20, 0x28, 0x84, 0xc9, 0x1d, 0x72,
257 0xbb, 0x0d, 0x5b, 0x9d, 0x07, 0x4b, 0x7f, 0x03, 0x3a, 0x5f, 0x01, 0x1c, 0x2f, 0x45, 0x8e, 0xdd,
258 0x2a, 0x7a, 0xc9, 0x0f, 0x5b, 0x9f, 0x06, 0x43, 0x79, 0x01, 0x2a, 0x4d, 0x01, 0x11, 0x1f, 0x66,
259 0x94, 0xe4, 0x43, 0x75, 0xcc, 0x11, 0x52, 0x9a, 0x06, 0x3b, 0x72, 0x02, 0x27, 0x4b, 0x01, 0x0f,
260 0x1d, 0x9c, 0x39, 0xe9, 0x77, 0x39, 0xd4, 0x3a, 0x30, 0xa3, 0x1d, 0x28, 0x7c, 0x0c, 0x1e, 0x51,
261 0x03, 0x0c, 0x1f, 0xbf, 0x6b, 0xe2, 0x7c, 0x75, 0xcc, 0x19, 0x63, 0x9b, 0x1d, 0x94, 0xd2, 0x25,
262 0x7e, 0xc2, 0x08, 0x5d, 0x9d, 0x02, 0x44, 0x76, 0x01, 0x27, 0x45, 0x01, 0x11, 0x21, 0x29, 0x97,
263 0xd5, 0x1b, 0x7b, 0xc1, 0x03, 0x52, 0x90, 0x01, 0x3a, 0x69, 0x01, 0x20, 0x3c, 0x01, 0x0d, 0x1a,
264 0x3b, 0x9f, 0xdc, 0x17, 0x7e, 0xc6, 0x04, 0x58, 0x97, 0x01, 0x42, 0x72, 0x01, 0x26, 0x47, 0x01,
265 0x12, 0x22, 0x72, 0x88, 0xe8, 0x33, 0x72, 0xcf, 0x0b, 0x53, 0x9b, 0x03, 0x38, 0x69, 0x01, 0x21,
266 0x41, 0x01, 0x11, 0x22, 0x95, 0x41, 0xea, 0x79, 0x39, 0xd7, 0x3d, 0x31, 0xa6, 0x1c, 0x24, 0x72,
267 0x0c, 0x19, 0x4c, 0x03, 0x10, 0x2a, 0xd6, 0x31, 0xdc, 0x84, 0x3f, 0xbc, 0x2a, 0x41, 0x89, 0x55,
268 0x89, 0xdd, 0x68, 0x83, 0xd8, 0x31, 0x6f, 0xc0, 0x15, 0x57, 0x9b, 0x02, 0x31, 0x57, 0x01, 0x10,
269 0x1c, 0x59, 0xa3, 0xe6, 0x5a, 0x89, 0xdc, 0x1d, 0x64, 0xb7, 0x0a, 0x46, 0x87, 0x02, 0x2a, 0x51,
270 0x01, 0x11, 0x21, 0x6c, 0xa7, 0xed, 0x37, 0x85, 0xde, 0x0f, 0x61, 0xb3, 0x04, 0x48, 0x87, 0x01,
271 0x2d, 0x55, 0x01, 0x13, 0x26, 0x7c, 0x92, 0xf0, 0x42, 0x7c, 0xe0, 0x11, 0x58, 0xaf, 0x04, 0x3a,
272 0x7a, 0x01, 0x24, 0x4b, 0x01, 0x12, 0x25, 0x8d, 0x4f, 0xf1, 0x7e, 0x46, 0xe3, 0x42, 0x3a, 0xb6,
273 0x1e, 0x2c, 0x88, 0x0c, 0x22, 0x60, 0x02, 0x14, 0x2f, 0xe5, 0x63, 0xf9, 0x8f, 0x6f, 0xeb, 0x2e,
274 0x6d, 0xc0, 0x52, 0x9e, 0xec, 0x5e, 0x92, 0xe0, 0x19, 0x75, 0xbf, 0x09, 0x57, 0x95, 0x03, 0x38,
275 0x63, 0x01, 0x21, 0x39, 0x53, 0xa7, 0xed, 0x44, 0x91, 0xde, 0x0a, 0x67, 0xb1, 0x02, 0x48, 0x83,
276 0x01, 0x29, 0x4f, 0x01, 0x14, 0x27, 0x63, 0xa7, 0xef, 0x2f, 0x8d, 0xe0, 0x0a, 0x68, 0xb2, 0x02,
277 0x49, 0x85, 0x01, 0x2c, 0x55, 0x01, 0x16, 0x2f, 0x7f, 0x91, 0xf3, 0x47, 0x81, 0xe4, 0x11, 0x5d,
278 0xb1, 0x03, 0x3d, 0x7c, 0x01, 0x29, 0x54, 0x01, 0x15, 0x34, 0x9d, 0x4e, 0xf4, 0x8c, 0x48, 0xe7,
279 0x45, 0x3a, 0xb8, 0x1f, 0x2c, 0x89, 0x0e, 0x26, 0x69, 0x08, 0x17, 0x3d, 0x7d, 0x22, 0xbb, 0x34,
280 0x29, 0x85, 0x06, 0x1f, 0x38, 0x25, 0x6d, 0x99, 0x33, 0x66, 0x93, 0x17, 0x57, 0x80, 0x08, 0x43,
281 0x65, 0x01, 0x29, 0x3f, 0x01, 0x13, 0x1d, 0x1f, 0x9a, 0xb9, 0x11, 0x7f, 0xaf, 0x06, 0x60, 0x91,
282 0x02, 0x49, 0x72, 0x01, 0x33, 0x52, 0x01, 0x1c, 0x2d, 0x17, 0xa3, 0xc8, 0x0a, 0x83, 0xb9, 0x02,
283 0x5d, 0x94, 0x01, 0x43, 0x6f, 0x01, 0x29, 0x45, 0x01, 0x0e, 0x18, 0x1d, 0xb0, 0xd9, 0x0c, 0x91,
284 0xc9, 0x03, 0x65, 0x9c, 0x01, 0x45, 0x6f, 0x01, 0x27, 0x3f, 0x01, 0x0e, 0x17, 0x39, 0xc0, 0xe9,
285 0x19, 0x9a, 0xd7, 0x06, 0x6d, 0xa7, 0x03, 0x4e, 0x76, 0x01, 0x30, 0x45, 0x01, 0x15, 0x1d, 0xca,
286 0x69, 0xf5, 0x6c, 0x6a, 0xd8, 0x12, 0x5a, 0x90, 0x21, 0xac, 0xdb, 0x40, 0x95, 0xce, 0x0e, 0x75,
287 0xb1, 0x05, 0x5a, 0x8d, 0x02, 0x3d, 0x5f, 0x01, 0x25, 0x39, 0x21, 0xb3, 0xdc, 0x0b, 0x8c, 0xc6,
288 0x01, 0x59, 0x94, 0x01, 0x3c, 0x68, 0x01, 0x21, 0x39, 0x01, 0x0c, 0x15, 0x1e, 0xb5, 0xdd, 0x08,
289 0x8d, 0xc6, 0x01, 0x57, 0x91, 0x01, 0x3a, 0x64, 0x01, 0x1f, 0x37, 0x01, 0x0c, 0x14, 0x20, 0xba,
290 0xe0, 0x07, 0x8e, 0xc6, 0x01, 0x56, 0x8f, 0x01, 0x3a, 0x64, 0x01, 0x1f, 0x37, 0x01, 0x0c, 0x16,
291 0x39, 0xc0, 0xe3, 0x14, 0x8f, 0xcc, 0x03, 0x60, 0x9a, 0x01, 0x44, 0x70, 0x01, 0x2a, 0x45, 0x01,
292 0x13, 0x20, 0xd4, 0x23, 0xd7, 0x71, 0x2f, 0xa9, 0x1d, 0x30, 0x69, 0x4a, 0x81, 0xcb, 0x6a, 0x78,
293 0xcb, 0x31, 0x6b, 0xb2, 0x13, 0x54, 0x90, 0x04, 0x32, 0x54, 0x01, 0x0f, 0x19, 0x47, 0xac, 0xd9,
294 0x2c, 0x8d, 0xd1, 0x0f, 0x66, 0xad, 0x06, 0x4c, 0x85, 0x02, 0x33, 0x59, 0x01, 0x18, 0x2a, 0x40,
295 0xb9, 0xe7, 0x1f, 0x94, 0xd8, 0x08, 0x67, 0xaf, 0x03, 0x4a, 0x83, 0x01, 0x2e, 0x51, 0x01, 0x12,
296 0x1e, 0x41, 0xc4, 0xeb, 0x19, 0x9d, 0xdd, 0x05, 0x69, 0xae, 0x01, 0x43, 0x78, 0x01, 0x26, 0x45,
297 0x01, 0x0f, 0x1e, 0x41, 0xcc, 0xee, 0x1e, 0x9c, 0xe0, 0x07, 0x6b, 0xb1, 0x02, 0x46, 0x7c, 0x01,
298 0x2a, 0x49, 0x01, 0x12, 0x22, 0xe1, 0x56, 0xfb, 0x90, 0x68, 0xeb, 0x2a, 0x63, 0xb5, 0x55, 0xaf,
299 0xef, 0x70, 0xa5, 0xe5, 0x1d, 0x88, 0xc8, 0x0c, 0x67, 0xa2, 0x06, 0x4d, 0x7b, 0x02, 0x35, 0x54,
300 0x4b, 0xb7, 0xef, 0x1e, 0x9b, 0xdd, 0x03, 0x6a, 0xab, 0x01, 0x4a, 0x80, 0x01, 0x2c, 0x4c, 0x01,
301 0x11, 0x1c, 0x49, 0xb9, 0xf0, 0x1b, 0x9f, 0xde, 0x02, 0x6b, 0xac, 0x01, 0x4b, 0x7f, 0x01, 0x2a,
302 0x49, 0x01, 0x11, 0x1d, 0x3e, 0xbe, 0xee, 0x15, 0x9f, 0xde, 0x02, 0x6b, 0xac, 0x01, 0x48, 0x7a,
303 0x01, 0x28, 0x47, 0x01, 0x12, 0x20, 0x3d, 0xc7, 0xf0, 0x1b, 0xa1, 0xe2, 0x04, 0x71, 0xb4, 0x01,
304 0x4c, 0x81, 0x01, 0x2e, 0x50, 0x01, 0x17, 0x29, 0x07, 0x1b, 0x99, 0x05, 0x1e, 0x5f, 0x01, 0x10,
305 0x1e, 0x32, 0x4b, 0x7f, 0x39, 0x4b, 0x7c, 0x1b, 0x43, 0x6c, 0x0a, 0x36, 0x56, 0x01, 0x21, 0x34,
306 0x01, 0x0c, 0x12, 0x2b, 0x7d, 0x97, 0x1a, 0x6c, 0x94, 0x07, 0x53, 0x7a, 0x02, 0x3b, 0x59, 0x01,
307 0x26, 0x3c, 0x01, 0x11, 0x1b, 0x17, 0x90, 0xa3, 0x0d, 0x70, 0x9a, 0x02, 0x4b, 0x75, 0x01, 0x32,
308 0x51, 0x01, 0x1f, 0x33, 0x01, 0x0e, 0x17, 0x12, 0xa2, 0xb9, 0x06, 0x7b, 0xab, 0x01, 0x4e, 0x7d,
309 0x01, 0x33, 0x56, 0x01, 0x1f, 0x36, 0x01, 0x0e, 0x17, 0x0f, 0xc7, 0xe3, 0x03, 0x96, 0xcc, 0x01,
310 0x5b, 0x92, 0x01, 0x37, 0x5f, 0x01, 0x1e, 0x35, 0x01, 0x0b, 0x14, 0x13, 0x37, 0xf0, 0x13, 0x3b,
311 0xc4, 0x03, 0x34, 0x69, 0x29, 0xa6, 0xcf, 0x68, 0x99, 0xc7, 0x1f, 0x7b, 0xb5, 0x0e, 0x65, 0x98,
312 0x05, 0x48, 0x6a, 0x01, 0x24, 0x34, 0x23, 0xb0, 0xd3, 0x0c, 0x83, 0xbe, 0x02, 0x58, 0x90, 0x01,
313 0x3c, 0x65, 0x01, 0x24, 0x3c, 0x01, 0x10, 0x1c, 0x1c, 0xb7, 0xd5, 0x08, 0x86, 0xbf, 0x01, 0x56,
314 0x8e, 0x01, 0x38, 0x60, 0x01, 0x1e, 0x35, 0x01, 0x0c, 0x14, 0x14, 0xbe, 0xd7, 0x04, 0x87, 0xc0,
315 0x01, 0x54, 0x8b, 0x01, 0x35, 0x5b, 0x01, 0x1c, 0x31, 0x01, 0x0b, 0x14, 0x0d, 0xc4, 0xd8, 0x02,
316 0x89, 0xc0, 0x01, 0x56, 0x8f, 0x01, 0x39, 0x63, 0x01, 0x20, 0x38, 0x01, 0x0d, 0x18, 0xd3, 0x1d,
317 0xd9, 0x60, 0x2f, 0x9c, 0x16, 0x2b, 0x57, 0x4e, 0x78, 0xc1, 0x6f, 0x74, 0xba, 0x2e, 0x66, 0xa4,
318 0x0f, 0x50, 0x80, 0x02, 0x31, 0x4c, 0x01, 0x12, 0x1c, 0x47, 0xa1, 0xcb, 0x2a, 0x84, 0xc0, 0x0a,
319 0x62, 0x96, 0x03, 0x45, 0x6d, 0x01, 0x2c, 0x46, 0x01, 0x12, 0x1d, 0x39, 0xba, 0xd3, 0x1e, 0x8c,
320 0xc4, 0x04, 0x5d, 0x92, 0x01, 0x3e, 0x66, 0x01, 0x26, 0x41, 0x01, 0x10, 0x1b, 0x2f, 0xc7, 0xd9,
321 0x0e, 0x91, 0xc4, 0x01, 0x58, 0x8e, 0x01, 0x39, 0x62, 0x01, 0x24, 0x3e, 0x01, 0x0f, 0x1a, 0x1a,
322 0xdb, 0xe5, 0x05, 0x9b, 0xcf, 0x01, 0x5e, 0x97, 0x01, 0x3c, 0x68, 0x01, 0x24, 0x3e, 0x01, 0x10,
323 0x1c, 0xe9, 0x1d, 0xf8, 0x92, 0x2f, 0xdc, 0x2b, 0x34, 0x8c, 0x64, 0xa3, 0xe8, 0xb3, 0xa1, 0xde,
324 0x3f, 0x8e, 0xcc, 0x25, 0x71, 0xae, 0x1a, 0x59, 0x89, 0x12, 0x44, 0x61, 0x55, 0xb5, 0xe6, 0x20,
325 0x92, 0xd1, 0x07, 0x64, 0xa4, 0x03, 0x47, 0x79, 0x01, 0x2d, 0x4d, 0x01, 0x12, 0x1e, 0x41, 0xbb,
326 0xe6, 0x14, 0x94, 0xcf, 0x02, 0x61, 0x9f, 0x01, 0x44, 0x74, 0x01, 0x28, 0x46, 0x01, 0x0e, 0x1d,
327 0x28, 0xc2, 0xe3, 0x08, 0x93, 0xcc, 0x01, 0x5e, 0x9b, 0x01, 0x41, 0x70, 0x01, 0x27, 0x42, 0x01,
328 0x0e, 0x1a, 0x10, 0xd0, 0xe4, 0x03, 0x97, 0xcf, 0x01, 0x62, 0xa0, 0x01, 0x43, 0x75, 0x01, 0x29,
329 0x4a, 0x01, 0x11, 0x1f, 0x11, 0x26, 0x8c, 0x07, 0x22, 0x50, 0x01, 0x11, 0x1d, 0x25, 0x4b, 0x80,
330 0x29, 0x4c, 0x80, 0x1a, 0x42, 0x74, 0x0c, 0x34, 0x5e, 0x02, 0x20, 0x37, 0x01, 0x0a, 0x10, 0x32,
331 0x7f, 0x9a, 0x25, 0x6d, 0x98, 0x10, 0x52, 0x79, 0x05, 0x3b, 0x55, 0x01, 0x23, 0x36, 0x01, 0x0d,
332 0x14, 0x28, 0x8e, 0xa7, 0x11, 0x6e, 0x9d, 0x02, 0x47, 0x70, 0x01, 0x2c, 0x48, 0x01, 0x1b, 0x2d,
333 0x01, 0x0b, 0x11, 0x1e, 0xaf, 0xbc, 0x09, 0x7c, 0xa9, 0x01, 0x4a, 0x74, 0x01, 0x30, 0x4e, 0x01,
334 0x1e, 0x31, 0x01, 0x0b, 0x12, 0x0a, 0xde, 0xdf, 0x02, 0x96, 0xc2, 0x01, 0x53, 0x80, 0x01, 0x30,
335 0x4f, 0x01, 0x1b, 0x2d, 0x01, 0x0b, 0x11, 0x24, 0x29, 0xeb, 0x1d, 0x24, 0xc1, 0x0a, 0x1b, 0x6f,
336 0x55, 0xa5, 0xde, 0xb1, 0xa2, 0xd7, 0x6e, 0x87, 0xc3, 0x39, 0x71, 0xa8, 0x17, 0x53, 0x78, 0x0a,
337 0x31, 0x3d, 0x55, 0xbe, 0xdf, 0x24, 0x8b, 0xc8, 0x05, 0x5a, 0x92, 0x01, 0x3c, 0x67, 0x01, 0x26,
338 0x41, 0x01, 0x12, 0x1e, 0x48, 0xca, 0xdf, 0x17, 0x8d, 0xc7, 0x02, 0x56, 0x8c, 0x01, 0x38, 0x61,
339 0x01, 0x24, 0x3d, 0x01, 0x10, 0x1b, 0x37, 0xda, 0xe1, 0x0d, 0x91, 0xc8, 0x01, 0x56, 0x8d, 0x01,
340 0x39, 0x63, 0x01, 0x23, 0x3d, 0x01, 0x0d, 0x16, 0x0f, 0xeb, 0xd4, 0x01, 0x84, 0xb8, 0x01, 0x54,
341 0x8b, 0x01, 0x39, 0x61, 0x01, 0x22, 0x38, 0x01, 0x0e, 0x17, 0xb5, 0x15, 0xc9, 0x3d, 0x25, 0x7b,
342 0x0a, 0x26, 0x47, 0x2f, 0x6a, 0xac, 0x5f, 0x68, 0xad, 0x2a, 0x5d, 0x9f, 0x12, 0x4d, 0x83, 0x04,
343 0x32, 0x51, 0x01, 0x11, 0x17, 0x3e, 0x93, 0xc7, 0x2c, 0x82, 0xbd, 0x1c, 0x66, 0x9a, 0x12, 0x4b,
344 0x73, 0x02, 0x2c, 0x41, 0x01, 0x0c, 0x13, 0x37, 0x99, 0xd2, 0x18, 0x82, 0xc2, 0x03, 0x5d, 0x92,
345 0x01, 0x3d, 0x61, 0x01, 0x1f, 0x32, 0x01, 0x0a, 0x10, 0x31, 0xba, 0xdf, 0x11, 0x94, 0xcc, 0x01,
346 0x60, 0x8e, 0x01, 0x35, 0x53, 0x01, 0x1a, 0x2c, 0x01, 0x0b, 0x11, 0x0d, 0xd9, 0xd4, 0x02, 0x88,
347 0xb4, 0x01, 0x4e, 0x7c, 0x01, 0x32, 0x53, 0x01, 0x1d, 0x31, 0x01, 0x0e, 0x17, 0xc5, 0x0d, 0xf7,
348 0x52, 0x11, 0xde, 0x19, 0x11, 0xa2, 0x7e, 0xba, 0xf7, 0xea, 0xbf, 0xf3, 0xb0, 0xb1, 0xea, 0x68,
349 0x9e, 0xdc, 0x42, 0x80, 0xba, 0x37, 0x5a, 0x89, 0x6f, 0xc5, 0xf2, 0x2e, 0x9e, 0xdb, 0x09, 0x68,
350 0xab, 0x02, 0x41, 0x7d, 0x01, 0x2c, 0x50, 0x01, 0x11, 0x5b, 0x68, 0xd0, 0xf5, 0x27, 0xa8, 0xe0,
351 0x03, 0x6d, 0xa2, 0x01, 0x4f, 0x7c, 0x01, 0x32, 0x66, 0x01, 0x2b, 0x66, 0x54, 0xdc, 0xf6, 0x1f,
352 0xb1, 0xe7, 0x02, 0x73, 0xb4, 0x01, 0x4f, 0x86, 0x01, 0x37, 0x4d, 0x01, 0x3c, 0x4f, 0x2b, 0xf3,
353 0xf0, 0x08, 0xb4, 0xd9, 0x01, 0x73, 0xa6, 0x01, 0x54, 0x79, 0x01, 0x33, 0x43, 0x01, 0x10, 0x06,
354 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
355 0xc0, 0x80, 0x40, 0x02, 0xad, 0x22, 0x07, 0x91, 0x55, 0x07, 0xa6, 0x3f, 0x07, 0x5e, 0x42, 0x08,
356 0x40, 0x2e, 0x11, 0x51, 0x1f, 0x19, 0x1d, 0x1e, 0xeb, 0xa2, 0x24, 0xff, 0x22, 0x03, 0x95, 0x90,
357 0x09, 0x66, 0xbb, 0xe1, 0xef, 0xb7, 0x77, 0x60, 0x29, 0x21, 0x10, 0x4d, 0x4a, 0x8e, 0x8e, 0xac,
358 0xaa, 0xee, 0xf7, 0x32, 0x7e, 0x7b, 0xdd, 0xe2, 0x41, 0x20, 0x12, 0x90, 0xa2, 0xc2, 0x29, 0x33,
359 0x62, 0x84, 0x44, 0x12, 0xa5, 0xd9, 0xc4, 0x2d, 0x28, 0x4e, 0xad, 0x50, 0x13, 0xb0, 0xf0, 0xc1,
360 0x40, 0x23, 0x2e, 0xdd, 0x87, 0x26, 0xc2, 0xf8, 0x79, 0x60, 0x55, 0x1d, 0xc7, 0x7a, 0x8d, 0x93,
361 0x3f, 0x9f, 0x94, 0x85, 0x76, 0x79, 0x68, 0x72, 0xae, 0x49, 0x57, 0x5c, 0x29, 0x53, 0x52, 0x63,
362 0x32, 0x35, 0x27, 0x27, 0xb1, 0x3a, 0x3b, 0x44, 0x1a, 0x3f, 0x34, 0x4f, 0x19, 0x11, 0x0e, 0x0c,
363 0xde, 0x22, 0x1e, 0x48, 0x10, 0x2c, 0x3a, 0x20, 0x0c, 0x0a, 0x07, 0x06, 0x20, 0x40, 0x60, 0x80,
364 0xe0, 0x90, 0xc0, 0xa8, 0xc0, 0xb0, 0xc0, 0xc6, 0xc6, 0xf5, 0xd8, 0x88, 0x8c, 0x94, 0xa0, 0xb0,
365 0xc0, 0xe0, 0xea, 0xea, 0xf0, 0x80, 0xd8, 0x80, 0xb0, 0xa0, 0xb0, 0xb0, 0xc0, 0xc6, 0xc6, 0xd0,
366 0xd0, 0x88, 0x8c, 0x94, 0xa0, 0xb0, 0xc0, 0xe0, 0xea, 0xea, 0xf0, 0x80, 0x80, 0x40, 0x60, 0x70,
367 0x40, 0x40, 0x60, 0x40, 0x80, 0x80, 0x40, 0x60, 0x70, 0x40, 0x40, 0x60, 0x40, 0xa0, 0x80, 0xa0,
368 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
369 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
370 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
371 0x78, 0x07, 0x4c, 0xb0, 0xd0, 0x7e, 0x1c, 0x36, 0x67, 0x30, 0x0c, 0x9a, 0x9b, 0x8b, 0x5a, 0x22,
372 0x75, 0x77, 0x43, 0x06, 0x19, 0xcc, 0xf3, 0x9e, 0x0d, 0x15, 0x60, 0x61, 0x05, 0x2c, 0x83, 0xb0,
373 0x8b, 0x30, 0x44, 0x61, 0x53, 0x05, 0x2a, 0x9c, 0x6f, 0x98, 0x1a, 0x31, 0x98, 0x50, 0x05, 0x3a,
374 0xb2, 0x4a, 0x53, 0x21, 0x3e, 0x91, 0x56, 0x05, 0x20, 0x9a, 0xc0, 0xa8, 0x0e, 0x16, 0xa3, 0x55,
375 0x05, 0x20, 0x9c, 0xd8, 0x94, 0x13, 0x1d, 0x49, 0x4d, 0x07, 0x40, 0x74, 0x84, 0x7a, 0x25, 0x7e,
376 0x78, 0x65, 0x15, 0x6b, 0xb5, 0xc0, 0x67, 0x13, 0x43, 0x7d, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
377 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
378 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
379 };
380
381 static const uint16_t
382 vdenc_vp9_quant_ac[256] = {
383 4, 8, 9, 10, 11, 12, 13, 14,
384 15, 16, 17, 18, 19, 20, 21, 22,
385 23, 24, 25, 26, 27, 28, 29, 30,
386 31, 32, 33, 34, 35, 36, 37, 38,
387 39, 40, 41, 42, 43, 44, 45, 46,
388 47, 48, 49, 50, 51, 52, 53, 54,
389 55, 56, 57, 58, 59, 60, 61, 62,
390 63, 64, 65, 66, 67, 68, 69, 70,
391 71, 72, 73, 74, 75, 76, 77, 78,
392 79, 80, 81, 82, 83, 84, 85, 86,
393 87, 88, 89, 90, 91, 92, 93, 94,
394 95, 96, 97, 98, 99, 100, 101, 102,
395 104, 106, 108, 110, 112, 114, 116, 118,
396 120, 122, 124, 126, 128, 130, 132, 134,
397 136, 138, 140, 142, 144, 146, 148, 150,
398 152, 155, 158, 161, 164, 167, 170, 173,
399 176, 179, 182, 185, 188, 191, 194, 197,
400 200, 203, 207, 211, 215, 219, 223, 227,
401 231, 235, 239, 243, 247, 251, 255, 260,
402 265, 270, 275, 280, 285, 290, 295, 300,
403 305, 311, 317, 323, 329, 335, 341, 347,
404 353, 359, 366, 373, 380, 387, 394, 401,
405 408, 416, 424, 432, 440, 448, 456, 465,
406 474, 483, 492, 501, 510, 520, 530, 540,
407 550, 560, 571, 582, 593, 604, 615, 627,
408 639, 651, 663, 676, 689, 702, 715, 729,
409 743, 757, 771, 786, 801, 816, 832, 848,
410 864, 881, 898, 915, 933, 951, 969, 988,
411 1007, 1026, 1046, 1066, 1087, 1108, 1129, 1151,
412 1173, 1196, 1219, 1243, 1267, 1292, 1317, 1343,
413 1369, 1396, 1423, 1451, 1479, 1508, 1537, 1567,
414 1597, 1628, 1660, 1692, 1725, 1759, 1793, 1828,
415 };
416
417 static const int8_t vdenc_vp9_huc_inst_rate_thresh_i[4] = {
418 30, 50, 90, 115,
419 };
420
421 static const int8_t vdenc_vp9_huc_inst_rate_thresh_p[4] = {
422 30, 50, 70, 120,
423 };
424
425 static const uint32_t vdenc_vp9_huc_brc_init_dmem_data[48] = {
426 0x00000000, 0x00038400, 0x00030d40, 0x000c3500, 0x00061a80, 0x00061a80, 0x00000000, 0x0000001e,
427 0x00000001, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x270f0020, 0x02800000, 0x00010168,
428 0x000000ff, 0x0000000e, 0x00000073, 0x00000000, 0x00000000, 0x7846321e, 0x7846321e, 0x735a321e,
429 0xe5dfd8d1, 0x2f29211b, 0xe5ddd7d1, 0x5e56463f, 0xeae3dad4, 0x2f281f16, 0x01007488, 0x00000000,
430 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
431 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000
432 };
433
434 static const uint32_t vdenc_vp9_huc_brc_update_dmem_data[64] = {
435 0x00061a80, 0x00000000, 0x0007a120, 0x000493e0, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
436 0x00000000, 0x00000000, 0x00000000, 0x0032000a, 0x00960064, 0x01680280, 0x02200000, 0x007802b8,
437 0x00000000, 0x00000000, 0x00000000, 0x02032000, 0xb4785028, 0x67614b28, 0x0101a07d, 0x28010203,
438 0x01030505, 0x00fefcfa, 0x04060402, 0x78503c1e, 0x00ffc88c, 0x503c1e04, 0xffc88c78, 0x28140200,
439 0xc8a08246, 0x090800ff, 0x040c0b0a, 0x07060605, 0x06060504, 0x00650007, 0x00000000, 0x00000000,
440 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
441 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
442 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000
443 };
444
445 static const uint32_t vdenc_vp9_huc_brc_constant_data[2][416] = {
446 {
447 0x32191900, 0x00264B4B, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x32191900, 0x00264B4B,
448 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x32191900, 0x00264B4B, 0x00000000, 0x00000000,
449 0x00000000, 0x00000000, 0x32191900, 0x00264B4B, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
450 0x32191900, 0x00264B4B, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x32191900, 0x00264B4B,
451 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x32191900, 0x00264B4B, 0x00000000, 0x00000000,
452 0x00000000, 0x00000000, 0x32191900, 0x00264B4B, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
453 0x32191900, 0x00264B4B, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x32191900, 0x00264B4B,
454 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x32191900, 0x00264B4B, 0x00000000, 0x00000000,
455 0x00000000, 0x00000000, 0x32191900, 0x00264B4B, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
456 0x32191900, 0x00264B4B, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x32191900, 0x00264B4B,
457 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x32191900, 0x00264B4B, 0x00000000, 0x00000000,
458 0x00000000, 0x00000000, 0x32191900, 0x00264B4B, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
459 0x32191900, 0x00264B4B, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x32191900, 0x00264B4B,
460 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x32191900, 0x00264B4B, 0x00000000, 0x00000000,
461 0x00000000, 0x00000000, 0x32191900, 0x00264B4B, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
462 0x32191900, 0x00264B4B, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x32191900, 0x00264B4B,
463 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x32191900, 0x00264B4B, 0x00000000, 0x00000000,
464 0x00000000, 0x00000000, 0x32191900, 0x00264B4B, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
465 0x32191900, 0x00264B4B, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x32191900, 0x00264B4B,
466 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x32191900, 0x00264B4B, 0x00000000, 0x00000000,
467 0x00000000, 0x00000000, 0x32191900, 0x00264B4B, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
468 0x32191900, 0x00264B4B, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x32191900, 0x00264B4B,
469 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x32191900, 0x00264B4B, 0x00000000, 0x00000000,
470 0x00000000, 0x00000000, 0x32191900, 0x00264B4B, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
471 0x32191900, 0x00264B4B, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x32191900, 0x00264B4B,
472 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x32191900, 0x00264B4B, 0x00000000, 0x00000000,
473 0x00000000, 0x00000000, 0x32191900, 0x00264B4B, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
474 0x32191900, 0x00264B4B, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x32191900, 0x00264B4B,
475 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x32191900, 0x00264B4B, 0x00000000, 0x00000000,
476 0x00000000, 0x00000000, 0x32191900, 0x00264B4B, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
477 0x32191900, 0x00264B4B, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x32191900, 0x00264B4B,
478 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x32191900, 0x00264B4B, 0x00000000, 0x00000000,
479 0x00000000, 0x00000000, 0x32191900, 0x00264B4B, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
480 0x32191900, 0x00264B4B, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x32191900, 0x00264B4B,
481 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x32191900, 0x00264B4B, 0x00000000, 0x00000000,
482 0x00000000, 0x00000000, 0x32191900, 0x00264B4B, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
483 0x32191900, 0x00264B4B, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x32191900, 0x00264B4B,
484 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x32191900, 0x00264B4B, 0x00000000, 0x00000000,
485 0x00000000, 0x00000000, 0x32191900, 0x00264B4B, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
486 0x0E0A0602, 0x06040212, 0x00000E0A, 0x00080402, 0x04020000, 0x000000FE, 0xFEFCFA02, 0xF8F60000,
487 0xF200FEFC, 0xFEFCF8F4, 0xFCF6F2EE, 0x0A0402FE, 0x04021410, 0x00100C08, 0x0C080402, 0x02000000,
488 0x0000FE04, 0xFEFC0200, 0xFA0000FE, 0x00FEFEFC, 0xFEFCFAF6, 0xF8F4F200, 0x0402FEFC, 0x0214100A,
489 0x100C0804, 0x08040200, 0x0000000C, 0x00FE0402, 0xFC020000, 0x0000FEFE, 0xFEFEFCFA, 0xFCFAF600,
490 0xF4F200FE, 0x00FEFCF8, 0x00000000, 0x14100C08, 0x00000000, 0x0E0A0600, 0x0000FE12, 0x08060000,
491 0xFEFC0E0C, 0x02000000, 0xFA0A0604, 0x0000FEFC, 0x0A060200, 0x00FEFCF8, 0x06020000, 0xFCFAF60A,
492 0x020000FE, 0xF8F40A06, 0x0000FEFC, 0xF40A0602, 0x00FEFCF8, 0x0A060200, 0x00000000, 0x0E0A0600,
493 0x00000012, 0x0A060000, 0x00FE100C, 0x06000000, 0xFC100E0A, 0x000000FE, 0x0C0A0804, 0x00FEFCFA,
494 0x08020000, 0xFEFCF80A, 0x02000000, 0xFCF80A08, 0x0000FEFE, 0xF80A0800, 0x00FEFCFA, 0x0A020000,
495 0xFEFCF8F6, 0x02000000, 0x00000008, 0x0A060000, 0x0000120E, 0x06000000, 0xFE100C0A, 0x00000000,
496 0x100E0A06, 0x0000FEFC, 0x0A080400, 0xFEFCFA0C, 0x02000000, 0xFCF80A08, 0x000000FE, 0xF80A0802,
497 0x00FEFEFC, 0x0A080000, 0xFEFCFAF8, 0x02000000, 0xFCF8F60A, 0x000000FE, 0x00000802, 0x00000000,
498 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000
499 },
500
501 {
502 0x13194B0D, 0x1F5E2626, 0x19321F4B, 0x1E1E1904, 0x0B0B001E, 0x0000000B, 0x13194B0D, 0x1F5E2626,
503 0x19321F4B, 0x1E1E1904, 0x0B0B001E, 0x0000000B, 0x13194B0D, 0x1F5E2626, 0x19321F4B, 0x1E1E1904,
504 0x0B0B001E, 0x0000000B, 0x13194B0D, 0x1F5E2626, 0x19321F4B, 0x1E1E1904, 0x0B0B001E, 0x0000000B,
505 0x13194B0D, 0x1F5E2626, 0x19321F4B, 0x1E1E1904, 0x0B0B001E, 0x0000000B, 0x13194B0D, 0x1F5E2626,
506 0x19321F4B, 0x1E1E1904, 0x0B0B001E, 0x0000000B, 0x13194B0D, 0x1F5E2626, 0x19321F4B, 0x1E1E1904,
507 0x0B0B001E, 0x0000000B, 0x13194B0D, 0x1F5E2626, 0x19321F4B, 0x1E1E1904, 0x0B0B001E, 0x0000000B,
508 0x13194B0D, 0x1F5E2626, 0x19321F4B, 0x1E1E1904, 0x0B0B001E, 0x0000000B, 0x13194B0D, 0x1F5E2626,
509 0x19321F4B, 0x1E1E1904, 0x0B0B001E, 0x0000000B, 0x13194B0D, 0x1F5E2626, 0x19321F4B, 0x1E1E1904,
510 0x0B0B001E, 0x0000000B, 0x13194B0D, 0x1F5E2626, 0x19321F4B, 0x1E1E1904, 0x0B0B001E, 0x0000000B,
511 0x13194B0D, 0x1F5E2626, 0x19321F4B, 0x1E1E1904, 0x0B0B001E, 0x0000000B, 0x13194B0D, 0x1F5E2626,
512 0x19321F4B, 0x1E1E1904, 0x0B0B001E, 0x0000000B, 0x13194B0D, 0x1F5E2626, 0x19321F4B, 0x1E1E1904,
513 0x0B0B001E, 0x0000000B, 0x13194B0D, 0x1F5E2626, 0x19321F4B, 0x1E1E1904, 0x0B0B001E, 0x0000000B,
514 0x13194B0D, 0x1F5E2626, 0x19321F4B, 0x1E1E1904, 0x0B0B001E, 0x0000000B, 0x13194B0D, 0x1F5E2626,
515 0x19321F4B, 0x1E1E1904, 0x0B0B001E, 0x0000000B, 0x13194B0D, 0x1F5E2626, 0x19321F4B, 0x1E1E1904,
516 0x0B0B001E, 0x0000000B, 0x13194B0D, 0x1F5E2626, 0x19321F4B, 0x1E1E1904, 0x0B0B001E, 0x0000000B,
517 0x13194B0D, 0x1F5E2626, 0x19321F4B, 0x1E1E1904, 0x0B0B001E, 0x0000000B, 0x13194B0D, 0x1F5E2626,
518 0x19321F4B, 0x1E1E1904, 0x0B0B001E, 0x0000000B, 0x13194B0D, 0x1F5E2626, 0x19321F4B, 0x1E1E1904,
519 0x0B0B001E, 0x0000000B, 0x13194B0D, 0x1F5E2626, 0x19321F4B, 0x1E1E1904, 0x0B0B001E, 0x0000000B,
520 0x13194B0D, 0x1F5E2626, 0x19321F4B, 0x1E1E1904, 0x0B0B001E, 0x0000000B, 0x13194B0D, 0x1F5E2626,
521 0x19321F4B, 0x1E1E1904, 0x0B0B001E, 0x0000000B, 0x13194B0D, 0x1F5E2626, 0x19321F4B, 0x1E1E1904,
522 0x0B0B001E, 0x0000000B, 0x13194B0D, 0x1F5E2626, 0x19321F4B, 0x1E1E1904, 0x0B0B001E, 0x0000000B,
523 0x13194B0D, 0x1F5E2626, 0x19321F4B, 0x1E1E1904, 0x0B0B001E, 0x0000000B, 0x13194B0D, 0x1F5E2626,
524 0x19321F4B, 0x1E1E1904, 0x0B0B001E, 0x0000000B, 0x13194B0D, 0x1F5E2626, 0x19321F4B, 0x1E1E1904,
525 0x0B0B001E, 0x0000000B, 0x13194B0D, 0x1F5E2626, 0x19321F4B, 0x1E1E1904, 0x0B0B001E, 0x0000000B,
526 0x13194B0D, 0x1F5E2626, 0x19321F4B, 0x1E1E1904, 0x0B0B001E, 0x0000000B, 0x13194B0D, 0x1F5E2626,
527 0x19321F4B, 0x1E1E1904, 0x0B0B001E, 0x0000000B, 0x13194B0D, 0x1F5E2626, 0x19321F4B, 0x1E1E1904,
528 0x0B0B001E, 0x0000000B, 0x13194B0D, 0x1F5E2626, 0x19321F4B, 0x1E1E1904, 0x0B0B001E, 0x0000000B,
529 0x13194B0D, 0x1F5E2626, 0x19321F4B, 0x1E1E1904, 0x0B0B001E, 0x0000000B, 0x13194B0D, 0x1F5E2626,
530 0x19321F4B, 0x1E1E1904, 0x0B0B001E, 0x0000000B, 0x13194B0D, 0x1F5E2626, 0x19321F4B, 0x1E1E1904,
531 0x0B0B001E, 0x0000000B, 0x13194B0D, 0x1F5E2626, 0x19321F4B, 0x1E1E1904, 0x0B0B001E, 0x0000000B,
532 0x13194B0D, 0x1F5E2626, 0x19321F4B, 0x1E1E1904, 0x0B0B001E, 0x0000000B, 0x13194B0D, 0x1F5E2626,
533 0x19321F4B, 0x1E1E1904, 0x0B0B001E, 0x0000000B, 0x13194B0D, 0x1F5E2626, 0x19321F4B, 0x1E1E1904,
534 0x0B0B001E, 0x0000000B, 0x13194B0D, 0x1F5E2626, 0x19321F4B, 0x1E1E1904, 0x0B0B001E, 0x0000000B,
535 0x13194B0D, 0x1F5E2626, 0x19321F4B, 0x1E1E1904, 0x0B0B001E, 0x0000000B, 0x13194B0D, 0x1F5E2626,
536 0x19321F4B, 0x1E1E1904, 0x0B0B001E, 0x0000000B, 0x13194B0D, 0x1F5E2626, 0x19321F4B, 0x1E1E1904,
537 0x0B0B001E, 0x0000000B, 0x13194B0D, 0x1F5E2626, 0x19321F4B, 0x1E1E1904, 0x0B0B001E, 0x0000000B,
538 0x13194B0D, 0x1F5E2626, 0x19321F4B, 0x1E1E1904, 0x0B0B001E, 0x0000000B, 0x13194B0D, 0x1F5E2626,
539 0x19321F4B, 0x1E1E1904, 0x0B0B001E, 0x0000000B, 0x13194B0D, 0x1F5E2626, 0x19321F4B, 0x1E1E1904,
540 0x0B0B001E, 0x0000000B, 0x13194B0D, 0x1F5E2626, 0x19321F4B, 0x1E1E1904, 0x0B0B001E, 0x0000000B,
541 0x0E0A0602, 0x06040212, 0x00000E0A, 0x00080402, 0x04020000, 0x000000FE, 0xFEFCFA02, 0xF8F60000,
542 0xF200FEFC, 0xFEFCF8F4, 0xFCF6F2EE, 0x0A0402FE, 0x04021410, 0x00100C08, 0x0C080402, 0x02000000,
543 0x0000FE04, 0xFEFC0200, 0xFA0000FE, 0x00FEFEFC, 0xFEFCFAF6, 0xF8F4F200, 0x0402FEFC, 0x0214100A,
544 0x100C0804, 0x08040200, 0x0000000C, 0x00FE0402, 0xFC020000, 0x0000FEFE, 0xFEFEFCFA, 0xFCFAF600,
545 0xF4F200FE, 0x00FEFCF8, 0x00000000, 0x14100C08, 0x00000000, 0x0E0A0600, 0x0000FE12, 0x08060000,
546 0xFEFC0E0C, 0x02000000, 0xFA0A0604, 0x0000FEFC, 0x0A060200, 0x00FEFCF8, 0x06020000, 0xFCFAF60A,
547 0x020000FE, 0xF8F40A06, 0x0000FEFC, 0xF40A0602, 0x00FEFCF8, 0x0A060200, 0x00000000, 0x0E0A0600,
548 0x00000012, 0x0A060000, 0x00FE100C, 0x06000000, 0xFC100E0A, 0x000000FE, 0x0C0A0804, 0x00FEFCFA,
549 0x08020000, 0xFEFCF80A, 0x02000000, 0xFCF80A08, 0x0000FEFE, 0xF80A0800, 0x00FEFCFA, 0x0A020000,
550 0xFEFCF8F6, 0x02000000, 0x00000008, 0x0A060000, 0x0000120E, 0x06000000, 0xFE100C0A, 0x00000000,
551 0x100E0A06, 0x0000FEFC, 0x0A080400, 0xFEFCFA0C, 0x02000000, 0xFCF80A08, 0x000000FE, 0xF80A0802,
552 0x00FEFEFC, 0x0A080000, 0xFEFCFAF8, 0x02000000, 0xFCF8F60A, 0x000000FE, 0x00000802, 0x00000000,
553 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000
554 }
555 };
556
557 static const double
558 vdenc_brc_dev_threshi0_fp_neg[4] = { 0.80, 0.60, 0.34, 0.2 };
559
560 static const double
561 vdenc_brc_dev_threshi0_fp_pos[4] = { 0.2, 0.4, 0.66, 0.9 };
562
563 static const double
564 vdenc_brc_dev_threshpb0_fp_neg[4] = { 0.90, 0.66, 0.46, 0.3 };
565
566 static const double
567 vdenc_brc_dev_threshpb0_fp_pos[4] = { 0.3, 0.46, 0.70, 0.90 };
568
569 static const double
570 vdenc_brc_dev_threshvbr0_neg[4] = { 0.90, 0.70, 0.50, 0.3 };
571
572 static const double
573 vdenc_brc_dev_threshvbr0_pos[4] = { 0.4, 0.5, 0.75, 0.90 };
574
575 #define OUT_BUFFER_2DW(batch, bo, is_target, delta) do { \
576 if (bo) { \
577 OUT_BCS_RELOC64(batch, \
578 bo, \
579 I915_GEM_DOMAIN_RENDER, \
580 is_target ? I915_GEM_DOMAIN_RENDER : 0, \
581 delta); \
582 } else { \
583 OUT_BCS_BATCH(batch, 0); \
584 OUT_BCS_BATCH(batch, 0); \
585 } \
586 } while (0)
587
588 #define OUT_BUFFER_3DW(batch, bo, is_target, delta, attr) do { \
589 OUT_BUFFER_2DW(batch, bo, is_target, delta); \
590 OUT_BCS_BATCH(batch, i965->intel.mocs_state); \
591 } while (0)
592
593 #define ALLOC_VDENC_BUFFER_RESOURCE(buffer, bfsize, des) do { \
594 buffer.type = I965_GPE_RESOURCE_BUFFER; \
595 buffer.width = bfsize; \
596 buffer.height = 1; \
597 buffer.pitch = buffer.width; \
598 buffer.size = buffer.pitch; \
599 buffer.tiling = I915_TILING_NONE; \
600 i965_allocate_gpe_resource(i965->intel.bufmgr, \
601 &buffer, \
602 bfsize, \
603 (des)); \
604 } while (0)
605
606 #define MAX_URB_SIZE 4096 /* In register */
607
608 extern const unsigned int gen9_vp9_avs_coeffs[256];
609
610 static void
611 gen10_vdenc_vp9_init_media_object_walker_parameter(struct intel_encoder_context *encoder_context,
612 struct gpe_encoder_kernel_walker_parameter *kernel_walker_param,
613 struct gpe_media_object_walker_parameter *walker_param)
614 {
615 memset(walker_param, 0, sizeof(*walker_param));
616
617 walker_param->use_scoreboard = kernel_walker_param->use_scoreboard;
618
619 walker_param->block_resolution.x = kernel_walker_param->resolution_x;
620 walker_param->block_resolution.y = kernel_walker_param->resolution_y;
621
622 walker_param->global_resolution.x = kernel_walker_param->resolution_x;
623 walker_param->global_resolution.y = kernel_walker_param->resolution_y;
624
625 walker_param->global_outer_loop_stride.x = kernel_walker_param->resolution_x;
626 walker_param->global_outer_loop_stride.y = 0;
627
628 walker_param->global_inner_loop_unit.x = 0;
629 walker_param->global_inner_loop_unit.y = kernel_walker_param->resolution_y;
630
631 walker_param->local_loop_exec_count = 0xFFFF; //MAX VALUE
632 walker_param->global_loop_exec_count = 0xFFFF; //MAX VALUE
633
634 if (kernel_walker_param->no_dependency) {
635 walker_param->scoreboard_mask = 0;
636 walker_param->use_scoreboard = 0;
637 // Raster scan walking pattern
638 walker_param->local_outer_loop_stride.x = 0;
639 walker_param->local_outer_loop_stride.y = 1;
640 walker_param->local_inner_loop_unit.x = 1;
641 walker_param->local_inner_loop_unit.y = 0;
642 walker_param->local_end.x = kernel_walker_param->resolution_x - 1;
643 walker_param->local_end.y = 0;
644 } else {
645 walker_param->local_end.x = 0;
646 walker_param->local_end.y = 0;
647
648 if (kernel_walker_param->walker_degree == VP9_45Z_DEGREE) {
649 // 45z degree
650 walker_param->scoreboard_mask = 0x0F;
651
652 walker_param->global_loop_exec_count = 0x3FF;
653 walker_param->local_loop_exec_count = 0x3FF;
654
655 walker_param->global_resolution.x = (unsigned int)(kernel_walker_param->resolution_x / 2.f) + 1;
656 walker_param->global_resolution.y = 2 * kernel_walker_param->resolution_y;
657
658 walker_param->global_start.x = 0;
659 walker_param->global_start.y = 0;
660
661 walker_param->global_outer_loop_stride.x = walker_param->global_resolution.x;
662 walker_param->global_outer_loop_stride.y = 0;
663
664 walker_param->global_inner_loop_unit.x = 0;
665 walker_param->global_inner_loop_unit.y = walker_param->global_resolution.y;
666
667 walker_param->block_resolution.x = walker_param->global_resolution.x;
668 walker_param->block_resolution.y = walker_param->global_resolution.y;
669
670 walker_param->local_start.x = 0;
671 walker_param->local_start.y = 0;
672
673 walker_param->local_outer_loop_stride.x = 1;
674 walker_param->local_outer_loop_stride.y = 0;
675
676 walker_param->local_inner_loop_unit.x = -1;
677 walker_param->local_inner_loop_unit.y = 4;
678
679 walker_param->middle_loop_extra_steps = 3;
680 walker_param->mid_loop_unit_x = 0;
681 walker_param->mid_loop_unit_y = 1;
682 } else {
683 // 26 degree
684 walker_param->scoreboard_mask = 0x0F;
685 walker_param->local_outer_loop_stride.x = 1;
686 walker_param->local_outer_loop_stride.y = 0;
687 walker_param->local_inner_loop_unit.x = -2;
688 walker_param->local_inner_loop_unit.y = 1;
689 }
690 }
691 }
692
693 static void
694 gen10_vdenc_vp9_run_media_object_walker(VADriverContextP ctx,
695 struct intel_encoder_context *encoder_context,
696 struct i965_gpe_context *gpe_context,
697 struct gpe_media_object_walker_parameter *param)
698 {
699 struct intel_batchbuffer *batch = encoder_context->base.batch;
700 struct gen10_vdenc_vp9_context *vdenc_context = encoder_context->mfc_context;
701 struct i965_gpe_table *gpe = vdenc_context->gpe_table;
702
703 intel_batchbuffer_start_atomic(batch, 0x1000);
704
705 intel_batchbuffer_emit_mi_flush(batch);
706 gpe->pipeline_setup(ctx, gpe_context, batch);
707 gpe->media_object_walker(ctx, gpe_context, batch, param);
708 gpe->media_state_flush(ctx, gpe_context, batch);
709 gpe->pipeline_end(ctx, gpe_context, batch);
710
711 intel_batchbuffer_end_atomic(batch);
712
713 intel_batchbuffer_flush(batch);
714 }
715
716 static void
717 gen10_vdenc_vp9_gpe_context_vfe_scoreboard_init(struct i965_gpe_context *gpe_context, struct gen10_vdenc_vp9_kernel_scoreboard_parameters *scoreboard_params)
718 {
719 gpe_context->vfe_desc5.scoreboard0.mask = scoreboard_params->mask;
720 gpe_context->vfe_desc5.scoreboard0.type = scoreboard_params->type;
721 gpe_context->vfe_desc5.scoreboard0.enable = scoreboard_params->enable;
722
723 if (scoreboard_params->walk_pattern_flag) {
724 gpe_context->vfe_desc5.scoreboard0.mask = 0x0F;
725 gpe_context->vfe_desc5.scoreboard0.type = 1;
726
727 gpe_context->vfe_desc6.scoreboard1.delta_x0 = 0;
728 gpe_context->vfe_desc6.scoreboard1.delta_y0 = -1;
729
730 gpe_context->vfe_desc6.scoreboard1.delta_x1 = 0;
731 gpe_context->vfe_desc6.scoreboard1.delta_y1 = -2;
732
733 gpe_context->vfe_desc6.scoreboard1.delta_x2 = -1;
734 gpe_context->vfe_desc6.scoreboard1.delta_y2 = 3;
735
736 gpe_context->vfe_desc6.scoreboard1.delta_x3 = -1;
737 gpe_context->vfe_desc6.scoreboard1.delta_y3 = 1;
738 } else {
739 // Scoreboard 0
740 gpe_context->vfe_desc6.scoreboard1.delta_x0 = -1;
741 gpe_context->vfe_desc6.scoreboard1.delta_y0 = 0;
742
743 // Scoreboard 1
744 gpe_context->vfe_desc6.scoreboard1.delta_x1 = 0;
745 gpe_context->vfe_desc6.scoreboard1.delta_y1 = -1;
746
747 // Scoreboard 2
748 gpe_context->vfe_desc6.scoreboard1.delta_x2 = 1;
749 gpe_context->vfe_desc6.scoreboard1.delta_y2 = -1;
750
751 // Scoreboard 3
752 gpe_context->vfe_desc6.scoreboard1.delta_x3 = -1;
753 gpe_context->vfe_desc6.scoreboard1.delta_y3 = -1;
754
755 // Scoreboard 4
756 gpe_context->vfe_desc7.scoreboard2.delta_x4 = -1;
757 gpe_context->vfe_desc7.scoreboard2.delta_y4 = 1;
758
759 // Scoreboard 5
760 gpe_context->vfe_desc7.scoreboard2.delta_x5 = 0;
761 gpe_context->vfe_desc7.scoreboard2.delta_y5 = -2;
762
763 // Scoreboard 6
764 gpe_context->vfe_desc7.scoreboard2.delta_x6 = 1;
765 gpe_context->vfe_desc7.scoreboard2.delta_y6 = -2;
766
767 // Scoreboard 7
768 gpe_context->vfe_desc7.scoreboard2.delta_x6 = -1;
769 gpe_context->vfe_desc7.scoreboard2.delta_y6 = -2;
770 }
771 }
772
773 static void
774 gen10_vdenc_vp9_gpe_context_init_once(VADriverContextP ctx,
775 struct i965_gpe_context *gpe_context,
776 struct gen10_vdenc_vp9_kernel_parameters *kernel_params)
777 {
778 struct i965_driver_data *i965 = i965_driver_data(ctx);
779
780 gpe_context->curbe.length = kernel_params->curbe_size; // in bytes
781
782 gpe_context->sampler.entry_size = 0;
783 gpe_context->sampler.max_entries = 0;
784
785 if (kernel_params->sampler_size) {
786 gpe_context->sampler.entry_size = ALIGN(kernel_params->sampler_size, 64);
787 gpe_context->sampler.max_entries = 1;
788 }
789
790 gpe_context->idrt.entry_size = ALIGN(sizeof(struct gen8_interface_descriptor_data), 64);
791 gpe_context->idrt.max_entries = NUM_KERNELS_PER_GPE_CONTEXT;
792
793 gpe_context->surface_state_binding_table.max_entries = MAX_VP9_VDENC_SURFACES;
794 gpe_context->surface_state_binding_table.binding_table_offset = 0;
795 gpe_context->surface_state_binding_table.surface_state_offset = gpe_context->surface_state_binding_table.binding_table_offset + ALIGN(MAX_VP9_VDENC_SURFACES * sizeof(unsigned int), 64);
796 gpe_context->surface_state_binding_table.length = ALIGN(MAX_VP9_VDENC_SURFACES * sizeof(unsigned int), 64) + ALIGN(MAX_VP9_VDENC_SURFACES * SURFACE_STATE_PADDED_SIZE_GEN9, 64);
797
798 if (i965->intel.eu_total > 0)
799 gpe_context->vfe_state.max_num_threads = 6 * i965->intel.eu_total;
800 else
801 gpe_context->vfe_state.max_num_threads = 112;
802
803 gpe_context->vfe_state.curbe_allocation_size = ALIGN(gpe_context->curbe.length, 32) >> 5; // in registers
804 gpe_context->vfe_state.urb_entry_size = MAX(1, (ALIGN(kernel_params->inline_data_size, 32) +
805 ALIGN(kernel_params->external_data_size, 32)) >> 5); // in registers
806 gpe_context->vfe_state.num_urb_entries = (MAX_URB_SIZE -
807 gpe_context->vfe_state.curbe_allocation_size -
808 ((gpe_context->idrt.entry_size >> 5) *
809 gpe_context->idrt.max_entries)) / gpe_context->vfe_state.urb_entry_size;
810 gpe_context->vfe_state.num_urb_entries = CLAMP(gpe_context->vfe_state.num_urb_entries, 1, 64);
811 gpe_context->vfe_state.gpgpu_mode = 0;
812 }
813
814 static void
815 gen10_vdenc_vp9_dys_set_sampler_state(struct i965_gpe_context *gpe_context)
816 {
817 struct gen9_sampler_8x8_avs *sampler_cmd;
818
819 if (!gpe_context)
820 return;
821
822 dri_bo_map(gpe_context->sampler.bo, 1);
823
824 if (!gpe_context->sampler.bo->virtual)
825 return;
826
827 sampler_cmd = (struct gen9_sampler_8x8_avs *)(gpe_context->sampler.bo->virtual + gpe_context->sampler.offset);
828 memset(sampler_cmd, 0, sizeof(struct gen9_sampler_8x8_avs));
829
830 sampler_cmd->dw0.r3c_coefficient = 15;
831 sampler_cmd->dw0.r3x_coefficient = 6;
832 sampler_cmd->dw0.strong_edge_threshold = 8;
833 sampler_cmd->dw0.weak_edge_threshold = 1;
834 sampler_cmd->dw0.gain_factor = 32;
835
836 sampler_cmd->dw2.r5c_coefficient = 3;
837 sampler_cmd->dw2.r5cx_coefficient = 8;
838 sampler_cmd->dw2.r5x_coefficient = 9;
839 sampler_cmd->dw2.strong_edge_weight = 6;
840 sampler_cmd->dw2.regular_weight = 3;
841 sampler_cmd->dw2.non_edge_weight = 2;
842 sampler_cmd->dw2.global_noise_estimation = 255;
843
844 sampler_cmd->dw3.enable_8tap_adaptive_filter = 0;
845 sampler_cmd->dw3.cos_alpha = 79;
846 sampler_cmd->dw3.sin_alpha = 101;
847
848 sampler_cmd->dw5.diamond_du = 0;
849 sampler_cmd->dw5.hs_margin = 3;
850 sampler_cmd->dw5.diamond_alpha = 100;
851
852 sampler_cmd->dw7.inv_margin_vyl = 3300;
853
854 sampler_cmd->dw8.inv_margin_vyu = 1600;
855
856 sampler_cmd->dw10.y_slope2 = 24;
857 sampler_cmd->dw10.s0l = 1792;
858
859 sampler_cmd->dw12.y_slope1 = 24;
860
861 sampler_cmd->dw14.s0u = 256;
862
863 sampler_cmd->dw15.s2u = 1792;
864 sampler_cmd->dw15.s1u = 0;
865
866 memcpy(sampler_cmd->coefficients, &gen9_vp9_avs_coeffs[0], 17 * sizeof(struct gen8_sampler_8x8_avs_coefficients));
867
868 sampler_cmd->dw152.default_sharpness_level = 255;
869 sampler_cmd->dw152.max_derivative_4_pixels = 7;
870 sampler_cmd->dw152.max_derivative_8_pixels = 20;
871 sampler_cmd->dw152.transition_area_with_4_pixels = 4;
872 sampler_cmd->dw152.transition_area_with_8_pixels = 5;
873
874 sampler_cmd->dw153.bypass_x_adaptive_filtering = 1;
875 sampler_cmd->dw153.bypass_y_adaptive_filtering = 1;
876 sampler_cmd->dw153.adaptive_filter_for_all_channel = 0;
877
878 memcpy(sampler_cmd->extra_coefficients, &gen9_vp9_avs_coeffs[17 * 8], 15 * sizeof(struct gen8_sampler_8x8_avs_coefficients));
879
880 dri_bo_unmap(gpe_context->sampler.bo);
881 }
882
883 static void
884 gen10_vdenc_vp9_dys_context_init(VADriverContextP ctx, struct gen10_vdenc_vp9_context *vdenc_context)
885 {
886 struct i965_gpe_table *gpe = vdenc_context->gpe_table;
887 struct i965_gpe_context *gpe_context = NULL;
888 struct gen10_vdenc_vp9_kernel_parameters kernel_params;
889 struct gen10_vdenc_vp9_kernel_scoreboard_parameters scoreboard_params;
890
891 kernel_params.curbe_size = sizeof(struct gen10_vdenc_vp9_dys_curbe_data);
892 kernel_params.inline_data_size = 0;
893 kernel_params.external_data_size = 0;
894 kernel_params.sampler_size = sizeof(struct gen9_sampler_8x8_avs);
895
896 memset(&scoreboard_params, 0, sizeof(scoreboard_params));
897 scoreboard_params.mask = 0xFF;
898 scoreboard_params.enable = vdenc_context->use_hw_scoreboard;
899 scoreboard_params.type = vdenc_context->use_hw_non_stalling_scoreborad;
900 scoreboard_params.walk_pattern_flag = 0;
901
902 gpe_context = &vdenc_context->dys_context.gpe_context;
903 gen10_vdenc_vp9_gpe_context_init_once(ctx, gpe_context, &kernel_params);
904 gen10_vdenc_vp9_gpe_context_vfe_scoreboard_init(gpe_context, &scoreboard_params);
905 gpe->load_kernels(ctx,
906 gpe_context,
907 &vdenc_vp9_kernels_dys[0],
908 1);
909 }
910
911 static void
912 gen10_vdenc_vp9_streamin_context_init(VADriverContextP ctx, struct gen10_vdenc_vp9_context *vdenc_context)
913 {
914 struct i965_gpe_table *gpe = vdenc_context->gpe_table;
915 struct i965_gpe_context *gpe_context = NULL;
916 struct gen10_vdenc_vp9_kernel_parameters kernel_params;
917 struct gen10_vdenc_vp9_kernel_scoreboard_parameters scoreboard_params;
918
919 kernel_params.curbe_size = sizeof(struct gen10_vdenc_vp9_streamin_curbe_data);
920 kernel_params.inline_data_size = 0;
921 kernel_params.external_data_size = 0;
922 kernel_params.sampler_size = 0;
923
924 memset(&scoreboard_params, 0, sizeof(scoreboard_params));
925 scoreboard_params.mask = 0xFF;
926 scoreboard_params.enable = vdenc_context->use_hw_scoreboard;
927 scoreboard_params.type = vdenc_context->use_hw_non_stalling_scoreborad;
928 scoreboard_params.walk_pattern_flag = 0;
929
930 gpe_context = &vdenc_context->streamin_context.gpe_context;
931 gen10_vdenc_vp9_gpe_context_init_once(ctx, gpe_context, &kernel_params);
932 gen10_vdenc_vp9_gpe_context_vfe_scoreboard_init(gpe_context, &scoreboard_params);
933 gpe->load_kernels(ctx,
934 gpe_context,
935 &vdenc_vp9_kernels_streamin[0],
936 1);
937 }
938
939 static Bool
940 gen10_vdenc_vp9_gpe_context_init(VADriverContextP ctx,
941 struct intel_encoder_context *encoder_context,
942 struct gen10_vdenc_vp9_context *vdenc_context)
943 {
944 gen10_vdenc_vp9_dys_context_init(ctx, vdenc_context);
945 gen10_vdenc_vp9_streamin_context_init(ctx, vdenc_context);
946
947 return True;
948 }
949
950 static void
951 gen10_vdenc_vp9_kernel_context_destroy(struct gen10_vdenc_vp9_context *vdenc_context)
952 {
953 struct i965_gpe_table *gpe = vdenc_context->gpe_table;
954
955 gpe->context_destroy(&vdenc_context->dys_context.gpe_context);
956 gpe->context_destroy(&vdenc_context->streamin_context.gpe_context);
957 }
958
959 static VAStatus
960 gen10_vdenc_vp9_gpe_kernel_init(VADriverContextP ctx,
961 struct encode_state *encode_state,
962 struct intel_encoder_context *encoder_context)
963 {
964 struct gen10_vdenc_vp9_context *vdenc_context = encoder_context->mfc_context;
965 struct gen10_vdenc_vp9_dys_context *dys_context = &vdenc_context->dys_context;
966 struct gen10_vdenc_vp9_streamin_context *streamin_context = &vdenc_context->streamin_context;
967 struct i965_gpe_table *gpe = vdenc_context->gpe_table;
968
969 /* DYS */
970 gpe->context_init(ctx, &dys_context->gpe_context);
971 gen10_vdenc_vp9_dys_set_sampler_state(&dys_context->gpe_context);
972
973 gpe->context_init(ctx, &streamin_context->gpe_context);
974
975 return VA_STATUS_SUCCESS;
976 }
977
978 static void
979 gen10_vdenc_vp9_dys_set_curbe_data(VADriverContextP ctx,
980 struct encode_state *encode_state,
981 struct i965_gpe_context *gpe_context,
982 struct intel_encoder_context *encoder_context,
983 struct gen10_vdenc_vp9_dys_curbe_parameters *curbe_param)
984 {
985 struct gen10_vdenc_vp9_dys_curbe_data *curbe_cmd;
986
987 curbe_cmd = i965_gpe_context_map_curbe(gpe_context);
988
989 if (!curbe_cmd)
990 return;
991
992 memset(curbe_cmd, 0, sizeof(*curbe_cmd));
993
994 curbe_cmd->dw0.input_frame_width = curbe_param->input_width;
995 curbe_cmd->dw0.input_frame_height = curbe_param->input_height;
996
997 curbe_cmd->dw1.output_frame_width = curbe_param->output_width;
998 curbe_cmd->dw1.output_frame_height = curbe_param->output_height;
999
1000 curbe_cmd->dw2.delta_u = 1.0f / curbe_param->output_width;
1001 curbe_cmd->dw3.delta_v = 1.0f / curbe_param->output_height;
1002
1003 curbe_cmd->dw16.input_frame_nv12_bti = VP9_BTI_DYS_INPUT_NV12;
1004 curbe_cmd->dw17.output_frame_y_bti = VP9_BTI_DYS_OUTPUT_Y;
1005 curbe_cmd->dw18.avs_sample_bti = 0;
1006
1007 i965_gpe_context_unmap_curbe(gpe_context);
1008 }
1009
1010 static VAStatus
1011 gen10_vdenc_vp9_dys_surface(VADriverContextP ctx,
1012 struct encode_state *encode_state,
1013 struct i965_gpe_context *gpe_context,
1014 struct intel_encoder_context *encoder_context,
1015 struct gen10_vdenc_vp9_dys_surface_parameters *surface_param)
1016 {
1017
1018 if (surface_param->input_frame)
1019 i965_add_adv_gpe_surface(ctx,
1020 gpe_context,
1021 surface_param->input_frame,
1022 VP9_BTI_DYS_INPUT_NV12);
1023
1024 if (surface_param->output_frame) {
1025 i965_add_2d_gpe_surface(ctx,
1026 gpe_context,
1027 surface_param->output_frame,
1028 0,
1029 1,
1030 I965_SURFACEFORMAT_R8_UNORM,
1031 VP9_BTI_DYS_OUTPUT_Y);
1032
1033 i965_add_2d_gpe_surface(ctx,
1034 gpe_context,
1035 surface_param->output_frame,
1036 1,
1037 1,
1038 I965_SURFACEFORMAT_R16_UINT,
1039 VP9_BTI_DYS_OUTPUT_UV);
1040 }
1041
1042 return VA_STATUS_SUCCESS;
1043 }
1044
1045 static VAStatus
1046 gen10_vdenc_vp9_dys_kernel(VADriverContextP ctx,
1047 struct encode_state *encode_state,
1048 struct intel_encoder_context *encoder_context,
1049 struct gen10_vdenc_vp9_dys_kernel_parameters *dys_kernel_param)
1050 {
1051 struct gen10_vdenc_vp9_context *vdenc_context = encoder_context->mfc_context;
1052 struct i965_gpe_context *gpe_context;
1053 struct gen10_vdenc_vp9_dys_curbe_parameters curbe_param;
1054 struct gen10_vdenc_vp9_dys_surface_parameters surface_param;
1055 struct gpe_media_object_walker_parameter media_object_walker_param;
1056 struct gpe_encoder_kernel_walker_parameter kernel_walker_param;
1057 struct i965_gpe_table *gpe = vdenc_context->gpe_table;
1058 unsigned int resolution_x, resolution_y;
1059
1060 gpe_context = &vdenc_context->dys_context.gpe_context;
1061 gpe->reset_binding_table(ctx, gpe_context);
1062
1063 memset(&curbe_param, 0, sizeof(curbe_param));
1064 curbe_param.input_width = dys_kernel_param->input_width;
1065 curbe_param.input_height = dys_kernel_param->input_height;
1066 curbe_param.output_width = dys_kernel_param->output_width;
1067 curbe_param.output_height = dys_kernel_param->output_height;
1068 gen10_vdenc_vp9_dys_set_curbe_data(ctx,
1069 encode_state,
1070 gpe_context,
1071 encoder_context,
1072 &curbe_param);
1073
1074 // Add surface states
1075 memset(&surface_param, 0, sizeof(surface_param));
1076 surface_param.input_frame = dys_kernel_param->input_surface;
1077 surface_param.output_frame = dys_kernel_param->output_surface;
1078 surface_param.vert_line_stride = 0;
1079 surface_param.vert_line_stride_offset = 0;
1080 gen10_vdenc_vp9_dys_surface(ctx,
1081 encode_state,
1082 gpe_context,
1083 encoder_context,
1084 &surface_param);
1085
1086 gpe->setup_interface_data(ctx, gpe_context);
1087
1088 resolution_x = ALIGN(dys_kernel_param->output_width, 16) / 16;
1089 resolution_y = ALIGN(dys_kernel_param->output_height, 16) / 16;
1090 memset(&kernel_walker_param, 0, sizeof(kernel_walker_param));
1091 kernel_walker_param.resolution_x = resolution_x;
1092 kernel_walker_param.resolution_y = resolution_y;
1093 kernel_walker_param.no_dependency = 1;
1094 gen10_vdenc_vp9_init_media_object_walker_parameter(encoder_context, &kernel_walker_param, &media_object_walker_param);
1095
1096 gen10_vdenc_vp9_run_media_object_walker(ctx,
1097 encoder_context,
1098 gpe_context,
1099 &media_object_walker_param);
1100
1101 return VA_STATUS_SUCCESS;
1102 }
1103
1104 static VAStatus
1105 gen10_vdenc_vp9_dys_src_frame(VADriverContextP ctx,
1106 struct encode_state *encode_state,
1107 struct intel_encoder_context *encoder_context)
1108 {
1109 struct gen10_vdenc_vp9_context *vdenc_context = encoder_context->mfc_context;
1110 struct gen10_vdenc_vp9_dys_kernel_parameters dys_kernel_param;
1111 struct object_surface *obj_surface, *input_surface, *output_surface;
1112 struct vdenc_vp9_surface *vdenc_vp9_surface;
1113 VAEncPictureParameterBufferVP9 *pic_param = vdenc_context->pic_param;
1114
1115 if (!vdenc_context->dys_in_use)
1116 return VA_STATUS_SUCCESS;
1117
1118 if ((pic_param->frame_width_src != pic_param->frame_width_dst) ||
1119 (pic_param->frame_height_src != pic_param->frame_height_dst)) {
1120 input_surface = encode_state->input_yuv_object;
1121 obj_surface = encode_state->reconstructed_object;
1122 vdenc_vp9_surface = (struct vdenc_vp9_surface *)(obj_surface->private_data);
1123 output_surface = vdenc_vp9_surface->dys_surface_obj;
1124
1125 memset(&dys_kernel_param, 0, sizeof(dys_kernel_param));
1126 dys_kernel_param.input_width = pic_param->frame_width_src;
1127 dys_kernel_param.input_height = pic_param->frame_height_src;
1128 dys_kernel_param.input_surface = input_surface;
1129 dys_kernel_param.output_width = pic_param->frame_width_dst;
1130 dys_kernel_param.output_height = pic_param->frame_height_dst;
1131 dys_kernel_param.output_surface = output_surface;
1132
1133 gen10_vdenc_vp9_dys_kernel(ctx,
1134 encode_state,
1135 encoder_context,
1136 &dys_kernel_param);
1137 }
1138
1139 return VA_STATUS_SUCCESS;
1140 }
1141
1142 #if 0
1143
1144 static void
1145 gen10_vdenc_vp9_streamin_set_curbe_data(VADriverContextP ctx,
1146 struct encode_state *encode_state,
1147 struct i965_gpe_context *gpe_context,
1148 struct intel_encoder_context *encoder_context,
1149 struct gen10_vdenc_vp9_streamin_curbe_parameters *curbe_param)
1150 {
1151 struct gen10_vdenc_vp9_streamin_curbe_data *curbe_cmd;
1152
1153 curbe_cmd = i965_gpe_context_map_curbe(gpe_context);
1154
1155 if (!curbe_cmd)
1156 return;
1157
1158 memset(curbe_cmd, 0, sizeof(*curbe_cmd));
1159
1160 i965_gpe_context_unmap_curbe(gpe_context);
1161 }
1162
1163 static VAStatus
1164 gen10_vdenc_vp9_streamin_surface(VADriverContextP ctx,
1165 struct encode_state *encode_state,
1166 struct i965_gpe_context *gpe_context,
1167 struct intel_encoder_context *encoder_context,
1168 struct gen10_vdenc_vp9_streamin_surface_parameters *surface_param)
1169 {
1170
1171 if (surface_param->input_frame)
1172 i965_add_adv_gpe_surface(ctx,
1173 gpe_context,
1174 surface_param->input_frame,
1175 VP9_BTI_DYS_INPUT_NV12);
1176
1177 if (surface_param->output_frame) {
1178 i965_add_2d_gpe_surface(ctx,
1179 gpe_context,
1180 surface_param->output_frame,
1181 0,
1182 1,
1183 I965_SURFACEFORMAT_R8_UNORM,
1184 VP9_BTI_DYS_OUTPUT_Y);
1185
1186 i965_add_2d_gpe_surface(ctx,
1187 gpe_context,
1188 surface_param->output_frame,
1189 1,
1190 1,
1191 I965_SURFACEFORMAT_R16_UINT,
1192 VP9_BTI_DYS_OUTPUT_UV);
1193 }
1194
1195 return VA_STATUS_SUCCESS;
1196 }
1197
1198 static VAStatus
1199 gen10_vdenc_vp9_streamin_kernel(VADriverContextP ctx,
1200 struct encode_state *encode_state,
1201 struct intel_encoder_context *encoder_context,
1202 struct gen10_vdenc_vp9_streamin_kernel_parameters *streamin_kernel_param)
1203 {
1204 struct gen10_vdenc_vp9_context *vdenc_context = encoder_context->mfc_context;
1205 struct i965_gpe_context *gpe_context;
1206 struct gen10_vdenc_vp9_streamin_curbe_parameters curbe_param;
1207 struct gen10_vdenc_vp9_streamin_surface_parameters surface_param;
1208 struct gpe_media_object_walker_parameter media_object_walker_param;
1209 struct gpe_encoder_kernel_walker_parameter kernel_walker_param;
1210 struct i965_gpe_table *gpe = vdenc_context->gpe_table;
1211 unsigned int resolution_x, resolution_y;
1212
1213 gpe_context = &vdenc_context->streamin_context.gpe_context;
1214 gpe->reset_binding_table(ctx, gpe_context);
1215
1216 memset(&curbe_param, 0, sizeof(curbe_param));
1217 curbe_param.input_width = streamin_kernel_param->input_width;
1218 curbe_param.input_height = streamin_kernel_param->input_height;
1219 curbe_param.output_width = streamin_kernel_param->output_width;
1220 curbe_param.output_height = streamin_kernel_param->output_height;
1221 gen10_vdenc_vp9_streamin_set_curbe_data(ctx,
1222 encode_state,
1223 gpe_context,
1224 encoder_context,
1225 &curbe_param);
1226
1227 // Add surface states
1228 memset(&surface_param, 0, sizeof(surface_param));
1229 surface_param.input_frame = streamin_kernel_param->input_surface;
1230 surface_param.output_frame = streamin_kernel_param->output_surface;
1231 surface_param.vert_line_stride = 0;
1232 surface_param.vert_line_stride_offset = 0;
1233 gen10_vdenc_vp9_streamin_surface(ctx,
1234 encode_state,
1235 gpe_context,
1236 encoder_context,
1237 &surface_param);
1238
1239 gpe->setup_interface_data(ctx, gpe_context);
1240
1241 resolution_x = ALIGN(streamin_kernel_param->output_width, 16) / 16;
1242 resolution_y = ALIGN(streamin_kernel_param->output_height, 16) / 16;
1243 memset(&kernel_walker_param, 0, sizeof(kernel_walker_param));
1244 kernel_walker_param.resolution_x = resolution_x;
1245 kernel_walker_param.resolution_y = resolution_y;
1246 kernel_walker_param.no_dependency = 1;
1247 gen10_vdenc_vp9_init_media_object_walker_parameter(encoder_context, &kernel_walker_param, &media_object_walker_param);
1248
1249 gen10_vdenc_vp9_run_media_object_walker(ctx,
1250 encoder_context,
1251 gpe_context,
1252 &media_object_walker_param);
1253
1254 return VA_STATUS_SUCCESS;
1255 }
1256
1257 static VAStatus
1258 gen10_vdenc_vp9_run_streamin(VADriverContextP ctx,
1259 struct encode_state *encode_state,
1260 struct intel_encoder_context *encoder_context)
1261 {
1262 struct gen10_vdenc_vp9_context *vdenc_context = encoder_context->mfc_context;
1263 struct gen10_vdenc_vp9_streamin_kernel_parameters streamin_kernel_param;
1264 struct object_surface *obj_surface, *input_surface, *output_surface;
1265 struct vdenc_vp9_surface *vdenc_vp9_surface;
1266 VAEncPictureParameterBufferVP9 *pic_param = vdenc_context->pic_param;
1267
1268 input_surface = encode_state->input_yuv_object;
1269 obj_surface = encode_state->reconstructed_object;
1270 vdenc_vp9_surface = (struct vdenc_vp9_surface *)(obj_surface->private_data);
1271 output_surface = vdenc_vp9_surface->dys_surface_obj;
1272
1273 memset(&streamin_kernel_param, 0, sizeof(streamin_kernel_param));
1274 streamin_kernel_param.input_width = pic_param->frame_width_src;
1275 streamin_kernel_param.input_height = pic_param->frame_height_src;
1276 streamin_kernel_param.input_surface = input_surface;
1277 streamin_kernel_param.output_width = pic_param->frame_width_dst;
1278 streamin_kernel_param.output_height = pic_param->frame_height_dst;
1279 streamin_kernel_param.output_surface = output_surface;
1280
1281 gen10_vdenc_vp9_streamin_kernel(ctx,
1282 encode_state,
1283 encoder_context,
1284 &streamin_kernel_param);
1285 return VA_STATUS_SUCCESS;
1286 }
1287
1288 #endif
1289
1290 static uint32_t
1291 intel_convert_sign_mag(int val, int sign_bit_pos)
1292 {
1293 uint32_t ret_val = 0;
1294
1295 if (val < 0) {
1296 val = -val;
1297 ret_val = ((1 << (sign_bit_pos - 1)) | (val & ((1 << (sign_bit_pos - 1)) - 1)));
1298 } else {
1299 ret_val = val & ((1 << (sign_bit_pos - 1)) - 1);
1300 }
1301
1302 return ret_val;
1303 }
1304
1305 static void
1306 gen10_vdenc_vp9_update_brc_parameters(VADriverContextP ctx,
1307 struct encode_state *encode_state,
1308 struct intel_encoder_context *encoder_context)
1309 {
1310 struct gen10_vdenc_vp9_context *vdenc_context = encoder_context->mfc_context;
1311
1312 if (vdenc_context->internal_rate_mode != I965_BRC_CQP &&
1313 encoder_context->brc.need_reset) {
1314 /* So far, vdenc doesn't support temporal layer */
1315 vdenc_context->framerate = encoder_context->brc.framerate[0];
1316
1317 vdenc_context->vbv_buffer_size_in_bit = encoder_context->brc.hrd_buffer_size;
1318 vdenc_context->init_vbv_buffer_fullness_in_bit = encoder_context->brc.hrd_initial_buffer_fullness;
1319
1320 vdenc_context->max_bit_rate = encoder_context->brc.bits_per_second[0];
1321 vdenc_context->brc_need_reset = (vdenc_context->brc_initted && encoder_context->brc.need_reset);
1322
1323 if (vdenc_context->internal_rate_mode == I965_BRC_CBR) {
1324 vdenc_context->min_bit_rate = vdenc_context->max_bit_rate;
1325 vdenc_context->target_bit_rate = vdenc_context->max_bit_rate;
1326 } else {
1327 assert(vdenc_context->internal_rate_mode == I965_BRC_VBR);
1328 vdenc_context->min_bit_rate = vdenc_context->max_bit_rate * (2 * encoder_context->brc.target_percentage[0] - 100) / 100;
1329 vdenc_context->target_bit_rate = vdenc_context->max_bit_rate * encoder_context->brc.target_percentage[0] / 100;
1330 }
1331 }
1332
1333 if (vdenc_context->internal_rate_mode == I965_BRC_CBR ||
1334 vdenc_context->internal_rate_mode == I965_BRC_VBR)
1335 vdenc_context->brc_enabled = 1;
1336 else
1337 vdenc_context->brc_enabled = 0;
1338
1339 if (vdenc_context->brc_enabled &&
1340 (!vdenc_context->init_vbv_buffer_fullness_in_bit ||
1341 !vdenc_context->vbv_buffer_size_in_bit ||
1342 !vdenc_context->max_bit_rate ||
1343 !vdenc_context->target_bit_rate ||
1344 !vdenc_context->framerate.num ||
1345 !vdenc_context->framerate.den))
1346 vdenc_context->brc_enabled = 0;
1347
1348 if (!vdenc_context->brc_enabled) {
1349 vdenc_context->target_bit_rate = 0;
1350 vdenc_context->max_bit_rate = 0;
1351 vdenc_context->min_bit_rate = 0;
1352 vdenc_context->init_vbv_buffer_fullness_in_bit = 0;
1353 vdenc_context->vbv_buffer_size_in_bit = 0;
1354 }
1355 }
1356
1357 static VAStatus
1358 gen10_vdenc_vp9_update_parameters(VADriverContextP ctx,
1359 VAProfile profile,
1360 struct encode_state *encode_state,
1361 struct intel_encoder_context *encoder_context)
1362 {
1363 struct i965_driver_data *i965 = i965_driver_data(ctx);
1364 struct gen10_vdenc_vp9_context *vdenc_context = encoder_context->mfc_context;
1365 struct object_surface *obj_surface;
1366 VAEncPictureParameterBufferVP9 *pic_param = NULL;
1367 VAEncMiscParameterTypeVP9PerSegmantParam *seg_param = NULL;
1368 VAEncSequenceParameterBufferVP9 *seq_param = NULL;
1369 VDEncVP9Surface *vdenc_vp9_surface;
1370
1371 vdenc_context->dys_multiple_pass_enbaled = 1;
1372 vdenc_context->tx_mode = TX_MODE_SELECT;
1373 vdenc_context->current_pass = 0;
1374 vdenc_context->num_passes = 1;
1375
1376 if (vdenc_context->has_hme)
1377 vdenc_context->need_hme = (encoder_context->quality_level == 1);
1378 else
1379 vdenc_context->need_hme = 0;
1380
1381 gen10_vdenc_vp9_update_brc_parameters(ctx, encode_state, encoder_context);
1382
1383 if (vdenc_context->use_huc)
1384 vdenc_context->num_passes = 2;
1385
1386 if (vdenc_context->brc_enabled) {
1387 vdenc_context->num_passes = VDENC_VP9_BRC_MAX_NUM_OF_PASSES;
1388
1389 if (!vdenc_context->multiple_pass_brc_enabled)
1390 vdenc_context->num_passes--;
1391 }
1392
1393 if (!encode_state->pic_param_ext ||
1394 !encode_state->pic_param_ext->buffer) {
1395 return VA_STATUS_ERROR_INVALID_PARAMETER;
1396 }
1397
1398 pic_param = (VAEncPictureParameterBufferVP9 *)encode_state->pic_param_ext->buffer;
1399
1400 if (!pic_param->pic_flags.bits.frame_type)
1401 vdenc_context->is_key_frame = 1;
1402 else
1403 vdenc_context->is_key_frame = 0;
1404
1405 if (pic_param->pic_flags.bits.intra_only)
1406 vdenc_context->frame_intra_only = 1;
1407 else
1408 vdenc_context->frame_intra_only = 0;
1409
1410 vdenc_context->is_8bit = (VAProfileVP9Profile0 == profile);
1411 vdenc_context->ref_frame_flag = VP9_REF_NONE;
1412 vdenc_context->num_ref_frames = 0;
1413 vdenc_context->pic_param = NULL;
1414 vdenc_context->segment_param = NULL;
1415 vdenc_context->seq_param = NULL;
1416 vdenc_context->last_ref_obj = NULL;
1417 vdenc_context->golden_ref_obj = NULL;
1418 vdenc_context->alt_ref_obj = NULL;
1419 i965_free_gpe_resource(&vdenc_context->mb_segment_map_buffer_res);
1420
1421 if (vdenc_context->is_key_frame || vdenc_context->frame_intra_only) {
1422 /* this will be regarded as I-frame type */
1423 vdenc_context->vp9_frame_type = VP9_FRAME_I;
1424 } else {
1425 vdenc_context->vp9_frame_type = VP9_FRAME_P;
1426 vdenc_context->ref_frame_flag = (pic_param->ref_flags.bits.ref_frame_ctrl_l0 | pic_param->ref_flags.bits.ref_frame_ctrl_l1);
1427
1428 /* Last */
1429 obj_surface = SURFACE(pic_param->reference_frames[pic_param->ref_flags.bits.ref_last_idx]);
1430
1431 if (!obj_surface ||
1432 !obj_surface->bo ||
1433 !obj_surface->private_data) {
1434 vdenc_context->ref_frame_flag &= ~(VP9_REF_LAST);
1435 obj_surface = NULL;
1436 }
1437
1438 vdenc_context->last_ref_obj = obj_surface;
1439
1440 /* Golden */
1441 obj_surface = SURFACE(pic_param->reference_frames[pic_param->ref_flags.bits.ref_gf_idx]);
1442
1443 if (!obj_surface ||
1444 !obj_surface->bo ||
1445 !obj_surface->private_data) {
1446 vdenc_context->ref_frame_flag &= ~(VP9_REF_GOLDEN);
1447 obj_surface = NULL;
1448 }
1449
1450 vdenc_context->golden_ref_obj = obj_surface;
1451
1452 /* Alt */
1453 obj_surface = SURFACE(pic_param->reference_frames[pic_param->ref_flags.bits.ref_arf_idx]);
1454
1455 if (!obj_surface ||
1456 !obj_surface->bo ||
1457 !obj_surface->private_data) {
1458 vdenc_context->ref_frame_flag &= ~(VP9_REF_ALT);
1459 obj_surface = NULL;
1460 }
1461
1462 vdenc_context->alt_ref_obj = obj_surface;
1463
1464 /* remove the duplicated flag and ref frame list */
1465 if (vdenc_context->ref_frame_flag & VP9_REF_LAST) {
1466 if (pic_param->reference_frames[pic_param->ref_flags.bits.ref_last_idx] ==
1467 pic_param->reference_frames[pic_param->ref_flags.bits.ref_gf_idx]) {
1468 vdenc_context->ref_frame_flag &= ~(VP9_REF_GOLDEN);
1469 vdenc_context->golden_ref_obj = NULL;
1470 }
1471
1472 if (pic_param->reference_frames[pic_param->ref_flags.bits.ref_last_idx] ==
1473 pic_param->reference_frames[pic_param->ref_flags.bits.ref_arf_idx]) {
1474 vdenc_context->ref_frame_flag &= ~(VP9_REF_ALT);
1475 vdenc_context->alt_ref_obj = NULL;
1476 }
1477
1478 vdenc_context->num_ref_frames++;
1479 }
1480
1481 if (vdenc_context->ref_frame_flag & VP9_REF_GOLDEN) {
1482 if (pic_param->reference_frames[pic_param->ref_flags.bits.ref_gf_idx] ==
1483 pic_param->reference_frames[pic_param->ref_flags.bits.ref_arf_idx]) {
1484 vdenc_context->ref_frame_flag &= ~(VP9_REF_ALT);
1485 vdenc_context->alt_ref_obj = NULL;
1486 }
1487
1488 vdenc_context->num_ref_frames++;
1489 }
1490
1491 if (vdenc_context->ref_frame_flag & VP9_REF_ALT) {
1492 vdenc_context->num_ref_frames++;
1493 }
1494
1495 if (vdenc_context->ref_frame_flag == VP9_REF_NONE)
1496 return VA_STATUS_ERROR_INVALID_PARAMETER;
1497 }
1498
1499 vdenc_context->hme_enabled = (vdenc_context->need_hme && vdenc_context->vp9_frame_type == VP9_FRAME_P);
1500 vdenc_context->hme_16x_enabled = (vdenc_context->hme_enabled && vdenc_context->has_hme_16x);
1501
1502 if (pic_param->pic_flags.bits.segmentation_enabled) {
1503 if (!encode_state->q_matrix ||
1504 !encode_state->q_matrix->buffer) {
1505 return VA_STATUS_ERROR_INVALID_PARAMETER;
1506 }
1507
1508 if (!encode_state->encmb_map ||
1509 !encode_state->encmb_map->bo)
1510 return VA_STATUS_ERROR_INVALID_PARAMETER;
1511
1512 seg_param = (VAEncMiscParameterTypeVP9PerSegmantParam *)encode_state->q_matrix->buffer;
1513 vdenc_context->segment_param = seg_param;
1514 i965_dri_object_to_2d_gpe_resource(&vdenc_context->mb_segment_map_buffer_res,
1515 encode_state->encmb_map->bo,
1516 vdenc_context->frame_width_in_mi_units,
1517 vdenc_context->frame_height_in_mi_units,
1518 vdenc_context->frame_width_in_mi_units);
1519 }
1520
1521 if (encode_state->seq_param_ext &&
1522 encode_state->seq_param_ext->buffer)
1523 seq_param = (VAEncSequenceParameterBufferVP9 *)encode_state->seq_param_ext->buffer;
1524
1525 if (!seq_param) {
1526 seq_param = &vdenc_context->bogus_seq_param;
1527 }
1528
1529 vdenc_context->pic_param = pic_param;
1530 vdenc_context->seq_param = seq_param;
1531
1532 vdenc_context->frame_width = pic_param->frame_width_dst; // TODO, check dynamic scaling
1533 vdenc_context->frame_height = pic_param->frame_height_dst; // TODO, check dynamic scaling
1534
1535 if (vdenc_context->max_frame_width < vdenc_context->frame_width)
1536 vdenc_context->max_frame_width = vdenc_context->frame_width;
1537
1538 if (vdenc_context->max_frame_height < vdenc_context->frame_height)
1539 vdenc_context->max_frame_height = vdenc_context->frame_height;
1540
1541 vdenc_context->frame_width_in_mi_units = ALIGN(vdenc_context->frame_width, 8) / 8;
1542 vdenc_context->frame_height_in_mi_units = ALIGN(vdenc_context->frame_height, 8) / 8;
1543 vdenc_context->frame_width_in_sbs = ALIGN(vdenc_context->frame_width, 64) / 64;
1544 vdenc_context->frame_height_in_sbs = ALIGN(vdenc_context->frame_height, 64) / 64;
1545
1546 vdenc_context->down_scaled_width_4x = ALIGN(vdenc_context->frame_width / 4, 16);
1547 vdenc_context->down_scaled_height_4x = ALIGN(vdenc_context->frame_height / 4, 16);
1548 vdenc_context->down_scaled_width_16x = ALIGN(vdenc_context->frame_width / 16, 16);
1549 vdenc_context->down_scaled_height_16x = ALIGN(vdenc_context->frame_height / 16, 16);
1550
1551 vdenc_context->frame_width_in_mbs = ALIGN(vdenc_context->frame_width, 16) / 16;
1552 vdenc_context->frame_height_in_mbs = ALIGN(vdenc_context->frame_height, 16) / 16;
1553 vdenc_context->down_scaled_width_in_mb4x = vdenc_context->down_scaled_width_4x / 16;
1554 vdenc_context->down_scaled_height_in_mb4x = vdenc_context->down_scaled_height_4x / 16;
1555 vdenc_context->down_scaled_width_in_mb16x = vdenc_context->down_scaled_width_16x / 16;
1556 vdenc_context->down_scaled_height_in_mb16x = vdenc_context->down_scaled_height_16x / 16;
1557
1558 vdenc_context->dys_in_use = 0;
1559
1560 if (pic_param->frame_width_src != pic_param->frame_width_dst ||
1561 pic_param->frame_height_src != pic_param->frame_height_dst)
1562 vdenc_context->dys_in_use = 1;
1563
1564 vdenc_context->dys_ref_frame_flag = VP9_REF_NONE;
1565
1566 if (vdenc_context->vp9_frame_type == VP9_FRAME_P) {
1567 vdenc_context->dys_ref_frame_flag = vdenc_context->ref_frame_flag;
1568
1569 if ((vdenc_context->ref_frame_flag & VP9_REF_LAST) &&
1570 vdenc_context->last_ref_obj) {
1571 obj_surface = vdenc_context->last_ref_obj;
1572 vdenc_vp9_surface = (VDEncVP9Surface *)(obj_surface->private_data);
1573
1574 if (vdenc_context->frame_width == vdenc_vp9_surface->frame_width &&
1575 vdenc_context->frame_height == vdenc_vp9_surface->frame_height)
1576 vdenc_context->dys_ref_frame_flag &= ~(VP9_REF_LAST);
1577 }
1578
1579 if ((vdenc_context->ref_frame_flag & VP9_REF_GOLDEN) &&
1580 vdenc_context->golden_ref_obj) {
1581 obj_surface = vdenc_context->golden_ref_obj;
1582 vdenc_vp9_surface = (VDEncVP9Surface *)(obj_surface->private_data);
1583
1584 if (vdenc_context->frame_width == vdenc_vp9_surface->frame_width &&
1585 vdenc_context->frame_height == vdenc_vp9_surface->frame_height)
1586 vdenc_context->dys_ref_frame_flag &= ~(VP9_REF_GOLDEN);
1587 }
1588
1589 if ((vdenc_context->ref_frame_flag & VP9_REF_ALT) &&
1590 vdenc_context->alt_ref_obj) {
1591 obj_surface = vdenc_context->alt_ref_obj;
1592 vdenc_vp9_surface = (VDEncVP9Surface *)(obj_surface->private_data);
1593
1594 if (vdenc_context->frame_width == vdenc_vp9_surface->frame_width &&
1595 vdenc_context->frame_height == vdenc_vp9_surface->frame_height)
1596 vdenc_context->dys_ref_frame_flag &= ~(VP9_REF_ALT);
1597 }
1598
1599 if (vdenc_context->dys_ref_frame_flag)
1600 vdenc_context->dys_in_use = 1;
1601 }
1602
1603 if (vdenc_context->dys_ref_frame_flag != VP9_REF_NONE &&
1604 vdenc_context->dys_multiple_pass_enbaled &&
1605 !vdenc_context->use_huc)
1606 vdenc_context->num_passes = 2;
1607
1608 return VA_STATUS_SUCCESS;
1609 }
1610
1611 static void
1612 gen10_vdenc_vp9_update_streamin_state(VADriverContextP ctx,
1613 struct intel_encoder_context *encoder_context)
1614 {
1615 struct gen10_vdenc_vp9_context *vdenc_context = encoder_context->mfc_context;
1616 struct gen10_vdenc_vp9_streamin_state *streamin_state;
1617 int row, col, i;
1618 int bwidth = ALIGN(vdenc_context->frame_width, VP9_SUPER_BLOCK_WIDTH) / 32;
1619 int bheight = ALIGN(vdenc_context->frame_height, VP9_SUPER_BLOCK_HEIGHT) / 32;
1620 unsigned char *segid_buffer, segid;
1621
1622 if (!vdenc_context->segment_param && !vdenc_context->hme_enabled)
1623 return;
1624
1625 i965_zero_gpe_resource(&vdenc_context->vdenc_streamin_buffer_res);
1626
1627 if (!vdenc_context->segment_param)
1628 return;
1629
1630 streamin_state = (struct gen10_vdenc_vp9_streamin_state *)i965_map_gpe_resource(&vdenc_context->vdenc_streamin_buffer_res);
1631
1632 if (!streamin_state)
1633 return;
1634
1635 segid_buffer = (unsigned char *)i965_map_gpe_resource(&vdenc_context->mb_segment_map_buffer_res);
1636
1637 if (!segid_buffer) {
1638 i965_unmap_gpe_resource(&vdenc_context->vdenc_streamin_buffer_res);
1639 return;
1640 }
1641
1642 for (col = 0; col < bwidth; col++) {
1643 for (row = 0; row < bheight; row++) {
1644 i = row * bwidth + col;
1645 segid = segid_buffer[i * 16];
1646
1647 streamin_state[i].dw7.segid_enable = 1;
1648 streamin_state[i].dw7.segid_32x32_0_16x16_03_vp9_only = (segid | segid << 4 | segid << 8 | segid << 12);
1649 streamin_state[i].dw0.max_tu_size = 3;
1650 streamin_state[i].dw0.max_cu_size = 3;
1651
1652 if ((i % 4) == 3 && !vdenc_context->is_key_frame) {
1653 if (!(streamin_state[i - 3].dw7.segid_32x32_0_16x16_03_vp9_only == streamin_state[i - 2].dw7.segid_32x32_0_16x16_03_vp9_only &&
1654 streamin_state[i - 2].dw7.segid_32x32_0_16x16_03_vp9_only == streamin_state[i - 1].dw7.segid_32x32_0_16x16_03_vp9_only &&
1655 streamin_state[i - 1].dw7.segid_32x32_0_16x16_03_vp9_only == streamin_state[i].dw7.segid_32x32_0_16x16_03_vp9_only)) {
1656 streamin_state[i - 3].dw0.max_cu_size = streamin_state[i - 2].dw0.max_cu_size = streamin_state[i - 1].dw0.max_cu_size = streamin_state[i].dw0.max_cu_size = 2;
1657 }
1658 }
1659
1660 streamin_state[i].dw0.num_ime_predictors = 8;
1661
1662 switch (encoder_context->quality_level) {
1663 case 7:
1664 streamin_state[i].dw0.num_ime_predictors = 4;
1665 streamin_state[i].dw6.num_merge_candidate_cu_8x8 = 0;
1666 streamin_state[i].dw6.num_merge_candidate_cu_16x16 = 2;
1667 streamin_state[i].dw6.num_merge_candidate_cu_32x32 = 2;
1668 streamin_state[i].dw6.num_merge_candidate_cu_64x64 = 2;
1669
1670 break;
1671
1672 case 1:
1673 case 4:
1674 default:
1675 streamin_state[i].dw6.num_merge_candidate_cu_8x8 = 1;
1676 streamin_state[i].dw6.num_merge_candidate_cu_16x16 = 2;
1677 streamin_state[i].dw6.num_merge_candidate_cu_32x32 = 3;
1678 streamin_state[i].dw6.num_merge_candidate_cu_64x64 = 4;
1679
1680 break;
1681 }
1682 }
1683 }
1684
1685 i965_unmap_gpe_resource(&vdenc_context->mb_segment_map_buffer_res);
1686 i965_unmap_gpe_resource(&vdenc_context->vdenc_streamin_buffer_res);
1687 }
1688
1689 static VAStatus
1690 gen10_vdenc_vp9_allocate_resources_once(VADriverContextP ctx,
1691 struct encode_state *encode_state,
1692 struct intel_encoder_context *encoder_context)
1693 {
1694 struct i965_driver_data *i965 = i965_driver_data(ctx);
1695 struct gen10_vdenc_vp9_context *vdenc_context = encoder_context->mfc_context;
1696 int res_size;
1697
1698 if (vdenc_context->allocate_once_done)
1699 return VA_STATUS_SUCCESS;
1700
1701 i965_free_gpe_resource(&vdenc_context->brc_history_buffer_res);
1702 i965_free_gpe_resource(&vdenc_context->brc_constant_data_buffer_res);
1703 i965_free_gpe_resource(&vdenc_context->brc_bitstream_size_buffer_res);
1704 i965_free_gpe_resource(&vdenc_context->brc_huc_data_buffer_res);
1705 i965_free_gpe_resource(&vdenc_context->vdenc_brc_stat_buffer_res);
1706 i965_free_gpe_resource(&vdenc_context->vdenc_brc_pak_stat_buffer_res);
1707 i965_free_gpe_resource(&vdenc_context->segmentid_buffer_res);
1708
1709 res_size = VDENC_VP9_BRC_HISTORY_BUFFER_SIZE;
1710 ALLOC_VDENC_BUFFER_RESOURCE(vdenc_context->brc_history_buffer_res,
1711 res_size,
1712 "Brc history buffer");
1713
1714 res_size = VDENC_VP9_BRC_CONSTANT_DATA_SIZE;
1715 ALLOC_VDENC_BUFFER_RESOURCE(vdenc_context->brc_constant_data_buffer_res,
1716 res_size,
1717 "Brc constant buffer");
1718
1719 res_size = ALIGN(VDENC_VP9_BRC_BITSTREAM_SIZE_BUFFER_SIZE, 4096);
1720 ALLOC_VDENC_BUFFER_RESOURCE(vdenc_context->brc_bitstream_size_buffer_res,
1721 res_size,
1722 "Brc bitstream buffer");
1723
1724 res_size = ALIGN(VDENC_VP9_BRC_HUC_DATA_BUFFER_SIZE, 4096);
1725 ALLOC_VDENC_BUFFER_RESOURCE(vdenc_context->brc_huc_data_buffer_res,
1726 res_size,
1727 "Brc huc data");
1728
1729 res_size = ALIGN(VDENC_VP9_BRC_STATS_BUF_SIZE, 4096);
1730 ALLOC_VDENC_BUFFER_RESOURCE(vdenc_context->vdenc_brc_stat_buffer_res,
1731 res_size,
1732 "VDEnc brc statistics buffer");
1733
1734 res_size = ALIGN(VDENC_VP9_BRC_PAK_STATS_BUF_SIZE, 4096);
1735 ALLOC_VDENC_BUFFER_RESOURCE(vdenc_context->vdenc_brc_pak_stat_buffer_res,
1736 res_size,
1737 "VDEnc brc pak statistics buffer");
1738 i965_zero_gpe_resource(&vdenc_context->vdenc_brc_pak_stat_buffer_res);
1739
1740 res_size = vdenc_context->frame_width_in_sbs * vdenc_context->frame_height_in_sbs * 64;
1741 ALLOC_VDENC_BUFFER_RESOURCE(vdenc_context->segmentid_buffer_res,
1742 res_size,
1743 "VP9 segment id");
1744
1745 i965_zero_gpe_resource(&vdenc_context->segmentid_buffer_res);
1746
1747 vdenc_context->allocate_once_done = 1;
1748
1749 return VA_STATUS_SUCCESS;
1750 }
1751
1752 static VAStatus
1753 gen10_vdenc_vp9_allocate_resources(VADriverContextP ctx,
1754 struct encode_state *encode_state,
1755 struct intel_encoder_context *encoder_context)
1756 {
1757 struct i965_driver_data *i965 = i965_driver_data(ctx);
1758 struct gen10_vdenc_vp9_context *vdenc_context = encoder_context->mfc_context;
1759 int i, res_size;
1760 uint32_t frame_width_in_sbs, frame_height_in_sbs, frame_size_in_sbs;
1761 unsigned int width, height, pitch, depth_factor = 1;
1762 char *pbuffer;
1763 int allocate_flag;
1764
1765 if (!vdenc_context->is_8bit)
1766 depth_factor = 2;
1767
1768 gen10_vdenc_vp9_allocate_resources_once(ctx, encode_state, encoder_context);
1769
1770 /* If the width/height of allocated buffer is greater than the expected,
1771 * it is unnecessary to allocate it again
1772 */
1773 if (vdenc_context->res_width >= vdenc_context->frame_width &&
1774 vdenc_context->res_height >= vdenc_context->frame_height) {
1775
1776 return VA_STATUS_SUCCESS;
1777 }
1778
1779 frame_width_in_sbs = vdenc_context->frame_width_in_sbs;
1780 frame_height_in_sbs = vdenc_context->frame_height_in_sbs;
1781 frame_size_in_sbs = frame_width_in_sbs * frame_height_in_sbs;
1782
1783 vdenc_context->coding_unit_offset = ALIGN(frame_size_in_sbs * 16, 4096); /* 3 dws for HCP_PAK_OBJECT and 1 dw for padding zero */
1784 vdenc_context->mb_code_buffer_size = ALIGN(8 * frame_size_in_sbs * (5 + 64 * 8), 4096);
1785 res_size = vdenc_context->mb_code_buffer_size + 8 * 64;
1786 i965_free_gpe_resource(&vdenc_context->mb_code_buffer_res);
1787 ALLOC_VDENC_BUFFER_RESOURCE(vdenc_context->mb_code_buffer_res,
1788 res_size,
1789 "VP9 mb_code surface");
1790
1791 res_size = frame_width_in_sbs * 64;
1792 i965_free_gpe_resource(&vdenc_context->hvd_line_buffer_res);
1793 ALLOC_VDENC_BUFFER_RESOURCE(vdenc_context->hvd_line_buffer_res,
1794 res_size,
1795 "VP9 hvd line line");
1796
1797 i965_free_gpe_resource(&vdenc_context->hvd_tile_line_buffer_res);
1798 ALLOC_VDENC_BUFFER_RESOURCE(vdenc_context->hvd_tile_line_buffer_res,
1799 res_size,
1800 "VP9 hvd tile_line line");
1801
1802 i965_free_gpe_resource(&vdenc_context->deblocking_filter_line_buffer_res);
1803 res_size = frame_width_in_sbs * (18 * depth_factor) * 64;
1804 ALLOC_VDENC_BUFFER_RESOURCE(vdenc_context->deblocking_filter_line_buffer_res,
1805 res_size,
1806 "VP9 deblocking filter line");
1807
1808 i965_free_gpe_resource(&vdenc_context->deblocking_filter_tile_line_buffer_res);
1809 ALLOC_VDENC_BUFFER_RESOURCE(vdenc_context->deblocking_filter_tile_line_buffer_res,
1810 res_size,
1811 "VP9 deblocking tile line");
1812
1813 i965_free_gpe_resource(&vdenc_context->deblocking_filter_tile_col_buffer_res);
1814 res_size = frame_height_in_sbs * (17 * depth_factor) * 64;
1815 ALLOC_VDENC_BUFFER_RESOURCE(vdenc_context->deblocking_filter_tile_col_buffer_res,
1816 res_size,
1817 "VP9 deblocking tile col");
1818
1819 res_size = frame_width_in_sbs * 5 * 64;
1820 i965_free_gpe_resource(&vdenc_context->metadata_line_buffer_res);
1821 ALLOC_VDENC_BUFFER_RESOURCE(vdenc_context->metadata_line_buffer_res,
1822 res_size,
1823 "VP9 metadata line");
1824
1825 i965_free_gpe_resource(&vdenc_context->metadata_tile_line_buffer_res);
1826 ALLOC_VDENC_BUFFER_RESOURCE(vdenc_context->metadata_tile_line_buffer_res,
1827 res_size,
1828 "VP9 metadata tile line");
1829
1830 res_size = frame_height_in_sbs * 5 * 64;
1831 i965_free_gpe_resource(&vdenc_context->metadata_tile_col_buffer_res);
1832 ALLOC_VDENC_BUFFER_RESOURCE(vdenc_context->metadata_tile_col_buffer_res,
1833 res_size,
1834 "VP9 metadata tile col");
1835
1836 res_size = frame_size_in_sbs * 9 * 64;
1837
1838 for (i = 0; i < 2; i++) {
1839 i965_free_gpe_resource(&vdenc_context->mv_temporal_buffer_res[i]);
1840 ALLOC_VDENC_BUFFER_RESOURCE(vdenc_context->mv_temporal_buffer_res[i],
1841 res_size,
1842 "VP9 temporal mv");
1843 }
1844
1845 res_size = 32 * 64;
1846
1847 for (i = 0; i < 4; i++) {
1848 i965_free_gpe_resource(&vdenc_context->prob_buffer_res[i]);
1849 ALLOC_VDENC_BUFFER_RESOURCE(vdenc_context->prob_buffer_res[i],
1850 res_size,
1851 "VP9 prob buffer");
1852 }
1853
1854 i965_free_gpe_resource(&vdenc_context->prob_delta_buffer_res);
1855 res_size = 29 * 64;
1856 ALLOC_VDENC_BUFFER_RESOURCE(vdenc_context->prob_delta_buffer_res,
1857 res_size,
1858 "VP9 prob delta");
1859
1860 i965_free_gpe_resource(&vdenc_context->compressed_header_buffer_res);
1861 res_size = 32 * 64;
1862 ALLOC_VDENC_BUFFER_RESOURCE(vdenc_context->compressed_header_buffer_res,
1863 res_size,
1864 "VP9 compressed input buffer");
1865
1866 i965_free_gpe_resource(&vdenc_context->prob_counter_buffer_res);
1867 res_size = 193 * 64;
1868 ALLOC_VDENC_BUFFER_RESOURCE(vdenc_context->prob_counter_buffer_res,
1869 res_size,
1870 "VP9 prob counter");
1871
1872 i965_free_gpe_resource(&vdenc_context->tile_record_streamout_buffer_res);
1873 res_size = frame_size_in_sbs * 64;
1874 ALLOC_VDENC_BUFFER_RESOURCE(vdenc_context->tile_record_streamout_buffer_res,
1875 res_size,
1876 "VP9 tile record stream_out");
1877
1878 i965_free_gpe_resource(&vdenc_context->cu_stat_streamout_buffer_res);
1879 res_size = frame_size_in_sbs * 64 * 8;
1880 ALLOC_VDENC_BUFFER_RESOURCE(vdenc_context->cu_stat_streamout_buffer_res,
1881 res_size,
1882 "VP9 CU stat stream_out");
1883
1884 res_size = MAX(sizeof(struct vdenc_vp9_huc_prob_dmem), sizeof(struct vp9_huc_prob_dmem));
1885 res_size = ALIGN(res_size, 64);
1886
1887 for (i = 0; i < 2; i++) {
1888 i965_free_gpe_resource(&vdenc_context->huc_prob_dmem_buffer_res[i]);
1889 ALLOC_VDENC_BUFFER_RESOURCE(vdenc_context->huc_prob_dmem_buffer_res[i],
1890 res_size,
1891 "huc prob dmem");
1892 }
1893
1894 res_size = ALIGN(sizeof(vdenc_vp9_key_frame_default_probs) + sizeof(vdenc_vp9_inter_default_probs), 64);
1895 i965_free_gpe_resource(&vdenc_context->huc_default_prob_buffer_res);
1896 ALLOC_VDENC_BUFFER_RESOURCE(vdenc_context->huc_default_prob_buffer_res,
1897 res_size,
1898 "huc default prob dmem");
1899
1900 pbuffer = (char *)i965_map_gpe_resource(&vdenc_context->huc_default_prob_buffer_res);
1901
1902 if (!pbuffer)
1903 return VA_STATUS_ERROR_ALLOCATION_FAILED;
1904
1905 memcpy(pbuffer, vdenc_vp9_key_frame_default_probs, sizeof(vdenc_vp9_key_frame_default_probs));
1906 pbuffer += sizeof(vdenc_vp9_key_frame_default_probs);
1907 memcpy(pbuffer, vdenc_vp9_inter_default_probs, sizeof(vdenc_vp9_inter_default_probs));
1908
1909 i965_unmap_gpe_resource(&vdenc_context->huc_default_prob_buffer_res);
1910
1911 res_size = 32 * 64;
1912 i965_free_gpe_resource(&vdenc_context->huc_prob_output_buffer_res);
1913 ALLOC_VDENC_BUFFER_RESOURCE(vdenc_context->huc_prob_output_buffer_res,
1914 res_size,
1915 "HuC prob output buffer");
1916
1917 res_size = 80;
1918 i965_free_gpe_resource(&vdenc_context->huc_pak_insert_uncompressed_header_input_2nd_batchbuffer_res);
1919 ALLOC_VDENC_BUFFER_RESOURCE(vdenc_context->huc_pak_insert_uncompressed_header_input_2nd_batchbuffer_res,
1920 res_size,
1921 "HuC pak insert uncompressed header read buffer");
1922
1923 res_size = 80;
1924 i965_free_gpe_resource(&vdenc_context->huc_pak_insert_uncompressed_header_output_2nd_batchbuffer_res);
1925 ALLOC_VDENC_BUFFER_RESOURCE(vdenc_context->huc_pak_insert_uncompressed_header_output_2nd_batchbuffer_res,
1926 res_size,
1927 "HuC pak insert uncompressed header write buffer");
1928
1929 res_size = 16; /* 4 dws */
1930 i965_free_gpe_resource(&vdenc_context->huc_status_buffer_res);
1931 ALLOC_VDENC_BUFFER_RESOURCE(vdenc_context->huc_status_buffer_res,
1932 res_size,
1933 "HuC status");
1934
1935 width = vdenc_context->down_scaled_width_in_mb4x * 32;
1936 height = vdenc_context->down_scaled_height_in_mb4x * 40;
1937 pitch = ALIGN(width, 128);
1938 i965_free_gpe_resource(&vdenc_context->s4x_memv_data_buffer_res);
1939 allocate_flag = i965_gpe_allocate_2d_resource(i965->intel.bufmgr,
1940 &vdenc_context->s4x_memv_data_buffer_res,
1941 width, height,
1942 ALIGN(width, 64),
1943 "VP9 4x MEMV data");
1944
1945 if (!allocate_flag)
1946 goto failed_allocation;
1947
1948 width = vdenc_context->down_scaled_width_in_mb4x * 8;
1949 height = vdenc_context->down_scaled_height_in_mb4x * 40;
1950 pitch = ALIGN(width, 128);
1951 i965_free_gpe_resource(&vdenc_context->s4x_memv_distortion_buffer_res);
1952 allocate_flag = i965_gpe_allocate_2d_resource(i965->intel.bufmgr,
1953 &vdenc_context->s4x_memv_distortion_buffer_res,
1954 width, height,
1955 ALIGN(width, 64),
1956 "VP9 4x MEMV distorion");
1957
1958 if (!allocate_flag)
1959 goto failed_allocation;
1960
1961 width = ALIGN(vdenc_context->down_scaled_width_in_mb16x * 32, 64);
1962 height = vdenc_context->down_scaled_height_in_mb16x * 40;
1963 pitch = ALIGN(width, 128);
1964 i965_free_gpe_resource(&vdenc_context->s16x_memv_data_buffer_res);
1965 allocate_flag = i965_gpe_allocate_2d_resource(i965->intel.bufmgr,
1966 &vdenc_context->s16x_memv_data_buffer_res,
1967 width, height,
1968 pitch,
1969 "VP9 16x MEMV data");
1970
1971 if (!allocate_flag)
1972 goto failed_allocation;
1973
1974 width = vdenc_context->frame_width_in_mbs * 16;
1975 height = vdenc_context->frame_height_in_mbs * 8;
1976 pitch = ALIGN(width, 64);
1977 i965_free_gpe_resource(&vdenc_context->output_16x16_inter_modes_buffer_res);
1978 allocate_flag = i965_gpe_allocate_2d_resource(i965->intel.bufmgr,
1979 &vdenc_context->output_16x16_inter_modes_buffer_res,
1980 width, height,
1981 ALIGN(width, 64),
1982 "VP9 output inter_mode");
1983
1984 if (!allocate_flag)
1985 goto failed_allocation;
1986
1987 res_size = vdenc_context->frame_width_in_mbs * vdenc_context->frame_height_in_mbs * 16 * 4;
1988
1989 for (i = 0; i < 2; i++) {
1990 i965_free_gpe_resource(&vdenc_context->mode_decision_buffer_res[i]);
1991 ALLOC_VDENC_BUFFER_RESOURCE(vdenc_context->mode_decision_buffer_res[i],
1992 res_size,
1993 "VP9 mode decision");
1994 }
1995
1996 // buffers for VDEnc
1997 res_size = ALIGN(VDENC_HCP_VP9_PIC_STATE_SIZE + VDENC_HCP_VP9_SEGMENT_STATE_SIZE * 8 + VDENC_VDENC_CMD0_STATE_SIZE + VDENC_VDENC_CMD1_STATE_SIZE + 8, 4096);
1998
1999 for (i = 0; i < 4; i++) {
2000 i965_free_gpe_resource(&vdenc_context->vdenc_pic_state_input_2nd_batchbuffer_res[i]);
2001 ALLOC_VDENC_BUFFER_RESOURCE(vdenc_context->vdenc_pic_state_input_2nd_batchbuffer_res[i],
2002 res_size,
2003 "VDEnc pic state input 2nd level batchbuffer");
2004
2005 i965_free_gpe_resource(&vdenc_context->vdenc_pic_state_output_2nd_batchbuffer_res[i]);
2006 ALLOC_VDENC_BUFFER_RESOURCE(vdenc_context->vdenc_pic_state_output_2nd_batchbuffer_res[i],
2007 res_size,
2008 "VDEnc pic state output 2nd level batchbuffer");
2009 }
2010
2011 i965_free_gpe_resource(&vdenc_context->vdenc_dys_pic_state_2nd_batchbuffer_res);
2012 ALLOC_VDENC_BUFFER_RESOURCE(vdenc_context->vdenc_dys_pic_state_2nd_batchbuffer_res,
2013 res_size,
2014 "VDEnc dys pic state 2nd level batchbuffer");
2015
2016 i965_free_gpe_resource(&vdenc_context->vdenc_brc_init_reset_dmem_buffer_res);
2017 ALLOC_VDENC_BUFFER_RESOURCE(vdenc_context->vdenc_brc_init_reset_dmem_buffer_res,
2018 ALIGN(sizeof(struct vdenc_vp9_huc_brc_init_dmem), 64),
2019 "brc init&reset dmem buffer");
2020
2021 for (i = 0; i < VDENC_VP9_BRC_MAX_NUM_OF_PASSES; i++) {
2022 i965_free_gpe_resource(&vdenc_context->vdenc_brc_update_dmem_buffer_res[i]);
2023 ALLOC_VDENC_BUFFER_RESOURCE(vdenc_context->vdenc_brc_update_dmem_buffer_res[i],
2024 ALIGN(sizeof(struct vdenc_vp9_huc_brc_update_dmem), 64),
2025 "brc update dmem buffer");
2026 }
2027
2028 i965_free_gpe_resource(&vdenc_context->vdenc_segment_map_stream_out_buffer_res);
2029 ALLOC_VDENC_BUFFER_RESOURCE(vdenc_context->vdenc_segment_map_stream_out_buffer_res,
2030 frame_size_in_sbs * 64,
2031 "VDEnc segment map stream out");
2032
2033 i965_free_gpe_resource(&vdenc_context->vdenc_sse_src_pixel_row_store_buffer_res);
2034 ALLOC_VDENC_BUFFER_RESOURCE(vdenc_context->vdenc_sse_src_pixel_row_store_buffer_res,
2035 (frame_width_in_sbs + 2) * 32 * 64,
2036 "VDEnc sse src pixel row store");
2037 i965_zero_gpe_resource(&vdenc_context->vdenc_sse_src_pixel_row_store_buffer_res);
2038
2039 i965_free_gpe_resource(&vdenc_context->vdenc_data_extension_buffer_res);
2040 ALLOC_VDENC_BUFFER_RESOURCE(vdenc_context->vdenc_data_extension_buffer_res,
2041 VDENC_VP9_HUC_DATA_EXTENSION_SIZE,
2042 "VDEnc data extension buffer");
2043 i965_zero_gpe_resource(&vdenc_context->vdenc_data_extension_buffer_res);
2044
2045 i965_free_gpe_resource(&vdenc_context->vdenc_streamin_buffer_res);
2046 ALLOC_VDENC_BUFFER_RESOURCE(vdenc_context->vdenc_streamin_buffer_res,
2047 (ALIGN(vdenc_context->frame_width, VP9_SUPER_BLOCK_WIDTH) / 32) * (ALIGN(vdenc_context->frame_height, VP9_SUPER_BLOCK_HEIGHT) / 32) * 64,
2048 "VDEnc stream in");
2049 i965_zero_gpe_resource(&vdenc_context->vdenc_streamin_buffer_res);
2050
2051 i965_free_gpe_resource(&vdenc_context->huc_status2_buffer_res);
2052 ALLOC_VDENC_BUFFER_RESOURCE(vdenc_context->huc_status2_buffer_res,
2053 64,
2054 "HuC Status 2");
2055
2056 i965_free_gpe_resource(&vdenc_context->vdenc_row_store_scratch_res);
2057 ALLOC_VDENC_BUFFER_RESOURCE(vdenc_context->vdenc_row_store_scratch_res,
2058 vdenc_context->frame_width_in_mbs * 64,
2059 "VDENC row store scratch buffer");
2060
2061 for (i = 0; i < VDENC_VP9_BRC_MAX_NUM_OF_PASSES; i++) {
2062 i965_free_gpe_resource(&vdenc_context->huc_initializer_dmem_buffer_res[i]);
2063 ALLOC_VDENC_BUFFER_RESOURCE(vdenc_context->huc_initializer_dmem_buffer_res[i],
2064 ALIGN(sizeof(struct huc_initializer_dmem), 64),
2065 "HuC Initializer DMEM buffer");
2066 i965_zero_gpe_resource(&vdenc_context->huc_initializer_dmem_buffer_res[i]);
2067
2068 i965_free_gpe_resource(&vdenc_context->huc_initializer_data_buffer_res[i]);
2069 ALLOC_VDENC_BUFFER_RESOURCE(vdenc_context->huc_initializer_data_buffer_res[i],
2070 ALIGN(sizeof(struct huc_initializer_data), 0x1000),
2071 "HuC Initializer Data buffer");
2072 i965_zero_gpe_resource(&vdenc_context->huc_initializer_data_buffer_res[i]);
2073 }
2074
2075 i965_free_gpe_resource(&vdenc_context->huc_initializer_dys_dmem_buffer_res);
2076 ALLOC_VDENC_BUFFER_RESOURCE(vdenc_context->huc_initializer_dys_dmem_buffer_res,
2077 ALIGN(sizeof(struct huc_initializer_dmem), 64),
2078 "HuC Initializer DYS DMEM buffer");
2079 i965_zero_gpe_resource(&vdenc_context->huc_initializer_dys_dmem_buffer_res);
2080
2081 i965_free_gpe_resource(&vdenc_context->huc_initializer_dys_data_buffer_res);
2082 ALLOC_VDENC_BUFFER_RESOURCE(vdenc_context->huc_initializer_dys_data_buffer_res,
2083 ALIGN(sizeof(struct huc_initializer_data), 0x1000),
2084 "HuC Initializer DYS data buffer");
2085 i965_zero_gpe_resource(&vdenc_context->huc_initializer_dys_data_buffer_res);
2086
2087 if (!vdenc_context->frame_header_data) {
2088 /* allocate 512 bytes for generating the uncompressed header */
2089 vdenc_context->frame_header_data = calloc(1, 512);
2090 }
2091
2092 vdenc_context->res_width = vdenc_context->frame_width;
2093 vdenc_context->res_height = vdenc_context->frame_height;
2094
2095 return VA_STATUS_SUCCESS;
2096
2097 failed_allocation:
2098 return VA_STATUS_ERROR_ALLOCATION_FAILED;
2099 }
2100
2101 static VAStatus
2102 gen10_vdenc_vp9_uncompressed_header(VADriverContextP ctx,
2103 struct encode_state *encode_state,
2104 struct intel_encoder_context *encoder_context)
2105 {
2106 struct gen10_vdenc_vp9_context *vdenc_context = encoder_context->mfc_context;
2107 VAEncPictureParameterBufferVP9 *pic_param;
2108 int driver_header_flag = 1; /* '1' means the driver should generate the uncompressed header */
2109
2110 if (!vdenc_context->pic_param)
2111 return VA_STATUS_ERROR_INVALID_PARAMETER;
2112
2113 pic_param = vdenc_context->pic_param;
2114
2115 if (encode_state->packed_header_data_ext &&
2116 encode_state->packed_header_data_ext[0] &&
2117 pic_param->bit_offset_first_partition_size) {
2118 VAEncPackedHeaderParameterBuffer *param = NULL;
2119
2120 param = (VAEncPackedHeaderParameterBuffer *)encode_state->packed_header_params_ext[0]->buffer;
2121
2122 if (param->type == VAEncPackedHeaderRawData) {
2123 char *header_data;
2124 unsigned int length_in_bits;
2125
2126 header_data = (char *)encode_state->packed_header_data_ext[0]->buffer;
2127 length_in_bits = param->bit_length;
2128 driver_header_flag = 0;
2129
2130 vdenc_context->frame_header.bit_offset_first_partition_size = pic_param->bit_offset_first_partition_size;
2131 vdenc_context->frame_header_length = ALIGN(length_in_bits, 8) >> 3;
2132 vdenc_context->alias_insert_data = header_data;
2133
2134 vdenc_context->frame_header.bit_offset_ref_lf_delta = pic_param->bit_offset_ref_lf_delta;
2135 vdenc_context->frame_header.bit_offset_mode_lf_delta = pic_param->bit_offset_mode_lf_delta;
2136 vdenc_context->frame_header.bit_offset_lf_level = pic_param->bit_offset_lf_level;
2137 vdenc_context->frame_header.bit_offset_qindex = pic_param->bit_offset_qindex;
2138 vdenc_context->frame_header.bit_offset_segmentation = pic_param->bit_offset_segmentation;
2139 vdenc_context->frame_header.bit_size_segmentation = pic_param->bit_size_segmentation;
2140 }
2141 }
2142
2143 if (driver_header_flag) {
2144 memset(&vdenc_context->frame_header, 0, sizeof(vdenc_context->frame_header));
2145 intel_write_uncompressed_header(encode_state,
2146 VAProfileVP9Profile0,
2147 vdenc_context->frame_header_data,
2148 &vdenc_context->frame_header_length,
2149 &vdenc_context->frame_header);
2150 vdenc_context->alias_insert_data = vdenc_context->frame_header_data;
2151 }
2152
2153 return VA_STATUS_SUCCESS;
2154 }
2155
2156 static VAStatus
2157 gen10_vdenc_vp9_check_dys_surfaces(VADriverContextP ctx,
2158 struct object_surface *obj_surface,
2159 uint32_t frame_width,
2160 uint32_t frame_height)
2161 {
2162 struct i965_driver_data *i965 = i965_driver_data(ctx);
2163 struct vdenc_vp9_surface *vdenc_vp9_surface;
2164 int dys_width_4x, dys_height_4x;
2165 int dys_width_8x, dys_height_8x;
2166 int dys_width_16x, dys_height_16x;
2167
2168 /* As this is handled after the surface checking, it is unnecessary
2169 * to check the surface bo and vp9_priv_surface again
2170 */
2171
2172 vdenc_vp9_surface = (struct vdenc_vp9_surface *)(obj_surface->private_data);
2173
2174 if (!vdenc_vp9_surface)
2175 return VA_STATUS_ERROR_INVALID_SURFACE;
2176
2177 /* if the frame_width/height of dys_surface is the same as
2178 * the expected, it is unnecessary to allocate it again
2179 */
2180
2181 if (vdenc_vp9_surface->dys_frame_width == frame_width &&
2182 vdenc_vp9_surface->dys_frame_height == frame_height)
2183 return VA_STATUS_SUCCESS;
2184
2185 if (vdenc_vp9_surface->dys_surface_obj) {
2186 i965_DestroySurfaces(vdenc_vp9_surface->ctx, &vdenc_vp9_surface->dys_surface_id, 1);
2187 vdenc_vp9_surface->dys_surface_id = VA_INVALID_SURFACE;
2188 vdenc_vp9_surface->dys_surface_obj = NULL;
2189 }
2190
2191 if (vdenc_vp9_surface->dys_4x_surface_obj) {
2192 i965_DestroySurfaces(vdenc_vp9_surface->ctx, &vdenc_vp9_surface->dys_4x_surface_id, 1);
2193 vdenc_vp9_surface->dys_4x_surface_id = VA_INVALID_SURFACE;
2194 vdenc_vp9_surface->dys_4x_surface_obj = NULL;
2195 }
2196
2197 if (vdenc_vp9_surface->dys_8x_surface_obj) {
2198 i965_DestroySurfaces(vdenc_vp9_surface->ctx, &vdenc_vp9_surface->dys_8x_surface_id, 1);
2199 vdenc_vp9_surface->dys_8x_surface_id = VA_INVALID_SURFACE;
2200 vdenc_vp9_surface->dys_8x_surface_obj = NULL;
2201 }
2202
2203 i965_CreateSurfaces(ctx,
2204 frame_width,
2205 frame_height,
2206 VA_RT_FORMAT_YUV420,
2207 1,
2208 &vdenc_vp9_surface->dys_surface_id);
2209 vdenc_vp9_surface->dys_surface_obj = SURFACE(vdenc_vp9_surface->dys_surface_id);
2210
2211 if (!vdenc_vp9_surface->dys_surface_obj) {
2212 return VA_STATUS_ERROR_ALLOCATION_FAILED;
2213 }
2214
2215 i965_check_alloc_surface_bo(ctx,
2216 vdenc_vp9_surface->dys_surface_obj,
2217 1,
2218 VA_FOURCC('N', 'V', '1', '2'),
2219 SUBSAMPLE_YUV420);
2220
2221 dys_width_4x = ALIGN(frame_width / 4, 16);
2222 dys_height_4x = ALIGN(frame_height / 4, 16);
2223
2224 i965_CreateSurfaces(ctx,
2225 dys_width_4x,
2226 dys_height_4x,
2227 VA_RT_FORMAT_YUV420,
2228 1,
2229 &vdenc_vp9_surface->dys_4x_surface_id);
2230
2231 vdenc_vp9_surface->dys_4x_surface_obj = SURFACE(vdenc_vp9_surface->dys_4x_surface_id);
2232
2233 if (!vdenc_vp9_surface->dys_4x_surface_obj) {
2234 return VA_STATUS_ERROR_ALLOCATION_FAILED;
2235 }
2236
2237 i965_check_alloc_surface_bo(ctx,
2238 vdenc_vp9_surface->dys_4x_surface_obj,
2239 1,
2240 VA_FOURCC('N', 'V', '1', '2'),
2241 SUBSAMPLE_YUV420);
2242
2243 dys_width_8x = ALIGN(frame_width / 8, 16);
2244 dys_height_8x = ALIGN(frame_height / 8, 16);
2245 i965_CreateSurfaces(ctx,
2246 dys_width_8x,
2247 dys_height_8x,
2248 VA_RT_FORMAT_YUV420,
2249 1,
2250 &vdenc_vp9_surface->dys_8x_surface_id);
2251 vdenc_vp9_surface->dys_8x_surface_obj = SURFACE(vdenc_vp9_surface->dys_8x_surface_id);
2252
2253 if (!vdenc_vp9_surface->dys_8x_surface_obj) {
2254 return VA_STATUS_ERROR_ALLOCATION_FAILED;
2255 }
2256
2257 i965_check_alloc_surface_bo(ctx,
2258 vdenc_vp9_surface->dys_8x_surface_obj,
2259 1,
2260 VA_FOURCC('N', 'V', '1', '2'),
2261 SUBSAMPLE_YUV420);
2262
2263 dys_width_16x = ALIGN(frame_width / 16, 16);
2264 dys_height_16x = ALIGN(frame_height / 16, 16);
2265 i965_CreateSurfaces(ctx,
2266 dys_width_16x,
2267 dys_height_16x,
2268 VA_RT_FORMAT_YUV420,
2269 1,
2270 &vdenc_vp9_surface->dys_16x_surface_id);
2271 vdenc_vp9_surface->dys_16x_surface_obj = SURFACE(vdenc_vp9_surface->dys_16x_surface_id);
2272
2273 if (!vdenc_vp9_surface->dys_16x_surface_obj) {
2274 return VA_STATUS_ERROR_ALLOCATION_FAILED;
2275 }
2276
2277 i965_check_alloc_surface_bo(ctx,
2278 vdenc_vp9_surface->dys_16x_surface_obj,
2279 1,
2280 VA_FOURCC('N', 'V', '1', '2'),
2281 SUBSAMPLE_YUV420);
2282
2283 vdenc_vp9_surface->dys_frame_width = frame_width;
2284 vdenc_vp9_surface->dys_frame_height = frame_height;
2285
2286 return VA_STATUS_SUCCESS;
2287 }
2288
2289 static VAStatus
2290 gen10_vdenc_vp9_prepare(VADriverContextP ctx,
2291 VAProfile profile,
2292 struct encode_state *encode_state,
2293 struct intel_encoder_context *encoder_context)
2294 {
2295 struct i965_driver_data *i965 = i965_driver_data(ctx);
2296 struct gen10_vdenc_vp9_context *vdenc_context = encoder_context->mfc_context;
2297 struct i965_coded_buffer_segment *coded_buffer_segment;
2298 struct object_surface *obj_surface;
2299 struct object_buffer *obj_buffer;
2300 VAStatus va_status;
2301 VAEncPictureParameterBufferVP9 *pic_param = NULL;
2302 VDEncVP9Surface *vdenc_vp9_surface;
2303 dri_bo *bo;
2304 char *pbuffer;
2305
2306 va_status = gen10_vdenc_vp9_update_parameters(ctx, profile, encode_state, encoder_context);
2307
2308 if (va_status != VA_STATUS_SUCCESS)
2309 return va_status;
2310
2311 pic_param = vdenc_context->pic_param;
2312
2313 /* Check reconstructed obj */
2314 obj_surface = encode_state->reconstructed_object;
2315
2316 if (pic_param->frame_width_dst > obj_surface->orig_width ||
2317 pic_param->frame_height_dst > obj_surface->orig_height)
2318 return VA_STATUS_ERROR_INVALID_SURFACE;
2319
2320 if (!vdenc_context->dys_enabled &&
2321 ((pic_param->frame_width_src != pic_param->frame_width_dst) ||
2322 (pic_param->frame_height_src != pic_param->frame_height_dst)))
2323 return VA_STATUS_ERROR_UNIMPLEMENTED; // TODO
2324
2325 i965_check_alloc_surface_bo(ctx, obj_surface, 1, VA_FOURCC_NV12, SUBSAMPLE_YUV420);
2326
2327 if (obj_surface->private_data == NULL) {
2328 vdenc_vp9_surface = calloc(sizeof(VDEncVP9Surface), 1);
2329 assert(vdenc_vp9_surface);
2330
2331 vdenc_vp9_surface->ctx = ctx;
2332 vdenc_vp9_surface->frame_width = vdenc_context->frame_width;
2333 vdenc_vp9_surface->frame_height = vdenc_context->frame_height;
2334
2335 i965_CreateSurfaces(ctx,
2336 vdenc_context->down_scaled_width_4x,
2337 vdenc_context->down_scaled_height_4x,
2338 VA_RT_FORMAT_YUV420,
2339 1,
2340 &vdenc_vp9_surface->scaled_4x_surface_id);
2341 vdenc_vp9_surface->scaled_4x_surface_obj = SURFACE(vdenc_vp9_surface->scaled_4x_surface_id);
2342 assert(vdenc_vp9_surface->scaled_4x_surface_obj);
2343 i965_check_alloc_surface_bo(ctx,
2344 vdenc_vp9_surface->scaled_4x_surface_obj,
2345 1,
2346 VA_FOURCC_NV12,
2347 SUBSAMPLE_YUV420);
2348
2349 i965_CreateSurfaces(ctx,
2350 vdenc_context->down_scaled_width_4x >> 1,
2351 vdenc_context->down_scaled_height_4x >> 1,
2352 VA_RT_FORMAT_YUV420,
2353 1,
2354 &vdenc_vp9_surface->scaled_8x_surface_id);
2355 vdenc_vp9_surface->scaled_8x_surface_obj = SURFACE(vdenc_vp9_surface->scaled_8x_surface_id);
2356 assert(vdenc_vp9_surface->scaled_8x_surface_obj);
2357 i965_check_alloc_surface_bo(ctx,
2358 vdenc_vp9_surface->scaled_8x_surface_obj,
2359 1,
2360 VA_FOURCC_NV12,
2361 SUBSAMPLE_YUV420);
2362
2363 i965_CreateSurfaces(ctx,
2364 vdenc_context->down_scaled_width_4x >> 2,
2365 vdenc_context->down_scaled_height_4x >> 2,
2366 VA_RT_FORMAT_YUV420,
2367 1,
2368 &vdenc_vp9_surface->scaled_16x_surface_id);
2369 vdenc_vp9_surface->scaled_16x_surface_obj = SURFACE(vdenc_vp9_surface->scaled_16x_surface_id);
2370 assert(vdenc_vp9_surface->scaled_16x_surface_obj);
2371 i965_check_alloc_surface_bo(ctx,
2372 vdenc_vp9_surface->scaled_16x_surface_obj,
2373 1,
2374 VA_FOURCC_NV12,
2375 SUBSAMPLE_YUV420);
2376
2377 obj_surface->private_data = (void *)vdenc_vp9_surface;
2378 obj_surface->free_private_data = (void *)vdenc_free_vp9_surface;
2379 }
2380
2381 vdenc_vp9_surface = (VDEncVP9Surface *)obj_surface->private_data;
2382 assert(vdenc_vp9_surface->scaled_4x_surface_obj);
2383 assert(vdenc_vp9_surface->scaled_8x_surface_obj);
2384 assert(vdenc_vp9_surface->scaled_16x_surface_obj);
2385
2386 /* Check dys object */
2387 if (vdenc_context->dys_in_use &&
2388 (pic_param->frame_width_src != pic_param->frame_width_dst ||
2389 pic_param->frame_height_src != pic_param->frame_height_dst)) {
2390 va_status = gen10_vdenc_vp9_check_dys_surfaces(ctx,
2391 encode_state->reconstructed_object,
2392 pic_param->frame_width_dst,
2393 pic_param->frame_height_dst);
2394
2395 if (va_status)
2396 return va_status;
2397 }
2398
2399 if ((vdenc_context->dys_ref_frame_flag & VP9_REF_LAST) && vdenc_context->last_ref_obj) {
2400 va_status = gen10_vdenc_vp9_check_dys_surfaces(ctx,
2401 vdenc_context->last_ref_obj,
2402 vdenc_context->frame_width,
2403 vdenc_context->frame_height);
2404
2405 if (va_status)
2406 return va_status;
2407 }
2408
2409 if ((vdenc_context->dys_ref_frame_flag & VP9_REF_GOLDEN) && vdenc_context->golden_ref_obj) {
2410 va_status = gen10_vdenc_vp9_check_dys_surfaces(ctx,
2411 vdenc_context->golden_ref_obj,
2412 vdenc_context->frame_width,
2413 vdenc_context->frame_height);
2414
2415 if (va_status)
2416 return va_status;
2417 }
2418
2419 if ((vdenc_context->dys_ref_frame_flag & VP9_REF_ALT) && vdenc_context->alt_ref_obj) {
2420 va_status = gen10_vdenc_vp9_check_dys_surfaces(ctx,
2421 vdenc_context->alt_ref_obj,
2422 vdenc_context->frame_width,
2423 vdenc_context->frame_height);
2424
2425 if (va_status)
2426 return va_status;
2427 }
2428
2429 /* Reconstructed res */
2430 i965_free_gpe_resource(&vdenc_context->recon_surface_res);
2431 i965_free_gpe_resource(&vdenc_context->scaled_4x_recon_surface_res);
2432 i965_free_gpe_resource(&vdenc_context->scaled_8x_recon_surface_res);
2433 i965_free_gpe_resource(&vdenc_context->scaled_16x_recon_surface_res);
2434 i965_object_surface_to_2d_gpe_resource(&vdenc_context->recon_surface_res, obj_surface);
2435 i965_object_surface_to_2d_gpe_resource(&vdenc_context->scaled_4x_recon_surface_res, vdenc_vp9_surface->scaled_4x_surface_obj);
2436 i965_object_surface_to_2d_gpe_resource(&vdenc_context->scaled_8x_recon_surface_res, vdenc_vp9_surface->scaled_8x_surface_obj);
2437 i965_object_surface_to_2d_gpe_resource(&vdenc_context->scaled_16x_recon_surface_res, vdenc_vp9_surface->scaled_16x_surface_obj);
2438
2439 /* Reference res */
2440 i965_free_gpe_resource(&vdenc_context->last_ref_res);
2441 i965_free_gpe_resource(&vdenc_context->golden_ref_res);
2442 i965_free_gpe_resource(&vdenc_context->alt_ref_res);
2443
2444 if (vdenc_context->last_ref_obj) {
2445 if (vdenc_context->dys_ref_frame_flag & VP9_REF_LAST) {
2446 assert(vdenc_context->last_ref_obj->private_data);
2447 vdenc_vp9_surface = (struct vdenc_vp9_surface *)vdenc_context->last_ref_obj->private_data;
2448 obj_surface = vdenc_vp9_surface->dys_surface_obj;
2449 assert(obj_surface);
2450 } else
2451 obj_surface = vdenc_context->last_ref_obj;
2452
2453 i965_object_surface_to_2d_gpe_resource(&vdenc_context->last_ref_res, obj_surface);
2454 }
2455
2456 if (vdenc_context->golden_ref_obj) {
2457 if (vdenc_context->dys_ref_frame_flag & VP9_REF_GOLDEN) {
2458 assert(vdenc_context->golden_ref_obj->private_data);
2459 vdenc_vp9_surface = (struct vdenc_vp9_surface *)vdenc_context->golden_ref_obj->private_data;
2460 obj_surface = vdenc_vp9_surface->dys_surface_obj;
2461 assert(obj_surface);
2462 } else
2463 obj_surface = vdenc_context->golden_ref_obj;
2464
2465 i965_object_surface_to_2d_gpe_resource(&vdenc_context->golden_ref_res, obj_surface);
2466 }
2467
2468 if (vdenc_context->alt_ref_obj) {
2469 if (vdenc_context->dys_ref_frame_flag & VP9_REF_ALT) {
2470 assert(vdenc_context->alt_ref_obj->private_data);
2471 vdenc_vp9_surface = (struct vdenc_vp9_surface *)vdenc_context->alt_ref_obj->private_data;
2472 obj_surface = vdenc_vp9_surface->dys_surface_obj;
2473 assert(obj_surface);
2474 } else
2475 obj_surface = vdenc_context->alt_ref_obj;
2476
2477 i965_object_surface_to_2d_gpe_resource(&vdenc_context->alt_ref_res, obj_surface);
2478 }
2479
2480 /* Input YUV res */
2481 i965_free_gpe_resource(&vdenc_context->uncompressed_input_yuv_surface_res);
2482
2483 if (vdenc_context->dys_in_use &&
2484 ((pic_param->frame_width_src != pic_param->frame_width_dst) ||
2485 (pic_param->frame_height_src != pic_param->frame_height_dst))) {
2486 assert(encode_state->reconstructed_object && encode_state->reconstructed_object->private_data);
2487 vdenc_vp9_surface = (struct vdenc_vp9_surface *)encode_state->reconstructed_object->private_data;
2488 obj_surface = vdenc_vp9_surface->dys_surface_obj;
2489 assert(obj_surface);
2490 } else {
2491 obj_surface = encode_state->input_yuv_object;
2492 }
2493
2494 i965_object_surface_to_2d_gpe_resource(&vdenc_context->uncompressed_input_yuv_surface_res, obj_surface);
2495
2496 /* Encoded bitstream */
2497 obj_buffer = encode_state->coded_buf_object;
2498 bo = obj_buffer->buffer_store->bo;
2499 i965_free_gpe_resource(&vdenc_context->compressed_bitstream.res);
2500 i965_dri_object_to_buffer_gpe_resource(&vdenc_context->compressed_bitstream.res, bo);
2501 vdenc_context->compressed_bitstream.start_offset = I965_CODEDBUFFER_HEADER_SIZE;
2502 vdenc_context->compressed_bitstream.end_offset = ALIGN(obj_buffer->size_element - 0x1000, 0x1000);
2503
2504 /* Status buffer */
2505 i965_free_gpe_resource(&vdenc_context->status_bffuer.res);
2506 i965_dri_object_to_buffer_gpe_resource(&vdenc_context->status_bffuer.res, bo);
2507 vdenc_context->status_bffuer.base_offset = offsetof(struct i965_coded_buffer_segment, codec_private_data);
2508 vdenc_context->status_bffuer.size = ALIGN(sizeof(struct gen10_vdenc_vp9_status), 64);
2509 vdenc_context->status_bffuer.bytes_per_frame_offset = offsetof(struct gen10_vdenc_vp9_status, bytes_per_frame);
2510 assert(vdenc_context->status_bffuer.base_offset + vdenc_context->status_bffuer.size <
2511 vdenc_context->compressed_bitstream.start_offset);
2512
2513 dri_bo_map(bo, 1);
2514
2515 coded_buffer_segment = (struct i965_coded_buffer_segment *)bo->virtual;
2516 coded_buffer_segment->mapped = 0;
2517 coded_buffer_segment->codec = encoder_context->codec;
2518 coded_buffer_segment->status_support = 1;
2519
2520 pbuffer = bo->virtual;
2521 pbuffer += vdenc_context->status_bffuer.base_offset;
2522 memset(pbuffer, 0, vdenc_context->status_bffuer.size);
2523
2524 dri_bo_unmap(bo);
2525
2526 va_status = gen10_vdenc_vp9_allocate_resources(ctx, encode_state, encoder_context);
2527
2528 if (va_status != VA_STATUS_SUCCESS)
2529 return va_status;
2530
2531 gen10_vdenc_vp9_uncompressed_header(ctx, encode_state, encoder_context);
2532 gen10_vdenc_vp9_gpe_kernel_init(ctx, encode_state, encoder_context);
2533 gen10_vdenc_vp9_dys_src_frame(ctx, encode_state, encoder_context);
2534 gen10_vdenc_vp9_update_streamin_state(ctx, encoder_context);
2535
2536 return VA_STATUS_SUCCESS;
2537 }
2538
2539 static void
2540 gen10_vdenc_vp9_huc_store_huc_status2(VADriverContextP ctx,
2541 struct intel_encoder_context *encoder_context)
2542 {
2543 struct gen10_vdenc_vp9_context *vdenc_context = encoder_context->mfc_context;
2544 struct intel_batchbuffer *batch = encoder_context->base.batch;
2545 struct gpe_mi_store_register_mem_parameter mi_store_register_mem_params;
2546 struct gpe_mi_store_data_imm_parameter mi_store_data_imm_params;
2547 struct i965_gpe_table *gpe = vdenc_context->gpe_table;
2548
2549 /* Write HUC_STATUS2 mask (1 << 6) */
2550 memset(&mi_store_data_imm_params, 0, sizeof(mi_store_data_imm_params));
2551 mi_store_data_imm_params.bo = vdenc_context->huc_status2_buffer_res.bo;
2552 mi_store_data_imm_params.offset = 0;
2553 mi_store_data_imm_params.dw0 = (1 << 6);
2554 gpe->mi_store_data_imm(ctx, batch, &mi_store_data_imm_params);
2555
2556 /* Store HUC_STATUS2 */
2557 memset(&mi_store_register_mem_params, 0, sizeof(mi_store_register_mem_params));
2558 mi_store_register_mem_params.mmio_offset = VCS0_HUC_STATUS2;
2559 mi_store_register_mem_params.bo = vdenc_context->huc_status2_buffer_res.bo;
2560 mi_store_register_mem_params.offset = 4;
2561 gpe->mi_store_register_mem(ctx, batch, &mi_store_register_mem_params);
2562 }
2563
2564 static VAStatus
2565 gen10_vdenc_vp9_calculate_initial_qp(VADriverContextP ctx,
2566 struct encode_state *encode_state,
2567 struct intel_encoder_context *encoder_context,
2568 unsigned int *init_qp_i,
2569 unsigned int *init_qp_p)
2570 {
2571 struct gen10_vdenc_vp9_context *vdenc_context = encoder_context->mfc_context;
2572 VAEncSequenceParameterBufferVP9 *seq_param = vdenc_context->seq_param;
2573 float x0 = 0, y0 = 1.19f, x1 = 1.75f, y1 = 1.75f;
2574 unsigned frame_size;
2575 int qp_i, qp_p, delat_qp;
2576
2577 frame_size = (vdenc_context->frame_width * vdenc_context->frame_height * 3 / 2);
2578 qp_p = (int)(1.0 / 1.2 * pow(10.0,
2579 (log10(frame_size * 2.0 / 3.0 * vdenc_context->framerate.num /
2580 ((double)vdenc_context->target_bit_rate * vdenc_context->framerate.den)) - x0) *
2581 (y1 - y0) / (x1 - x0) + y0) + 0.5);
2582 qp_p = qp_p * 5;
2583 qp_p -= 20;
2584 qp_p = CLAMP(1, 200, qp_p);
2585 qp_i = (qp_p > 4) ? (qp_p - 4) : qp_p;
2586 delat_qp = (seq_param->intra_period - 1) / 30 - 1;
2587 delat_qp = CLAMP(0, 20, delat_qp);
2588 qp_i -= delat_qp;
2589 qp_i = CLAMP(1, 200, qp_i);
2590 qp_p = qp_i + 20;
2591
2592 *init_qp_i = qp_i;
2593 *init_qp_p = qp_p;
2594
2595 return VA_STATUS_SUCCESS;
2596 }
2597
2598 static void
2599 gen10_vdenc_vp9_update_huc_brc_init_dmem(VADriverContextP ctx,
2600 struct encode_state *encode_state,
2601 struct intel_encoder_context *encoder_context)
2602 {
2603 struct gen10_vdenc_vp9_context *vdenc_context = encoder_context->mfc_context;
2604 struct vdenc_vp9_huc_brc_init_dmem *dmem;
2605 VAEncSequenceParameterBufferVP9 *seq_param = vdenc_context->seq_param;
2606 unsigned int seq_max_frame_size, qp_i = 20, qp_p = 20;
2607 double input_bits_per_frame, bps_ratio;
2608 int i;
2609
2610 if (!seq_param)
2611 return;
2612
2613 seq_max_frame_size = seq_param->max_frame_width * seq_param->max_frame_height;
2614
2615 assert(sizeof(*dmem) == sizeof(vdenc_vp9_huc_brc_init_dmem_data));
2616 dmem = (struct vdenc_vp9_huc_brc_init_dmem *)i965_map_gpe_resource(&vdenc_context->vdenc_brc_init_reset_dmem_buffer_res);
2617
2618 if (!dmem)
2619 return;
2620
2621 memcpy(dmem, vdenc_vp9_huc_brc_init_dmem_data, sizeof(*dmem));
2622
2623 dmem->brc_func = vdenc_context->brc_initted ? 2 : 0;
2624 dmem->profile_level_max_frame = vdenc_context->max_frame_width * vdenc_context->max_frame_height;
2625
2626 if (seq_max_frame_size)
2627 dmem->profile_level_max_frame = MIN(dmem->profile_level_max_frame, seq_max_frame_size);
2628
2629 dmem->buffer_size = vdenc_context->vbv_buffer_size_in_bit;
2630 dmem->init_buffer_fullness = vdenc_context->init_vbv_buffer_fullness_in_bit;
2631 dmem->target_bitrate = vdenc_context->target_bit_rate;
2632 dmem->max_rate = vdenc_context->max_bit_rate;
2633 dmem->frame_rate_m = vdenc_context->framerate.num;
2634 dmem->frame_rate_d = vdenc_context->framerate.den;
2635
2636 if (vdenc_context->internal_rate_mode == I965_BRC_CBR) {
2637 dmem->brc_flag = 0x10;
2638 dmem->max_rate = dmem->target_bitrate;
2639 } else if (vdenc_context->internal_rate_mode == I965_BRC_VBR)
2640 dmem->brc_flag = 0x20;
2641
2642 if (dmem->max_rate < dmem->target_bitrate)
2643 dmem->max_rate = (dmem->target_bitrate << 1);
2644
2645 dmem->num_p_in_gop = seq_param->intra_period - 1;
2646 dmem->frame_width = vdenc_context->frame_width;
2647 dmem->frame_height = vdenc_context->frame_height;
2648 dmem->min_qp = 0;
2649 dmem->max_qp = 255;
2650 dmem->enable_scaling = vdenc_context->dys_in_use;
2651
2652 assert(ARRAY_ELEMS(dmem->inst_rate_thresh_i0) == ARRAY_ELEMS(dmem->inst_rate_thresh_p0));
2653 assert(ARRAY_ELEMS(dmem->inst_rate_thresh_i0) == ARRAY_ELEMS(vdenc_vp9_huc_inst_rate_thresh_i));
2654 assert(ARRAY_ELEMS(dmem->inst_rate_thresh_i0) == ARRAY_ELEMS(vdenc_vp9_huc_inst_rate_thresh_p));
2655 for (i = 0; i < ARRAY_ELEMS(dmem->inst_rate_thresh_i0); i++) {
2656 dmem->inst_rate_thresh_i0[i] = vdenc_vp9_huc_inst_rate_thresh_i[i];
2657 dmem->inst_rate_thresh_p0[i] = vdenc_vp9_huc_inst_rate_thresh_p[i];
2658 }
2659
2660 input_bits_per_frame = ((double)dmem->max_rate * (double)dmem->frame_rate_d) / (double)dmem->frame_rate_m;
2661
2662 if (dmem->buffer_size < (uint32_t)(input_bits_per_frame * 4))
2663 dmem->buffer_size = (uint32_t)(input_bits_per_frame * 4);
2664
2665 if (dmem->init_buffer_fullness == 0)
2666 dmem->init_buffer_fullness = 7 * dmem->buffer_size / 8;
2667
2668 if (dmem->init_buffer_fullness < (uint32_t)(input_bits_per_frame * 2))
2669 dmem->init_buffer_fullness = (uint32_t)(input_bits_per_frame * 2);
2670
2671 if (dmem->init_buffer_fullness > dmem->buffer_size)
2672 dmem->init_buffer_fullness = dmem->buffer_size;
2673
2674 bps_ratio = input_bits_per_frame /
2675 ((double)vdenc_context->vbv_buffer_size_in_bit * vdenc_context->framerate.den / vdenc_context->framerate.num);
2676
2677 if (bps_ratio < 0.1)
2678 bps_ratio = 0.1;
2679
2680 if (bps_ratio > 3.5)
2681 bps_ratio = 3.5;
2682
2683 for (i = 0; i < 4; i++) {
2684 dmem->dev_thresh_pb0[i] = (char)(-50 * pow(vdenc_brc_dev_threshpb0_fp_neg[i], bps_ratio));
2685 dmem->dev_thresh_pb0[i + 4] = (char)(50 * pow(vdenc_brc_dev_threshpb0_fp_pos[i], bps_ratio));
2686
2687 dmem->dev_thresh_i0[i] = (char)(-50 * pow(vdenc_brc_dev_threshi0_fp_neg[i], bps_ratio));
2688 dmem->dev_thresh_i0[i + 4] = (char)(50 * pow(vdenc_brc_dev_threshi0_fp_pos[i], bps_ratio));
2689
2690 dmem->dev_thresh_vbr0[i] = (char)(-50 * pow(vdenc_brc_dev_threshvbr0_neg[i], bps_ratio));
2691 dmem->dev_thresh_vbr0[i + 4] = (char)(100 * pow(vdenc_brc_dev_threshvbr0_pos[i], bps_ratio));
2692 }
2693
2694 gen10_vdenc_vp9_calculate_initial_qp(ctx, encode_state, encoder_context, &qp_i, &qp_p);
2695
2696 dmem->init_qp_i = qp_i;
2697 dmem->init_qp_p = qp_p;
2698
2699 dmem->total_level = 1; // TODO for temporal
2700
2701 i965_unmap_gpe_resource(&vdenc_context->vdenc_brc_init_reset_dmem_buffer_res);
2702
2703 vdenc_context->input_bits_per_frame =
2704 ((double)vdenc_context->max_bit_rate * vdenc_context->framerate.den) / vdenc_context->framerate.num;
2705 vdenc_context->current_target_buf_full_in_bits = vdenc_context->target_bit_rate;
2706 }
2707
2708 static void
2709 gen10_vdenc_vp9_huc_brc_init_reset(VADriverContextP ctx,
2710 struct encode_state *encode_state,
2711 struct intel_encoder_context *encoder_context)
2712 {
2713 struct intel_batchbuffer *batch = encoder_context->base.batch;
2714 struct gen10_vdenc_vp9_context *vdenc_context = encoder_context->mfc_context;
2715 struct gen10_huc_pipe_mode_select_parameter pipe_mode_select_params;
2716 struct gen10_huc_imem_state_parameter imem_state_params;
2717 struct gen10_huc_dmem_state_parameter dmem_state_params;
2718 struct gen10_huc_virtual_addr_parameter virtual_addr_params;
2719 struct gen10_huc_start_parameter start_params;
2720 struct gpe_mi_flush_dw_parameter mi_flush_dw_params;
2721 struct i965_gpe_table *gpe = vdenc_context->gpe_table;
2722 gen10_vdenc_vd_pipeline_flush_param pipeline_flush_params;
2723
2724 memset(&imem_state_params, 0, sizeof(imem_state_params));
2725 imem_state_params.huc_firmware_descriptor = VDENC_VP9_HUC_BRC_INIT_RESET;
2726 gen10_huc_imem_state(ctx, batch, &imem_state_params);
2727
2728 memset(&pipe_mode_select_params, 0, sizeof(pipe_mode_select_params));
2729 gen10_huc_pipe_mode_select(ctx, batch, &pipe_mode_select_params);
2730
2731 gen10_vdenc_vp9_update_huc_brc_init_dmem(ctx, encode_state, encoder_context);
2732 memset(&dmem_state_params, 0, sizeof(dmem_state_params));
2733 dmem_state_params.huc_data_source_res = &vdenc_context->vdenc_brc_init_reset_dmem_buffer_res;
2734 dmem_state_params.huc_data_destination_base_address = VDENC_VP9_HUC_DMEM_DATA_OFFSET;
2735 dmem_state_params.huc_data_length = ALIGN(sizeof(struct vdenc_vp9_huc_brc_init_dmem), 64);
2736 gen10_huc_dmem_state(ctx, batch, &dmem_state_params);
2737
2738 memset(&virtual_addr_params, 0, sizeof(virtual_addr_params));
2739 virtual_addr_params.regions[0].huc_surface_res = &vdenc_context->brc_history_buffer_res;
2740 virtual_addr_params.regions[0].is_target = 1;
2741 gen10_huc_virtual_addr_state(ctx, batch, &virtual_addr_params);
2742
2743 gen10_vdenc_vp9_huc_store_huc_status2(ctx, encoder_context);
2744
2745 memset(&start_params, 0, sizeof(start_params));
2746 start_params.last_stream_object = 1;
2747 gen10_huc_start(ctx, batch, &start_params);
2748
2749 memset(&pipeline_flush_params, 0, sizeof(pipeline_flush_params));
2750 pipeline_flush_params.dw1.hevc_pipeline_done = 1;
2751 pipeline_flush_params.dw1.hevc_pipeline_flush = 1;
2752 gen10_vdenc_vd_pipeline_flush(ctx, batch, &pipeline_flush_params);
2753
2754 memset(&mi_flush_dw_params, 0, sizeof(mi_flush_dw_params));
2755 mi_flush_dw_params.video_pipeline_cache_invalidate = 1;
2756 gpe->mi_flush_dw(ctx, batch, &mi_flush_dw_params);
2757 }
2758
2759 static void
2760 gen10_vdenc_vp9_update_huc_update_dmem(VADriverContextP ctx, struct intel_encoder_context *encoder_context)
2761 {
2762 struct gen10_vdenc_vp9_context *vdenc_context = encoder_context->mfc_context;
2763 VAEncPictureParameterBufferVP9 *pic_param;
2764 struct vdenc_vp9_huc_brc_update_dmem *dmem;
2765
2766 if (!vdenc_context->pic_param)
2767 return;
2768
2769 pic_param = vdenc_context->pic_param;
2770
2771 dmem = (struct vdenc_vp9_huc_brc_update_dmem *)i965_map_gpe_resource(&vdenc_context->vdenc_brc_update_dmem_buffer_res[vdenc_context->current_pass]);
2772
2773 if (!dmem)
2774 return;
2775
2776 assert(sizeof(struct vdenc_vp9_huc_brc_update_dmem) == sizeof(vdenc_vp9_huc_brc_update_dmem_data));
2777 memcpy(dmem, vdenc_vp9_huc_brc_update_dmem_data, sizeof(struct vdenc_vp9_huc_brc_update_dmem));
2778
2779 if (vdenc_context->current_target_buf_full_in_bits > vdenc_context->vbv_buffer_size_in_bit) {
2780 dmem->overflow_flag = 1;
2781 vdenc_context->current_target_buf_full_in_bits -= vdenc_context->vbv_buffer_size_in_bit;
2782 }
2783
2784 if (vdenc_context->current_pass == 0) {
2785 dmem->target_buf_fullness = vdenc_context->current_target_buf_full_in_bits;
2786 }
2787
2788 dmem->frame_num = vdenc_context->frame_number;
2789 dmem->temporal_level = 0; // TODO
2790 dmem->hrd_buffer_fullness_upper = 0;
2791 dmem->hrd_buffer_fullness_lower = 0;
2792
2793 dmem->cur_width = vdenc_context->frame_width;
2794 dmem->cur_height = vdenc_context->frame_height;
2795 dmem->current_frame_type = vdenc_context->is_key_frame ? 2 : 0;
2796
2797 dmem->max_num_paks = vdenc_context->num_passes - 1; // no update for repak
2798 dmem->current_pak_pass = vdenc_context->current_pass;
2799
2800 dmem->vdenc_igs_offset = vdenc_context->cmd1_state_offset_in_2nd_batchbuffer;
2801 dmem->second_level_batchbuffer_size = vdenc_context->huc_2nd_batchbuffer_size;
2802 dmem->pic_state_offset = vdenc_context->pic_state_offset_in_2nd_batchbuffer;
2803
2804 dmem->acq_qp = pic_param->luma_ac_qindex;
2805 dmem->segment_map_generating = !!vdenc_context->segment_param;
2806
2807 dmem->delta_qp_for_sad_zone0 = -5;
2808 dmem->delta_qp_for_sad_zone1 = -1;
2809 dmem->delta_qp_for_sad_zone2 = 1;
2810 dmem->delta_qp_for_sad_zone3 = 5;
2811 dmem->delta_qp_for_mv_zero = -5;
2812 dmem->delta_qp_for_mv_zone0 = -2;
2813 dmem->delta_qp_for_mv_zone1 = 1;
2814 dmem->delta_qp_for_mv_zone2 = 5;
2815
2816 i965_unmap_gpe_resource(&vdenc_context->vdenc_brc_update_dmem_buffer_res[vdenc_context->current_pass]);
2817 }
2818
2819 static void
2820 gen10_vdenc_vp9_huc_brc_update_constant_data(VADriverContextP ctx,
2821 struct encode_state *encode_state,
2822 struct intel_encoder_context *encoder_context)
2823 {
2824 struct gen10_vdenc_vp9_context *vdenc_context = encoder_context->mfc_context;
2825 struct huc_brc_update_constant_data *brc_buffer;
2826
2827 brc_buffer = (struct huc_brc_update_constant_data *)i965_map_gpe_resource(&vdenc_context->brc_constant_data_buffer_res);
2828
2829 if (!brc_buffer)
2830 return;
2831
2832 assert(sizeof(vdenc_vp9_huc_brc_constant_data[0]) == VDENC_VP9_BRC_CONSTANT_DATA_SIZE);
2833 memcpy(brc_buffer, vdenc_vp9_huc_brc_constant_data[!vdenc_context->is_key_frame], VDENC_VP9_BRC_CONSTANT_DATA_SIZE);
2834
2835 i965_unmap_gpe_resource(&vdenc_context->brc_constant_data_buffer_res);
2836 }
2837
2838 static void
2839 gen10_vdenc_vp9_huc_brc_update(VADriverContextP ctx,
2840 struct encode_state *encode_state,
2841 struct intel_encoder_context *encoder_context)
2842 {
2843 struct intel_batchbuffer *batch = encoder_context->base.batch;
2844 struct gen10_vdenc_vp9_context *vdenc_context = encoder_context->mfc_context;
2845 struct gen10_huc_pipe_mode_select_parameter pipe_mode_select_params;
2846 struct gen10_huc_imem_state_parameter imem_state_params;
2847 struct gen10_huc_dmem_state_parameter dmem_state_params;
2848 struct gen10_huc_virtual_addr_parameter virtual_addr_params;
2849 struct gen10_huc_start_parameter start_params;
2850 struct gpe_mi_flush_dw_parameter mi_flush_dw_params;
2851 struct i965_gpe_table *gpe = vdenc_context->gpe_table;
2852 gen10_vdenc_vd_pipeline_flush_param pipeline_flush_params;
2853
2854 gen10_vdenc_vp9_huc_brc_update_constant_data(ctx, encode_state, encoder_context);
2855
2856 memset(&imem_state_params, 0, sizeof(imem_state_params));
2857 imem_state_params.huc_firmware_descriptor = VDENC_VP9_HUC_BRC_UPDATE;
2858 gen10_huc_imem_state(ctx, batch, &imem_state_params);
2859
2860 memset(&pipe_mode_select_params, 0, sizeof(pipe_mode_select_params));
2861 gen10_huc_pipe_mode_select(ctx, batch, &pipe_mode_select_params);
2862
2863 gen10_vdenc_vp9_update_huc_update_dmem(ctx, encoder_context);
2864
2865 memset(&dmem_state_params, 0, sizeof(dmem_state_params));
2866 dmem_state_params.huc_data_source_res = &vdenc_context->vdenc_brc_update_dmem_buffer_res[vdenc_context->current_pass];
2867 dmem_state_params.huc_data_destination_base_address = VDENC_VP9_HUC_DMEM_DATA_OFFSET;
2868 dmem_state_params.huc_data_length = ALIGN(sizeof(struct vdenc_vp9_huc_brc_update_dmem), 64);
2869 gen10_huc_dmem_state(ctx, batch, &dmem_state_params);
2870
2871 memset(&virtual_addr_params, 0, sizeof(virtual_addr_params));
2872 virtual_addr_params.regions[0].huc_surface_res = &vdenc_context->brc_history_buffer_res;
2873 virtual_addr_params.regions[0].is_target = 1;
2874 virtual_addr_params.regions[1].huc_surface_res = &vdenc_context->vdenc_brc_stat_buffer_res;
2875 virtual_addr_params.regions[2].huc_surface_res = &vdenc_context->vdenc_brc_pak_stat_buffer_res;
2876 virtual_addr_params.regions[3].huc_surface_res = &vdenc_context->vdenc_pic_state_input_2nd_batchbuffer_res[vdenc_context->current_pass];
2877 virtual_addr_params.regions[4].huc_surface_res = &vdenc_context->brc_huc_data_buffer_res;
2878 virtual_addr_params.regions[4].is_target = 1;
2879 virtual_addr_params.regions[5].huc_surface_res = &vdenc_context->brc_constant_data_buffer_res;
2880 virtual_addr_params.regions[6].huc_surface_res = &vdenc_context->vdenc_pic_state_output_2nd_batchbuffer_res[0]; // the first for non-tile clip
2881 virtual_addr_params.regions[6].is_target = 1;
2882 virtual_addr_params.regions[7].huc_surface_res = &vdenc_context->brc_bitstream_size_buffer_res;
2883 gen10_huc_virtual_addr_state(ctx, batch, &virtual_addr_params);
2884
2885 gen10_vdenc_vp9_huc_store_huc_status2(ctx, encoder_context);
2886
2887 memset(&start_params, 0, sizeof(start_params));
2888 start_params.last_stream_object = 1;
2889 gen10_huc_start(ctx, batch, &start_params);
2890
2891 memset(&pipeline_flush_params, 0, sizeof(pipeline_flush_params));
2892 pipeline_flush_params.dw1.hevc_pipeline_done = 1;
2893 pipeline_flush_params.dw1.hevc_pipeline_flush = 1;
2894 gen10_vdenc_vd_pipeline_flush(ctx, batch, &pipeline_flush_params);
2895
2896 memset(&mi_flush_dw_params, 0, sizeof(mi_flush_dw_params));
2897 mi_flush_dw_params.video_pipeline_cache_invalidate = 1;
2898 gpe->mi_flush_dw(ctx, batch, &mi_flush_dw_params);
2899
2900 #if 0
2901 /* Store HUC_STATUS */
2902 memset(&mi_store_register_mem_params, 0, sizeof(mi_store_register_mem_params));
2903 mi_store_register_mem_params.mmio_offset = VCS0_HUC_STATUS;
2904 mi_store_register_mem_params.bo = vdenc_context->huc_status_buffer_res.bo;
2905 gpe->mi_store_register_mem(ctx, batch, &mi_store_register_mem_params);
2906
2907 /* Write HUC_STATUS mask (1 << 31) */
2908 memset(&mi_store_data_imm_params, 0, sizeof(mi_store_data_imm_params));
2909 mi_store_data_imm_params.bo = vdenc_context->huc_status_buffer_res.bo;
2910 mi_store_data_imm_params.offset = 4;
2911 mi_store_data_imm_params.dw0 = (1 << 31);
2912 gpe->mi_store_data_imm(ctx, batch, &mi_store_data_imm_params);
2913 #endif
2914
2915 if (vdenc_context->current_pass == 0) {
2916 vdenc_context->current_target_buf_full_in_bits += vdenc_context->input_bits_per_frame;
2917 }
2918 }
2919
2920 static void
2921 gen10_vdenc_mfx_wait(VADriverContextP ctx,
2922 struct encode_state *encode_state,
2923 struct intel_encoder_context *encoder_context)
2924 {
2925 struct intel_batchbuffer *batch = encoder_context->base.batch;
2926
2927 BEGIN_BCS_BATCH(batch, 1);
2928
2929 OUT_BCS_BATCH(batch, MFX_WAIT);
2930
2931 ADVANCE_BCS_BATCH(batch);
2932 }
2933
2934 static void
2935 gen10_vdenc_vp9_hcp_pipe_mode_select(VADriverContextP ctx,
2936 struct encode_state *encode_state,
2937 struct intel_encoder_context *encoder_context)
2938 {
2939 struct gen10_vdenc_vp9_context *vdenc_context = encoder_context->mfc_context;
2940 struct intel_batchbuffer *batch = encoder_context->base.batch;
2941
2942 BEGIN_BCS_BATCH(batch, 6);
2943
2944 OUT_BCS_BATCH(batch, HCP_PIPE_MODE_SELECT | (6 - 2));
2945 OUT_BCS_BATCH(batch,
2946 (!!vdenc_context->brc_enabled << 12) | // Frame level
2947 (1 << 10) |
2948 (HCP_CODEC_VP9 << 5) |
2949 (0 << 3) | /* disable Pic Status / Error Report */
2950 (!!vdenc_context->brc_enabled << 2) | // Pipeline
2951 HCP_CODEC_SELECT_ENCODE);
2952 OUT_BCS_BATCH(batch, 0);
2953 OUT_BCS_BATCH(batch, 0);
2954 OUT_BCS_BATCH(batch, 0);
2955 // OUT_BCS_BATCH(batch, (1 << 6)); // TODO check it later
2956 OUT_BCS_BATCH(batch, 0);
2957
2958 ADVANCE_BCS_BATCH(batch);
2959 }
2960
2961 static void
2962 gen10_vdenc_vp9_hcp_surface_state(VADriverContextP ctx,
2963 struct intel_encoder_context *encoder_context,
2964 struct i965_gpe_resource *gpe_resource,
2965 int id)
2966 {
2967 struct intel_batchbuffer *batch = encoder_context->base.batch;
2968
2969 if (!gpe_resource->bo)
2970 return;
2971
2972 BEGIN_BCS_BATCH(batch, 3);
2973 OUT_BCS_BATCH(batch, HCP_SURFACE_STATE | (3 - 2));
2974 OUT_BCS_BATCH(batch,
2975 (id << 28) |
2976 (gpe_resource->pitch - 1));
2977 OUT_BCS_BATCH(batch,
2978 (SURFACE_FORMAT_PLANAR_420_8 << 28) |
2979 (gpe_resource->y_cb_offset));
2980 ADVANCE_BCS_BATCH(batch);
2981 }
2982
2983 static void
2984 gen10_vdenc_vp9_hcp_pipe_buf_addr_state(VADriverContextP ctx,
2985 struct encode_state *encode_state,
2986 struct intel_encoder_context *encoder_context)
2987 {
2988 struct i965_driver_data *i965 = i965_driver_data(ctx);
2989 struct intel_batchbuffer *batch = encoder_context->base.batch;
2990 struct gen10_vdenc_vp9_context *vdenc_context = encoder_context->mfc_context;
2991 VAEncPictureParameterBufferVP9 *pic_param = vdenc_context->pic_param;
2992 unsigned int i;
2993
2994 BEGIN_BCS_BATCH(batch, 104);
2995
2996 OUT_BCS_BATCH(batch, HCP_PIPE_BUF_ADDR_STATE | (104 - 2));
2997
2998 /* DW 1..3 decoded surface */
2999 OUT_BUFFER_3DW(batch, vdenc_context->recon_surface_res.bo, 1, 0, 0);
3000
3001 /* DW 4..6 deblocking line */
3002 OUT_BUFFER_3DW(batch, vdenc_context->deblocking_filter_line_buffer_res.bo, 1, 0, 0);
3003
3004 /* DW 7..9 deblocking tile line */
3005 OUT_BUFFER_3DW(batch, vdenc_context->deblocking_filter_tile_line_buffer_res.bo, 1, 0, 0);
3006
3007 /* DW 10..12 deblocking tile col */
3008 OUT_BUFFER_3DW(batch, vdenc_context->deblocking_filter_tile_col_buffer_res.bo, 1, 0, 0);
3009
3010 /* DW 13..15 metadata line */
3011 OUT_BUFFER_3DW(batch, vdenc_context->metadata_line_buffer_res.bo, 1, 0, 0);
3012
3013 /* DW 16..18 metadata tile line */
3014 OUT_BUFFER_3DW(batch, vdenc_context->metadata_tile_line_buffer_res.bo, 1, 0, 0);
3015
3016 /* DW 19..21 metadata tile col */
3017 OUT_BUFFER_3DW(batch, vdenc_context->metadata_tile_col_buffer_res.bo, 1, 0, 0);
3018
3019 /* DW 22..30 SAO is not used for VP9 */
3020 OUT_BUFFER_3DW(batch, NULL, 0, 0, 0);
3021 OUT_BUFFER_3DW(batch, NULL, 0, 0, 0);
3022 OUT_BUFFER_3DW(batch, NULL, 0, 0, 0);
3023
3024 /* DW 31..33 Current Motion vector temporal buffer */
3025 OUT_BUFFER_3DW(batch, vdenc_context->mv_temporal_buffer_res[vdenc_context->curr_mv_temporal_index].bo, 1, 0, 0);
3026
3027 /* DW 34..36 Not used */
3028 OUT_BUFFER_3DW(batch, NULL, 0, 0, 0);
3029
3030 /* Only the first three reference_frame is used for VP9 */
3031 /* DW 37..52 for reference_frame */
3032 i = 0;
3033
3034 if (vdenc_context->vp9_frame_type == VP9_FRAME_P) {
3035 for (i = 0; i < 3; i++) {
3036 if (encode_state->reference_objects[i] &&
3037 encode_state->reference_objects[i]->bo)
3038 OUT_BUFFER_2DW(batch, encode_state->reference_objects[i]->bo, 0, 0);
3039 else
3040 OUT_BUFFER_2DW(batch, NULL, 0, 0);
3041 }
3042 }
3043
3044 for (; i < 8; i++) {
3045 OUT_BUFFER_2DW(batch, NULL, 0, 0);
3046 }
3047
3048 OUT_BCS_BATCH(batch, i965->intel.mocs_state);
3049
3050 /* DW 54..56 for source input */
3051 OUT_BUFFER_3DW(batch, vdenc_context->uncompressed_input_yuv_surface_res.bo, 0, 0, 0);
3052
3053 /* DW 57..59 StreamOut is not used */
3054 OUT_BUFFER_3DW(batch, NULL, 0, 0, 0);
3055
3056 /* DW 60..62. Not used for encoder */
3057 OUT_BUFFER_3DW(batch, NULL, 0, 0, 0);
3058
3059 /* DW 63..65. ILDB Not used for encoder */
3060 OUT_BUFFER_3DW(batch, NULL, 0, 0, 0);
3061
3062 /* DW 66..81 For the collocated motion vector temporal buffer */
3063 if (vdenc_context->vp9_frame_type == VP9_FRAME_P) {
3064 int prev_index = vdenc_context->curr_mv_temporal_index ^ 0x01;
3065 OUT_BUFFER_2DW(batch, vdenc_context->mv_temporal_buffer_res[prev_index].bo, 0, 0);
3066 } else {
3067 OUT_BUFFER_2DW(batch, NULL, 0, 0);
3068 }
3069
3070 for (i = 1; i < 8; i++) {
3071 OUT_BUFFER_2DW(batch, NULL, 0, 0);
3072 }
3073
3074 OUT_BCS_BATCH(batch, i965->intel.mocs_state);
3075
3076 /* DW 83..85 VP9 prob buffer */
3077 if (vdenc_context->current_pass == vdenc_context->num_passes - 1)
3078 OUT_BUFFER_3DW(batch, vdenc_context->huc_prob_output_buffer_res.bo, 1, 0, 0);
3079 else {
3080 int frame_ctx = pic_param->pic_flags.bits.frame_context_idx;
3081
3082 OUT_BUFFER_3DW(batch, vdenc_context->prob_buffer_res[frame_ctx].bo, 1, 0, 0);
3083 }
3084
3085 /* DW 86..88 Segment id buffer */
3086 OUT_BUFFER_3DW(batch, vdenc_context->segmentid_buffer_res.bo, 1, 0, 0);
3087
3088 /* DW 89..91 HVD line rowstore buffer */
3089 OUT_BUFFER_3DW(batch, vdenc_context->hvd_line_buffer_res.bo, 1, 0, 0);
3090
3091 /* DW 92..94 HVD tile line rowstore buffer */
3092 OUT_BUFFER_3DW(batch, vdenc_context->hvd_tile_line_buffer_res.bo, 1, 0, 0);
3093
3094 /* DW 95..97 SAO streamout. Not used for VP9 */
3095 OUT_BUFFER_3DW(batch, NULL, 0, 0, 0);
3096
3097 /* DW 98..101 Frame Stat Stream out */
3098 OUT_BUFFER_3DW(batch, vdenc_context->vdenc_brc_pak_stat_buffer_res.bo, 1, 0, 0);
3099
3100 /* 101..103 */
3101 OUT_BUFFER_3DW(batch, vdenc_context->vdenc_sse_src_pixel_row_store_buffer_res.bo, 1, 0, 0);
3102
3103 ADVANCE_BCS_BATCH(batch);
3104 }
3105
3106 static void
3107 gen10_vdenc_vp9_hcp_ind_obj_base_addr_state(VADriverContextP ctx, struct encode_state *encode_state, struct intel_encoder_context *encoder_context)
3108 {
3109 struct i965_driver_data *i965 = i965_driver_data(ctx);
3110 struct gen10_vdenc_vp9_context *vdenc_context = encoder_context->mfc_context;
3111 struct intel_batchbuffer *batch = encoder_context->base.batch;
3112
3113 BEGIN_BCS_BATCH(batch, 29);
3114
3115 OUT_BCS_BATCH(batch, HCP_IND_OBJ_BASE_ADDR_STATE | (29 - 2));
3116
3117 /* indirect bitstream object base */
3118 OUT_BUFFER_3DW(batch, NULL, 0, 0, 0);
3119 /* the upper bound of indirect bitstream object */
3120 OUT_BUFFER_2DW(batch, NULL, 0, 0);
3121
3122 /* DW 6: Indirect CU object base address, ignored for vdenc */
3123 OUT_BUFFER_3DW(batch, NULL, 0, 0, 0);
3124
3125 /* DW 9..11, PAK-BSE */
3126 OUT_BUFFER_3DW(batch,
3127 vdenc_context->compressed_bitstream.res.bo,
3128 1,
3129 vdenc_context->compressed_bitstream.start_offset,
3130 0);
3131 OUT_BUFFER_2DW(batch,
3132 vdenc_context->compressed_bitstream.res.bo,
3133 1,
3134 vdenc_context->compressed_bitstream.end_offset);
3135
3136 /* DW 14..16 compressed header buffer */
3137 OUT_BUFFER_3DW(batch,
3138 vdenc_context->compressed_header_buffer_res.bo,
3139 0,
3140 0,
3141 0);
3142
3143 /* DW 17..19 prob counter streamout */
3144 OUT_BUFFER_3DW(batch,
3145 vdenc_context->prob_counter_buffer_res.bo,
3146 1,
3147 0,
3148 0);
3149
3150 /* DW 20..22 prob delta streamin */
3151 OUT_BUFFER_3DW(batch,
3152 vdenc_context->prob_delta_buffer_res.bo,
3153 0,
3154 0,
3155 0);
3156
3157 /* DW 23..25 Tile record streamout */
3158 OUT_BUFFER_3DW(batch,
3159 vdenc_context->tile_record_streamout_buffer_res.bo,
3160 1,
3161 0,
3162 0);
3163
3164 /* DW 26..28, VP9 PAK CU level Statistic streamout */
3165 OUT_BUFFER_3DW(batch,
3166 vdenc_context->cu_stat_streamout_buffer_res.bo,
3167 1,
3168 0,
3169 0);
3170
3171 ADVANCE_BCS_BATCH(batch);
3172 }
3173
3174 static void
3175 gen10_vdenc_vp9_vdenc_pipe_mode_select(VADriverContextP ctx,
3176 struct encode_state *encode_state,
3177 struct intel_encoder_context *encoder_context)
3178 {
3179 struct gen10_vdenc_vp9_context *vdenc_context = encoder_context->mfc_context;
3180 struct intel_batchbuffer *batch = encoder_context->base.batch;
3181
3182 BEGIN_BCS_BATCH(batch, 2);
3183
3184 OUT_BCS_BATCH(batch, VDENC_PIPE_MODE_SELECT | (2 - 2));
3185 OUT_BCS_BATCH(batch,
3186 (0 << 12) | /* TODO, Bit Depth */
3187 (0 << 9) | /* Must be 0 */
3188 (vdenc_context->vdenc_pak_threshold_check_enable << 8) |
3189 (1 << 7) | /* Tlb prefetch enable */
3190 (vdenc_context->vdenc_pak_object_streamout_enable << 6) |
3191 (1 << 5) | /* Frame Statistics Stream-Out Enable */
3192 (VDENC_CODEC_VP9 << 0));
3193
3194 ADVANCE_BCS_BATCH(batch);
3195 }
3196
3197 static void
3198 gen10_vdenc_vp9_vdenc_src_surface_state(VADriverContextP ctx,
3199 struct intel_encoder_context *encoder_context,
3200 struct i965_gpe_resource *gpe_resource)
3201 {
3202 struct intel_batchbuffer *batch = encoder_context->base.batch;
3203
3204 BEGIN_BCS_BATCH(batch, 6);
3205
3206 OUT_BCS_BATCH(batch, VDENC_SRC_SURFACE_STATE | (6 - 2));
3207 OUT_BCS_BATCH(batch, 0);
3208 OUT_BCS_BATCH(batch,
3209 ((gpe_resource->height - 1) << 18) |
3210 ((gpe_resource->width - 1) << 4));
3211 OUT_BCS_BATCH(batch,
3212 (VDENC_SURFACE_PLANAR_420_8 << 28) | /* 420 planar YUV surface, TODO: 10bits support */
3213 (1 << 27) | /* must be 1 for interleave U/V, hardware requirement */
3214 ((gpe_resource->pitch - 1) << 3) | /* pitch */
3215 (0 << 2) | /* must be 0 for interleave U/V */
3216 (1 << 1) | /* must be tiled */
3217 (I965_TILEWALK_YMAJOR << 0)); /* tile walk, TILEWALK_YMAJOR */
3218 OUT_BCS_BATCH(batch,
3219 (0 << 16) | /* must be 0 for interleave U/V */
3220 (gpe_resource->y_cb_offset)); /* y offset for U(cb) */
3221 OUT_BCS_BATCH(batch,
3222 (0 << 16) | /* must be 0 for interleave U/V */
3223 (gpe_resource->y_cb_offset)); /* y offset for v(cr) */
3224
3225 ADVANCE_BCS_BATCH(batch);
3226 }
3227
3228 static void
3229 gen10_vdenc_vp9_vdenc_ref_surface_state(VADriverContextP ctx,
3230 struct intel_encoder_context *encoder_context,
3231 struct i965_gpe_resource *gpe_resource)
3232 {
3233 struct intel_batchbuffer *batch = encoder_context->base.batch;
3234
3235 BEGIN_BCS_BATCH(batch, 6);
3236
3237 OUT_BCS_BATCH(batch, VDENC_REF_SURFACE_STATE | (6 - 2));
3238 OUT_BCS_BATCH(batch, 0);
3239 OUT_BCS_BATCH(batch,
3240 ((gpe_resource->height - 1) << 18) |
3241 ((gpe_resource->width - 1) << 4));
3242 OUT_BCS_BATCH(batch,
3243 (VDENC_SURFACE_PLANAR_420_8 << 28) | /* 420 planar YUV surface TODO: 10bits support */
3244 (1 << 27) | /* must be 1 for interleave U/V, hardware requirement */
3245 ((gpe_resource->pitch - 1) << 3) | /* pitch */
3246 (0 << 2) | /* must be 0 for interleave U/V */
3247 (1 << 1) | /* must be tiled */
3248 (I965_TILEWALK_YMAJOR << 0)); /* tile walk, TILEWALK_YMAJOR */
3249 OUT_BCS_BATCH(batch,
3250 (0 << 16) | /* must be 0 for interleave U/V */
3251 (gpe_resource->y_cb_offset)); /* y offset for U(cb) */
3252 OUT_BCS_BATCH(batch,
3253 (0 << 16) | /* must be 0 for interleave U/V */
3254 (gpe_resource->y_cb_offset)); /* y offset for v(cr) */
3255
3256 ADVANCE_BCS_BATCH(batch);
3257 }
3258
3259 static void
3260 gen10_vdenc_vp9_vdenc_ds_ref_surface_state(VADriverContextP ctx,
3261 struct intel_encoder_context *encoder_context,
3262 struct i965_gpe_resource *gpe_resource0,
3263 struct i965_gpe_resource *gpe_resource1)
3264 {
3265 struct intel_batchbuffer *batch = encoder_context->base.batch;
3266
3267 BEGIN_BCS_BATCH(batch, 10);
3268
3269 OUT_BCS_BATCH(batch, VDENC_DS_REF_SURFACE_STATE | (10 - 2));
3270 OUT_BCS_BATCH(batch, 0);
3271 OUT_BCS_BATCH(batch,
3272 ((gpe_resource0->height - 1) << 18) |
3273 ((gpe_resource0->width - 1) << 4));
3274 OUT_BCS_BATCH(batch,
3275 (VDENC_SURFACE_PLANAR_420_8 << 28) | /* 420 planar YUV surface TODO: 10bits surface */
3276 (1 << 27) | /* must be 1 for interleave U/V, hardware requirement */
3277 ((gpe_resource0->pitch - 1) << 3) | /* pitch */
3278 (0 << 2) | /* must be 0 for interleave U/V */
3279 (1 << 1) | /* must be tiled */
3280 (I965_TILEWALK_YMAJOR << 0)); /* tile walk, TILEWALK_YMAJOR */
3281 OUT_BCS_BATCH(batch,
3282 (0 << 16) | /* must be 0 for interleave U/V */
3283 (gpe_resource0->y_cb_offset)); /* y offset for U(cb) */
3284 OUT_BCS_BATCH(batch,
3285 (0 << 16) | /* must be 0 for interleave U/V */
3286 (gpe_resource0->y_cb_offset)); /* y offset for v(cr) */
3287
3288 OUT_BCS_BATCH(batch,
3289 ((gpe_resource1->height - 1) << 18) |
3290 ((gpe_resource1->width - 1) << 4));
3291 OUT_BCS_BATCH(batch,
3292 (VDENC_SURFACE_PLANAR_420_8 << 28) | /* 420 planar YUV surface TODO: 10bits surface */
3293 (1 << 27) | /* must be 1 for interleave U/V, hardware requirement */
3294 ((gpe_resource1->pitch - 1) << 3) | /* pitch */
3295 (0 << 2) | /* must be 0 for interleave U/V */
3296 (1 << 1) | /* must be tiled */
3297 (I965_TILEWALK_YMAJOR << 0)); /* tile walk, TILEWALK_YMAJOR */
3298 OUT_BCS_BATCH(batch,
3299 (0 << 16) | /* must be 0 for interleave U/V */
3300 (gpe_resource1->y_cb_offset)); /* y offset for U(cb) */
3301 OUT_BCS_BATCH(batch,
3302 (0 << 16) | /* must be 0 for interleave U/V */
3303 (gpe_resource1->y_cb_offset)); /* y offset for v(cr) */
3304
3305 ADVANCE_BCS_BATCH(batch);
3306 }
3307
3308 static void
3309 gen10_vdenc_vdenc_pipe_buf_addr_state(VADriverContextP ctx,
3310 struct encode_state *encode_state,
3311 struct intel_encoder_context *encoder_context)
3312 {
3313 struct i965_driver_data *i965 = i965_driver_data(ctx);
3314 struct gen10_vdenc_vp9_context *vdenc_context = encoder_context->mfc_context;
3315 struct intel_batchbuffer *batch = encoder_context->base.batch;
3316 struct vdenc_vp9_surface *vdenc_vp9_surface0 = NULL, *vdenc_vp9_surface1 = NULL;
3317
3318 if (vdenc_context->last_ref_obj)
3319 vdenc_vp9_surface0 = (struct vdenc_vp9_surface *)(vdenc_context->last_ref_obj->private_data);
3320
3321 if (vdenc_context->golden_ref_obj)
3322 vdenc_vp9_surface1 = (struct vdenc_vp9_surface *)(vdenc_context->golden_ref_obj->private_data);
3323
3324 BEGIN_BCS_BATCH(batch, 62);
3325
3326 OUT_BCS_BATCH(batch, VDENC_PIPE_BUF_ADDR_STATE | (62 - 2));
3327
3328 /* DW1-6 for DS 8x REF */
3329 if (vdenc_vp9_surface0 && vdenc_vp9_surface0->scaled_8x_surface_obj)
3330 OUT_BUFFER_3DW(batch, vdenc_vp9_surface0->scaled_8x_surface_obj->bo, 0, 0, 0);
3331 else
3332 OUT_BUFFER_3DW(batch, NULL, 0, 0, 0);
3333
3334 if (vdenc_vp9_surface1 && vdenc_vp9_surface1->scaled_8x_surface_obj)
3335 OUT_BUFFER_3DW(batch, vdenc_vp9_surface1->scaled_8x_surface_obj->bo, 0, 0, 0);
3336 else
3337 OUT_BUFFER_3DW(batch, NULL, 0, 0, 0);
3338
3339 /* DW7-9 for DS BWD REF0. B-frame is not supported */
3340 OUT_BUFFER_3DW(batch, NULL, 0, 0, 0);
3341
3342 /* DW10-12 for uncompressed input data */
3343 OUT_BUFFER_3DW(batch, vdenc_context->uncompressed_input_yuv_surface_res.bo, 0, 0, 0);
3344
3345 /* DW13-DW15 for streamin data */
3346 OUT_BUFFER_3DW(batch, vdenc_context->vdenc_streamin_buffer_res.bo, 0, 0, 0);
3347
3348 /* DW16-DW18 for row scratch buffer */
3349 OUT_BUFFER_3DW(batch, vdenc_context->vdenc_row_store_scratch_res.bo, 1, 0, 0);
3350
3351 /* DW19-DW21, mv temporal buffer */
3352 if (vdenc_context->vp9_frame_type == VP9_FRAME_P) {
3353 int prev_index = vdenc_context->curr_mv_temporal_index ^ 0x01;
3354 OUT_BUFFER_3DW(batch, vdenc_context->mv_temporal_buffer_res[prev_index].bo, 1, 0, 0);
3355 } else
3356 OUT_BUFFER_3DW(batch, NULL, 0, 0, 0);
3357
3358 /* DW22-DW30 for Last, Golden, Alt reference */
3359 OUT_BUFFER_3DW(batch, vdenc_context->last_ref_res.bo, 0, 0, 0);
3360 OUT_BUFFER_3DW(batch, vdenc_context->golden_ref_res.bo, 0, 0, 0);
3361 OUT_BUFFER_3DW(batch, vdenc_context->alt_ref_res.bo, 0, 0, 0);
3362
3363 /* DW31-DW33 for BDW REF0. Ignored*/
3364 OUT_BUFFER_3DW(batch, NULL, 0, 0, 0);
3365
3366 /* DW34-DW36 for VDEnc statistics streamout */
3367 OUT_BUFFER_3DW(batch, vdenc_context->vdenc_brc_stat_buffer_res.bo, 1, 0, 0);
3368
3369 /* DW37..DW42. DS 4x REF */
3370 if (vdenc_vp9_surface0 && vdenc_vp9_surface0->scaled_4x_surface_obj)
3371 OUT_BUFFER_3DW(batch, vdenc_vp9_surface0->scaled_4x_surface_obj->bo, 0, 0, 0);
3372 else
3373 OUT_BUFFER_3DW(batch, NULL, 0, 0, 0);
3374
3375 if (vdenc_vp9_surface1 && vdenc_vp9_surface1->scaled_4x_surface_obj)
3376 OUT_BUFFER_3DW(batch, vdenc_vp9_surface1->scaled_4x_surface_obj->bo, 0, 0, 0);
3377 else
3378 OUT_BUFFER_3DW(batch, NULL, 0, 0, 0);
3379
3380 /* DW43..DW45. Not used */
3381 OUT_BUFFER_3DW(batch, NULL, 0, 0, 0);
3382
3383 /* DW46..DW48. streamout for pak object command */
3384 OUT_BUFFER_3DW(batch, vdenc_context->mb_code_buffer_res.bo, 1, 0, 0);
3385
3386 /* DW49..DW51. DS 8x */
3387 OUT_BUFFER_3DW(batch, vdenc_context->scaled_8x_recon_surface_res.bo, 1, 0, 0);
3388
3389 /* DW52..DW54. DS 4x */
3390 OUT_BUFFER_3DW(batch, vdenc_context->scaled_4x_recon_surface_res.bo, 1, 0, 0);
3391
3392 /* DW55..DW57. segment map streamout */
3393 OUT_BUFFER_3DW(batch, vdenc_context->vdenc_segment_map_stream_out_buffer_res.bo, 1, 0, 0);
3394
3395 /* DW58..DW60. */
3396 OUT_BUFFER_3DW(batch, vdenc_context->vdenc_segment_map_stream_out_buffer_res.bo, 1, 0, 0);
3397
3398 /* DW 61. */
3399 OUT_BCS_BATCH(batch, 64 * 3);
3400
3401 ADVANCE_BCS_BATCH(batch);
3402 }
3403
3404 static void
3405 gen10_vdenc_vp9_vdecn_weihgtsoffsets_state(VADriverContextP ctx,
3406 struct encode_state *encode_state,
3407 struct intel_encoder_context *encoder_context)
3408 {
3409 struct intel_batchbuffer *batch = encoder_context->base.batch;
3410
3411 BEGIN_BCS_BATCH(batch, 5);
3412
3413 OUT_BCS_BATCH(batch, VDENC_WEIGHTSOFFSETS_STATE | (5 - 2));
3414
3415 OUT_BCS_BATCH(batch, (0 << 24 |
3416 1 << 16 |
3417 0 << 8 |
3418 1 << 0));
3419 OUT_BCS_BATCH(batch, (0 << 8 |
3420 1 << 0));
3421 OUT_BCS_BATCH(batch, (0 << 24 |
3422 1 << 16 |
3423 0 << 8 |
3424 1 << 0));
3425 OUT_BCS_BATCH(batch, (0 << 24 |
3426 1 << 16 |
3427 0 << 8 |
3428 1 << 0));
3429
3430 ADVANCE_BCS_BATCH(batch);
3431 }
3432
3433 static void
3434 gen10_vdenc_vp9_vdenc_walker_state(VADriverContextP ctx,
3435 struct encode_state *encode_state,
3436 struct intel_encoder_context *encoder_context)
3437 {
3438 struct gen10_vdenc_vp9_context *vdenc_context = encoder_context->mfc_context;
3439 struct intel_batchbuffer *batch = encoder_context->base.batch;
3440 VAEncPictureParameterBufferVP9 *pic_param = vdenc_context->pic_param;
3441
3442 BEGIN_BCS_BATCH(batch, 6);
3443 OUT_BCS_BATCH(batch, VDENC_WALKER_STATE | (6 - 2));
3444
3445 OUT_BCS_BATCH(batch, 0);
3446 OUT_BCS_BATCH(batch, ((ALIGN(pic_param->frame_width_dst, 64) / 64) << 16 |
3447 (ALIGN(pic_param->frame_height_dst, 64) / 64)));
3448 OUT_BCS_BATCH(batch, 0);
3449 OUT_BCS_BATCH(batch, 0);
3450 OUT_BCS_BATCH(batch, pic_param->frame_width_dst - 1);
3451
3452 ADVANCE_BCS_BATCH(batch);
3453 }
3454
3455 static void
3456 gen10_vdenc_vp9_hcp_vdenc_pipeline(VADriverContextP ctx,
3457 struct encode_state *encode_state,
3458 struct intel_encoder_context *encoder_context)
3459 {
3460 struct gen10_vdenc_vp9_context *vdenc_context = encoder_context->mfc_context;
3461 struct intel_batchbuffer *batch = encoder_context->base.batch;
3462 struct gpe_mi_batch_buffer_start_parameter mi_batch_buffer_start_params;
3463 struct gpe_mi_flush_dw_parameter mi_flush_dw_params;
3464 struct i965_gpe_table *gpe = vdenc_context->gpe_table;
3465 gen10_vdenc_vd_pipeline_flush_param pipeline_flush_params;
3466
3467 if (vdenc_context->num_passes > 1 && vdenc_context->current_pass == (vdenc_context->num_passes - 1)) {
3468 struct gpe_mi_conditional_batch_buffer_end_parameter mi_conditional_batch_buffer_end_params;
3469
3470 memset(&mi_conditional_batch_buffer_end_params, 0, sizeof(mi_conditional_batch_buffer_end_params));
3471 mi_conditional_batch_buffer_end_params.bo = vdenc_context->huc_status_buffer_res.bo;
3472 /* Muse use Mask mode */
3473 mi_conditional_batch_buffer_end_params.compare_mask_mode_disabled = 0;
3474 gpe->mi_conditional_batch_buffer_end(ctx, batch, &mi_conditional_batch_buffer_end_params);
3475 }
3476
3477 gen10_vdenc_vp9_hcp_pipe_mode_select(ctx, encode_state, encoder_context);
3478
3479 /* MFX_WAIT to make sure previous operation is done */
3480 gen10_vdenc_mfx_wait(ctx, encode_state, encoder_context);
3481
3482 gen10_vdenc_vp9_hcp_surface_state(ctx, encoder_context, &vdenc_context->recon_surface_res, 0);
3483 gen10_vdenc_vp9_hcp_surface_state(ctx, encoder_context, &vdenc_context->uncompressed_input_yuv_surface_res, 1);
3484 gen10_vdenc_vp9_hcp_surface_state(ctx, encoder_context, &vdenc_context->last_ref_res, 2);
3485 gen10_vdenc_vp9_hcp_surface_state(ctx, encoder_context, &vdenc_context->golden_ref_res, 3);
3486 gen10_vdenc_vp9_hcp_surface_state(ctx, encoder_context, &vdenc_context->alt_ref_res, 4);
3487
3488 gen10_vdenc_vp9_hcp_pipe_buf_addr_state(ctx, encode_state, encoder_context);
3489 gen10_vdenc_vp9_hcp_ind_obj_base_addr_state(ctx, encode_state, encoder_context);
3490
3491 gen10_vdenc_vp9_vdenc_pipe_mode_select(ctx, encode_state, encoder_context);
3492 gen10_vdenc_vp9_vdenc_src_surface_state(ctx, encoder_context, &vdenc_context->uncompressed_input_yuv_surface_res);
3493
3494 if (vdenc_context->is_key_frame)
3495 gen10_vdenc_vp9_vdenc_ref_surface_state(ctx, encoder_context, &vdenc_context->recon_surface_res);
3496 else {
3497 struct i965_gpe_resource *ref_gpe_res = &vdenc_context->last_ref_res;
3498
3499 if (!ref_gpe_res->bo)
3500 ref_gpe_res = &vdenc_context->golden_ref_res;
3501
3502 if (!ref_gpe_res->bo)
3503 ref_gpe_res = &vdenc_context->alt_ref_res;
3504
3505 assert(ref_gpe_res->bo);
3506 gen10_vdenc_vp9_vdenc_ref_surface_state(ctx, encoder_context, ref_gpe_res);
3507 }
3508
3509 gen10_vdenc_vp9_vdenc_ds_ref_surface_state(ctx, encoder_context, &vdenc_context->scaled_8x_recon_surface_res, &vdenc_context->scaled_4x_recon_surface_res);
3510
3511 gen10_vdenc_vdenc_pipe_buf_addr_state(ctx, encode_state, encoder_context);
3512
3513 memset(&mi_batch_buffer_start_params, 0, sizeof(mi_batch_buffer_start_params));
3514 mi_batch_buffer_start_params.is_second_level = 1; /* Must be the second level batch buffer */
3515
3516 if (vdenc_context->use_huc)
3517 mi_batch_buffer_start_params.bo = vdenc_context->vdenc_pic_state_output_2nd_batchbuffer_res[0].bo;
3518 else {
3519 if (vdenc_context->dys_ref_frame_flag != VP9_REF_NONE && vdenc_context->dys_multiple_pass_enbaled)
3520 mi_batch_buffer_start_params.bo = vdenc_context->vdenc_dys_pic_state_2nd_batchbuffer_res.bo;
3521 else
3522 mi_batch_buffer_start_params.bo = vdenc_context->vdenc_pic_state_input_2nd_batchbuffer_res[vdenc_context->current_pass].bo;
3523 }
3524
3525 gpe->mi_batch_buffer_start(ctx, batch, &mi_batch_buffer_start_params);
3526
3527 if (vdenc_context->use_huc)
3528 mi_batch_buffer_start_params.bo = vdenc_context->huc_pak_insert_uncompressed_header_output_2nd_batchbuffer_res.bo;
3529 else {
3530 mi_batch_buffer_start_params.bo = vdenc_context->huc_pak_insert_uncompressed_header_input_2nd_batchbuffer_res.bo;
3531 }
3532
3533 gpe->mi_batch_buffer_start(ctx, batch, &mi_batch_buffer_start_params);
3534
3535 gen10_vdenc_vp9_vdecn_weihgtsoffsets_state(ctx, encode_state, encoder_context);
3536 gen10_vdenc_vp9_vdenc_walker_state(ctx, encode_state, encoder_context);
3537
3538 memset(&pipeline_flush_params, 0, sizeof(pipeline_flush_params));
3539 pipeline_flush_params.dw1.mfx_pipeline_done = 1;
3540 pipeline_flush_params.dw1.hevc_pipeline_done = 1;
3541 pipeline_flush_params.dw1.hevc_pipeline_flush = 1;
3542 pipeline_flush_params.dw1.vd_cmd_msg_parser_done = 1;
3543 gen10_vdenc_vd_pipeline_flush(ctx, batch, &pipeline_flush_params);
3544
3545 memset(&mi_flush_dw_params, 0, sizeof(mi_flush_dw_params));
3546 mi_flush_dw_params.video_pipeline_cache_invalidate = 1;
3547 gpe->mi_flush_dw(ctx, batch, &mi_flush_dw_params);
3548 }
3549
3550 static void
3551 gen10_vdenc_vp9_context_brc_prepare(struct encode_state *encode_state,
3552 struct intel_encoder_context *encoder_context)
3553 {
3554 struct gen10_vdenc_vp9_context *vdenc_context = encoder_context->mfc_context;
3555 unsigned int rate_control_mode = encoder_context->rate_control_mode;
3556
3557 switch (rate_control_mode & 0x7f) {
3558 case VA_RC_CBR:
3559 vdenc_context->internal_rate_mode = I965_BRC_CBR;
3560 break;
3561
3562 case VA_RC_VBR:
3563 vdenc_context->internal_rate_mode = I965_BRC_VBR;
3564 break;
3565
3566 case VA_RC_CQP:
3567 default:
3568 vdenc_context->internal_rate_mode = I965_BRC_CQP;
3569 break;
3570 }
3571
3572 if (encoder_context->quality_level == 0)
3573 encoder_context->quality_level = ENCODER_DEFAULT_QUALITY_VP9;
3574 }
3575
3576 static void
3577 gen10_vdenc_vp9_read_status(VADriverContextP ctx, struct intel_encoder_context *encoder_context)
3578 {
3579 struct gen10_vdenc_vp9_context *vdenc_context = encoder_context->mfc_context;
3580 struct intel_batchbuffer *batch = encoder_context->base.batch;
3581 struct gpe_mi_store_register_mem_parameter mi_store_register_mem_params;
3582 struct gpe_mi_flush_dw_parameter mi_flush_dw_params;
3583 struct gpe_mi_copy_mem_parameter mi_copy_mem_mem_params;
3584 struct i965_gpe_table *gpe = vdenc_context->gpe_table;
3585 unsigned int base_offset = vdenc_context->status_bffuer.base_offset;
3586
3587 memset(&mi_store_register_mem_params, 0, sizeof(mi_store_register_mem_params));
3588 mi_store_register_mem_params.mmio_offset = HCP_VP9_BITSTREAM_BYTECOUNT_FRAME_REG;
3589 mi_store_register_mem_params.bo = vdenc_context->status_bffuer.res.bo;
3590 mi_store_register_mem_params.offset = base_offset + vdenc_context->status_bffuer.bytes_per_frame_offset;
3591 gpe->mi_store_register_mem(ctx, batch, &mi_store_register_mem_params);
3592
3593 memset(&mi_copy_mem_mem_params, 0, sizeof(mi_copy_mem_mem_params));
3594 mi_copy_mem_mem_params.src_bo = vdenc_context->status_bffuer.res.bo;
3595 mi_copy_mem_mem_params.src_offset = base_offset + vdenc_context->status_bffuer.bytes_per_frame_offset;
3596 mi_copy_mem_mem_params.dst_bo = vdenc_context->brc_bitstream_size_buffer_res.bo;
3597 mi_copy_mem_mem_params.dst_offset = 0;
3598 gpe->mi_copy_mem_mem(ctx, batch, &mi_copy_mem_mem_params);
3599
3600 mi_copy_mem_mem_params.dst_bo = vdenc_context->huc_prob_dmem_buffer_res[1].bo;
3601 mi_copy_mem_mem_params.dst_offset = offsetof(struct vdenc_vp9_huc_prob_dmem, frame_size);
3602 gpe->mi_copy_mem_mem(ctx, batch, &mi_copy_mem_mem_params);
3603
3604 memset(&mi_flush_dw_params, 0, sizeof(mi_flush_dw_params));
3605 gpe->mi_flush_dw(ctx, batch, &mi_flush_dw_params);
3606 }
3607
3608 static VAStatus
3609 gen10_vdenc_vp9_check_capability(VADriverContextP ctx,
3610 struct encode_state *encode_state,
3611 struct intel_encoder_context *encoder_context)
3612 {
3613 return VA_STATUS_SUCCESS;
3614 }
3615
3616 static VAStatus
3617 gen10_vdenc_vp9_dys_ref_frames(VADriverContextP ctx,
3618 struct encode_state *encode_state,
3619 struct intel_encoder_context *encoder_context)
3620 {
3621 struct gen10_vdenc_vp9_context *vdenc_context = encoder_context->mfc_context;
3622
3623 if (vdenc_context->dys_ref_frame_flag == VP9_REF_NONE)
3624 return VA_STATUS_SUCCESS;
3625
3626 if (vdenc_context->current_pass == 0) {
3627 if (vdenc_context->dys_multiple_pass_enbaled) {
3628 vdenc_context->vdenc_pak_object_streamout_enable = 1; // TODO, double check this flag
3629 }
3630 }
3631
3632 return VA_STATUS_SUCCESS;
3633 }
3634
3635 static VAStatus
3636 gen10_vdenc_vp9_fill_pak_insert_object_batchbuffer(VADriverContextP ctx,
3637 struct encode_state *encode_state,
3638 struct intel_encoder_context *encoder_context)
3639 {
3640 struct gen10_vdenc_vp9_context *vdenc_context = encoder_context->mfc_context;
3641 int uncompressed_header_length;
3642 unsigned int *cmd_ptr;
3643 unsigned int dw_length, bits_in_last_dw;
3644
3645 if (vdenc_context->current_pass)
3646 return VA_STATUS_SUCCESS;
3647
3648 assert(vdenc_context->alias_insert_data);
3649 uncompressed_header_length = vdenc_context->frame_header_length;
3650 cmd_ptr = i965_map_gpe_resource(&vdenc_context->huc_pak_insert_uncompressed_header_input_2nd_batchbuffer_res);
3651
3652 if (!cmd_ptr)
3653 return VA_STATUS_ERROR_UNKNOWN;
3654
3655 bits_in_last_dw = uncompressed_header_length % 4;
3656 bits_in_last_dw *= 8;
3657
3658 if (bits_in_last_dw == 0)
3659 bits_in_last_dw = 32;
3660
3661 /* get the DWORD length of the inserted_data */
3662 dw_length = ALIGN(uncompressed_header_length, 4) / 4;
3663 *cmd_ptr++ = HCP_INSERT_PAK_OBJECT | dw_length;
3664
3665 *cmd_ptr++ = ((0 << 31) | /* indirect payload */
3666 (0 << 16) | /* the start offset in first DW */
3667 (0 << 15) |
3668 (bits_in_last_dw << 8) | /* bits_in_last_dw */
3669 (0 << 4) | /* skip emulation byte count. 0 for VP9 */
3670 (0 << 3) | /* emulation flag. 0 for VP9 */
3671 (1 << 2) | /* last header flag. */
3672 (1 << 1)); /* End of slice */
3673 memcpy(cmd_ptr, vdenc_context->alias_insert_data, dw_length * sizeof(unsigned int));
3674
3675 cmd_ptr += dw_length;
3676
3677 *cmd_ptr++ = MI_NOOP;
3678 *cmd_ptr++ = MI_BATCH_BUFFER_END;
3679 i965_unmap_gpe_resource(&vdenc_context->huc_pak_insert_uncompressed_header_input_2nd_batchbuffer_res);
3680
3681 return VA_STATUS_SUCCESS;
3682 }
3683
3684 static void
3685 gen10_vdenc_vp9_fill_hcp_vp9_pic_state(VADriverContextP ctx,
3686 struct encode_state *encode_state,
3687 struct intel_encoder_context *encoder_context,
3688 uint32_t *pcmd)
3689 {
3690 struct gen10_vdenc_vp9_context *vdenc_context = encoder_context->mfc_context;
3691 struct object_surface *obj_surface;
3692 gen10_hcp_vp9_pic_state_param *param;
3693 VAEncPictureParameterBufferVP9 *pic_param;
3694 VDEncVP9Surface *vdenc_vp9_surface;
3695 unsigned int use_prev_frame_mvs;
3696 unsigned int scaled_h = 0, scaled_w = 0;
3697 unsigned int ref_frame_width, ref_frame_height;
3698
3699 if (!vdenc_context->pic_param)
3700 return;
3701
3702 pic_param = vdenc_context->pic_param;
3703 assert(sizeof(*param) == (VDENC_HCP_VP9_PIC_STATE_SIZE - 4));
3704 *pcmd++ = (HCP_VP9_PIC_STATE | (VDENC_HCP_VP9_PIC_STATE_SIZE_IN_DWS - 2));
3705 param = (gen10_hcp_vp9_pic_state_param *)pcmd;
3706 memset(param, 0, sizeof(*param));
3707
3708 param->dw1.frame_width_in_pixels_minus1 = ALIGN(pic_param->frame_width_dst, 8) - 1;
3709 param->dw1.frame_height_in_pixels_minus1 = ALIGN(pic_param->frame_height_dst, 8) - 1;
3710
3711 param->dw2.frame_type = !vdenc_context->is_key_frame;
3712 param->dw2.adapt_probabilities_flag = (!pic_param->pic_flags.bits.error_resilient_mode && !pic_param->pic_flags.bits.frame_parallel_decoding_mode);
3713 param->dw2.intra_only_flag = pic_param->pic_flags.bits.intra_only;
3714 param->dw2.allow_high_precision_mv = pic_param->pic_flags.bits.allow_high_precision_mv;
3715 param->dw2.motion_comp_filter_type = pic_param->pic_flags.bits.mcomp_filter_type;
3716 param->dw2.ref_frame_sign_bias_last = pic_param->ref_flags.bits.ref_last_sign_bias;
3717 param->dw2.ref_frame_sign_bias_golden = pic_param->ref_flags.bits.ref_gf_sign_bias;
3718 param->dw2.ref_frame_sign_bias_altref = pic_param->ref_flags.bits.ref_arf_sign_bias;
3719 param->dw2.hybrid_prediction_mode = (pic_param->pic_flags.bits.comp_prediction_mode == 2);
3720 param->dw2.selectable_tx_mode = (vdenc_context->tx_mode == TX_MODE_SELECT);
3721 param->dw2.refresh_frame_context = pic_param->pic_flags.bits.refresh_frame_context;
3722 param->dw2.error_resilient_mode = pic_param->pic_flags.bits.error_resilient_mode;
3723 param->dw2.frame_parallel_decoding_mode = pic_param->pic_flags.bits.frame_parallel_decoding_mode;
3724 param->dw2.filter_level = pic_param->filter_level;
3725 param->dw2.sharpness_level = pic_param->sharpness_level;
3726 param->dw2.segmentation_enabled = pic_param->pic_flags.bits.segmentation_enabled;
3727 param->dw2.segmentation_update_map = pic_param->pic_flags.bits.segmentation_update_map;
3728 param->dw2.segmentation_temporal_update = pic_param->pic_flags.bits.segmentation_temporal_update;
3729 param->dw2.lossless_mode = pic_param->pic_flags.bits.lossless_mode;
3730
3731 param->dw3.log2_tile_column = pic_param->log2_tile_columns;
3732 param->dw3.log2_tile_row = pic_param->log2_tile_rows;
3733 param->dw3.sse_enable = vdenc_context->brc_enabled;
3734
3735 if (vdenc_context->vp9_frame_type == VP9_FRAME_P) {
3736 if (pic_param->pic_flags.bits.error_resilient_mode ||
3737 vdenc_context->last_frame_status.is_key_frame ||
3738 vdenc_context->last_frame_status.intra_only ||
3739 !vdenc_context->last_frame_status.show_frame ||
3740 (pic_param->frame_width_dst != vdenc_context->last_frame_status.frame_width) ||
3741 (pic_param->frame_height_dst != vdenc_context->last_frame_status.frame_height))
3742 use_prev_frame_mvs = 0;
3743 else
3744 use_prev_frame_mvs = 1;
3745
3746 param->dw2.last_frame_type = !vdenc_context->last_frame_status.is_key_frame;
3747 param->dw2.use_prev_in_find_mv_references = use_prev_frame_mvs;
3748
3749 /* slot 0 is for last reference */
3750 obj_surface = encode_state->reference_objects[0];
3751 scaled_w = 0;
3752 scaled_h = 0;
3753 ref_frame_width = 1;
3754 ref_frame_height = 1;
3755
3756 if (obj_surface && obj_surface->private_data) {
3757 vdenc_vp9_surface = obj_surface->private_data;
3758 ref_frame_width = vdenc_vp9_surface->frame_width;
3759 ref_frame_height = vdenc_vp9_surface->frame_height;
3760 scaled_w = (ref_frame_width << 14) / pic_param->frame_width_dst;
3761 scaled_h = (ref_frame_height << 14) / pic_param->frame_height_dst;
3762 }
3763
3764 param->dw4.horizontal_scale_factor_for_last = scaled_w;
3765 param->dw4.vertical_scale_factor_for_last = scaled_h;
3766 param->dw7.last_frame_width_in_pixels_minus1 = ref_frame_width - 1;
3767 param->dw7.last_frame_height_in_pixels_minus1 = ref_frame_height - 1;
3768
3769 /* slot 1 is for golden reference */
3770 obj_surface = encode_state->reference_objects[1];
3771 scaled_w = 0;
3772 scaled_h = 0;
3773 ref_frame_width = 1;
3774 ref_frame_height = 1;
3775
3776 if (obj_surface && obj_surface->private_data) {
3777 vdenc_vp9_surface = obj_surface->private_data;
3778 ref_frame_width = vdenc_vp9_surface->frame_width;
3779 ref_frame_height = vdenc_vp9_surface->frame_height;
3780 scaled_w = (ref_frame_width << 14) / pic_param->frame_width_dst;
3781 scaled_h = (ref_frame_height << 14) / pic_param->frame_height_dst;
3782 }
3783
3784 param->dw5.horizontal_scale_factor_for_golden = scaled_w;
3785 param->dw5.vertical_scale_factor_for_golden = scaled_h;
3786 param->dw8.golden_frame_width_in_pixels_minus1 = ref_frame_width - 1;
3787 param->dw8.golden_frame_height_in_pixels_minus1 = ref_frame_height - 1;
3788
3789 /* slot 2 is for alt reference */
3790 obj_surface = encode_state->reference_objects[2];
3791 scaled_w = 0;
3792 scaled_h = 0;
3793 ref_frame_width = 1;
3794 ref_frame_height = 1;
3795
3796 if (obj_surface && obj_surface->private_data) {
3797 vdenc_vp9_surface = obj_surface->private_data;
3798 ref_frame_width = vdenc_vp9_surface->frame_width;
3799 ref_frame_height = vdenc_vp9_surface->frame_height;
3800 scaled_w = (ref_frame_width << 14) / pic_param->frame_width_dst;
3801 scaled_h = (ref_frame_height << 14) / pic_param->frame_height_dst;
3802 }
3803
3804 param->dw6.horizontal_scale_factor_for_altref = scaled_w;
3805 param->dw6.vertical_scale_factor_for_altref = scaled_h;
3806 param->dw9.altref_frame_width_in_pixels_minus1 = ref_frame_width - 1;
3807 param->dw9.altref_frame_height_in_pixels_minus1 = ref_frame_height - 1;
3808 }
3809
3810 param->dw11.motion_comp_scaling = 1;
3811 param->dw13.base_qindex = pic_param->luma_ac_qindex;
3812 param->dw13.header_insertion_enable = 1;
3813
3814 param->dw14.chroma_ac_qindex_delta = intel_convert_sign_mag(pic_param->chroma_ac_qindex_delta, 5);
3815 param->dw14.chroma_dc_qindex_delta = intel_convert_sign_mag(pic_param->chroma_dc_qindex_delta, 5);
3816 param->dw14.luma_dc_qindex_delta = intel_convert_sign_mag(pic_param->luma_dc_qindex_delta, 5);
3817
3818 param->dw15.lf_ref_delta0 = intel_convert_sign_mag(pic_param->ref_lf_delta[0], 7);
3819 param->dw15.lf_ref_delta1 = intel_convert_sign_mag(pic_param->ref_lf_delta[1], 7);
3820 param->dw15.lf_ref_delta2 = intel_convert_sign_mag(pic_param->ref_lf_delta[2], 7);
3821 param->dw15.lf_ref_delta3 = intel_convert_sign_mag(pic_param->ref_lf_delta[3], 7);
3822
3823 param->dw16.lf_mode_delta0 = intel_convert_sign_mag(pic_param->mode_lf_delta[0], 7);
3824 param->dw16.lf_mode_delta1 = intel_convert_sign_mag(pic_param->mode_lf_delta[1], 7);
3825
3826 param->dw17.bit_offset_for_lf_ref_delta = vdenc_context->frame_header.bit_offset_ref_lf_delta;
3827 param->dw17.bit_offset_for_mode_delta = vdenc_context->frame_header.bit_offset_mode_lf_delta;
3828
3829 param->dw18.bit_offset_for_lf_level = vdenc_context->frame_header.bit_offset_lf_level;
3830 param->dw18.bit_offset_for_qindex = vdenc_context->frame_header.bit_offset_qindex;
3831
3832 param->dw32.bit_offset_for_first_partition_size = vdenc_context->frame_header.bit_offset_first_partition_size;
3833
3834 param->dw19.vdenc_pak_only_pass = vdenc_context->pak_only_pass_enabled; // TODO, check the flag
3835
3836 if (vdenc_context->max_bit_rate || vdenc_context->min_bit_rate) {
3837 param->dw20.frame_bitrate_max = (vdenc_context->max_bit_rate >> 12);
3838 param->dw20.frame_bitrate_max_unit = 1;
3839 param->dw21.frame_bitrate_min = (vdenc_context->min_bit_rate >> 12);
3840 param->dw21.frame_bitrate_min_unit = 1;
3841 }
3842 }
3843
3844 static void
3845 gen10_vdenc_vp9_fill_hcp_vp9_segment_state(VADriverContextP ctx,
3846 struct encode_state *encode_state,
3847 struct intel_encoder_context *encoder_context,
3848 VAEncSegParamVP9 *seg_param,
3849 int segment_id,
3850 uint32_t *pcmd)
3851 {
3852 gen10_hcp_vp9_segment_state_param *param;
3853
3854 assert(sizeof(*param) == (VDENC_HCP_VP9_SEGMENT_STATE_SIZE - 4));
3855 *pcmd++ = (HCP_VP9_SEGMENT_STATE | (VDENC_HCP_VP9_SEGMENT_STATE_SIZE_IN_DWS - 2));
3856 param = (gen10_hcp_vp9_segment_state_param *)pcmd;
3857 memset(param, 0, sizeof(*param));
3858
3859 param->dw1.segment_id = segment_id;
3860 param->dw2.segment_skipped = seg_param->seg_flags.bits.segment_reference_skipped;
3861 param->dw2.segment_reference = seg_param->seg_flags.bits.segment_reference;
3862 param->dw2.segment_reference_enabled = seg_param->seg_flags.bits.segment_reference_enabled;
3863
3864 param->dw7.segment_qindex_delta = intel_convert_sign_mag(seg_param->segment_qindex_delta, 9);
3865 param->dw7.segment_lf_level_delta = intel_convert_sign_mag(seg_param->segment_lf_level_delta, 7);
3866 }
3867
3868 static void
3869 gen10_vdenc_vp9_fill_mi_batchbuffer_end(VADriverContextP ctx,
3870 struct encode_state *encode_state,
3871 struct intel_encoder_context *encoder_context,
3872 uint32_t *pcmd)
3873 {
3874 *pcmd++ = MI_BATCH_BUFFER_END;
3875 }
3876
3877 static void
3878 gen10_vdenc_vp9_huc_initializer_init(VADriverContextP ctx,
3879 struct encode_state *encode_state,
3880 struct intel_encoder_context *encoder_context)
3881 {
3882 struct gen10_vdenc_vp9_context *vdenc_context = encoder_context->mfc_context;
3883 struct i965_gpe_resource *dmem_gpe_resource, *data_gpe_resource;
3884 struct huc_initializer_dmem *pdmem;
3885 struct huc_initializer_data *pdata;
3886 struct huc_initializer_input_command1 input_cmd1;
3887 VAEncPictureParameterBufferVP9 *pic_param;
3888 double qp_scale, lambda;
3889 uint8_t qp;
3890 int i;
3891
3892 if (!vdenc_context->pic_param)
3893 return;
3894
3895 pic_param = vdenc_context->pic_param;
3896
3897 if (vdenc_context->dys_in_use) {
3898 dmem_gpe_resource = &vdenc_context->huc_initializer_dys_dmem_buffer_res;
3899 data_gpe_resource = &vdenc_context->huc_initializer_dys_data_buffer_res;
3900 } else {
3901 dmem_gpe_resource = &vdenc_context->huc_initializer_dmem_buffer_res[vdenc_context->current_pass];
3902 data_gpe_resource = &vdenc_context->huc_initializer_data_buffer_res[vdenc_context->current_pass];
3903 }
3904
3905 pdata = i965_map_gpe_resource(data_gpe_resource);
3906
3907 if (!pdata)
3908 return;
3909
3910 memset(pdata, 0, sizeof(struct huc_initializer_data));
3911 pdata->total_commands = 2;
3912
3913 pdata->input_command[0].id = 2;
3914 pdata->input_command[0].size_of_data = 1;
3915
3916 if (vdenc_context->vp9_frame_type == VP9_FRAME_I)
3917 qp_scale = 0.31;
3918 else
3919 qp_scale = 0.33;
3920
3921 qp = pic_param->luma_ac_qindex;
3922 lambda = qp_scale * vdenc_vp9_quant_ac[qp] / 8;
3923
3924 pdata->input_command[0].data[0] = (uint32_t)(lambda * 4 + 0.5);
3925
3926 pdata->input_command[1].id = 1;
3927 pdata->input_command[1].size_of_data = 0x14;
3928
3929 memset(&input_cmd1, 0, sizeof(input_cmd1));
3930 input_cmd1.vdenc_streamin_enabled = (!!vdenc_context->segment_param || vdenc_context->hme_enabled);
3931 input_cmd1.segment_map_streamin_enabled = !!vdenc_context->segment_param;
3932 input_cmd1.pak_only_multi_pass_enabled = vdenc_context->pak_only_pass_enabled;
3933
3934 if (vdenc_context->is_key_frame)
3935 input_cmd1.num_ref_idx_l0_active_minus1 = 0;
3936 else
3937 input_cmd1.num_ref_idx_l0_active_minus1 = vdenc_context->num_ref_frames - 1;;
3938
3939 input_cmd1.sad_qp_lambda = (uint16_t)(lambda * 4 + 0.5);
3940 input_cmd1.rd_qp_lambda = (uint16_t)(lambda * lambda * 4 + 0.5);
3941
3942 input_cmd1.dst_frame_width_minus1 = vdenc_context->frame_width - 1;
3943 input_cmd1.dst_frame_height_minus1 = vdenc_context->frame_height - 1;
3944 input_cmd1.segment_enabled = pic_param->pic_flags.bits.segmentation_enabled;
3945 input_cmd1.prev_frame_segment_enabled = vdenc_context->last_frame_status.segment_enabled;
3946 input_cmd1.luma_ac_qindex = pic_param->luma_ac_qindex;
3947 input_cmd1.luma_dc_qindex_delta = pic_param->luma_dc_qindex_delta;
3948
3949 if (input_cmd1.segment_enabled && vdenc_context->segment_param) {
3950 VAEncMiscParameterTypeVP9PerSegmantParam *segment_param = vdenc_context->segment_param;
3951 VAEncSegParamVP9 *seg_param;
3952
3953 for (i = 0; i < VP9_MAX_SEGMENTS; i++) {
3954 seg_param = &segment_param->seg_data[i];
3955 input_cmd1.segment_qindex_delta[i] = seg_param->segment_qindex_delta;
3956 }
3957 }
3958
3959 memcpy(pdata->input_command[1].data, &input_cmd1, sizeof(input_cmd1));
3960 i965_unmap_gpe_resource(data_gpe_resource);
3961
3962 pdmem = i965_map_gpe_resource(dmem_gpe_resource);
3963
3964 if (!pdmem)
3965 return;
3966
3967 pdmem->total_output_commands = 2;
3968 pdmem->codec = 1;
3969 pdmem->target_usage = encoder_context->quality_level;
3970 pdmem->frame_type = pic_param->pic_flags.bits.frame_type;
3971
3972 pdmem->output_command[0].id = 2;
3973 pdmem->output_command[0].type = 1;
3974 pdmem->output_command[0].start_in_bytes = 0;
3975
3976 pdmem->output_command[1].id = 1;
3977 pdmem->output_command[1].type = 1;
3978 pdmem->output_command[1].start_in_bytes = 544;
3979
3980 pdmem->output_size = 544 + 148;
3981
3982 i965_unmap_gpe_resource(dmem_gpe_resource);
3983 }
3984
3985 static void
3986 gen10_vdenc_vp9_huc_initializer(VADriverContextP ctx,
3987 struct encode_state *encode_state,
3988 struct intel_encoder_context *encoder_context,
3989 struct i965_gpe_resource *pic_state_buffer_res)
3990 {
3991 struct intel_batchbuffer *batch = encoder_context->base.batch;
3992 struct gen10_vdenc_vp9_context *vdenc_context = encoder_context->mfc_context;
3993 struct gen10_huc_pipe_mode_select_parameter pipe_mode_select_params;
3994 struct gen10_huc_imem_state_parameter imem_state_params;
3995 struct gen10_huc_dmem_state_parameter dmem_state_params;
3996 struct gen10_huc_virtual_addr_parameter virtual_addr_params;
3997 struct gen10_huc_start_parameter start_params;
3998 struct gpe_mi_flush_dw_parameter mi_flush_dw_params;
3999 struct i965_gpe_table *gpe = vdenc_context->gpe_table;
4000 gen10_vdenc_vd_pipeline_flush_param pipeline_flush_params;
4001
4002 memset(&imem_state_params, 0, sizeof(imem_state_params));
4003 imem_state_params.huc_firmware_descriptor = VDENC_VP9_HUC_INITIALIZER;
4004 gen10_huc_imem_state(ctx, batch, &imem_state_params);
4005
4006 memset(&pipe_mode_select_params, 0, sizeof(pipe_mode_select_params));
4007 gen10_huc_pipe_mode_select(ctx, batch, &pipe_mode_select_params);
4008
4009 gen10_vdenc_vp9_huc_initializer_init(ctx, encode_state, encoder_context);
4010
4011 memset(&dmem_state_params, 0, sizeof(dmem_state_params));
4012
4013 if (vdenc_context->dys_in_use) {
4014 dmem_state_params.huc_data_source_res = &vdenc_context->huc_initializer_dys_dmem_buffer_res;
4015 } else {
4016 dmem_state_params.huc_data_source_res = &vdenc_context->huc_initializer_dmem_buffer_res[vdenc_context->current_pass];
4017 }
4018
4019 dmem_state_params.huc_data_destination_base_address = VDENC_VP9_HUC_DMEM_DATA_OFFSET;
4020 dmem_state_params.huc_data_length = ALIGN(sizeof(struct huc_initializer_dmem), 64);
4021 gen10_huc_dmem_state(ctx, batch, &dmem_state_params);
4022
4023 memset(&virtual_addr_params, 0, sizeof(virtual_addr_params));
4024
4025 if (vdenc_context->dys_in_use)
4026 virtual_addr_params.regions[0].huc_surface_res = &vdenc_context->huc_initializer_dys_data_buffer_res;
4027 else
4028 virtual_addr_params.regions[0].huc_surface_res = &vdenc_context->huc_initializer_data_buffer_res[vdenc_context->current_pass];
4029
4030 virtual_addr_params.regions[1].huc_surface_res = pic_state_buffer_res;
4031 virtual_addr_params.regions[1].is_target = 1;
4032 gen10_huc_virtual_addr_state(ctx, batch, &virtual_addr_params);
4033
4034 memset(&start_params, 0, sizeof(start_params));
4035 start_params.last_stream_object = 1;
4036 gen10_huc_start(ctx, batch, &start_params);
4037
4038 memset(&pipeline_flush_params, 0, sizeof(pipeline_flush_params));
4039 pipeline_flush_params.dw1.hevc_pipeline_done = 1;
4040 pipeline_flush_params.dw1.hevc_pipeline_flush = 1;
4041 gen10_vdenc_vd_pipeline_flush(ctx, batch, &pipeline_flush_params);
4042
4043 memset(&mi_flush_dw_params, 0, sizeof(mi_flush_dw_params));
4044 mi_flush_dw_params.video_pipeline_cache_invalidate = 1;
4045 gpe->mi_flush_dw(ctx, batch, &mi_flush_dw_params);
4046 }
4047
4048 static VAStatus
4049 gen10_vdenc_vp9_fill_pic_state_batchbuffer(VADriverContextP ctx,
4050 struct encode_state *encode_state,
4051 struct intel_encoder_context *encoder_context)
4052 {
4053 struct gen10_vdenc_vp9_context *vdenc_context = encoder_context->mfc_context;
4054 struct i965_gpe_resource *gpe_resource;
4055 VAEncPictureParameterBufferVP9 *pic_param;
4056 VAEncMiscParameterTypeVP9PerSegmantParam *seg_param, tmp_seg_param;
4057 char *pdata, *pdata_header;
4058 int i, segment_count;
4059
4060 if (!vdenc_context->pic_param)
4061 return VA_STATUS_ERROR_INVALID_PARAMETER;
4062
4063 pic_param = vdenc_context->pic_param;
4064
4065 if ((vdenc_context->dys_ref_frame_flag != VP9_REF_NONE) && vdenc_context->dys_multiple_pass_enbaled)
4066 gpe_resource = &vdenc_context->vdenc_dys_pic_state_2nd_batchbuffer_res;
4067 else
4068 gpe_resource = &vdenc_context->vdenc_pic_state_input_2nd_batchbuffer_res[vdenc_context->current_pass];
4069
4070 pdata_header = pdata = i965_map_gpe_resource(gpe_resource);
4071
4072 if (!pdata)
4073 return VA_STATUS_ERROR_UNKNOWN;
4074
4075 pdata += VDENC_VDENC_CMD0_STATE_SIZE;
4076 vdenc_context->pic_state_offset_in_2nd_batchbuffer = pdata - pdata_header;
4077 gen10_vdenc_vp9_fill_hcp_vp9_pic_state(ctx, encode_state, encoder_context, (uint32_t *)pdata);
4078 pdata += VDENC_HCP_VP9_PIC_STATE_SIZE;
4079
4080 seg_param = vdenc_context->segment_param;
4081
4082 if (pic_param->pic_flags.bits.segmentation_enabled && seg_param)
4083 segment_count = VP9_MAX_SEGMENTS;
4084 else {
4085 segment_count = 1;
4086 memset(&tmp_seg_param, 0, sizeof(tmp_seg_param));
4087 seg_param = &tmp_seg_param;
4088 }
4089
4090 for (i = 0; i < segment_count; i++) {
4091 gen10_vdenc_vp9_fill_hcp_vp9_segment_state(ctx, encode_state, encoder_context, &seg_param->seg_data[i], i, (uint32_t *)pdata);
4092 pdata += VDENC_HCP_VP9_SEGMENT_STATE_SIZE;
4093 }
4094
4095 if (segment_count < VP9_MAX_SEGMENTS) {
4096 memset(pdata, 0, VDENC_HCP_VP9_SEGMENT_STATE_SIZE * (VP9_MAX_SEGMENTS - 1));
4097 pdata += VDENC_HCP_VP9_SEGMENT_STATE_SIZE * (VP9_MAX_SEGMENTS - 1);
4098 }
4099
4100 vdenc_context->cmd1_state_offset_in_2nd_batchbuffer = pdata - pdata_header;
4101 pdata += VDENC_VDENC_CMD1_STATE_SIZE;
4102
4103 gen10_vdenc_vp9_fill_mi_batchbuffer_end(ctx, encode_state, encoder_context, (uint32_t *)pdata);
4104 pdata += VDENC_BATCHBUFFER_END_SIZE;
4105
4106 vdenc_context->huc_2nd_batchbuffer_size = pdata - pdata_header;
4107
4108 i965_unmap_gpe_resource(gpe_resource);
4109
4110 gen10_vdenc_vp9_huc_initializer(ctx,
4111 encode_state,
4112 encoder_context,
4113 gpe_resource);
4114
4115 return VA_STATUS_SUCCESS;
4116 }
4117
4118 static int
4119 gen10_vdenc_vp9_get_reference_index(uint8_t refresh_flags)
4120 {
4121 int index = 0;
4122
4123 if (refresh_flags == 0) {
4124 return 0;
4125 }
4126
4127 refresh_flags = ~refresh_flags;
4128
4129 while (refresh_flags & 1) {
4130 refresh_flags >>= 1;
4131 index++;
4132 }
4133
4134 return index;
4135 }
4136
4137 static void
4138 gen10_vdenc_vp9_update_huc_vp9_prob_dmem(VADriverContextP ctx, struct intel_encoder_context *encoder_context)
4139 {
4140 struct gen10_vdenc_vp9_context *vdenc_context = encoder_context->mfc_context;
4141 VAEncPictureParameterBufferVP9 *pic_param = vdenc_context->pic_param;
4142 VAEncMiscParameterTypeVP9PerSegmantParam *seg_param = vdenc_context->segment_param;
4143 struct vdenc_vp9_huc_prob_dmem *dmem;
4144 int i;
4145
4146 if (vdenc_context->current_pass == 0) {
4147 dmem = (struct vdenc_vp9_huc_prob_dmem *)i965_map_gpe_resource(&vdenc_context->huc_prob_dmem_buffer_res[1]);
4148
4149 if (!dmem)
4150 return;
4151
4152 memcpy(dmem, vdenc_vp9_huc_prob_dmem_data, sizeof(struct vdenc_vp9_huc_prob_dmem));
4153 i965_unmap_gpe_resource(&vdenc_context->huc_prob_dmem_buffer_res[1]);
4154
4155 dmem = (struct vdenc_vp9_huc_prob_dmem *)i965_map_gpe_resource(&vdenc_context->huc_prob_dmem_buffer_res[0]);
4156
4157 if (!dmem)
4158 return;
4159
4160 memcpy(dmem, vdenc_vp9_huc_prob_dmem_data, sizeof(struct vdenc_vp9_huc_prob_dmem));
4161 } else {
4162 dmem = (struct vdenc_vp9_huc_prob_dmem *)i965_map_gpe_resource(&vdenc_context->huc_prob_dmem_buffer_res[1]);
4163
4164 if (!dmem)
4165 return;
4166 }
4167
4168 dmem->huc_pass_num = vdenc_context->is_super_frame_huc_pass ? VDENC_VP9_HUC_SUPERFRAME_PASS : !!vdenc_context->current_pass;
4169 dmem->frame_width = vdenc_context->frame_width;
4170 dmem->frame_height = vdenc_context->frame_height;
4171
4172 if (!seg_param) {
4173 for (i = 0; i < VP9_MAX_SEGMENTS; i++) {
4174 dmem->segment_ref[i] = 0xff;
4175 dmem->segment_skip[i] = 0;
4176 }
4177 } else {
4178 for (i = 0; i < VP9_MAX_SEGMENTS; i++) {
4179 if (seg_param->seg_data[i].seg_flags.bits.segment_reference_enabled)
4180 dmem->segment_ref[i] = seg_param->seg_data[i].seg_flags.bits.segment_reference;
4181 else
4182 dmem->segment_ref[i] = 0xff;
4183
4184 dmem->segment_skip[i] = seg_param->seg_data[i].seg_flags.bits.segment_reference_skipped;
4185 }
4186 }
4187
4188 dmem->seg_code_abs = 0;
4189 dmem->seg_temporal_update = pic_param->pic_flags.bits.segmentation_temporal_update;
4190 dmem->last_ref_index = pic_param->ref_flags.bits.ref_last_idx;
4191 dmem->golden_ref_index = pic_param->ref_flags.bits.ref_gf_idx;
4192 dmem->alt_ref_index = pic_param->ref_flags.bits.ref_arf_idx;
4193 dmem->refresh_frame_flags = pic_param->refresh_frame_flags;
4194 dmem->ref_frame_flags = vdenc_context->ref_frame_flag;
4195 dmem->context_frame_types = vdenc_context->context_frame_types[pic_param->pic_flags.bits.frame_context_idx];
4196 dmem->frame_to_show = gen10_vdenc_vp9_get_reference_index(dmem->refresh_frame_flags);
4197
4198 dmem->frame_ctrl.frame_type = pic_param->pic_flags.bits.frame_type;
4199 dmem->frame_ctrl.show_frame = pic_param->pic_flags.bits.show_frame;
4200 dmem->frame_ctrl.error_resilient_mode = pic_param->pic_flags.bits.error_resilient_mode;
4201 dmem->frame_ctrl.intra_only = pic_param->pic_flags.bits.intra_only;
4202 dmem->frame_ctrl.context_reset = pic_param->pic_flags.bits.reset_frame_context;
4203 dmem->frame_ctrl.last_ref_frame_bias = pic_param->ref_flags.bits.ref_last_sign_bias;
4204 dmem->frame_ctrl.golden_ref_frame_bias = pic_param->ref_flags.bits.ref_gf_sign_bias;
4205 dmem->frame_ctrl.alt_ref_frame_bias = pic_param->ref_flags.bits.ref_arf_sign_bias;
4206 dmem->frame_ctrl.allow_high_precision_mv = pic_param->pic_flags.bits.allow_high_precision_mv;
4207 dmem->frame_ctrl.mcomp_filter_mode = pic_param->pic_flags.bits.mcomp_filter_type;
4208 dmem->frame_ctrl.tx_mode = vdenc_context->tx_mode;
4209 dmem->frame_ctrl.refresh_frame_context = pic_param->pic_flags.bits.refresh_frame_context;
4210 dmem->frame_ctrl.frame_parallel_decode = pic_param->pic_flags.bits.frame_parallel_decoding_mode;
4211 dmem->frame_ctrl.comp_pred_mode = pic_param->pic_flags.bits.comp_prediction_mode;
4212 dmem->frame_ctrl.frame_context_idx = pic_param->pic_flags.bits.frame_context_idx;
4213 dmem->frame_ctrl.sharpness_level = pic_param->sharpness_level;
4214 dmem->frame_ctrl.seg_on = pic_param->pic_flags.bits.segmentation_enabled;
4215 dmem->frame_ctrl.seg_map_update = pic_param->pic_flags.bits.segmentation_update_map;
4216 dmem->frame_ctrl.seg_update_data = 0; // TODO
4217 dmem->frame_ctrl.log2tile_cols = pic_param->log2_tile_columns;
4218 dmem->frame_ctrl.log2tile_rows = pic_param->log2_tile_rows;
4219
4220 dmem->streamin_segenable = !!seg_param;
4221 dmem->streamin_enable = !!seg_param; // TODO
4222 dmem->prev_frame_info.intra_only = vdenc_context->last_frame_status.intra_only;
4223 dmem->prev_frame_info.frame_width = vdenc_context->last_frame_status.frame_width;
4224 dmem->prev_frame_info.frame_height = vdenc_context->last_frame_status.frame_height;
4225 dmem->prev_frame_info.key_frame = vdenc_context->last_frame_status.is_key_frame;
4226 dmem->prev_frame_info.show_frame = vdenc_context->last_frame_status.show_frame;
4227 dmem->repak = (vdenc_context->num_passes > 1 && vdenc_context->current_pass == vdenc_context->num_passes - 1);
4228
4229 if (dmem->repak && vdenc_context->has_adaptive_repak) {
4230 // do nothing so far
4231 }
4232
4233 /* Must use vdenc_context->frame_header.bit_offset_first_partition_size to calculate dmem->uncomp_hdr_total_length_in_bits */
4234 dmem->loop_filter_level_bit_offset = vdenc_context->frame_header.bit_offset_lf_level;
4235 dmem->qindex_bit_offset = vdenc_context->frame_header.bit_offset_qindex;
4236 dmem->seg_bit_offset = vdenc_context->frame_header.bit_offset_segmentation + 1; // exclude segment_enable bit
4237 dmem->seg_length_in_bits = vdenc_context->frame_header.bit_size_segmentation - 1; // exclude segment_enable bit
4238 dmem->uncomp_hdr_total_length_in_bits = vdenc_context->frame_header.bit_offset_first_partition_size + 16;
4239 dmem->pic_state_offset = vdenc_context->pic_state_offset_in_2nd_batchbuffer;
4240 dmem->slb_block_size = vdenc_context->huc_2nd_batchbuffer_size;
4241 dmem->ivf_header_size = (vdenc_context->frame_number == 0) ? 44 : 12;
4242
4243 i965_unmap_gpe_resource(&vdenc_context->huc_prob_dmem_buffer_res[!!vdenc_context->current_pass]);
4244 }
4245
4246 static void
4247 gen10_vdenc_vp9_huc_vp9_prob(VADriverContextP ctx,
4248 struct encode_state *encode_state,
4249 struct intel_encoder_context *encoder_context)
4250 {
4251 struct intel_batchbuffer *batch = encoder_context->base.batch;
4252 struct gen10_vdenc_vp9_context *vdenc_context = encoder_context->mfc_context;
4253 struct gen10_huc_pipe_mode_select_parameter pipe_mode_select_params;
4254 struct gen10_huc_imem_state_parameter imem_state_params;
4255 struct gen10_huc_dmem_state_parameter dmem_state_params;
4256 struct gen10_huc_virtual_addr_parameter virtual_addr_params;
4257 struct gen10_huc_start_parameter start_params;
4258 struct gpe_mi_flush_dw_parameter mi_flush_dw_params;
4259 struct gpe_mi_store_register_mem_parameter mi_store_register_mem_params;
4260 struct gpe_mi_store_data_imm_parameter mi_store_data_imm_params;
4261 VAEncPictureParameterBufferVP9 *pic_param;
4262 struct i965_gpe_table *gpe = vdenc_context->gpe_table;
4263 gen10_vdenc_vd_pipeline_flush_param pipeline_flush_params;
4264
4265 if (!vdenc_context->pic_param)
4266 return;
4267
4268 pic_param = vdenc_context->pic_param;
4269
4270 memset(&imem_state_params, 0, sizeof(imem_state_params));
4271 imem_state_params.huc_firmware_descriptor = VDENC_VP9_HUC_PROB;
4272 gen10_huc_imem_state(ctx, batch, &imem_state_params);
4273
4274 memset(&pipe_mode_select_params, 0, sizeof(pipe_mode_select_params));
4275 gen10_huc_pipe_mode_select(ctx, batch, &pipe_mode_select_params);
4276
4277 gen10_vdenc_vp9_update_huc_vp9_prob_dmem(ctx, encoder_context);
4278
4279 memset(&dmem_state_params, 0, sizeof(dmem_state_params));
4280 dmem_state_params.huc_data_source_res = &vdenc_context->huc_prob_dmem_buffer_res[!!vdenc_context->current_pass];
4281 dmem_state_params.huc_data_destination_base_address = VDENC_VP9_HUC_DMEM_DATA_OFFSET;
4282 dmem_state_params.huc_data_length = ALIGN(sizeof(struct vdenc_vp9_huc_prob_dmem), 64);
4283 gen10_huc_dmem_state(ctx, batch, &dmem_state_params);
4284
4285 memset(&virtual_addr_params, 0, sizeof(virtual_addr_params));
4286 virtual_addr_params.regions[0].huc_surface_res = &vdenc_context->prob_buffer_res[pic_param->pic_flags.bits.frame_context_idx];
4287 virtual_addr_params.regions[0].is_target = 1;
4288
4289 virtual_addr_params.regions[1].huc_surface_res = &vdenc_context->prob_counter_buffer_res;
4290
4291 virtual_addr_params.regions[2].huc_surface_res = &vdenc_context->huc_prob_output_buffer_res;
4292 virtual_addr_params.regions[2].is_target = 1;
4293
4294 virtual_addr_params.regions[3].huc_surface_res = &vdenc_context->prob_delta_buffer_res;
4295 virtual_addr_params.regions[3].is_target = 1;
4296
4297 virtual_addr_params.regions[4].huc_surface_res = &vdenc_context->huc_pak_insert_uncompressed_header_output_2nd_batchbuffer_res;
4298 virtual_addr_params.regions[4].is_target = 1;
4299
4300 virtual_addr_params.regions[5].huc_surface_res = &vdenc_context->compressed_header_buffer_res;
4301 virtual_addr_params.regions[5].is_target = 1;
4302
4303 virtual_addr_params.regions[6].huc_surface_res = &vdenc_context->vdenc_pic_state_output_2nd_batchbuffer_res[0];
4304 virtual_addr_params.regions[6].is_target = 1;
4305
4306 if (vdenc_context->brc_enabled)
4307 virtual_addr_params.regions[7].huc_surface_res = &vdenc_context->vdenc_pic_state_output_2nd_batchbuffer_res[0];
4308 else
4309 virtual_addr_params.regions[7].huc_surface_res = &vdenc_context->vdenc_pic_state_input_2nd_batchbuffer_res[vdenc_context->current_pass];
4310
4311 virtual_addr_params.regions[8].huc_surface_res = &vdenc_context->huc_pak_insert_uncompressed_header_input_2nd_batchbuffer_res;
4312
4313 virtual_addr_params.regions[9].huc_surface_res = &vdenc_context->huc_default_prob_buffer_res;
4314
4315 virtual_addr_params.regions[10].huc_surface_res = &vdenc_context->compressed_bitstream.res;
4316 virtual_addr_params.regions[10].offset = vdenc_context->compressed_bitstream.start_offset;
4317 virtual_addr_params.regions[10].is_target = 1;
4318
4319 virtual_addr_params.regions[11].huc_surface_res = &vdenc_context->vdenc_data_extension_buffer_res;
4320 virtual_addr_params.regions[11].is_target = 1;
4321
4322 gen10_huc_virtual_addr_state(ctx, batch, &virtual_addr_params);
4323
4324 gen10_vdenc_vp9_huc_store_huc_status2(ctx, encoder_context);
4325
4326 memset(&start_params, 0, sizeof(start_params));
4327 start_params.last_stream_object = 1;
4328 gen10_huc_start(ctx, batch, &start_params);
4329
4330 memset(&pipeline_flush_params, 0, sizeof(pipeline_flush_params));
4331 pipeline_flush_params.dw1.hevc_pipeline_done = 1;
4332 pipeline_flush_params.dw1.hevc_pipeline_flush = 1;
4333 gen10_vdenc_vd_pipeline_flush(ctx, batch, &pipeline_flush_params);
4334
4335 memset(&mi_flush_dw_params, 0, sizeof(mi_flush_dw_params));
4336 mi_flush_dw_params.video_pipeline_cache_invalidate = 1;
4337 gpe->mi_flush_dw(ctx, batch, &mi_flush_dw_params);
4338
4339 /* Write HUC_STATUS mask (1 << 31) */
4340 memset(&mi_store_data_imm_params, 0, sizeof(mi_store_data_imm_params));
4341 mi_store_data_imm_params.bo = vdenc_context->huc_status_buffer_res.bo;
4342 mi_store_data_imm_params.offset = 4;
4343 mi_store_data_imm_params.dw0 = (1 << 31);
4344 gpe->mi_store_data_imm(ctx, batch, &mi_store_data_imm_params);
4345
4346 /* Store HUC_STATUS */
4347 memset(&mi_store_register_mem_params, 0, sizeof(mi_store_register_mem_params));
4348 mi_store_register_mem_params.mmio_offset = VCS0_HUC_STATUS;
4349 mi_store_register_mem_params.bo = vdenc_context->huc_status_buffer_res.bo;
4350 gpe->mi_store_register_mem(ctx, batch, &mi_store_register_mem_params);
4351
4352 if (vdenc_context->is_super_frame_huc_pass) {
4353 // TODO, enable for super frame
4354 }
4355 }
4356
4357 static VAStatus
4358 gen10_vdenc_vp9_encode_picture(VADriverContextP ctx,
4359 VAProfile profile,
4360 struct encode_state *encode_state,
4361 struct intel_encoder_context *encoder_context)
4362 {
4363 VAStatus va_status;
4364 struct gen10_vdenc_vp9_context *vdenc_context = encoder_context->mfc_context;
4365 struct intel_batchbuffer *batch = encoder_context->base.batch;
4366 VAEncPictureParameterBufferVP9 *pic_param;
4367
4368 va_status = gen10_vdenc_vp9_check_capability(ctx, encode_state, encoder_context);
4369
4370 if (va_status != VA_STATUS_SUCCESS)
4371 return va_status;
4372
4373 gen10_vdenc_vp9_prepare(ctx, profile, encode_state, encoder_context);
4374
4375 vdenc_context->submit_batchbuffer = 1;
4376 vdenc_context->vdenc_pak_object_streamout_enable = 0;
4377
4378 for (vdenc_context->current_pass = 0; vdenc_context->current_pass < vdenc_context->num_passes; vdenc_context->current_pass++) {
4379 vdenc_context->is_first_pass = (vdenc_context->current_pass == 0);
4380 vdenc_context->is_last_pass = (vdenc_context->current_pass == (vdenc_context->num_passes - 1));
4381
4382 if (vdenc_context->submit_batchbuffer) {
4383 intel_batchbuffer_start_atomic_bcs_override(batch, 0x1000, BSD_RING0);
4384 intel_batchbuffer_emit_mi_flush(batch);
4385 }
4386
4387 if (vdenc_context->dys_ref_frame_flag == VP9_REF_NONE) {
4388 if (vdenc_context->current_pass == 0 &&
4389 vdenc_context->brc_enabled) {
4390 vdenc_context->vdenc_pak_object_streamout_enable = 1;
4391 }
4392 } else {
4393 gen10_vdenc_vp9_dys_ref_frames(ctx, encode_state, encoder_context);
4394 }
4395
4396 gen10_vdenc_vp9_fill_pak_insert_object_batchbuffer(ctx, encode_state, encoder_context);
4397 gen10_vdenc_vp9_fill_pic_state_batchbuffer(ctx, encode_state, encoder_context);
4398
4399 intel_batchbuffer_emit_mi_flush(batch);
4400
4401 if (vdenc_context->brc_enabled) {
4402 assert(vdenc_context->num_passes > 1);
4403
4404 if (!vdenc_context->brc_initted || vdenc_context->brc_need_reset)
4405 gen10_vdenc_vp9_huc_brc_init_reset(ctx, encode_state, encoder_context);
4406
4407 if (vdenc_context->current_pass < (vdenc_context->num_passes - 1) ||
4408 (vdenc_context->current_pass == 0 &&
4409 vdenc_context->num_passes == 1))
4410 gen10_vdenc_vp9_huc_brc_update(ctx, encode_state, encoder_context);
4411
4412 /* intel_batchbuffer_emit_mi_flush(batch); */
4413 }
4414
4415 if ((vdenc_context->current_pass == 0) || (vdenc_context->current_pass == (vdenc_context->num_passes - 1)))
4416 gen10_vdenc_vp9_huc_vp9_prob(ctx, encode_state, encoder_context);
4417
4418 gen10_vdenc_vp9_hcp_vdenc_pipeline(ctx, encode_state, encoder_context);
4419 gen10_vdenc_vp9_read_status(ctx, encoder_context);
4420
4421 if (vdenc_context->submit_batchbuffer) {
4422 intel_batchbuffer_end_atomic(batch);
4423 intel_batchbuffer_flush(batch);
4424 }
4425
4426 vdenc_context->brc_initted = 1;
4427 vdenc_context->brc_need_reset = 0;
4428 }
4429
4430 assert(vdenc_context->pic_param);
4431 pic_param = vdenc_context->pic_param;
4432 vdenc_context->last_frame_status.frame_width = pic_param->frame_width_dst;
4433 vdenc_context->last_frame_status.frame_height = pic_param->frame_height_dst;
4434 vdenc_context->last_frame_status.is_key_frame = vdenc_context->is_key_frame;
4435 vdenc_context->last_frame_status.show_frame = pic_param->pic_flags.bits.show_frame;
4436 vdenc_context->last_frame_status.refresh_frame_context = pic_param->pic_flags.bits.refresh_frame_context;
4437 vdenc_context->last_frame_status.frame_context_idx = pic_param->pic_flags.bits.frame_context_idx;
4438 vdenc_context->last_frame_status.intra_only = (vdenc_context->vp9_frame_type == VP9_FRAME_I);
4439 vdenc_context->last_frame_status.segment_enabled = !!vdenc_context->segment_param;
4440 vdenc_context->context_frame_types[pic_param->pic_flags.bits.frame_context_idx] = pic_param->pic_flags.bits.frame_type;
4441 vdenc_context->frame_number++;
4442 vdenc_context->curr_mv_temporal_index ^= 1;
4443 vdenc_context->is_first_frame = 0;
4444
4445 return VA_STATUS_SUCCESS;
4446 }
4447
4448 static VAStatus
4449 gen10_vdenc_vp9_pipeline(VADriverContextP ctx,
4450 VAProfile profile,
4451 struct encode_state *encode_state,
4452 struct intel_encoder_context *encoder_context)
4453 {
4454 VAStatus vaStatus;
4455
4456 switch (profile) {
4457 case VAProfileVP9Profile0:
4458 vaStatus = gen10_vdenc_vp9_encode_picture(ctx, profile, encode_state, encoder_context);
4459 break;
4460
4461 default:
4462 vaStatus = VA_STATUS_ERROR_UNSUPPORTED_PROFILE;
4463 break;
4464 }
4465
4466 return vaStatus;
4467 }
4468
4469 static void
4470 gen10_vdenc_vp9_free_resources(struct gen10_vdenc_vp9_context *vdenc_context)
4471 {
4472 int i;
4473
4474 /* PAK buffer */
4475 i965_free_gpe_resource(&vdenc_context->brc_history_buffer_res);
4476 i965_free_gpe_resource(&vdenc_context->brc_constant_data_buffer_res);
4477 i965_free_gpe_resource(&vdenc_context->brc_bitstream_size_buffer_res);
4478 i965_free_gpe_resource(&vdenc_context->brc_huc_data_buffer_res);
4479
4480 /* HME */
4481 i965_free_gpe_resource(&vdenc_context->s4x_memv_data_buffer_res);
4482 i965_free_gpe_resource(&vdenc_context->s4x_memv_distortion_buffer_res);
4483 i965_free_gpe_resource(&vdenc_context->s16x_memv_data_buffer_res);
4484 i965_free_gpe_resource(&vdenc_context->output_16x16_inter_modes_buffer_res);
4485
4486 for (i = 0; i < 2; i++) {
4487 i965_free_gpe_resource(&vdenc_context->mode_decision_buffer_res[i]);
4488 i965_free_gpe_resource(&vdenc_context->mv_temporal_buffer_res[i]);
4489 }
4490
4491 i965_free_gpe_resource(&vdenc_context->mb_code_buffer_res);
4492 i965_free_gpe_resource(&vdenc_context->mb_segment_map_buffer_res);
4493
4494 /* PAK resource */
4495 i965_free_gpe_resource(&vdenc_context->hvd_line_buffer_res);
4496 i965_free_gpe_resource(&vdenc_context->hvd_tile_line_buffer_res);
4497 i965_free_gpe_resource(&vdenc_context->deblocking_filter_line_buffer_res);
4498 i965_free_gpe_resource(&vdenc_context->deblocking_filter_tile_line_buffer_res);
4499 i965_free_gpe_resource(&vdenc_context->deblocking_filter_tile_col_buffer_res);
4500
4501 i965_free_gpe_resource(&vdenc_context->metadata_line_buffer_res);
4502 i965_free_gpe_resource(&vdenc_context->metadata_tile_line_buffer_res);
4503 i965_free_gpe_resource(&vdenc_context->metadata_tile_col_buffer_res);
4504
4505 i965_free_gpe_resource(&vdenc_context->segmentid_buffer_res);
4506
4507 for (i = 0; i < 4; i++) {
4508 i965_free_gpe_resource(&vdenc_context->prob_buffer_res[i]);
4509 }
4510
4511 i965_free_gpe_resource(&vdenc_context->prob_counter_buffer_res);
4512 i965_free_gpe_resource(&vdenc_context->prob_delta_buffer_res);
4513
4514 i965_free_gpe_resource(&vdenc_context->compressed_header_buffer_res);
4515 i965_free_gpe_resource(&vdenc_context->tile_record_streamout_buffer_res);
4516 i965_free_gpe_resource(&vdenc_context->cu_stat_streamout_buffer_res);
4517
4518 /* HuC */
4519 for (i = 0; i < 2; i++) {
4520 i965_free_gpe_resource(&vdenc_context->huc_prob_dmem_buffer_res[i]);
4521 }
4522
4523 i965_free_gpe_resource(&vdenc_context->huc_default_prob_buffer_res);
4524 i965_free_gpe_resource(&vdenc_context->huc_prob_output_buffer_res);
4525 i965_free_gpe_resource(&vdenc_context->huc_pak_insert_uncompressed_header_input_2nd_batchbuffer_res);
4526 i965_free_gpe_resource(&vdenc_context->huc_pak_insert_uncompressed_header_output_2nd_batchbuffer_res);
4527
4528 /* VDEnc */
4529 i965_free_gpe_resource(&vdenc_context->vdenc_row_store_scratch_res);
4530 i965_free_gpe_resource(&vdenc_context->vdenc_brc_stat_buffer_res);
4531
4532 for (i = 0; i < 4; i++) {
4533 i965_free_gpe_resource(&vdenc_context->vdenc_pic_state_input_2nd_batchbuffer_res[i]);
4534 i965_free_gpe_resource(&vdenc_context->vdenc_pic_state_output_2nd_batchbuffer_res[i]);
4535 }
4536
4537 i965_free_gpe_resource(&vdenc_context->vdenc_dys_pic_state_2nd_batchbuffer_res);
4538 i965_free_gpe_resource(&vdenc_context->vdenc_brc_init_reset_dmem_buffer_res);
4539
4540 for (i = 0; i < VDENC_VP9_BRC_MAX_NUM_OF_PASSES; i++)
4541 i965_free_gpe_resource(&vdenc_context->vdenc_brc_update_dmem_buffer_res[i]);
4542
4543 i965_free_gpe_resource(&vdenc_context->vdenc_segment_map_stream_out_buffer_res);
4544 i965_free_gpe_resource(&vdenc_context->vdenc_brc_pak_stat_buffer_res);
4545 i965_free_gpe_resource(&vdenc_context->vdenc_sse_src_pixel_row_store_buffer_res);
4546 i965_free_gpe_resource(&vdenc_context->vdenc_data_extension_buffer_res);
4547 i965_free_gpe_resource(&vdenc_context->vdenc_streamin_buffer_res);
4548 i965_free_gpe_resource(&vdenc_context->huc_status2_buffer_res);
4549 i965_free_gpe_resource(&vdenc_context->huc_status_buffer_res);
4550
4551 /* Reconstructed picture */
4552 i965_free_gpe_resource(&vdenc_context->recon_surface_res);
4553 i965_free_gpe_resource(&vdenc_context->scaled_4x_recon_surface_res);
4554 i965_free_gpe_resource(&vdenc_context->scaled_8x_recon_surface_res);
4555 i965_free_gpe_resource(&vdenc_context->scaled_16x_recon_surface_res);
4556
4557 /* HuC Initializer */
4558 for (i = 0; i < VDENC_VP9_BRC_MAX_NUM_OF_PASSES; i++) {
4559 i965_free_gpe_resource(&vdenc_context->huc_initializer_dmem_buffer_res[i]);
4560 i965_free_gpe_resource(&vdenc_context->huc_initializer_data_buffer_res[i]);
4561 }
4562
4563 i965_free_gpe_resource(&vdenc_context->huc_initializer_dys_dmem_buffer_res);
4564 i965_free_gpe_resource(&vdenc_context->huc_initializer_dys_data_buffer_res);
4565
4566 /* Reference */
4567 i965_free_gpe_resource(&vdenc_context->last_ref_res);
4568 i965_free_gpe_resource(&vdenc_context->golden_ref_res);
4569 i965_free_gpe_resource(&vdenc_context->alt_ref_res);
4570
4571 /* Input YUV */
4572 i965_free_gpe_resource(&vdenc_context->uncompressed_input_yuv_surface_res);
4573
4574 /* Compressed bitstream */
4575 i965_free_gpe_resource(&vdenc_context->compressed_bitstream.res);
4576
4577 /* Status buffer */
4578 i965_free_gpe_resource(&vdenc_context->status_bffuer.res);
4579
4580 free(vdenc_context->frame_header_data);
4581 vdenc_context->frame_header_data = NULL;
4582 }
4583
4584
4585 static void
4586 gen10_vdenc_vp9_context_destroy(void *context)
4587 {
4588 struct gen10_vdenc_vp9_context *vdenc_context = context;
4589
4590 gen10_vdenc_vp9_kernel_context_destroy(vdenc_context);
4591 gen10_vdenc_vp9_free_resources(vdenc_context);
4592
4593 free(vdenc_context);
4594 }
4595
4596 static VAStatus
4597 gen10_vdenc_vp9_context_get_status(VADriverContextP ctx,
4598 struct intel_encoder_context *encoder_context,
4599 struct i965_coded_buffer_segment *coded_buffer_segment)
4600 {
4601 struct gen10_vdenc_vp9_status *vdenc_status = (struct gen10_vdenc_vp9_status *)coded_buffer_segment->codec_private_data;
4602
4603 coded_buffer_segment->base.size = vdenc_status->bytes_per_frame;
4604
4605 return VA_STATUS_SUCCESS;
4606 }
4607
4608 Bool
4609 gen10_vdenc_vp9_context_init(VADriverContextP ctx, struct intel_encoder_context *encoder_context)
4610 {
4611 struct i965_driver_data *i965 = i965_driver_data(ctx);
4612 struct gen10_vdenc_vp9_context *vdenc_context = calloc(1, sizeof(struct gen10_vdenc_vp9_context));
4613
4614 if (!vdenc_context)
4615 return False;
4616
4617 vdenc_context->gpe_table = &i965->gpe_table;
4618 vdenc_context->brc_initted = 0;
4619 vdenc_context->brc_need_reset = 0;
4620 vdenc_context->current_pass = 0;
4621 vdenc_context->num_passes = 1;
4622 vdenc_context->vdenc_pak_threshold_check_enable = 0;
4623 vdenc_context->dys_enabled = 0; // TODO
4624 vdenc_context->is_first_frame = 1;
4625 vdenc_context->has_hme = 0;
4626 vdenc_context->need_hme = 0;
4627 vdenc_context->hme_enabled = 0;
4628 vdenc_context->has_hme_16x = 0;
4629 vdenc_context->hme_16x_enabled = 0;
4630 vdenc_context->use_huc = 1;
4631 vdenc_context->multiple_pass_brc_enabled = 0;
4632 vdenc_context->has_adaptive_repak = 0;
4633 vdenc_context->use_hw_scoreboard = 1;
4634 vdenc_context->use_hw_non_stalling_scoreborad = 1; /* default: non-stalling */
4635
4636 gen10_vdenc_vp9_gpe_context_init(ctx, encoder_context, vdenc_context);
4637
4638 encoder_context->mfc_context = vdenc_context;
4639 encoder_context->mfc_context_destroy = gen10_vdenc_vp9_context_destroy;
4640 encoder_context->mfc_pipeline = gen10_vdenc_vp9_pipeline;
4641 encoder_context->mfc_brc_prepare = gen10_vdenc_vp9_context_brc_prepare;
4642 encoder_context->get_status = gen10_vdenc_vp9_context_get_status;
4643
4644 return True;
4645 }