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 <jiangfeng@kylinos.cn>
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].target_bits_picture);
233 ITEM_SET(vh264, h264, rate_ctrl[i].peak_bits_picture_integer);
234 ITEM_SET(vh264, h264, rate_ctrl[i].peak_bits_picture_fraction);
235 ITEM_SET(vh264, h264, rate_ctrl[i].fill_data_enable);
236 ITEM_SET(vh264, h264, rate_ctrl[i].skip_frame_enable);
237 ITEM_SET(vh264, h264, rate_ctrl[i].enforce_hrd);
238 ITEM_SET(vh264, h264, rate_ctrl[i].max_au_size);
239 ITEM_SET(vh264, h264, rate_ctrl[i].max_qp);
240 ITEM_SET(vh264, h264, rate_ctrl[i].min_qp);
241 }
242
243 /* motion_est */
244 ITEM_SET(vh264, h264, motion_est.motion_est_quarter_pixel);
245 ITEM_SET(vh264, h264, motion_est.enc_disable_sub_mode);
246 ITEM_SET(vh264, h264, motion_est.lsmvert);
247 ITEM_SET(vh264, h264, motion_est.enc_en_ime_overw_dis_subm);
248 ITEM_SET(vh264, h264, motion_est.enc_ime_overw_dis_subm_no);
249 ITEM_SET(vh264, h264, motion_est.enc_ime2_search_range_x);
250 ITEM_SET(vh264, h264, motion_est.enc_ime2_search_range_y);
251
252 /* pic_ctrl */
253 ITEM_SET(vh264, h264, pic_ctrl.enc_cabac_enable);
254 ITEM_SET(vh264, h264, pic_ctrl.enc_cabac_init_idc);
255
256 ITEM_SET(vh264, h264, intra_idr_period);
257
258 ITEM_SET(vh264, h264, quant_i_frames);
259 ITEM_SET(vh264, h264, quant_p_frames);
260 ITEM_SET(vh264, h264, quant_b_frames);
261
262 ITEM_SET(vh264, h264, picture_type);
263 ITEM_SET(vh264, h264, frame_num);
264 ITEM_SET(vh264, h264, frame_num_cnt);
265 ITEM_SET(vh264, h264, p_remain);
266 ITEM_SET(vh264, h264, i_remain);
267 ITEM_SET(vh264, h264, idr_pic_id);
268 ITEM_SET(vh264, h264, gop_cnt);
269 ITEM_SET(vh264, h264, pic_order_cnt);
270 ITEM_SET(vh264, h264, num_ref_idx_l0_active_minus1);
271 ITEM_SET(vh264, h264, num_ref_idx_l1_active_minus1);
272
273 for (i = 0; i < 32; i++) {
274 ITEM_SET(vh264, h264, ref_idx_l0_list[i]);
275 ITEM_SET(vh264, h264, ref_idx_l1_list[i]);
276 ITEM_SET(vh264, h264, l0_is_long_term[i]);
277 ITEM_SET(vh264, h264, l1_is_long_term[i]);
278 }
279
280 ITEM_SET(vh264, h264, gop_size);
281
282 ITEM_SET(vh264, h264, quality_modes.level);
283 ITEM_SET(vh264, h264, quality_modes.preset_mode);
284 ITEM_SET(vh264, h264, quality_modes.pre_encode_mode);
285 ITEM_SET(vh264, h264, quality_modes.vbaq_mode);
286
287 ITEM_SET(vh264, h264, not_referenced);
288 ITEM_SET(vh264, h264, is_ltr);
289 ITEM_SET(vh264, h264, ltr_index);
290 ITEM_SET(vh264, h264, enable_vui);
291
292 ITEM_SET(vh264, h264, num_slice_descriptors);
293 for (i = 0; i < vh264->num_slice_descriptors; i++) {
294 ITEM_SET(vh264, h264, slices_descriptors[i].macroblock_address);
295 ITEM_SET(vh264, h264, slices_descriptors[i].num_macroblocks);
296 ITEM_SET(vh264, h264, slices_descriptors[i].slice_type);
297 }
298
299 return 0;
300 }
301
fill_h265_picture_desc(const struct pipe_picture_desc * desc,union virgl_picture_desc * vdsc)302 static int fill_h265_picture_desc(const struct pipe_picture_desc *desc,
303 union virgl_picture_desc *vdsc)
304 {
305 unsigned i;
306 struct virgl_video_buffer *vbuf;
307
308 struct virgl_h265_picture_desc *vh265 = &vdsc->h265;
309 struct pipe_h265_picture_desc *h265 = (struct pipe_h265_picture_desc *)desc;
310
311 fill_base_picture_desc(desc, &vh265->base);
312
313 ITEM_SET(&vh265->pps.sps, h265->pps->sps, chroma_format_idc);
314 ITEM_SET(&vh265->pps.sps, h265->pps->sps, separate_colour_plane_flag);
315 ITEM_SET(&vh265->pps.sps, h265->pps->sps, pic_width_in_luma_samples);
316 ITEM_SET(&vh265->pps.sps, h265->pps->sps, pic_height_in_luma_samples);
317 ITEM_SET(&vh265->pps.sps, h265->pps->sps, bit_depth_luma_minus8);
318 ITEM_SET(&vh265->pps.sps, h265->pps->sps, bit_depth_chroma_minus8);
319 ITEM_SET(&vh265->pps.sps, h265->pps->sps, log2_max_pic_order_cnt_lsb_minus4);
320 ITEM_SET(&vh265->pps.sps, h265->pps->sps, sps_max_dec_pic_buffering_minus1);
321 ITEM_SET(&vh265->pps.sps, h265->pps->sps, log2_min_luma_coding_block_size_minus3);
322 ITEM_SET(&vh265->pps.sps, h265->pps->sps, log2_diff_max_min_luma_coding_block_size);
323 ITEM_SET(&vh265->pps.sps, h265->pps->sps, log2_min_transform_block_size_minus2);
324 ITEM_SET(&vh265->pps.sps, h265->pps->sps, log2_diff_max_min_transform_block_size);
325 ITEM_SET(&vh265->pps.sps, h265->pps->sps, max_transform_hierarchy_depth_inter);
326 ITEM_SET(&vh265->pps.sps, h265->pps->sps, max_transform_hierarchy_depth_intra);
327 ITEM_SET(&vh265->pps.sps, h265->pps->sps, scaling_list_enabled_flag);
328 ITEM_CPY(&vh265->pps.sps, h265->pps->sps, ScalingList4x4);
329 ITEM_CPY(&vh265->pps.sps, h265->pps->sps, ScalingList8x8);
330 ITEM_CPY(&vh265->pps.sps, h265->pps->sps, ScalingList16x16);
331 ITEM_CPY(&vh265->pps.sps, h265->pps->sps, ScalingList32x32);
332 ITEM_CPY(&vh265->pps.sps, h265->pps->sps, ScalingListDCCoeff16x16);
333 ITEM_CPY(&vh265->pps.sps, h265->pps->sps, ScalingListDCCoeff32x32);
334 ITEM_SET(&vh265->pps.sps, h265->pps->sps, amp_enabled_flag);
335 ITEM_SET(&vh265->pps.sps, h265->pps->sps, sample_adaptive_offset_enabled_flag);
336 ITEM_SET(&vh265->pps.sps, h265->pps->sps, pcm_enabled_flag);
337 ITEM_SET(&vh265->pps.sps, h265->pps->sps, pcm_sample_bit_depth_luma_minus1);
338 ITEM_SET(&vh265->pps.sps, h265->pps->sps, pcm_sample_bit_depth_chroma_minus1);
339 ITEM_SET(&vh265->pps.sps, h265->pps->sps, log2_min_pcm_luma_coding_block_size_minus3);
340 ITEM_SET(&vh265->pps.sps, h265->pps->sps, log2_diff_max_min_pcm_luma_coding_block_size);
341 ITEM_SET(&vh265->pps.sps, h265->pps->sps, pcm_loop_filter_disabled_flag);
342 ITEM_SET(&vh265->pps.sps, h265->pps->sps, num_short_term_ref_pic_sets);
343 ITEM_SET(&vh265->pps.sps, h265->pps->sps, long_term_ref_pics_present_flag);
344 ITEM_SET(&vh265->pps.sps, h265->pps->sps, num_long_term_ref_pics_sps);
345 ITEM_SET(&vh265->pps.sps, h265->pps->sps, sps_temporal_mvp_enabled_flag);
346 ITEM_SET(&vh265->pps.sps, h265->pps->sps, strong_intra_smoothing_enabled_flag);
347
348 ITEM_SET(&vh265->pps, h265->pps, dependent_slice_segments_enabled_flag);
349 ITEM_SET(&vh265->pps, h265->pps, output_flag_present_flag);
350 ITEM_SET(&vh265->pps, h265->pps, num_extra_slice_header_bits);
351 ITEM_SET(&vh265->pps, h265->pps, sign_data_hiding_enabled_flag);
352 ITEM_SET(&vh265->pps, h265->pps, cabac_init_present_flag);
353 ITEM_SET(&vh265->pps, h265->pps, num_ref_idx_l0_default_active_minus1);
354 ITEM_SET(&vh265->pps, h265->pps, num_ref_idx_l1_default_active_minus1);
355 ITEM_SET(&vh265->pps, h265->pps, init_qp_minus26);
356 ITEM_SET(&vh265->pps, h265->pps, constrained_intra_pred_flag);
357 ITEM_SET(&vh265->pps, h265->pps, transform_skip_enabled_flag);
358 ITEM_SET(&vh265->pps, h265->pps, cu_qp_delta_enabled_flag);
359 ITEM_SET(&vh265->pps, h265->pps, diff_cu_qp_delta_depth);
360 ITEM_SET(&vh265->pps, h265->pps, pps_cb_qp_offset);
361 ITEM_SET(&vh265->pps, h265->pps, pps_cr_qp_offset);
362 ITEM_SET(&vh265->pps, h265->pps, pps_slice_chroma_qp_offsets_present_flag);
363 ITEM_SET(&vh265->pps, h265->pps, weighted_pred_flag);
364 ITEM_SET(&vh265->pps, h265->pps, weighted_bipred_flag);
365 ITEM_SET(&vh265->pps, h265->pps, transquant_bypass_enabled_flag);
366 ITEM_SET(&vh265->pps, h265->pps, tiles_enabled_flag);
367 ITEM_SET(&vh265->pps, h265->pps, entropy_coding_sync_enabled_flag);
368 ITEM_SET(&vh265->pps, h265->pps, num_tile_columns_minus1);
369 ITEM_SET(&vh265->pps, h265->pps, num_tile_rows_minus1);
370 ITEM_SET(&vh265->pps, h265->pps, uniform_spacing_flag);
371 ITEM_CPY(&vh265->pps, h265->pps, column_width_minus1);
372 ITEM_CPY(&vh265->pps, h265->pps, row_height_minus1);
373 ITEM_SET(&vh265->pps, h265->pps, loop_filter_across_tiles_enabled_flag);
374 ITEM_SET(&vh265->pps, h265->pps, pps_loop_filter_across_slices_enabled_flag);
375 ITEM_SET(&vh265->pps, h265->pps, deblocking_filter_control_present_flag);
376 ITEM_SET(&vh265->pps, h265->pps, deblocking_filter_override_enabled_flag);
377 ITEM_SET(&vh265->pps, h265->pps, pps_deblocking_filter_disabled_flag);
378 ITEM_SET(&vh265->pps, h265->pps, pps_beta_offset_div2);
379 ITEM_SET(&vh265->pps, h265->pps, pps_tc_offset_div2);
380 ITEM_SET(&vh265->pps, h265->pps, lists_modification_present_flag);
381 ITEM_SET(&vh265->pps, h265->pps, log2_parallel_merge_level_minus2);
382 ITEM_SET(&vh265->pps, h265->pps, slice_segment_header_extension_present_flag);
383 ITEM_SET(&vh265->pps, h265->pps, st_rps_bits);
384
385 ITEM_SET(vh265, h265, IDRPicFlag);
386 ITEM_SET(vh265, h265, RAPPicFlag);
387 ITEM_SET(vh265, h265, CurrRpsIdx);
388 ITEM_SET(vh265, h265, NumPocTotalCurr);
389 ITEM_SET(vh265, h265, NumDeltaPocsOfRefRpsIdx);
390 ITEM_SET(vh265, h265, NumShortTermPictureSliceHeaderBits);
391 ITEM_SET(vh265, h265, NumLongTermPictureSliceHeaderBits);
392
393 ITEM_SET(vh265, h265, CurrPicOrderCntVal);
394 for (i = 0; i < 16; i++) {
395 vbuf = virgl_video_buffer(h265->ref[i]);
396 vh265->ref[i] = vbuf ? vbuf->handle : 0;
397 }
398 ITEM_CPY(vh265, h265, PicOrderCntVal);
399 ITEM_CPY(vh265, h265, IsLongTerm);
400 ITEM_SET(vh265, h265, NumPocStCurrBefore);
401 ITEM_SET(vh265, h265, NumPocStCurrAfter);
402 ITEM_SET(vh265, h265, NumPocLtCurr);
403 ITEM_CPY(vh265, h265, RefPicSetStCurrBefore);
404 ITEM_CPY(vh265, h265, RefPicSetStCurrAfter);
405 ITEM_CPY(vh265, h265, RefPicSetLtCurr);
406 ITEM_CPY(vh265, h265, RefPicList);
407 ITEM_SET(vh265, h265, UseRefPicList);
408 ITEM_SET(vh265, h265, UseStRpsBits);
409
410 return 0;
411 }
412
fill_h265_enc_picture_desc(const struct pipe_picture_desc * desc,union virgl_picture_desc * vdsc)413 static int fill_h265_enc_picture_desc(const struct pipe_picture_desc *desc,
414 union virgl_picture_desc *vdsc)
415 {
416 unsigned i;
417 struct virgl_h265_enc_picture_desc *vh265 = &vdsc->h265_enc;
418 struct pipe_h265_enc_picture_desc *h265 = (struct pipe_h265_enc_picture_desc *)desc;
419
420 fill_base_picture_desc(desc, &vh265->base);
421
422 ITEM_SET(vh265, h265, seq.general_profile_idc);
423 ITEM_SET(vh265, h265, seq.general_level_idc);
424 ITEM_SET(vh265, h265, seq.general_tier_flag);
425 ITEM_SET(vh265, h265, seq.intra_period);
426 ITEM_SET(vh265, h265, seq.ip_period);
427 ITEM_SET(vh265, h265, seq.pic_width_in_luma_samples);
428 ITEM_SET(vh265, h265, seq.pic_height_in_luma_samples);
429 ITEM_SET(vh265, h265, seq.chroma_format_idc);
430 ITEM_SET(vh265, h265, seq.bit_depth_luma_minus8);
431 ITEM_SET(vh265, h265, seq.bit_depth_chroma_minus8);
432 ITEM_SET(vh265, h265, seq.strong_intra_smoothing_enabled_flag);
433 ITEM_SET(vh265, h265, seq.amp_enabled_flag);
434 ITEM_SET(vh265, h265, seq.sample_adaptive_offset_enabled_flag);
435 ITEM_SET(vh265, h265, seq.pcm_enabled_flag);
436 ITEM_SET(vh265, h265, seq.sps_temporal_mvp_enabled_flag);
437 ITEM_SET(vh265, h265, seq.log2_min_luma_coding_block_size_minus3);
438 ITEM_SET(vh265, h265, seq.log2_diff_max_min_luma_coding_block_size);
439 ITEM_SET(vh265, h265, seq.log2_min_transform_block_size_minus2);
440 ITEM_SET(vh265, h265, seq.log2_diff_max_min_transform_block_size);
441 ITEM_SET(vh265, h265, seq.max_transform_hierarchy_depth_inter);
442 ITEM_SET(vh265, h265, seq.max_transform_hierarchy_depth_intra);
443 ITEM_SET(vh265, h265, seq.conformance_window_flag);
444 ITEM_SET(vh265, h265, seq.conf_win_left_offset);
445 ITEM_SET(vh265, h265, seq.conf_win_right_offset);
446 ITEM_SET(vh265, h265, seq.conf_win_top_offset);
447 ITEM_SET(vh265, h265, seq.conf_win_bottom_offset);
448 ITEM_SET(vh265, h265, seq.vui_parameters_present_flag);
449 ITEM_SET(vh265, h265, seq.vui_flags.aspect_ratio_info_present_flag);
450 ITEM_SET(vh265, h265, seq.vui_flags.timing_info_present_flag);
451 ITEM_SET(vh265, h265, seq.aspect_ratio_idc);
452 ITEM_SET(vh265, h265, seq.sar_width);
453 ITEM_SET(vh265, h265, seq.sar_height);
454 ITEM_SET(vh265, h265, seq.num_units_in_tick);
455 ITEM_SET(vh265, h265, seq.time_scale);
456
457 ITEM_SET(vh265, h265, pic.log2_parallel_merge_level_minus2);
458 ITEM_SET(vh265, h265, pic.nal_unit_type);
459 ITEM_SET(vh265, h265, pic.constrained_intra_pred_flag);
460 ITEM_SET(vh265, h265, pic.pps_loop_filter_across_slices_enabled_flag);
461 ITEM_SET(vh265, h265, pic.transform_skip_enabled_flag);
462
463 ITEM_SET(vh265, h265, slice.max_num_merge_cand);
464 ITEM_SET(vh265, h265, slice.slice_cb_qp_offset);
465 ITEM_SET(vh265, h265, slice.slice_cr_qp_offset);
466 ITEM_SET(vh265, h265, slice.slice_beta_offset_div2);
467 ITEM_SET(vh265, h265, slice.slice_tc_offset_div2);
468 ITEM_SET(vh265, h265, slice.cabac_init_flag);
469 ITEM_SET(vh265, h265, slice.slice_deblocking_filter_disabled_flag);
470 ITEM_SET(vh265, h265, slice.slice_loop_filter_across_slices_enabled_flag);
471
472 ITEM_SET(vh265, h265, rc.rate_ctrl_method);
473 ITEM_SET(vh265, h265, rc.target_bitrate);
474 ITEM_SET(vh265, h265, rc.peak_bitrate);
475 ITEM_SET(vh265, h265, rc.frame_rate_num);
476 ITEM_SET(vh265, h265, rc.frame_rate_den);
477 ITEM_SET(vh265, h265, rc.quant_i_frames);
478 ITEM_SET(vh265, h265, rc.quant_p_frames);
479 ITEM_SET(vh265, h265, rc.quant_b_frames);
480 ITEM_SET(vh265, h265, rc.vbv_buffer_size);
481 ITEM_SET(vh265, h265, rc.vbv_buf_lv);
482 ITEM_SET(vh265, h265, rc.target_bits_picture);
483 ITEM_SET(vh265, h265, rc.peak_bits_picture_integer);
484 ITEM_SET(vh265, h265, rc.peak_bits_picture_fraction);
485 ITEM_SET(vh265, h265, rc.fill_data_enable);
486 ITEM_SET(vh265, h265, rc.skip_frame_enable);
487 ITEM_SET(vh265, h265, rc.enforce_hrd);
488 ITEM_SET(vh265, h265, rc.max_au_size);
489 ITEM_SET(vh265, h265, rc.max_qp);
490 ITEM_SET(vh265, h265, rc.min_qp);
491
492 ITEM_SET(vh265, h265, picture_type);
493 ITEM_SET(vh265, h265, decoded_curr_pic);
494
495 for (i = 0; i < 16; i++) {
496 ITEM_SET(vh265, h265, reference_frames[i]);
497 }
498
499 ITEM_SET(vh265, h265, frame_num);
500 ITEM_SET(vh265, h265, pic_order_cnt);
501 ITEM_SET(vh265, h265, pic_order_cnt_type);
502
503 ITEM_SET(vh265, h265, quality_modes.level);
504 ITEM_SET(vh265, h265, quality_modes.preset_mode);
505 ITEM_SET(vh265, h265, quality_modes.pre_encode_mode);
506 ITEM_SET(vh265, h265, quality_modes.vbaq_mode);
507
508 ITEM_SET(vh265, h265, num_ref_idx_l0_active_minus1);
509 ITEM_SET(vh265, h265, num_ref_idx_l1_active_minus1);
510
511 for (i = 0; i < 15; i++) {
512 ITEM_SET(vh265, h265, ref_idx_l0_list[i]);
513 ITEM_SET(vh265, h265, ref_idx_l1_list[i]);
514 }
515
516 ITEM_SET(vh265, h265, not_referenced);
517
518 ITEM_SET(vh265, h265, num_slice_descriptors);
519 for (i = 0; i < vh265->num_slice_descriptors; i++) {
520 ITEM_SET(vh265, h265, slices_descriptors[i].slice_segment_address);
521 ITEM_SET(vh265, h265, slices_descriptors[i].num_ctu_in_slice);
522 ITEM_SET(vh265, h265, slices_descriptors[i].slice_type);
523 }
524
525 return 0;
526 }
527
fill_mpeg4_picture_desc(const struct pipe_picture_desc * desc,union virgl_picture_desc * vdsc)528 static int fill_mpeg4_picture_desc(const struct pipe_picture_desc *desc,
529 union virgl_picture_desc *vdsc)
530 {
531 unsigned i;
532 struct virgl_video_buffer *vbuf;
533 struct virgl_mpeg4_picture_desc *vmpeg4 = &vdsc->mpeg4;
534 struct pipe_mpeg4_picture_desc *mpeg4 = (struct pipe_mpeg4_picture_desc *)desc;
535
536 fill_base_picture_desc(desc, &vmpeg4->base);
537
538 ITEM_CPY(vmpeg4, mpeg4, trd);
539 ITEM_CPY(vmpeg4, mpeg4, trb);
540 ITEM_SET(vmpeg4, mpeg4, vop_time_increment_resolution);
541 ITEM_SET(vmpeg4, mpeg4, vop_coding_type);
542 ITEM_SET(vmpeg4, mpeg4, vop_fcode_forward);
543 ITEM_SET(vmpeg4, mpeg4, vop_fcode_backward);
544 ITEM_SET(vmpeg4, mpeg4, resync_marker_disable);
545 ITEM_SET(vmpeg4, mpeg4, interlaced);
546 ITEM_SET(vmpeg4, mpeg4, quant_type);
547 ITEM_SET(vmpeg4, mpeg4, quarter_sample);
548 ITEM_SET(vmpeg4, mpeg4, short_video_header);
549 ITEM_SET(vmpeg4, mpeg4, rounding_control);
550 ITEM_SET(vmpeg4, mpeg4, alternate_vertical_scan_flag);
551 ITEM_SET(vmpeg4, mpeg4, top_field_first);
552
553 memcpy(vmpeg4->intra_matrix, mpeg4->intra_matrix, 64);
554 memcpy(vmpeg4->non_intra_matrix, mpeg4->non_intra_matrix, 64);
555
556 for (i = 0; i < ARRAY_SIZE(mpeg4->ref); i++) {
557 vbuf = virgl_video_buffer(mpeg4->ref[i]);
558 vmpeg4->ref[i] = vbuf ? vbuf->handle : 0;
559 }
560
561 return 0;
562 }
563
fill_mpeg12_picture_desc(const struct pipe_picture_desc * desc,union virgl_picture_desc * vdsc)564 static int fill_mpeg12_picture_desc(const struct pipe_picture_desc *desc,
565 union virgl_picture_desc *vdsc)
566 {
567 unsigned i;
568 struct virgl_video_buffer *vbuf;
569 struct virgl_mpeg12_picture_desc *vmpeg12 = &vdsc->mpeg12;
570 struct pipe_mpeg12_picture_desc *mpeg12 = (struct pipe_mpeg12_picture_desc *)desc;
571
572 fill_base_picture_desc(desc, &vmpeg12->base);
573
574 for (i = 0; i < 2; i++) {
575 vbuf = virgl_video_buffer(mpeg12->ref[i]);
576 vmpeg12->ref[i] = vbuf ? vbuf->handle : 0;
577 }
578
579 memcpy(vmpeg12->intra_matrix, mpeg12->intra_matrix, 64);
580 memcpy(vmpeg12->non_intra_matrix, mpeg12->non_intra_matrix, 64);
581
582 ITEM_SET(vmpeg12, mpeg12, picture_coding_type);
583 vmpeg12->f_code[0][0] = mpeg12->f_code[0][0] ;
584 vmpeg12->f_code[0][1] = mpeg12->f_code[0][1] ;
585 vmpeg12->f_code[1][0] = mpeg12->f_code[1][0] ;
586 vmpeg12->f_code[1][1] = mpeg12->f_code[1][1] ;
587 ITEM_SET(vmpeg12, mpeg12, intra_dc_precision);
588 ITEM_SET(vmpeg12, mpeg12, picture_structure);
589 ITEM_SET(vmpeg12, mpeg12, top_field_first);
590 ITEM_SET(vmpeg12, mpeg12, frame_pred_frame_dct);
591 ITEM_SET(vmpeg12, mpeg12, concealment_motion_vectors);
592 ITEM_SET(vmpeg12, mpeg12, q_scale_type);
593 ITEM_SET(vmpeg12, mpeg12, intra_vlc_format);
594 ITEM_SET(vmpeg12, mpeg12, alternate_scan);
595 return 0;
596 }
597
598
fill_vc1_picture_desc(const struct pipe_picture_desc * desc,union virgl_picture_desc * vdsc)599 static int fill_vc1_picture_desc(const struct pipe_picture_desc *desc,
600 union virgl_picture_desc *vdsc)
601 {
602 unsigned i;
603 struct virgl_video_buffer *vbuf;
604 struct virgl_vc1_picture_desc *vvc1 = &vdsc->vc1;
605 struct pipe_vc1_picture_desc *vc1 = (struct pipe_vc1_picture_desc *)desc;
606
607 fill_base_picture_desc(desc, &vvc1->base);
608
609 for (i = 0; i < 2; i++) {
610 vbuf = virgl_video_buffer(vc1->ref[i]);
611 vvc1->ref[i] = vbuf ? vbuf->handle : 0;
612 }
613 ITEM_SET(vvc1, vc1, picture_type);
614 ITEM_SET(vvc1, vc1, pulldown);
615 ITEM_SET(vvc1, vc1, interlace);
616 ITEM_SET(vvc1, vc1, tfcntrflag);
617 ITEM_SET(vvc1, vc1, finterpflag);
618 ITEM_SET(vvc1, vc1, psf);
619 ITEM_SET(vvc1, vc1, dquant);
620 ITEM_SET(vvc1, vc1, panscan_flag);
621 ITEM_SET(vvc1, vc1, refdist_flag);
622 ITEM_SET(vvc1, vc1, quantizer);
623 ITEM_SET(vvc1, vc1, extended_mv);
624 ITEM_SET(vvc1, vc1, extended_dmv);
625 ITEM_SET(vvc1, vc1, overlap);
626 ITEM_SET(vvc1, vc1, vstransform);
627 ITEM_SET(vvc1, vc1, loopfilter);
628 ITEM_SET(vvc1, vc1, fastuvmc);
629 ITEM_SET(vvc1, vc1, range_mapy_flag);
630 ITEM_SET(vvc1, vc1, range_mapy);
631 ITEM_SET(vvc1, vc1, range_mapuv_flag);
632 ITEM_SET(vvc1, vc1, range_mapuv);
633 ITEM_SET(vvc1, vc1, multires);
634 ITEM_SET(vvc1, vc1, syncmarker);
635 ITEM_SET(vvc1, vc1, rangered);
636 ITEM_SET(vvc1, vc1, maxbframes);
637 ITEM_SET(vvc1, vc1, deblockEnable);
638 ITEM_SET(vvc1, vc1, pquant);
639 ITEM_SET(vvc1, vc1, slice_count);
640
641 return 0;
642 }
643
fill_mjpeg_picture_desc(const struct pipe_picture_desc * desc,union virgl_picture_desc * vdsc)644 static int fill_mjpeg_picture_desc(const struct pipe_picture_desc *desc,
645 union virgl_picture_desc *vdsc)
646 {
647 unsigned i;
648 struct virgl_mjpeg_picture_desc *vmjpeg = &vdsc->mjpeg;
649 struct pipe_mjpeg_picture_desc *mjpeg = (struct pipe_mjpeg_picture_desc *)desc;
650
651 fill_base_picture_desc(desc, &vmjpeg->base);
652
653 ITEM_SET(&vmjpeg->picture_parameter, &mjpeg->picture_parameter, picture_width);
654 ITEM_SET(&vmjpeg->picture_parameter, &mjpeg->picture_parameter, picture_height);
655 ITEM_SET(&vmjpeg->picture_parameter, &mjpeg->picture_parameter, crop_x);
656 ITEM_SET(&vmjpeg->picture_parameter, &mjpeg->picture_parameter, crop_y);
657 ITEM_SET(&vmjpeg->picture_parameter, &mjpeg->picture_parameter, crop_width);
658 ITEM_SET(&vmjpeg->picture_parameter, &mjpeg->picture_parameter, crop_height);
659
660 ITEM_SET(&vmjpeg->picture_parameter, &mjpeg->picture_parameter, num_components);
661 for (i = 0; i < mjpeg->picture_parameter.num_components; ++i) {
662 ITEM_SET(&vmjpeg->picture_parameter.components[i], &mjpeg->picture_parameter.components[i], component_id);
663 ITEM_SET(&vmjpeg->picture_parameter.components[i], &mjpeg->picture_parameter.components[i], h_sampling_factor);
664 ITEM_SET(&vmjpeg->picture_parameter.components[i], &mjpeg->picture_parameter.components[i], v_sampling_factor);
665 ITEM_SET(&vmjpeg->picture_parameter.components[i], &mjpeg->picture_parameter.components[i], quantiser_table_selector);
666 }
667
668 ITEM_SET(&vmjpeg->slice_parameter, &mjpeg->slice_parameter, slice_data_size);
669 ITEM_SET(&vmjpeg->slice_parameter, &mjpeg->slice_parameter, slice_data_offset);
670 ITEM_SET(&vmjpeg->slice_parameter, &mjpeg->slice_parameter, slice_data_flag);
671 ITEM_SET(&vmjpeg->slice_parameter, &mjpeg->slice_parameter, slice_horizontal_position);
672 ITEM_SET(&vmjpeg->slice_parameter, &mjpeg->slice_parameter, slice_vertical_position);
673
674 ITEM_SET(&vmjpeg->slice_parameter, &mjpeg->slice_parameter, num_components);
675 for (i = 0; i < mjpeg->slice_parameter.num_components; ++i) {
676 ITEM_SET(&vmjpeg->slice_parameter.components[i], &mjpeg->slice_parameter.components[i], component_selector);
677 ITEM_SET(&vmjpeg->slice_parameter.components[i], &mjpeg->slice_parameter.components[i], dc_table_selector);
678 ITEM_SET(&vmjpeg->slice_parameter.components[i], &mjpeg->slice_parameter.components[i], ac_table_selector);
679 }
680
681 ITEM_SET(&vmjpeg->slice_parameter, &mjpeg->slice_parameter, restart_interval);
682 ITEM_SET(&vmjpeg->slice_parameter, &mjpeg->slice_parameter, num_mcus);
683
684 ITEM_CPY(&vmjpeg->quantization_table, &mjpeg->quantization_table, load_quantiser_table);
685 ITEM_CPY(&vmjpeg->quantization_table, &mjpeg->quantization_table, quantiser_table);
686
687 for (i = 0; i < 2; ++i) {
688 ITEM_SET(&vmjpeg->huffman_table, &mjpeg->huffman_table, load_huffman_table[i]);
689 ITEM_CPY(&vmjpeg->huffman_table.table[i], &mjpeg->huffman_table.table[i], num_dc_codes);
690 ITEM_CPY(&vmjpeg->huffman_table.table[i], &mjpeg->huffman_table.table[i], dc_values);
691 ITEM_CPY(&vmjpeg->huffman_table.table[i], &mjpeg->huffman_table.table[i], num_ac_codes);
692 ITEM_CPY(&vmjpeg->huffman_table.table[i], &mjpeg->huffman_table.table[i], ac_values);
693 ITEM_CPY(&vmjpeg->huffman_table.table[i], &mjpeg->huffman_table.table[i], pad);
694 }
695 return 0;
696 }
697
fill_vp9_picture_desc(const struct pipe_picture_desc * desc,union virgl_picture_desc * vdsc)698 static int fill_vp9_picture_desc(const struct pipe_picture_desc *desc,
699 union virgl_picture_desc *vdsc)
700 {
701 unsigned i;
702 struct virgl_video_buffer *vbuf;
703 struct virgl_vp9_picture_desc *vvp9 = &vdsc->vp9;
704 struct pipe_vp9_picture_desc *vp9 = (struct pipe_vp9_picture_desc *)desc;
705
706 fill_base_picture_desc(desc, &vvp9->base);
707
708 for (i = 0; i < 16; i++) {
709 vbuf = virgl_video_buffer(vp9->ref[i]);
710 vvp9->ref[i] = vbuf ? vbuf->handle : 0;
711 }
712
713 ITEM_SET(vvp9, vp9, picture_parameter.frame_width);
714 ITEM_SET(vvp9, vp9, picture_parameter.frame_height);
715 ITEM_SET(vvp9, vp9, picture_parameter.pic_fields.subsampling_x);
716 ITEM_SET(vvp9, vp9, picture_parameter.pic_fields.subsampling_y);
717 ITEM_SET(vvp9, vp9, picture_parameter.pic_fields.frame_type);
718 ITEM_SET(vvp9, vp9, picture_parameter.pic_fields.show_frame);
719 ITEM_SET(vvp9, vp9, picture_parameter.pic_fields.error_resilient_mode);
720 ITEM_SET(vvp9, vp9, picture_parameter.pic_fields.intra_only);
721 ITEM_SET(vvp9, vp9, picture_parameter.pic_fields.allow_high_precision_mv);
722 ITEM_SET(vvp9, vp9, picture_parameter.pic_fields.mcomp_filter_type);
723 ITEM_SET(vvp9, vp9, picture_parameter.pic_fields.frame_parallel_decoding_mode);
724 ITEM_SET(vvp9, vp9, picture_parameter.pic_fields.reset_frame_context);
725 ITEM_SET(vvp9, vp9, picture_parameter.pic_fields.refresh_frame_context);
726 ITEM_SET(vvp9, vp9, picture_parameter.pic_fields.frame_context_idx);
727 ITEM_SET(vvp9, vp9, picture_parameter.pic_fields.segmentation_enabled);
728 ITEM_SET(vvp9, vp9, picture_parameter.pic_fields.segmentation_temporal_update);
729 ITEM_SET(vvp9, vp9, picture_parameter.pic_fields.segmentation_update_map);
730 ITEM_SET(vvp9, vp9, picture_parameter.pic_fields.last_ref_frame);
731 ITEM_SET(vvp9, vp9, picture_parameter.pic_fields.last_ref_frame_sign_bias);
732 ITEM_SET(vvp9, vp9, picture_parameter.pic_fields.golden_ref_frame);
733 ITEM_SET(vvp9, vp9, picture_parameter.pic_fields.golden_ref_frame_sign_bias);
734 ITEM_SET(vvp9, vp9, picture_parameter.pic_fields.alt_ref_frame);
735 ITEM_SET(vvp9, vp9, picture_parameter.pic_fields.alt_ref_frame_sign_bias);
736 ITEM_SET(vvp9, vp9, picture_parameter.pic_fields.lossless_flag);
737 ITEM_SET(vvp9, vp9, picture_parameter.filter_level);
738 ITEM_SET(vvp9, vp9, picture_parameter.sharpness_level);
739 ITEM_SET(vvp9, vp9, picture_parameter.log2_tile_rows);
740 ITEM_SET(vvp9, vp9, picture_parameter.log2_tile_columns);
741 ITEM_SET(vvp9, vp9, picture_parameter.frame_header_length_in_bytes);
742 ITEM_SET(vvp9, vp9, picture_parameter.first_partition_size);
743 ITEM_CPY(vvp9, vp9, picture_parameter.mb_segment_tree_probs);
744 ITEM_CPY(vvp9, vp9, picture_parameter.segment_pred_probs);
745 ITEM_SET(vvp9, vp9, picture_parameter.profile);
746 ITEM_SET(vvp9, vp9, picture_parameter.bit_depth);
747 ITEM_SET(vvp9, vp9, picture_parameter.mode_ref_delta_enabled);
748 ITEM_SET(vvp9, vp9, picture_parameter.mode_ref_delta_update);
749 ITEM_SET(vvp9, vp9, picture_parameter.base_qindex);
750 ITEM_SET(vvp9, vp9, picture_parameter.y_dc_delta_q);
751 ITEM_SET(vvp9, vp9, picture_parameter.uv_ac_delta_q);
752 ITEM_SET(vvp9, vp9, picture_parameter.uv_dc_delta_q);
753 ITEM_SET(vvp9, vp9, picture_parameter.abs_delta);
754 ITEM_CPY(vvp9, vp9, picture_parameter.ref_deltas);
755 ITEM_CPY(vvp9, vp9, picture_parameter.mode_deltas);
756
757 vvp9->slice_parameter.slice_data_size = vp9->slice_parameter.slice_data_size[0];
758 vvp9->slice_parameter.slice_data_offset = vp9->slice_parameter.slice_data_offset[0];
759 vvp9->slice_parameter.slice_data_flag = vp9->slice_parameter.slice_data_flag[0];
760
761 for (i = 0; i < 8; i++) {
762 ITEM_SET(vvp9, vp9, slice_parameter.seg_param[i].segment_flags.segment_reference_enabled);
763 ITEM_SET(vvp9, vp9, slice_parameter.seg_param[i].segment_flags.segment_reference);
764 ITEM_SET(vvp9, vp9, slice_parameter.seg_param[i].segment_flags.segment_reference_skipped);
765 ITEM_CPY(vvp9, vp9, slice_parameter.seg_param[i].filter_level);
766 ITEM_SET(vvp9, vp9, slice_parameter.seg_param[i].luma_ac_quant_scale);
767 ITEM_SET(vvp9, vp9, slice_parameter.seg_param[i].luma_dc_quant_scale);
768 ITEM_SET(vvp9, vp9, slice_parameter.seg_param[i].chroma_ac_quant_scale);
769 ITEM_SET(vvp9, vp9, slice_parameter.seg_param[i].chroma_dc_quant_scale);
770 }
771
772 return 0;
773 }
774
fill_av1_picture_desc(const struct pipe_picture_desc * desc,union virgl_picture_desc * vdsc)775 static int fill_av1_picture_desc(const struct pipe_picture_desc *desc,
776 union virgl_picture_desc *vdsc)
777 {
778 unsigned i;
779 struct virgl_video_buffer *vbuf;
780 struct virgl_av1_picture_desc *vav1 = &vdsc->av1;
781 struct pipe_av1_picture_desc *av1 = (struct pipe_av1_picture_desc *)desc;
782
783 fill_base_picture_desc(desc, &vav1->base);
784
785 for (i = 0; i < ARRAY_SIZE(vav1->ref); i++) {
786 vbuf = virgl_video_buffer(av1->ref[i]);
787 vav1->ref[i] = vbuf ? vbuf->handle : 0;
788 }
789 vbuf = virgl_video_buffer(av1->film_grain_target);
790 vav1->film_grain_target = vbuf ? vbuf->handle : 0;
791
792 ITEM_SET(vav1, av1, picture_parameter.profile);
793 ITEM_SET(vav1, av1, picture_parameter.order_hint_bits_minus_1);
794 ITEM_SET(vav1, av1, picture_parameter.bit_depth_idx);
795
796 ITEM_SET(vav1, av1, picture_parameter.seq_info_fields.use_128x128_superblock);
797 ITEM_SET(vav1, av1, picture_parameter.seq_info_fields.enable_filter_intra);
798 ITEM_SET(vav1, av1, picture_parameter.seq_info_fields.enable_intra_edge_filter);
799 ITEM_SET(vav1, av1, picture_parameter.seq_info_fields.enable_interintra_compound);
800 ITEM_SET(vav1, av1, picture_parameter.seq_info_fields.enable_masked_compound);
801 ITEM_SET(vav1, av1, picture_parameter.seq_info_fields.enable_dual_filter);
802 ITEM_SET(vav1, av1, picture_parameter.seq_info_fields.enable_order_hint);
803 ITEM_SET(vav1, av1, picture_parameter.seq_info_fields.enable_jnt_comp);
804 ITEM_SET(vav1, av1, picture_parameter.seq_info_fields.enable_cdef);
805 ITEM_SET(vav1, av1, picture_parameter.seq_info_fields.mono_chrome);
806 ITEM_SET(vav1, av1, picture_parameter.seq_info_fields.ref_frame_mvs);
807 ITEM_SET(vav1, av1, picture_parameter.seq_info_fields.film_grain_params_present);
808
809 ITEM_SET(vav1, av1, picture_parameter.current_frame_id);
810 ITEM_SET(vav1, av1, picture_parameter.frame_width);
811 ITEM_SET(vav1, av1, picture_parameter.frame_height);
812 ITEM_SET(vav1, av1, picture_parameter.max_width);
813 ITEM_SET(vav1, av1, picture_parameter.max_height);
814 ITEM_CPY(vav1, av1, picture_parameter.ref_frame_idx);
815 ITEM_SET(vav1, av1, picture_parameter.primary_ref_frame);
816 ITEM_SET(vav1, av1, picture_parameter.order_hint);
817
818 ITEM_SET(vav1, av1, picture_parameter.seg_info.segment_info_fields.enabled);
819 ITEM_SET(vav1, av1, picture_parameter.seg_info.segment_info_fields.update_map);
820 ITEM_SET(vav1, av1, picture_parameter.seg_info.segment_info_fields.update_data);
821 ITEM_SET(vav1, av1, picture_parameter.seg_info.segment_info_fields.temporal_update);
822 ITEM_CPY(vav1, av1, picture_parameter.seg_info.feature_data);
823 ITEM_CPY(vav1, av1, picture_parameter.seg_info.feature_mask);
824
825 ITEM_SET(vav1, av1, picture_parameter.film_grain_info.film_grain_info_fields.apply_grain);
826 ITEM_SET(vav1, av1, picture_parameter.film_grain_info.film_grain_info_fields.chroma_scaling_from_luma);
827 ITEM_SET(vav1, av1, picture_parameter.film_grain_info.film_grain_info_fields.grain_scaling_minus_8);
828 ITEM_SET(vav1, av1, picture_parameter.film_grain_info.film_grain_info_fields.ar_coeff_lag);
829 ITEM_SET(vav1, av1, picture_parameter.film_grain_info.film_grain_info_fields.ar_coeff_shift_minus_6);
830 ITEM_SET(vav1, av1, picture_parameter.film_grain_info.film_grain_info_fields.grain_scale_shift);
831 ITEM_SET(vav1, av1, picture_parameter.film_grain_info.film_grain_info_fields.overlap_flag);
832 ITEM_SET(vav1, av1, picture_parameter.film_grain_info.film_grain_info_fields.clip_to_restricted_range);
833
834 ITEM_SET(vav1, av1, picture_parameter.film_grain_info.grain_seed);
835 ITEM_SET(vav1, av1, picture_parameter.film_grain_info.num_y_points);
836 ITEM_CPY(vav1, av1, picture_parameter.film_grain_info.point_y_value);
837 ITEM_CPY(vav1, av1, picture_parameter.film_grain_info.point_y_scaling);
838 ITEM_SET(vav1, av1, picture_parameter.film_grain_info.num_cb_points);
839 ITEM_CPY(vav1, av1, picture_parameter.film_grain_info.point_cb_value);
840 ITEM_CPY(vav1, av1, picture_parameter.film_grain_info.point_cb_scaling);
841 ITEM_SET(vav1, av1, picture_parameter.film_grain_info.num_cr_points);
842 ITEM_CPY(vav1, av1, picture_parameter.film_grain_info.point_cr_value);
843 ITEM_CPY(vav1, av1, picture_parameter.film_grain_info.point_cr_scaling);
844 ITEM_CPY(vav1, av1, picture_parameter.film_grain_info.ar_coeffs_y);
845 ITEM_CPY(vav1, av1, picture_parameter.film_grain_info.ar_coeffs_cb);
846 ITEM_CPY(vav1, av1, picture_parameter.film_grain_info.ar_coeffs_cr);
847 ITEM_SET(vav1, av1, picture_parameter.film_grain_info.cb_mult);
848 ITEM_SET(vav1, av1, picture_parameter.film_grain_info.cb_luma_mult);
849 ITEM_SET(vav1, av1, picture_parameter.film_grain_info.cb_offset);
850 ITEM_SET(vav1, av1, picture_parameter.film_grain_info.cr_mult);
851 ITEM_SET(vav1, av1, picture_parameter.film_grain_info.cr_luma_mult);
852 ITEM_SET(vav1, av1, picture_parameter.film_grain_info.cr_offset);
853
854 ITEM_SET(vav1, av1, picture_parameter.tile_cols);
855 ITEM_SET(vav1, av1, picture_parameter.tile_rows);
856 ITEM_CPY(vav1, av1, picture_parameter.tile_col_start_sb);
857 ITEM_CPY(vav1, av1, picture_parameter.tile_row_start_sb);
858 ITEM_CPY(vav1, av1, picture_parameter.width_in_sbs);
859 ITEM_CPY(vav1, av1, picture_parameter.height_in_sbs);
860 ITEM_SET(vav1, av1, picture_parameter.context_update_tile_id);
861
862 ITEM_SET(vav1, av1, picture_parameter.pic_info_fields.frame_type);
863 ITEM_SET(vav1, av1, picture_parameter.pic_info_fields.show_frame);
864 ITEM_SET(vav1, av1, picture_parameter.pic_info_fields.showable_frame);
865 ITEM_SET(vav1, av1, picture_parameter.pic_info_fields.error_resilient_mode);
866 ITEM_SET(vav1, av1, picture_parameter.pic_info_fields.disable_cdf_update);
867 ITEM_SET(vav1, av1, picture_parameter.pic_info_fields.allow_screen_content_tools);
868 ITEM_SET(vav1, av1, picture_parameter.pic_info_fields.force_integer_mv);
869 ITEM_SET(vav1, av1, picture_parameter.pic_info_fields.allow_intrabc);
870 ITEM_SET(vav1, av1, picture_parameter.pic_info_fields.use_superres);
871 ITEM_SET(vav1, av1, picture_parameter.pic_info_fields.allow_high_precision_mv);
872 ITEM_SET(vav1, av1, picture_parameter.pic_info_fields.is_motion_mode_switchable);
873 ITEM_SET(vav1, av1, picture_parameter.pic_info_fields.use_ref_frame_mvs);
874 ITEM_SET(vav1, av1, picture_parameter.pic_info_fields.disable_frame_end_update_cdf);
875 ITEM_SET(vav1, av1, picture_parameter.pic_info_fields.uniform_tile_spacing_flag);
876 ITEM_SET(vav1, av1, picture_parameter.pic_info_fields.allow_warped_motion);
877 ITEM_SET(vav1, av1, picture_parameter.pic_info_fields.large_scale_tile);
878
879 ITEM_SET(vav1, av1, picture_parameter.superres_scale_denominator);
880 ITEM_SET(vav1, av1, picture_parameter.interp_filter);
881 ITEM_CPY(vav1, av1, picture_parameter.filter_level);
882 ITEM_SET(vav1, av1, picture_parameter.filter_level_u);
883 ITEM_SET(vav1, av1, picture_parameter.filter_level_v);
884 ITEM_SET(vav1, av1, picture_parameter.loop_filter_info_fields.sharpness_level);
885 ITEM_SET(vav1, av1, picture_parameter.loop_filter_info_fields.mode_ref_delta_enabled);
886 ITEM_SET(vav1, av1, picture_parameter.loop_filter_info_fields.mode_ref_delta_update);
887
888 ITEM_CPY(vav1, av1, picture_parameter.ref_deltas);
889 ITEM_CPY(vav1, av1, picture_parameter.mode_deltas);
890 ITEM_SET(vav1, av1, picture_parameter.base_qindex);
891 ITEM_SET(vav1, av1, picture_parameter.y_dc_delta_q);
892 ITEM_SET(vav1, av1, picture_parameter.u_dc_delta_q);
893 ITEM_SET(vav1, av1, picture_parameter.u_ac_delta_q);
894 ITEM_SET(vav1, av1, picture_parameter.v_dc_delta_q);
895 ITEM_SET(vav1, av1, picture_parameter.v_ac_delta_q);
896
897 ITEM_SET(vav1, av1, picture_parameter.qmatrix_fields.using_qmatrix);
898 ITEM_SET(vav1, av1, picture_parameter.qmatrix_fields.qm_y);
899 ITEM_SET(vav1, av1, picture_parameter.qmatrix_fields.qm_u);
900 ITEM_SET(vav1, av1, picture_parameter.qmatrix_fields.qm_v);
901
902 ITEM_SET(vav1, av1, picture_parameter.mode_control_fields.delta_q_present_flag);
903 ITEM_SET(vav1, av1, picture_parameter.mode_control_fields.log2_delta_q_res);
904 ITEM_SET(vav1, av1, picture_parameter.mode_control_fields.delta_lf_present_flag);
905 ITEM_SET(vav1, av1, picture_parameter.mode_control_fields.log2_delta_lf_res);
906 ITEM_SET(vav1, av1, picture_parameter.mode_control_fields.delta_lf_multi);
907 ITEM_SET(vav1, av1, picture_parameter.mode_control_fields.tx_mode);
908 ITEM_SET(vav1, av1, picture_parameter.mode_control_fields.reference_select);
909 ITEM_SET(vav1, av1, picture_parameter.mode_control_fields.reduced_tx_set_used);
910 ITEM_SET(vav1, av1, picture_parameter.mode_control_fields.skip_mode_present);
911
912 ITEM_SET(vav1, av1, picture_parameter.cdef_damping_minus_3);
913 ITEM_SET(vav1, av1, picture_parameter.cdef_bits);
914 ITEM_CPY(vav1, av1, picture_parameter.cdef_y_strengths);
915 ITEM_CPY(vav1, av1, picture_parameter.cdef_uv_strengths);
916
917 ITEM_SET(vav1, av1, picture_parameter.loop_restoration_fields.yframe_restoration_type);
918 ITEM_SET(vav1, av1, picture_parameter.loop_restoration_fields.cbframe_restoration_type);
919 ITEM_SET(vav1, av1, picture_parameter.loop_restoration_fields.crframe_restoration_type);
920 ITEM_SET(vav1, av1, picture_parameter.loop_restoration_fields.lr_unit_shift);
921 ITEM_SET(vav1, av1, picture_parameter.loop_restoration_fields.lr_uv_shift);
922
923 for (i = 0; i < ARRAY_SIZE(vav1->picture_parameter.wm); i++) {
924 ITEM_SET(vav1, av1, picture_parameter.wm[i].wmtype);
925 ITEM_SET(vav1, av1, picture_parameter.wm[i].invalid);
926 ITEM_CPY(vav1, av1, picture_parameter.wm[i].wmmat);
927 }
928
929 ITEM_SET(vav1, av1, picture_parameter.refresh_frame_flags);
930 ITEM_SET(vav1, av1, picture_parameter.matrix_coefficients);
931
932 ITEM_CPY(vav1, av1, slice_parameter.slice_data_size);
933 ITEM_CPY(vav1, av1, slice_parameter.slice_data_offset);
934 ITEM_CPY(vav1, av1, slice_parameter.slice_data_row);
935 ITEM_CPY(vav1, av1, slice_parameter.slice_data_col);
936 ITEM_CPY(vav1, av1, slice_parameter.slice_data_anchor_frame_idx);
937 ITEM_SET(vav1, av1, slice_parameter.slice_count);
938
939 return 0;
940 }
941
942 #undef ITEM_SET
943 #undef ITEM_CPY
944
fill_picture_desc(const struct pipe_picture_desc * desc,union virgl_picture_desc * vdsc)945 static int fill_picture_desc(const struct pipe_picture_desc *desc,
946 union virgl_picture_desc *vdsc)
947 {
948 switch (u_reduce_video_profile(desc->profile)) {
949 case PIPE_VIDEO_FORMAT_MPEG4:
950 return fill_mpeg4_picture_desc(desc, vdsc);
951 case PIPE_VIDEO_FORMAT_MPEG4_AVC:
952 return fill_h264_picture_desc(desc, vdsc);
953 case PIPE_VIDEO_FORMAT_HEVC:
954 return fill_h265_picture_desc(desc, vdsc);
955 case PIPE_VIDEO_FORMAT_MPEG12:
956 return fill_mpeg12_picture_desc(desc, vdsc);
957 case PIPE_VIDEO_FORMAT_VC1:
958 return fill_vc1_picture_desc(desc, vdsc);
959 case PIPE_VIDEO_FORMAT_JPEG:
960 return fill_mjpeg_picture_desc(desc, vdsc);
961 case PIPE_VIDEO_FORMAT_VP9:
962 return fill_vp9_picture_desc(desc, vdsc);
963 case PIPE_VIDEO_FORMAT_AV1:
964 return fill_av1_picture_desc(desc, vdsc);
965 default:
966 return -1;
967 }
968 }
969
fill_enc_picture_desc(const struct pipe_picture_desc * desc,union virgl_picture_desc * vdsc)970 static int fill_enc_picture_desc(const struct pipe_picture_desc *desc,
971 union virgl_picture_desc *vdsc)
972 {
973 switch (u_reduce_video_profile(desc->profile)) {
974 case PIPE_VIDEO_FORMAT_MPEG4_AVC:
975 return fill_h264_enc_picture_desc(desc, vdsc);
976 case PIPE_VIDEO_FORMAT_HEVC:
977 return fill_h265_enc_picture_desc(desc, vdsc);
978 default:
979 return -1;
980 }
981 }
982
virgl_video_begin_frame(struct pipe_video_codec * codec,struct pipe_video_buffer * target,struct pipe_picture_desc * picture)983 static void virgl_video_begin_frame(struct pipe_video_codec *codec,
984 struct pipe_video_buffer *target,
985 struct pipe_picture_desc *picture)
986 {
987 struct virgl_video_codec *vcdc = virgl_video_codec(codec);
988 struct virgl_video_buffer *vbuf = virgl_video_buffer(target);
989
990 if (codec->entrypoint == PIPE_VIDEO_ENTRYPOINT_ENCODE)
991 fill_enc_picture_desc(picture, &vcdc->desc);
992
993 virgl_encode_begin_frame(vcdc->vctx, vcdc, vbuf);
994 }
995
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)996 static void virgl_video_decode_macroblock(struct pipe_video_codec *codec,
997 struct pipe_video_buffer *target,
998 struct pipe_picture_desc *picture,
999 const struct pipe_macroblock *macroblocks,
1000 unsigned num_macroblocks)
1001 {
1002 (void)codec;
1003 (void)target;
1004 (void)picture;
1005 (void)macroblocks;
1006 (void)num_macroblocks;
1007 }
1008
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)1009 static void virgl_video_decode_bitstream(struct pipe_video_codec *codec,
1010 struct pipe_video_buffer *target,
1011 struct pipe_picture_desc *picture,
1012 unsigned num_buffers,
1013 const void * const *buffers,
1014 const unsigned *sizes)
1015 {
1016 struct virgl_video_codec *vcdc = virgl_video_codec(codec);
1017 struct virgl_video_buffer *vbuf = virgl_video_buffer(target);
1018 struct virgl_context *vctx = vcdc->vctx;
1019 struct virgl_screen *vs = virgl_screen(vctx->base.screen);
1020 struct virgl_resource *vres;
1021 union virgl_picture_desc vdsc;
1022 struct pipe_transfer *xfer = NULL;
1023 void *ptr;
1024 unsigned i, total_size;
1025
1026 /* transfer bitstream data */
1027 for (i = 0, total_size = 0; i < num_buffers; i++)
1028 total_size += sizes[i];
1029
1030 if (total_size > pipe_buffer_size(vcdc->bs_buffers[vcdc->cur_buffer])) {
1031 pipe_resource_reference(&vcdc->bs_buffers[vcdc->cur_buffer], NULL);
1032 vcdc->bs_buffers[vcdc->cur_buffer] = pipe_buffer_create(vctx->base.screen,
1033 PIPE_BIND_CUSTOM, PIPE_USAGE_STAGING, total_size);
1034 }
1035
1036 vctx->base.flush(&vctx->base, NULL, 0);
1037
1038 vres = virgl_resource(vcdc->bs_buffers[vcdc->cur_buffer]);
1039 vs->vws->resource_wait(vs->vws, vres->hw_res);
1040 ptr = pipe_buffer_map(&vctx->base, vcdc->bs_buffers[vcdc->cur_buffer],
1041 PIPE_MAP_WRITE, &xfer);
1042 if (!ptr)
1043 return;
1044 for (i = 0, vcdc->bs_size = 0; i < num_buffers; i++) {
1045 memcpy((uint8_t *)ptr + vcdc->bs_size, buffers[i], sizes[i]);
1046 vcdc->bs_size += sizes[i];
1047 }
1048 pipe_buffer_unmap(&vctx->base, xfer);
1049
1050 /* transfer picture description */
1051 fill_picture_desc(picture, &vdsc);
1052 vres = virgl_resource(vcdc->desc_buffers[vcdc->cur_buffer]);
1053 vs->vws->resource_wait(vs->vws, vres->hw_res);
1054 ptr = pipe_buffer_map(&vctx->base, vcdc->desc_buffers[vcdc->cur_buffer],
1055 PIPE_MAP_WRITE, &xfer);
1056 if (!ptr)
1057 return;
1058 memcpy(ptr, &vdsc, sizeof(vdsc));
1059 pipe_buffer_unmap(&vctx->base, xfer);
1060
1061 virgl_encode_decode_bitstream(vctx, vcdc, vbuf, &vdsc, sizeof(vdsc));
1062 }
1063
virgl_video_encode_bitstream(struct pipe_video_codec * codec,struct pipe_video_buffer * source,struct pipe_resource * target,void ** feedback)1064 static void virgl_video_encode_bitstream(struct pipe_video_codec *codec,
1065 struct pipe_video_buffer *source,
1066 struct pipe_resource *target,
1067 void **feedback)
1068 {
1069 struct virgl_video_codec *vcdc = virgl_video_codec(codec);
1070 struct virgl_context *vctx = vcdc->vctx;
1071 struct virgl_screen *vs = virgl_screen(vctx->base.screen);
1072 struct virgl_resource *vres;
1073 struct virgl_video_encode_feedback *fb;
1074 struct pipe_transfer *xfer = NULL;
1075 void *ptr;
1076
1077 /* Transfer picture desc */
1078 vres = virgl_resource(vcdc->desc_buffers[vcdc->cur_buffer]);
1079 vs->vws->resource_wait(vs->vws, vres->hw_res);
1080 ptr = pipe_buffer_map(&vctx->base, vcdc->desc_buffers[vcdc->cur_buffer],
1081 PIPE_MAP_WRITE, &xfer);
1082 if (!ptr)
1083 return;
1084 memcpy(ptr, &vcdc->desc, sizeof(vcdc->desc));
1085 pipe_buffer_unmap(&vctx->base, xfer);
1086
1087 /* Init feedback */
1088 vres = virgl_resource(vcdc->feed_buffers[vcdc->cur_buffer]);
1089 vs->vws->resource_wait(vs->vws, vres->hw_res);
1090 fb = pipe_buffer_map(&vctx->base, vcdc->feed_buffers[vcdc->cur_buffer],
1091 PIPE_MAP_WRITE, &xfer);
1092 if (!fb)
1093 return;
1094 fb->stat = VIRGL_VIDEO_ENCODE_STAT_NOT_STARTED;
1095 fb->coded_size = 0;
1096 pipe_buffer_unmap(&vctx->base, xfer);
1097 *feedback = vres;
1098
1099 /*
1100 * These objects do not need to be transferred manually:
1101 * source - corresponds to VASurface in VA-API
1102 * target - corresponds to VACodedBuffer in VA-API
1103 */
1104
1105 virgl_encode_encode_bitstream(vctx, vcdc, virgl_video_buffer(source),
1106 virgl_resource(target));
1107 }
1108
virgl_video_end_frame(struct pipe_video_codec * codec,struct pipe_video_buffer * target,struct pipe_picture_desc * picture)1109 static void virgl_video_end_frame(struct pipe_video_codec *codec,
1110 struct pipe_video_buffer *target,
1111 struct pipe_picture_desc *picture)
1112 {
1113 struct virgl_video_codec *vcdc = virgl_video_codec(codec);
1114 struct virgl_context *vctx = virgl_context(vcdc->base.context);
1115 struct virgl_video_buffer *vbuf = virgl_video_buffer(target);
1116
1117 virgl_encode_end_frame(vctx, vcdc, vbuf);
1118 virgl_flush_eq(vctx, vctx, NULL);
1119
1120 switch_buffer(vcdc);
1121 }
1122
virgl_video_get_decoder_fence(struct pipe_video_codec * decoder,struct pipe_fence_handle * fence,uint64_t timeout)1123 static int virgl_video_get_decoder_fence(struct pipe_video_codec *decoder,
1124 struct pipe_fence_handle *fence,
1125 uint64_t timeout) {
1126 struct virgl_video_codec *vcdc = virgl_video_codec(decoder);
1127 struct virgl_context *vctx = vcdc->vctx;
1128 struct virgl_screen *vs = virgl_screen(vctx->base.screen);
1129
1130 return vs->vws->fence_wait(vs->vws, fence, timeout);
1131 }
1132
virgl_video_flush(struct pipe_video_codec * codec)1133 static void virgl_video_flush(struct pipe_video_codec *codec)
1134 {
1135 struct pipe_context *ctx = codec->context;
1136 struct pipe_fence_handle *fence = NULL;
1137
1138 ctx->flush(ctx, &fence, 0);
1139 if (fence) {
1140 ctx->screen->fence_finish(ctx->screen, NULL, fence, OS_TIMEOUT_INFINITE);
1141 ctx->screen->fence_reference(ctx->screen, &fence, NULL);
1142 }
1143 }
1144
virgl_video_get_feedback(struct pipe_video_codec * codec,void * feedback,unsigned * size,struct pipe_enc_feedback_metadata * metadata)1145 static void virgl_video_get_feedback(struct pipe_video_codec *codec,
1146 void *feedback,
1147 unsigned *size,
1148 struct pipe_enc_feedback_metadata* metadata)
1149 {
1150 struct virgl_video_codec *vcdc = virgl_video_codec(codec);
1151 struct virgl_context *vctx = vcdc->vctx;
1152 struct virgl_screen *vs = virgl_screen(vctx->base.screen);
1153 struct virgl_resource *vres = feedback;
1154 struct virgl_video_encode_feedback *fb;
1155 struct pipe_transfer *xfer;
1156
1157 if (!feedback || !size)
1158 return;
1159
1160 vs->vws->resource_wait(vs->vws, vres->hw_res);
1161 fb = pipe_buffer_map(&vctx->base, &vres->b, PIPE_MAP_READ, &xfer);
1162 if (!fb)
1163 return;
1164 if (fb->stat == VIRGL_VIDEO_ENCODE_STAT_SUCCESS) {
1165 *size = fb->coded_size;
1166 } else {
1167 *size = 0;
1168 if (virgl_debug & VIRGL_DEBUG_VIDEO) {
1169 debug_printf("unexpected encode feedback: %u\n", fb->stat);
1170 }
1171 }
1172 pipe_buffer_unmap(&vctx->base, xfer);
1173 }
1174
virgl_video_destroy_codec(struct pipe_video_codec * codec)1175 static void virgl_video_destroy_codec(struct pipe_video_codec *codec)
1176 {
1177 unsigned i;
1178 struct virgl_video_codec *vcdc = virgl_video_codec(codec);
1179 struct virgl_context *vctx = virgl_context(vcdc->base.context);
1180
1181 for (i = 0; i < VIRGL_VIDEO_CODEC_BUF_NUM; i++) {
1182 if (codec->entrypoint != PIPE_VIDEO_ENTRYPOINT_ENCODE) {
1183 pipe_resource_reference(&vcdc->bs_buffers[i], NULL);
1184 } else {
1185 pipe_resource_reference(&vcdc->feed_buffers[i], NULL);
1186 }
1187 pipe_resource_reference(&vcdc->desc_buffers[i], NULL);
1188 }
1189
1190 virgl_encode_destroy_video_codec(vctx, vcdc);
1191
1192 free(vcdc);
1193 }
1194
1195
1196 struct pipe_video_codec *
virgl_video_create_codec(struct pipe_context * ctx,const struct pipe_video_codec * templ)1197 virgl_video_create_codec(struct pipe_context *ctx,
1198 const struct pipe_video_codec *templ)
1199 {
1200 unsigned i;
1201 struct virgl_video_codec *vcdc;
1202 struct virgl_context *vctx = virgl_context(ctx);
1203 unsigned width = templ->width, height = templ->height;
1204
1205 if (virgl_debug & VIRGL_DEBUG_VIDEO)
1206 debug_printf("VIDEO: create codec. profile=%d, level=%u, entryp=%d, "
1207 "chroma_fmt=%d, size=%ux%u, max_ref=%u, expect=%d\n",
1208 templ->profile, templ->level, templ->entrypoint,
1209 templ->chroma_format, templ->width, templ->height,
1210 templ->max_references, templ->expect_chunked_decode);
1211
1212 switch (u_reduce_video_profile(templ->profile)) {
1213 case PIPE_VIDEO_FORMAT_MPEG4: /* fall through */
1214 case PIPE_VIDEO_FORMAT_MPEG4_AVC:
1215 width = align(width, VL_MACROBLOCK_WIDTH);
1216 height = align(height, VL_MACROBLOCK_HEIGHT);
1217 break;
1218 case PIPE_VIDEO_FORMAT_HEVC:
1219 case PIPE_VIDEO_FORMAT_MPEG12:
1220 case PIPE_VIDEO_FORMAT_VC1:
1221 case PIPE_VIDEO_FORMAT_JPEG:
1222 case PIPE_VIDEO_FORMAT_VP9:
1223 case PIPE_VIDEO_FORMAT_AV1: /* fall through */
1224 default:
1225 break;
1226 }
1227
1228 vcdc = CALLOC_STRUCT(virgl_video_codec);
1229 if (!vcdc)
1230 return NULL;
1231
1232 vcdc->base = *templ;
1233 vcdc->base.width = width;
1234 vcdc->base.height = height;
1235 vcdc->base.context = ctx;
1236
1237 vcdc->base.destroy = virgl_video_destroy_codec;
1238 vcdc->base.begin_frame = virgl_video_begin_frame;
1239 vcdc->base.decode_macroblock = virgl_video_decode_macroblock;
1240 vcdc->base.decode_bitstream = virgl_video_decode_bitstream;
1241 vcdc->base.encode_bitstream = virgl_video_encode_bitstream;
1242 vcdc->base.end_frame = virgl_video_end_frame;
1243 vcdc->base.flush = virgl_video_flush;
1244 vcdc->base.get_feedback = virgl_video_get_feedback;
1245
1246 vcdc->bs_size = 0;
1247 vcdc->cur_buffer = 0;
1248 for (i = 0; i < VIRGL_VIDEO_CODEC_BUF_NUM; i++) {
1249 if (templ->entrypoint != PIPE_VIDEO_ENTRYPOINT_ENCODE) {
1250 vcdc->bs_buffers[i] = pipe_buffer_create(ctx->screen,
1251 PIPE_BIND_CUSTOM, PIPE_USAGE_STAGING,
1252 BS_BUF_DEFAULT_SIZE(width, height));
1253 } else {
1254 vcdc->feed_buffers[i] = pipe_buffer_create(ctx->screen,
1255 PIPE_BIND_CUSTOM, PIPE_USAGE_STAGING,
1256 sizeof(struct virgl_video_encode_feedback));
1257 }
1258
1259 vcdc->desc_buffers[i] = pipe_buffer_create(ctx->screen,
1260 PIPE_BIND_CUSTOM, PIPE_USAGE_STAGING,
1261 sizeof(union virgl_picture_desc));
1262 }
1263
1264 vcdc->handle = virgl_object_assign_handle();
1265 vcdc->vctx = vctx;
1266
1267 virgl_encode_create_video_codec(vctx, vcdc);
1268
1269 return &vcdc->base;
1270 }
1271
1272
virgl_video_destroy_buffer(struct pipe_video_buffer * buffer)1273 static void virgl_video_destroy_buffer(struct pipe_video_buffer *buffer)
1274 {
1275 struct virgl_video_buffer *vbuf = virgl_video_buffer(buffer);
1276
1277 virgl_encode_destroy_video_buffer(vbuf->vctx, vbuf);
1278
1279 vl_video_buffer_destroy(buffer);
1280
1281 free(vbuf);
1282 }
1283
virgl_video_destroy_buffer_associated_data(void * data)1284 static void virgl_video_destroy_buffer_associated_data(void *data)
1285 {
1286 (void)data;
1287 }
1288
1289 struct pipe_video_buffer *
virgl_video_create_buffer(struct pipe_context * ctx,const struct pipe_video_buffer * tmpl)1290 virgl_video_create_buffer(struct pipe_context *ctx,
1291 const struct pipe_video_buffer *tmpl)
1292 {
1293 struct virgl_context *vctx = virgl_context(ctx);
1294 struct virgl_video_buffer *vbuf;
1295
1296 vbuf = CALLOC_STRUCT(virgl_video_buffer);
1297 if (!vbuf)
1298 return NULL;
1299
1300 vbuf->buf = vl_video_buffer_create(ctx, tmpl);
1301 if (!vbuf->buf) {
1302 free(vbuf);
1303 return NULL;
1304 }
1305 vbuf->buf->destroy = virgl_video_destroy_buffer;
1306 vl_video_buffer_set_associated_data(vbuf->buf,
1307 NULL, vbuf, virgl_video_destroy_buffer_associated_data);
1308
1309 vbuf->num_planes = util_format_get_num_planes(vbuf->buf->buffer_format);
1310 vbuf->plane_views = vbuf->buf->get_sampler_view_planes(vbuf->buf);
1311 vbuf->handle = virgl_object_assign_handle();
1312 vbuf->buffer_format = tmpl->buffer_format;
1313 vbuf->width = tmpl->width;
1314 vbuf->height = tmpl->height;
1315 vbuf->vctx = vctx;
1316
1317 virgl_encode_create_video_buffer(vctx, vbuf);
1318
1319 if (virgl_debug & VIRGL_DEBUG_VIDEO) {
1320 debug_printf("VIDEO: create buffer. fmt=%s, %ux%u, num_planes=%u\n",
1321 util_format_name(tmpl->buffer_format),
1322 tmpl->width, tmpl->height, vbuf->num_planes);
1323
1324 for (unsigned i = 0; i < vbuf->num_planes; i++)
1325 if (vbuf->plane_views[i])
1326 debug_printf("VIDEO: plane[%d]: fmt=%s, target=%u\n", i,
1327 util_format_name(vbuf->plane_views[i]->format),
1328 vbuf->plane_views[i]->target);
1329 }
1330
1331 return vbuf->buf;
1332 }
1333
1334