1 /*
2 * Copyright 2022 Kylin Software Co., Ltd.
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * on the rights to use, copy, modify, merge, publish, distribute, sub
8 * license, and/or sell copies of the Software, and to permit persons to whom
9 * the Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice (including the next
12 * paragraph) shall be included in all copies or substantial portions of the
13 * Software.
14 *
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
18 * THE AUTHOR(S) AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
19 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
20 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
21 * USE OR OTHER DEALINGS IN THE SOFTWARE.
22 */
23
24 /**
25 * @file
26 * Virgl video driver implementation.
27 *
28 * The virgl video driver acts as the frontend, and the virglrenderer acts as
29 * the backend. Currently, the backend is implemented via VA-API, but it is
30 * not limited to this.
31 *
32 * The relationship between vaSurface and video buffer objects:
33 *
34 * GUEST (Mesa) | HOST (Virglrenderer)
35 * |
36 * +------------+ | +------------+
37 * | vaSurface | | | vaSurface | <------+
38 * +------------+ | +------------+ |
39 * | | |
40 * +---------------------------+ | +-------------------------+ |
41 * | virgl_video_buffer | | | vrend_video_buffer | |
42 * | +-----------------------+ | | | +-------------------+ | |
43 * | | vl_video_buffer | | | | | vrend_resource(s) | | |
44 * | | +-------------------+ | |<--+-->| +-------------------+ | |
45 * | | | virgl_resource(s) | | | | | +--------------------+ | |
46 * | | +-------------------+ | | | | | virgl_video_buffer |-+--+
47 * | +-----------------------+ | | | +--------------------+ |
48 * +---------------------------+ | +-------------------------+
49 *
50 * The relationship between vaContext and video codec objects:
51 *
52 * GUEST (Mesa) | HOST (Virglrenderer)
53 * |
54 * +------------+ | +------------+
55 * | vaContext | | | vaContext | <-------+
56 * +------------+ | +------------+ |
57 * | | |
58 * +------------------------+ | +--------------------------+ |
59 * | virgl_video_codec | <--+--> | vrend_video_codec | |
60 * +------------------------+ | | +--------------------+ | |
61 * | | | virgl_video_codec | -+--+
62 * | | +--------------------+ |
63 * | +--------------------------+
64 *
65 * @author Feng Jiang <[email protected]>
66 */
67
68 #include <string.h>
69
70 #include "vl/vl_decoder.h"
71 #include "vl/vl_video_buffer.h"
72 #include "util/u_video.h"
73 #include "util/u_memory.h"
74 #include "util/macros.h"
75
76 #include "virgl_screen.h"
77 #include "virgl_resource.h"
78 #include "virgl_encode.h"
79 #include "virgl_video.h"
80 #include "virtio-gpu/virgl_video_hw.h"
81
82 /*
83 * The max size of bs buffer is approximately:
84 * num_of_macroblocks * max_size_of_per_macroblock + size_of_some_headers
85 * Now, we only support YUV420 formats, this means that we have a limit of
86 * 3200 bits(400 Bytes) per macroblock. To simplify the calculation, we
87 * directly use 512 instead of 400.
88 */
89 #define BS_BUF_DEFAULT_SIZE(width, height) \
90 ((width) * (height) / (VL_MACROBLOCK_WIDTH * VL_MACROBLOCK_HEIGHT) * 512)
91
switch_buffer(struct virgl_video_codec * vcdc)92 static void switch_buffer(struct virgl_video_codec *vcdc)
93 {
94 vcdc->cur_buffer++;
95 vcdc->cur_buffer %= VIRGL_VIDEO_CODEC_BUF_NUM;
96 }
97
98 #define ITEM_SET(dest, src, item) (dest)->item = (src)->item
99 #define ITEM_CPY(dest, src, item) memcpy(&(dest)->item, &(src)->item, sizeof((dest)->item))
100
fill_base_picture_desc(const struct pipe_picture_desc * desc,struct virgl_base_picture_desc * vbase)101 static int fill_base_picture_desc(const struct pipe_picture_desc *desc,
102 struct virgl_base_picture_desc *vbase)
103 {
104 ITEM_SET(vbase, desc, profile);
105 ITEM_SET(vbase, desc, entry_point);
106 ITEM_SET(vbase, desc, protected_playback);
107 ITEM_SET(vbase, desc, key_size);
108 memcpy(vbase->decrypt_key, desc->decrypt_key,
109 MIN2(desc->key_size, sizeof(vbase->decrypt_key)));
110
111 return 0;
112 }
113
fill_h264_picture_desc(const struct pipe_picture_desc * desc,union virgl_picture_desc * vdsc)114 static int fill_h264_picture_desc(const struct pipe_picture_desc *desc,
115 union virgl_picture_desc *vdsc)
116 {
117 unsigned i;
118 struct virgl_video_buffer *vbuf;
119
120 struct virgl_h264_picture_desc *vh264 = &vdsc->h264;
121 struct virgl_h264_pps *vpps = &vh264->pps;
122 struct virgl_h264_sps *vsps = &vh264->pps.sps;
123
124 struct pipe_h264_picture_desc *h264 = (struct pipe_h264_picture_desc *)desc;
125 struct pipe_h264_pps *pps = h264->pps;
126 struct pipe_h264_sps *sps = h264->pps->sps;
127
128 fill_base_picture_desc(desc, &vh264->base);
129
130 ITEM_SET(vsps, sps, level_idc);
131 ITEM_SET(vsps, sps, chroma_format_idc);
132 ITEM_SET(vsps, sps, separate_colour_plane_flag);
133 ITEM_SET(vsps, sps, bit_depth_luma_minus8);
134 ITEM_SET(vsps, sps, bit_depth_chroma_minus8);
135 ITEM_SET(vsps, sps, seq_scaling_matrix_present_flag);
136 ITEM_CPY(vsps, sps, ScalingList4x4);
137 ITEM_CPY(vsps, sps, ScalingList8x8);
138 ITEM_SET(vsps, sps, log2_max_frame_num_minus4);
139 ITEM_SET(vsps, sps, pic_order_cnt_type);
140 ITEM_SET(vsps, sps, log2_max_pic_order_cnt_lsb_minus4);
141 ITEM_SET(vsps, sps, delta_pic_order_always_zero_flag);
142 ITEM_SET(vsps, sps, offset_for_non_ref_pic);
143 ITEM_SET(vsps, sps, offset_for_top_to_bottom_field);
144 ITEM_CPY(vsps, sps, offset_for_ref_frame);
145 ITEM_SET(vsps, sps, num_ref_frames_in_pic_order_cnt_cycle);
146 ITEM_SET(vsps, sps, max_num_ref_frames);
147 ITEM_SET(vsps, sps, frame_mbs_only_flag);
148 ITEM_SET(vsps, sps, mb_adaptive_frame_field_flag);
149 ITEM_SET(vsps, sps, direct_8x8_inference_flag);
150 ITEM_SET(vsps, sps, MinLumaBiPredSize8x8);
151
152 ITEM_SET(vpps, pps, entropy_coding_mode_flag);
153 ITEM_SET(vpps, pps, bottom_field_pic_order_in_frame_present_flag);
154 ITEM_SET(vpps, pps, num_slice_groups_minus1);
155 ITEM_SET(vpps, pps, slice_group_map_type);
156 ITEM_SET(vpps, pps, slice_group_change_rate_minus1);
157 ITEM_SET(vpps, pps, num_ref_idx_l0_default_active_minus1);
158 ITEM_SET(vpps, pps, num_ref_idx_l1_default_active_minus1);
159 ITEM_SET(vpps, pps, weighted_pred_flag);
160 ITEM_SET(vpps, pps, weighted_bipred_idc);
161 ITEM_SET(vpps, pps, pic_init_qp_minus26);
162 ITEM_SET(vpps, pps, pic_init_qs_minus26);
163 ITEM_SET(vpps, pps, chroma_qp_index_offset);
164 ITEM_SET(vpps, pps, deblocking_filter_control_present_flag);
165 ITEM_SET(vpps, pps, constrained_intra_pred_flag);
166 ITEM_SET(vpps, pps, redundant_pic_cnt_present_flag);
167 ITEM_CPY(vpps, pps, ScalingList4x4);
168 ITEM_CPY(vpps, pps, ScalingList8x8);
169 ITEM_SET(vpps, pps, transform_8x8_mode_flag);
170 ITEM_SET(vpps, pps, second_chroma_qp_index_offset);
171
172 ITEM_SET(vh264, h264, frame_num);
173 ITEM_SET(vh264, h264, field_pic_flag);
174 ITEM_SET(vh264, h264, bottom_field_flag);
175 ITEM_SET(vh264, h264, num_ref_idx_l0_active_minus1);
176 ITEM_SET(vh264, h264, num_ref_idx_l1_active_minus1);
177 ITEM_SET(vh264, h264, slice_count);
178 ITEM_CPY(vh264, h264, field_order_cnt);
179 ITEM_SET(vh264, h264, is_reference);
180 ITEM_SET(vh264, h264, num_ref_frames);
181 ITEM_CPY(vh264, h264, field_order_cnt_list);
182 ITEM_CPY(vh264, h264, frame_num_list);
183
184 for (i = 0; i < 16; i++) {
185 ITEM_SET(vh264, h264, is_long_term[i]);
186 ITEM_SET(vh264, h264, top_is_reference[i]);
187 ITEM_SET(vh264, h264, bottom_is_reference[i]);
188
189 vbuf = virgl_video_buffer(h264->ref[i]);
190 vh264->buffer_id[i] = vbuf ? vbuf->handle : 0;
191 }
192
193 return 0;
194 }
195
fill_h264_enc_picture_desc(const struct pipe_picture_desc * desc,union virgl_picture_desc * vdsc)196 static int fill_h264_enc_picture_desc(const struct pipe_picture_desc *desc,
197 union virgl_picture_desc *vdsc)
198 {
199 unsigned i;
200 struct virgl_h264_enc_picture_desc *vh264 = &vdsc->h264_enc;
201 struct pipe_h264_enc_picture_desc *h264 = (struct pipe_h264_enc_picture_desc *)desc;
202
203 fill_base_picture_desc(desc, &vh264->base);
204
205 /* seq param */
206 ITEM_SET(vh264, h264, seq.enc_constraint_set_flags);
207 ITEM_SET(vh264, h264, seq.enc_frame_cropping_flag);
208 ITEM_SET(vh264, h264, seq.enc_frame_crop_left_offset);
209 ITEM_SET(vh264, h264, seq.enc_frame_crop_right_offset);
210 ITEM_SET(vh264, h264, seq.enc_frame_crop_top_offset);
211 ITEM_SET(vh264, h264, seq.enc_frame_crop_bottom_offset);
212 ITEM_SET(vh264, h264, seq.pic_order_cnt_type);
213 ITEM_SET(vh264, h264, seq.num_temporal_layers);
214 ITEM_SET(vh264, h264, seq.vui_parameters_present_flag);
215 ITEM_SET(vh264, h264, seq.vui_flags.aspect_ratio_info_present_flag);
216 ITEM_SET(vh264, h264, seq.vui_flags.timing_info_present_flag);
217 ITEM_SET(vh264, h264, seq.aspect_ratio_idc);
218 ITEM_SET(vh264, h264, seq.sar_width);
219 ITEM_SET(vh264, h264, seq.sar_height);
220 ITEM_SET(vh264, h264, seq.num_units_in_tick);
221 ITEM_SET(vh264, h264, seq.time_scale);
222
223 /* rate_ctrl */
224 for (i = 0; i < 4; i++) {
225 ITEM_SET(vh264, h264, rate_ctrl[i].rate_ctrl_method);
226 ITEM_SET(vh264, h264, rate_ctrl[i].target_bitrate);
227 ITEM_SET(vh264, h264, rate_ctrl[i].peak_bitrate);
228 ITEM_SET(vh264, h264, rate_ctrl[i].frame_rate_num);
229 ITEM_SET(vh264, h264, rate_ctrl[i].frame_rate_den);
230 ITEM_SET(vh264, h264, rate_ctrl[i].vbv_buffer_size);
231 ITEM_SET(vh264, h264, rate_ctrl[i].vbv_buf_lv);
232 ITEM_SET(vh264, h264, rate_ctrl[i].fill_data_enable);
233 ITEM_SET(vh264, h264, rate_ctrl[i].skip_frame_enable);
234 ITEM_SET(vh264, h264, rate_ctrl[i].enforce_hrd);
235 ITEM_SET(vh264, h264, rate_ctrl[i].max_au_size);
236 ITEM_SET(vh264, h264, rate_ctrl[i].max_qp);
237 ITEM_SET(vh264, h264, rate_ctrl[i].min_qp);
238 }
239
240 /* motion_est */
241 ITEM_SET(vh264, h264, motion_est.motion_est_quarter_pixel);
242 ITEM_SET(vh264, h264, motion_est.enc_disable_sub_mode);
243 ITEM_SET(vh264, h264, motion_est.lsmvert);
244 ITEM_SET(vh264, h264, motion_est.enc_en_ime_overw_dis_subm);
245 ITEM_SET(vh264, h264, motion_est.enc_ime_overw_dis_subm_no);
246 ITEM_SET(vh264, h264, motion_est.enc_ime2_search_range_x);
247 ITEM_SET(vh264, h264, motion_est.enc_ime2_search_range_y);
248
249 /* pic_ctrl */
250 ITEM_SET(vh264, h264, pic_ctrl.enc_cabac_enable);
251 ITEM_SET(vh264, h264, pic_ctrl.enc_cabac_init_idc);
252
253 ITEM_SET(vh264, h264, intra_idr_period);
254
255 ITEM_SET(vh264, h264, quant_i_frames);
256 ITEM_SET(vh264, h264, quant_p_frames);
257 ITEM_SET(vh264, h264, quant_b_frames);
258
259 ITEM_SET(vh264, h264, picture_type);
260 ITEM_SET(vh264, h264, frame_num);
261 ITEM_SET(vh264, h264, frame_num_cnt);
262 ITEM_SET(vh264, h264, p_remain);
263 ITEM_SET(vh264, h264, i_remain);
264 ITEM_SET(vh264, h264, idr_pic_id);
265 ITEM_SET(vh264, h264, gop_cnt);
266 ITEM_SET(vh264, h264, pic_order_cnt);
267 ITEM_SET(vh264, h264, num_ref_idx_l0_active_minus1);
268 ITEM_SET(vh264, h264, num_ref_idx_l1_active_minus1);
269
270 for (i = 0; i < 32; i++) {
271 ITEM_SET(vh264, h264, ref_idx_l0_list[i]);
272 ITEM_SET(vh264, h264, ref_idx_l1_list[i]);
273 ITEM_SET(vh264, h264, l0_is_long_term[i]);
274 ITEM_SET(vh264, h264, l1_is_long_term[i]);
275 }
276
277 ITEM_SET(vh264, h264, gop_size);
278
279 ITEM_SET(vh264, h264, quality_modes.level);
280 ITEM_SET(vh264, h264, quality_modes.preset_mode);
281 ITEM_SET(vh264, h264, quality_modes.pre_encode_mode);
282 ITEM_SET(vh264, h264, quality_modes.vbaq_mode);
283
284 ITEM_SET(vh264, h264, not_referenced);
285 ITEM_SET(vh264, h264, is_ltr);
286 ITEM_SET(vh264, h264, ltr_index);
287 ITEM_SET(vh264, h264, enable_vui);
288
289 ITEM_SET(vh264, h264, num_slice_descriptors);
290 for (i = 0; i < vh264->num_slice_descriptors; i++) {
291 ITEM_SET(vh264, h264, slices_descriptors[i].macroblock_address);
292 ITEM_SET(vh264, h264, slices_descriptors[i].num_macroblocks);
293 ITEM_SET(vh264, h264, slices_descriptors[i].slice_type);
294 }
295
296 return 0;
297 }
298
fill_h265_picture_desc(const struct pipe_picture_desc * desc,union virgl_picture_desc * vdsc)299 static int fill_h265_picture_desc(const struct pipe_picture_desc *desc,
300 union virgl_picture_desc *vdsc)
301 {
302 unsigned i;
303 struct virgl_video_buffer *vbuf;
304
305 struct virgl_h265_picture_desc *vh265 = &vdsc->h265;
306 struct pipe_h265_picture_desc *h265 = (struct pipe_h265_picture_desc *)desc;
307
308 fill_base_picture_desc(desc, &vh265->base);
309
310 ITEM_SET(&vh265->pps.sps, h265->pps->sps, chroma_format_idc);
311 ITEM_SET(&vh265->pps.sps, h265->pps->sps, separate_colour_plane_flag);
312 ITEM_SET(&vh265->pps.sps, h265->pps->sps, pic_width_in_luma_samples);
313 ITEM_SET(&vh265->pps.sps, h265->pps->sps, pic_height_in_luma_samples);
314 ITEM_SET(&vh265->pps.sps, h265->pps->sps, bit_depth_luma_minus8);
315 ITEM_SET(&vh265->pps.sps, h265->pps->sps, bit_depth_chroma_minus8);
316 ITEM_SET(&vh265->pps.sps, h265->pps->sps, log2_max_pic_order_cnt_lsb_minus4);
317 ITEM_SET(&vh265->pps.sps, h265->pps->sps, sps_max_dec_pic_buffering_minus1);
318 ITEM_SET(&vh265->pps.sps, h265->pps->sps, log2_min_luma_coding_block_size_minus3);
319 ITEM_SET(&vh265->pps.sps, h265->pps->sps, log2_diff_max_min_luma_coding_block_size);
320 ITEM_SET(&vh265->pps.sps, h265->pps->sps, log2_min_transform_block_size_minus2);
321 ITEM_SET(&vh265->pps.sps, h265->pps->sps, log2_diff_max_min_transform_block_size);
322 ITEM_SET(&vh265->pps.sps, h265->pps->sps, max_transform_hierarchy_depth_inter);
323 ITEM_SET(&vh265->pps.sps, h265->pps->sps, max_transform_hierarchy_depth_intra);
324 ITEM_SET(&vh265->pps.sps, h265->pps->sps, scaling_list_enabled_flag);
325 ITEM_CPY(&vh265->pps.sps, h265->pps->sps, ScalingList4x4);
326 ITEM_CPY(&vh265->pps.sps, h265->pps->sps, ScalingList8x8);
327 ITEM_CPY(&vh265->pps.sps, h265->pps->sps, ScalingList16x16);
328 ITEM_CPY(&vh265->pps.sps, h265->pps->sps, ScalingList32x32);
329 ITEM_CPY(&vh265->pps.sps, h265->pps->sps, ScalingListDCCoeff16x16);
330 ITEM_CPY(&vh265->pps.sps, h265->pps->sps, ScalingListDCCoeff32x32);
331 ITEM_SET(&vh265->pps.sps, h265->pps->sps, amp_enabled_flag);
332 ITEM_SET(&vh265->pps.sps, h265->pps->sps, sample_adaptive_offset_enabled_flag);
333 ITEM_SET(&vh265->pps.sps, h265->pps->sps, pcm_enabled_flag);
334 ITEM_SET(&vh265->pps.sps, h265->pps->sps, pcm_sample_bit_depth_luma_minus1);
335 ITEM_SET(&vh265->pps.sps, h265->pps->sps, pcm_sample_bit_depth_chroma_minus1);
336 ITEM_SET(&vh265->pps.sps, h265->pps->sps, log2_min_pcm_luma_coding_block_size_minus3);
337 ITEM_SET(&vh265->pps.sps, h265->pps->sps, log2_diff_max_min_pcm_luma_coding_block_size);
338 ITEM_SET(&vh265->pps.sps, h265->pps->sps, pcm_loop_filter_disabled_flag);
339 ITEM_SET(&vh265->pps.sps, h265->pps->sps, num_short_term_ref_pic_sets);
340 ITEM_SET(&vh265->pps.sps, h265->pps->sps, long_term_ref_pics_present_flag);
341 ITEM_SET(&vh265->pps.sps, h265->pps->sps, num_long_term_ref_pics_sps);
342 ITEM_SET(&vh265->pps.sps, h265->pps->sps, sps_temporal_mvp_enabled_flag);
343 ITEM_SET(&vh265->pps.sps, h265->pps->sps, strong_intra_smoothing_enabled_flag);
344
345 ITEM_SET(&vh265->pps, h265->pps, dependent_slice_segments_enabled_flag);
346 ITEM_SET(&vh265->pps, h265->pps, output_flag_present_flag);
347 ITEM_SET(&vh265->pps, h265->pps, num_extra_slice_header_bits);
348 ITEM_SET(&vh265->pps, h265->pps, sign_data_hiding_enabled_flag);
349 ITEM_SET(&vh265->pps, h265->pps, cabac_init_present_flag);
350 ITEM_SET(&vh265->pps, h265->pps, num_ref_idx_l0_default_active_minus1);
351 ITEM_SET(&vh265->pps, h265->pps, num_ref_idx_l1_default_active_minus1);
352 ITEM_SET(&vh265->pps, h265->pps, init_qp_minus26);
353 ITEM_SET(&vh265->pps, h265->pps, constrained_intra_pred_flag);
354 ITEM_SET(&vh265->pps, h265->pps, transform_skip_enabled_flag);
355 ITEM_SET(&vh265->pps, h265->pps, cu_qp_delta_enabled_flag);
356 ITEM_SET(&vh265->pps, h265->pps, diff_cu_qp_delta_depth);
357 ITEM_SET(&vh265->pps, h265->pps, pps_cb_qp_offset);
358 ITEM_SET(&vh265->pps, h265->pps, pps_cr_qp_offset);
359 ITEM_SET(&vh265->pps, h265->pps, pps_slice_chroma_qp_offsets_present_flag);
360 ITEM_SET(&vh265->pps, h265->pps, weighted_pred_flag);
361 ITEM_SET(&vh265->pps, h265->pps, weighted_bipred_flag);
362 ITEM_SET(&vh265->pps, h265->pps, transquant_bypass_enabled_flag);
363 ITEM_SET(&vh265->pps, h265->pps, tiles_enabled_flag);
364 ITEM_SET(&vh265->pps, h265->pps, entropy_coding_sync_enabled_flag);
365 ITEM_SET(&vh265->pps, h265->pps, num_tile_columns_minus1);
366 ITEM_SET(&vh265->pps, h265->pps, num_tile_rows_minus1);
367 ITEM_SET(&vh265->pps, h265->pps, uniform_spacing_flag);
368 ITEM_CPY(&vh265->pps, h265->pps, column_width_minus1);
369 ITEM_CPY(&vh265->pps, h265->pps, row_height_minus1);
370 ITEM_SET(&vh265->pps, h265->pps, loop_filter_across_tiles_enabled_flag);
371 ITEM_SET(&vh265->pps, h265->pps, pps_loop_filter_across_slices_enabled_flag);
372 ITEM_SET(&vh265->pps, h265->pps, deblocking_filter_control_present_flag);
373 ITEM_SET(&vh265->pps, h265->pps, deblocking_filter_override_enabled_flag);
374 ITEM_SET(&vh265->pps, h265->pps, pps_deblocking_filter_disabled_flag);
375 ITEM_SET(&vh265->pps, h265->pps, pps_beta_offset_div2);
376 ITEM_SET(&vh265->pps, h265->pps, pps_tc_offset_div2);
377 ITEM_SET(&vh265->pps, h265->pps, lists_modification_present_flag);
378 ITEM_SET(&vh265->pps, h265->pps, log2_parallel_merge_level_minus2);
379 ITEM_SET(&vh265->pps, h265->pps, slice_segment_header_extension_present_flag);
380 ITEM_SET(&vh265->pps, h265->pps, st_rps_bits);
381
382 ITEM_SET(vh265, h265, IDRPicFlag);
383 ITEM_SET(vh265, h265, RAPPicFlag);
384 ITEM_SET(vh265, h265, CurrRpsIdx);
385 ITEM_SET(vh265, h265, NumPocTotalCurr);
386 ITEM_SET(vh265, h265, NumDeltaPocsOfRefRpsIdx);
387 ITEM_SET(vh265, h265, NumShortTermPictureSliceHeaderBits);
388 ITEM_SET(vh265, h265, NumLongTermPictureSliceHeaderBits);
389
390 ITEM_SET(vh265, h265, CurrPicOrderCntVal);
391 for (i = 0; i < 16; i++) {
392 vbuf = virgl_video_buffer(h265->ref[i]);
393 vh265->ref[i] = vbuf ? vbuf->handle : 0;
394 }
395 ITEM_CPY(vh265, h265, PicOrderCntVal);
396 ITEM_CPY(vh265, h265, IsLongTerm);
397 ITEM_SET(vh265, h265, NumPocStCurrBefore);
398 ITEM_SET(vh265, h265, NumPocStCurrAfter);
399 ITEM_SET(vh265, h265, NumPocLtCurr);
400 ITEM_CPY(vh265, h265, RefPicSetStCurrBefore);
401 ITEM_CPY(vh265, h265, RefPicSetStCurrAfter);
402 ITEM_CPY(vh265, h265, RefPicSetLtCurr);
403 ITEM_CPY(vh265, h265, RefPicList);
404 ITEM_SET(vh265, h265, UseRefPicList);
405 ITEM_SET(vh265, h265, UseStRpsBits);
406
407 return 0;
408 }
409
fill_h265_enc_picture_desc(const struct pipe_picture_desc * desc,union virgl_picture_desc * vdsc)410 static int fill_h265_enc_picture_desc(const struct pipe_picture_desc *desc,
411 union virgl_picture_desc *vdsc)
412 {
413 unsigned i;
414 struct virgl_h265_enc_picture_desc *vh265 = &vdsc->h265_enc;
415 struct pipe_h265_enc_picture_desc *h265 = (struct pipe_h265_enc_picture_desc *)desc;
416
417 fill_base_picture_desc(desc, &vh265->base);
418
419 ITEM_SET(vh265, h265, seq.general_profile_idc);
420 ITEM_SET(vh265, h265, seq.general_level_idc);
421 ITEM_SET(vh265, h265, seq.general_tier_flag);
422 ITEM_SET(vh265, h265, seq.intra_period);
423 ITEM_SET(vh265, h265, seq.ip_period);
424 ITEM_SET(vh265, h265, seq.pic_width_in_luma_samples);
425 ITEM_SET(vh265, h265, seq.pic_height_in_luma_samples);
426 ITEM_SET(vh265, h265, seq.chroma_format_idc);
427 ITEM_SET(vh265, h265, seq.bit_depth_luma_minus8);
428 ITEM_SET(vh265, h265, seq.bit_depth_chroma_minus8);
429 ITEM_SET(vh265, h265, seq.strong_intra_smoothing_enabled_flag);
430 ITEM_SET(vh265, h265, seq.amp_enabled_flag);
431 ITEM_SET(vh265, h265, seq.sample_adaptive_offset_enabled_flag);
432 ITEM_SET(vh265, h265, seq.pcm_enabled_flag);
433 ITEM_SET(vh265, h265, seq.sps_temporal_mvp_enabled_flag);
434 ITEM_SET(vh265, h265, seq.log2_min_luma_coding_block_size_minus3);
435 ITEM_SET(vh265, h265, seq.log2_diff_max_min_luma_coding_block_size);
436 ITEM_SET(vh265, h265, seq.log2_min_transform_block_size_minus2);
437 ITEM_SET(vh265, h265, seq.log2_diff_max_min_transform_block_size);
438 ITEM_SET(vh265, h265, seq.max_transform_hierarchy_depth_inter);
439 ITEM_SET(vh265, h265, seq.max_transform_hierarchy_depth_intra);
440 ITEM_SET(vh265, h265, seq.conformance_window_flag);
441 ITEM_SET(vh265, h265, seq.conf_win_left_offset);
442 ITEM_SET(vh265, h265, seq.conf_win_right_offset);
443 ITEM_SET(vh265, h265, seq.conf_win_top_offset);
444 ITEM_SET(vh265, h265, seq.conf_win_bottom_offset);
445 ITEM_SET(vh265, h265, seq.vui_parameters_present_flag);
446 ITEM_SET(vh265, h265, seq.vui_flags.aspect_ratio_info_present_flag);
447 ITEM_SET(vh265, h265, seq.vui_flags.timing_info_present_flag);
448 ITEM_SET(vh265, h265, seq.aspect_ratio_idc);
449 ITEM_SET(vh265, h265, seq.sar_width);
450 ITEM_SET(vh265, h265, seq.sar_height);
451 ITEM_SET(vh265, h265, seq.num_units_in_tick);
452 ITEM_SET(vh265, h265, seq.time_scale);
453
454 ITEM_SET(vh265, h265, pic.log2_parallel_merge_level_minus2);
455 ITEM_SET(vh265, h265, pic.nal_unit_type);
456 ITEM_SET(vh265, h265, pic.constrained_intra_pred_flag);
457 ITEM_SET(vh265, h265, pic.pps_loop_filter_across_slices_enabled_flag);
458 ITEM_SET(vh265, h265, pic.transform_skip_enabled_flag);
459
460 ITEM_SET(vh265, h265, slice.max_num_merge_cand);
461 ITEM_SET(vh265, h265, slice.slice_cb_qp_offset);
462 ITEM_SET(vh265, h265, slice.slice_cr_qp_offset);
463 ITEM_SET(vh265, h265, slice.slice_beta_offset_div2);
464 ITEM_SET(vh265, h265, slice.slice_tc_offset_div2);
465 ITEM_SET(vh265, h265, slice.cabac_init_flag);
466 ITEM_SET(vh265, h265, slice.slice_deblocking_filter_disabled_flag);
467 ITEM_SET(vh265, h265, slice.slice_loop_filter_across_slices_enabled_flag);
468
469 vh265->rc.rate_ctrl_method = h265->rc[0].rate_ctrl_method;
470 vh265->rc.target_bitrate = h265->rc[0].target_bitrate;
471 vh265->rc.peak_bitrate = h265->rc[0].peak_bitrate;
472 vh265->rc.frame_rate_num = h265->rc[0].frame_rate_num;
473 vh265->rc.frame_rate_den = h265->rc[0].frame_rate_den;
474 vh265->rc.quant_i_frames = h265->rc[0].quant_i_frames;
475 vh265->rc.quant_p_frames = h265->rc[0].quant_p_frames;
476 vh265->rc.quant_b_frames = h265->rc[0].quant_b_frames;
477 vh265->rc.vbv_buffer_size = h265->rc[0].vbv_buffer_size;
478 vh265->rc.vbv_buf_lv = h265->rc[0].vbv_buf_lv;
479 vh265->rc.fill_data_enable = h265->rc[0].fill_data_enable;
480 vh265->rc.skip_frame_enable = h265->rc[0].skip_frame_enable;
481 vh265->rc.enforce_hrd = h265->rc[0].enforce_hrd;
482 vh265->rc.max_au_size = h265->rc[0].max_au_size;
483 vh265->rc.max_qp = h265->rc[0].max_qp;
484 vh265->rc.min_qp = h265->rc[0].min_qp;
485
486 ITEM_SET(vh265, h265, picture_type);
487 ITEM_SET(vh265, h265, decoded_curr_pic);
488
489 for (i = 0; i < 16; i++) {
490 ITEM_SET(vh265, h265, reference_frames[i]);
491 }
492
493 ITEM_SET(vh265, h265, frame_num);
494 ITEM_SET(vh265, h265, pic_order_cnt);
495 ITEM_SET(vh265, h265, pic_order_cnt_type);
496
497 ITEM_SET(vh265, h265, quality_modes.level);
498 ITEM_SET(vh265, h265, quality_modes.preset_mode);
499 ITEM_SET(vh265, h265, quality_modes.pre_encode_mode);
500 ITEM_SET(vh265, h265, quality_modes.vbaq_mode);
501
502 ITEM_SET(vh265, h265, num_ref_idx_l0_active_minus1);
503 ITEM_SET(vh265, h265, num_ref_idx_l1_active_minus1);
504
505 for (i = 0; i < 15; i++) {
506 ITEM_SET(vh265, h265, ref_idx_l0_list[i]);
507 ITEM_SET(vh265, h265, ref_idx_l1_list[i]);
508 }
509
510 ITEM_SET(vh265, h265, not_referenced);
511
512 ITEM_SET(vh265, h265, num_slice_descriptors);
513 for (i = 0; i < vh265->num_slice_descriptors; i++) {
514 ITEM_SET(vh265, h265, slices_descriptors[i].slice_segment_address);
515 ITEM_SET(vh265, h265, slices_descriptors[i].num_ctu_in_slice);
516 ITEM_SET(vh265, h265, slices_descriptors[i].slice_type);
517 }
518
519 return 0;
520 }
521
fill_mpeg4_picture_desc(const struct pipe_picture_desc * desc,union virgl_picture_desc * vdsc)522 static int fill_mpeg4_picture_desc(const struct pipe_picture_desc *desc,
523 union virgl_picture_desc *vdsc)
524 {
525 unsigned i;
526 struct virgl_video_buffer *vbuf;
527 struct virgl_mpeg4_picture_desc *vmpeg4 = &vdsc->mpeg4;
528 struct pipe_mpeg4_picture_desc *mpeg4 = (struct pipe_mpeg4_picture_desc *)desc;
529
530 fill_base_picture_desc(desc, &vmpeg4->base);
531
532 ITEM_CPY(vmpeg4, mpeg4, trd);
533 ITEM_CPY(vmpeg4, mpeg4, trb);
534 ITEM_SET(vmpeg4, mpeg4, vop_time_increment_resolution);
535 ITEM_SET(vmpeg4, mpeg4, vop_coding_type);
536 ITEM_SET(vmpeg4, mpeg4, vop_fcode_forward);
537 ITEM_SET(vmpeg4, mpeg4, vop_fcode_backward);
538 ITEM_SET(vmpeg4, mpeg4, resync_marker_disable);
539 ITEM_SET(vmpeg4, mpeg4, interlaced);
540 ITEM_SET(vmpeg4, mpeg4, quant_type);
541 ITEM_SET(vmpeg4, mpeg4, quarter_sample);
542 ITEM_SET(vmpeg4, mpeg4, short_video_header);
543 ITEM_SET(vmpeg4, mpeg4, rounding_control);
544 ITEM_SET(vmpeg4, mpeg4, alternate_vertical_scan_flag);
545 ITEM_SET(vmpeg4, mpeg4, top_field_first);
546
547 memcpy(vmpeg4->intra_matrix, mpeg4->intra_matrix, 64);
548 memcpy(vmpeg4->non_intra_matrix, mpeg4->non_intra_matrix, 64);
549
550 for (i = 0; i < ARRAY_SIZE(mpeg4->ref); i++) {
551 vbuf = virgl_video_buffer(mpeg4->ref[i]);
552 vmpeg4->ref[i] = vbuf ? vbuf->handle : 0;
553 }
554
555 return 0;
556 }
557
fill_mpeg12_picture_desc(const struct pipe_picture_desc * desc,union virgl_picture_desc * vdsc)558 static int fill_mpeg12_picture_desc(const struct pipe_picture_desc *desc,
559 union virgl_picture_desc *vdsc)
560 {
561 unsigned i;
562 struct virgl_video_buffer *vbuf;
563 struct virgl_mpeg12_picture_desc *vmpeg12 = &vdsc->mpeg12;
564 struct pipe_mpeg12_picture_desc *mpeg12 = (struct pipe_mpeg12_picture_desc *)desc;
565
566 fill_base_picture_desc(desc, &vmpeg12->base);
567
568 for (i = 0; i < 2; i++) {
569 vbuf = virgl_video_buffer(mpeg12->ref[i]);
570 vmpeg12->ref[i] = vbuf ? vbuf->handle : 0;
571 }
572
573 memcpy(vmpeg12->intra_matrix, mpeg12->intra_matrix, 64);
574 memcpy(vmpeg12->non_intra_matrix, mpeg12->non_intra_matrix, 64);
575
576 ITEM_SET(vmpeg12, mpeg12, picture_coding_type);
577 vmpeg12->f_code[0][0] = mpeg12->f_code[0][0] ;
578 vmpeg12->f_code[0][1] = mpeg12->f_code[0][1] ;
579 vmpeg12->f_code[1][0] = mpeg12->f_code[1][0] ;
580 vmpeg12->f_code[1][1] = mpeg12->f_code[1][1] ;
581 ITEM_SET(vmpeg12, mpeg12, intra_dc_precision);
582 ITEM_SET(vmpeg12, mpeg12, picture_structure);
583 ITEM_SET(vmpeg12, mpeg12, top_field_first);
584 ITEM_SET(vmpeg12, mpeg12, frame_pred_frame_dct);
585 ITEM_SET(vmpeg12, mpeg12, concealment_motion_vectors);
586 ITEM_SET(vmpeg12, mpeg12, q_scale_type);
587 ITEM_SET(vmpeg12, mpeg12, intra_vlc_format);
588 ITEM_SET(vmpeg12, mpeg12, alternate_scan);
589 return 0;
590 }
591
592
fill_vc1_picture_desc(const struct pipe_picture_desc * desc,union virgl_picture_desc * vdsc)593 static int fill_vc1_picture_desc(const struct pipe_picture_desc *desc,
594 union virgl_picture_desc *vdsc)
595 {
596 unsigned i;
597 struct virgl_video_buffer *vbuf;
598 struct virgl_vc1_picture_desc *vvc1 = &vdsc->vc1;
599 struct pipe_vc1_picture_desc *vc1 = (struct pipe_vc1_picture_desc *)desc;
600
601 fill_base_picture_desc(desc, &vvc1->base);
602
603 for (i = 0; i < 2; i++) {
604 vbuf = virgl_video_buffer(vc1->ref[i]);
605 vvc1->ref[i] = vbuf ? vbuf->handle : 0;
606 }
607 ITEM_SET(vvc1, vc1, picture_type);
608 ITEM_SET(vvc1, vc1, pulldown);
609 ITEM_SET(vvc1, vc1, interlace);
610 ITEM_SET(vvc1, vc1, tfcntrflag);
611 ITEM_SET(vvc1, vc1, finterpflag);
612 ITEM_SET(vvc1, vc1, psf);
613 ITEM_SET(vvc1, vc1, dquant);
614 ITEM_SET(vvc1, vc1, panscan_flag);
615 ITEM_SET(vvc1, vc1, refdist_flag);
616 ITEM_SET(vvc1, vc1, quantizer);
617 ITEM_SET(vvc1, vc1, extended_mv);
618 ITEM_SET(vvc1, vc1, extended_dmv);
619 ITEM_SET(vvc1, vc1, overlap);
620 ITEM_SET(vvc1, vc1, vstransform);
621 ITEM_SET(vvc1, vc1, loopfilter);
622 ITEM_SET(vvc1, vc1, fastuvmc);
623 ITEM_SET(vvc1, vc1, range_mapy_flag);
624 ITEM_SET(vvc1, vc1, range_mapy);
625 ITEM_SET(vvc1, vc1, range_mapuv_flag);
626 ITEM_SET(vvc1, vc1, range_mapuv);
627 ITEM_SET(vvc1, vc1, multires);
628 ITEM_SET(vvc1, vc1, syncmarker);
629 ITEM_SET(vvc1, vc1, rangered);
630 ITEM_SET(vvc1, vc1, maxbframes);
631 ITEM_SET(vvc1, vc1, deblockEnable);
632 ITEM_SET(vvc1, vc1, pquant);
633 ITEM_SET(vvc1, vc1, slice_count);
634
635 return 0;
636 }
637
fill_mjpeg_picture_desc(const struct pipe_picture_desc * desc,union virgl_picture_desc * vdsc)638 static int fill_mjpeg_picture_desc(const struct pipe_picture_desc *desc,
639 union virgl_picture_desc *vdsc)
640 {
641 unsigned i;
642 struct virgl_mjpeg_picture_desc *vmjpeg = &vdsc->mjpeg;
643 struct pipe_mjpeg_picture_desc *mjpeg = (struct pipe_mjpeg_picture_desc *)desc;
644
645 fill_base_picture_desc(desc, &vmjpeg->base);
646
647 ITEM_SET(&vmjpeg->picture_parameter, &mjpeg->picture_parameter, picture_width);
648 ITEM_SET(&vmjpeg->picture_parameter, &mjpeg->picture_parameter, picture_height);
649 ITEM_SET(&vmjpeg->picture_parameter, &mjpeg->picture_parameter, crop_x);
650 ITEM_SET(&vmjpeg->picture_parameter, &mjpeg->picture_parameter, crop_y);
651 ITEM_SET(&vmjpeg->picture_parameter, &mjpeg->picture_parameter, crop_width);
652 ITEM_SET(&vmjpeg->picture_parameter, &mjpeg->picture_parameter, crop_height);
653
654 ITEM_SET(&vmjpeg->picture_parameter, &mjpeg->picture_parameter, num_components);
655 for (i = 0; i < mjpeg->picture_parameter.num_components; ++i) {
656 ITEM_SET(&vmjpeg->picture_parameter.components[i], &mjpeg->picture_parameter.components[i], component_id);
657 ITEM_SET(&vmjpeg->picture_parameter.components[i], &mjpeg->picture_parameter.components[i], h_sampling_factor);
658 ITEM_SET(&vmjpeg->picture_parameter.components[i], &mjpeg->picture_parameter.components[i], v_sampling_factor);
659 ITEM_SET(&vmjpeg->picture_parameter.components[i], &mjpeg->picture_parameter.components[i], quantiser_table_selector);
660 }
661
662 ITEM_SET(&vmjpeg->slice_parameter, &mjpeg->slice_parameter, slice_data_size);
663 ITEM_SET(&vmjpeg->slice_parameter, &mjpeg->slice_parameter, slice_data_offset);
664 ITEM_SET(&vmjpeg->slice_parameter, &mjpeg->slice_parameter, slice_data_flag);
665 ITEM_SET(&vmjpeg->slice_parameter, &mjpeg->slice_parameter, slice_horizontal_position);
666 ITEM_SET(&vmjpeg->slice_parameter, &mjpeg->slice_parameter, slice_vertical_position);
667
668 ITEM_SET(&vmjpeg->slice_parameter, &mjpeg->slice_parameter, num_components);
669 for (i = 0; i < mjpeg->slice_parameter.num_components; ++i) {
670 ITEM_SET(&vmjpeg->slice_parameter.components[i], &mjpeg->slice_parameter.components[i], component_selector);
671 ITEM_SET(&vmjpeg->slice_parameter.components[i], &mjpeg->slice_parameter.components[i], dc_table_selector);
672 ITEM_SET(&vmjpeg->slice_parameter.components[i], &mjpeg->slice_parameter.components[i], ac_table_selector);
673 }
674
675 ITEM_SET(&vmjpeg->slice_parameter, &mjpeg->slice_parameter, restart_interval);
676 ITEM_SET(&vmjpeg->slice_parameter, &mjpeg->slice_parameter, num_mcus);
677
678 ITEM_CPY(&vmjpeg->quantization_table, &mjpeg->quantization_table, load_quantiser_table);
679 ITEM_CPY(&vmjpeg->quantization_table, &mjpeg->quantization_table, quantiser_table);
680
681 for (i = 0; i < 2; ++i) {
682 ITEM_SET(&vmjpeg->huffman_table, &mjpeg->huffman_table, load_huffman_table[i]);
683 ITEM_CPY(&vmjpeg->huffman_table.table[i], &mjpeg->huffman_table.table[i], num_dc_codes);
684 ITEM_CPY(&vmjpeg->huffman_table.table[i], &mjpeg->huffman_table.table[i], dc_values);
685 ITEM_CPY(&vmjpeg->huffman_table.table[i], &mjpeg->huffman_table.table[i], num_ac_codes);
686 ITEM_CPY(&vmjpeg->huffman_table.table[i], &mjpeg->huffman_table.table[i], ac_values);
687 ITEM_CPY(&vmjpeg->huffman_table.table[i], &mjpeg->huffman_table.table[i], pad);
688 }
689 return 0;
690 }
691
fill_vp9_picture_desc(const struct pipe_picture_desc * desc,union virgl_picture_desc * vdsc)692 static int fill_vp9_picture_desc(const struct pipe_picture_desc *desc,
693 union virgl_picture_desc *vdsc)
694 {
695 unsigned i;
696 struct virgl_video_buffer *vbuf;
697 struct virgl_vp9_picture_desc *vvp9 = &vdsc->vp9;
698 struct pipe_vp9_picture_desc *vp9 = (struct pipe_vp9_picture_desc *)desc;
699
700 fill_base_picture_desc(desc, &vvp9->base);
701
702 for (i = 0; i < 16; i++) {
703 vbuf = virgl_video_buffer(vp9->ref[i]);
704 vvp9->ref[i] = vbuf ? vbuf->handle : 0;
705 }
706
707 ITEM_SET(vvp9, vp9, picture_parameter.frame_width);
708 ITEM_SET(vvp9, vp9, picture_parameter.frame_height);
709 ITEM_SET(vvp9, vp9, picture_parameter.pic_fields.subsampling_x);
710 ITEM_SET(vvp9, vp9, picture_parameter.pic_fields.subsampling_y);
711 ITEM_SET(vvp9, vp9, picture_parameter.pic_fields.frame_type);
712 ITEM_SET(vvp9, vp9, picture_parameter.pic_fields.show_frame);
713 ITEM_SET(vvp9, vp9, picture_parameter.pic_fields.error_resilient_mode);
714 ITEM_SET(vvp9, vp9, picture_parameter.pic_fields.intra_only);
715 ITEM_SET(vvp9, vp9, picture_parameter.pic_fields.allow_high_precision_mv);
716 ITEM_SET(vvp9, vp9, picture_parameter.pic_fields.mcomp_filter_type);
717 ITEM_SET(vvp9, vp9, picture_parameter.pic_fields.frame_parallel_decoding_mode);
718 ITEM_SET(vvp9, vp9, picture_parameter.pic_fields.reset_frame_context);
719 ITEM_SET(vvp9, vp9, picture_parameter.pic_fields.refresh_frame_context);
720 ITEM_SET(vvp9, vp9, picture_parameter.pic_fields.frame_context_idx);
721 ITEM_SET(vvp9, vp9, picture_parameter.pic_fields.segmentation_enabled);
722 ITEM_SET(vvp9, vp9, picture_parameter.pic_fields.segmentation_temporal_update);
723 ITEM_SET(vvp9, vp9, picture_parameter.pic_fields.segmentation_update_map);
724 ITEM_SET(vvp9, vp9, picture_parameter.pic_fields.last_ref_frame);
725 ITEM_SET(vvp9, vp9, picture_parameter.pic_fields.last_ref_frame_sign_bias);
726 ITEM_SET(vvp9, vp9, picture_parameter.pic_fields.golden_ref_frame);
727 ITEM_SET(vvp9, vp9, picture_parameter.pic_fields.golden_ref_frame_sign_bias);
728 ITEM_SET(vvp9, vp9, picture_parameter.pic_fields.alt_ref_frame);
729 ITEM_SET(vvp9, vp9, picture_parameter.pic_fields.alt_ref_frame_sign_bias);
730 ITEM_SET(vvp9, vp9, picture_parameter.pic_fields.lossless_flag);
731 ITEM_SET(vvp9, vp9, picture_parameter.filter_level);
732 ITEM_SET(vvp9, vp9, picture_parameter.sharpness_level);
733 ITEM_SET(vvp9, vp9, picture_parameter.log2_tile_rows);
734 ITEM_SET(vvp9, vp9, picture_parameter.log2_tile_columns);
735 ITEM_SET(vvp9, vp9, picture_parameter.frame_header_length_in_bytes);
736 ITEM_SET(vvp9, vp9, picture_parameter.first_partition_size);
737 ITEM_CPY(vvp9, vp9, picture_parameter.mb_segment_tree_probs);
738 ITEM_CPY(vvp9, vp9, picture_parameter.segment_pred_probs);
739 ITEM_SET(vvp9, vp9, picture_parameter.profile);
740 ITEM_SET(vvp9, vp9, picture_parameter.bit_depth);
741 ITEM_SET(vvp9, vp9, picture_parameter.mode_ref_delta_enabled);
742 ITEM_SET(vvp9, vp9, picture_parameter.mode_ref_delta_update);
743 ITEM_SET(vvp9, vp9, picture_parameter.base_qindex);
744 ITEM_SET(vvp9, vp9, picture_parameter.y_dc_delta_q);
745 ITEM_SET(vvp9, vp9, picture_parameter.uv_ac_delta_q);
746 ITEM_SET(vvp9, vp9, picture_parameter.uv_dc_delta_q);
747 ITEM_SET(vvp9, vp9, picture_parameter.abs_delta);
748 ITEM_CPY(vvp9, vp9, picture_parameter.ref_deltas);
749 ITEM_CPY(vvp9, vp9, picture_parameter.mode_deltas);
750
751 vvp9->slice_parameter.slice_data_size = vp9->slice_parameter.slice_data_size[0];
752 vvp9->slice_parameter.slice_data_offset = vp9->slice_parameter.slice_data_offset[0];
753 vvp9->slice_parameter.slice_data_flag = vp9->slice_parameter.slice_data_flag[0];
754
755 for (i = 0; i < 8; i++) {
756 ITEM_SET(vvp9, vp9, slice_parameter.seg_param[i].segment_flags.segment_reference_enabled);
757 ITEM_SET(vvp9, vp9, slice_parameter.seg_param[i].segment_flags.segment_reference);
758 ITEM_SET(vvp9, vp9, slice_parameter.seg_param[i].segment_flags.segment_reference_skipped);
759 ITEM_CPY(vvp9, vp9, slice_parameter.seg_param[i].filter_level);
760 ITEM_SET(vvp9, vp9, slice_parameter.seg_param[i].luma_ac_quant_scale);
761 ITEM_SET(vvp9, vp9, slice_parameter.seg_param[i].luma_dc_quant_scale);
762 ITEM_SET(vvp9, vp9, slice_parameter.seg_param[i].chroma_ac_quant_scale);
763 ITEM_SET(vvp9, vp9, slice_parameter.seg_param[i].chroma_dc_quant_scale);
764 }
765
766 return 0;
767 }
768
fill_av1_picture_desc(const struct pipe_picture_desc * desc,union virgl_picture_desc * vdsc)769 static int fill_av1_picture_desc(const struct pipe_picture_desc *desc,
770 union virgl_picture_desc *vdsc)
771 {
772 unsigned i;
773 struct virgl_video_buffer *vbuf;
774 struct virgl_av1_picture_desc *vav1 = &vdsc->av1;
775 struct pipe_av1_picture_desc *av1 = (struct pipe_av1_picture_desc *)desc;
776
777 fill_base_picture_desc(desc, &vav1->base);
778
779 for (i = 0; i < ARRAY_SIZE(vav1->ref); i++) {
780 vbuf = virgl_video_buffer(av1->ref[i]);
781 vav1->ref[i] = vbuf ? vbuf->handle : 0;
782 }
783 vbuf = virgl_video_buffer(av1->film_grain_target);
784 vav1->film_grain_target = vbuf ? vbuf->handle : 0;
785
786 ITEM_SET(vav1, av1, picture_parameter.profile);
787 ITEM_SET(vav1, av1, picture_parameter.order_hint_bits_minus_1);
788 ITEM_SET(vav1, av1, picture_parameter.bit_depth_idx);
789
790 ITEM_SET(vav1, av1, picture_parameter.seq_info_fields.use_128x128_superblock);
791 ITEM_SET(vav1, av1, picture_parameter.seq_info_fields.enable_filter_intra);
792 ITEM_SET(vav1, av1, picture_parameter.seq_info_fields.enable_intra_edge_filter);
793 ITEM_SET(vav1, av1, picture_parameter.seq_info_fields.enable_interintra_compound);
794 ITEM_SET(vav1, av1, picture_parameter.seq_info_fields.enable_masked_compound);
795 ITEM_SET(vav1, av1, picture_parameter.seq_info_fields.enable_dual_filter);
796 ITEM_SET(vav1, av1, picture_parameter.seq_info_fields.enable_order_hint);
797 ITEM_SET(vav1, av1, picture_parameter.seq_info_fields.enable_jnt_comp);
798 ITEM_SET(vav1, av1, picture_parameter.seq_info_fields.enable_cdef);
799 ITEM_SET(vav1, av1, picture_parameter.seq_info_fields.mono_chrome);
800 ITEM_SET(vav1, av1, picture_parameter.seq_info_fields.ref_frame_mvs);
801 ITEM_SET(vav1, av1, picture_parameter.seq_info_fields.film_grain_params_present);
802
803 ITEM_SET(vav1, av1, picture_parameter.current_frame_id);
804 ITEM_SET(vav1, av1, picture_parameter.frame_width);
805 ITEM_SET(vav1, av1, picture_parameter.frame_height);
806 ITEM_SET(vav1, av1, picture_parameter.max_width);
807 ITEM_SET(vav1, av1, picture_parameter.max_height);
808 ITEM_CPY(vav1, av1, picture_parameter.ref_frame_idx);
809 ITEM_SET(vav1, av1, picture_parameter.primary_ref_frame);
810 ITEM_SET(vav1, av1, picture_parameter.order_hint);
811
812 ITEM_SET(vav1, av1, picture_parameter.seg_info.segment_info_fields.enabled);
813 ITEM_SET(vav1, av1, picture_parameter.seg_info.segment_info_fields.update_map);
814 ITEM_SET(vav1, av1, picture_parameter.seg_info.segment_info_fields.update_data);
815 ITEM_SET(vav1, av1, picture_parameter.seg_info.segment_info_fields.temporal_update);
816 ITEM_CPY(vav1, av1, picture_parameter.seg_info.feature_data);
817 ITEM_CPY(vav1, av1, picture_parameter.seg_info.feature_mask);
818
819 ITEM_SET(vav1, av1, picture_parameter.film_grain_info.film_grain_info_fields.apply_grain);
820 ITEM_SET(vav1, av1, picture_parameter.film_grain_info.film_grain_info_fields.chroma_scaling_from_luma);
821 ITEM_SET(vav1, av1, picture_parameter.film_grain_info.film_grain_info_fields.grain_scaling_minus_8);
822 ITEM_SET(vav1, av1, picture_parameter.film_grain_info.film_grain_info_fields.ar_coeff_lag);
823 ITEM_SET(vav1, av1, picture_parameter.film_grain_info.film_grain_info_fields.ar_coeff_shift_minus_6);
824 ITEM_SET(vav1, av1, picture_parameter.film_grain_info.film_grain_info_fields.grain_scale_shift);
825 ITEM_SET(vav1, av1, picture_parameter.film_grain_info.film_grain_info_fields.overlap_flag);
826 ITEM_SET(vav1, av1, picture_parameter.film_grain_info.film_grain_info_fields.clip_to_restricted_range);
827
828 ITEM_SET(vav1, av1, picture_parameter.film_grain_info.grain_seed);
829 ITEM_SET(vav1, av1, picture_parameter.film_grain_info.num_y_points);
830 ITEM_CPY(vav1, av1, picture_parameter.film_grain_info.point_y_value);
831 ITEM_CPY(vav1, av1, picture_parameter.film_grain_info.point_y_scaling);
832 ITEM_SET(vav1, av1, picture_parameter.film_grain_info.num_cb_points);
833 ITEM_CPY(vav1, av1, picture_parameter.film_grain_info.point_cb_value);
834 ITEM_CPY(vav1, av1, picture_parameter.film_grain_info.point_cb_scaling);
835 ITEM_SET(vav1, av1, picture_parameter.film_grain_info.num_cr_points);
836 ITEM_CPY(vav1, av1, picture_parameter.film_grain_info.point_cr_value);
837 ITEM_CPY(vav1, av1, picture_parameter.film_grain_info.point_cr_scaling);
838 ITEM_CPY(vav1, av1, picture_parameter.film_grain_info.ar_coeffs_y);
839 ITEM_CPY(vav1, av1, picture_parameter.film_grain_info.ar_coeffs_cb);
840 ITEM_CPY(vav1, av1, picture_parameter.film_grain_info.ar_coeffs_cr);
841 ITEM_SET(vav1, av1, picture_parameter.film_grain_info.cb_mult);
842 ITEM_SET(vav1, av1, picture_parameter.film_grain_info.cb_luma_mult);
843 ITEM_SET(vav1, av1, picture_parameter.film_grain_info.cb_offset);
844 ITEM_SET(vav1, av1, picture_parameter.film_grain_info.cr_mult);
845 ITEM_SET(vav1, av1, picture_parameter.film_grain_info.cr_luma_mult);
846 ITEM_SET(vav1, av1, picture_parameter.film_grain_info.cr_offset);
847
848 ITEM_SET(vav1, av1, picture_parameter.tile_cols);
849 ITEM_SET(vav1, av1, picture_parameter.tile_rows);
850 ITEM_CPY(vav1, av1, picture_parameter.tile_col_start_sb);
851 ITEM_CPY(vav1, av1, picture_parameter.tile_row_start_sb);
852 ITEM_CPY(vav1, av1, picture_parameter.width_in_sbs);
853 ITEM_CPY(vav1, av1, picture_parameter.height_in_sbs);
854 ITEM_SET(vav1, av1, picture_parameter.context_update_tile_id);
855
856 ITEM_SET(vav1, av1, picture_parameter.pic_info_fields.frame_type);
857 ITEM_SET(vav1, av1, picture_parameter.pic_info_fields.show_frame);
858 ITEM_SET(vav1, av1, picture_parameter.pic_info_fields.showable_frame);
859 ITEM_SET(vav1, av1, picture_parameter.pic_info_fields.error_resilient_mode);
860 ITEM_SET(vav1, av1, picture_parameter.pic_info_fields.disable_cdf_update);
861 ITEM_SET(vav1, av1, picture_parameter.pic_info_fields.allow_screen_content_tools);
862 ITEM_SET(vav1, av1, picture_parameter.pic_info_fields.force_integer_mv);
863 ITEM_SET(vav1, av1, picture_parameter.pic_info_fields.allow_intrabc);
864 ITEM_SET(vav1, av1, picture_parameter.pic_info_fields.use_superres);
865 ITEM_SET(vav1, av1, picture_parameter.pic_info_fields.allow_high_precision_mv);
866 ITEM_SET(vav1, av1, picture_parameter.pic_info_fields.is_motion_mode_switchable);
867 ITEM_SET(vav1, av1, picture_parameter.pic_info_fields.use_ref_frame_mvs);
868 ITEM_SET(vav1, av1, picture_parameter.pic_info_fields.disable_frame_end_update_cdf);
869 ITEM_SET(vav1, av1, picture_parameter.pic_info_fields.uniform_tile_spacing_flag);
870 ITEM_SET(vav1, av1, picture_parameter.pic_info_fields.allow_warped_motion);
871 ITEM_SET(vav1, av1, picture_parameter.pic_info_fields.large_scale_tile);
872
873 ITEM_SET(vav1, av1, picture_parameter.superres_scale_denominator);
874 ITEM_SET(vav1, av1, picture_parameter.interp_filter);
875 ITEM_CPY(vav1, av1, picture_parameter.filter_level);
876 ITEM_SET(vav1, av1, picture_parameter.filter_level_u);
877 ITEM_SET(vav1, av1, picture_parameter.filter_level_v);
878 ITEM_SET(vav1, av1, picture_parameter.loop_filter_info_fields.sharpness_level);
879 ITEM_SET(vav1, av1, picture_parameter.loop_filter_info_fields.mode_ref_delta_enabled);
880 ITEM_SET(vav1, av1, picture_parameter.loop_filter_info_fields.mode_ref_delta_update);
881
882 ITEM_CPY(vav1, av1, picture_parameter.ref_deltas);
883 ITEM_CPY(vav1, av1, picture_parameter.mode_deltas);
884 ITEM_SET(vav1, av1, picture_parameter.base_qindex);
885 ITEM_SET(vav1, av1, picture_parameter.y_dc_delta_q);
886 ITEM_SET(vav1, av1, picture_parameter.u_dc_delta_q);
887 ITEM_SET(vav1, av1, picture_parameter.u_ac_delta_q);
888 ITEM_SET(vav1, av1, picture_parameter.v_dc_delta_q);
889 ITEM_SET(vav1, av1, picture_parameter.v_ac_delta_q);
890
891 ITEM_SET(vav1, av1, picture_parameter.qmatrix_fields.using_qmatrix);
892 ITEM_SET(vav1, av1, picture_parameter.qmatrix_fields.qm_y);
893 ITEM_SET(vav1, av1, picture_parameter.qmatrix_fields.qm_u);
894 ITEM_SET(vav1, av1, picture_parameter.qmatrix_fields.qm_v);
895
896 ITEM_SET(vav1, av1, picture_parameter.mode_control_fields.delta_q_present_flag);
897 ITEM_SET(vav1, av1, picture_parameter.mode_control_fields.log2_delta_q_res);
898 ITEM_SET(vav1, av1, picture_parameter.mode_control_fields.delta_lf_present_flag);
899 ITEM_SET(vav1, av1, picture_parameter.mode_control_fields.log2_delta_lf_res);
900 ITEM_SET(vav1, av1, picture_parameter.mode_control_fields.delta_lf_multi);
901 ITEM_SET(vav1, av1, picture_parameter.mode_control_fields.tx_mode);
902 ITEM_SET(vav1, av1, picture_parameter.mode_control_fields.reference_select);
903 ITEM_SET(vav1, av1, picture_parameter.mode_control_fields.reduced_tx_set_used);
904 ITEM_SET(vav1, av1, picture_parameter.mode_control_fields.skip_mode_present);
905
906 ITEM_SET(vav1, av1, picture_parameter.cdef_damping_minus_3);
907 ITEM_SET(vav1, av1, picture_parameter.cdef_bits);
908 ITEM_CPY(vav1, av1, picture_parameter.cdef_y_strengths);
909 ITEM_CPY(vav1, av1, picture_parameter.cdef_uv_strengths);
910
911 ITEM_SET(vav1, av1, picture_parameter.loop_restoration_fields.yframe_restoration_type);
912 ITEM_SET(vav1, av1, picture_parameter.loop_restoration_fields.cbframe_restoration_type);
913 ITEM_SET(vav1, av1, picture_parameter.loop_restoration_fields.crframe_restoration_type);
914 ITEM_SET(vav1, av1, picture_parameter.loop_restoration_fields.lr_unit_shift);
915 ITEM_SET(vav1, av1, picture_parameter.loop_restoration_fields.lr_uv_shift);
916
917 for (i = 0; i < ARRAY_SIZE(vav1->picture_parameter.wm); i++) {
918 ITEM_SET(vav1, av1, picture_parameter.wm[i].wmtype);
919 ITEM_SET(vav1, av1, picture_parameter.wm[i].invalid);
920 ITEM_CPY(vav1, av1, picture_parameter.wm[i].wmmat);
921 }
922
923 ITEM_SET(vav1, av1, picture_parameter.refresh_frame_flags);
924 ITEM_SET(vav1, av1, picture_parameter.matrix_coefficients);
925
926 ITEM_CPY(vav1, av1, slice_parameter.slice_data_size);
927 ITEM_CPY(vav1, av1, slice_parameter.slice_data_offset);
928 ITEM_CPY(vav1, av1, slice_parameter.slice_data_row);
929 ITEM_CPY(vav1, av1, slice_parameter.slice_data_col);
930 ITEM_CPY(vav1, av1, slice_parameter.slice_data_anchor_frame_idx);
931 ITEM_SET(vav1, av1, slice_parameter.slice_count);
932
933 return 0;
934 }
935
936 #undef ITEM_SET
937 #undef ITEM_CPY
938
fill_picture_desc(const struct pipe_picture_desc * desc,union virgl_picture_desc * vdsc)939 static int fill_picture_desc(const struct pipe_picture_desc *desc,
940 union virgl_picture_desc *vdsc)
941 {
942 switch (u_reduce_video_profile(desc->profile)) {
943 case PIPE_VIDEO_FORMAT_MPEG4:
944 return fill_mpeg4_picture_desc(desc, vdsc);
945 case PIPE_VIDEO_FORMAT_MPEG4_AVC:
946 return fill_h264_picture_desc(desc, vdsc);
947 case PIPE_VIDEO_FORMAT_HEVC:
948 return fill_h265_picture_desc(desc, vdsc);
949 case PIPE_VIDEO_FORMAT_MPEG12:
950 return fill_mpeg12_picture_desc(desc, vdsc);
951 case PIPE_VIDEO_FORMAT_VC1:
952 return fill_vc1_picture_desc(desc, vdsc);
953 case PIPE_VIDEO_FORMAT_JPEG:
954 return fill_mjpeg_picture_desc(desc, vdsc);
955 case PIPE_VIDEO_FORMAT_VP9:
956 return fill_vp9_picture_desc(desc, vdsc);
957 case PIPE_VIDEO_FORMAT_AV1:
958 return fill_av1_picture_desc(desc, vdsc);
959 default:
960 return -1;
961 }
962 }
963
fill_enc_picture_desc(const struct pipe_picture_desc * desc,union virgl_picture_desc * vdsc)964 static int fill_enc_picture_desc(const struct pipe_picture_desc *desc,
965 union virgl_picture_desc *vdsc)
966 {
967 switch (u_reduce_video_profile(desc->profile)) {
968 case PIPE_VIDEO_FORMAT_MPEG4_AVC:
969 return fill_h264_enc_picture_desc(desc, vdsc);
970 case PIPE_VIDEO_FORMAT_HEVC:
971 return fill_h265_enc_picture_desc(desc, vdsc);
972 default:
973 return -1;
974 }
975 }
976
virgl_video_begin_frame(struct pipe_video_codec * codec,struct pipe_video_buffer * target,struct pipe_picture_desc * picture)977 static void virgl_video_begin_frame(struct pipe_video_codec *codec,
978 struct pipe_video_buffer *target,
979 struct pipe_picture_desc *picture)
980 {
981 struct virgl_video_codec *vcdc = virgl_video_codec(codec);
982 struct virgl_video_buffer *vbuf = virgl_video_buffer(target);
983
984 if (codec->entrypoint == PIPE_VIDEO_ENTRYPOINT_ENCODE)
985 fill_enc_picture_desc(picture, &vcdc->desc);
986
987 virgl_encode_begin_frame(vcdc->vctx, vcdc, vbuf);
988 }
989
virgl_video_decode_macroblock(struct pipe_video_codec * codec,struct pipe_video_buffer * target,struct pipe_picture_desc * picture,const struct pipe_macroblock * macroblocks,unsigned num_macroblocks)990 static void virgl_video_decode_macroblock(struct pipe_video_codec *codec,
991 struct pipe_video_buffer *target,
992 struct pipe_picture_desc *picture,
993 const struct pipe_macroblock *macroblocks,
994 unsigned num_macroblocks)
995 {
996 (void)codec;
997 (void)target;
998 (void)picture;
999 (void)macroblocks;
1000 (void)num_macroblocks;
1001 }
1002
virgl_video_decode_bitstream(struct pipe_video_codec * codec,struct pipe_video_buffer * target,struct pipe_picture_desc * picture,unsigned num_buffers,const void * const * buffers,const unsigned * sizes)1003 static void virgl_video_decode_bitstream(struct pipe_video_codec *codec,
1004 struct pipe_video_buffer *target,
1005 struct pipe_picture_desc *picture,
1006 unsigned num_buffers,
1007 const void * const *buffers,
1008 const unsigned *sizes)
1009 {
1010 struct virgl_video_codec *vcdc = virgl_video_codec(codec);
1011 struct virgl_video_buffer *vbuf = virgl_video_buffer(target);
1012 struct virgl_context *vctx = vcdc->vctx;
1013 struct virgl_screen *vs = virgl_screen(vctx->base.screen);
1014 struct virgl_resource *vres;
1015 union virgl_picture_desc vdsc;
1016 struct pipe_transfer *xfer = NULL;
1017 void *ptr;
1018 unsigned i, total_size;
1019
1020 /* transfer bitstream data */
1021 for (i = 0, total_size = 0; i < num_buffers; i++)
1022 total_size += sizes[i];
1023
1024 if (total_size > pipe_buffer_size(vcdc->bs_buffers[vcdc->cur_buffer])) {
1025 pipe_resource_reference(&vcdc->bs_buffers[vcdc->cur_buffer], NULL);
1026 vcdc->bs_buffers[vcdc->cur_buffer] = pipe_buffer_create(vctx->base.screen,
1027 PIPE_BIND_CUSTOM, PIPE_USAGE_STAGING, total_size);
1028 }
1029
1030 vctx->base.flush(&vctx->base, NULL, 0);
1031
1032 vres = virgl_resource(vcdc->bs_buffers[vcdc->cur_buffer]);
1033 vs->vws->resource_wait(vs->vws, vres->hw_res);
1034 ptr = pipe_buffer_map(&vctx->base, vcdc->bs_buffers[vcdc->cur_buffer],
1035 PIPE_MAP_WRITE, &xfer);
1036 if (!ptr)
1037 return;
1038 for (i = 0, vcdc->bs_size = 0; i < num_buffers; i++) {
1039 memcpy((uint8_t *)ptr + vcdc->bs_size, buffers[i], sizes[i]);
1040 vcdc->bs_size += sizes[i];
1041 }
1042 pipe_buffer_unmap(&vctx->base, xfer);
1043
1044 /* transfer picture description */
1045 fill_picture_desc(picture, &vdsc);
1046 vres = virgl_resource(vcdc->desc_buffers[vcdc->cur_buffer]);
1047 vs->vws->resource_wait(vs->vws, vres->hw_res);
1048 ptr = pipe_buffer_map(&vctx->base, vcdc->desc_buffers[vcdc->cur_buffer],
1049 PIPE_MAP_WRITE, &xfer);
1050 if (!ptr)
1051 return;
1052 memcpy(ptr, &vdsc, sizeof(vdsc));
1053 pipe_buffer_unmap(&vctx->base, xfer);
1054
1055 virgl_encode_decode_bitstream(vctx, vcdc, vbuf, &vdsc, sizeof(vdsc));
1056 }
1057
virgl_video_encode_bitstream(struct pipe_video_codec * codec,struct pipe_video_buffer * source,struct pipe_resource * target,void ** feedback)1058 static void virgl_video_encode_bitstream(struct pipe_video_codec *codec,
1059 struct pipe_video_buffer *source,
1060 struct pipe_resource *target,
1061 void **feedback)
1062 {
1063 struct virgl_video_codec *vcdc = virgl_video_codec(codec);
1064 struct virgl_context *vctx = vcdc->vctx;
1065 struct virgl_screen *vs = virgl_screen(vctx->base.screen);
1066 struct virgl_resource *vres;
1067 struct virgl_video_encode_feedback *fb;
1068 struct pipe_transfer *xfer = NULL;
1069 void *ptr;
1070
1071 /* Transfer picture desc */
1072 vres = virgl_resource(vcdc->desc_buffers[vcdc->cur_buffer]);
1073 vs->vws->resource_wait(vs->vws, vres->hw_res);
1074 ptr = pipe_buffer_map(&vctx->base, vcdc->desc_buffers[vcdc->cur_buffer],
1075 PIPE_MAP_WRITE, &xfer);
1076 if (!ptr)
1077 return;
1078 memcpy(ptr, &vcdc->desc, sizeof(vcdc->desc));
1079 pipe_buffer_unmap(&vctx->base, xfer);
1080
1081 /* Init feedback */
1082 vres = virgl_resource(vcdc->feed_buffers[vcdc->cur_buffer]);
1083 vs->vws->resource_wait(vs->vws, vres->hw_res);
1084 fb = pipe_buffer_map(&vctx->base, vcdc->feed_buffers[vcdc->cur_buffer],
1085 PIPE_MAP_WRITE, &xfer);
1086 if (!fb)
1087 return;
1088 fb->stat = VIRGL_VIDEO_ENCODE_STAT_NOT_STARTED;
1089 fb->coded_size = 0;
1090 pipe_buffer_unmap(&vctx->base, xfer);
1091 *feedback = vres;
1092
1093 /*
1094 * These objects do not need to be transferred manually:
1095 * source - corresponds to VASurface in VA-API
1096 * target - corresponds to VACodedBuffer in VA-API
1097 */
1098
1099 virgl_encode_encode_bitstream(vctx, vcdc, virgl_video_buffer(source),
1100 virgl_resource(target));
1101 }
1102
virgl_video_end_frame(struct pipe_video_codec * codec,struct pipe_video_buffer * target,struct pipe_picture_desc * picture)1103 static int virgl_video_end_frame(struct pipe_video_codec *codec,
1104 struct pipe_video_buffer *target,
1105 struct pipe_picture_desc *picture)
1106 {
1107 struct virgl_video_codec *vcdc = virgl_video_codec(codec);
1108 struct virgl_context *vctx = virgl_context(vcdc->base.context);
1109 struct virgl_video_buffer *vbuf = virgl_video_buffer(target);
1110
1111 virgl_encode_end_frame(vctx, vcdc, vbuf);
1112 virgl_flush_eq(vctx, vctx, NULL);
1113
1114 switch_buffer(vcdc);
1115 return 0;
1116 }
1117
virgl_video_get_decoder_fence(struct pipe_video_codec * decoder,struct pipe_fence_handle * fence,uint64_t timeout)1118 static int virgl_video_get_decoder_fence(struct pipe_video_codec *decoder,
1119 struct pipe_fence_handle *fence,
1120 uint64_t timeout) {
1121 struct virgl_video_codec *vcdc = virgl_video_codec(decoder);
1122 struct virgl_context *vctx = vcdc->vctx;
1123 struct virgl_screen *vs = virgl_screen(vctx->base.screen);
1124
1125 return vs->vws->fence_wait(vs->vws, fence, timeout);
1126 }
1127
virgl_video_flush(struct pipe_video_codec * codec)1128 static void virgl_video_flush(struct pipe_video_codec *codec)
1129 {
1130 struct pipe_context *ctx = codec->context;
1131 struct pipe_fence_handle *fence = NULL;
1132
1133 ctx->flush(ctx, &fence, 0);
1134 if (fence) {
1135 ctx->screen->fence_finish(ctx->screen, NULL, fence, OS_TIMEOUT_INFINITE);
1136 ctx->screen->fence_reference(ctx->screen, &fence, NULL);
1137 }
1138 }
1139
virgl_video_get_feedback(struct pipe_video_codec * codec,void * feedback,unsigned * size,struct pipe_enc_feedback_metadata * metadata)1140 static void virgl_video_get_feedback(struct pipe_video_codec *codec,
1141 void *feedback,
1142 unsigned *size,
1143 struct pipe_enc_feedback_metadata* metadata)
1144 {
1145 struct virgl_video_codec *vcdc = virgl_video_codec(codec);
1146 struct virgl_context *vctx = vcdc->vctx;
1147 struct virgl_screen *vs = virgl_screen(vctx->base.screen);
1148 struct virgl_resource *vres = feedback;
1149 struct virgl_video_encode_feedback *fb;
1150 struct pipe_transfer *xfer;
1151
1152 if (!feedback || !size)
1153 return;
1154
1155 vs->vws->resource_wait(vs->vws, vres->hw_res);
1156 fb = pipe_buffer_map(&vctx->base, &vres->b, PIPE_MAP_READ, &xfer);
1157 if (!fb)
1158 return;
1159 if (fb->stat == VIRGL_VIDEO_ENCODE_STAT_SUCCESS) {
1160 *size = fb->coded_size;
1161 } else {
1162 *size = 0;
1163 if (virgl_debug & VIRGL_DEBUG_VIDEO) {
1164 debug_printf("unexpected encode feedback: %u\n", fb->stat);
1165 }
1166 }
1167 pipe_buffer_unmap(&vctx->base, xfer);
1168 }
1169
virgl_video_destroy_codec(struct pipe_video_codec * codec)1170 static void virgl_video_destroy_codec(struct pipe_video_codec *codec)
1171 {
1172 unsigned i;
1173 struct virgl_video_codec *vcdc = virgl_video_codec(codec);
1174 struct virgl_context *vctx = virgl_context(vcdc->base.context);
1175
1176 for (i = 0; i < VIRGL_VIDEO_CODEC_BUF_NUM; i++) {
1177 if (codec->entrypoint != PIPE_VIDEO_ENTRYPOINT_ENCODE) {
1178 pipe_resource_reference(&vcdc->bs_buffers[i], NULL);
1179 } else {
1180 pipe_resource_reference(&vcdc->feed_buffers[i], NULL);
1181 }
1182 pipe_resource_reference(&vcdc->desc_buffers[i], NULL);
1183 }
1184
1185 virgl_encode_destroy_video_codec(vctx, vcdc);
1186
1187 free(vcdc);
1188 }
1189
1190
1191 struct pipe_video_codec *
virgl_video_create_codec(struct pipe_context * ctx,const struct pipe_video_codec * templ)1192 virgl_video_create_codec(struct pipe_context *ctx,
1193 const struct pipe_video_codec *templ)
1194 {
1195 unsigned i;
1196 struct virgl_video_codec *vcdc;
1197 struct virgl_context *vctx = virgl_context(ctx);
1198 unsigned width = templ->width, height = templ->height;
1199
1200 if (virgl_debug & VIRGL_DEBUG_VIDEO)
1201 debug_printf("VIDEO: create codec. profile=%d, level=%u, entryp=%d, "
1202 "chroma_fmt=%d, size=%ux%u, max_ref=%u, expect=%d\n",
1203 templ->profile, templ->level, templ->entrypoint,
1204 templ->chroma_format, templ->width, templ->height,
1205 templ->max_references, templ->expect_chunked_decode);
1206
1207 switch (u_reduce_video_profile(templ->profile)) {
1208 case PIPE_VIDEO_FORMAT_MPEG4: /* fall through */
1209 case PIPE_VIDEO_FORMAT_MPEG4_AVC:
1210 width = align(width, VL_MACROBLOCK_WIDTH);
1211 height = align(height, VL_MACROBLOCK_HEIGHT);
1212 break;
1213 case PIPE_VIDEO_FORMAT_HEVC:
1214 case PIPE_VIDEO_FORMAT_MPEG12:
1215 case PIPE_VIDEO_FORMAT_VC1:
1216 case PIPE_VIDEO_FORMAT_JPEG:
1217 case PIPE_VIDEO_FORMAT_VP9:
1218 case PIPE_VIDEO_FORMAT_AV1: /* fall through */
1219 default:
1220 break;
1221 }
1222
1223 vcdc = CALLOC_STRUCT(virgl_video_codec);
1224 if (!vcdc)
1225 return NULL;
1226
1227 vcdc->base = *templ;
1228 vcdc->base.width = width;
1229 vcdc->base.height = height;
1230 vcdc->base.context = ctx;
1231
1232 vcdc->base.destroy = virgl_video_destroy_codec;
1233 vcdc->base.begin_frame = virgl_video_begin_frame;
1234 vcdc->base.decode_macroblock = virgl_video_decode_macroblock;
1235 vcdc->base.decode_bitstream = virgl_video_decode_bitstream;
1236 vcdc->base.encode_bitstream = virgl_video_encode_bitstream;
1237 vcdc->base.end_frame = virgl_video_end_frame;
1238 vcdc->base.flush = virgl_video_flush;
1239 vcdc->base.get_feedback = virgl_video_get_feedback;
1240
1241 vcdc->bs_size = 0;
1242 vcdc->cur_buffer = 0;
1243 for (i = 0; i < VIRGL_VIDEO_CODEC_BUF_NUM; i++) {
1244 if (templ->entrypoint != PIPE_VIDEO_ENTRYPOINT_ENCODE) {
1245 vcdc->bs_buffers[i] = pipe_buffer_create(ctx->screen,
1246 PIPE_BIND_CUSTOM, PIPE_USAGE_STAGING,
1247 BS_BUF_DEFAULT_SIZE(width, height));
1248 } else {
1249 vcdc->feed_buffers[i] = pipe_buffer_create(ctx->screen,
1250 PIPE_BIND_CUSTOM, PIPE_USAGE_STAGING,
1251 sizeof(struct virgl_video_encode_feedback));
1252 }
1253
1254 vcdc->desc_buffers[i] = pipe_buffer_create(ctx->screen,
1255 PIPE_BIND_CUSTOM, PIPE_USAGE_STAGING,
1256 sizeof(union virgl_picture_desc));
1257 }
1258
1259 vcdc->handle = virgl_object_assign_handle();
1260 vcdc->vctx = vctx;
1261
1262 virgl_encode_create_video_codec(vctx, vcdc);
1263
1264 return &vcdc->base;
1265 }
1266
1267
virgl_video_destroy_buffer(struct pipe_video_buffer * buffer)1268 static void virgl_video_destroy_buffer(struct pipe_video_buffer *buffer)
1269 {
1270 struct virgl_video_buffer *vbuf = virgl_video_buffer(buffer);
1271
1272 virgl_encode_destroy_video_buffer(vbuf->vctx, vbuf);
1273
1274 vl_video_buffer_destroy(buffer);
1275
1276 free(vbuf);
1277 }
1278
virgl_video_destroy_buffer_associated_data(void * data)1279 static void virgl_video_destroy_buffer_associated_data(void *data)
1280 {
1281 (void)data;
1282 }
1283
1284 struct pipe_video_buffer *
virgl_video_create_buffer(struct pipe_context * ctx,const struct pipe_video_buffer * tmpl)1285 virgl_video_create_buffer(struct pipe_context *ctx,
1286 const struct pipe_video_buffer *tmpl)
1287 {
1288 struct virgl_context *vctx = virgl_context(ctx);
1289 struct virgl_video_buffer *vbuf;
1290
1291 vbuf = CALLOC_STRUCT(virgl_video_buffer);
1292 if (!vbuf)
1293 return NULL;
1294
1295 vbuf->buf = vl_video_buffer_create(ctx, tmpl);
1296 if (!vbuf->buf) {
1297 free(vbuf);
1298 return NULL;
1299 }
1300 vbuf->buf->destroy = virgl_video_destroy_buffer;
1301 vl_video_buffer_set_associated_data(vbuf->buf,
1302 NULL, vbuf, virgl_video_destroy_buffer_associated_data);
1303
1304 vbuf->num_planes = util_format_get_num_planes(vbuf->buf->buffer_format);
1305 vbuf->plane_views = vbuf->buf->get_sampler_view_planes(vbuf->buf);
1306 vbuf->handle = virgl_object_assign_handle();
1307 vbuf->buffer_format = tmpl->buffer_format;
1308 vbuf->width = tmpl->width;
1309 vbuf->height = tmpl->height;
1310 vbuf->vctx = vctx;
1311
1312 virgl_encode_create_video_buffer(vctx, vbuf);
1313
1314 if (virgl_debug & VIRGL_DEBUG_VIDEO) {
1315 debug_printf("VIDEO: create buffer. fmt=%s, %ux%u, num_planes=%u\n",
1316 util_format_name(tmpl->buffer_format),
1317 tmpl->width, tmpl->height, vbuf->num_planes);
1318
1319 for (unsigned i = 0; i < vbuf->num_planes; i++)
1320 if (vbuf->plane_views[i])
1321 debug_printf("VIDEO: plane[%d]: fmt=%s, target=%u\n", i,
1322 util_format_name(vbuf->plane_views[i]->format),
1323 vbuf->plane_views[i]->target);
1324 }
1325
1326 return vbuf->buf;
1327 }
1328
1329