Debian Codegraph @

src/i965_avc_encoder.c

raw
1 /*
2 * Copyright @ 2017 Intel Corporation
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the
6 * "Software"), to deal in the Software without restriction, including
7 * without limitation the rights to use, copy, modify, merge, publish,
8 * distribute, sub license, and/or sell copies of the Software, and to
9 * permit persons to whom the Software is furnished to do so, subject to
10 * the following conditions:
11 *
12 * The above copyright notice and this permission notice (including the
13 * next paragraph) shall be included in all copies or substantial portions
14 * of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
17 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
18 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
19 * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
20 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
21 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
22 * SOFTWAR OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
23 *
24 * Authors:
25 * Pengfei Qu <[email protected]>
26 * Sreerenj Balachandran <[email protected]>
27 *
28 */
29
30 #include <stdio.h>
31 #include <stdlib.h>
32 #include <stdbool.h>
33 #include <string.h>
34 #include <math.h>
35 #include <assert.h>
36 #include <va/va.h>
37
38 #include "intel_batchbuffer.h"
39 #include "intel_driver.h"
40
41 #include "i965_defines.h"
42 #include "i965_structs.h"
43 #include "i965_drv_video.h"
44 #include "i965_encoder.h"
45 #include "i965_encoder_utils.h"
46 #include "intel_media.h"
47
48 #include "i965_gpe_utils.h"
49 #include "i965_encoder_common.h"
50 #include "i965_avc_encoder_common.h"
51 #include "i965_avc_encoder_kernels.h"
52 #include "i965_avc_encoder.h"
53 #include "i965_avc_const_def.h"
54
55 #define MAX_URB_SIZE 4096 /* In register */
56 #define NUM_KERNELS_PER_GPE_CONTEXT 1
57 #define MBENC_KERNEL_BASE GEN9_AVC_KERNEL_MBENC_QUALITY_I
58 #define GPE_RESOURCE_ALIGNMENT 4 /* 4 means 16 = 1 << 4) */
59
60 #define OUT_BUFFER_2DW(batch, bo, is_target, delta) do { \
61 if (bo) { \
62 OUT_BCS_RELOC64(batch, \
63 bo, \
64 I915_GEM_DOMAIN_INSTRUCTION, \
65 is_target ? I915_GEM_DOMAIN_RENDER : 0, \
66 delta); \
67 } else { \
68 OUT_BCS_BATCH(batch, 0); \
69 OUT_BCS_BATCH(batch, 0); \
70 } \
71 } while (0)
72
73 #define OUT_BUFFER_3DW(batch, bo, is_target, delta, attr) do { \
74 OUT_BUFFER_2DW(batch, bo, is_target, delta); \
75 OUT_BCS_BATCH(batch, attr); \
76 } while (0)
77
78 /* FEI specific buffer sizes per MB in bytes for gen9 */
79 #define FEI_AVC_MB_CODE_BUFFER_SIZE 64
80 #define FEI_AVC_MV_DATA_BUFFER_SIZE 128
81 #define FEI_AVC_MB_CONTROL_BUFFER_SIZE 16
82 #define FEI_AVC_MV_PREDICTOR_BUFFER_SIZE 40
83 #define FEI_AVC_DISTORTION_BUFFER_SIZE 48
84 #define FEI_AVC_QP_BUFFER_SIZE 1
85 #define PREENC_AVC_STATISTICS_BUFFER_SIZE 64
86
87 #define SCALE_CUR_PIC 1
88 #define SCALE_PAST_REF_PIC 2
89 #define SCALE_FUTURE_REF_PIC 3
90
91 static const uint32_t qm_flat[16] = {
92 0x10101010, 0x10101010, 0x10101010, 0x10101010,
93 0x10101010, 0x10101010, 0x10101010, 0x10101010,
94 0x10101010, 0x10101010, 0x10101010, 0x10101010,
95 0x10101010, 0x10101010, 0x10101010, 0x10101010
96 };
97
98 static const uint32_t fqm_flat[32] = {
99 0x10001000, 0x10001000, 0x10001000, 0x10001000,
100 0x10001000, 0x10001000, 0x10001000, 0x10001000,
101 0x10001000, 0x10001000, 0x10001000, 0x10001000,
102 0x10001000, 0x10001000, 0x10001000, 0x10001000,
103 0x10001000, 0x10001000, 0x10001000, 0x10001000,
104 0x10001000, 0x10001000, 0x10001000, 0x10001000,
105 0x10001000, 0x10001000, 0x10001000, 0x10001000,
106 0x10001000, 0x10001000, 0x10001000, 0x10001000
107 };
108
109 static const unsigned int slice_type_kernel[3] = {1, 2, 0};
110
111 static const gen9_avc_brc_init_reset_curbe_data gen9_avc_brc_init_reset_curbe_init_data = {
112 // unsigned int 0
113 {
114 0
115 },
116
117 // unsigned int 1
118 {
119 0
120 },
121
122 // unsigned int 2
123 {
124 0
125 },
126
127 // unsigned int 3
128 {
129 0
130 },
131
132 // unsigned int 4
133 {
134 0
135 },
136
137 // unsigned int 5
138 {
139 0
140 },
141
142 // unsigned int 6
143 {
144 0
145 },
146
147 // unsigned int 7
148 {
149 0
150 },
151
152 // unsigned int 8
153 {
154 0,
155 0
156 },
157
158 // unsigned int 9
159 {
160 0,
161 0
162 },
163
164 // unsigned int 10
165 {
166 0,
167 0
168 },
169
170 // unsigned int 11
171 {
172 0,
173 1
174 },
175
176 // unsigned int 12
177 {
178 51,
179 0
180 },
181
182 // unsigned int 13
183 {
184 40,
185 60,
186 80,
187 120
188 },
189
190 // unsigned int 14
191 {
192 35,
193 60,
194 80,
195 120
196 },
197
198 // unsigned int 15
199 {
200 40,
201 60,
202 90,
203 115
204 },
205
206 // unsigned int 16
207 {
208 0,
209 0,
210 0,
211 0
212 },
213
214 // unsigned int 17
215 {
216 0,
217 0,
218 0,
219 0
220 },
221
222 // unsigned int 18
223 {
224 0,
225 0,
226 0,
227 0
228 },
229
230 // unsigned int 19
231 {
232 0,
233 0,
234 0,
235 0
236 },
237
238 // unsigned int 20
239 {
240 0,
241 0,
242 0,
243 0
244 },
245
246 // unsigned int 21
247 {
248 0,
249 0,
250 0,
251 0
252 },
253
254 // unsigned int 22
255 {
256 0,
257 0,
258 0,
259 0
260 },
261
262 // unsigned int 23
263 {
264 0
265 }
266 };
267
268 static const gen8_avc_frame_brc_update_curbe_data gen8_avc_frame_brc_update_curbe_init_data = {
269 //unsigned int 0
270 {
271 0
272 },
273
274 //unsigned int 1
275 {
276 0
277 },
278
279 //unsigned int 2
280 {
281 0
282 },
283
284 //unsigned int 3
285 {
286
287 10,
288 50
289
290 },
291
292 //unsigned int 4
293 {
294
295 100,
296 150
297
298 },
299
300 //unsigned int 5
301 {
302 0, 0, 0, 0
303 },
304
305 //unsigned int 6
306 {
307 0, 0, 0, 0, 0, 0
308 },
309
310 //unsigned int 7
311 {
312 0
313 },
314
315 //unsigned int 8
316 {
317
318 1,
319 1,
320 3,
321 2
322
323 },
324
325 //unsigned int 9
326 {
327
328 1,
329 40,
330 5,
331 5
332
333 },
334
335 //unsigned int 10
336 {
337
338 3,
339 1,
340 7,
341 18
342
343 },
344
345 //unsigned int 11
346 {
347
348 25,
349 37,
350 40,
351 75
352
353 },
354
355 //unsigned int 12
356 {
357
358 97,
359 103,
360 125,
361 160
362
363 },
364
365 //unsigned int 13
366 {
367
368 -3,
369 -2,
370 -1,
371 0
372
373 },
374
375 //unsigned int 14
376 {
377
378 1,
379 2,
380 3,
381 0xff
382
383 },
384
385 //unsigned int 15
386 {
387 0, 0, 0
388 },
389
390 //unsigned int 16
391 {
392 0, 0
393 },
394
395 //unsigned int 17
396 {
397 0, 0
398 },
399
400 //unsigned int 18
401 {
402 0, 0
403 },
404
405 //unsigned int 19
406 {
407 0
408 },
409
410 //unsigned int 20
411 {
412 0
413 },
414
415 //unsigned int 21
416 {
417 0
418 },
419
420 //unsigned int 22
421 {
422 0
423 },
424
425 //unsigned int 23
426 {
427 0
428 },
429 };
430 static const gen9_avc_frame_brc_update_curbe_data gen9_avc_frame_brc_update_curbe_init_data = {
431 // unsigned int 0
432 {
433 0
434 },
435
436 // unsigned int 1
437 {
438 0
439 },
440
441 // unsigned int 2
442 {
443 0
444 },
445
446 // unsigned int 3
447 {
448 10,
449 50
450 },
451
452 // unsigned int 4
453 {
454 100,
455 150
456 },
457
458 // unsigned int 5
459 {
460 0,
461 0,
462 0,
463 0
464 },
465
466 // unsigned int 6
467 {
468 0,
469 0,
470 0,
471 0,
472 0,
473 0
474 },
475
476 // unsigned int 7
477 {
478 0
479 },
480
481 // unsigned int 8
482 {
483 1,
484 1,
485 3,
486 2
487 },
488
489 // unsigned int 9
490 {
491 1,
492 40,
493 5,
494 5
495 },
496
497 // unsigned int 10
498 {
499 3,
500 1,
501 7,
502 18
503 },
504
505 // unsigned int 11
506 {
507 25,
508 37,
509 40,
510 75
511 },
512
513 // unsigned int 12
514 {
515 97,
516 103,
517 125,
518 160
519 },
520
521 // unsigned int 13
522 {
523 -3,
524 -2,
525 -1,
526 0
527 },
528
529 // unsigned int 14
530 {
531 1,
532 2,
533 3,
534 0xff
535 },
536
537 // unsigned int 15
538 {
539 0,
540 0,
541 0,
542 0
543 },
544
545 // unsigned int 16
546 {
547 0
548 },
549
550 // unsigned int 17
551 {
552 0
553 },
554
555 // unsigned int 18
556 {
557 0
558 },
559
560 // unsigned int 19
561 {
562 0
563 },
564
565 // unsigned int 20
566 {
567 0
568 },
569
570 // unsigned int 21
571 {
572 0
573 },
574
575 // unsigned int 22
576 {
577 0
578 },
579
580 // unsigned int 23
581 {
582 0
583 },
584
585 };
586
587 static const gen8_avc_ipcm_threshold gen8_avc_ipcm_threshold_table[5] =
588 {
589 { 2, 3000 },
590 { 4, 3600 },
591 { 6, 5000 },
592 { 10, 7500 },
593 { 18, 9000 },
594 };
595
596 static void
597 gen9_avc_update_misc_parameters(VADriverContextP ctx,
598 struct encode_state *encode_state,
599 struct intel_encoder_context *encoder_context)
600 {
601 struct encoder_vme_mfc_context * vme_context = (struct encoder_vme_mfc_context *)encoder_context->vme_context;
602 struct generic_enc_codec_state * generic_state = (struct generic_enc_codec_state *)vme_context->generic_enc_state;
603 int i;
604
605 /* brc */
606 generic_state->max_bit_rate = (encoder_context->brc.bits_per_second[0] + 1000 - 1) / 1000;
607
608 if (generic_state->internal_rate_mode == VA_RC_CBR) {
609 generic_state->min_bit_rate = generic_state->max_bit_rate;
610 generic_state->mb_brc_enabled = encoder_context->brc.mb_rate_control[0] == 1;
611
612 if (generic_state->target_bit_rate != generic_state->max_bit_rate) {
613 generic_state->target_bit_rate = generic_state->max_bit_rate;
614 generic_state->brc_need_reset = 1;
615 }
616 } else if (generic_state->internal_rate_mode == VA_RC_VBR) {
617 generic_state->min_bit_rate = generic_state->max_bit_rate * (2 * encoder_context->brc.target_percentage[0] - 100) / 100;
618 generic_state->mb_brc_enabled = encoder_context->brc.mb_rate_control[0] == 1;
619
620 if (generic_state->target_bit_rate != generic_state->max_bit_rate * encoder_context->brc.target_percentage[0] / 100) {
621 generic_state->target_bit_rate = generic_state->max_bit_rate * encoder_context->brc.target_percentage[0] / 100;
622 generic_state->brc_need_reset = 1;
623 }
624 }
625
626 /* frame rate */
627 if (generic_state->internal_rate_mode != VA_RC_CQP) {
628 generic_state->frames_per_100s = encoder_context->brc.framerate[0].num * 100 / encoder_context->brc.framerate[0].den ;
629 generic_state->frame_rate = encoder_context->brc.framerate[0].num / encoder_context->brc.framerate[0].den ;
630 generic_state->frames_per_window_size = (int)(encoder_context->brc.window_size * generic_state->frame_rate / 1000); // brc.windows size in ms as the unit
631 } else {
632 generic_state->frames_per_100s = 30 * 100;
633 generic_state->frame_rate = 30 ;
634 generic_state->frames_per_window_size = 30;
635 }
636
637 /* HRD */
638 if (generic_state->internal_rate_mode != VA_RC_CQP) {
639 generic_state->vbv_buffer_size_in_bit = encoder_context->brc.hrd_buffer_size;//misc->buffer_size;
640 generic_state->init_vbv_buffer_fullness_in_bit = encoder_context->brc.hrd_initial_buffer_fullness;//misc->initial_buffer_fullness;
641 }
642
643 /* ROI */
644 generic_state->num_roi = MIN(encoder_context->brc.num_roi, 3);
645 if (generic_state->num_roi > 0) {
646 generic_state->max_delta_qp = encoder_context->brc.roi_max_delta_qp;
647 generic_state->min_delta_qp = encoder_context->brc.roi_min_delta_qp;
648
649 for (i = 0; i < generic_state->num_roi; i++) {
650 generic_state->roi[i].left = encoder_context->brc.roi[i].left;
651 generic_state->roi[i].right = encoder_context->brc.roi[i].right;
652 generic_state->roi[i].top = encoder_context->brc.roi[i].top;
653 generic_state->roi[i].bottom = encoder_context->brc.roi[i].bottom;
654 generic_state->roi[i].value = encoder_context->brc.roi[i].value;
655
656 generic_state->roi[i].left /= 16;
657 generic_state->roi[i].right /= 16;
658 generic_state->roi[i].top /= 16;
659 generic_state->roi[i].bottom /= 16;
660 }
661 }
662
663 }
664
665 static bool
666 intel_avc_get_kernel_header_and_size(void *pvbinary,
667 int binary_size,
668 INTEL_GENERIC_ENC_OPERATION operation,
669 int krnstate_idx,
670 struct i965_kernel *ret_kernel)
671 {
672 typedef uint32_t BIN_PTR[4];
673
674 char *bin_start;
675 gen9_avc_encoder_kernel_header *pkh_table;
676 kernel_header *pcurr_header, *pinvalid_entry, *pnext_header;
677 int next_krnoffset;
678
679 if (!pvbinary || !ret_kernel)
680 return false;
681
682 bin_start = (char *)pvbinary;
683 pkh_table = (gen9_avc_encoder_kernel_header *)pvbinary;
684 pinvalid_entry = &(pkh_table->static_detection) + 1;
685 next_krnoffset = binary_size;
686
687 if (operation == INTEL_GENERIC_ENC_SCALING4X) {
688 pcurr_header = &pkh_table->ply_dscale_ply;
689 } else if (operation == INTEL_GENERIC_ENC_SCALING2X) {
690 pcurr_header = &pkh_table->ply_2xdscale_ply;
691 } else if (operation == INTEL_GENERIC_ENC_ME) {
692 pcurr_header = &pkh_table->me_p;
693 } else if (operation == INTEL_GENERIC_ENC_BRC) {
694 pcurr_header = &pkh_table->frame_brc_init;
695 } else if (operation == INTEL_GENERIC_ENC_MBENC) {
696 pcurr_header = &pkh_table->mbenc_quality_I;
697 } else if (operation == INTEL_GENERIC_ENC_WP) {
698 pcurr_header = &pkh_table->wp;
699 } else if (operation == INTEL_GENERIC_ENC_SFD) {
700 pcurr_header = &pkh_table->static_detection;
701 } else {
702 return false;
703 }
704
705 pcurr_header += krnstate_idx;
706 ret_kernel->bin = (const BIN_PTR *)(bin_start + (pcurr_header->kernel_start_pointer << 6));
707
708 pnext_header = (pcurr_header + 1);
709 if (pnext_header < pinvalid_entry) {
710 next_krnoffset = pnext_header->kernel_start_pointer << 6;
711 }
712 ret_kernel->size = next_krnoffset - (pcurr_header->kernel_start_pointer << 6);
713
714 return true;
715 }
716
717 static bool
718 gen8_avc_get_kernel_header_and_size(void *pvbinary,
719 int binary_size,
720 INTEL_GENERIC_ENC_OPERATION operation,
721 int krnstate_idx,
722 struct i965_kernel *ret_kernel)
723 {
724 typedef uint32_t BIN_PTR[4];
725
726 char *bin_start;
727 gen8_avc_encoder_kernel_header *pkh_table;
728 kernel_header *pcurr_header, *pinvalid_entry, *pnext_header;
729 int next_krnoffset;
730
731 if (!pvbinary || !ret_kernel)
732 return false;
733
734 bin_start = (char *)pvbinary;
735 pkh_table = (gen8_avc_encoder_kernel_header *)pvbinary;
736 pinvalid_entry = &(pkh_table->static_detection) + 1;
737 next_krnoffset = binary_size;
738
739 if (operation == INTEL_GENERIC_ENC_SCALING4X) {
740 pcurr_header = &pkh_table->ply_dscale_ply;
741 } else if (operation == INTEL_GENERIC_ENC_SCALING2X) {
742 pcurr_header = &pkh_table->ply_2xdscale_ply;
743 } else if (operation == INTEL_GENERIC_ENC_ME) {
744 pcurr_header = &pkh_table->me_p;
745 } else if (operation == INTEL_GENERIC_ENC_BRC) {
746 pcurr_header = &pkh_table->frame_brc_init;
747 } else if (operation == INTEL_GENERIC_ENC_MBENC) {
748 pcurr_header = &pkh_table->mbenc_quality_I;
749 } else if (operation == INTEL_GENERIC_ENC_SFD) {
750 pcurr_header = &pkh_table->static_detection;
751 } else {
752 return false;
753 }
754
755 pcurr_header += krnstate_idx;
756 ret_kernel->bin = (const BIN_PTR *)(bin_start + (pcurr_header->kernel_start_pointer << 6));
757
758 pnext_header = (pcurr_header + 1);
759 if (pnext_header < pinvalid_entry) {
760 next_krnoffset = pnext_header->kernel_start_pointer << 6;
761 }
762 ret_kernel->size = next_krnoffset - (pcurr_header->kernel_start_pointer << 6);
763
764 return true;
765 }
766
767 static bool
768 intel_avc_fei_get_kernel_header_and_size(
769 void *pvbinary,
770 int binary_size,
771 INTEL_GENERIC_ENC_OPERATION operation,
772 int krnstate_idx,
773 struct i965_kernel *ret_kernel)
774 {
775 typedef uint32_t BIN_PTR[4];
776
777 char *bin_start;
778 gen9_avc_fei_encoder_kernel_header *pkh_table;
779 kernel_header *pcurr_header, *pinvalid_entry, *pnext_header;
780 int next_krnoffset;
781
782 if (!pvbinary || !ret_kernel)
783 return false;
784
785 bin_start = (char *)pvbinary;
786 pkh_table = (gen9_avc_fei_encoder_kernel_header *)pvbinary;
787 pinvalid_entry = &(pkh_table->wp) + 1;
788 next_krnoffset = binary_size;
789
790 if (operation == INTEL_GENERIC_ENC_SCALING4X) {
791 pcurr_header = &pkh_table->ply_dscale_ply;
792 } else if (operation == INTEL_GENERIC_ENC_ME) {
793 pcurr_header = &pkh_table->me_p;
794 } else if (operation == INTEL_GENERIC_ENC_MBENC) {
795 pcurr_header = &pkh_table->mbenc_i;
796 } else if (operation == INTEL_GENERIC_ENC_PREPROC) {
797 pcurr_header = &pkh_table->preproc;
798 } else {
799 return false;
800 }
801
802 pcurr_header += krnstate_idx;
803 ret_kernel->bin = (const BIN_PTR *)(bin_start + (pcurr_header->kernel_start_pointer << 6));
804
805 pnext_header = (pcurr_header + 1);
806 if (pnext_header < pinvalid_entry) {
807 next_krnoffset = pnext_header->kernel_start_pointer << 6;
808 }
809 ret_kernel->size = next_krnoffset - (pcurr_header->kernel_start_pointer << 6);
810
811 return true;
812 }
813
814 static void
815 gen9_free_surfaces_avc(void **data)
816 {
817 struct gen9_surface_avc *avc_surface;
818
819 if (!data || !*data)
820 return;
821
822 avc_surface = *data;
823
824 if (avc_surface->scaled_4x_surface_obj) {
825 i965_DestroySurfaces(avc_surface->ctx, &avc_surface->scaled_4x_surface_id, 1);
826 avc_surface->scaled_4x_surface_id = VA_INVALID_SURFACE;
827 avc_surface->scaled_4x_surface_obj = NULL;
828 }
829
830 if (avc_surface->scaled_16x_surface_obj) {
831 i965_DestroySurfaces(avc_surface->ctx, &avc_surface->scaled_16x_surface_id, 1);
832 avc_surface->scaled_16x_surface_id = VA_INVALID_SURFACE;
833 avc_surface->scaled_16x_surface_obj = NULL;
834 }
835
836 if (avc_surface->scaled_32x_surface_obj) {
837 i965_DestroySurfaces(avc_surface->ctx, &avc_surface->scaled_32x_surface_id, 1);
838 avc_surface->scaled_32x_surface_id = VA_INVALID_SURFACE;
839 avc_surface->scaled_32x_surface_obj = NULL;
840 }
841
842 i965_free_gpe_resource(&avc_surface->res_mb_code_surface);
843 i965_free_gpe_resource(&avc_surface->res_mv_data_surface);
844 i965_free_gpe_resource(&avc_surface->res_ref_pic_select_surface);
845
846 /* FEI specific resources */
847 /* since the driver previously taken an extra reference to the drm_bo
848 * in case the buffers were supplied by middleware, there shouldn't
849 * be any memory handling issue */
850 i965_free_gpe_resource(&avc_surface->res_fei_mb_cntrl_surface);
851 i965_free_gpe_resource(&avc_surface->res_fei_mv_predictor_surface);
852 i965_free_gpe_resource(&avc_surface->res_fei_vme_distortion_surface);
853 i965_free_gpe_resource(&avc_surface->res_fei_mb_qp_surface);
854
855 dri_bo_unreference(avc_surface->dmv_top);
856 avc_surface->dmv_top = NULL;
857 dri_bo_unreference(avc_surface->dmv_bottom);
858 avc_surface->dmv_bottom = NULL;
859
860 free(avc_surface);
861
862 *data = NULL;
863
864 return;
865 }
866
867 static VAStatus
868 gen9_avc_init_check_surfaces(VADriverContextP ctx,
869 struct object_surface *obj_surface,
870 struct intel_encoder_context *encoder_context,
871 struct avc_surface_param *surface_param)
872 {
873 struct i965_driver_data *i965 = i965_driver_data(ctx);
874 struct encoder_vme_mfc_context * vme_context = (struct encoder_vme_mfc_context *)encoder_context->vme_context;
875 struct avc_enc_state * avc_state = (struct avc_enc_state *)vme_context->private_enc_state;
876 struct generic_enc_codec_state * generic_state = (struct generic_enc_codec_state *)vme_context->generic_enc_state;
877
878 struct gen9_surface_avc *avc_surface;
879 int downscaled_width_4x, downscaled_height_4x;
880 int downscaled_width_16x, downscaled_height_16x;
881 int downscaled_width_32x, downscaled_height_32x;
882 int size = 0;
883 unsigned int frame_width_in_mbs = ALIGN(surface_param->frame_width, 16) / 16;
884 unsigned int frame_height_in_mbs = ALIGN(surface_param->frame_height, 16) / 16;
885 unsigned int frame_mb_nums = frame_width_in_mbs * frame_height_in_mbs;
886 int allocate_flag = 1;
887 int width, height;
888
889 if (!obj_surface || !obj_surface->bo)
890 return VA_STATUS_ERROR_INVALID_SURFACE;
891
892 if (obj_surface->private_data) {
893 return VA_STATUS_SUCCESS;
894 }
895
896 avc_surface = calloc(1, sizeof(struct gen9_surface_avc));
897
898 if (!avc_surface)
899 return VA_STATUS_ERROR_ALLOCATION_FAILED;
900
901 avc_surface->ctx = ctx;
902 obj_surface->private_data = avc_surface;
903 obj_surface->free_private_data = gen9_free_surfaces_avc;
904
905 downscaled_width_4x = generic_state->frame_width_4x;
906 downscaled_height_4x = generic_state->frame_height_4x;
907
908 i965_CreateSurfaces(ctx,
909 downscaled_width_4x,
910 downscaled_height_4x,
911 VA_RT_FORMAT_YUV420,
912 1,
913 &avc_surface->scaled_4x_surface_id);
914
915 avc_surface->scaled_4x_surface_obj = SURFACE(avc_surface->scaled_4x_surface_id);
916
917 if (!avc_surface->scaled_4x_surface_obj) {
918 return VA_STATUS_ERROR_ALLOCATION_FAILED;
919 }
920
921 i965_check_alloc_surface_bo(ctx, avc_surface->scaled_4x_surface_obj, 1,
922 VA_FOURCC('N', 'V', '1', '2'), SUBSAMPLE_YUV420);
923
924 downscaled_width_16x = generic_state->frame_width_16x;
925 downscaled_height_16x = generic_state->frame_height_16x;
926 i965_CreateSurfaces(ctx,
927 downscaled_width_16x,
928 downscaled_height_16x,
929 VA_RT_FORMAT_YUV420,
930 1,
931 &avc_surface->scaled_16x_surface_id);
932 avc_surface->scaled_16x_surface_obj = SURFACE(avc_surface->scaled_16x_surface_id);
933
934 if (!avc_surface->scaled_16x_surface_obj) {
935 return VA_STATUS_ERROR_ALLOCATION_FAILED;
936 }
937
938 i965_check_alloc_surface_bo(ctx, avc_surface->scaled_16x_surface_obj, 1,
939 VA_FOURCC('N', 'V', '1', '2'), SUBSAMPLE_YUV420);
940
941 if (generic_state->b32xme_supported ||
942 generic_state->b32xme_enabled) {
943 downscaled_width_32x = generic_state->frame_width_32x;
944 downscaled_height_32x = generic_state->frame_height_32x;
945 i965_CreateSurfaces(ctx,
946 downscaled_width_32x,
947 downscaled_height_32x,
948 VA_RT_FORMAT_YUV420,
949 1,
950 &avc_surface->scaled_32x_surface_id);
951 avc_surface->scaled_32x_surface_obj = SURFACE(avc_surface->scaled_32x_surface_id);
952
953 if (!avc_surface->scaled_32x_surface_obj) {
954 return VA_STATUS_ERROR_ALLOCATION_FAILED;
955 }
956
957 i965_check_alloc_surface_bo(ctx, avc_surface->scaled_32x_surface_obj, 1,
958 VA_FOURCC('N', 'V', '1', '2'), SUBSAMPLE_YUV420);
959 }
960
961 /*mb code and mv data for each frame*/
962 if (!encoder_context->fei_enabled) {
963 size = frame_mb_nums * 16 * 4;
964 allocate_flag = i965_allocate_gpe_resource(i965->intel.bufmgr,
965 &avc_surface->res_mb_code_surface,
966 ALIGN(size, 0x1000),
967 "mb code buffer");
968 if (!allocate_flag)
969 goto failed_allocation;
970
971 size = frame_mb_nums * 32 * 4;
972 allocate_flag = i965_allocate_gpe_resource(i965->intel.bufmgr,
973 &avc_surface->res_mv_data_surface,
974 ALIGN(size, 0x1000),
975 "mv data buffer");
976 if (!allocate_flag)
977 goto failed_allocation;
978 }
979
980 /* ref pic list*/
981 if (avc_state->ref_pic_select_list_supported) {
982 width = ALIGN(frame_width_in_mbs * 8, 64);
983 height = frame_height_in_mbs ;
984 allocate_flag = i965_gpe_allocate_2d_resource(i965->intel.bufmgr,
985 &avc_surface->res_ref_pic_select_surface,
986 width, height,
987 width,
988 "Ref pic select list buffer");
989 if (!allocate_flag)
990 goto failed_allocation;
991 }
992
993 /*direct mv*/
994 avc_surface->dmv_top =
995 dri_bo_alloc(i965->intel.bufmgr,
996 "direct mv top Buffer",
997 68 * frame_mb_nums,
998 64);
999 avc_surface->dmv_bottom =
1000 dri_bo_alloc(i965->intel.bufmgr,
1001 "direct mv bottom Buffer",
1002 68 * frame_mb_nums,
1003 64);
1004 assert(avc_surface->dmv_top);
1005 assert(avc_surface->dmv_bottom);
1006
1007 return VA_STATUS_SUCCESS;
1008
1009 failed_allocation:
1010 return VA_STATUS_ERROR_ALLOCATION_FAILED;
1011 }
1012
1013 static void
1014 gen9_avc_generate_slice_map(VADriverContextP ctx,
1015 struct encode_state *encode_state,
1016 struct intel_encoder_context *encoder_context)
1017 {
1018 struct encoder_vme_mfc_context * vme_context = (struct encoder_vme_mfc_context *)encoder_context->vme_context;
1019 struct i965_avc_encoder_context * avc_ctx = (struct i965_avc_encoder_context *)vme_context->private_enc_ctx;
1020 struct generic_enc_codec_state * generic_state = (struct generic_enc_codec_state *)vme_context->generic_enc_state;
1021 struct avc_enc_state * avc_state = (struct avc_enc_state *)vme_context->private_enc_state;
1022
1023 struct i965_gpe_resource *gpe_resource = NULL;
1024 VAEncSliceParameterBufferH264 * slice_param = NULL;
1025 unsigned int * data = NULL;
1026 unsigned int * data_row = NULL;
1027 int i, j, count = 0;
1028 unsigned int pitch = ALIGN((generic_state->frame_width_in_mbs + 1) * 4, 64) / 4;
1029
1030 if (!avc_state->arbitrary_num_mbs_in_slice)
1031 return;
1032
1033 gpe_resource = &(avc_ctx->res_mbenc_slice_map_surface);
1034 assert(gpe_resource);
1035
1036 i965_zero_gpe_resource(gpe_resource);
1037
1038 data_row = (unsigned int *)i965_map_gpe_resource(gpe_resource);
1039 assert(data_row);
1040
1041 data = data_row;
1042 for (i = 0; i < avc_state->slice_num; i++) {
1043 slice_param = avc_state->slice_param[i];
1044 for (j = 0; j < slice_param->num_macroblocks; j++) {
1045 *data++ = i;
1046 if ((count > 0) && (count % generic_state->frame_width_in_mbs == 0)) {
1047 data_row += pitch;
1048 data = data_row;
1049 *data++ = i;
1050 }
1051 count++;
1052 }
1053 }
1054 *data++ = 0xFFFFFFFF;
1055
1056 i965_unmap_gpe_resource(gpe_resource);
1057 }
1058
1059 static VAStatus
1060 gen9_avc_allocate_resources(VADriverContextP ctx,
1061 struct encode_state *encode_state,
1062 struct intel_encoder_context *encoder_context)
1063 {
1064 struct i965_driver_data *i965 = i965_driver_data(ctx);
1065 struct encoder_vme_mfc_context * vme_context = (struct encoder_vme_mfc_context *)encoder_context->vme_context;
1066 struct i965_avc_encoder_context * avc_ctx = (struct i965_avc_encoder_context *)vme_context->private_enc_ctx;
1067 struct generic_enc_codec_state * generic_state = (struct generic_enc_codec_state *)vme_context->generic_enc_state;
1068 struct avc_enc_state * avc_state = (struct avc_enc_state *)vme_context->private_enc_state;
1069 unsigned int size = 0;
1070 unsigned int width = 0;
1071 unsigned int height = 0;
1072 unsigned char * data = NULL;
1073 int allocate_flag = 1;
1074 int i = 0;
1075
1076 /*all the surface/buffer are allocated here*/
1077
1078 /*second level batch buffer for image state write when cqp etc*/
1079 i965_free_gpe_resource(&avc_ctx->res_image_state_batch_buffer_2nd_level);
1080 size = INTEL_AVC_IMAGE_STATE_CMD_SIZE ;
1081 allocate_flag = i965_allocate_gpe_resource(i965->intel.bufmgr,
1082 &avc_ctx->res_image_state_batch_buffer_2nd_level,
1083 ALIGN(size, 0x1000),
1084 "second levle batch (image state write) buffer");
1085 if (!allocate_flag)
1086 goto failed_allocation;
1087
1088 /* scaling related surface */
1089 if (avc_state->mb_status_supported) {
1090 i965_free_gpe_resource(&avc_ctx->res_mb_status_buffer);
1091 size = (generic_state->frame_width_in_mbs * generic_state->frame_height_in_mbs * 16 * 4 + 1023) & ~0x3ff;
1092 allocate_flag = i965_allocate_gpe_resource(i965->intel.bufmgr,
1093 &avc_ctx->res_mb_status_buffer,
1094 ALIGN(size, 0x1000),
1095 "MB statistics output buffer");
1096 if (!allocate_flag)
1097 goto failed_allocation;
1098 i965_zero_gpe_resource(&avc_ctx->res_mb_status_buffer);
1099 }
1100
1101 if (avc_state->flatness_check_supported) {
1102 width = generic_state->frame_width_in_mbs * 4;
1103 height = generic_state->frame_height_in_mbs * 4;
1104 i965_free_gpe_resource(&avc_ctx->res_flatness_check_surface);
1105 allocate_flag = i965_gpe_allocate_2d_resource(i965->intel.bufmgr,
1106 &avc_ctx->res_flatness_check_surface,
1107 width, height,
1108 ALIGN(width, 64),
1109 "Flatness check buffer");
1110 if (!allocate_flag)
1111 goto failed_allocation;
1112 }
1113 /* me related surface */
1114 width = generic_state->downscaled_width_4x_in_mb * 8;
1115 height = generic_state->downscaled_height_4x_in_mb * 4 * 10;
1116 i965_free_gpe_resource(&avc_ctx->s4x_memv_distortion_buffer);
1117 allocate_flag = i965_gpe_allocate_2d_resource(i965->intel.bufmgr,
1118 &avc_ctx->s4x_memv_distortion_buffer,
1119 width, height,
1120 ALIGN(width, 64),
1121 "4x MEMV distortion buffer");
1122 if (!allocate_flag)
1123 goto failed_allocation;
1124 i965_zero_gpe_resource(&avc_ctx->s4x_memv_distortion_buffer);
1125
1126 width = (generic_state->downscaled_width_4x_in_mb + 7) / 8 * 64;
1127 height = (generic_state->downscaled_height_4x_in_mb + 1) / 2 * 8;
1128 i965_free_gpe_resource(&avc_ctx->s4x_memv_min_distortion_brc_buffer);
1129 allocate_flag = i965_gpe_allocate_2d_resource(i965->intel.bufmgr,
1130 &avc_ctx->s4x_memv_min_distortion_brc_buffer,
1131 width, height,
1132 width,
1133 "4x MEMV min distortion brc buffer");
1134 if (!allocate_flag)
1135 goto failed_allocation;
1136 i965_zero_gpe_resource(&avc_ctx->s4x_memv_min_distortion_brc_buffer);
1137
1138
1139 width = ALIGN(generic_state->downscaled_width_4x_in_mb * 32, 64);
1140 height = generic_state->downscaled_height_4x_in_mb * 4 * 2 * 10;
1141 i965_free_gpe_resource(&avc_ctx->s4x_memv_data_buffer);
1142 allocate_flag = i965_gpe_allocate_2d_resource(i965->intel.bufmgr,
1143 &avc_ctx->s4x_memv_data_buffer,
1144 width, height,
1145 width,
1146 "4x MEMV data buffer");
1147 if (!allocate_flag)
1148 goto failed_allocation;
1149 i965_zero_gpe_resource(&avc_ctx->s4x_memv_data_buffer);
1150
1151
1152 width = ALIGN(generic_state->downscaled_width_16x_in_mb * 32, 64);
1153 height = generic_state->downscaled_height_16x_in_mb * 4 * 2 * 10 ;
1154 i965_free_gpe_resource(&avc_ctx->s16x_memv_data_buffer);
1155 allocate_flag = i965_gpe_allocate_2d_resource(i965->intel.bufmgr,
1156 &avc_ctx->s16x_memv_data_buffer,
1157 width, height,
1158 width,
1159 "16x MEMV data buffer");
1160 if (!allocate_flag)
1161 goto failed_allocation;
1162 i965_zero_gpe_resource(&avc_ctx->s16x_memv_data_buffer);
1163
1164
1165 width = ALIGN(generic_state->downscaled_width_32x_in_mb * 32, 64);
1166 height = generic_state->downscaled_height_32x_in_mb * 4 * 2 * 10 ;
1167 i965_free_gpe_resource(&avc_ctx->s32x_memv_data_buffer);
1168 allocate_flag = i965_gpe_allocate_2d_resource(i965->intel.bufmgr,
1169 &avc_ctx->s32x_memv_data_buffer,
1170 width, height,
1171 width,
1172 "32x MEMV data buffer");
1173 if (!allocate_flag)
1174 goto failed_allocation;
1175 i965_zero_gpe_resource(&avc_ctx->s32x_memv_data_buffer);
1176
1177
1178 if (!generic_state->brc_allocated) {
1179 /*brc related surface */
1180 i965_free_gpe_resource(&avc_ctx->res_brc_history_buffer);
1181 size = 864;
1182 allocate_flag = i965_allocate_gpe_resource(i965->intel.bufmgr,
1183 &avc_ctx->res_brc_history_buffer,
1184 ALIGN(size, 0x1000),
1185 "brc history buffer");
1186 if (!allocate_flag)
1187 goto failed_allocation;
1188
1189 i965_free_gpe_resource(&avc_ctx->res_brc_pre_pak_statistics_output_buffer);
1190 size = 64;//44
1191 allocate_flag = i965_allocate_gpe_resource(i965->intel.bufmgr,
1192 &avc_ctx->res_brc_pre_pak_statistics_output_buffer,
1193 ALIGN(size, 0x1000),
1194 "brc pak statistic buffer");
1195 if (!allocate_flag)
1196 goto failed_allocation;
1197
1198 i965_free_gpe_resource(&avc_ctx->res_brc_image_state_read_buffer);
1199 size = INTEL_AVC_IMAGE_STATE_CMD_SIZE * 7;
1200 allocate_flag = i965_allocate_gpe_resource(i965->intel.bufmgr,
1201 &avc_ctx->res_brc_image_state_read_buffer,
1202 ALIGN(size, 0x1000),
1203 "brc image state read buffer");
1204 if (!allocate_flag)
1205 goto failed_allocation;
1206
1207 i965_free_gpe_resource(&avc_ctx->res_brc_image_state_write_buffer);
1208 size = INTEL_AVC_IMAGE_STATE_CMD_SIZE * 7;
1209 allocate_flag = i965_allocate_gpe_resource(i965->intel.bufmgr,
1210 &avc_ctx->res_brc_image_state_write_buffer,
1211 ALIGN(size, 0x1000),
1212 "brc image state write buffer");
1213 if (!allocate_flag)
1214 goto failed_allocation;
1215
1216 width = ALIGN(avc_state->brc_const_data_surface_width, 64);
1217 height = avc_state->brc_const_data_surface_height;
1218 i965_free_gpe_resource(&avc_ctx->res_brc_const_data_buffer);
1219 allocate_flag = i965_gpe_allocate_2d_resource(i965->intel.bufmgr,
1220 &avc_ctx->res_brc_const_data_buffer,
1221 width, height,
1222 width,
1223 "brc const data buffer");
1224 if (!allocate_flag)
1225 goto failed_allocation;
1226 i965_zero_gpe_resource(&avc_ctx->res_brc_const_data_buffer);
1227
1228 if (generic_state->brc_distortion_buffer_supported) {
1229 width = ALIGN(generic_state->downscaled_width_4x_in_mb * 8, 64);
1230 height = ALIGN(generic_state->downscaled_height_4x_in_mb * 4, 8);
1231 width = (generic_state->downscaled_width_4x_in_mb + 7) / 8 * 64;
1232 height = (generic_state->downscaled_height_4x_in_mb + 1) / 2 * 8;
1233 i965_free_gpe_resource(&avc_ctx->res_brc_dist_data_surface);
1234 allocate_flag = i965_gpe_allocate_2d_resource(i965->intel.bufmgr,
1235 &avc_ctx->res_brc_dist_data_surface,
1236 width, height,
1237 width,
1238 "brc dist data buffer");
1239 if (!allocate_flag)
1240 goto failed_allocation;
1241 i965_zero_gpe_resource(&avc_ctx->res_brc_dist_data_surface);
1242 }
1243
1244 if (generic_state->brc_roi_enable) {
1245 width = ALIGN(generic_state->downscaled_width_4x_in_mb * 16, 64);
1246 height = ALIGN(generic_state->downscaled_height_4x_in_mb * 4, 8);
1247 i965_free_gpe_resource(&avc_ctx->res_mbbrc_roi_surface);
1248 allocate_flag = i965_gpe_allocate_2d_resource(i965->intel.bufmgr,
1249 &avc_ctx->res_mbbrc_roi_surface,
1250 width, height,
1251 width,
1252 "mbbrc roi buffer");
1253 if (!allocate_flag)
1254 goto failed_allocation;
1255 i965_zero_gpe_resource(&avc_ctx->res_mbbrc_roi_surface);
1256 }
1257
1258 /*mb qp in mb brc*/
1259 width = ALIGN(generic_state->downscaled_width_4x_in_mb * 4, 64);
1260 height = ALIGN(generic_state->downscaled_height_4x_in_mb * 4, 8);
1261 i965_free_gpe_resource(&avc_ctx->res_mbbrc_mb_qp_data_surface);
1262 allocate_flag = i965_gpe_allocate_2d_resource(i965->intel.bufmgr,
1263 &avc_ctx->res_mbbrc_mb_qp_data_surface,
1264 width, height,
1265 width,
1266 "mbbrc mb qp buffer");
1267 if (!allocate_flag)
1268 goto failed_allocation;
1269
1270 i965_free_gpe_resource(&avc_ctx->res_mbbrc_const_data_buffer);
1271 size = 16 * AVC_QP_MAX * 4;
1272 allocate_flag = i965_allocate_gpe_resource(i965->intel.bufmgr,
1273 &avc_ctx->res_mbbrc_const_data_buffer,
1274 ALIGN(size, 0x1000),
1275 "mbbrc const data buffer");
1276 if (!allocate_flag)
1277 goto failed_allocation;
1278
1279 if (avc_state->decouple_mbenc_curbe_from_brc_enable) {
1280 i965_free_gpe_resource(&avc_ctx->res_mbenc_brc_buffer);
1281 size = avc_state->mbenc_brc_buffer_size;
1282 allocate_flag = i965_allocate_gpe_resource(i965->intel.bufmgr,
1283 &avc_ctx->res_mbenc_brc_buffer,
1284 ALIGN(size, 0x1000),
1285 "mbenc brc buffer");
1286 if (!allocate_flag)
1287 goto failed_allocation;
1288 i965_zero_gpe_resource(&avc_ctx->res_mbenc_brc_buffer);
1289 }
1290 generic_state->brc_allocated = 1;
1291 }
1292
1293 /*mb qp external*/
1294 if (avc_state->mb_qp_data_enable) {
1295 width = ALIGN(generic_state->downscaled_width_4x_in_mb * 4, 64);
1296 height = ALIGN(generic_state->downscaled_height_4x_in_mb * 4, 8);
1297 i965_free_gpe_resource(&avc_ctx->res_mb_qp_data_surface);
1298 allocate_flag = i965_gpe_allocate_2d_resource(i965->intel.bufmgr,
1299 &avc_ctx->res_mb_qp_data_surface,
1300 width, height,
1301 width,
1302 "external mb qp buffer");
1303 if (!allocate_flag)
1304 goto failed_allocation;
1305 }
1306
1307 /* mbenc related surface. it share most of surface with other kernels */
1308 if (avc_state->arbitrary_num_mbs_in_slice) {
1309 width = ALIGN((generic_state->frame_width_in_mbs + 1) * 4, 64);
1310 height = generic_state->frame_height_in_mbs ;
1311 i965_free_gpe_resource(&avc_ctx->res_mbenc_slice_map_surface);
1312 allocate_flag = i965_gpe_allocate_2d_resource(i965->intel.bufmgr,
1313 &avc_ctx->res_mbenc_slice_map_surface,
1314 width, height,
1315 width,
1316 "slice map buffer");
1317 if (!allocate_flag)
1318 goto failed_allocation;
1319 i965_zero_gpe_resource(&avc_ctx->res_mbenc_slice_map_surface);
1320
1321 /*generate slice map,default one slice per frame.*/
1322 }
1323
1324 /* sfd related surface */
1325 if (avc_state->sfd_enable) {
1326 i965_free_gpe_resource(&avc_ctx->res_sfd_output_buffer);
1327 size = 128;
1328 allocate_flag = i965_allocate_gpe_resource(i965->intel.bufmgr,
1329 &avc_ctx->res_sfd_output_buffer,
1330 size,
1331 "sfd output buffer");
1332 if (!allocate_flag)
1333 goto failed_allocation;
1334 i965_zero_gpe_resource(&avc_ctx->res_sfd_output_buffer);
1335
1336 i965_free_gpe_resource(&avc_ctx->res_sfd_cost_table_p_frame_buffer);
1337 size = ALIGN(52, 64);
1338 allocate_flag = i965_allocate_gpe_resource(i965->intel.bufmgr,
1339 &avc_ctx->res_sfd_cost_table_p_frame_buffer,
1340 size,
1341 "sfd P frame cost table buffer");
1342 if (!allocate_flag)
1343 goto failed_allocation;
1344 data = i965_map_gpe_resource(&(avc_ctx->res_sfd_cost_table_p_frame_buffer));
1345 assert(data);
1346 memcpy(data, gen9_avc_sfd_cost_table_p_frame, sizeof(unsigned char) * 52);
1347 i965_unmap_gpe_resource(&(avc_ctx->res_sfd_cost_table_p_frame_buffer));
1348
1349 i965_free_gpe_resource(&avc_ctx->res_sfd_cost_table_b_frame_buffer);
1350 size = ALIGN(52, 64);
1351 allocate_flag = i965_allocate_gpe_resource(i965->intel.bufmgr,
1352 &avc_ctx->res_sfd_cost_table_b_frame_buffer,
1353 size,
1354 "sfd B frame cost table buffer");
1355 if (!allocate_flag)
1356 goto failed_allocation;
1357 data = i965_map_gpe_resource(&(avc_ctx->res_sfd_cost_table_b_frame_buffer));
1358 assert(data);
1359 memcpy(data, gen9_avc_sfd_cost_table_b_frame, sizeof(unsigned char) * 52);
1360 i965_unmap_gpe_resource(&(avc_ctx->res_sfd_cost_table_b_frame_buffer));
1361 }
1362
1363 /* wp related surfaces */
1364 if (avc_state->weighted_prediction_supported) {
1365 for (i = 0; i < 2 ; i++) {
1366 if (avc_ctx->wp_output_pic_select_surface_obj[i]) {
1367 continue;
1368 }
1369
1370 width = generic_state->frame_width_in_pixel;
1371 height = generic_state->frame_height_in_pixel ;
1372 i965_CreateSurfaces(ctx,
1373 width,
1374 height,
1375 VA_RT_FORMAT_YUV420,
1376 1,
1377 &avc_ctx->wp_output_pic_select_surface_id[i]);
1378 avc_ctx->wp_output_pic_select_surface_obj[i] = SURFACE(avc_ctx->wp_output_pic_select_surface_id[i]);
1379
1380 if (!avc_ctx->wp_output_pic_select_surface_obj[i]) {
1381 goto failed_allocation;
1382 }
1383
1384 i965_check_alloc_surface_bo(ctx, avc_ctx->wp_output_pic_select_surface_obj[i], 1,
1385 VA_FOURCC('N', 'V', '1', '2'), SUBSAMPLE_YUV420);
1386 }
1387 i965_free_gpe_resource(&avc_ctx->res_wp_output_pic_select_surface_list[0]);
1388 i965_object_surface_to_2d_gpe_resource_with_align(&avc_ctx->res_wp_output_pic_select_surface_list[0], avc_ctx->wp_output_pic_select_surface_obj[0], GPE_RESOURCE_ALIGNMENT);
1389 i965_free_gpe_resource(&avc_ctx->res_wp_output_pic_select_surface_list[1]);
1390 i965_object_surface_to_2d_gpe_resource_with_align(&avc_ctx->res_wp_output_pic_select_surface_list[1], avc_ctx->wp_output_pic_select_surface_obj[1], GPE_RESOURCE_ALIGNMENT);
1391 }
1392
1393 /* other */
1394
1395 i965_free_gpe_resource(&avc_ctx->res_mad_data_buffer);
1396 size = 4 * 1;
1397 allocate_flag = i965_allocate_gpe_resource(i965->intel.bufmgr,
1398 &avc_ctx->res_mad_data_buffer,
1399 ALIGN(size, 0x1000),
1400 "MAD data buffer");
1401 if (!allocate_flag)
1402 goto failed_allocation;
1403
1404 return VA_STATUS_SUCCESS;
1405
1406 failed_allocation:
1407 return VA_STATUS_ERROR_ALLOCATION_FAILED;
1408 }
1409
1410 static void
1411 gen9_avc_free_resources(struct encoder_vme_mfc_context * vme_context)
1412 {
1413 if (!vme_context)
1414 return;
1415
1416 struct i965_avc_encoder_context * avc_ctx = (struct i965_avc_encoder_context *)vme_context->private_enc_ctx;
1417 VADriverContextP ctx = avc_ctx->ctx;
1418 int i = 0;
1419
1420 /* free all the surface/buffer here*/
1421 i965_free_gpe_resource(&avc_ctx->res_image_state_batch_buffer_2nd_level);
1422 i965_free_gpe_resource(&avc_ctx->res_mb_status_buffer);
1423 i965_free_gpe_resource(&avc_ctx->res_flatness_check_surface);
1424 i965_free_gpe_resource(&avc_ctx->s4x_memv_distortion_buffer);
1425 i965_free_gpe_resource(&avc_ctx->s4x_memv_min_distortion_brc_buffer);
1426 i965_free_gpe_resource(&avc_ctx->s4x_memv_data_buffer);
1427 i965_free_gpe_resource(&avc_ctx->s16x_memv_data_buffer);
1428 i965_free_gpe_resource(&avc_ctx->s32x_memv_data_buffer);
1429 i965_free_gpe_resource(&avc_ctx->res_brc_history_buffer);
1430 i965_free_gpe_resource(&avc_ctx->res_brc_pre_pak_statistics_output_buffer);
1431 i965_free_gpe_resource(&avc_ctx->res_brc_image_state_read_buffer);
1432 i965_free_gpe_resource(&avc_ctx->res_brc_image_state_write_buffer);
1433 i965_free_gpe_resource(&avc_ctx->res_brc_const_data_buffer);
1434 i965_free_gpe_resource(&avc_ctx->res_brc_dist_data_surface);
1435 i965_free_gpe_resource(&avc_ctx->res_mbbrc_roi_surface);
1436 i965_free_gpe_resource(&avc_ctx->res_mbbrc_mb_qp_data_surface);
1437 i965_free_gpe_resource(&avc_ctx->res_mbenc_brc_buffer);
1438 i965_free_gpe_resource(&avc_ctx->res_mb_qp_data_surface);
1439 i965_free_gpe_resource(&avc_ctx->res_mbbrc_const_data_buffer);
1440 i965_free_gpe_resource(&avc_ctx->res_mbenc_slice_map_surface);
1441 i965_free_gpe_resource(&avc_ctx->res_sfd_output_buffer);
1442 i965_free_gpe_resource(&avc_ctx->res_sfd_cost_table_p_frame_buffer);
1443 i965_free_gpe_resource(&avc_ctx->res_sfd_cost_table_b_frame_buffer);
1444 i965_free_gpe_resource(&avc_ctx->res_wp_output_pic_select_surface_list[0]);
1445 i965_free_gpe_resource(&avc_ctx->res_wp_output_pic_select_surface_list[1]);
1446 i965_free_gpe_resource(&avc_ctx->res_mad_data_buffer);
1447
1448 for (i = 0; i < 2 ; i++) {
1449 if (avc_ctx->wp_output_pic_select_surface_obj[i]) {
1450 i965_DestroySurfaces(ctx, &avc_ctx->wp_output_pic_select_surface_id[i], 1);
1451 avc_ctx->wp_output_pic_select_surface_id[i] = VA_INVALID_SURFACE;
1452 avc_ctx->wp_output_pic_select_surface_obj[i] = NULL;
1453 }
1454 }
1455
1456 /* free preenc resources */
1457 i965_free_gpe_resource(&avc_ctx->preproc_mv_predictor_buffer);
1458 i965_free_gpe_resource(&avc_ctx->preproc_mb_qp_buffer);
1459 i965_free_gpe_resource(&avc_ctx->preproc_mv_data_out_buffer);
1460 i965_free_gpe_resource(&avc_ctx->preproc_stat_data_out_buffer);
1461
1462 i965_free_gpe_resource(&avc_ctx->preenc_past_ref_stat_data_out_buffer);
1463 i965_free_gpe_resource(&avc_ctx->preenc_future_ref_stat_data_out_buffer);
1464
1465 i965_DestroySurfaces(ctx, &avc_ctx->preenc_scaled_4x_surface_id, 1);
1466 avc_ctx->preenc_scaled_4x_surface_id = VA_INVALID_SURFACE;
1467 avc_ctx->preenc_scaled_4x_surface_obj = NULL;
1468
1469 i965_DestroySurfaces(ctx, &avc_ctx->preenc_past_ref_scaled_4x_surface_id, 1);
1470 avc_ctx->preenc_past_ref_scaled_4x_surface_id = VA_INVALID_SURFACE;
1471 avc_ctx->preenc_past_ref_scaled_4x_surface_obj = NULL;
1472
1473 i965_DestroySurfaces(ctx, &avc_ctx->preenc_future_ref_scaled_4x_surface_id, 1);
1474 avc_ctx->preenc_future_ref_scaled_4x_surface_id = VA_INVALID_SURFACE;
1475 avc_ctx->preenc_future_ref_scaled_4x_surface_obj = NULL;
1476 }
1477
1478 static void
1479 gen9_avc_run_kernel_media_object(VADriverContextP ctx,
1480 struct intel_encoder_context *encoder_context,
1481 struct i965_gpe_context *gpe_context,
1482 int media_function,
1483 struct gpe_media_object_parameter *param)
1484 {
1485 struct i965_driver_data *i965 = i965_driver_data(ctx);
1486 struct i965_gpe_table *gpe = &i965->gpe_table;
1487 struct encoder_vme_mfc_context * vme_context = (struct encoder_vme_mfc_context *)encoder_context->vme_context;
1488 struct i965_avc_encoder_context * avc_ctx = (struct i965_avc_encoder_context *)vme_context->private_enc_ctx;
1489
1490 struct intel_batchbuffer *batch = encoder_context->base.batch;
1491 struct encoder_status_buffer_internal *status_buffer;
1492 struct gpe_mi_store_data_imm_parameter mi_store_data_imm;
1493
1494 if (!batch)
1495 return;
1496
1497 intel_batchbuffer_start_atomic(batch, 0x1000);
1498 intel_batchbuffer_emit_mi_flush(batch);
1499
1500 status_buffer = &(avc_ctx->status_buffer);
1501 memset(&mi_store_data_imm, 0, sizeof(mi_store_data_imm));
1502 mi_store_data_imm.bo = status_buffer->bo;
1503 mi_store_data_imm.offset = status_buffer->media_index_offset;
1504 mi_store_data_imm.dw0 = media_function;
1505 gpe->mi_store_data_imm(ctx, batch, &mi_store_data_imm);
1506
1507 gpe->pipeline_setup(ctx, gpe_context, batch);
1508 gpe->media_object(ctx, gpe_context, batch, param);
1509 gpe->media_state_flush(ctx, gpe_context, batch);
1510
1511 gpe->pipeline_end(ctx, gpe_context, batch);
1512
1513 intel_batchbuffer_end_atomic(batch);
1514
1515 intel_batchbuffer_flush(batch);
1516 }
1517
1518 static void
1519 gen9_avc_run_kernel_media_object_walker(VADriverContextP ctx,
1520 struct intel_encoder_context *encoder_context,
1521 struct i965_gpe_context *gpe_context,
1522 int media_function,
1523 struct gpe_media_object_walker_parameter *param)
1524 {
1525 struct i965_driver_data *i965 = i965_driver_data(ctx);
1526 struct i965_gpe_table *gpe = &i965->gpe_table;
1527 struct encoder_vme_mfc_context * vme_context = (struct encoder_vme_mfc_context *)encoder_context->vme_context;
1528 struct i965_avc_encoder_context * avc_ctx = (struct i965_avc_encoder_context *)vme_context->private_enc_ctx;
1529
1530 struct intel_batchbuffer *batch = encoder_context->base.batch;
1531 struct encoder_status_buffer_internal *status_buffer;
1532 struct gpe_mi_store_data_imm_parameter mi_store_data_imm;
1533
1534 if (!batch)
1535 return;
1536
1537 intel_batchbuffer_start_atomic(batch, 0x1000);
1538
1539 intel_batchbuffer_emit_mi_flush(batch);
1540
1541 status_buffer = &(avc_ctx->status_buffer);
1542 memset(&mi_store_data_imm, 0, sizeof(mi_store_data_imm));
1543 mi_store_data_imm.bo = status_buffer->bo;
1544 mi_store_data_imm.offset = status_buffer->media_index_offset;
1545 mi_store_data_imm.dw0 = media_function;
1546 gpe->mi_store_data_imm(ctx, batch, &mi_store_data_imm);
1547
1548 gpe->pipeline_setup(ctx, gpe_context, batch);
1549 gpe->media_object_walker(ctx, gpe_context, batch, param);
1550 gpe->media_state_flush(ctx, gpe_context, batch);
1551
1552 gpe->pipeline_end(ctx, gpe_context, batch);
1553
1554 intel_batchbuffer_end_atomic(batch);
1555
1556 intel_batchbuffer_flush(batch);
1557 }
1558
1559 static void
1560 gen9_init_gpe_context_avc(VADriverContextP ctx,
1561 struct i965_gpe_context *gpe_context,
1562 struct encoder_kernel_parameter *kernel_param)
1563 {
1564 struct i965_driver_data *i965 = i965_driver_data(ctx);
1565
1566 gpe_context->curbe.length = kernel_param->curbe_size; // in bytes
1567
1568 gpe_context->sampler.entry_size = 0;
1569 gpe_context->sampler.max_entries = 0;
1570
1571 if (kernel_param->sampler_size) {
1572 gpe_context->sampler.entry_size = ALIGN(kernel_param->sampler_size, 64);
1573 gpe_context->sampler.max_entries = 1;
1574 }
1575
1576 gpe_context->idrt.entry_size = ALIGN(sizeof(struct gen8_interface_descriptor_data), 64); // 8 dws, 1 register
1577 gpe_context->idrt.max_entries = NUM_KERNELS_PER_GPE_CONTEXT;
1578
1579 gpe_context->surface_state_binding_table.max_entries = MAX_AVC_ENCODER_SURFACES;
1580 gpe_context->surface_state_binding_table.binding_table_offset = 0;
1581 gpe_context->surface_state_binding_table.surface_state_offset = ALIGN(MAX_AVC_ENCODER_SURFACES * 4, 64);
1582 gpe_context->surface_state_binding_table.length = ALIGN(MAX_AVC_ENCODER_SURFACES * 4, 64) + ALIGN(MAX_AVC_ENCODER_SURFACES * SURFACE_STATE_PADDED_SIZE_GEN9, 64);
1583
1584 if (i965->intel.eu_total > 0)
1585 gpe_context->vfe_state.max_num_threads = 6 * i965->intel.eu_total;
1586 else
1587 gpe_context->vfe_state.max_num_threads = 112; // 16 EU * 7 threads
1588
1589 gpe_context->vfe_state.curbe_allocation_size = MAX(1, ALIGN(gpe_context->curbe.length, 32) >> 5); // in registers
1590 gpe_context->vfe_state.urb_entry_size = MAX(1, ALIGN(kernel_param->inline_data_size, 32) >> 5); // in registers
1591 gpe_context->vfe_state.num_urb_entries = (MAX_URB_SIZE -
1592 gpe_context->vfe_state.curbe_allocation_size -
1593 ((gpe_context->idrt.entry_size >> 5) *
1594 gpe_context->idrt.max_entries)) / gpe_context->vfe_state.urb_entry_size;
1595 gpe_context->vfe_state.num_urb_entries = CLAMP(1, 127, gpe_context->vfe_state.num_urb_entries);
1596 gpe_context->vfe_state.gpgpu_mode = 0;
1597 }
1598
1599 static void
1600 gen9_init_vfe_scoreboard_avc(struct i965_gpe_context *gpe_context,
1601 struct encoder_scoreboard_parameter *scoreboard_param)
1602 {
1603 gpe_context->vfe_desc5.scoreboard0.mask = scoreboard_param->mask;
1604 gpe_context->vfe_desc5.scoreboard0.type = scoreboard_param->type;
1605 gpe_context->vfe_desc5.scoreboard0.enable = scoreboard_param->enable;
1606
1607 if (scoreboard_param->walkpat_flag) {
1608 gpe_context->vfe_desc5.scoreboard0.mask = 0x0F;
1609 gpe_context->vfe_desc5.scoreboard0.type = 1;
1610
1611 gpe_context->vfe_desc6.scoreboard1.delta_x0 = 0;
1612 gpe_context->vfe_desc6.scoreboard1.delta_y0 = -1;
1613
1614 gpe_context->vfe_desc6.scoreboard1.delta_x1 = 0;
1615 gpe_context->vfe_desc6.scoreboard1.delta_y1 = -2;
1616
1617 gpe_context->vfe_desc6.scoreboard1.delta_x2 = -1;
1618 gpe_context->vfe_desc6.scoreboard1.delta_y2 = 3;
1619
1620 gpe_context->vfe_desc6.scoreboard1.delta_x3 = -1;
1621 gpe_context->vfe_desc6.scoreboard1.delta_y3 = 1;
1622 } else {
1623 // Scoreboard 0
1624 gpe_context->vfe_desc6.scoreboard1.delta_x0 = -1;
1625 gpe_context->vfe_desc6.scoreboard1.delta_y0 = 0;
1626
1627 // Scoreboard 1
1628 gpe_context->vfe_desc6.scoreboard1.delta_x1 = 0;
1629 gpe_context->vfe_desc6.scoreboard1.delta_y1 = -1;
1630
1631 // Scoreboard 2
1632 gpe_context->vfe_desc6.scoreboard1.delta_x2 = 1;
1633 gpe_context->vfe_desc6.scoreboard1.delta_y2 = -1;
1634
1635 // Scoreboard 3
1636 gpe_context->vfe_desc6.scoreboard1.delta_x3 = -1;
1637 gpe_context->vfe_desc6.scoreboard1.delta_y3 = -1;
1638
1639 // Scoreboard 4
1640 gpe_context->vfe_desc7.scoreboard2.delta_x4 = -1;
1641 gpe_context->vfe_desc7.scoreboard2.delta_y4 = 1;
1642
1643 // Scoreboard 5
1644 gpe_context->vfe_desc7.scoreboard2.delta_x5 = 0;
1645 gpe_context->vfe_desc7.scoreboard2.delta_y5 = -2;
1646
1647 // Scoreboard 6
1648 gpe_context->vfe_desc7.scoreboard2.delta_x6 = 1;
1649 gpe_context->vfe_desc7.scoreboard2.delta_y6 = -2;
1650
1651 // Scoreboard 7
1652 gpe_context->vfe_desc7.scoreboard2.delta_x6 = -1;
1653 gpe_context->vfe_desc7.scoreboard2.delta_y6 = -2;
1654 }
1655 }
1656 /*
1657 VME pipeline related function
1658 */
1659
1660 /*
1661 scaling kernel related function
1662 */
1663 static void
1664 gen9_avc_set_curbe_scaling4x(VADriverContextP ctx,
1665 struct encode_state *encode_state,
1666 struct i965_gpe_context *gpe_context,
1667 struct intel_encoder_context *encoder_context,
1668 void *param)
1669 {
1670 gen9_avc_scaling4x_curbe_data *curbe_cmd;
1671 struct scaling_param *surface_param = (struct scaling_param *)param;
1672
1673 curbe_cmd = i965_gpe_context_map_curbe(gpe_context);
1674
1675 if (!curbe_cmd)
1676 return;
1677
1678 memset(curbe_cmd, 0, sizeof(gen9_avc_scaling4x_curbe_data));
1679
1680 curbe_cmd->dw0.input_picture_width = surface_param->input_frame_width;
1681 curbe_cmd->dw0.input_picture_height = surface_param->input_frame_height;
1682
1683 curbe_cmd->dw1.input_y_bti = GEN9_AVC_SCALING_FRAME_SRC_Y_INDEX;
1684 curbe_cmd->dw2.output_y_bti = GEN9_AVC_SCALING_FRAME_DST_Y_INDEX;
1685
1686
1687 curbe_cmd->dw5.flatness_threshold = 128;
1688 curbe_cmd->dw6.enable_mb_flatness_check = surface_param->enable_mb_flatness_check;
1689 curbe_cmd->dw7.enable_mb_variance_output = surface_param->enable_mb_variance_output;
1690 curbe_cmd->dw8.enable_mb_pixel_average_output = surface_param->enable_mb_pixel_average_output;
1691
1692 if (curbe_cmd->dw6.enable_mb_flatness_check ||
1693 curbe_cmd->dw7.enable_mb_variance_output ||
1694 curbe_cmd->dw8.enable_mb_pixel_average_output) {
1695 curbe_cmd->dw10.mbv_proc_stat_bti = GEN9_AVC_SCALING_FRAME_MBVPROCSTATS_DST_INDEX;
1696 }
1697
1698 i965_gpe_context_unmap_curbe(gpe_context);
1699 return;
1700 }
1701
1702 static void
1703 gen95_avc_set_curbe_scaling4x(VADriverContextP ctx,
1704 struct encode_state *encode_state,
1705 struct i965_gpe_context *gpe_context,
1706 struct intel_encoder_context *encoder_context,
1707 void *param)
1708 {
1709 gen95_avc_scaling4x_curbe_data *curbe_cmd;
1710 struct scaling_param *surface_param = (struct scaling_param *)param;
1711
1712 curbe_cmd = i965_gpe_context_map_curbe(gpe_context);
1713
1714 if (!curbe_cmd)
1715 return;
1716
1717 memset(curbe_cmd, 0, sizeof(gen95_avc_scaling4x_curbe_data));
1718
1719 curbe_cmd->dw0.input_picture_width = surface_param->input_frame_width;
1720 curbe_cmd->dw0.input_picture_height = surface_param->input_frame_height;
1721
1722 curbe_cmd->dw1.input_y_bti_frame = GEN9_AVC_SCALING_FRAME_SRC_Y_INDEX;
1723 curbe_cmd->dw2.output_y_bti_frame = GEN9_AVC_SCALING_FRAME_DST_Y_INDEX;
1724
1725 if (surface_param->enable_mb_flatness_check)
1726 curbe_cmd->dw5.flatness_threshold = 128;
1727 curbe_cmd->dw6.enable_mb_flatness_check = surface_param->enable_mb_flatness_check;
1728 curbe_cmd->dw6.enable_mb_variance_output = surface_param->enable_mb_variance_output;
1729 curbe_cmd->dw6.enable_mb_pixel_average_output = surface_param->enable_mb_pixel_average_output;
1730 curbe_cmd->dw6.enable_block8x8_statistics_output = surface_param->blk8x8_stat_enabled;
1731
1732 if (curbe_cmd->dw6.enable_mb_flatness_check ||
1733 curbe_cmd->dw6.enable_mb_variance_output ||
1734 curbe_cmd->dw6.enable_mb_pixel_average_output) {
1735 curbe_cmd->dw8.mbv_proc_stat_bti_frame = GEN9_AVC_SCALING_FRAME_MBVPROCSTATS_DST_INDEX;
1736 }
1737
1738 i965_gpe_context_unmap_curbe(gpe_context);
1739 return;
1740 }
1741
1742 static void
1743 gen9_avc_set_curbe_scaling2x(VADriverContextP ctx,
1744 struct encode_state *encode_state,
1745 struct i965_gpe_context *gpe_context,
1746 struct intel_encoder_context *encoder_context,
1747 void *param)
1748 {
1749 gen9_avc_scaling2x_curbe_data *curbe_cmd;
1750 struct scaling_param *surface_param = (struct scaling_param *)param;
1751
1752 curbe_cmd = i965_gpe_context_map_curbe(gpe_context);
1753
1754 if (!curbe_cmd)
1755 return;
1756
1757 memset(curbe_cmd, 0, sizeof(gen9_avc_scaling2x_curbe_data));
1758
1759 curbe_cmd->dw0.input_picture_width = surface_param->input_frame_width;
1760 curbe_cmd->dw0.input_picture_height = surface_param->input_frame_height;
1761
1762 curbe_cmd->dw8.input_y_bti = GEN9_AVC_SCALING_FRAME_SRC_Y_INDEX;
1763 curbe_cmd->dw9.output_y_bti = GEN9_AVC_SCALING_FRAME_DST_Y_INDEX;
1764
1765 i965_gpe_context_unmap_curbe(gpe_context);
1766 return;
1767 }
1768
1769 static void
1770 gen9_avc_send_surface_scaling(VADriverContextP ctx,
1771 struct encode_state *encode_state,
1772 struct i965_gpe_context *gpe_context,
1773 struct intel_encoder_context *encoder_context,
1774 void *param)
1775 {
1776 struct scaling_param *surface_param = (struct scaling_param *)param;
1777 struct i965_driver_data *i965 = i965_driver_data(ctx);
1778 unsigned int surface_format;
1779 unsigned int res_size;
1780
1781 if (surface_param->scaling_out_use_32unorm_surf_fmt)
1782 surface_format = I965_SURFACEFORMAT_R32_UNORM;
1783 else if (surface_param->scaling_out_use_16unorm_surf_fmt)
1784 surface_format = I965_SURFACEFORMAT_R16_UNORM;
1785 else
1786 surface_format = I965_SURFACEFORMAT_R8_UNORM;
1787
1788 i965_add_2d_gpe_surface(ctx, gpe_context,
1789 surface_param->input_surface,
1790 0, 1, surface_format,
1791 GEN9_AVC_SCALING_FRAME_SRC_Y_INDEX);
1792
1793 i965_add_2d_gpe_surface(ctx, gpe_context,
1794 surface_param->output_surface,
1795 0, 1, surface_format,
1796 GEN9_AVC_SCALING_FRAME_DST_Y_INDEX);
1797
1798 /*add buffer mv_proc_stat, here need change*/
1799 if (IS_GEN8(i965->intel.device_info)) {
1800 if (surface_param->mbv_proc_stat_enabled) {
1801 res_size = 16 * (surface_param->input_frame_width / 16) * (surface_param->input_frame_height / 16) * sizeof(unsigned int);
1802
1803 i965_add_buffer_gpe_surface(ctx,
1804 gpe_context,
1805 surface_param->pres_mbv_proc_stat_buffer,
1806 0,
1807 res_size / 4,
1808 0,
1809 GEN8_SCALING_FRAME_MBVPROCSTATS_DST_CM);
1810 }
1811 if (surface_param->enable_mb_flatness_check) {
1812 i965_add_buffer_2d_gpe_surface(ctx, gpe_context,
1813 surface_param->pres_flatness_check_surface,
1814 1,
1815 I965_SURFACEFORMAT_R8_UNORM,
1816 GEN8_SCALING_FRAME_FLATNESS_DST_CM);
1817 }
1818 } else {
1819 if (surface_param->mbv_proc_stat_enabled) {
1820 res_size = 16 * (surface_param->input_frame_width / 16) * (surface_param->input_frame_height / 16) * sizeof(unsigned int);
1821
1822 i965_add_buffer_gpe_surface(ctx,
1823 gpe_context,
1824 surface_param->pres_mbv_proc_stat_buffer,
1825 0,
1826 res_size / 4,
1827 0,
1828 GEN9_AVC_SCALING_FRAME_MBVPROCSTATS_DST_INDEX);
1829 } else if (surface_param->enable_mb_flatness_check) {
1830 i965_add_buffer_2d_gpe_surface(ctx, gpe_context,
1831 surface_param->pres_flatness_check_surface,
1832 1,
1833 I965_SURFACEFORMAT_R8_UNORM,
1834 GEN9_AVC_SCALING_FRAME_MBVPROCSTATS_DST_INDEX);
1835 }
1836 }
1837 return;
1838 }
1839
1840 static VAStatus
1841 gen9_avc_kernel_scaling(VADriverContextP ctx,
1842 struct encode_state *encode_state,
1843 struct intel_encoder_context *encoder_context,
1844 int hme_type)
1845 {
1846 struct i965_driver_data *i965 = i965_driver_data(ctx);
1847 struct i965_gpe_table *gpe = &i965->gpe_table;
1848 struct encoder_vme_mfc_context * vme_context = (struct encoder_vme_mfc_context *)encoder_context->vme_context;
1849 struct i965_avc_encoder_context * avc_ctx = (struct i965_avc_encoder_context *)vme_context->private_enc_ctx;
1850 struct generic_enc_codec_state * generic_state = (struct generic_enc_codec_state *)vme_context->generic_enc_state;
1851 struct avc_enc_state * avc_state = (struct avc_enc_state *)vme_context->private_enc_state;
1852 struct generic_encoder_context * generic_ctx = (struct generic_encoder_context *)vme_context->generic_enc_ctx;
1853
1854 struct i965_gpe_context *gpe_context;
1855 struct scaling_param surface_param;
1856 struct object_surface *obj_surface;
1857 struct gen9_surface_avc *avc_priv_surface;
1858 struct gpe_media_object_walker_parameter media_object_walker_param;
1859 struct gpe_encoder_kernel_walker_parameter kernel_walker_param;
1860 unsigned int downscaled_width_in_mb, downscaled_height_in_mb;
1861 int media_function = 0;
1862 int kernel_idx = 0;
1863
1864 obj_surface = encode_state->reconstructed_object;
1865 avc_priv_surface = obj_surface->private_data;
1866
1867 memset(&surface_param, 0, sizeof(struct scaling_param));
1868 switch (hme_type) {
1869 case INTEL_ENC_HME_4x : {
1870 media_function = INTEL_MEDIA_STATE_4X_SCALING;
1871 kernel_idx = GEN9_AVC_KERNEL_SCALING_4X_IDX;
1872 downscaled_width_in_mb = generic_state->downscaled_width_4x_in_mb;
1873 downscaled_height_in_mb = generic_state->downscaled_height_4x_in_mb;
1874
1875 surface_param.input_surface = encode_state->input_yuv_object ;
1876 surface_param.input_frame_width = generic_state->frame_width_in_pixel ;
1877 surface_param.input_frame_height = generic_state->frame_height_in_pixel ;
1878
1879 surface_param.output_surface = avc_priv_surface->scaled_4x_surface_obj ;
1880 surface_param.output_frame_width = generic_state->frame_width_4x ;
1881 surface_param.output_frame_height = generic_state->frame_height_4x ;
1882
1883 surface_param.enable_mb_flatness_check = avc_state->flatness_check_enable;
1884 surface_param.enable_mb_variance_output = avc_state->mb_status_enable;
1885 surface_param.enable_mb_pixel_average_output = avc_state->mb_status_enable;
1886
1887 surface_param.blk8x8_stat_enabled = 0 ;
1888 surface_param.use_4x_scaling = 1 ;
1889 surface_param.use_16x_scaling = 0 ;
1890 surface_param.use_32x_scaling = 0 ;
1891 break;
1892 }
1893 case INTEL_ENC_HME_16x : {
1894 media_function = INTEL_MEDIA_STATE_16X_SCALING;
1895 kernel_idx = GEN9_AVC_KERNEL_SCALING_4X_IDX;
1896 downscaled_width_in_mb = generic_state->downscaled_width_16x_in_mb;
1897 downscaled_height_in_mb = generic_state->downscaled_height_16x_in_mb;
1898
1899 surface_param.input_surface = avc_priv_surface->scaled_4x_surface_obj ;
1900 surface_param.input_frame_width = generic_state->frame_width_4x ;
1901 surface_param.input_frame_height = generic_state->frame_height_4x ;
1902
1903 surface_param.output_surface = avc_priv_surface->scaled_16x_surface_obj ;
1904 surface_param.output_frame_width = generic_state->frame_width_16x ;
1905 surface_param.output_frame_height = generic_state->frame_height_16x ;
1906
1907 surface_param.enable_mb_flatness_check = 0 ;
1908 surface_param.enable_mb_variance_output = 0 ;
1909 surface_param.enable_mb_pixel_average_output = 0 ;
1910
1911 surface_param.blk8x8_stat_enabled = 0 ;
1912 surface_param.use_4x_scaling = 0 ;
1913 surface_param.use_16x_scaling = 1 ;
1914 surface_param.use_32x_scaling = 0 ;
1915
1916 break;
1917 }
1918 case INTEL_ENC_HME_32x : {
1919 media_function = INTEL_MEDIA_STATE_32X_SCALING;
1920 kernel_idx = GEN9_AVC_KERNEL_SCALING_2X_IDX;
1921 downscaled_width_in_mb = generic_state->downscaled_width_32x_in_mb;
1922 downscaled_height_in_mb = generic_state->downscaled_height_32x_in_mb;
1923
1924 surface_param.input_surface = avc_priv_surface->scaled_16x_surface_obj ;
1925 surface_param.input_frame_width = generic_state->frame_width_16x ;
1926 surface_param.input_frame_height = generic_state->frame_height_16x ;
1927
1928 surface_param.output_surface = avc_priv_surface->scaled_32x_surface_obj ;
1929 surface_param.output_frame_width = generic_state->frame_width_32x ;
1930 surface_param.output_frame_height = generic_state->frame_height_32x ;
1931
1932 surface_param.enable_mb_flatness_check = 0 ;
1933 surface_param.enable_mb_variance_output = 0 ;
1934 surface_param.enable_mb_pixel_average_output = 0 ;
1935
1936 surface_param.blk8x8_stat_enabled = 0 ;
1937 surface_param.use_4x_scaling = 0 ;
1938 surface_param.use_16x_scaling = 0 ;
1939 surface_param.use_32x_scaling = 1 ;
1940 break;
1941 }
1942 default :
1943 assert(0);
1944
1945 }
1946
1947 gpe_context = &(avc_ctx->context_scaling.gpe_contexts[kernel_idx]);
1948
1949 gpe->context_init(ctx, gpe_context);
1950 gpe->reset_binding_table(ctx, gpe_context);
1951
1952 if (surface_param.use_32x_scaling) {
1953 generic_ctx->pfn_set_curbe_scaling2x(ctx, encode_state, gpe_context, encoder_context, &surface_param);
1954 } else {
1955 generic_ctx->pfn_set_curbe_scaling4x(ctx, encode_state, gpe_context, encoder_context, &surface_param);
1956 }
1957
1958 if (surface_param.use_32x_scaling) {
1959 surface_param.scaling_out_use_16unorm_surf_fmt = 1 ;
1960 surface_param.scaling_out_use_32unorm_surf_fmt = 0 ;
1961 } else {
1962 surface_param.scaling_out_use_16unorm_surf_fmt = 0 ;
1963 surface_param.scaling_out_use_32unorm_surf_fmt = 1 ;
1964 }
1965
1966 if (surface_param.use_4x_scaling) {
1967 if (avc_state->mb_status_supported) {
1968 surface_param.enable_mb_flatness_check = 0;
1969 surface_param.mbv_proc_stat_enabled = (surface_param.use_4x_scaling) ? (avc_state->mb_status_enable || avc_state->flatness_check_enable) : 0 ;
1970 surface_param.pres_mbv_proc_stat_buffer = &(avc_ctx->res_mb_status_buffer);
1971
1972 } else {
1973 surface_param.enable_mb_flatness_check = (surface_param.use_4x_scaling) ? avc_state->flatness_check_enable : 0;
1974 surface_param.mbv_proc_stat_enabled = 0 ;
1975 surface_param.pres_flatness_check_surface = &(avc_ctx->res_flatness_check_surface);
1976 }
1977 }
1978
1979 generic_ctx->pfn_send_scaling_surface(ctx, encode_state, gpe_context, encoder_context, &surface_param);
1980
1981 /* setup the interface data */
1982 gpe->setup_interface_data(ctx, gpe_context);
1983
1984 memset(&kernel_walker_param, 0, sizeof(kernel_walker_param));
1985 if (surface_param.use_32x_scaling) {
1986 kernel_walker_param.resolution_x = downscaled_width_in_mb ;
1987 kernel_walker_param.resolution_y = downscaled_height_in_mb ;
1988 } else {
1989 /* the scaling is based on 8x8 blk level */
1990 kernel_walker_param.resolution_x = downscaled_width_in_mb * 2;
1991 kernel_walker_param.resolution_y = downscaled_height_in_mb * 2;
1992 }
1993 kernel_walker_param.no_dependency = 1;
1994
1995 i965_init_media_object_walker_parameter(&kernel_walker_param, &media_object_walker_param);
1996
1997 gen9_avc_run_kernel_media_object_walker(ctx, encoder_context,
1998 gpe_context,
1999 media_function,
2000 &media_object_walker_param);
2001
2002 return VA_STATUS_SUCCESS;
2003 }
2004
2005 /*
2006 frame/mb brc related function
2007 */
2008 static void
2009 gen9_avc_init_mfx_avc_img_state(VADriverContextP ctx,
2010 struct encode_state *encode_state,
2011 struct intel_encoder_context *encoder_context,
2012 struct gen9_mfx_avc_img_state *pstate)
2013 {
2014 struct encoder_vme_mfc_context * vme_context = (struct encoder_vme_mfc_context *)encoder_context->vme_context;
2015 struct generic_enc_codec_state * generic_state = (struct generic_enc_codec_state *)vme_context->generic_enc_state;
2016 struct avc_enc_state * avc_state = (struct avc_enc_state *)vme_context->private_enc_state;
2017
2018 VAEncSequenceParameterBufferH264 *seq_param = avc_state->seq_param;
2019 VAEncPictureParameterBufferH264 *pic_param = avc_state->pic_param;
2020
2021 memset(pstate, 0, sizeof(*pstate));
2022
2023 pstate->dw0.dword_length = (sizeof(struct gen9_mfx_avc_img_state)) / 4 - 2;
2024 pstate->dw0.sub_opcode_b = 0;
2025 pstate->dw0.sub_opcode_a = 0;
2026 pstate->dw0.command_opcode = 1;
2027 pstate->dw0.pipeline = 2;
2028 pstate->dw0.command_type = 3;
2029
2030 pstate->dw1.frame_size_in_mbs = generic_state->frame_width_in_mbs * generic_state->frame_height_in_mbs ;
2031
2032 pstate->dw2.frame_width_in_mbs_minus1 = generic_state->frame_width_in_mbs - 1;
2033 pstate->dw2.frame_height_in_mbs_minus1 = generic_state->frame_height_in_mbs - 1;
2034
2035 pstate->dw3.image_structure = 0;//frame is zero
2036 pstate->dw3.weighted_bipred_idc = pic_param->pic_fields.bits.weighted_bipred_idc;
2037 pstate->dw3.weighted_pred_flag = pic_param->pic_fields.bits.weighted_pred_flag;
2038 pstate->dw3.brc_domain_rate_control_enable = 0;//0,set for non-vdenc mode;
2039 pstate->dw3.chroma_qp_offset = pic_param->chroma_qp_index_offset;
2040 pstate->dw3.second_chroma_qp_offset = pic_param->second_chroma_qp_index_offset;
2041
2042 pstate->dw4.field_picture_flag = 0;
2043 pstate->dw4.mbaff_mode_active = seq_param->seq_fields.bits.mb_adaptive_frame_field_flag;
2044 pstate->dw4.frame_mb_only_flag = seq_param->seq_fields.bits.frame_mbs_only_flag;
2045 pstate->dw4.transform_8x8_idct_mode_flag = pic_param->pic_fields.bits.transform_8x8_mode_flag;
2046 pstate->dw4.direct_8x8_interface_flag = seq_param->seq_fields.bits.direct_8x8_inference_flag;
2047 pstate->dw4.constrained_intra_prediction_flag = pic_param->pic_fields.bits.constrained_intra_pred_flag;
2048 pstate->dw4.entropy_coding_flag = pic_param->pic_fields.bits.entropy_coding_mode_flag;
2049 pstate->dw4.mb_mv_format_flag = 1;
2050 pstate->dw4.chroma_format_idc = seq_param->seq_fields.bits.chroma_format_idc;
2051 pstate->dw4.mv_unpacked_flag = 1;
2052 pstate->dw4.insert_test_flag = 0;
2053 pstate->dw4.load_slice_pointer_flag = 0;
2054 pstate->dw4.macroblock_stat_enable = 0; /* disable in the first pass */
2055 pstate->dw4.minimum_frame_size = 0;
2056 pstate->dw5.intra_mb_max_bit_flag = 1;
2057 pstate->dw5.inter_mb_max_bit_flag = 1;
2058 pstate->dw5.frame_size_over_flag = 1;
2059 pstate->dw5.frame_size_under_flag = 1;
2060 pstate->dw5.intra_mb_ipcm_flag = 1;
2061 pstate->dw5.mb_rate_ctrl_flag = 0;
2062 pstate->dw5.non_first_pass_flag = 0;
2063 pstate->dw5.aq_enable = pstate->dw5.aq_rounding = 0;
2064 pstate->dw5.aq_chroma_disable = 1;
2065 if (pstate->dw4.entropy_coding_flag && (avc_state->tq_enable)) {
2066 pstate->dw5.aq_enable = avc_state->tq_enable;
2067 pstate->dw5.aq_rounding = avc_state->tq_rounding;
2068 } else {
2069 pstate->dw5.aq_rounding = 0;
2070 }
2071
2072 pstate->dw6.intra_mb_max_size = 2700;
2073 pstate->dw6.inter_mb_max_size = 4095;
2074
2075 pstate->dw8.slice_delta_qp_max0 = 0;
2076 pstate->dw8.slice_delta_qp_max1 = 0;
2077 pstate->dw8.slice_delta_qp_max2 = 0;
2078 pstate->dw8.slice_delta_qp_max3 = 0;
2079
2080 pstate->dw9.slice_delta_qp_min0 = 0;
2081 pstate->dw9.slice_delta_qp_min1 = 0;
2082 pstate->dw9.slice_delta_qp_min2 = 0;
2083 pstate->dw9.slice_delta_qp_min3 = 0;
2084
2085 pstate->dw10.frame_bitrate_min = 0;
2086 pstate->dw10.frame_bitrate_min_unit = 1;
2087 pstate->dw10.frame_bitrate_min_unit_mode = 1;
2088 pstate->dw10.frame_bitrate_max = (1 << 14) - 1;
2089 pstate->dw10.frame_bitrate_max_unit = 1;
2090 pstate->dw10.frame_bitrate_max_unit_mode = 1;
2091
2092 pstate->dw11.frame_bitrate_min_delta = 0;
2093 pstate->dw11.frame_bitrate_max_delta = 0;
2094
2095 pstate->dw12.vad_error_logic = 1;
2096 /* set paramters DW19/DW20 for slices */
2097 }
2098
2099 static void
2100 gen8_avc_init_mfx_avc_img_state(VADriverContextP ctx,
2101 struct encode_state *encode_state,
2102 struct intel_encoder_context *encoder_context,
2103 struct gen8_mfx_avc_img_state *pstate)
2104 {
2105 struct encoder_vme_mfc_context * vme_context = (struct encoder_vme_mfc_context *)encoder_context->vme_context;
2106 struct generic_enc_codec_state * generic_state = (struct generic_enc_codec_state *)vme_context->generic_enc_state;
2107 struct avc_enc_state * avc_state = (struct avc_enc_state *)vme_context->private_enc_state;
2108
2109 VAEncSequenceParameterBufferH264 *seq_param = avc_state->seq_param;
2110 VAEncPictureParameterBufferH264 *pic_param = avc_state->pic_param;
2111
2112 memset(pstate, 0, sizeof(*pstate));
2113
2114 pstate->dw0.dword_length = (sizeof(struct gen8_mfx_avc_img_state)) / 4 - 2;
2115 pstate->dw0.command_sub_opcode_b = 0;
2116 pstate->dw0.command_sub_opcode_a = 0;
2117 pstate->dw0.command_opcode = 1;
2118 pstate->dw0.command_pipeline = 2;
2119 pstate->dw0.command_type = 3;
2120
2121 pstate->dw1.frame_size_in_mbs = generic_state->frame_width_in_mbs * generic_state->frame_height_in_mbs ;
2122
2123 pstate->dw2.frame_width_in_mbs_minus1 = generic_state->frame_width_in_mbs - 1;
2124 pstate->dw2.frame_height_in_mbs_minus1 = generic_state->frame_height_in_mbs - 1;
2125
2126 pstate->dw3.image_structure = 0;//frame is zero
2127 pstate->dw3.weighted_bipred_idc = pic_param->pic_fields.bits.weighted_bipred_idc;
2128 pstate->dw3.weighted_pred_flag = pic_param->pic_fields.bits.weighted_pred_flag;
2129 pstate->dw3.inter_mb_conf_flag = 0;
2130 pstate->dw3.intra_mb_conf_flag = 0;
2131 pstate->dw3.chroma_qp_offset = pic_param->chroma_qp_index_offset;
2132 pstate->dw3.second_chroma_qp_offset = pic_param->second_chroma_qp_index_offset;
2133
2134 pstate->dw4.field_picture_flag = 0;
2135 pstate->dw4.mbaff_mode_active = seq_param->seq_fields.bits.mb_adaptive_frame_field_flag;
2136 pstate->dw4.frame_mb_only_flag = seq_param->seq_fields.bits.frame_mbs_only_flag;
2137 pstate->dw4.transform_8x8_idct_mode_flag = pic_param->pic_fields.bits.transform_8x8_mode_flag;
2138 pstate->dw4.direct_8x8_interface_flag = seq_param->seq_fields.bits.direct_8x8_inference_flag;
2139 pstate->dw4.constrained_intra_prediction_flag = pic_param->pic_fields.bits.constrained_intra_pred_flag;
2140 pstate->dw4.entropy_coding_flag = pic_param->pic_fields.bits.entropy_coding_mode_flag;
2141 pstate->dw4.mb_mv_format_flag = 1;
2142 pstate->dw4.chroma_format_idc = seq_param->seq_fields.bits.chroma_format_idc;
2143 pstate->dw4.mv_unpacked_flag = 1;
2144 pstate->dw4.insert_test_flag = 0;
2145 pstate->dw4.load_slice_pointer_flag = 0;
2146 pstate->dw4.macroblock_stat_enable = 0; /* disable in the first pass */
2147 pstate->dw4.minimum_frame_size = 0;
2148 pstate->dw5.intra_mb_max_bit_flag = 1;
2149 pstate->dw5.inter_mb_max_bit_flag = 1;
2150 pstate->dw5.frame_size_over_flag = 1;
2151 pstate->dw5.frame_size_under_flag = 1;
2152 pstate->dw5.intra_mb_ipcm_flag = 1;
2153 pstate->dw5.mb_rate_ctrl_flag = 0;
2154 pstate->dw5.non_first_pass_flag = 0;
2155 pstate->dw5.aq_enable = pstate->dw5.aq_rounding = 0;
2156 pstate->dw5.aq_chroma_disable = 1;
2157 if (pstate->dw4.entropy_coding_flag && (avc_state->tq_enable)) {
2158 pstate->dw5.aq_enable = avc_state->tq_enable;
2159 pstate->dw5.aq_rounding = avc_state->tq_rounding;
2160 } else {
2161 pstate->dw5.aq_rounding = 0;
2162 }
2163
2164 pstate->dw6.intra_mb_max_size = 2700;
2165 pstate->dw6.inter_mb_max_size = 4095;
2166
2167 pstate->dw8.slice_delta_qp_max0 = 0;
2168 pstate->dw8.slice_delta_qp_max1 = 0;
2169 pstate->dw8.slice_delta_qp_max2 = 0;
2170 pstate->dw8.slice_delta_qp_max3 = 0;
2171
2172 pstate->dw9.slice_delta_qp_min0 = 0;
2173 pstate->dw9.slice_delta_qp_min1 = 0;
2174 pstate->dw9.slice_delta_qp_min2 = 0;
2175 pstate->dw9.slice_delta_qp_min3 = 0;
2176
2177 pstate->dw10.frame_bitrate_min = 0;
2178 pstate->dw10.frame_bitrate_min_unit = 1;
2179 pstate->dw10.frame_bitrate_min_unit_mode = 1;
2180 pstate->dw10.frame_bitrate_max = (1 << 14) - 1;
2181 pstate->dw10.frame_bitrate_max_unit = 1;
2182 pstate->dw10.frame_bitrate_max_unit_mode = 1;
2183
2184 pstate->dw11.frame_bitrate_min_delta = 0;
2185 pstate->dw11.frame_bitrate_max_delta = 0;
2186 /* set paramters DW19/DW20 for slices */
2187 }
2188 void gen9_avc_set_image_state(VADriverContextP ctx,
2189 struct encode_state *encode_state,
2190 struct intel_encoder_context *encoder_context,
2191 struct i965_gpe_resource *gpe_resource)
2192 {
2193 struct encoder_vme_mfc_context * pak_context = (struct encoder_vme_mfc_context *)encoder_context->vme_context;
2194 struct generic_enc_codec_state * generic_state = (struct generic_enc_codec_state *)pak_context->generic_enc_state;
2195 char *pdata;
2196 int i;
2197 unsigned int * data;
2198 struct gen9_mfx_avc_img_state cmd;
2199
2200 pdata = i965_map_gpe_resource(gpe_resource);
2201
2202 if (!pdata)
2203 return;
2204
2205 gen9_avc_init_mfx_avc_img_state(ctx, encode_state, encoder_context, &cmd);
2206 for (i = 0; i < generic_state->num_pak_passes; i++) {
2207
2208 if (i == 0) {
2209 cmd.dw4.macroblock_stat_enable = 0;
2210 cmd.dw5.non_first_pass_flag = 0;
2211 } else {
2212 cmd.dw4.macroblock_stat_enable = 1;
2213 cmd.dw5.non_first_pass_flag = 1;
2214 cmd.dw5.intra_mb_ipcm_flag = 1;
2215
2216 }
2217 cmd.dw5.mb_rate_ctrl_flag = 0;
2218 memcpy(pdata, &cmd, sizeof(struct gen9_mfx_avc_img_state));
2219 data = (unsigned int *)(pdata + sizeof(struct gen9_mfx_avc_img_state));
2220 *data = MI_BATCH_BUFFER_END;
2221
2222 pdata += INTEL_AVC_IMAGE_STATE_CMD_SIZE;
2223 }
2224 i965_unmap_gpe_resource(gpe_resource);
2225 return;
2226 }
2227
2228 void gen8_avc_set_image_state(VADriverContextP ctx,
2229 struct encode_state *encode_state,
2230 struct intel_encoder_context *encoder_context,
2231 struct i965_gpe_resource *gpe_resource)
2232 {
2233 struct encoder_vme_mfc_context * pak_context = (struct encoder_vme_mfc_context *)encoder_context->vme_context;
2234 struct generic_enc_codec_state * generic_state = (struct generic_enc_codec_state *)pak_context->generic_enc_state;
2235 char *pdata;
2236 int i;
2237 unsigned int * data;
2238 struct gen8_mfx_avc_img_state cmd;
2239
2240 pdata = i965_map_gpe_resource(gpe_resource);
2241
2242 if (!pdata)
2243 return;
2244
2245 gen8_avc_init_mfx_avc_img_state(ctx, encode_state, encoder_context, &cmd);
2246 for (i = 0; i < generic_state->num_pak_passes; i++) {
2247
2248 if (i == 0) {
2249 cmd.dw4.macroblock_stat_enable = 0;
2250 cmd.dw5.non_first_pass_flag = 0;
2251 } else {
2252 cmd.dw4.macroblock_stat_enable = 1;
2253 cmd.dw5.non_first_pass_flag = 1;
2254 cmd.dw5.intra_mb_ipcm_flag = 1;
2255 cmd.dw3.inter_mb_conf_flag = 1;
2256 cmd.dw3.intra_mb_conf_flag = 1;
2257 }
2258 cmd.dw5.mb_rate_ctrl_flag = 0;
2259 memcpy(pdata, &cmd, sizeof(struct gen8_mfx_avc_img_state));
2260 data = (unsigned int *)(pdata + sizeof(struct gen8_mfx_avc_img_state));
2261 *data = MI_BATCH_BUFFER_END;
2262
2263 pdata += INTEL_AVC_IMAGE_STATE_CMD_SIZE;
2264 }
2265 i965_unmap_gpe_resource(gpe_resource);
2266 return;
2267 }
2268
2269 void gen9_avc_set_image_state_non_brc(VADriverContextP ctx,
2270 struct encode_state *encode_state,
2271 struct intel_encoder_context *encoder_context,
2272 struct i965_gpe_resource *gpe_resource)
2273 {
2274 struct encoder_vme_mfc_context * pak_context = (struct encoder_vme_mfc_context *)encoder_context->vme_context;
2275 struct generic_enc_codec_state * generic_state = (struct generic_enc_codec_state *)pak_context->generic_enc_state;
2276 char *pdata;
2277
2278 unsigned int * data;
2279 struct gen9_mfx_avc_img_state cmd;
2280
2281 pdata = i965_map_gpe_resource(gpe_resource);
2282
2283 if (!pdata)
2284 return;
2285
2286 gen9_avc_init_mfx_avc_img_state(ctx, encode_state, encoder_context, &cmd);
2287
2288 if (generic_state->curr_pak_pass == 0) {
2289 cmd.dw4.macroblock_stat_enable = 0;
2290 cmd.dw5.non_first_pass_flag = 0;
2291
2292 } else {
2293 cmd.dw4.macroblock_stat_enable = 1;
2294 cmd.dw5.non_first_pass_flag = 0;
2295 cmd.dw5.intra_mb_ipcm_flag = 1;
2296 }
2297
2298 cmd.dw5.mb_rate_ctrl_flag = 0;
2299 memcpy(pdata, &cmd, sizeof(struct gen9_mfx_avc_img_state));
2300 data = (unsigned int *)(pdata + sizeof(struct gen9_mfx_avc_img_state));
2301 *data = MI_BATCH_BUFFER_END;
2302
2303 i965_unmap_gpe_resource(gpe_resource);
2304 return;
2305 }
2306
2307 static void
2308 gen95_avc_calc_lambda_table(VADriverContextP ctx,
2309 struct encode_state *encode_state,
2310 struct intel_encoder_context *encoder_context)
2311 {
2312 struct encoder_vme_mfc_context * vme_context = (struct encoder_vme_mfc_context *)encoder_context->vme_context;
2313 struct generic_enc_codec_state * generic_state = (struct generic_enc_codec_state *)vme_context->generic_enc_state;
2314 struct avc_enc_state * avc_state = (struct avc_enc_state *)vme_context->private_enc_state;
2315 unsigned int value, inter, intra;
2316 unsigned int size = 0;
2317 int i = 0;
2318 int col = 0;
2319 unsigned int * lambda_table = (unsigned int *)(avc_state->lamda_value_lut);
2320
2321 value = 0;
2322 inter = 0;
2323 intra = 0;
2324
2325 size = AVC_QP_MAX * 2 * sizeof(unsigned int);
2326 switch (generic_state->frame_type) {
2327 case SLICE_TYPE_I:
2328 memcpy((unsigned char *)lambda_table, (unsigned char *)&gen95_avc_tq_lambda_i_frame[0][0], size * sizeof(unsigned char));
2329 break;
2330 case SLICE_TYPE_P:
2331 memcpy((unsigned char *)lambda_table, (unsigned char *)&gen95_avc_tq_lambda_p_frame[0][0], size * sizeof(unsigned char));
2332 break;
2333 case SLICE_TYPE_B:
2334 memcpy((unsigned char *)lambda_table, (unsigned char *)&gen95_avc_tq_lambda_b_frame[0][0], size * sizeof(unsigned char));
2335 break;
2336 default:
2337 assert(0);
2338 break;
2339 }
2340
2341 for (i = 0; i < AVC_QP_MAX ; i++) {
2342 for (col = 0; col < 2; col++) {
2343 value = *(lambda_table + i * 2 + col);
2344 intra = value >> 16;
2345
2346 intra = intra << 16;
2347 inter = value & 0xffff;
2348
2349 if (inter < GEN95_AVC_MAX_LAMBDA) {
2350 inter = 0xf000;
2351 }
2352 *(lambda_table + i * 2 + col) = intra + inter;
2353 }
2354 }
2355 }
2356
2357 static void
2358 gen9_avc_init_brc_const_data(VADriverContextP ctx,
2359 struct encode_state *encode_state,
2360 struct intel_encoder_context *encoder_context)
2361 {
2362 struct i965_driver_data *i965 = i965_driver_data(ctx);
2363 struct encoder_vme_mfc_context * vme_context = (struct encoder_vme_mfc_context *)encoder_context->vme_context;
2364 struct i965_avc_encoder_context * avc_ctx = (struct i965_avc_encoder_context *)vme_context->private_enc_ctx;
2365 struct generic_enc_codec_state * generic_state = (struct generic_enc_codec_state *)vme_context->generic_enc_state;
2366 struct avc_enc_state * avc_state = (struct avc_enc_state *)vme_context->private_enc_state;
2367
2368 struct i965_gpe_resource *gpe_resource = NULL;
2369 unsigned char * data = NULL;
2370 unsigned char * data_tmp = NULL;
2371 unsigned int size = 0;
2372 unsigned int table_idx = 0;
2373 unsigned int block_based_skip_enable = avc_state->block_based_skip_enable;
2374 int i = 0;
2375
2376 struct object_surface *obj_surface;
2377 VAEncSliceParameterBufferH264 * slice_param = avc_state->slice_param[0];
2378 VASurfaceID surface_id;
2379 unsigned int transform_8x8_mode_flag = avc_state->transform_8x8_mode_enable;
2380
2381 gpe_resource = &(avc_ctx->res_brc_const_data_buffer);
2382 assert(gpe_resource);
2383
2384 i965_zero_gpe_resource(gpe_resource);
2385
2386 data = i965_map_gpe_resource(gpe_resource);
2387 assert(data);
2388
2389 table_idx = slice_type_kernel[generic_state->frame_type];
2390
2391 /* Fill surface with QP Adjustment table, Distortion threshold table, MaxFrame threshold table, Distortion QP Adjustment Table*/
2392 size = sizeof(gen9_avc_qp_adjustment_dist_threshold_max_frame_threshold_dist_qp_adjustment_ipb);
2393 memcpy(data, gen9_avc_qp_adjustment_dist_threshold_max_frame_threshold_dist_qp_adjustment_ipb, size * sizeof(unsigned char));
2394
2395 data += size;
2396
2397 /* skip threshold table*/
2398 size = 128;
2399 switch (generic_state->frame_type) {
2400 case SLICE_TYPE_P:
2401 memcpy(data, gen9_avc_skip_value_p[block_based_skip_enable][transform_8x8_mode_flag], size * sizeof(unsigned char));
2402 break;
2403 case SLICE_TYPE_B:
2404 memcpy(data, gen9_avc_skip_value_b[block_based_skip_enable][transform_8x8_mode_flag], size * sizeof(unsigned char));
2405 break;
2406 default:
2407 /*SLICE_TYPE_I,no change */
2408 break;
2409 }
2410
2411 if ((generic_state->frame_type != SLICE_TYPE_I) && avc_state->non_ftq_skip_threshold_lut_input_enable) {
2412 for (i = 0; i < AVC_QP_MAX ; i++) {
2413 *(data + 1 + (i * 2)) = (unsigned char)i965_avc_calc_skip_value(block_based_skip_enable, transform_8x8_mode_flag, avc_state->non_ftq_skip_threshold_lut[i]);
2414 }
2415 }
2416 data += size;
2417
2418 /*fill the qp for ref list*/
2419 size = 32 + 32 + 32 + 160;
2420 memset(data, 0xff, 32);
2421 memset(data + 32 + 32, 0xff, 32);
2422 switch (generic_state->frame_type) {
2423 case SLICE_TYPE_P: {
2424 for (i = 0 ; i < slice_param->num_ref_idx_l0_active_minus1 + 1; i++) {
2425 surface_id = slice_param->RefPicList0[i].picture_id;
2426 obj_surface = SURFACE(surface_id);
2427 if (!obj_surface)
2428 break;
2429 *(data + i) = avc_state->list_ref_idx[0][i];//?
2430 }
2431 }
2432 break;
2433 case SLICE_TYPE_B: {
2434 data = data + 32 + 32;
2435 for (i = 0 ; i < slice_param->num_ref_idx_l1_active_minus1 + 1; i++) {
2436 surface_id = slice_param->RefPicList1[i].picture_id;
2437 obj_surface = SURFACE(surface_id);
2438 if (!obj_surface)
2439 break;
2440 *(data + i) = avc_state->list_ref_idx[1][i];//?
2441 }
2442
2443 data = data - 32 - 32;
2444
2445 for (i = 0 ; i < slice_param->num_ref_idx_l0_active_minus1 + 1; i++) {
2446 surface_id = slice_param->RefPicList0[i].picture_id;
2447 obj_surface = SURFACE(surface_id);
2448 if (!obj_surface)
2449 break;
2450 *(data + i) = avc_state->list_ref_idx[0][i];//?
2451 }
2452 }
2453 break;
2454 default:
2455 /*SLICE_TYPE_I,no change */
2456 break;
2457 }
2458 data += size;
2459
2460 /*mv cost and mode cost*/
2461 size = 1664;
2462 memcpy(data, (unsigned char *)&gen9_avc_mode_mv_cost_table[table_idx][0][0], size * sizeof(unsigned char));
2463
2464 if (avc_state->old_mode_cost_enable) {
2465 data_tmp = data;
2466 for (i = 0; i < AVC_QP_MAX ; i++) {
2467 *(data_tmp + 3) = (unsigned int)gen9_avc_old_intra_mode_cost[i];
2468 data_tmp += 16;
2469 }
2470 }
2471
2472 if (avc_state->ftq_skip_threshold_lut_input_enable) {
2473 for (i = 0; i < AVC_QP_MAX ; i++) {
2474 *(data + (i * 32) + 24) =
2475 *(data + (i * 32) + 25) =
2476 *(data + (i * 32) + 27) =
2477 *(data + (i * 32) + 28) =
2478 *(data + (i * 32) + 29) =
2479 *(data + (i * 32) + 30) =
2480 *(data + (i * 32) + 31) = avc_state->ftq_skip_threshold_lut[i];
2481 }
2482
2483 }
2484 data += size;
2485
2486 /*ref cost*/
2487 size = 128;
2488 memcpy(data, (unsigned char *)&gen9_avc_ref_cost[table_idx][0], size * sizeof(unsigned char));
2489 data += size;
2490
2491 /*scaling factor*/
2492 size = 64;
2493 if (avc_state->adaptive_intra_scaling_enable) {
2494 memcpy(data, (unsigned char *)gen9_avc_adaptive_intra_scaling_factor, size * sizeof(unsigned char));
2495 } else {
2496 memcpy(data, (unsigned char *)gen9_avc_intra_scaling_factor, size * sizeof(unsigned char));
2497 }
2498
2499 if (IS_KBL(i965->intel.device_info) ||
2500 IS_GEN10(i965->intel.device_info) ||
2501 IS_GLK(i965->intel.device_info)) {
2502 data += size;
2503
2504 size = 512;
2505 memcpy(data, (unsigned char *)gen95_avc_lambda_data, size * sizeof(unsigned char));
2506 data += size;
2507
2508 size = 64;
2509 memcpy(data, (unsigned char *)gen95_avc_ftq25, size * sizeof(unsigned char));
2510 }
2511
2512 i965_unmap_gpe_resource(gpe_resource);
2513 }
2514
2515 static void
2516 gen9_avc_init_brc_const_data_old(VADriverContextP ctx,
2517 struct encode_state *encode_state,
2518 struct intel_encoder_context *encoder_context)
2519 {
2520 struct encoder_vme_mfc_context * vme_context = (struct encoder_vme_mfc_context *)encoder_context->vme_context;
2521 struct i965_avc_encoder_context * avc_ctx = (struct i965_avc_encoder_context *)vme_context->private_enc_ctx;
2522 struct generic_enc_codec_state * generic_state = (struct generic_enc_codec_state *)vme_context->generic_enc_state;
2523 struct avc_enc_state * avc_state = (struct avc_enc_state *)vme_context->private_enc_state;
2524
2525 struct i965_gpe_resource *gpe_resource = NULL;
2526 unsigned int * data = NULL;
2527 unsigned int * data_tmp = NULL;
2528 unsigned int size = 0;
2529 unsigned int table_idx = 0;
2530 unsigned int block_based_skip_enable = avc_state->block_based_skip_enable;
2531 unsigned int transform_8x8_mode_flag = avc_state->transform_8x8_mode_enable;
2532 int i = 0;
2533
2534 gpe_resource = &(avc_ctx->res_brc_const_data_buffer);
2535 assert(gpe_resource);
2536
2537 i965_zero_gpe_resource(gpe_resource);
2538
2539 data = i965_map_gpe_resource(gpe_resource);
2540 assert(data);
2541
2542 table_idx = slice_type_kernel[generic_state->frame_type];
2543
2544 /* Fill surface with QP Adjustment table, Distortion threshold table, MaxFrame threshold table, Distortion QP Adjustment Table*/
2545 size = sizeof(gen75_avc_qp_adjustment_dist_threshold_max_frame_threshold_dist_qp_adjustment_ipb);
2546 memcpy(data, gen75_avc_qp_adjustment_dist_threshold_max_frame_threshold_dist_qp_adjustment_ipb, size * sizeof(unsigned char));
2547
2548 data += size;
2549
2550 /* skip threshold table*/
2551 size = 128;
2552 switch (generic_state->frame_type) {
2553 case SLICE_TYPE_P:
2554 memcpy(data, gen9_avc_skip_value_p[block_based_skip_enable][transform_8x8_mode_flag], size * sizeof(unsigned char));
2555 break;
2556 case SLICE_TYPE_B:
2557 memcpy(data, gen9_avc_skip_value_b[block_based_skip_enable][transform_8x8_mode_flag], size * sizeof(unsigned char));
2558 break;
2559 default:
2560 /*SLICE_TYPE_I,no change */
2561 break;
2562 }
2563
2564 if ((generic_state->frame_type != SLICE_TYPE_I) && avc_state->non_ftq_skip_threshold_lut_input_enable) {
2565 for (i = 0; i < AVC_QP_MAX ; i++) {
2566 *(data + 1 + (i * 2)) = (unsigned char)i965_avc_calc_skip_value(block_based_skip_enable, transform_8x8_mode_flag, avc_state->non_ftq_skip_threshold_lut[i]);
2567 }
2568 }
2569 data += size;
2570
2571 /*fill the qp for ref list*/
2572 size = 128;
2573 data += size;
2574 size = 128;
2575 data += size;
2576
2577 /*mv cost and mode cost*/
2578 size = 1664;
2579 memcpy(data, (unsigned char *)&gen75_avc_mode_mv_cost_table[table_idx][0][0], size * sizeof(unsigned char));
2580
2581 if (avc_state->old_mode_cost_enable) {
2582 data_tmp = data;
2583 for (i = 0; i < AVC_QP_MAX ; i++) {
2584 *(data_tmp + 3) = (unsigned int)gen9_avc_old_intra_mode_cost[i];
2585 data_tmp += 16;
2586 }
2587 }
2588
2589 if (avc_state->ftq_skip_threshold_lut_input_enable) {
2590 for (i = 0; i < AVC_QP_MAX ; i++) {
2591 *(data + (i * 32) + 24) =
2592 *(data + (i * 32) + 25) =
2593 *(data + (i * 32) + 27) =
2594 *(data + (i * 32) + 28) =
2595 *(data + (i * 32) + 29) =
2596 *(data + (i * 32) + 30) =
2597 *(data + (i * 32) + 31) = avc_state->ftq_skip_threshold_lut[i];
2598 }
2599
2600 }
2601 data += size;
2602
2603 /*ref cost*/
2604 size = 128;
2605 memcpy(data, (unsigned char *)&gen9_avc_ref_cost[table_idx][0], size * sizeof(unsigned char));
2606
2607 i965_unmap_gpe_resource(gpe_resource);
2608 }
2609 static void
2610 gen9_avc_set_curbe_brc_init_reset(VADriverContextP ctx,
2611 struct encode_state *encode_state,
2612 struct i965_gpe_context *gpe_context,
2613 struct intel_encoder_context *encoder_context,
2614 void * param)
2615 {
2616 gen9_avc_brc_init_reset_curbe_data *cmd;
2617 struct encoder_vme_mfc_context * vme_context = (struct encoder_vme_mfc_context *)encoder_context->vme_context;
2618 struct generic_enc_codec_state * generic_state = (struct generic_enc_codec_state *)vme_context->generic_enc_state;
2619 struct avc_enc_state * avc_state = (struct avc_enc_state *)vme_context->private_enc_state;
2620 double input_bits_per_frame = 0;
2621 double bps_ratio = 0;
2622 VAEncSequenceParameterBufferH264 * seq_param = avc_state->seq_param;
2623 struct avc_param common_param;
2624
2625 cmd = i965_gpe_context_map_curbe(gpe_context);
2626
2627 if (!cmd)
2628 return;
2629
2630 memcpy(cmd, &gen9_avc_brc_init_reset_curbe_init_data, sizeof(gen9_avc_brc_init_reset_curbe_data));
2631
2632 memset(&common_param, 0, sizeof(common_param));
2633 common_param.frame_width_in_pixel = generic_state->frame_width_in_pixel;
2634 common_param.frame_height_in_pixel = generic_state->frame_height_in_pixel;
2635 common_param.frame_width_in_mbs = generic_state->frame_width_in_mbs;
2636 common_param.frame_height_in_mbs = generic_state->frame_height_in_mbs;
2637 common_param.frames_per_100s = generic_state->frames_per_100s;
2638 common_param.vbv_buffer_size_in_bit = generic_state->vbv_buffer_size_in_bit;
2639 common_param.target_bit_rate = generic_state->target_bit_rate;
2640
2641 cmd->dw0.profile_level_max_frame = i965_avc_get_profile_level_max_frame(&common_param, seq_param->level_idc);
2642 cmd->dw1.init_buf_full_in_bits = generic_state->init_vbv_buffer_fullness_in_bit;
2643 cmd->dw2.buf_size_in_bits = generic_state->vbv_buffer_size_in_bit;
2644 cmd->dw3.average_bit_rate = generic_state->target_bit_rate * 1000;
2645 cmd->dw4.max_bit_rate = generic_state->max_bit_rate * 1000;
2646 cmd->dw8.gop_p = (generic_state->gop_ref_distance) ? ((generic_state->gop_size - 1) / generic_state->gop_ref_distance) : 0;
2647 cmd->dw9.gop_b = (generic_state->gop_size - 1 - cmd->dw8.gop_p);
2648 cmd->dw9.frame_width_in_bytes = generic_state->frame_width_in_pixel;
2649 cmd->dw10.frame_height_in_bytes = generic_state->frame_height_in_pixel;
2650 cmd->dw12.no_slices = avc_state->slice_num;
2651
2652 //VUI
2653 if (seq_param->vui_parameters_present_flag && generic_state->internal_rate_mode != INTEL_BRC_AVBR) {
2654 if (generic_state->internal_rate_mode == VA_RC_CBR) {
2655 cmd->dw3.average_bit_rate = cmd->dw4.max_bit_rate;
2656
2657 }
2658
2659 }
2660 cmd->dw6.frame_rate_m = generic_state->frames_per_100s;
2661 cmd->dw7.frame_rate_d = 100;
2662 cmd->dw8.brc_flag = 0;
2663 cmd->dw8.brc_flag |= (generic_state->mb_brc_enabled) ? 0 : 0x8000;
2664
2665
2666 if (generic_state->internal_rate_mode == VA_RC_CBR) {
2667 //CBR
2668 cmd->dw4.max_bit_rate = cmd->dw3.average_bit_rate;
2669 cmd->dw8.brc_flag = cmd->dw8.brc_flag | INTEL_ENCODE_BRCINIT_ISCBR;
2670
2671 } else if (generic_state->internal_rate_mode == VA_RC_VBR) {
2672 //VBR
2673 if (cmd->dw4.max_bit_rate < cmd->dw3.average_bit_rate) {
2674 cmd->dw4.max_bit_rate = cmd->dw3.average_bit_rate << 1;
2675 }
2676 cmd->dw8.brc_flag = cmd->dw8.brc_flag | INTEL_ENCODE_BRCINIT_ISVBR;
2677
2678 } else if (generic_state->internal_rate_mode == INTEL_BRC_AVBR) {
2679 //AVBR
2680 cmd->dw4.max_bit_rate = cmd->dw3.average_bit_rate;
2681 cmd->dw8.brc_flag = cmd->dw8.brc_flag | INTEL_ENCODE_BRCINIT_ISAVBR;
2682
2683 }
2684 //igonre icq/vcm/qvbr
2685
2686 cmd->dw10.avbr_accuracy = generic_state->avbr_curracy;
2687 cmd->dw11.avbr_convergence = generic_state->avbr_convergence;
2688
2689 //frame bits
2690 input_bits_per_frame = (double)(cmd->dw4.max_bit_rate) * (double)(cmd->dw7.frame_rate_d) / (double)(cmd->dw6.frame_rate_m);
2691
2692 if (cmd->dw2.buf_size_in_bits == 0) {
2693 cmd->dw2.buf_size_in_bits = (unsigned int)(input_bits_per_frame * 4);
2694 }
2695
2696 if (cmd->dw1.init_buf_full_in_bits == 0) {
2697 cmd->dw1.init_buf_full_in_bits = cmd->dw2.buf_size_in_bits * 7 / 8;
2698 }
2699 if (cmd->dw1.init_buf_full_in_bits < (unsigned int)(input_bits_per_frame * 2)) {
2700 cmd->dw1.init_buf_full_in_bits = (unsigned int)(input_bits_per_frame * 2);
2701 }
2702 if (cmd->dw1.init_buf_full_in_bits > cmd->dw2.buf_size_in_bits) {
2703 cmd->dw1.init_buf_full_in_bits = cmd->dw2.buf_size_in_bits;
2704 }
2705
2706 //AVBR
2707 if (generic_state->internal_rate_mode == INTEL_BRC_AVBR) {
2708 cmd->dw2.buf_size_in_bits = 2 * generic_state->target_bit_rate * 1000;
2709 cmd->dw1.init_buf_full_in_bits = (unsigned int)(3 * cmd->dw2.buf_size_in_bits / 4);
2710
2711 }
2712
2713 bps_ratio = input_bits_per_frame / (cmd->dw2.buf_size_in_bits / 30.0);
2714 bps_ratio = (bps_ratio < 0.1) ? 0.1 : (bps_ratio > 3.5) ? 3.5 : bps_ratio;
2715
2716
2717 cmd->dw16.deviation_threshold_0_pand_b = (unsigned int)(-50 * pow(0.90, bps_ratio));
2718 cmd->dw16.deviation_threshold_1_pand_b = (unsigned int)(-50 * pow(0.66, bps_ratio));
2719 cmd->dw16.deviation_threshold_2_pand_b = (unsigned int)(-50 * pow(0.46, bps_ratio));
2720 cmd->dw16.deviation_threshold_3_pand_b = (unsigned int)(-50 * pow(0.3, bps_ratio));
2721 cmd->dw17.deviation_threshold_4_pand_b = (unsigned int)(50 * pow(0.3, bps_ratio));
2722 cmd->dw17.deviation_threshold_5_pand_b = (unsigned int)(50 * pow(0.46, bps_ratio));
2723 cmd->dw17.deviation_threshold_6_pand_b = (unsigned int)(50 * pow(0.7, bps_ratio));
2724 cmd->dw17.deviation_threshold_7_pand_b = (unsigned int)(50 * pow(0.9, bps_ratio));
2725 cmd->dw18.deviation_threshold_0_vbr = (unsigned int)(-50 * pow(0.9, bps_ratio));
2726 cmd->dw18.deviation_threshold_1_vbr = (unsigned int)(-50 * pow(0.7, bps_ratio));
2727 cmd->dw18.deviation_threshold_2_vbr = (unsigned int)(-50 * pow(0.5, bps_ratio));
2728 cmd->dw18.deviation_threshold_3_vbr = (unsigned int)(-50 * pow(0.3, bps_ratio));
2729 cmd->dw19.deviation_threshold_4_vbr = (unsigned int)(100 * pow(0.4, bps_ratio));
2730 cmd->dw19.deviation_threshold_5_vbr = (unsigned int)(100 * pow(0.5, bps_ratio));
2731 cmd->dw19.deviation_threshold_6_vbr = (unsigned int)(100 * pow(0.75, bps_ratio));
2732 cmd->dw19.deviation_threshold_7_vbr = (unsigned int)(100 * pow(0.9, bps_ratio));
2733 cmd->dw20.deviation_threshold_0_i = (unsigned int)(-50 * pow(0.8, bps_ratio));
2734 cmd->dw20.deviation_threshold_1_i = (unsigned int)(-50 * pow(0.6, bps_ratio));
2735 cmd->dw20.deviation_threshold_2_i = (unsigned int)(-50 * pow(0.34, bps_ratio));
2736 cmd->dw20.deviation_threshold_3_i = (unsigned int)(-50 * pow(0.2, bps_ratio));
2737 cmd->dw21.deviation_threshold_4_i = (unsigned int)(50 * pow(0.2, bps_ratio));
2738 cmd->dw21.deviation_threshold_5_i = (unsigned int)(50 * pow(0.4, bps_ratio));
2739 cmd->dw21.deviation_threshold_6_i = (unsigned int)(50 * pow(0.66, bps_ratio));
2740 cmd->dw21.deviation_threshold_7_i = (unsigned int)(50 * pow(0.9, bps_ratio));
2741
2742 cmd->dw22.sliding_window_size = generic_state->frames_per_window_size;
2743
2744 i965_gpe_context_unmap_curbe(gpe_context);
2745
2746 return;
2747 }
2748
2749 static void
2750 gen9_avc_send_surface_brc_init_reset(VADriverContextP ctx,
2751 struct encode_state *encode_state,
2752 struct i965_gpe_context *gpe_context,
2753 struct intel_encoder_context *encoder_context,
2754 void * param_mbenc)
2755 {
2756 struct encoder_vme_mfc_context * vme_context = (struct encoder_vme_mfc_context *)encoder_context->vme_context;
2757 struct i965_avc_encoder_context * avc_ctx = (struct i965_avc_encoder_context *)vme_context->private_enc_ctx;
2758
2759 i965_add_buffer_gpe_surface(ctx,
2760 gpe_context,
2761 &avc_ctx->res_brc_history_buffer,
2762 0,
2763 avc_ctx->res_brc_history_buffer.size,
2764 0,
2765 GEN9_AVC_BRC_INIT_RESET_HISTORY_INDEX);
2766
2767 i965_add_buffer_2d_gpe_surface(ctx,
2768 gpe_context,
2769 &avc_ctx->res_brc_dist_data_surface,
2770 1,
2771 I965_SURFACEFORMAT_R8_UNORM,
2772 GEN9_AVC_BRC_INIT_RESET_DISTORTION_INDEX);
2773
2774 return;
2775 }
2776
2777 static VAStatus
2778 gen9_avc_kernel_brc_init_reset(VADriverContextP ctx,
2779 struct encode_state *encode_state,
2780 struct intel_encoder_context *encoder_context)
2781 {
2782 struct i965_driver_data *i965 = i965_driver_data(ctx);
2783 struct i965_gpe_table *gpe = &i965->gpe_table;
2784 struct encoder_vme_mfc_context * vme_context = (struct encoder_vme_mfc_context *)encoder_context->vme_context;
2785 struct i965_avc_encoder_context * avc_ctx = (struct i965_avc_encoder_context *)vme_context->private_enc_ctx;
2786 struct generic_enc_codec_state * generic_state = (struct generic_enc_codec_state *)vme_context->generic_enc_state;
2787 struct generic_encoder_context * generic_ctx = (struct generic_encoder_context *)vme_context->generic_enc_ctx;
2788
2789 struct i965_gpe_context *gpe_context;
2790 struct gpe_media_object_parameter media_object_param;
2791 struct gpe_media_object_inline_data media_object_inline_data;
2792 int media_function = 0;
2793 int kernel_idx = GEN9_AVC_KERNEL_BRC_INIT;
2794
2795 media_function = INTEL_MEDIA_STATE_BRC_INIT_RESET;
2796
2797 if (generic_state->brc_inited)
2798 kernel_idx = GEN9_AVC_KERNEL_BRC_RESET;
2799
2800 gpe_context = &(avc_ctx->context_brc.gpe_contexts[kernel_idx]);
2801
2802 gpe->context_init(ctx, gpe_context);
2803 gpe->reset_binding_table(ctx, gpe_context);
2804
2805 generic_ctx->pfn_set_curbe_brc_init_reset(ctx, encode_state, gpe_context, encoder_context, NULL);
2806
2807 generic_ctx->pfn_send_brc_init_reset_surface(ctx, encode_state, gpe_context, encoder_context, NULL);
2808
2809 gpe->setup_interface_data(ctx, gpe_context);
2810
2811 memset(&media_object_param, 0, sizeof(media_object_param));
2812 memset(&media_object_inline_data, 0, sizeof(media_object_inline_data));
2813 media_object_param.pinline_data = &media_object_inline_data;
2814 media_object_param.inline_size = sizeof(media_object_inline_data);
2815
2816 gen9_avc_run_kernel_media_object(ctx, encoder_context,
2817 gpe_context,
2818 media_function,
2819 &media_object_param);
2820
2821 return VA_STATUS_SUCCESS;
2822 }
2823
2824 static void
2825 gen9_avc_set_curbe_brc_frame_update(VADriverContextP ctx,
2826 struct encode_state *encode_state,
2827 struct i965_gpe_context *gpe_context,
2828 struct intel_encoder_context *encoder_context,
2829 void * param)
2830 {
2831 gen9_avc_frame_brc_update_curbe_data *cmd;
2832 struct encoder_vme_mfc_context * vme_context = (struct encoder_vme_mfc_context *)encoder_context->vme_context;
2833 struct generic_enc_codec_state * generic_state = (struct generic_enc_codec_state *)vme_context->generic_enc_state;
2834 struct avc_enc_state * avc_state = (struct avc_enc_state *)vme_context->private_enc_state;
2835 struct object_surface *obj_surface;
2836 struct gen9_surface_avc *avc_priv_surface;
2837 struct avc_param common_param;
2838 VAEncSequenceParameterBufferH264 * seq_param = avc_state->seq_param;
2839
2840 obj_surface = encode_state->reconstructed_object;
2841
2842 if (!obj_surface || !obj_surface->private_data)
2843 return;
2844 avc_priv_surface = obj_surface->private_data;
2845
2846 cmd = i965_gpe_context_map_curbe(gpe_context);
2847
2848 if (!cmd)
2849 return;
2850
2851 memcpy(cmd, &gen9_avc_frame_brc_update_curbe_init_data, sizeof(gen9_avc_frame_brc_update_curbe_data));
2852
2853 cmd->dw5.target_size_flag = 0 ;
2854 if (generic_state->brc_init_current_target_buf_full_in_bits > (double)generic_state->brc_init_reset_buf_size_in_bits) {
2855 /*overflow*/
2856 generic_state->brc_init_current_target_buf_full_in_bits -= (double)generic_state->brc_init_reset_buf_size_in_bits;
2857 cmd->dw5.target_size_flag = 1 ;
2858 }
2859
2860 if (generic_state->skip_frame_enbale) {
2861 cmd->dw6.num_skip_frames = generic_state->num_skip_frames ;
2862 cmd->dw7.size_skip_frames = generic_state->size_skip_frames;
2863
2864 generic_state->brc_init_current_target_buf_full_in_bits += generic_state->brc_init_reset_input_bits_per_frame * generic_state->num_skip_frames;
2865
2866 }
2867 cmd->dw0.target_size = (unsigned int)generic_state->brc_init_current_target_buf_full_in_bits ;
2868 cmd->dw1.frame_number = generic_state->seq_frame_number ;
2869 cmd->dw2.size_of_pic_headers = generic_state->herder_bytes_inserted << 3 ;
2870 cmd->dw5.cur_frame_type = generic_state->frame_type ;
2871 cmd->dw5.brc_flag = 0 ;
2872 cmd->dw5.brc_flag |= (avc_priv_surface->is_as_ref) ? INTEL_ENCODE_BRCUPDATE_IS_REFERENCE : 0 ;
2873
2874 if (avc_state->multi_pre_enable) {
2875 cmd->dw5.brc_flag |= INTEL_ENCODE_BRCUPDATE_IS_ACTUALQP ;
2876 cmd->dw14.qp_index_of_cur_pic = avc_priv_surface->frame_idx ; //do not know this. use -1
2877 }
2878
2879 cmd->dw5.max_num_paks = generic_state->num_pak_passes ;
2880 if (avc_state->min_max_qp_enable) {
2881 switch (generic_state->frame_type) {
2882 case SLICE_TYPE_I:
2883 cmd->dw6.minimum_qp = avc_state->min_qp_i ;
2884 cmd->dw6.maximum_qp = avc_state->max_qp_i ;
2885 break;
2886 case SLICE_TYPE_P:
2887 cmd->dw6.minimum_qp = avc_state->min_qp_p ;
2888 cmd->dw6.maximum_qp = avc_state->max_qp_p ;
2889 break;
2890 case SLICE_TYPE_B:
2891 cmd->dw6.minimum_qp = avc_state->min_qp_b ;
2892 cmd->dw6.maximum_qp = avc_state->max_qp_b ;
2893 break;
2894 }
2895 } else {
2896 cmd->dw6.minimum_qp = 0 ;
2897 cmd->dw6.maximum_qp = 0 ;
2898 }
2899 cmd->dw6.enable_force_skip = avc_state->enable_force_skip ;
2900 cmd->dw6.enable_sliding_window = 0 ;
2901
2902 generic_state->brc_init_current_target_buf_full_in_bits += generic_state->brc_init_reset_input_bits_per_frame;
2903
2904 if (generic_state->internal_rate_mode == INTEL_BRC_AVBR) {
2905 cmd->dw3.start_gadj_frame0 = (unsigned int)((10 * generic_state->avbr_convergence) / (double)150);
2906 cmd->dw3.start_gadj_frame1 = (unsigned int)((50 * generic_state->avbr_convergence) / (double)150);
2907 cmd->dw4.start_gadj_frame2 = (unsigned int)((100 * generic_state->avbr_convergence) / (double)150);
2908 cmd->dw4.start_gadj_frame3 = (unsigned int)((150 * generic_state->avbr_convergence) / (double)150);
2909 cmd->dw11.g_rate_ratio_threshold_0 = (unsigned int)((100 - (generic_state->avbr_curracy / (double)30) * (100 - 40)));
2910 cmd->dw11.g_rate_ratio_threshold_1 = (unsigned int)((100 - (generic_state->avbr_curracy / (double)30) * (100 - 75)));
2911 cmd->dw12.g_rate_ratio_threshold_2 = (unsigned int)((100 - (generic_state->avbr_curracy / (double)30) * (100 - 97)));
2912 cmd->dw12.g_rate_ratio_threshold_3 = (unsigned int)((100 + (generic_state->avbr_curracy / (double)30) * (103 - 100)));
2913 cmd->dw12.g_rate_ratio_threshold_4 = (unsigned int)((100 + (generic_state->avbr_curracy / (double)30) * (125 - 100)));
2914 cmd->dw12.g_rate_ratio_threshold_5 = (unsigned int)((100 + (generic_state->avbr_curracy / (double)30) * (160 - 100)));
2915
2916 }
2917 cmd->dw15.enable_roi = generic_state->brc_roi_enable ;
2918
2919 memset(&common_param, 0, sizeof(common_param));
2920 common_param.frame_width_in_pixel = generic_state->frame_width_in_pixel;
2921 common_param.frame_height_in_pixel = generic_state->frame_height_in_pixel;
2922 common_param.frame_width_in_mbs = generic_state->frame_width_in_mbs;
2923 common_param.frame_height_in_mbs = generic_state->frame_height_in_mbs;
2924 common_param.frames_per_100s = generic_state->frames_per_100s;
2925 common_param.vbv_buffer_size_in_bit = generic_state->vbv_buffer_size_in_bit;
2926 common_param.target_bit_rate = generic_state->target_bit_rate;
2927
2928 cmd->dw19.user_max_frame = i965_avc_get_profile_level_max_frame(&common_param, seq_param->level_idc);
2929 i965_gpe_context_unmap_curbe(gpe_context);
2930
2931 return;
2932 }
2933
2934 static void
2935 gen9_avc_send_surface_brc_frame_update(VADriverContextP ctx,
2936 struct encode_state *encode_state,
2937 struct i965_gpe_context *gpe_context,
2938 struct intel_encoder_context *encoder_context,
2939 void * param_brc)
2940 {
2941 struct i965_driver_data *i965 = i965_driver_data(ctx);
2942 struct encoder_vme_mfc_context * vme_context = (struct encoder_vme_mfc_context *)encoder_context->vme_context;
2943 struct i965_avc_encoder_context * avc_ctx = (struct i965_avc_encoder_context *)vme_context->private_enc_ctx;
2944 struct brc_param * param = (struct brc_param *)param_brc ;
2945 struct i965_gpe_context * gpe_context_mbenc = param->gpe_context_mbenc;
2946 struct avc_enc_state * avc_state = (struct avc_enc_state *)vme_context->private_enc_state;
2947 unsigned char is_g95 = 0;
2948
2949 if (IS_SKL(i965->intel.device_info) ||
2950 IS_BXT(i965->intel.device_info) ||
2951 IS_GEN8(i965->intel.device_info))
2952 is_g95 = 0;
2953 else if (IS_KBL(i965->intel.device_info) ||
2954 IS_GEN10(i965->intel.device_info) ||
2955 IS_GLK(i965->intel.device_info))
2956 is_g95 = 1;
2957
2958 /* brc history buffer*/
2959 i965_add_buffer_gpe_surface(ctx,
2960 gpe_context,
2961 &avc_ctx->res_brc_history_buffer,
2962 0,
2963 avc_ctx->res_brc_history_buffer.size,
2964 0,
2965 (is_g95 ? GEN95_AVC_FRAME_BRC_UPDATE_HISTORY_INDEX : GEN9_AVC_FRAME_BRC_UPDATE_HISTORY_INDEX));
2966
2967 /* previous pak buffer*/
2968 i965_add_buffer_gpe_surface(ctx,
2969 gpe_context,
2970 &avc_ctx->res_brc_pre_pak_statistics_output_buffer,
2971 0,
2972 avc_ctx->res_brc_pre_pak_statistics_output_buffer.size,
2973 0,
2974 (is_g95 ? GEN95_AVC_FRAME_BRC_UPDATE_PAK_STATISTICS_OUTPUT_INDEX : GEN9_AVC_FRAME_BRC_UPDATE_PAK_STATISTICS_OUTPUT_INDEX));
2975
2976 /* image state command buffer read only*/
2977 i965_add_buffer_gpe_surface(ctx,
2978 gpe_context,
2979 &avc_ctx->res_brc_image_state_read_buffer,
2980 0,
2981 avc_ctx->res_brc_image_state_read_buffer.size,
2982 0,
2983 (is_g95 ? GEN95_AVC_FRAME_BRC_UPDATE_IMAGE_STATE_READ_INDEX : GEN9_AVC_FRAME_BRC_UPDATE_IMAGE_STATE_READ_INDEX));
2984
2985 /* image state command buffer write only*/
2986 i965_add_buffer_gpe_surface(ctx,
2987 gpe_context,
2988 &avc_ctx->res_brc_image_state_write_buffer,
2989 0,
2990 avc_ctx->res_brc_image_state_write_buffer.size,
2991 0,
2992 (is_g95 ? GEN95_AVC_FRAME_BRC_UPDATE_IMAGE_STATE_WRITE_INDEX : GEN9_AVC_FRAME_BRC_UPDATE_IMAGE_STATE_WRITE_INDEX));
2993
2994 if (avc_state->mbenc_brc_buffer_size > 0) {
2995 i965_add_buffer_gpe_surface(ctx,
2996 gpe_context,
2997 &(avc_ctx->res_mbenc_brc_buffer),
2998 0,
2999 avc_ctx->res_mbenc_brc_buffer.size,
3000 0,
3001 GEN95_AVC_FRAME_BRC_UPDATE_MBENC_CURBE_WRITE_INDEX);
3002 } else {
3003 /* Mbenc curbe input buffer */
3004 gen9_add_dri_buffer_gpe_surface(ctx,
3005 gpe_context,
3006 gpe_context_mbenc->dynamic_state.bo,
3007 0,
3008 ALIGN(gpe_context_mbenc->curbe.length, 64),
3009 gpe_context_mbenc->curbe.offset,
3010 GEN9_AVC_FRAME_BRC_UPDATE_MBENC_CURBE_READ_INDEX);
3011 /* Mbenc curbe output buffer */
3012 gen9_add_dri_buffer_gpe_surface(ctx,
3013 gpe_context,
3014 gpe_context_mbenc->dynamic_state.bo,
3015 0,
3016 ALIGN(gpe_context_mbenc->curbe.length, 64),
3017 gpe_context_mbenc->curbe.offset,
3018 GEN9_AVC_FRAME_BRC_UPDATE_MBENC_CURBE_WRITE_INDEX);
3019 }
3020
3021 /* AVC_ME Distortion 2D surface buffer,input/output. is it res_brc_dist_data_surface*/
3022 i965_add_buffer_2d_gpe_surface(ctx,
3023 gpe_context,
3024 &avc_ctx->res_brc_dist_data_surface,
3025 1,
3026 I965_SURFACEFORMAT_R8_UNORM,
3027 (is_g95 ? GEN95_AVC_FRAME_BRC_UPDATE_DISTORTION_INDEX : GEN9_AVC_FRAME_BRC_UPDATE_DISTORTION_INDEX));
3028
3029 /* BRC const data 2D surface buffer */
3030 i965_add_buffer_2d_gpe_surface(ctx,
3031 gpe_context,
3032 &avc_ctx->res_brc_const_data_buffer,
3033 1,
3034 I965_SURFACEFORMAT_R8_UNORM,
3035 (is_g95 ? GEN95_AVC_FRAME_BRC_UPDATE_CONSTANT_DATA_INDEX : GEN9_AVC_FRAME_BRC_UPDATE_CONSTANT_DATA_INDEX));
3036
3037 /* MB statistical data surface*/
3038 if (!IS_GEN8(i965->intel.device_info)) {
3039 i965_add_buffer_gpe_surface(ctx,
3040 gpe_context,
3041 &avc_ctx->res_mb_status_buffer,
3042 0,
3043 avc_ctx->res_mb_status_buffer.size,
3044 0,
3045 (is_g95 ? GEN95_AVC_FRAME_BRC_UPDATE_MB_STATUS_INDEX : GEN9_AVC_FRAME_BRC_UPDATE_MB_STATUS_INDEX));
3046 } else {
3047 i965_add_buffer_2d_gpe_surface(ctx,
3048 gpe_context,
3049 &avc_ctx->res_mbbrc_mb_qp_data_surface,
3050 1,
3051 I965_SURFACEFORMAT_R8_UNORM,
3052 GEN9_AVC_FRAME_BRC_UPDATE_MB_STATUS_INDEX);
3053 }
3054 return;
3055 }
3056
3057 static VAStatus
3058 gen9_avc_kernel_brc_frame_update(VADriverContextP ctx,
3059 struct encode_state *encode_state,
3060 struct intel_encoder_context *encoder_context)
3061
3062 {
3063 struct i965_driver_data *i965 = i965_driver_data(ctx);
3064 struct i965_gpe_table *gpe = &i965->gpe_table;
3065 struct encoder_vme_mfc_context * vme_context = (struct encoder_vme_mfc_context *)encoder_context->vme_context;
3066 struct generic_encoder_context * generic_ctx = (struct generic_encoder_context *)vme_context->generic_enc_ctx;
3067 struct i965_avc_encoder_context * avc_ctx = (struct i965_avc_encoder_context *)vme_context->private_enc_ctx;
3068 struct generic_enc_codec_state * generic_state = (struct generic_enc_codec_state *)vme_context->generic_enc_state;
3069 struct avc_enc_state * avc_state = (struct avc_enc_state *)vme_context->private_enc_state;
3070
3071 struct i965_gpe_context *gpe_context = NULL;
3072 struct gpe_media_object_parameter media_object_param;
3073 struct gpe_media_object_inline_data media_object_inline_data;
3074 int media_function = 0;
3075 int kernel_idx = 0;
3076 unsigned int mb_const_data_buffer_in_use, mb_qp_buffer_in_use;
3077 unsigned int brc_enabled = 0;
3078 unsigned int roi_enable = (generic_state->num_roi > 0) ? 1 : 0;
3079 unsigned int dirty_roi_enable = ((generic_state->dirty_num_roi > 0) && (generic_state->frame_type == SLICE_TYPE_P) && (0));
3080
3081 /* the following set the mbenc curbe*/
3082 struct mbenc_param curbe_mbenc_param ;
3083 struct brc_param curbe_brc_param ;
3084
3085 mb_const_data_buffer_in_use =
3086 generic_state->mb_brc_enabled ||
3087 roi_enable ||
3088 dirty_roi_enable ||
3089 avc_state->mb_qp_data_enable ||
3090 avc_state->rolling_intra_refresh_enable;
3091 mb_qp_buffer_in_use =
3092 generic_state->mb_brc_enabled ||
3093 generic_state->brc_roi_enable ||
3094 avc_state->mb_qp_data_enable;
3095
3096 switch (generic_state->kernel_mode) {
3097 case INTEL_ENC_KERNEL_NORMAL : {
3098 kernel_idx = MBENC_KERNEL_BASE + GEN9_AVC_KERNEL_MBENC_NORMAL_I;
3099 break;
3100 }
3101 case INTEL_ENC_KERNEL_PERFORMANCE : {
3102 kernel_idx = MBENC_KERNEL_BASE + GEN9_AVC_KERNEL_MBENC_PERFORMANCE_I;
3103 break;
3104 }
3105 case INTEL_ENC_KERNEL_QUALITY : {
3106 kernel_idx = MBENC_KERNEL_BASE + GEN9_AVC_KERNEL_MBENC_QUALITY_I;
3107 break;
3108 }
3109 default:
3110 assert(0);
3111
3112 }
3113
3114 if (generic_state->frame_type == SLICE_TYPE_P) {
3115 kernel_idx += 1;
3116 } else if (generic_state->frame_type == SLICE_TYPE_B) {
3117 kernel_idx += 2;
3118 }
3119
3120 gpe_context = &(avc_ctx->context_mbenc.gpe_contexts[kernel_idx]);
3121 gpe->context_init(ctx, gpe_context);
3122
3123 memset(&curbe_mbenc_param, 0, sizeof(struct mbenc_param));
3124
3125 curbe_mbenc_param.mb_const_data_buffer_in_use = mb_const_data_buffer_in_use;
3126 curbe_mbenc_param.mb_qp_buffer_in_use = mb_qp_buffer_in_use;
3127 curbe_mbenc_param.mbenc_i_frame_dist_in_use = 0;
3128 curbe_mbenc_param.brc_enabled = brc_enabled;
3129 curbe_mbenc_param.roi_enabled = roi_enable;
3130
3131 /* set curbe mbenc*/
3132 generic_ctx->pfn_set_curbe_mbenc(ctx, encode_state, gpe_context, encoder_context, &curbe_mbenc_param);
3133
3134 // gen95 set curbe out of the brc. gen9 do it here
3135 avc_state->mbenc_curbe_set_in_brc_update = !avc_state->decouple_mbenc_curbe_from_brc_enable;
3136 /*begin brc frame update*/
3137 memset(&curbe_brc_param, 0, sizeof(struct brc_param));
3138 curbe_brc_param.gpe_context_mbenc = gpe_context;
3139 media_function = INTEL_MEDIA_STATE_BRC_UPDATE;
3140 kernel_idx = GEN9_AVC_KERNEL_BRC_FRAME_UPDATE;
3141 gpe_context = &(avc_ctx->context_brc.gpe_contexts[kernel_idx]);
3142 curbe_brc_param.gpe_context_brc_frame_update = gpe_context;
3143
3144 gpe->context_init(ctx, gpe_context);
3145 gpe->reset_binding_table(ctx, gpe_context);
3146 /*brc copy ignored*/
3147
3148 /* set curbe frame update*/
3149 generic_ctx->pfn_set_curbe_brc_frame_update(ctx, encode_state, gpe_context, encoder_context, &curbe_brc_param);
3150
3151 /* load brc constant data, is it same as mbenc mb brc constant data? no.*/
3152 if (avc_state->multi_pre_enable) {
3153 gen9_avc_init_brc_const_data(ctx, encode_state, encoder_context);
3154 } else {
3155 gen9_avc_init_brc_const_data_old(ctx, encode_state, encoder_context);
3156 }
3157 /* image state construct*/
3158 if (IS_GEN8(i965->intel.device_info)) {
3159 gen8_avc_set_image_state(ctx, encode_state, encoder_context, &(avc_ctx->res_brc_image_state_read_buffer));
3160 } else {
3161 gen9_avc_set_image_state(ctx, encode_state, encoder_context, &(avc_ctx->res_brc_image_state_read_buffer));
3162 }
3163 /* set surface frame mbenc*/
3164 generic_ctx->pfn_send_brc_frame_update_surface(ctx, encode_state, gpe_context, encoder_context, &curbe_brc_param);
3165
3166
3167 gpe->setup_interface_data(ctx, gpe_context);
3168
3169 memset(&media_object_param, 0, sizeof(media_object_param));
3170 memset(&media_object_inline_data, 0, sizeof(media_object_inline_data));
3171 media_object_param.pinline_data = &media_object_inline_data;
3172 media_object_param.inline_size = sizeof(media_object_inline_data);
3173
3174 gen9_avc_run_kernel_media_object(ctx, encoder_context,
3175 gpe_context,
3176 media_function,
3177 &media_object_param);
3178
3179 return VA_STATUS_SUCCESS;
3180 }
3181
3182 static void
3183 gen9_avc_set_curbe_brc_mb_update(VADriverContextP ctx,
3184 struct encode_state *encode_state,
3185 struct i965_gpe_context *gpe_context,
3186 struct intel_encoder_context *encoder_context,
3187 void * param)
3188 {
3189 gen9_avc_mb_brc_curbe_data *cmd;
3190 struct encoder_vme_mfc_context * vme_context = (struct encoder_vme_mfc_context *)encoder_context->vme_context;
3191 struct generic_enc_codec_state * generic_state = (struct generic_enc_codec_state *)vme_context->generic_enc_state;
3192
3193 cmd = i965_gpe_context_map_curbe(gpe_context);
3194
3195 if (!cmd)
3196 return;
3197
3198 memset(cmd, 0, sizeof(gen9_avc_mb_brc_curbe_data));
3199
3200 cmd->dw0.cur_frame_type = generic_state->frame_type;
3201 if (generic_state->brc_roi_enable) {
3202 cmd->dw0.enable_roi = 1;
3203 } else {
3204 cmd->dw0.enable_roi = 0;
3205 }
3206
3207 i965_gpe_context_unmap_curbe(gpe_context);
3208
3209 return;
3210 }
3211
3212 static void
3213 gen9_avc_send_surface_brc_mb_update(VADriverContextP ctx,
3214 struct encode_state *encode_state,
3215 struct i965_gpe_context *gpe_context,
3216 struct intel_encoder_context *encoder_context,
3217 void * param_mbenc)
3218 {
3219 struct encoder_vme_mfc_context * vme_context = (struct encoder_vme_mfc_context *)encoder_context->vme_context;
3220 struct i965_avc_encoder_context * avc_ctx = (struct i965_avc_encoder_context *)vme_context->private_enc_ctx;
3221 struct generic_enc_codec_state * generic_state = (struct generic_enc_codec_state *)vme_context->generic_enc_state;
3222
3223 /* brc history buffer*/
3224 i965_add_buffer_gpe_surface(ctx,
3225 gpe_context,
3226 &avc_ctx->res_brc_history_buffer,
3227 0,
3228 avc_ctx->res_brc_history_buffer.size,
3229 0,
3230 GEN9_AVC_MB_BRC_UPDATE_HISTORY_INDEX);
3231
3232 /* MB qp data buffer is it same as res_mbbrc_mb_qp_data_surface*/
3233 if (generic_state->mb_brc_enabled) {
3234 i965_add_buffer_2d_gpe_surface(ctx,
3235 gpe_context,
3236 &avc_ctx->res_mbbrc_mb_qp_data_surface,
3237 1,
3238 I965_SURFACEFORMAT_R8_UNORM,
3239 GEN9_AVC_MB_BRC_UPDATE_MB_QP_INDEX);
3240
3241 }
3242
3243 /* BRC roi feature*/
3244 if (generic_state->brc_roi_enable) {
3245 i965_add_buffer_gpe_surface(ctx,
3246 gpe_context,
3247 &avc_ctx->res_mbbrc_roi_surface,
3248 0,
3249 avc_ctx->res_mbbrc_roi_surface.size,
3250 0,
3251 GEN9_AVC_MB_BRC_UPDATE_ROI_INDEX);
3252
3253 }
3254
3255 /* MB statistical data surface*/
3256 i965_add_buffer_gpe_surface(ctx,
3257 gpe_context,
3258 &avc_ctx->res_mb_status_buffer,
3259 0,
3260 avc_ctx->res_mb_status_buffer.size,
3261 0,
3262 GEN9_AVC_MB_BRC_UPDATE_MB_STATUS_INDEX);
3263
3264 return;
3265 }
3266
3267 static VAStatus
3268 gen9_avc_kernel_brc_mb_update(VADriverContextP ctx,
3269 struct encode_state *encode_state,
3270 struct intel_encoder_context *encoder_context)
3271
3272 {
3273 struct i965_driver_data *i965 = i965_driver_data(ctx);
3274 struct i965_gpe_table *gpe = &i965->gpe_table;
3275 struct encoder_vme_mfc_context * vme_context = (struct encoder_vme_mfc_context *)encoder_context->vme_context;
3276 struct i965_avc_encoder_context * avc_ctx = (struct i965_avc_encoder_context *)vme_context->private_enc_ctx;
3277 struct generic_enc_codec_state * generic_state = (struct generic_enc_codec_state *)vme_context->generic_enc_state;
3278 struct generic_encoder_context * generic_ctx = (struct generic_encoder_context *)vme_context->generic_enc_ctx;
3279
3280 struct i965_gpe_context *gpe_context;
3281 struct gpe_media_object_walker_parameter media_object_walker_param;
3282 struct gpe_encoder_kernel_walker_parameter kernel_walker_param;
3283 int media_function = 0;
3284 int kernel_idx = 0;
3285
3286 media_function = INTEL_MEDIA_STATE_MB_BRC_UPDATE;
3287 kernel_idx = GEN9_AVC_KERNEL_BRC_MB_UPDATE;
3288 gpe_context = &(avc_ctx->context_brc.gpe_contexts[kernel_idx]);
3289
3290 gpe->context_init(ctx, gpe_context);
3291 gpe->reset_binding_table(ctx, gpe_context);
3292
3293 /* set curbe brc mb update*/
3294 generic_ctx->pfn_set_curbe_brc_mb_update(ctx, encode_state, gpe_context, encoder_context, NULL);
3295
3296
3297 /* set surface brc mb update*/
3298 generic_ctx->pfn_send_brc_mb_update_surface(ctx, encode_state, gpe_context, encoder_context, NULL);
3299
3300
3301 gpe->setup_interface_data(ctx, gpe_context);
3302
3303 memset(&kernel_walker_param, 0, sizeof(kernel_walker_param));
3304 /* the scaling is based on 8x8 blk level */
3305 kernel_walker_param.resolution_x = (generic_state->frame_width_in_mbs + 1) / 2;
3306 kernel_walker_param.resolution_y = (generic_state->frame_height_in_mbs + 1) / 2 ;
3307 kernel_walker_param.no_dependency = 1;
3308
3309 i965_init_media_object_walker_parameter(&kernel_walker_param, &media_object_walker_param);
3310
3311 gen9_avc_run_kernel_media_object_walker(ctx, encoder_context,
3312 gpe_context,
3313 media_function,
3314 &media_object_walker_param);
3315
3316 return VA_STATUS_SUCCESS;
3317 }
3318
3319 /*
3320 mbenc kernel related function,it include intra dist kernel
3321 */
3322 static int
3323 gen9_avc_get_biweight(int dist_scale_factor_ref_id0_list0, unsigned short weighted_bipredidc)
3324 {
3325 int biweight = 32; // default value
3326
3327 /* based on kernel HLD*/
3328 if (weighted_bipredidc != INTEL_AVC_WP_MODE_IMPLICIT) {
3329 biweight = 32;
3330 } else {
3331 biweight = (dist_scale_factor_ref_id0_list0 + 2) >> 2;
3332
3333 if (biweight != 16 && biweight != 21 &&
3334 biweight != 32 && biweight != 43 && biweight != 48) {
3335 biweight = 32; // If # of B-pics between two refs is more than 3. VME does not support it.
3336 }
3337 }
3338
3339 return biweight;
3340 }
3341
3342 static void
3343 gen9_avc_get_dist_scale_factor(VADriverContextP ctx,
3344 struct encode_state *encode_state,
3345 struct intel_encoder_context *encoder_context)
3346 {
3347 struct encoder_vme_mfc_context * vme_context = (struct encoder_vme_mfc_context *)encoder_context->vme_context;
3348 struct avc_enc_state * avc_state = (struct avc_enc_state *)vme_context->private_enc_state;
3349 VAEncSliceParameterBufferH264 * slice_param = avc_state->slice_param[0];
3350 VAEncPictureParameterBufferH264 *pic_param = avc_state->pic_param;
3351
3352 int max_num_references;
3353 VAPictureH264 *curr_pic;
3354 VAPictureH264 *ref_pic_l0;
3355 VAPictureH264 *ref_pic_l1;
3356 int i = 0;
3357 int tb = 0;
3358 int td = 0;
3359 int tx = 0;
3360 int tmp = 0;
3361 int poc0 = 0;
3362 int poc1 = 0;
3363
3364 max_num_references = pic_param->num_ref_idx_l0_active_minus1 + 1;
3365
3366 memset(avc_state->dist_scale_factor_list0, 0, 32 * sizeof(unsigned int));
3367 curr_pic = &pic_param->CurrPic;
3368 for (i = 0; i < max_num_references; i++) {
3369 ref_pic_l0 = &(slice_param->RefPicList0[i]);
3370
3371 if ((ref_pic_l0->flags & VA_PICTURE_H264_INVALID) ||
3372 (ref_pic_l0->picture_id == VA_INVALID_SURFACE))
3373 break;
3374 ref_pic_l1 = &(slice_param->RefPicList1[0]);
3375 if ((ref_pic_l0->flags & VA_PICTURE_H264_INVALID) ||
3376 (ref_pic_l0->picture_id == VA_INVALID_SURFACE))
3377 break;
3378
3379 poc0 = (curr_pic->TopFieldOrderCnt - ref_pic_l0->TopFieldOrderCnt);
3380 poc1 = (ref_pic_l1->TopFieldOrderCnt - ref_pic_l0->TopFieldOrderCnt);
3381 CLIP(poc0, -128, 127);
3382 CLIP(poc1, -128, 127);
3383 tb = poc0;
3384 td = poc1;
3385
3386 if (td == 0) {
3387 td = 1;
3388 }
3389 tmp = (td / 2 > 0) ? (td / 2) : (-(td / 2));
3390 tx = (16384 + tmp) / td ;
3391 tmp = (tb * tx + 32) >> 6;
3392 CLIP(tmp, -1024, 1023);
3393 avc_state->dist_scale_factor_list0[i] = tmp;
3394 }
3395 return;
3396 }
3397
3398 static unsigned int
3399 gen9_avc_get_qp_from_ref_list(VADriverContextP ctx,
3400 VAEncSliceParameterBufferH264 *slice_param,
3401 int list,
3402 int ref_frame_idx)
3403 {
3404 struct i965_driver_data *i965 = i965_driver_data(ctx);
3405 struct object_surface *obj_surface;
3406 struct gen9_surface_avc *avc_priv_surface;
3407 VASurfaceID surface_id;
3408
3409 assert(slice_param);
3410 assert(list < 2);
3411
3412 if (list == 0) {
3413 if (ref_frame_idx < slice_param->num_ref_idx_l0_active_minus1 + 1)
3414 surface_id = slice_param->RefPicList0[ref_frame_idx].picture_id;
3415 else
3416 return 0;
3417 } else {
3418 if (ref_frame_idx < slice_param->num_ref_idx_l1_active_minus1 + 1)
3419 surface_id = slice_param->RefPicList1[ref_frame_idx].picture_id;
3420 else
3421 return 0;
3422 }
3423 obj_surface = SURFACE(surface_id);
3424 if (obj_surface && obj_surface->private_data) {
3425 avc_priv_surface = obj_surface->private_data;
3426 return avc_priv_surface->qp_value;
3427 } else {
3428 return 0;
3429 }
3430 }
3431
3432 static void
3433 gen9_avc_load_mb_brc_const_data(VADriverContextP ctx,
3434 struct encode_state *encode_state,
3435 struct intel_encoder_context *encoder_context)
3436 {
3437 struct encoder_vme_mfc_context * vme_context = (struct encoder_vme_mfc_context *)encoder_context->vme_context;
3438 struct i965_avc_encoder_context * avc_ctx = (struct i965_avc_encoder_context *)vme_context->private_enc_ctx;
3439 struct generic_enc_codec_state * generic_state = (struct generic_enc_codec_state *)vme_context->generic_enc_state;
3440 struct avc_enc_state * avc_state = (struct avc_enc_state *)vme_context->private_enc_state;
3441
3442 struct i965_gpe_resource *gpe_resource = NULL;
3443 unsigned int * data = NULL;
3444 unsigned int * data_tmp = NULL;
3445 unsigned int size = 16 * 52;
3446 unsigned int table_idx = 0;
3447 unsigned int block_based_skip_enable = avc_state->block_based_skip_enable;
3448 unsigned int transform_8x8_mode_flag = avc_state->transform_8x8_mode_enable;
3449 int i = 0;
3450
3451 gpe_resource = &(avc_ctx->res_mbbrc_const_data_buffer);
3452 assert(gpe_resource);
3453 data = i965_map_gpe_resource(gpe_resource);
3454 assert(data);
3455
3456 table_idx = slice_type_kernel[generic_state->frame_type];
3457
3458 memcpy(data, gen9_avc_mb_brc_const_data[table_idx][0], size * sizeof(unsigned int));
3459
3460 data_tmp = data;
3461
3462 switch (generic_state->frame_type) {
3463 case SLICE_TYPE_I:
3464 for (i = 0; i < AVC_QP_MAX ; i++) {
3465 if (avc_state->old_mode_cost_enable)
3466 *data = (unsigned int)gen9_avc_old_intra_mode_cost[i];
3467 data += 16;
3468 }
3469 break;
3470 case SLICE_TYPE_P:
3471 case SLICE_TYPE_B:
3472 for (i = 0; i < AVC_QP_MAX ; i++) {
3473 if (generic_state->frame_type == SLICE_TYPE_P) {
3474 if (avc_state->skip_bias_adjustment_enable)
3475 *(data + 3) = (unsigned int)gen9_avc_mv_cost_p_skip_adjustment[i];
3476 }
3477 if (avc_state->non_ftq_skip_threshold_lut_input_enable) {
3478 *(data + 9) = (unsigned int)i965_avc_calc_skip_value(block_based_skip_enable, transform_8x8_mode_flag, avc_state->non_ftq_skip_threshold_lut[i]);
3479 } else if (generic_state->frame_type == SLICE_TYPE_P) {
3480 *(data + 9) = (unsigned int)gen9_avc_skip_value_p[block_based_skip_enable][transform_8x8_mode_flag][i];
3481 } else {
3482 *(data + 9) = (unsigned int)gen9_avc_skip_value_b[block_based_skip_enable][transform_8x8_mode_flag][i];
3483 }
3484
3485 if (avc_state->adaptive_intra_scaling_enable) {
3486 *(data + 10) = (unsigned int)gen9_avc_adaptive_intra_scaling_factor[i];
3487 } else {
3488 *(data + 10) = (unsigned int)gen9_avc_intra_scaling_factor[i];
3489
3490 }
3491 data += 16;
3492
3493 }
3494 break;
3495 default:
3496 assert(0);
3497 }
3498
3499 data = data_tmp;
3500 for (i = 0; i < AVC_QP_MAX ; i++) {
3501 if (avc_state->ftq_skip_threshold_lut_input_enable) {
3502 *(data + 6) = (avc_state->ftq_skip_threshold_lut[i] |
3503 (avc_state->ftq_skip_threshold_lut[i] << 16) |
3504 (avc_state->ftq_skip_threshold_lut[i] << 24));
3505 *(data + 7) = (avc_state->ftq_skip_threshold_lut[i] |
3506 (avc_state->ftq_skip_threshold_lut[i] << 8) |
3507 (avc_state->ftq_skip_threshold_lut[i] << 16) |
3508 (avc_state->ftq_skip_threshold_lut[i] << 24));
3509 }
3510
3511 if (avc_state->kernel_trellis_enable) {
3512 *(data + 11) = (unsigned int)avc_state->lamda_value_lut[i][0];
3513 *(data + 12) = (unsigned int)avc_state->lamda_value_lut[i][1];
3514
3515 }
3516 data += 16;
3517
3518 }
3519 i965_unmap_gpe_resource(gpe_resource);
3520 }
3521
3522 static void
3523 gen9_avc_set_curbe_mbenc(VADriverContextP ctx,
3524 struct encode_state *encode_state,
3525 struct i965_gpe_context *gpe_context,
3526 struct intel_encoder_context *encoder_context,
3527 void * param)
3528 {
3529 struct i965_driver_data *i965 = i965_driver_data(ctx);
3530 union {
3531 gen9_avc_mbenc_curbe_data *g9;
3532 gen95_avc_mbenc_curbe_data *g95;
3533 } cmd;
3534 struct encoder_vme_mfc_context * vme_context = (struct encoder_vme_mfc_context *)encoder_context->vme_context;
3535 struct generic_enc_codec_state * generic_state = (struct generic_enc_codec_state *)vme_context->generic_enc_state;
3536 struct avc_enc_state * avc_state = (struct avc_enc_state *)vme_context->private_enc_state;
3537
3538 VAEncSliceParameterBufferH264 * slice_param = avc_state->slice_param[0];
3539 VAEncPictureParameterBufferH264 *pic_param = avc_state->pic_param;
3540 VASurfaceID surface_id;
3541 struct object_surface *obj_surface;
3542
3543 struct mbenc_param * curbe_param = (struct mbenc_param *)param ;
3544 unsigned char qp = 0;
3545 unsigned char me_method = 0;
3546 unsigned int mbenc_i_frame_dist_in_use = curbe_param->mbenc_i_frame_dist_in_use;
3547 unsigned int table_idx = 0;
3548 unsigned char is_g9 = 0;
3549 unsigned char is_g95 = 0;
3550 unsigned int curbe_size = 0;
3551
3552 unsigned int preset = generic_state->preset;
3553 if (IS_SKL(i965->intel.device_info) ||
3554 IS_BXT(i965->intel.device_info)) {
3555 cmd.g9 = (gen9_avc_mbenc_curbe_data *)i965_gpe_context_map_curbe(gpe_context);
3556 if (!cmd.g9)
3557 return;
3558 is_g9 = 1;
3559 curbe_size = sizeof(gen9_avc_mbenc_curbe_data);
3560 memset(cmd.g9, 0, curbe_size);
3561
3562 if (mbenc_i_frame_dist_in_use) {
3563 memcpy(cmd.g9, gen9_avc_mbenc_curbe_i_frame_dist_init_data, curbe_size);
3564
3565 } else {
3566 switch (generic_state->frame_type) {
3567 case SLICE_TYPE_I:
3568 memcpy(cmd.g9, gen9_avc_mbenc_curbe_normal_i_frame_init_data, curbe_size);
3569 break;
3570 case SLICE_TYPE_P:
3571 memcpy(cmd.g9, gen9_avc_mbenc_curbe_normal_p_frame_init_data, curbe_size);
3572 break;
3573 case SLICE_TYPE_B:
3574 memcpy(cmd.g9, gen9_avc_mbenc_curbe_normal_b_frame_init_data, curbe_size);
3575 break;
3576 default:
3577 assert(0);
3578 }
3579
3580 }
3581 } else if (IS_KBL(i965->intel.device_info) ||
3582 IS_GEN10(i965->intel.device_info) ||
3583 IS_GLK(i965->intel.device_info)) {
3584 cmd.g95 = (gen95_avc_mbenc_curbe_data *)i965_gpe_context_map_curbe(gpe_context);
3585 if (!cmd.g95)
3586 return;
3587 is_g95 = 1;
3588 curbe_size = sizeof(gen95_avc_mbenc_curbe_data);
3589 memset(cmd.g9, 0, curbe_size);
3590
3591 if (mbenc_i_frame_dist_in_use) {
3592 memcpy(cmd.g95, gen95_avc_mbenc_curbe_i_frame_dist_init_data, curbe_size);
3593
3594 } else {
3595 switch (generic_state->frame_type) {
3596 case SLICE_TYPE_I:
3597 memcpy(cmd.g95, gen95_avc_mbenc_curbe_normal_i_frame_init_data, curbe_size);
3598 break;
3599 case SLICE_TYPE_P:
3600 memcpy(cmd.g95, gen95_avc_mbenc_curbe_normal_p_frame_init_data, curbe_size);
3601 break;
3602 case SLICE_TYPE_B:
3603 memcpy(cmd.g95, gen95_avc_mbenc_curbe_normal_b_frame_init_data, curbe_size);
3604 break;
3605 default:
3606 assert(0);
3607 }
3608
3609 }
3610 } else {
3611 /* Never get here, just silence a gcc warning */
3612 assert(0);
3613
3614 return;
3615 }
3616
3617 me_method = (generic_state->frame_type == SLICE_TYPE_B) ? gen9_avc_b_me_method[preset] : gen9_avc_p_me_method[preset];
3618 qp = pic_param->pic_init_qp + slice_param->slice_qp_delta;
3619
3620 cmd.g9->dw0.adaptive_enable = gen9_avc_enable_adaptive_search[preset];
3621 cmd.g9->dw37.adaptive_enable = gen9_avc_enable_adaptive_search[preset];
3622 cmd.g9->dw0.t8x8_flag_for_inter_enable = avc_state->transform_8x8_mode_enable;
3623 cmd.g9->dw37.t8x8_flag_for_inter_enable = avc_state->transform_8x8_mode_enable;
3624
3625 cmd.g9->dw2.max_len_sp = gen9_avc_max_len_sp[preset];
3626 cmd.g9->dw38.max_len_sp = 0;
3627
3628 if (is_g95)
3629 cmd.g95->dw1.extended_mv_cost_range = avc_state->extended_mv_cost_range_enable;
3630
3631 cmd.g9->dw3.src_access = 0;
3632 cmd.g9->dw3.ref_access = 0;
3633
3634 if (avc_state->ftq_enable && (generic_state->frame_type != SLICE_TYPE_I)) {
3635 //disable ftq_override by now.
3636 if (avc_state->ftq_override) {
3637 cmd.g9->dw3.ftq_enable = avc_state->ftq_enable;
3638
3639 } else {
3640 // both gen9 and gen95 come here by now
3641 if (generic_state->frame_type == SLICE_TYPE_P) {
3642 cmd.g9->dw3.ftq_enable = gen9_avc_max_ftq_based_skip[preset] & 0x01;
3643
3644 } else {
3645 cmd.g9->dw3.ftq_enable = (gen9_avc_max_ftq_based_skip[preset] >> 1) & 0x01;
3646 }
3647 }
3648 } else {
3649 cmd.g9->dw3.ftq_enable = 0;
3650 }
3651
3652 if (avc_state->disable_sub_mb_partion)
3653 cmd.g9->dw3.sub_mb_part_mask = 0x7;
3654
3655 if (mbenc_i_frame_dist_in_use) {
3656 cmd.g9->dw2.pitch_width = generic_state->downscaled_width_4x_in_mb;
3657 cmd.g9->dw4.picture_height_minus1 = generic_state->downscaled_height_4x_in_mb - 1;
3658 cmd.g9->dw5.slice_mb_height = (avc_state->slice_height + 4 - 1) / 4;
3659 cmd.g9->dw6.batch_buffer_end = 0;
3660 cmd.g9->dw31.intra_compute_type = 1;
3661
3662 } else {
3663 cmd.g9->dw2.pitch_width = generic_state->frame_width_in_mbs;
3664 cmd.g9->dw4.picture_height_minus1 = generic_state->frame_height_in_mbs - 1;
3665 cmd.g9->dw5.slice_mb_height = (avc_state->arbitrary_num_mbs_in_slice) ? generic_state->frame_height_in_mbs : avc_state->slice_height;
3666
3667 {
3668 memcpy(&(cmd.g9->dw8), gen9_avc_mode_mv_cost_table[slice_type_kernel[generic_state->frame_type]][qp], 8 * sizeof(unsigned int));
3669 if ((generic_state->frame_type == SLICE_TYPE_I) && avc_state->old_mode_cost_enable) {
3670 } else if (avc_state->skip_bias_adjustment_enable) {
3671 /* Load different MvCost for P picture when SkipBiasAdjustment is enabled
3672 // No need to check for P picture as the flag is only enabled for P picture */
3673 cmd.g9->dw11.value = gen9_avc_mv_cost_p_skip_adjustment[qp];
3674
3675 }
3676 }
3677
3678 table_idx = (generic_state->frame_type == SLICE_TYPE_B) ? 1 : 0;
3679 memcpy(&(cmd.g9->dw16), table_enc_search_path[table_idx][me_method], 16 * sizeof(unsigned int));
3680 }
3681 cmd.g9->dw4.enable_fbr_bypass = avc_state->fbr_bypass_enable;
3682 cmd.g9->dw4.enable_intra_cost_scaling_for_static_frame = avc_state->sfd_enable && generic_state->hme_enabled;
3683 cmd.g9->dw4.field_parity_flag = 0;//bottom field
3684 cmd.g9->dw4.enable_cur_fld_idr = 0;//field realted
3685 cmd.g9->dw4.contrained_intra_pred_flag = pic_param->pic_fields.bits.constrained_intra_pred_flag;
3686 cmd.g9->dw4.hme_enable = generic_state->hme_enabled;
3687 cmd.g9->dw4.picture_type = slice_type_kernel[generic_state->frame_type];
3688 cmd.g9->dw4.use_actual_ref_qp_value = generic_state->hme_enabled && (gen9_avc_mr_disable_qp_check[preset] == 0);
3689
3690
3691 cmd.g9->dw7.intra_part_mask = avc_state->transform_8x8_mode_enable ? 0 : 0x02;
3692 cmd.g9->dw7.src_field_polarity = 0;//field related
3693
3694 /*ftq_skip_threshold_lut set,dw14 /15*/
3695
3696 /*r5 disable NonFTQSkipThresholdLUT*/
3697 if (generic_state->frame_type == SLICE_TYPE_P) {
3698 cmd.g9->dw32.skip_val = gen9_avc_skip_value_p[avc_state->block_based_skip_enable][avc_state->transform_8x8_mode_enable][qp];
3699
3700 } else if (generic_state->frame_type == SLICE_TYPE_B) {
3701 cmd.g9->dw32.skip_val = gen9_avc_skip_value_b[avc_state->block_based_skip_enable][avc_state->transform_8x8_mode_enable][qp];
3702
3703 }
3704
3705 cmd.g9->dw13.qp_prime_y = qp;
3706 cmd.g9->dw13.qp_prime_cb = qp;
3707 cmd.g9->dw13.qp_prime_cr = qp;
3708 cmd.g9->dw13.target_size_in_word = 0xff;//hardcode for brc disable
3709
3710 if ((generic_state->frame_type != SLICE_TYPE_I) && avc_state->multi_pre_enable) {
3711 switch (gen9_avc_multi_pred[preset]) {
3712 case 0:
3713 cmd.g9->dw32.mult_pred_l0_disable = 128;
3714 cmd.g9->dw32.mult_pred_l1_disable = 128;
3715 break;
3716 case 1:
3717 cmd.g9->dw32.mult_pred_l0_disable = (generic_state->frame_type == SLICE_TYPE_P) ? 1 : 128;
3718 cmd.g9->dw32.mult_pred_l1_disable = 128;
3719 break;
3720 case 2:
3721 cmd.g9->dw32.mult_pred_l0_disable = (generic_state->frame_type == SLICE_TYPE_B) ? 1 : 128;
3722 cmd.g9->dw32.mult_pred_l1_disable = (generic_state->frame_type == SLICE_TYPE_B) ? 1 : 128;
3723 break;
3724 case 3:
3725 cmd.g9->dw32.mult_pred_l0_disable = 1;
3726 cmd.g9->dw32.mult_pred_l1_disable = (generic_state->frame_type == SLICE_TYPE_B) ? 1 : 128;
3727 break;
3728
3729 }
3730
3731 } else {
3732 cmd.g9->dw32.mult_pred_l0_disable = 128;
3733 cmd.g9->dw32.mult_pred_l1_disable = 128;
3734 }
3735
3736 /*field setting for dw33 34, ignored*/
3737
3738 if (avc_state->adaptive_transform_decision_enable) {
3739 if (generic_state->frame_type != SLICE_TYPE_I) {
3740 if (is_g9) {
3741 cmd.g9->dw34.enable_adaptive_tx_decision = 1;
3742 cmd.g9->dw58.mb_texture_threshold = 1024;
3743 cmd.g9->dw58.tx_decision_threshold = 128;
3744 } else if (is_g95) {
3745 cmd.g95->dw34.enable_adaptive_tx_decision = 1;
3746 cmd.g95->dw60.mb_texture_threshold = 1024;
3747 cmd.g95->dw60.tx_decision_threshold = 128;
3748 }
3749 }
3750 }
3751
3752
3753 if (generic_state->frame_type == SLICE_TYPE_B) {
3754 cmd.g9->dw34.list1_ref_id0_frm_field_parity = 0; //frame only
3755 cmd.g9->dw34.list1_ref_id0_frm_field_parity = 0;
3756 cmd.g9->dw34.b_direct_mode = slice_param->direct_spatial_mv_pred_flag;
3757 }
3758
3759 cmd.g9->dw34.b_original_bff = 0; //frame only
3760 cmd.g9->dw34.enable_mb_flatness_check_optimization = avc_state->flatness_check_enable;
3761 cmd.g9->dw34.roi_enable_flag = curbe_param->roi_enabled;
3762 cmd.g9->dw34.mad_enable_falg = avc_state->mad_enable;
3763 cmd.g9->dw34.mb_brc_enable = avc_state->mb_qp_data_enable || generic_state->mb_brc_enabled;
3764 cmd.g9->dw34.arbitray_num_mbs_per_slice = avc_state->arbitrary_num_mbs_in_slice;
3765 if (is_g95) {
3766 cmd.g95->dw34.tq_enable = avc_state->tq_enable;
3767 cmd.g95->dw34.cqp_flag = !generic_state->brc_enabled;
3768 }
3769
3770 if (is_g9) {
3771 cmd.g9->dw34.force_non_skip_check = avc_state->mb_disable_skip_map_enable;
3772
3773 if (cmd.g9->dw34.force_non_skip_check) {
3774 cmd.g9->dw34.disable_enc_skip_check = avc_state->skip_check_disable;
3775 }
3776 }
3777
3778
3779 cmd.g9->dw36.check_all_fractional_enable = avc_state->caf_enable;
3780 cmd.g9->dw38.ref_threshold = 400;
3781 cmd.g9->dw39.hme_ref_windows_comb_threshold = (generic_state->frame_type == SLICE_TYPE_B) ? gen9_avc_hme_b_combine_len[preset] : gen9_avc_hme_combine_len[preset];
3782
3783 /* Default:2 used for MBBRC (MB QP Surface width and height are 4x downscaled picture in MB unit * 4 bytes)
3784 0 used for MBQP data surface (MB QP Surface width and height are same as the input picture size in MB unit * 1bytes)
3785 starting GEN9, BRC use split kernel, MB QP surface is same size as input picture */
3786 cmd.g9->dw47.mb_qp_read_factor = (avc_state->mb_qp_data_enable || generic_state->mb_brc_enabled) ? 0 : 2;
3787
3788 if (mbenc_i_frame_dist_in_use) {
3789 cmd.g9->dw13.qp_prime_y = 0;
3790 cmd.g9->dw13.qp_prime_cb = 0;
3791 cmd.g9->dw13.qp_prime_cr = 0;
3792 cmd.g9->dw33.intra_16x16_nondc_penalty = 0;
3793 cmd.g9->dw33.intra_8x8_nondc_penalty = 0;
3794 cmd.g9->dw33.intra_4x4_nondc_penalty = 0;
3795
3796 }
3797 if (cmd.g9->dw4.use_actual_ref_qp_value) {
3798 cmd.g9->dw44.actual_qp_value_for_ref_id0_list0 = gen9_avc_get_qp_from_ref_list(ctx, slice_param, 0, 0);
3799 cmd.g9->dw44.actual_qp_value_for_ref_id1_list0 = gen9_avc_get_qp_from_ref_list(ctx, slice_param, 0, 1);
3800 cmd.g9->dw44.actual_qp_value_for_ref_id2_list0 = gen9_avc_get_qp_from_ref_list(ctx, slice_param, 0, 2);
3801 cmd.g9->dw44.actual_qp_value_for_ref_id3_list0 = gen9_avc_get_qp_from_ref_list(ctx, slice_param, 0, 3);
3802 cmd.g9->dw45.actual_qp_value_for_ref_id4_list0 = gen9_avc_get_qp_from_ref_list(ctx, slice_param, 0, 4);
3803 cmd.g9->dw45.actual_qp_value_for_ref_id5_list0 = gen9_avc_get_qp_from_ref_list(ctx, slice_param, 0, 5);
3804 cmd.g9->dw45.actual_qp_value_for_ref_id6_list0 = gen9_avc_get_qp_from_ref_list(ctx, slice_param, 0, 6);
3805 cmd.g9->dw45.actual_qp_value_for_ref_id7_list0 = gen9_avc_get_qp_from_ref_list(ctx, slice_param, 0, 7);
3806 cmd.g9->dw46.actual_qp_value_for_ref_id0_list1 = gen9_avc_get_qp_from_ref_list(ctx, slice_param, 1, 0);
3807 cmd.g9->dw46.actual_qp_value_for_ref_id1_list1 = gen9_avc_get_qp_from_ref_list(ctx, slice_param, 1, 1);
3808 }
3809
3810 table_idx = slice_type_kernel[generic_state->frame_type];
3811 cmd.g9->dw46.ref_cost = gen9_avc_ref_cost[table_idx][qp];
3812
3813 if (generic_state->frame_type == SLICE_TYPE_I) {
3814 cmd.g9->dw0.skip_mode_enable = 0;
3815 cmd.g9->dw37.skip_mode_enable = 0;
3816 cmd.g9->dw36.hme_combine_overlap = 0;
3817 cmd.g9->dw47.intra_cost_sf = 16;
3818 cmd.g9->dw34.enable_direct_bias_adjustment = 0;
3819 if (is_g9)
3820 cmd.g9->dw34.enable_global_motion_bias_adjustment = 0;
3821
3822 } else if (generic_state->frame_type == SLICE_TYPE_P) {
3823 cmd.g9->dw1.max_num_mvs = i965_avc_get_max_mv_per_2mb(avc_state->seq_param->level_idc) / 2;
3824 cmd.g9->dw3.bme_disable_fbr = 1;
3825 cmd.g9->dw5.ref_width = gen9_avc_search_x[preset];
3826 cmd.g9->dw5.ref_height = gen9_avc_search_y[preset];
3827 cmd.g9->dw7.non_skip_zmv_added = 1;
3828 cmd.g9->dw7.non_skip_mode_added = 1;
3829 cmd.g9->dw7.skip_center_mask = 1;
3830 cmd.g9->dw47.intra_cost_sf = (avc_state->adaptive_intra_scaling_enable) ? gen9_avc_adaptive_intra_scaling_factor[qp] : gen9_avc_intra_scaling_factor[qp];
3831 cmd.g9->dw47.max_vmv_r = i965_avc_get_max_mv_len(avc_state->seq_param->level_idc) * 4;//frame onlys
3832 cmd.g9->dw36.hme_combine_overlap = 1;
3833 cmd.g9->dw36.num_ref_idx_l0_minus_one = (avc_state->multi_pre_enable) ? slice_param->num_ref_idx_l0_active_minus1 : 0;
3834 cmd.g9->dw39.ref_width = gen9_avc_search_x[preset];
3835 cmd.g9->dw39.ref_height = gen9_avc_search_y[preset];
3836 cmd.g9->dw34.enable_direct_bias_adjustment = 0;
3837 cmd.g9->dw34.enable_global_motion_bias_adjustment = avc_state->global_motion_bias_adjustment_enable;
3838 if (is_g9 && avc_state->global_motion_bias_adjustment_enable)
3839 cmd.g9->dw59.hme_mv_cost_scaling_factor = avc_state->hme_mv_cost_scaling_factor;
3840
3841 } else {
3842 cmd.g9->dw1.max_num_mvs = i965_avc_get_max_mv_per_2mb(avc_state->seq_param->level_idc) / 2;
3843 cmd.g9->dw1.bi_weight = avc_state->bi_weight;
3844 cmd.g9->dw3.search_ctrl = 7;
3845 cmd.g9->dw3.skip_type = 1;
3846 cmd.g9->dw5.ref_width = gen9_avc_b_search_x[preset];
3847 cmd.g9->dw5.ref_height = gen9_avc_b_search_y[preset];
3848 cmd.g9->dw7.skip_center_mask = 0xff;
3849 cmd.g9->dw47.intra_cost_sf = (avc_state->adaptive_intra_scaling_enable) ? gen9_avc_adaptive_intra_scaling_factor[qp] : gen9_avc_intra_scaling_factor[qp];
3850 cmd.g9->dw47.max_vmv_r = i965_avc_get_max_mv_len(avc_state->seq_param->level_idc) * 4;//frame only
3851 cmd.g9->dw36.hme_combine_overlap = 1;
3852 surface_id = slice_param->RefPicList1[0].picture_id;
3853 obj_surface = SURFACE(surface_id);
3854 if (!obj_surface) {
3855 WARN_ONCE("Invalid backward reference frame\n");
3856 return;
3857 }
3858 cmd.g9->dw36.is_fwd_frame_short_term_ref = !!(slice_param->RefPicList1[0].flags & VA_PICTURE_H264_SHORT_TERM_REFERENCE);
3859
3860 cmd.g9->dw36.num_ref_idx_l0_minus_one = (avc_state->multi_pre_enable) ? slice_param->num_ref_idx_l0_active_minus1 : 0;
3861 cmd.g9->dw36.num_ref_idx_l1_minus_one = (avc_state->multi_pre_enable) ? slice_param->num_ref_idx_l1_active_minus1 : 0;
3862 cmd.g9->dw39.ref_width = gen9_avc_b_search_x[preset];
3863 cmd.g9->dw39.ref_height = gen9_avc_b_search_y[preset];
3864 cmd.g9->dw40.dist_scale_factor_ref_id0_list0 = avc_state->dist_scale_factor_list0[0];
3865 cmd.g9->dw40.dist_scale_factor_ref_id1_list0 = avc_state->dist_scale_factor_list0[1];
3866 cmd.g9->dw41.dist_scale_factor_ref_id2_list0 = avc_state->dist_scale_factor_list0[2];
3867 cmd.g9->dw41.dist_scale_factor_ref_id3_list0 = avc_state->dist_scale_factor_list0[3];
3868 cmd.g9->dw42.dist_scale_factor_ref_id4_list0 = avc_state->dist_scale_factor_list0[4];
3869 cmd.g9->dw42.dist_scale_factor_ref_id5_list0 = avc_state->dist_scale_factor_list0[5];
3870 cmd.g9->dw43.dist_scale_factor_ref_id6_list0 = avc_state->dist_scale_factor_list0[6];
3871 cmd.g9->dw43.dist_scale_factor_ref_id7_list0 = avc_state->dist_scale_factor_list0[7];
3872
3873 cmd.g9->dw34.enable_direct_bias_adjustment = avc_state->direct_bias_adjustment_enable;
3874 if (cmd.g9->dw34.enable_direct_bias_adjustment) {
3875 cmd.g9->dw7.non_skip_zmv_added = 1;
3876 cmd.g9->dw7.non_skip_mode_added = 1;
3877 }
3878
3879 cmd.g9->dw34.enable_global_motion_bias_adjustment = avc_state->global_motion_bias_adjustment_enable;
3880 if (is_g9 && avc_state->global_motion_bias_adjustment_enable)
3881 cmd.g9->dw59.hme_mv_cost_scaling_factor = avc_state->hme_mv_cost_scaling_factor;
3882
3883 }
3884
3885 avc_state->block_based_skip_enable = cmd.g9->dw3.block_based_skip_enable;
3886
3887 if (avc_state->rolling_intra_refresh_enable) {
3888 /*by now disable it*/
3889 cmd.g9->dw34.widi_intra_refresh_en = avc_state->rolling_intra_refresh_enable;
3890 cmd.g9->dw32.mult_pred_l0_disable = 128;
3891 /* Pass the same IntraRefreshUnit to the kernel w/o the adjustment by -1, so as to have an overlap of one MB row or column of Intra macroblocks
3892 across one P frame to another P frame, as needed by the RollingI algo */
3893 if (is_g9) {
3894 cmd.g9->dw48.widi_intra_refresh_mb_num = 0;
3895 cmd.g9->dw48.widi_intra_refresh_unit_in_mb_minus1 = 0;
3896 cmd.g9->dw48.widi_intra_refresh_qp_delta = 0;
3897 }
3898
3899 if (is_g95) {
3900 if (avc_state->rolling_intra_refresh_enable == INTEL_ROLLING_I_SQUARE && generic_state->brc_enabled) {
3901 cmd.g95->dw4.enable_intra_refresh = 0;
3902 cmd.g95->dw34.widi_intra_refresh_en = INTEL_ROLLING_I_DISABLED;
3903 cmd.g95->dw48.widi_intra_refresh_mb_x = 0;
3904 cmd.g95->dw61.widi_intra_refresh_mb_y = 0;
3905 } else {
3906 cmd.g95->dw4.enable_intra_refresh = 1;
3907 cmd.g95->dw34.widi_intra_refresh_en = avc_state->rolling_intra_refresh_enable;
3908 cmd.g95->dw48.widi_intra_refresh_mb_x = 0;
3909 cmd.g95->dw61.widi_intra_refresh_mb_y = 0;
3910 cmd.g9->dw48.widi_intra_refresh_unit_in_mb_minus1 = 0;
3911 cmd.g9->dw48.widi_intra_refresh_qp_delta = 0;
3912 }
3913 }
3914
3915 } else {
3916 cmd.g9->dw34.widi_intra_refresh_en = 0;
3917 }
3918
3919 cmd.g9->dw34.enable_per_mb_static_check = avc_state->sfd_enable && generic_state->hme_enabled;
3920 if (is_g9)
3921 cmd.g9->dw34.enable_adaptive_search_window_size = avc_state->adaptive_search_window_enable;
3922 else if (is_g95)
3923 cmd.g95->dw34.enable_adaptive_search_window_size = avc_state->adaptive_search_window_enable;
3924
3925 /*roi set disable by now. 49-56*/
3926 if (curbe_param->roi_enabled) {
3927 cmd.g9->dw49.roi_1_x_left = generic_state->roi[0].left;
3928 cmd.g9->dw49.roi_1_y_top = generic_state->roi[0].top;
3929 cmd.g9->dw50.roi_1_x_right = generic_state->roi[0].right;
3930 cmd.g9->dw50.roi_1_y_bottom = generic_state->roi[0].bottom;
3931
3932 cmd.g9->dw51.roi_2_x_left = generic_state->roi[1].left;
3933 cmd.g9->dw51.roi_2_y_top = generic_state->roi[1].top;
3934 cmd.g9->dw52.roi_2_x_right = generic_state->roi[1].right;
3935 cmd.g9->dw52.roi_2_y_bottom = generic_state->roi[1].bottom;
3936
3937 cmd.g9->dw53.roi_3_x_left = generic_state->roi[2].left;
3938 cmd.g9->dw53.roi_3_y_top = generic_state->roi[2].top;
3939 cmd.g9->dw54.roi_3_x_right = generic_state->roi[2].right;
3940 cmd.g9->dw54.roi_3_y_bottom = generic_state->roi[2].bottom;
3941
3942 cmd.g9->dw55.roi_4_x_left = generic_state->roi[3].left;
3943 cmd.g9->dw55.roi_4_y_top = generic_state->roi[3].top;
3944 cmd.g9->dw56.roi_4_x_right = generic_state->roi[3].right;
3945 cmd.g9->dw56.roi_4_y_bottom = generic_state->roi[3].bottom;
3946
3947 if (!generic_state->brc_enabled) {
3948 char tmp = 0;
3949 tmp = generic_state->roi[0].value;
3950 CLIP(tmp, -qp, AVC_QP_MAX - qp);
3951 cmd.g9->dw57.roi_1_dqp_prime_y = tmp;
3952 tmp = generic_state->roi[1].value;
3953 CLIP(tmp, -qp, AVC_QP_MAX - qp);
3954 cmd.g9->dw57.roi_2_dqp_prime_y = tmp;
3955 tmp = generic_state->roi[2].value;
3956 CLIP(tmp, -qp, AVC_QP_MAX - qp);
3957 cmd.g9->dw57.roi_3_dqp_prime_y = tmp;
3958 tmp = generic_state->roi[3].value;
3959 CLIP(tmp, -qp, AVC_QP_MAX - qp);
3960 cmd.g9->dw57.roi_4_dqp_prime_y = tmp;
3961 } else {
3962 cmd.g9->dw34.roi_enable_flag = 0;
3963 }
3964 }
3965
3966 if (is_g95) {
3967 if (avc_state->tq_enable) {
3968 if (generic_state->frame_type == SLICE_TYPE_I) {
3969 cmd.g95->dw58.value = gen95_avc_tq_lambda_i_frame[qp][0];
3970 cmd.g95->dw59.value = gen95_avc_tq_lambda_i_frame[qp][1];
3971
3972 } else if (generic_state->frame_type == SLICE_TYPE_P) {
3973 cmd.g95->dw58.value = gen95_avc_tq_lambda_p_frame[qp][0];
3974 cmd.g95->dw59.value = gen95_avc_tq_lambda_p_frame[qp][1];
3975
3976 } else {
3977 cmd.g95->dw58.value = gen95_avc_tq_lambda_b_frame[qp][0];
3978 cmd.g95->dw59.value = gen95_avc_tq_lambda_b_frame[qp][1];
3979 }
3980
3981 if (cmd.g95->dw58.lambda_8x8_inter > GEN95_AVC_MAX_LAMBDA)
3982 cmd.g95->dw58.lambda_8x8_inter = 0xf000 + avc_state->rounding_value;
3983
3984 if (cmd.g95->dw58.lambda_8x8_intra > GEN95_AVC_MAX_LAMBDA)
3985 cmd.g95->dw58.lambda_8x8_intra = 0xf000 + GEN95_AVC_DEFAULT_TRELLIS_QUANT_INTRA_ROUNDING;
3986
3987 if (cmd.g95->dw59.lambda_inter > GEN95_AVC_MAX_LAMBDA)
3988 cmd.g95->dw59.lambda_inter = 0xf000 + avc_state->rounding_value;
3989
3990 if (cmd.g95->dw59.lambda_intra > GEN95_AVC_MAX_LAMBDA)
3991 cmd.g95->dw59.lambda_intra = 0xf000 + GEN95_AVC_DEFAULT_TRELLIS_QUANT_INTRA_ROUNDING;
3992 }
3993 }
3994
3995 if (is_g95) {
3996 cmd.g95->dw66.mb_data_surf_index = GEN9_AVC_MBENC_MFC_AVC_PAK_OBJ_INDEX;
3997 cmd.g95->dw67.mv_data_surf_index = GEN9_AVC_MBENC_IND_MV_DATA_INDEX;
3998 cmd.g95->dw68.i_dist_surf_index = GEN9_AVC_MBENC_BRC_DISTORTION_INDEX;
3999 cmd.g95->dw69.src_y_surf_index = GEN9_AVC_MBENC_CURR_Y_INDEX;
4000 cmd.g95->dw70.mb_specific_data_surf_index = GEN9_AVC_MBENC_MB_SPECIFIC_DATA_INDEX;
4001 cmd.g95->dw71.aux_vme_out_surf_index = GEN9_AVC_MBENC_AUX_VME_OUT_INDEX;
4002 cmd.g95->dw72.curr_ref_pic_sel_surf_index = GEN9_AVC_MBENC_REFPICSELECT_L0_INDEX;
4003 cmd.g95->dw73.hme_mv_pred_fwd_bwd_surf_index = GEN9_AVC_MBENC_MV_DATA_FROM_ME_INDEX;
4004 cmd.g95->dw74.hme_dist_surf_index = GEN9_AVC_MBENC_4XME_DISTORTION_INDEX;
4005 cmd.g95->dw75.slice_map_surf_index = GEN9_AVC_MBENC_SLICEMAP_DATA_INDEX;
4006 cmd.g95->dw76.fwd_frm_mb_data_surf_index = GEN9_AVC_MBENC_FWD_MB_DATA_INDEX;
4007 cmd.g95->dw77.fwd_frm_mv_surf_index = GEN9_AVC_MBENC_FWD_MV_DATA_INDEX;
4008 cmd.g95->dw78.mb_qp_buffer = GEN9_AVC_MBENC_MBQP_INDEX;
4009 cmd.g95->dw79.mb_brc_lut = GEN9_AVC_MBENC_MBBRC_CONST_DATA_INDEX;
4010 cmd.g95->dw80.vme_inter_prediction_surf_index = GEN9_AVC_MBENC_VME_INTER_PRED_CURR_PIC_IDX_0_INDEX;
4011 cmd.g95->dw81.vme_inter_prediction_mr_surf_index = GEN9_AVC_MBENC_VME_INTER_PRED_CURR_PIC_IDX_1_INDEX;
4012 cmd.g95->dw82.mb_stats_surf_index = GEN9_AVC_MBENC_MB_STATS_INDEX;
4013 cmd.g95->dw83.mad_surf_index = GEN9_AVC_MBENC_MAD_DATA_INDEX;
4014 cmd.g95->dw84.brc_curbe_surf_index = GEN95_AVC_MBENC_BRC_CURBE_DATA_INDEX;
4015 cmd.g95->dw85.force_non_skip_mb_map_surface = GEN95_AVC_MBENC_FORCE_NONSKIP_MB_MAP_INDEX;
4016 cmd.g95->dw86.widi_wa_surf_index = GEN95_AVC_MBENC_WIDI_WA_INDEX;
4017 cmd.g95->dw87.static_detection_cost_table_index = GEN95_AVC_MBENC_SFD_COST_TABLE_INDEX;
4018 }
4019
4020 if (is_g9) {
4021 cmd.g9->dw64.mb_data_surf_index = GEN9_AVC_MBENC_MFC_AVC_PAK_OBJ_INDEX;
4022 cmd.g9->dw65.mv_data_surf_index = GEN9_AVC_MBENC_IND_MV_DATA_INDEX;
4023 cmd.g9->dw66.i_dist_surf_index = GEN9_AVC_MBENC_BRC_DISTORTION_INDEX;
4024 cmd.g9->dw67.src_y_surf_index = GEN9_AVC_MBENC_CURR_Y_INDEX;
4025 cmd.g9->dw68.mb_specific_data_surf_index = GEN9_AVC_MBENC_MB_SPECIFIC_DATA_INDEX;
4026 cmd.g9->dw69.aux_vme_out_surf_index = GEN9_AVC_MBENC_AUX_VME_OUT_INDEX;
4027 cmd.g9->dw70.curr_ref_pic_sel_surf_index = GEN9_AVC_MBENC_REFPICSELECT_L0_INDEX;
4028 cmd.g9->dw71.hme_mv_pred_fwd_bwd_surf_index = GEN9_AVC_MBENC_MV_DATA_FROM_ME_INDEX;
4029 cmd.g9->dw72.hme_dist_surf_index = GEN9_AVC_MBENC_4XME_DISTORTION_INDEX;
4030 cmd.g9->dw73.slice_map_surf_index = GEN9_AVC_MBENC_SLICEMAP_DATA_INDEX;
4031 cmd.g9->dw74.fwd_frm_mb_data_surf_index = GEN9_AVC_MBENC_FWD_MB_DATA_INDEX;
4032 cmd.g9->dw75.fwd_frm_mv_surf_index = GEN9_AVC_MBENC_FWD_MV_DATA_INDEX;
4033 cmd.g9->dw76.mb_qp_buffer = GEN9_AVC_MBENC_MBQP_INDEX;
4034 cmd.g9->dw77.mb_brc_lut = GEN9_AVC_MBENC_MBBRC_CONST_DATA_INDEX;
4035 cmd.g9->dw78.vme_inter_prediction_surf_index = GEN9_AVC_MBENC_VME_INTER_PRED_CURR_PIC_IDX_0_INDEX;
4036 cmd.g9->dw79.vme_inter_prediction_mr_surf_index = GEN9_AVC_MBENC_VME_INTER_PRED_CURR_PIC_IDX_1_INDEX;
4037 cmd.g9->dw80.mb_stats_surf_index = GEN9_AVC_MBENC_MB_STATS_INDEX;
4038 cmd.g9->dw81.mad_surf_index = GEN9_AVC_MBENC_MAD_DATA_INDEX;
4039 cmd.g9->dw82.force_non_skip_mb_map_surface = GEN9_AVC_MBENC_FORCE_NONSKIP_MB_MAP_INDEX;
4040 cmd.g9->dw83.widi_wa_surf_index = GEN9_AVC_MBENC_WIDI_WA_INDEX;
4041 cmd.g9->dw84.brc_curbe_surf_index = GEN9_AVC_MBENC_BRC_CURBE_DATA_INDEX;
4042 cmd.g9->dw85.static_detection_cost_table_index = GEN9_AVC_MBENC_SFD_COST_TABLE_INDEX;
4043 }
4044
4045 i965_gpe_context_unmap_curbe(gpe_context);
4046
4047 return;
4048 }
4049
4050 static void
4051 gen9_avc_fei_set_curbe_mbenc(VADriverContextP ctx,
4052 struct encode_state *encode_state,
4053 struct i965_gpe_context *gpe_context,
4054 struct intel_encoder_context *encoder_context,
4055 void * param)
4056 {
4057 struct i965_driver_data *i965 = i965_driver_data(ctx);
4058 gen9_avc_fei_mbenc_curbe_data *cmd;
4059 struct encoder_vme_mfc_context * vme_context = (struct encoder_vme_mfc_context *)encoder_context->vme_context;
4060 struct generic_enc_codec_state * generic_state = (struct generic_enc_codec_state *)vme_context->generic_enc_state;
4061 struct avc_enc_state * avc_state = (struct avc_enc_state *)vme_context->private_enc_state;
4062 VASurfaceID surface_id;
4063 struct object_surface *obj_surface;
4064 VAEncSliceParameterBufferH264 * slice_param = avc_state->slice_param[0];
4065 VAEncPictureParameterBufferH264 *pic_param = avc_state->pic_param;
4066 VAEncMiscParameterFEIFrameControlH264 *fei_param = avc_state->fei_framectl_param;
4067
4068 struct mbenc_param * curbe_param = (struct mbenc_param *)param ;
4069 unsigned char qp = 0;
4070 unsigned char me_method = 0;
4071 unsigned int mbenc_i_frame_dist_in_use = curbe_param->mbenc_i_frame_dist_in_use;
4072 unsigned int table_idx = 0;
4073 int ref_width, ref_height, len_sp;
4074 int is_bframe = (generic_state->frame_type == SLICE_TYPE_B);
4075 int is_pframe = (generic_state->frame_type == SLICE_TYPE_P);
4076 unsigned int preset = generic_state->preset;
4077
4078 qp = pic_param->pic_init_qp + slice_param->slice_qp_delta;
4079
4080 assert(gpe_context != NULL);
4081 cmd = (gen9_avc_fei_mbenc_curbe_data *)i965_gpe_context_map_curbe(gpe_context);
4082 memset(cmd, 0, sizeof(gen9_avc_fei_mbenc_curbe_data));
4083
4084 if (mbenc_i_frame_dist_in_use) {
4085 memcpy(cmd, gen9_avc_fei_mbenc_curbe_i_frame_dist_init_data, sizeof(gen9_avc_fei_mbenc_curbe_data));
4086
4087 } else {
4088 switch (generic_state->frame_type) {
4089 case SLICE_TYPE_I:
4090 memcpy(cmd, gen9_avc_fei_mbenc_curbe_i_frame_init_data, sizeof(gen9_avc_fei_mbenc_curbe_data));
4091 break;
4092 case SLICE_TYPE_P:
4093 memcpy(cmd, gen9_avc_fei_mbenc_curbe_p_frame_init_data, sizeof(gen9_avc_fei_mbenc_curbe_data));
4094 break;
4095 case SLICE_TYPE_B:
4096 memcpy(cmd, gen9_avc_fei_mbenc_curbe_b_frame_init_data, sizeof(gen9_avc_fei_mbenc_curbe_data));
4097 break;
4098 default:
4099 assert(0);
4100 }
4101
4102 }
4103 /* 4 means full search, 6 means diamand search */
4104 me_method = (fei_param->search_window == 5) ||
4105 (fei_param->search_window == 8) ? 4 : 6;
4106
4107 ref_width = fei_param->ref_width;
4108 ref_height = fei_param->ref_height;
4109 len_sp = fei_param->len_sp;
4110 /* If there is a serch_window, discard user provided ref_width, ref_height
4111 * and search_path length */
4112 switch (fei_param->search_window) {
4113 case 0:
4114 /* not use predefined search window, there should be a search_path input */
4115 if ((fei_param->search_path != 0) &&
4116 (fei_param->search_path != 1) &&
4117 (fei_param->search_path != 2)) {
4118 WARN_ONCE("Invalid input search_path for SearchWindow=0 \n");
4119 assert(0);
4120 }
4121 /* 4 means full search, 6 means diamand search */
4122 me_method = (fei_param->search_path == 1) ? 6 : 4;
4123 if (((ref_width * ref_height) > 2048) || (ref_width > 64) || (ref_height > 64)) {
4124 WARN_ONCE("Invalid input ref_width/ref_height in"
4125 "SearchWindow=0 case! \n");
4126 assert(0);
4127 }
4128 break;
4129
4130 case 1:
4131 /* Tiny - 4 SUs 24x24 window */
4132 ref_width = 24;
4133 ref_height = 24;
4134 len_sp = 4;
4135 break;
4136
4137 case 2:
4138 /* Small - 9 SUs 28x28 window */
4139 ref_width = 28;
4140 ref_height = 28;
4141 len_sp = 9;
4142 break;
4143 case 3:
4144 /* Diamond - 16 SUs 48x40 window */
4145 ref_width = 48;
4146 ref_height = 40;
4147 len_sp = 16;
4148 break;
4149 case 4:
4150 /* Large Diamond - 32 SUs 48x40 window */
4151 ref_width = 48;
4152 ref_height = 40;
4153 len_sp = 32;
4154 break;
4155 case 5:
4156 /* Exhaustive - 48 SUs 48x40 window */
4157 ref_width = 48;
4158 ref_height = 40;
4159 len_sp = 48;
4160 break;
4161 case 6:
4162 /* Diamond - 16 SUs 64x32 window */
4163 ref_width = 64;
4164 ref_height = 32;
4165 len_sp = 16;
4166 break;
4167 case 7:
4168 /* Large Diamond - 32 SUs 64x32 window */
4169 ref_width = 64;
4170 ref_height = 32;
4171 len_sp = 32;
4172 break;
4173 case 8:
4174 /* Exhaustive - 48 SUs 64x32 window */
4175 ref_width = 64;
4176 ref_height = 32;
4177 len_sp = 48;
4178 break;
4179
4180 default:
4181 assert(0);
4182 }
4183
4184 /* ref_width*ref_height = Max 64x32 one direction, Max 32x32 two directions */
4185 if (is_bframe) {
4186 CLIP(ref_width, 4, 32);
4187 CLIP(ref_height, 4, 32);
4188 } else if (is_pframe) {
4189 CLIP(ref_width, 4, 64);
4190 CLIP(ref_height, 4, 32);
4191 }
4192
4193 cmd->dw0.adaptive_enable =
4194 cmd->dw37.adaptive_enable = fei_param->adaptive_search;
4195 cmd->dw0.t8x8_flag_for_inter_enable = cmd->dw37.t8x8_flag_for_inter_enable
4196 = avc_state->transform_8x8_mode_enable;
4197 cmd->dw2.max_len_sp = len_sp;
4198 cmd->dw38.max_len_sp = 0; // HLD mandates this field to be Zero
4199 cmd->dw2.max_num_su = cmd->dw38.max_num_su = 57;
4200 cmd->dw3.src_access =
4201 cmd->dw3.ref_access = 0; // change it to (is_frame ? 0: 1) when interlace is suppoted
4202
4203 if (avc_state->ftq_enable && (generic_state->frame_type != SLICE_TYPE_I)) {
4204 if (avc_state->ftq_override) {
4205 cmd->dw3.ft_enable = avc_state->ftq_enable;
4206 } else {
4207 if (generic_state->frame_type == SLICE_TYPE_P) {
4208 cmd->dw3.ft_enable = gen9_avc_max_ftq_based_skip[preset] & 0x01;
4209 } else {
4210 cmd->dw3.ft_enable = (gen9_avc_max_ftq_based_skip[preset] >> 1) & 0x01;
4211 }
4212 }
4213 } else {
4214 cmd->dw3.ft_enable = 0;
4215 }
4216
4217 if (avc_state->disable_sub_mb_partion)
4218 cmd->dw3.sub_mb_part_mask = 0x7;
4219
4220 if (mbenc_i_frame_dist_in_use) {
4221 /* Fixme: Not supported, no brc in fei */
4222 assert(0);
4223 cmd->dw2.pic_width = generic_state->downscaled_width_4x_in_mb;
4224 cmd->dw4.pic_height_minus1 = generic_state->downscaled_height_4x_in_mb - 1;
4225 cmd->dw5.slice_mb_height = (avc_state->slice_height + 4 - 1) / 4;
4226 cmd->dw6.batch_buffer_end = 0;
4227 cmd->dw31.intra_compute_type = 1;
4228 }
4229
4230 cmd->dw2.pic_width = generic_state->frame_width_in_mbs;
4231 cmd->dw4.pic_height_minus1 = generic_state->frame_height_in_mbs - 1;
4232 cmd->dw5.slice_mb_height = (avc_state->arbitrary_num_mbs_in_slice) ?
4233 generic_state->frame_height_in_mbs : avc_state->slice_height;
4234 cmd->dw3.sub_mb_part_mask = fei_param->sub_mb_part_mask;
4235 cmd->dw3.sub_pel_mode = fei_param->sub_pel_mode;
4236 cmd->dw3.inter_sad = fei_param->inter_sad;
4237 cmd->dw3.Intra_sad = fei_param->intra_sad;
4238 cmd->dw3.search_ctrl = (is_bframe) ? 7 : 0;
4239 cmd->dw4.enable_fbr_bypass = avc_state->fbr_bypass_enable;
4240 cmd->dw4.enable_intra_cost_scaling_for_static_frame =
4241 avc_state->sfd_enable && generic_state->hme_enabled;
4242 cmd->dw4.true_distortion_enable = fei_param->distortion_type == 0 ? 1 : 0;
4243 cmd->dw4.constrained_intra_pred_flag =
4244 pic_param->pic_fields.bits.constrained_intra_pred_flag;
4245 cmd->dw4.hme_enable = 0;
4246 cmd->dw4.picture_type = slice_type_kernel[generic_state->frame_type];
4247 cmd->dw4.use_actual_ref_qp_value =
4248 generic_state->hme_enabled && (gen9_avc_mr_disable_qp_check[preset] == 0);
4249 cmd->dw7.intra_part_mask = fei_param->intra_part_mask;
4250 cmd->dw7.src_field_polarity = 0;
4251
4252 /* mv mode cost */
4253 memcpy(&(cmd->dw8), gen9_avc_mode_mv_cost_table[slice_type_kernel[generic_state->frame_type]][qp], 8 * sizeof(unsigned int));
4254 if ((generic_state->frame_type == SLICE_TYPE_I) && avc_state->old_mode_cost_enable) {
4255 // cmd->dw8 = gen9_avc_old_intra_mode_cost[qp];
4256 } else if (avc_state->skip_bias_adjustment_enable) {
4257 // Load different MvCost for P picture when SkipBiasAdjustment is enabled
4258 // No need to check for P picture as the flag is only enabled for P picture
4259 cmd->dw11.value = gen9_avc_mv_cost_p_skip_adjustment[qp];
4260 }
4261
4262 //dw16
4263 /* search path tables */
4264 table_idx = (generic_state->frame_type == SLICE_TYPE_B) ? 1 : 0;
4265 memcpy(&(cmd->dw16), table_enc_search_path[table_idx][me_method], 16 * sizeof(unsigned int));
4266
4267 //ftq_skip_threshold_lut set,dw14 /15
4268
4269 //r5 disable NonFTQSkipThresholdLUT
4270 if (generic_state->frame_type == SLICE_TYPE_P) {
4271 cmd->dw32.skip_val = gen9_avc_skip_value_p[avc_state->block_based_skip_enable][avc_state->transform_8x8_mode_enable][qp];
4272 } else if (generic_state->frame_type == SLICE_TYPE_B) {
4273 cmd->dw32.skip_val =
4274 gen9_avc_skip_value_b[avc_state->block_based_skip_enable][avc_state->transform_8x8_mode_enable][qp];
4275 }
4276 cmd->dw13.qp_prime_y = qp;
4277 cmd->dw13.qp_prime_cb = qp;
4278 cmd->dw13.qp_prime_cr = qp;
4279 cmd->dw13.target_size_in_word = 0xff; /* hardcoded for brc disable */
4280
4281 if ((generic_state->frame_type != SLICE_TYPE_I) && avc_state->multi_pre_enable) {
4282 cmd->dw32.mult_pred_l0_disable = fei_param->multi_pred_l0 ? 0x01 : 0x80;
4283 cmd->dw32.mult_pred_l1_disable = ((generic_state->frame_type == SLICE_TYPE_B) && fei_param->multi_pred_l1) ? 0x01 : 0x80;
4284 } else {
4285 /* disable */
4286 cmd->dw32.mult_pred_l0_disable = 0x80;
4287 cmd->dw32.mult_pred_l1_disable = 0x80;
4288 }
4289 /* no field pic setting, not supported */
4290
4291 //dw34 58
4292 if (avc_state->adaptive_transform_decision_enable) {
4293 if (generic_state->frame_type != SLICE_TYPE_I) {
4294 cmd->dw34.enable_adaptive_tx_decision = 1;
4295 }
4296
4297 cmd->dw58.mb_texture_threshold = 1024;
4298 cmd->dw58.tx_decision_threshold = 128;
4299 }
4300 if (generic_state->frame_type == SLICE_TYPE_B) {
4301 cmd->dw34.list1_ref_id0_frm_field_parity = 0; //frame only
4302 cmd->dw34.list1_ref_id1_frm_field_parity = 0;
4303 cmd->dw34.b_direct_mode = slice_param->direct_spatial_mv_pred_flag;
4304 }
4305 cmd->dw34.enable_mb_flatness_check_optimization = avc_state->flatness_check_enable;
4306 cmd->dw34.roi_enable_flag = generic_state->brc_roi_enable;
4307 cmd->dw34.mad_enable_falg = avc_state->mad_enable;
4308 cmd->dw34.mb_brc_enable = avc_state->mb_qp_data_enable && generic_state->mb_brc_enabled;
4309 cmd->dw34.arbitray_num_mbs_per_slice = avc_state->arbitrary_num_mbs_in_slice;
4310 cmd->dw34.force_non_skip_check = avc_state->mb_disable_skip_map_enable;
4311
4312 if (cmd->dw34.force_non_skip_check) {
4313 cmd->dw34.disable_enc_skip_check = avc_state->skip_check_disable;
4314 }
4315 cmd->dw36.check_all_fractional_enable = avc_state->caf_enable;
4316 cmd->dw38.ref_threshold = 400;
4317 cmd->dw39.hme_ref_windows_comb_threshold = (generic_state->frame_type == SLICE_TYPE_B) ? gen9_avc_hme_b_combine_len[preset] : gen9_avc_hme_combine_len[preset];
4318 // Default:2 used for MBBRC (MB QP Surface width and height are 4x downscaled picture in MB unit * 4 bytes)
4319 // 0 used for MBQP data surface (MB QP Surface width and height are same as the input picture size in MB unit * 1bytes)
4320 // starting GEN9, BRC use split kernel, MB QP surface is same size as input picture
4321 cmd->dw47.mb_qp_read_factor = (avc_state->mb_qp_data_enable || generic_state->mb_brc_enabled) ? 0 : 2;
4322 if (mbenc_i_frame_dist_in_use) {
4323 cmd->dw13.qp_prime_y = 0;
4324 cmd->dw13.qp_prime_cb = 0;
4325 cmd->dw13.qp_prime_cr = 0;
4326 cmd->dw33.intra_16x16_nondc_penalty = 0;
4327 cmd->dw33.intra_8x8_nondc_penalty = 0;
4328 cmd->dw33.intra_4x4_nondc_penalty = 0;
4329 }
4330 if (cmd->dw4.use_actual_ref_qp_value) {
4331 cmd->dw44.actual_qp_value_for_ref_id0_list0 = gen9_avc_get_qp_from_ref_list(ctx, slice_param, 0, 0);
4332 cmd->dw44.actual_qp_value_for_ref_id1_list0 = gen9_avc_get_qp_from_ref_list(ctx, slice_param, 0, 1);
4333 cmd->dw44.actual_qp_value_for_ref_id2_list0 = gen9_avc_get_qp_from_ref_list(ctx, slice_param, 0, 2);
4334 cmd->dw44.actual_qp_value_for_ref_id3_list0 = gen9_avc_get_qp_from_ref_list(ctx, slice_param, 0, 3);
4335 cmd->dw45.actual_qp_value_for_ref_id4_list0 = gen9_avc_get_qp_from_ref_list(ctx, slice_param, 0, 4);
4336 cmd->dw45.actual_qp_value_for_ref_id5_list0 = gen9_avc_get_qp_from_ref_list(ctx, slice_param, 0, 5);
4337 cmd->dw45.actual_qp_value_for_ref_id6_list0 = gen9_avc_get_qp_from_ref_list(ctx, slice_param, 0, 6);
4338 cmd->dw45.actual_qp_value_for_ref_id7_list0 = gen9_avc_get_qp_from_ref_list(ctx, slice_param, 0, 7);
4339 cmd->dw46.actual_qp_value_for_ref_id0_list1 = gen9_avc_get_qp_from_ref_list(ctx, slice_param, 1, 0);
4340 cmd->dw46.actual_qp_value_for_ref_id1_list1 = gen9_avc_get_qp_from_ref_list(ctx, slice_param, 1, 1);
4341 }
4342
4343 table_idx = slice_type_kernel[generic_state->frame_type];
4344 cmd->dw46.ref_cost = gen9_avc_ref_cost[table_idx][qp];
4345
4346 if (generic_state->frame_type == SLICE_TYPE_I) {
4347 cmd->dw0.skip_mode_enable = 0;
4348 cmd->dw37.skip_mode_enable = 0;
4349 cmd->dw36.hme_combine_overlap = 0;
4350 cmd->dw36.check_all_fractional_enable = 0;
4351 cmd->dw47.intra_cost_sf = 16;/* not used, but recommended to set 16 by kernel team */
4352 cmd->dw34.enable_direct_bias_adjustment = 0;
4353 cmd->dw34.enable_global_motion_bias_adjustment = 0;
4354
4355 } else if (generic_state->frame_type == SLICE_TYPE_P) {
4356 cmd->dw1.max_num_mvs = i965_avc_get_max_mv_per_2mb(avc_state->seq_param->level_idc) / 2;
4357 cmd->dw3.bme_disable_fbr = 1;
4358 cmd->dw5.ref_width = cmd->dw39.ref_width = ref_width;
4359 cmd->dw5.ref_height = cmd->dw39.ref_height = ref_height;
4360 cmd->dw7.non_skip_zmv_added = 1;
4361 cmd->dw7.non_skip_mode_added = 1;
4362 cmd->dw7.skip_center_mask = 1;
4363
4364 cmd->dw47.intra_cost_sf =
4365 (avc_state->adaptive_intra_scaling_enable) ?
4366 gen9_avc_adaptive_intra_scaling_factor[preset] :
4367 gen9_avc_intra_scaling_factor[preset];
4368
4369 cmd->dw47.max_vmv_r =
4370 i965_avc_get_max_mv_len(avc_state->seq_param->level_idc) * 4;//frame only
4371
4372 cmd->dw36.hme_combine_overlap = 1;
4373 cmd->dw36.num_ref_idx_l0_minus_one = (avc_state->multi_pre_enable) ? slice_param->num_ref_idx_l0_active_minus1 : 0;
4374 cmd->dw36.check_all_fractional_enable = fei_param->repartition_check_enable;
4375 cmd->dw34.enable_direct_bias_adjustment = 0;
4376 cmd->dw34.enable_global_motion_bias_adjustment = avc_state->global_motion_bias_adjustment_enable;
4377 if (avc_state->global_motion_bias_adjustment_enable)
4378 cmd->dw59.hme_mv_cost_scaling_factor = avc_state->hme_mv_cost_scaling_factor;
4379
4380 cmd->dw64.num_mv_predictors_l0 = fei_param->num_mv_predictors_l0;
4381
4382 } else { /* B slice */
4383
4384 cmd->dw1.max_num_mvs = i965_avc_get_max_mv_per_2mb(avc_state->seq_param->level_idc) / 2;
4385 cmd->dw1.bi_Weight = avc_state->bi_weight;
4386 cmd->dw3.search_ctrl = 7;
4387 cmd->dw3.skip_type = 1;
4388 cmd->dw5.ref_width = cmd->dw39.ref_width = ref_width;
4389 cmd->dw5.ref_height = cmd->dw39.ref_height = ref_height;
4390 cmd->dw7.skip_center_mask = 0xff;
4391
4392 cmd->dw47.intra_cost_sf = avc_state->adaptive_intra_scaling_enable ?
4393 gen9_avc_adaptive_intra_scaling_factor[qp] :
4394 gen9_avc_intra_scaling_factor[qp];
4395
4396 cmd->dw47.max_vmv_r =
4397 i965_avc_get_max_mv_len(avc_state->seq_param->level_idc) * 4;//frame only
4398
4399 cmd->dw36.hme_combine_overlap = 1;
4400
4401 //check is_fwd_frame_short_term_ref
4402 surface_id = slice_param->RefPicList1[0].picture_id;
4403 obj_surface = SURFACE(surface_id);
4404 if (!obj_surface) {
4405 WARN_ONCE("Invalid backward reference frame\n");
4406 if (gpe_context)
4407 i965_gpe_context_unmap_curbe(gpe_context);
4408 return;
4409 }
4410 cmd->dw36.is_fwd_frame_short_term_ref = !!(slice_param->RefPicList1[0].flags & VA_PICTURE_H264_SHORT_TERM_REFERENCE);
4411
4412 cmd->dw36.num_ref_idx_l0_minus_one =
4413 (avc_state->multi_pre_enable) ? slice_param->num_ref_idx_l0_active_minus1
4414 : 0;
4415 cmd->dw36.num_ref_idx_l1_minus_one =
4416 (avc_state->multi_pre_enable) ? slice_param->num_ref_idx_l1_active_minus1
4417 : 0;
4418 cmd->dw36.check_all_fractional_enable = fei_param->repartition_check_enable;
4419
4420 cmd->dw40.dist_scale_factor_ref_id0_list0 = avc_state->dist_scale_factor_list0[0];
4421 cmd->dw40.dist_scale_factor_ref_id1_list0 = avc_state->dist_scale_factor_list0[1];
4422 cmd->dw41.dist_scale_factor_ref_id2_list0 = avc_state->dist_scale_factor_list0[2];
4423 cmd->dw41.dist_scale_factor_ref_id3_list0 = avc_state->dist_scale_factor_list0[3];
4424 cmd->dw42.dist_scale_factor_ref_id4_list0 = avc_state->dist_scale_factor_list0[4];
4425 cmd->dw42.dist_scale_factor_ref_id5_list0 = avc_state->dist_scale_factor_list0[5];
4426 cmd->dw43.dist_scale_factor_ref_id6_list0 = avc_state->dist_scale_factor_list0[6];
4427 cmd->dw43.dist_scale_factor_ref_id7_list0 = avc_state->dist_scale_factor_list0[7];
4428
4429 cmd->dw34.enable_direct_bias_adjustment = avc_state->direct_bias_adjustment_enable;
4430 if (cmd->dw34.enable_direct_bias_adjustment) {
4431 cmd->dw7.non_skip_mode_added = 1;
4432 cmd->dw7.non_skip_zmv_added = 1;
4433 }
4434
4435 cmd->dw34.enable_global_motion_bias_adjustment =
4436 avc_state->global_motion_bias_adjustment_enable;
4437 if (avc_state->global_motion_bias_adjustment_enable)
4438 cmd->dw59.hme_mv_cost_scaling_factor = avc_state->hme_mv_cost_scaling_factor;
4439
4440 cmd->dw64.num_mv_predictors_l0 = fei_param->num_mv_predictors_l0;
4441 cmd->dw64.num_mv_predictors_l1 = fei_param->num_mv_predictors_l1;
4442 }
4443
4444 avc_state->block_based_skip_enable = cmd->dw3.block_based_skip_enable;
4445
4446 if (avc_state->rolling_intra_refresh_enable) {
4447 //Not supported
4448 cmd->dw34.widi_intra_refresh_en = avc_state->rolling_intra_refresh_enable;
4449
4450 } else {
4451 cmd->dw34.widi_intra_refresh_en = 0;
4452 }
4453 cmd->dw34.enable_per_mb_static_check = avc_state->sfd_enable && generic_state->hme_enabled;
4454 cmd->dw34.enable_adaptive_search_window_size = avc_state->adaptive_search_window_enable;
4455
4456 /* Fixme: Skipped ROI stuffs for now */
4457
4458 /* r64: FEI specific fields */
4459 cmd->dw64.fei_enable = 1;
4460 cmd->dw64.multiple_mv_predictor_per_mb_enable = fei_param->mv_predictor_enable;
4461 if (fei_param->distortion != VA_INVALID_ID)
4462 cmd->dw64.vme_distortion_output_enable = 1;
4463 cmd->dw64.per_mb_qp_enable = fei_param->mb_qp;
4464 cmd->dw64.mb_input_enable = fei_param->mb_input;
4465
4466 // FEI mode is disabled when external MVP is available
4467 if (fei_param->mv_predictor_enable)
4468 cmd->dw64.fei_mode = 0;
4469 else
4470 cmd->dw64.fei_mode = 1;
4471
4472 cmd->dw80.mb_data_surf_index = GEN9_AVC_MBENC_MFC_AVC_PAK_OBJ_INDEX;
4473 cmd->dw81.mv_data_surf_index = GEN9_AVC_MBENC_IND_MV_DATA_INDEX;
4474 cmd->dw82.i_dist_surf_index = GEN9_AVC_MBENC_BRC_DISTORTION_INDEX;
4475 cmd->dw83.src_y_surf_index = GEN9_AVC_MBENC_CURR_Y_INDEX;
4476 cmd->dw84.mb_specific_data_surf_index = GEN9_AVC_MBENC_MB_SPECIFIC_DATA_INDEX;
4477 cmd->dw85.aux_vme_out_surf_index = GEN9_AVC_MBENC_AUX_VME_OUT_INDEX;
4478 cmd->dw86.curr_ref_pic_sel_surf_index = GEN9_AVC_MBENC_REFPICSELECT_L0_INDEX;
4479 cmd->dw87.hme_mv_pred_fwd_bwd_surf_index = GEN9_AVC_MBENC_MV_DATA_FROM_ME_INDEX;
4480 cmd->dw88.hme_dist_surf_index = GEN9_AVC_MBENC_4XME_DISTORTION_INDEX;
4481 cmd->dw89.slice_map_surf_index = GEN9_AVC_MBENC_SLICEMAP_DATA_INDEX;
4482 cmd->dw90.fwd_frm_mb_data_surf_index = GEN9_AVC_MBENC_FWD_MB_DATA_INDEX;
4483 cmd->dw91.fwd_frm_mv_surf_index = GEN9_AVC_MBENC_FWD_MV_DATA_INDEX;
4484 cmd->dw92.mb_qp_buffer = GEN9_AVC_MBENC_MBQP_INDEX;
4485 cmd->dw93.mb_brc_lut = GEN9_AVC_MBENC_MBBRC_CONST_DATA_INDEX;
4486 cmd->dw94.vme_inter_prediction_surf_index = GEN9_AVC_MBENC_VME_INTER_PRED_CURR_PIC_IDX_0_INDEX;
4487 cmd->dw95.vme_inter_prediction_mr_surf_index = GEN9_AVC_MBENC_VME_INTER_PRED_CURR_PIC_IDX_1_INDEX;
4488 cmd->dw96.mb_stats_surf_index = GEN9_AVC_MBENC_MB_STATS_INDEX;
4489 cmd->dw97.mad_surf_index = GEN9_AVC_MBENC_MAD_DATA_INDEX;
4490 cmd->dw98.force_non_skip_mb_map_surface = GEN9_AVC_MBENC_FORCE_NONSKIP_MB_MAP_INDEX;
4491 cmd->dw99.widi_wa_surf_index = GEN9_AVC_MBENC_WIDI_WA_INDEX;
4492 cmd->dw100.brc_curbe_surf_index = GEN9_AVC_MBENC_BRC_CURBE_DATA_INDEX;
4493 cmd->dw101.static_detection_cost_table_index = GEN9_AVC_MBENC_SFD_COST_TABLE_INDEX;
4494 cmd->dw102.fei_mv_predictor_surf_index = GEN9_AVC_MBENC_MV_PREDICTOR_INDEX;
4495 i965_gpe_context_unmap_curbe(gpe_context);
4496
4497 return;
4498 }
4499
4500 static void
4501 gen9_avc_send_surface_mbenc(VADriverContextP ctx,
4502 struct encode_state *encode_state,
4503 struct i965_gpe_context *gpe_context,
4504 struct intel_encoder_context *encoder_context,
4505 void * param_mbenc)
4506 {
4507 struct i965_driver_data *i965 = i965_driver_data(ctx);
4508 struct encoder_vme_mfc_context * vme_context = (struct encoder_vme_mfc_context *)encoder_context->vme_context;
4509 struct i965_avc_encoder_context * avc_ctx = (struct i965_avc_encoder_context *)vme_context->private_enc_ctx;
4510 struct generic_enc_codec_state * generic_state = (struct generic_enc_codec_state *)vme_context->generic_enc_state;
4511 struct avc_enc_state * avc_state = (struct avc_enc_state *)vme_context->private_enc_state;
4512 struct object_surface *obj_surface;
4513 struct gen9_surface_avc *avc_priv_surface;
4514 struct i965_gpe_resource *gpe_resource;
4515 struct mbenc_param * param = (struct mbenc_param *)param_mbenc ;
4516 VASurfaceID surface_id;
4517 unsigned int mbenc_i_frame_dist_in_use = param->mbenc_i_frame_dist_in_use;
4518 unsigned int size = 0;
4519 unsigned int frame_mb_size = generic_state->frame_width_in_mbs *
4520 generic_state->frame_height_in_mbs;
4521 int i = 0;
4522 VAEncSliceParameterBufferH264 * slice_param = avc_state->slice_param[0];
4523 unsigned char is_g95 = 0;
4524
4525 if (IS_SKL(i965->intel.device_info) ||
4526 IS_BXT(i965->intel.device_info))
4527 is_g95 = 0;
4528 else if (IS_KBL(i965->intel.device_info) ||
4529 IS_GEN10(i965->intel.device_info) ||
4530 IS_GLK(i965->intel.device_info))
4531 is_g95 = 1;
4532
4533 obj_surface = encode_state->reconstructed_object;
4534
4535 if (!obj_surface || !obj_surface->private_data)
4536 return;
4537 avc_priv_surface = obj_surface->private_data;
4538
4539 /*pak obj command buffer output*/
4540 size = frame_mb_size * 16 * 4;
4541 gpe_resource = &avc_priv_surface->res_mb_code_surface;
4542 i965_add_buffer_gpe_surface(ctx,
4543 gpe_context,
4544 gpe_resource,
4545 0,
4546 size / 4,
4547 0,
4548 GEN9_AVC_MBENC_MFC_AVC_PAK_OBJ_INDEX);
4549
4550 /*mv data buffer output*/
4551 size = frame_mb_size * 32 * 4;
4552 gpe_resource = &avc_priv_surface->res_mv_data_surface;
4553 i965_add_buffer_gpe_surface(ctx,
4554 gpe_context,
4555 gpe_resource,
4556 0,
4557 size / 4,
4558 0,
4559 GEN9_AVC_MBENC_IND_MV_DATA_INDEX);
4560
4561 /*input current YUV surface, current input Y/UV object*/
4562 if (mbenc_i_frame_dist_in_use) {
4563 obj_surface = encode_state->reconstructed_object;
4564 if (!obj_surface || !obj_surface->private_data)
4565 return;
4566 avc_priv_surface = obj_surface->private_data;
4567 obj_surface = avc_priv_surface->scaled_4x_surface_obj;
4568 } else {
4569 obj_surface = encode_state->input_yuv_object;
4570 }
4571 i965_add_2d_gpe_surface(ctx,
4572 gpe_context,
4573 obj_surface,
4574 0,
4575 1,
4576 I965_SURFACEFORMAT_R8_UNORM,
4577 GEN9_AVC_MBENC_CURR_Y_INDEX);
4578
4579 i965_add_2d_gpe_surface(ctx,
4580 gpe_context,
4581 obj_surface,
4582 1,
4583 1,
4584 I965_SURFACEFORMAT_R16_UINT,
4585 GEN9_AVC_MBENC_CURR_UV_INDEX);
4586
4587 if (generic_state->hme_enabled) {
4588 /*memv input 4x*/
4589 if (!IS_GEN8(i965->intel.device_info)) {
4590 gpe_resource = &(avc_ctx->s4x_memv_data_buffer);
4591 i965_add_buffer_2d_gpe_surface(ctx, gpe_context,
4592 gpe_resource,
4593 1,
4594 I965_SURFACEFORMAT_R8_UNORM,
4595 GEN9_AVC_MBENC_MV_DATA_FROM_ME_INDEX);
4596 /* memv distortion input*/
4597 gpe_resource = &(avc_ctx->s4x_memv_distortion_buffer);
4598 i965_add_buffer_2d_gpe_surface(ctx, gpe_context,
4599 gpe_resource,
4600 1,
4601 I965_SURFACEFORMAT_R8_UNORM,
4602 GEN9_AVC_MBENC_4XME_DISTORTION_INDEX);
4603 } else if (generic_state->frame_type != SLICE_TYPE_I) {
4604 gpe_resource = &(avc_ctx->s4x_memv_data_buffer);
4605 i965_add_buffer_2d_gpe_surface(ctx, gpe_context,
4606 gpe_resource,
4607 1,
4608 I965_SURFACEFORMAT_R8_UNORM,
4609 GEN9_AVC_MBENC_MV_DATA_FROM_ME_INDEX);
4610 /* memv distortion input*/
4611 gpe_resource = &(avc_ctx->s4x_memv_distortion_buffer);
4612 i965_add_buffer_2d_gpe_surface(ctx, gpe_context,
4613 gpe_resource,
4614 1,
4615 I965_SURFACEFORMAT_R8_UNORM,
4616 GEN9_AVC_MBENC_4XME_DISTORTION_INDEX);
4617 }
4618 }
4619
4620 /*mbbrc const data_buffer*/
4621 if (param->mb_const_data_buffer_in_use) {
4622 size = 16 * AVC_QP_MAX * sizeof(unsigned int);
4623 gpe_resource = &avc_ctx->res_mbbrc_const_data_buffer;
4624 i965_add_buffer_gpe_surface(ctx,
4625 gpe_context,
4626 gpe_resource,
4627 0,
4628 size / 4,
4629 0,
4630 GEN9_AVC_MBENC_MBBRC_CONST_DATA_INDEX);
4631
4632 }
4633
4634 /*mb qp data_buffer*/
4635 if (param->mb_qp_buffer_in_use) {
4636 if (avc_state->mb_qp_data_enable)
4637 gpe_resource = &(avc_ctx->res_mb_qp_data_surface);
4638 else
4639 gpe_resource = &(avc_ctx->res_mbbrc_mb_qp_data_surface);
4640 i965_add_buffer_2d_gpe_surface(ctx, gpe_context,
4641 gpe_resource,
4642 1,
4643 I965_SURFACEFORMAT_R8_UNORM,
4644 GEN9_AVC_MBENC_MBQP_INDEX);
4645 }
4646
4647 /*input current YUV surface, current input Y/UV object*/
4648 if (mbenc_i_frame_dist_in_use) {
4649 obj_surface = encode_state->reconstructed_object;
4650 if (!obj_surface || !obj_surface->private_data)
4651 return;
4652 avc_priv_surface = obj_surface->private_data;
4653 obj_surface = avc_priv_surface->scaled_4x_surface_obj;
4654 } else {
4655 obj_surface = encode_state->input_yuv_object;
4656 }
4657 i965_add_adv_gpe_surface(ctx, gpe_context,
4658 obj_surface,
4659 GEN9_AVC_MBENC_VME_INTER_PRED_CURR_PIC_IDX_0_INDEX);
4660 /*input ref YUV surface*/
4661 for (i = 0; i < slice_param->num_ref_idx_l0_active_minus1 + 1; i++) {
4662 surface_id = slice_param->RefPicList0[i].picture_id;
4663 obj_surface = SURFACE(surface_id);
4664 if (!obj_surface || !obj_surface->private_data)
4665 break;
4666
4667 i965_add_adv_gpe_surface(ctx, gpe_context,
4668 obj_surface,
4669 GEN9_AVC_MBENC_VME_INTER_PRED_CURR_PIC_IDX_0_INDEX + i * 2 + 1);
4670 }
4671 /*input current YUV surface, current input Y/UV object*/
4672 if (mbenc_i_frame_dist_in_use) {
4673 obj_surface = encode_state->reconstructed_object;
4674 if (!obj_surface || !obj_surface->private_data)
4675 return;
4676 avc_priv_surface = obj_surface->private_data;
4677 obj_surface = avc_priv_surface->scaled_4x_surface_obj;
4678 } else {
4679 obj_surface = encode_state->input_yuv_object;
4680 }
4681 i965_add_adv_gpe_surface(ctx, gpe_context,
4682 obj_surface,
4683 GEN9_AVC_MBENC_VME_INTER_PRED_CURR_PIC_IDX_1_INDEX);
4684
4685 for (i = 0; i < slice_param->num_ref_idx_l1_active_minus1 + 1; i++) {
4686 if (i > 0) break; // only one ref supported here for B frame
4687 surface_id = slice_param->RefPicList1[i].picture_id;
4688 obj_surface = SURFACE(surface_id);
4689 if (!obj_surface || !obj_surface->private_data)
4690 break;
4691
4692 i965_add_adv_gpe_surface(ctx, gpe_context,
4693 obj_surface,
4694 GEN9_AVC_MBENC_VME_INTER_PRED_CURR_PIC_IDX_1_INDEX + i * 2 + 1);
4695 i965_add_adv_gpe_surface(ctx, gpe_context,
4696 obj_surface,
4697 GEN9_AVC_MBENC_VME_INTER_PRED_CURR_PIC_IDX_0_INDEX + i * 2 + 2);
4698 if (i == 0) {
4699 avc_priv_surface = obj_surface->private_data;
4700 /*pak obj command buffer output(mb code)*/
4701 size = frame_mb_size * 16 * 4;
4702 gpe_resource = &avc_priv_surface->res_mb_code_surface;
4703 i965_add_buffer_gpe_surface(ctx,
4704 gpe_context,
4705 gpe_resource,
4706 0,
4707 size / 4,
4708 0,
4709 GEN9_AVC_MBENC_FWD_MB_DATA_INDEX);
4710
4711 /*mv data buffer output*/
4712 size = frame_mb_size * 32 * 4;
4713 gpe_resource = &avc_priv_surface->res_mv_data_surface;
4714 i965_add_buffer_gpe_surface(ctx,
4715 gpe_context,
4716 gpe_resource,
4717 0,
4718 size / 4,
4719 0,
4720 GEN9_AVC_MBENC_FWD_MV_DATA_INDEX);
4721
4722 }
4723
4724 if (i < INTEL_AVC_MAX_BWD_REF_NUM) {
4725 i965_add_adv_gpe_surface(ctx, gpe_context,
4726 obj_surface,
4727 GEN9_AVC_MBENC_VME_INTER_PRED_CURR_PIC_IDX_1_INDEX + i * 2 + 1 + INTEL_AVC_MAX_BWD_REF_NUM);
4728 }
4729
4730 }
4731
4732 /* BRC distortion data buffer for I frame*/
4733 if (mbenc_i_frame_dist_in_use) {
4734 gpe_resource = &(avc_ctx->res_brc_dist_data_surface);
4735 i965_add_buffer_2d_gpe_surface(ctx, gpe_context,
4736 gpe_resource,
4737 1,
4738 I965_SURFACEFORMAT_R8_UNORM,
4739 GEN9_AVC_MBENC_BRC_DISTORTION_INDEX);
4740 }
4741
4742 /* as ref frame ,update later RefPicSelect of Current Picture*/
4743 obj_surface = encode_state->reconstructed_object;
4744 avc_priv_surface = obj_surface->private_data;
4745 if (avc_state->ref_pic_select_list_supported && avc_priv_surface->is_as_ref) {
4746 gpe_resource = &(avc_priv_surface->res_ref_pic_select_surface);
4747 i965_add_buffer_2d_gpe_surface(ctx, gpe_context,
4748 gpe_resource,
4749 1,
4750 I965_SURFACEFORMAT_R8_UNORM,
4751 GEN9_AVC_MBENC_REFPICSELECT_L0_INDEX);
4752
4753 }
4754 if (!IS_GEN8(i965->intel.device_info)) {
4755 if (param->mb_vproc_stats_enable) {
4756 /*mb status buffer input*/
4757 size = frame_mb_size * 16 * 4;
4758 gpe_resource = &(avc_ctx->res_mb_status_buffer);
4759 i965_add_buffer_gpe_surface(ctx,
4760 gpe_context,
4761 gpe_resource,
4762 0,
4763 size / 4,
4764 0,
4765 GEN9_AVC_MBENC_MB_STATS_INDEX);
4766
4767 } else if (avc_state->flatness_check_enable) {
4768 gpe_resource = &(avc_ctx->res_flatness_check_surface);
4769 i965_add_buffer_2d_gpe_surface(ctx, gpe_context,
4770 gpe_resource,
4771 1,
4772 I965_SURFACEFORMAT_R8_UNORM,
4773 GEN9_AVC_MBENC_MB_STATS_INDEX);
4774 }
4775 } else if (avc_state->flatness_check_enable) {
4776 gpe_resource = &(avc_ctx->res_flatness_check_surface);
4777 i965_add_buffer_2d_gpe_surface(ctx, gpe_context,
4778 gpe_resource,
4779 1,
4780 I965_SURFACEFORMAT_R8_UNORM,
4781 GEN9_AVC_MBENC_MB_STATS_INDEX);
4782 }
4783
4784 if (param->mad_enable) {
4785 /*mad buffer input*/
4786 size = 4;
4787 gpe_resource = &(avc_ctx->res_mad_data_buffer);
4788 i965_add_buffer_gpe_surface(ctx,
4789 gpe_context,
4790 gpe_resource,
4791 0,
4792 size / 4,
4793 0,
4794 GEN9_AVC_MBENC_MAD_DATA_INDEX);
4795 i965_zero_gpe_resource(gpe_resource);
4796 }
4797
4798 /*brc updated mbenc curbe data buffer,it is ignored by gen9 and used in gen95*/
4799 if (avc_state->mbenc_brc_buffer_size > 0) {
4800 size = avc_state->mbenc_brc_buffer_size;
4801 gpe_resource = &(avc_ctx->res_mbenc_brc_buffer);
4802 i965_add_buffer_gpe_surface(ctx,
4803 gpe_context,
4804 gpe_resource,
4805 0,
4806 size / 4,
4807 0,
4808 GEN95_AVC_MBENC_BRC_CURBE_DATA_INDEX);
4809 }
4810
4811 /*artitratry num mbs in slice*/
4812 if (avc_state->arbitrary_num_mbs_in_slice) {
4813 /*slice surface input*/
4814 gpe_resource = &(avc_ctx->res_mbenc_slice_map_surface);
4815 i965_add_buffer_2d_gpe_surface(ctx, gpe_context,
4816 gpe_resource,
4817 1,
4818 I965_SURFACEFORMAT_R8_UNORM,
4819 GEN9_AVC_MBENC_SLICEMAP_DATA_INDEX);
4820 gen9_avc_generate_slice_map(ctx, encode_state, encoder_context);
4821 }
4822
4823 /* BRC distortion data buffer for I frame */
4824 if (!mbenc_i_frame_dist_in_use) {
4825 if (avc_state->mb_disable_skip_map_enable) {
4826 gpe_resource = &(avc_ctx->res_mb_disable_skip_map_surface);
4827 i965_add_buffer_2d_gpe_surface(ctx, gpe_context,
4828 gpe_resource,
4829 1,
4830 I965_SURFACEFORMAT_R8_UNORM,
4831 (is_g95 ? GEN95_AVC_MBENC_FORCE_NONSKIP_MB_MAP_INDEX : GEN9_AVC_MBENC_FORCE_NONSKIP_MB_MAP_INDEX));
4832 }
4833 if (IS_GEN8(i965->intel.device_info)) {
4834 if (avc_state->sfd_enable) {
4835 size = 128 / sizeof(unsigned long);
4836 gpe_resource = &(avc_ctx->res_sfd_output_buffer);
4837 i965_add_buffer_gpe_surface(ctx,
4838 gpe_context,
4839 gpe_resource,
4840 0,
4841 size / 4,
4842 0,
4843 GEN8_AVC_MBENC_STATIC_FRAME_DETECTION_OUTPUT_CM);
4844
4845 }
4846 } else {
4847 if (avc_state->sfd_enable && generic_state->hme_enabled) {
4848 if (generic_state->frame_type == SLICE_TYPE_P) {
4849 gpe_resource = &(avc_ctx->res_sfd_cost_table_p_frame_buffer);
4850 } else if (generic_state->frame_type == SLICE_TYPE_B) {
4851 gpe_resource = &(avc_ctx->res_sfd_cost_table_b_frame_buffer);
4852 }
4853 if (generic_state->frame_type != SLICE_TYPE_I) {
4854 size = 64;
4855 i965_add_buffer_gpe_surface(ctx,
4856 gpe_context,
4857 gpe_resource,
4858 0,
4859 size / 4,
4860 0,
4861 (is_g95 ? GEN95_AVC_MBENC_SFD_COST_TABLE_INDEX : GEN9_AVC_MBENC_SFD_COST_TABLE_INDEX));
4862
4863
4864 }
4865 }
4866 }
4867 }
4868 return;
4869 }
4870
4871 static void
4872 gen9_avc_fei_send_surface_mbenc(VADriverContextP ctx,
4873 struct encode_state *encode_state,
4874 struct i965_gpe_context *gpe_context,
4875 struct intel_encoder_context *encoder_context,
4876 void * param_mbenc)
4877 {
4878 struct i965_driver_data *i965 = i965_driver_data(ctx);
4879 struct encoder_vme_mfc_context * vme_context = (struct encoder_vme_mfc_context *)encoder_context->vme_context;
4880 struct generic_enc_codec_state * generic_state = (struct generic_enc_codec_state *)vme_context->generic_enc_state;
4881 struct avc_enc_state * avc_state = (struct avc_enc_state *)vme_context->private_enc_state;
4882 VAEncSliceParameterBufferH264 * slice_param = avc_state->slice_param[0];
4883 VAEncMiscParameterFEIFrameControlH264 *fei_param = NULL;
4884 struct object_buffer *obj_buffer = NULL;
4885 struct buffer_store *buffer_store = NULL;
4886 struct object_surface *obj_surface = NULL;
4887 struct gen9_surface_avc *avc_priv_surface;
4888 struct i965_gpe_resource *gpe_resource;
4889 VASurfaceID surface_id;
4890 unsigned int size = 0;
4891 unsigned int frame_mb_nums;
4892 int i = 0, allocate_flag = 1;
4893
4894 obj_surface = encode_state->reconstructed_object;
4895 if (!obj_surface || !obj_surface->private_data)
4896 return;
4897 avc_priv_surface = obj_surface->private_data;
4898
4899 frame_mb_nums = generic_state->frame_width_in_mbs *
4900 generic_state->frame_height_in_mbs;
4901 fei_param = avc_state->fei_framectl_param;
4902
4903 assert(fei_param != NULL);
4904
4905 /* res_mb_code_surface for MB code */
4906 size = frame_mb_nums * FEI_AVC_MB_CODE_BUFFER_SIZE;
4907 if (avc_priv_surface->res_mb_code_surface.bo != NULL)
4908 i965_free_gpe_resource(&avc_priv_surface->res_mb_code_surface);
4909 if (fei_param->mb_code_data != VA_INVALID_ID) {
4910 obj_buffer = BUFFER(fei_param->mb_code_data);
4911 assert(obj_buffer != NULL);
4912 buffer_store = obj_buffer->buffer_store;
4913 assert(size <= buffer_store->bo->size);
4914 i965_dri_object_to_buffer_gpe_resource(
4915 &avc_priv_surface->res_mb_code_surface,
4916 buffer_store->bo);
4917 } else {
4918 allocate_flag = i965_allocate_gpe_resource(i965->intel.bufmgr,
4919 &avc_priv_surface->res_mb_code_surface,
4920 ALIGN(size, 0x1000),
4921 "mb code buffer");
4922 assert(allocate_flag != 0);
4923 }
4924
4925 /* res_mv_data_surface for MV data */
4926 size = frame_mb_nums * FEI_AVC_MV_DATA_BUFFER_SIZE;
4927 if (avc_priv_surface->res_mv_data_surface.bo != NULL)
4928 i965_free_gpe_resource(&avc_priv_surface->res_mv_data_surface);
4929 if (fei_param->mv_data != VA_INVALID_ID) {
4930 obj_buffer = BUFFER(fei_param->mv_data);
4931 assert(obj_buffer != NULL);
4932 buffer_store = obj_buffer->buffer_store;
4933 assert(size <= buffer_store->bo->size);
4934 i965_dri_object_to_buffer_gpe_resource(
4935 &avc_priv_surface->res_mv_data_surface,
4936 buffer_store->bo);
4937 } else {
4938 allocate_flag = i965_allocate_gpe_resource(i965->intel.bufmgr,
4939 &avc_priv_surface->res_mv_data_surface,
4940 ALIGN(size, 0x1000),
4941 "mv data buffer");
4942 assert(allocate_flag != 0);
4943 }
4944
4945 /* fei mb control data surface */
4946 size = frame_mb_nums * FEI_AVC_MB_CONTROL_BUFFER_SIZE;
4947 if (fei_param->mb_input | fei_param->mb_size_ctrl) {
4948 assert(fei_param->mb_ctrl != VA_INVALID_ID);
4949 obj_buffer = BUFFER(fei_param->mb_ctrl);
4950 assert(obj_buffer != NULL);
4951 buffer_store = obj_buffer->buffer_store;
4952 assert(size <= buffer_store->bo->size);
4953 if (avc_priv_surface->res_fei_mb_cntrl_surface.bo != NULL)
4954 i965_free_gpe_resource(&avc_priv_surface->res_fei_mb_cntrl_surface);
4955 i965_dri_object_to_buffer_gpe_resource(
4956 &avc_priv_surface->res_fei_mb_cntrl_surface,
4957 buffer_store->bo);
4958 }
4959
4960 /* fei mv predictor surface*/
4961 size = frame_mb_nums * FEI_AVC_MV_PREDICTOR_BUFFER_SIZE;
4962 if (fei_param->mv_predictor_enable &&
4963 (fei_param->mv_predictor != VA_INVALID_ID)) {
4964 obj_buffer = BUFFER(fei_param->mv_predictor);
4965 assert(obj_buffer != NULL);
4966 buffer_store = obj_buffer->buffer_store;
4967 assert(size <= buffer_store->bo->size);
4968 if (avc_priv_surface->res_fei_mv_predictor_surface.bo != NULL)
4969 i965_free_gpe_resource(&avc_priv_surface->res_fei_mv_predictor_surface);
4970 i965_dri_object_to_buffer_gpe_resource(
4971 &avc_priv_surface->res_fei_mv_predictor_surface,
4972 buffer_store->bo);
4973 } else {
4974 if (fei_param->mv_predictor_enable)
4975 assert(fei_param->mv_predictor != VA_INVALID_ID);
4976 }
4977
4978 /* fei vme distortion */
4979 size = frame_mb_nums * FEI_AVC_DISTORTION_BUFFER_SIZE;
4980 if (avc_priv_surface->res_fei_vme_distortion_surface.bo != NULL)
4981 i965_free_gpe_resource(&avc_priv_surface->res_fei_vme_distortion_surface);
4982 if (fei_param->distortion != VA_INVALID_ID) {
4983 obj_buffer = BUFFER(fei_param->distortion);
4984 assert(obj_buffer != NULL);
4985 buffer_store = obj_buffer->buffer_store;
4986 assert(size <= buffer_store->bo->size);
4987 i965_dri_object_to_buffer_gpe_resource(
4988 &avc_priv_surface->res_fei_vme_distortion_surface,
4989 buffer_store->bo);
4990 } else {
4991 allocate_flag = i965_allocate_gpe_resource(i965->intel.bufmgr,
4992 &avc_priv_surface->res_fei_vme_distortion_surface,
4993 ALIGN(size, 0x1000),
4994 "fei vme distortion");
4995 assert(allocate_flag != 0);
4996 }
4997
4998 /* fei mb qp */
4999 /* Fixme/Confirm: not sure why we need 3 byte padding here */
5000 size = frame_mb_nums * FEI_AVC_QP_BUFFER_SIZE + 3;
5001 if (fei_param->mb_qp && (fei_param->qp != VA_INVALID_ID)) {
5002 obj_buffer = BUFFER(fei_param->qp);
5003 assert(obj_buffer != NULL);
5004 buffer_store = obj_buffer->buffer_store;
5005 assert((size - 3) <= buffer_store->bo->size);
5006 if (avc_priv_surface->res_fei_mb_qp_surface.bo != NULL)
5007 i965_free_gpe_resource(&avc_priv_surface->res_fei_mb_qp_surface);
5008 i965_dri_object_to_buffer_gpe_resource(
5009 &avc_priv_surface->res_fei_mb_qp_surface,
5010 buffer_store->bo);
5011 } else {
5012 if (fei_param->mb_qp)
5013 assert(fei_param->qp != VA_INVALID_ID);
5014 }
5015
5016 /*==== pak obj command buffer output ====*/
5017 size = frame_mb_nums * FEI_AVC_MB_CODE_BUFFER_SIZE;
5018 gpe_resource = &avc_priv_surface->res_mb_code_surface;
5019 i965_add_buffer_gpe_surface(ctx,
5020 gpe_context,
5021 gpe_resource,
5022 0,
5023 size / 4,
5024 0,
5025 GEN9_AVC_MBENC_MFC_AVC_PAK_OBJ_INDEX);
5026
5027
5028 /*=== mv data buffer output */
5029 size = frame_mb_nums * FEI_AVC_MV_DATA_BUFFER_SIZE;
5030 gpe_resource = &avc_priv_surface->res_mv_data_surface;
5031 i965_add_buffer_gpe_surface(ctx,
5032 gpe_context,
5033 gpe_resource,
5034 0,
5035 size / 4,
5036 0,
5037 GEN9_AVC_MBENC_IND_MV_DATA_INDEX);
5038
5039
5040 /* === current input Y (binding table offset = 3)=== */
5041 obj_surface = encode_state->input_yuv_object;
5042 i965_add_2d_gpe_surface(ctx,
5043 gpe_context,
5044 obj_surface,
5045 0,
5046 1,
5047 I965_SURFACEFORMAT_R8_UNORM,
5048 GEN9_AVC_MBENC_CURR_Y_INDEX);
5049
5050 /* === current input UV === (binding table offset == 4)*/
5051 i965_add_2d_gpe_surface(ctx,
5052 gpe_context,
5053 obj_surface,
5054 1,
5055 1,
5056 I965_SURFACEFORMAT_R16_UINT,
5057 GEN9_AVC_MBENC_CURR_UV_INDEX);
5058
5059 /* === input current YUV surface, (binding table offset == 15) === */
5060 i965_add_adv_gpe_surface(ctx, gpe_context,
5061 obj_surface,
5062 GEN9_AVC_MBENC_VME_INTER_PRED_CURR_PIC_IDX_0_INDEX);
5063
5064
5065 /*== input current YUV surface, (binding table offset == 32)*/
5066 i965_add_adv_gpe_surface(ctx, gpe_context,
5067 obj_surface,
5068 GEN9_AVC_MBENC_VME_INTER_PRED_CURR_PIC_IDX_1_INDEX);
5069
5070 /* list 0 references */
5071 for (i = 0; i < slice_param->num_ref_idx_l0_active_minus1 + 1; i++) {
5072
5073 surface_id = slice_param->RefPicList0[i].picture_id;
5074 obj_surface = SURFACE(surface_id);
5075 if (!obj_surface || !obj_surface->private_data)
5076 break;
5077 i965_add_adv_gpe_surface(ctx, gpe_context,
5078 obj_surface,
5079 GEN9_AVC_MBENC_VME_INTER_PRED_CURR_PIC_IDX_0_INDEX + i * 2 + 1);
5080 }
5081
5082
5083 /* list 1 references */
5084 for (i = 0; i < slice_param->num_ref_idx_l1_active_minus1 + 1; i++) {
5085 if (i > 0) break; // only one ref supported here for B frame
5086 surface_id = slice_param->RefPicList1[i].picture_id;
5087 obj_surface = SURFACE(surface_id);
5088 if (!obj_surface || !obj_surface->private_data)
5089 break;
5090
5091 i965_add_adv_gpe_surface(ctx, gpe_context,
5092 obj_surface,
5093 GEN9_AVC_MBENC_VME_INTER_PRED_CURR_PIC_IDX_0_INDEX + i * 2 + 2);
5094 if (i == 0) {
5095 avc_priv_surface = obj_surface->private_data;
5096 /* mb code of Backward reference frame */
5097 size = frame_mb_nums * FEI_AVC_MB_CODE_BUFFER_SIZE;
5098 gpe_resource = &avc_priv_surface->res_mb_code_surface;
5099 i965_add_buffer_gpe_surface(ctx,
5100 gpe_context,
5101 gpe_resource,
5102 0,
5103 size / 4,
5104 0,
5105 GEN9_AVC_MBENC_FWD_MB_DATA_INDEX);
5106
5107 /* mv data of backward ref frame */
5108 size = frame_mb_nums * FEI_AVC_MV_DATA_BUFFER_SIZE;
5109 gpe_resource = &avc_priv_surface->res_mv_data_surface;
5110 i965_add_buffer_gpe_surface(ctx,
5111 gpe_context,
5112 gpe_resource,
5113 0,
5114 size / 4,
5115 0,
5116 GEN9_AVC_MBENC_FWD_MV_DATA_INDEX);
5117
5118 }
5119 //again
5120 if (i < INTEL_AVC_MAX_BWD_REF_NUM) {
5121 i965_add_adv_gpe_surface(ctx, gpe_context,
5122 obj_surface,
5123 GEN9_AVC_MBENC_VME_INTER_PRED_CURR_PIC_IDX_1_INDEX + i * 2 + 1);
5124 }
5125 }
5126
5127 /* as ref frame ,update later RefPicSelect of Current Picture*/
5128 obj_surface = encode_state->reconstructed_object;
5129 avc_priv_surface = obj_surface->private_data;
5130 if (avc_state->ref_pic_select_list_supported && avc_priv_surface->is_as_ref) {
5131 gpe_resource = &(avc_priv_surface->res_ref_pic_select_surface);
5132 i965_add_buffer_2d_gpe_surface(ctx, gpe_context,
5133 gpe_resource,
5134 1,
5135 I965_SURFACEFORMAT_R8_UNORM,
5136 GEN9_AVC_MBENC_REFPICSELECT_L0_INDEX);
5137
5138 }
5139
5140
5141 /* mb specific data, macroblock control parameters */
5142 if ((fei_param->mb_input | fei_param->mb_size_ctrl) &&
5143 (fei_param->mb_ctrl != VA_INVALID_ID)) {
5144 size = frame_mb_nums * FEI_AVC_MB_CONTROL_BUFFER_SIZE;
5145 gpe_resource = &avc_priv_surface->res_fei_mb_cntrl_surface;
5146 i965_add_buffer_gpe_surface(ctx,
5147 gpe_context,
5148 gpe_resource,
5149 0,
5150 size / 4,
5151 0,
5152 GEN9_AVC_MBENC_MB_SPECIFIC_DATA_INDEX);
5153 }
5154
5155 /* multi mv predictor surface */
5156 if (fei_param->mv_predictor_enable && (fei_param->mv_predictor != VA_INVALID_ID)) {
5157 size = frame_mb_nums * 48; //sizeof (VAEncMVPredictorH264Intel) == 40
5158 gpe_resource = &avc_priv_surface->res_fei_mv_predictor_surface;
5159 i965_add_buffer_gpe_surface(ctx,
5160 gpe_context,
5161 gpe_resource,
5162 0,
5163 size / 4,
5164 0,
5165 GEN9_AVC_MBENC_MV_PREDICTOR_INDEX);
5166 }
5167
5168 /* mb qp */
5169 if (fei_param->mb_qp && (fei_param->qp != VA_INVALID_ID)) {
5170 size = frame_mb_nums + 3;
5171 gpe_resource = &avc_priv_surface->res_fei_mb_qp_surface,
5172 i965_add_buffer_gpe_surface(ctx,
5173 gpe_context,
5174 gpe_resource,
5175 0,
5176 size / 4,
5177 0,
5178 GEN9_AVC_MBENC_MBQP_INDEX);
5179 }
5180
5181
5182 /*=== FEI distortion surface ====*/
5183 size = frame_mb_nums * 48; //sizeof (VAEncFEIDistortionBufferH264Intel) == 48
5184 gpe_resource = &avc_priv_surface->res_fei_vme_distortion_surface;
5185 i965_add_buffer_gpe_surface(ctx,
5186 gpe_context,
5187 gpe_resource,
5188 0,
5189 size / 4,
5190 0,
5191 GEN9_AVC_MBENC_AUX_VME_OUT_INDEX);
5192
5193 return;
5194 }
5195
5196 static VAStatus
5197 gen9_avc_kernel_mbenc(VADriverContextP ctx,
5198 struct encode_state *encode_state,
5199 struct intel_encoder_context *encoder_context,
5200 bool i_frame_dist_in_use)
5201 {
5202 struct i965_driver_data *i965 = i965_driver_data(ctx);
5203 struct i965_gpe_table *gpe = &i965->gpe_table;
5204 struct encoder_vme_mfc_context * vme_context = (struct encoder_vme_mfc_context *)encoder_context->vme_context;
5205 struct generic_encoder_context * generic_ctx = (struct generic_encoder_context *)vme_context->generic_enc_ctx;
5206 struct i965_avc_encoder_context * avc_ctx = (struct i965_avc_encoder_context *)vme_context->private_enc_ctx;
5207 struct generic_enc_codec_state * generic_state = (struct generic_enc_codec_state *)vme_context->generic_enc_state;
5208 struct avc_enc_state * avc_state = (struct avc_enc_state *)vme_context->private_enc_state;
5209
5210 struct i965_gpe_context *gpe_context;
5211 struct gpe_media_object_walker_parameter media_object_walker_param;
5212 struct gpe_encoder_kernel_walker_parameter kernel_walker_param;
5213 unsigned int downscaled_width_in_mb, downscaled_height_in_mb;
5214 int media_function = 0;
5215 int kernel_idx = 0;
5216 unsigned int mb_const_data_buffer_in_use = 0;
5217 unsigned int mb_qp_buffer_in_use = 0;
5218 unsigned int brc_enabled = 0;
5219 unsigned int roi_enable = (generic_state->num_roi > 0) ? 1 : 0;
5220 unsigned int dirty_roi_enable = ((generic_state->dirty_num_roi > 0) && (generic_state->frame_type == SLICE_TYPE_P) && (0));
5221 struct mbenc_param param ;
5222
5223 int mbenc_i_frame_dist_in_use = i_frame_dist_in_use;
5224 int mad_enable = 0;
5225 VAEncSliceParameterBufferH264 * slice_param = avc_state->slice_param[0];
5226
5227 mb_const_data_buffer_in_use =
5228 generic_state->mb_brc_enabled ||
5229 roi_enable ||
5230 dirty_roi_enable ||
5231 avc_state->mb_qp_data_enable ||
5232 avc_state->rolling_intra_refresh_enable;
5233 mb_qp_buffer_in_use =
5234 generic_state->mb_brc_enabled ||
5235 generic_state->brc_roi_enable ||
5236 avc_state->mb_qp_data_enable;
5237
5238 if (mbenc_i_frame_dist_in_use) {
5239 media_function = INTEL_MEDIA_STATE_ENC_I_FRAME_DIST;
5240 kernel_idx = GEN9_AVC_KERNEL_BRC_I_FRAME_DIST;
5241 downscaled_width_in_mb = generic_state->downscaled_width_4x_in_mb;
5242 downscaled_height_in_mb = generic_state->downscaled_height_4x_in_mb;
5243 mad_enable = 0;
5244 brc_enabled = 0;
5245
5246 gpe_context = &(avc_ctx->context_brc.gpe_contexts[kernel_idx]);
5247 } else {
5248 switch (generic_state->kernel_mode) {
5249 case INTEL_ENC_KERNEL_NORMAL : {
5250 media_function = INTEL_MEDIA_STATE_ENC_NORMAL;
5251 kernel_idx = MBENC_KERNEL_BASE + GEN9_AVC_KERNEL_MBENC_NORMAL_I;
5252 break;
5253 }
5254 case INTEL_ENC_KERNEL_PERFORMANCE : {
5255 media_function = INTEL_MEDIA_STATE_ENC_PERFORMANCE;
5256 kernel_idx = MBENC_KERNEL_BASE + GEN9_AVC_KERNEL_MBENC_PERFORMANCE_I;
5257 break;
5258 }
5259 case INTEL_ENC_KERNEL_QUALITY : {
5260 media_function = INTEL_MEDIA_STATE_ENC_QUALITY;
5261 kernel_idx = MBENC_KERNEL_BASE + GEN9_AVC_KERNEL_MBENC_QUALITY_I;
5262 break;
5263 }
5264 default:
5265 assert(0);
5266
5267 }
5268
5269 if (encoder_context->fei_enabled) {
5270 media_function = INTEL_MEDIA_STATE_ENC_NORMAL;
5271 kernel_idx = MBENC_KERNEL_BASE + GEN9_AVC_FEI_KERNEL_I;
5272 }
5273
5274 if (generic_state->frame_type == SLICE_TYPE_P) {
5275 kernel_idx += 1;
5276 } else if (generic_state->frame_type == SLICE_TYPE_B) {
5277 kernel_idx += 2;
5278 }
5279
5280 downscaled_width_in_mb = generic_state->frame_width_in_mbs;
5281 downscaled_height_in_mb = generic_state->frame_height_in_mbs;
5282 mad_enable = avc_state->mad_enable;
5283 brc_enabled = generic_state->brc_enabled;
5284
5285 gpe_context = &(avc_ctx->context_mbenc.gpe_contexts[kernel_idx]);
5286 }
5287
5288 memset(&param, 0, sizeof(struct mbenc_param));
5289
5290 param.mb_const_data_buffer_in_use = mb_const_data_buffer_in_use;
5291 param.mb_qp_buffer_in_use = mb_qp_buffer_in_use;
5292 param.mbenc_i_frame_dist_in_use = mbenc_i_frame_dist_in_use;
5293 param.mad_enable = mad_enable;
5294 param.brc_enabled = brc_enabled;
5295 param.roi_enabled = roi_enable;
5296
5297 if (avc_state->mb_status_supported) {
5298 param.mb_vproc_stats_enable = avc_state->flatness_check_enable || avc_state->adaptive_transform_decision_enable;
5299 }
5300
5301 if (!avc_state->mbenc_curbe_set_in_brc_update) {
5302 gpe->context_init(ctx, gpe_context);
5303 }
5304
5305 gpe->reset_binding_table(ctx, gpe_context);
5306
5307 if (!avc_state->mbenc_curbe_set_in_brc_update) {
5308 /*set curbe here*/
5309 generic_ctx->pfn_set_curbe_mbenc(ctx, encode_state, gpe_context, encoder_context, &param);
5310 }
5311
5312 /* MB brc const data buffer set up*/
5313 if (mb_const_data_buffer_in_use) {
5314 // caculate the lambda table, it is kernel controlled trellis quantization,gen95+
5315 if (avc_state->lambda_table_enable)
5316 gen95_avc_calc_lambda_table(ctx, encode_state, encoder_context);
5317
5318 gen9_avc_load_mb_brc_const_data(ctx, encode_state, encoder_context);
5319 }
5320
5321 /*clear the mad buffer*/
5322 if (mad_enable) {
5323 i965_zero_gpe_resource(&(avc_ctx->res_mad_data_buffer));
5324 }
5325 /*send surface*/
5326 generic_ctx->pfn_send_mbenc_surface(ctx, encode_state, gpe_context, encoder_context, &param);
5327
5328 gpe->setup_interface_data(ctx, gpe_context);
5329
5330 /*walker setting*/
5331 memset(&kernel_walker_param, 0, sizeof(kernel_walker_param));
5332
5333 kernel_walker_param.use_scoreboard = 1;
5334 kernel_walker_param.resolution_x = downscaled_width_in_mb ;
5335 kernel_walker_param.resolution_y = downscaled_height_in_mb ;
5336 if (mbenc_i_frame_dist_in_use) {
5337 kernel_walker_param.no_dependency = 1;
5338 } else {
5339 switch (generic_state->frame_type) {
5340 case SLICE_TYPE_I:
5341 kernel_walker_param.walker_degree = WALKER_45_DEGREE;
5342 break;
5343 case SLICE_TYPE_P:
5344 kernel_walker_param.walker_degree = WALKER_26_DEGREE;
5345 break;
5346 case SLICE_TYPE_B:
5347 kernel_walker_param.walker_degree = WALKER_26_DEGREE;
5348 if (!slice_param->direct_spatial_mv_pred_flag) {
5349 kernel_walker_param.walker_degree = WALKER_45_DEGREE;
5350 }
5351 break;
5352 default:
5353 assert(0);
5354 }
5355 kernel_walker_param.no_dependency = 0;
5356 }
5357
5358 i965_init_media_object_walker_parameter(&kernel_walker_param, &media_object_walker_param);
5359
5360 gen9_avc_run_kernel_media_object_walker(ctx, encoder_context,
5361 gpe_context,
5362 media_function,
5363 &media_object_walker_param);
5364 return VA_STATUS_SUCCESS;
5365 }
5366
5367 /*
5368 me kernle related function
5369 */
5370 static void
5371 gen9_avc_set_curbe_me(VADriverContextP ctx,
5372 struct encode_state *encode_state,
5373 struct i965_gpe_context *gpe_context,
5374 struct intel_encoder_context *encoder_context,
5375 void * param)
5376 {
5377 gen9_avc_me_curbe_data *curbe_cmd;
5378 struct encoder_vme_mfc_context * vme_context = (struct encoder_vme_mfc_context *)encoder_context->vme_context;
5379 struct generic_enc_codec_state * generic_state = (struct generic_enc_codec_state *)vme_context->generic_enc_state;
5380 struct avc_enc_state * avc_state = (struct avc_enc_state *)vme_context->private_enc_state;
5381
5382 VAEncSliceParameterBufferH264 * slice_param = avc_state->slice_param[0];
5383
5384 struct me_param * curbe_param = (struct me_param *)param ;
5385 unsigned char use_mv_from_prev_step = 0;
5386 unsigned char write_distortions = 0;
5387 unsigned char qp_prime_y = 0;
5388 unsigned char me_method = gen9_avc_p_me_method[generic_state->preset];
5389 unsigned char seach_table_idx = 0;
5390 unsigned char mv_shift_factor = 0, prev_mv_read_pos_factor = 0;
5391 unsigned int downscaled_width_in_mb, downscaled_height_in_mb;
5392 unsigned int scale_factor = 0;
5393
5394 qp_prime_y = avc_state->pic_param->pic_init_qp + slice_param->slice_qp_delta;
5395 switch (curbe_param->hme_type) {
5396 case INTEL_ENC_HME_4x : {
5397 use_mv_from_prev_step = (generic_state->b16xme_enabled) ? 1 : 0;
5398 write_distortions = 1;
5399 mv_shift_factor = 2;
5400 scale_factor = 4;
5401 prev_mv_read_pos_factor = 0;
5402 break;
5403 }
5404 case INTEL_ENC_HME_16x : {
5405 use_mv_from_prev_step = (generic_state->b32xme_enabled) ? 1 : 0;
5406 write_distortions = 0;
5407 mv_shift_factor = 2;
5408 scale_factor = 16;
5409 prev_mv_read_pos_factor = 1;
5410 break;
5411 }
5412 case INTEL_ENC_HME_32x : {
5413 use_mv_from_prev_step = 0;
5414 write_distortions = 0;
5415 mv_shift_factor = 1;
5416 scale_factor = 32;
5417 prev_mv_read_pos_factor = 0;
5418 break;
5419 }
5420 default:
5421 assert(0);
5422
5423 }
5424 curbe_cmd = i965_gpe_context_map_curbe(gpe_context);
5425
5426 if (!curbe_cmd)
5427 return;
5428
5429 downscaled_width_in_mb = ALIGN(generic_state->frame_width_in_pixel / scale_factor, 16) / 16;
5430 downscaled_height_in_mb = ALIGN(generic_state->frame_height_in_pixel / scale_factor, 16) / 16;
5431
5432 memcpy(curbe_cmd, gen9_avc_me_curbe_init_data, sizeof(gen9_avc_me_curbe_data));
5433
5434 curbe_cmd->dw3.sub_pel_mode = 3;
5435 if (avc_state->field_scaling_output_interleaved) {
5436 /*frame set to zero,field specified*/
5437 curbe_cmd->dw3.src_access = 0;
5438 curbe_cmd->dw3.ref_access = 0;
5439 curbe_cmd->dw7.src_field_polarity = 0;
5440 }
5441 curbe_cmd->dw4.picture_height_minus1 = downscaled_height_in_mb - 1;
5442 curbe_cmd->dw4.picture_width = downscaled_width_in_mb;
5443 curbe_cmd->dw5.qp_prime_y = qp_prime_y;
5444
5445 curbe_cmd->dw6.use_mv_from_prev_step = use_mv_from_prev_step;
5446 curbe_cmd->dw6.write_distortions = write_distortions;
5447 curbe_cmd->dw6.super_combine_dist = gen9_avc_super_combine_dist[generic_state->preset];
5448 curbe_cmd->dw6.max_vmvr = i965_avc_get_max_mv_len(avc_state->seq_param->level_idc) * 4;//frame only
5449
5450 if (generic_state->frame_type == SLICE_TYPE_B) {
5451 curbe_cmd->dw1.bi_weight = 32;
5452 curbe_cmd->dw13.num_ref_idx_l1_minus1 = slice_param->num_ref_idx_l1_active_minus1;
5453 me_method = gen9_avc_b_me_method[generic_state->preset];
5454 seach_table_idx = 1;
5455 }
5456
5457 if (generic_state->frame_type == SLICE_TYPE_P ||
5458 generic_state->frame_type == SLICE_TYPE_B)
5459 curbe_cmd->dw13.num_ref_idx_l0_minus1 = slice_param->num_ref_idx_l0_active_minus1;
5460
5461 curbe_cmd->dw13.ref_streamin_cost = 5;
5462 curbe_cmd->dw13.roi_enable = 0;
5463
5464 curbe_cmd->dw15.prev_mv_read_pos_factor = prev_mv_read_pos_factor;
5465 curbe_cmd->dw15.mv_shift_factor = mv_shift_factor;
5466
5467 memcpy(&curbe_cmd->dw16, table_enc_search_path[seach_table_idx][me_method], 14 * sizeof(int));
5468
5469 curbe_cmd->dw32._4x_memv_output_data_surf_index = GEN9_AVC_ME_MV_DATA_SURFACE_INDEX;
5470 curbe_cmd->dw33._16x_32x_memv_input_data_surf_index = (curbe_param->hme_type == INTEL_ENC_HME_32x) ? GEN9_AVC_32XME_MV_DATA_SURFACE_INDEX : GEN9_AVC_16XME_MV_DATA_SURFACE_INDEX ;
5471 curbe_cmd->dw34._4x_me_output_dist_surf_index = GEN9_AVC_ME_DISTORTION_SURFACE_INDEX;
5472 curbe_cmd->dw35._4x_me_output_brc_dist_surf_index = GEN9_AVC_ME_BRC_DISTORTION_INDEX;
5473 curbe_cmd->dw36.vme_fwd_inter_pred_surf_index = GEN9_AVC_ME_CURR_FOR_FWD_REF_INDEX;
5474 curbe_cmd->dw37.vme_bdw_inter_pred_surf_index = GEN9_AVC_ME_CURR_FOR_BWD_REF_INDEX;
5475 curbe_cmd->dw38.reserved = GEN9_AVC_ME_VDENC_STREAMIN_INDEX;
5476
5477 i965_gpe_context_unmap_curbe(gpe_context);
5478 return;
5479 }
5480
5481 static void
5482 gen9_avc_send_surface_me(VADriverContextP ctx,
5483 struct encode_state *encode_state,
5484 struct i965_gpe_context *gpe_context,
5485 struct intel_encoder_context *encoder_context,
5486 void * param)
5487 {
5488 struct i965_driver_data *i965 = i965_driver_data(ctx);
5489
5490 struct encoder_vme_mfc_context * vme_context = (struct encoder_vme_mfc_context *)encoder_context->vme_context;
5491 struct generic_enc_codec_state * generic_state = (struct generic_enc_codec_state *)vme_context->generic_enc_state;
5492 struct i965_avc_encoder_context * avc_ctx = (struct i965_avc_encoder_context *)vme_context->private_enc_ctx;
5493 struct avc_enc_state * avc_state = (struct avc_enc_state *)vme_context->private_enc_state;
5494
5495 struct object_surface *obj_surface, *input_surface;
5496 struct gen9_surface_avc *avc_priv_surface;
5497 struct i965_gpe_resource *gpe_resource;
5498 struct me_param * curbe_param = (struct me_param *)param ;
5499
5500 VAEncSliceParameterBufferH264 * slice_param = avc_state->slice_param[0];
5501 VASurfaceID surface_id;
5502 int i = 0;
5503
5504 /* all scaled input surface stored in reconstructed_object*/
5505 obj_surface = encode_state->reconstructed_object;
5506 if (!obj_surface || !obj_surface->private_data)
5507 return;
5508 avc_priv_surface = obj_surface->private_data;
5509
5510
5511 switch (curbe_param->hme_type) {
5512 case INTEL_ENC_HME_4x : {
5513 /*memv output 4x*/
5514 gpe_resource = &avc_ctx->s4x_memv_data_buffer;
5515 i965_add_buffer_2d_gpe_surface(ctx, gpe_context,
5516 gpe_resource,
5517 1,
5518 I965_SURFACEFORMAT_R8_UNORM,
5519 GEN9_AVC_ME_MV_DATA_SURFACE_INDEX);
5520
5521 /*memv input 16x*/
5522 if (generic_state->b16xme_enabled) {
5523 gpe_resource = &avc_ctx->s16x_memv_data_buffer;
5524 i965_add_buffer_2d_gpe_surface(ctx, gpe_context,
5525 gpe_resource,
5526 1,
5527 I965_SURFACEFORMAT_R8_UNORM,
5528 GEN9_AVC_16XME_MV_DATA_SURFACE_INDEX);
5529 }
5530 /* brc distortion output*/
5531 gpe_resource = &avc_ctx->res_brc_dist_data_surface;
5532 i965_add_buffer_2d_gpe_surface(ctx, gpe_context,
5533 gpe_resource,
5534 1,
5535 I965_SURFACEFORMAT_R8_UNORM,
5536 GEN9_AVC_ME_BRC_DISTORTION_INDEX);
5537 /* memv distortion output*/
5538 gpe_resource = &avc_ctx->s4x_memv_distortion_buffer;
5539 i965_add_buffer_2d_gpe_surface(ctx, gpe_context,
5540 gpe_resource,
5541 1,
5542 I965_SURFACEFORMAT_R8_UNORM,
5543 GEN9_AVC_ME_DISTORTION_SURFACE_INDEX);
5544 /*input current down scaled YUV surface*/
5545 obj_surface = encode_state->reconstructed_object;
5546 avc_priv_surface = obj_surface->private_data;
5547 input_surface = avc_priv_surface->scaled_4x_surface_obj;
5548 i965_add_adv_gpe_surface(ctx, gpe_context,
5549 input_surface,
5550 GEN9_AVC_ME_CURR_FOR_FWD_REF_INDEX);
5551 /*input ref scaled YUV surface*/
5552 for (i = 0; i < slice_param->num_ref_idx_l0_active_minus1 + 1; i++) {
5553 surface_id = slice_param->RefPicList0[i].picture_id;
5554 obj_surface = SURFACE(surface_id);
5555 if (!obj_surface || !obj_surface->private_data)
5556 break;
5557 avc_priv_surface = obj_surface->private_data;
5558
5559 input_surface = avc_priv_surface->scaled_4x_surface_obj;
5560
5561 i965_add_adv_gpe_surface(ctx, gpe_context,
5562 input_surface,
5563 GEN9_AVC_ME_CURR_FOR_FWD_REF_INDEX + i * 2 + 1);
5564 }
5565
5566 obj_surface = encode_state->reconstructed_object;
5567 avc_priv_surface = obj_surface->private_data;
5568 input_surface = avc_priv_surface->scaled_4x_surface_obj;
5569
5570 i965_add_adv_gpe_surface(ctx, gpe_context,
5571 input_surface,
5572 GEN9_AVC_ME_CURR_FOR_BWD_REF_INDEX);
5573
5574 for (i = 0; i < slice_param->num_ref_idx_l1_active_minus1 + 1; i++) {
5575 surface_id = slice_param->RefPicList1[i].picture_id;
5576 obj_surface = SURFACE(surface_id);
5577 if (!obj_surface || !obj_surface->private_data)
5578 break;
5579 avc_priv_surface = obj_surface->private_data;
5580
5581 input_surface = avc_priv_surface->scaled_4x_surface_obj;
5582
5583 i965_add_adv_gpe_surface(ctx, gpe_context,
5584 input_surface,
5585 GEN9_AVC_ME_CURR_FOR_BWD_REF_INDEX + i * 2 + 1);
5586 }
5587 break;
5588
5589 }
5590 case INTEL_ENC_HME_16x : {
5591 gpe_resource = &avc_ctx->s16x_memv_data_buffer;
5592 i965_add_buffer_2d_gpe_surface(ctx, gpe_context,
5593 gpe_resource,
5594 1,
5595 I965_SURFACEFORMAT_R8_UNORM,
5596 GEN9_AVC_ME_MV_DATA_SURFACE_INDEX);
5597
5598 if (generic_state->b32xme_enabled) {
5599 gpe_resource = &avc_ctx->s32x_memv_data_buffer;
5600 i965_add_buffer_2d_gpe_surface(ctx, gpe_context,
5601 gpe_resource,
5602 1,
5603 I965_SURFACEFORMAT_R8_UNORM,
5604 GEN9_AVC_32XME_MV_DATA_SURFACE_INDEX);
5605 }
5606
5607 obj_surface = encode_state->reconstructed_object;
5608 avc_priv_surface = obj_surface->private_data;
5609 input_surface = avc_priv_surface->scaled_16x_surface_obj;
5610 i965_add_adv_gpe_surface(ctx, gpe_context,
5611 input_surface,
5612 GEN9_AVC_ME_CURR_FOR_FWD_REF_INDEX);
5613
5614 for (i = 0; i < slice_param->num_ref_idx_l0_active_minus1 + 1; i++) {
5615 surface_id = slice_param->RefPicList0[i].picture_id;
5616 obj_surface = SURFACE(surface_id);
5617 if (!obj_surface || !obj_surface->private_data)
5618 break;
5619 avc_priv_surface = obj_surface->private_data;
5620
5621 input_surface = avc_priv_surface->scaled_16x_surface_obj;
5622
5623 i965_add_adv_gpe_surface(ctx, gpe_context,
5624 input_surface,
5625 GEN9_AVC_ME_CURR_FOR_FWD_REF_INDEX + i * 2 + 1);
5626 }
5627
5628 obj_surface = encode_state->reconstructed_object;
5629 avc_priv_surface = obj_surface->private_data;
5630 input_surface = avc_priv_surface->scaled_16x_surface_obj;
5631
5632 i965_add_adv_gpe_surface(ctx, gpe_context,
5633 input_surface,
5634 GEN9_AVC_ME_CURR_FOR_BWD_REF_INDEX);
5635
5636 for (i = 0; i < slice_param->num_ref_idx_l1_active_minus1 + 1; i++) {
5637 surface_id = slice_param->RefPicList1[i].picture_id;
5638 obj_surface = SURFACE(surface_id);
5639 if (!obj_surface || !obj_surface->private_data)
5640 break;
5641 avc_priv_surface = obj_surface->private_data;
5642
5643 input_surface = avc_priv_surface->scaled_16x_surface_obj;
5644
5645 i965_add_adv_gpe_surface(ctx, gpe_context,
5646 input_surface,
5647 GEN9_AVC_ME_CURR_FOR_BWD_REF_INDEX + i * 2 + 1);
5648 }
5649 break;
5650 }
5651 case INTEL_ENC_HME_32x : {
5652 gpe_resource = &avc_ctx->s32x_memv_data_buffer;
5653 i965_add_buffer_2d_gpe_surface(ctx, gpe_context,
5654 gpe_resource,
5655 1,
5656 I965_SURFACEFORMAT_R8_UNORM,
5657 GEN9_AVC_ME_MV_DATA_SURFACE_INDEX);
5658
5659 obj_surface = encode_state->reconstructed_object;
5660 avc_priv_surface = obj_surface->private_data;
5661 input_surface = avc_priv_surface->scaled_32x_surface_obj;
5662 i965_add_adv_gpe_surface(ctx, gpe_context,
5663 input_surface,
5664 GEN9_AVC_ME_CURR_FOR_FWD_REF_INDEX);
5665
5666 for (i = 0; i < slice_param->num_ref_idx_l0_active_minus1 + 1; i++) {
5667 surface_id = slice_param->RefPicList0[i].picture_id;
5668 obj_surface = SURFACE(surface_id);
5669 if (!obj_surface || !obj_surface->private_data)
5670 break;
5671 avc_priv_surface = obj_surface->private_data;
5672
5673 input_surface = avc_priv_surface->scaled_32x_surface_obj;
5674
5675 i965_add_adv_gpe_surface(ctx, gpe_context,
5676 input_surface,
5677 GEN9_AVC_ME_CURR_FOR_FWD_REF_INDEX + i * 2 + 1);
5678 }
5679
5680 obj_surface = encode_state->reconstructed_object;
5681 avc_priv_surface = obj_surface->private_data;
5682 input_surface = avc_priv_surface->scaled_32x_surface_obj;
5683
5684 i965_add_adv_gpe_surface(ctx, gpe_context,
5685 input_surface,
5686 GEN9_AVC_ME_CURR_FOR_BWD_REF_INDEX);
5687
5688 for (i = 0; i < slice_param->num_ref_idx_l1_active_minus1 + 1; i++) {
5689 surface_id = slice_param->RefPicList1[i].picture_id;
5690 obj_surface = SURFACE(surface_id);
5691 if (!obj_surface || !obj_surface->private_data)
5692 break;
5693 avc_priv_surface = obj_surface->private_data;
5694
5695 input_surface = avc_priv_surface->scaled_32x_surface_obj;
5696
5697 i965_add_adv_gpe_surface(ctx, gpe_context,
5698 input_surface,
5699 GEN9_AVC_ME_CURR_FOR_BWD_REF_INDEX + i * 2 + 1);
5700 }
5701 break;
5702 }
5703 default:
5704 assert(0);
5705
5706 }
5707 }
5708
5709 static VAStatus
5710 gen9_avc_kernel_me(VADriverContextP ctx,
5711 struct encode_state *encode_state,
5712 struct intel_encoder_context *encoder_context,
5713 int hme_type)
5714 {
5715 struct i965_driver_data *i965 = i965_driver_data(ctx);
5716 struct i965_gpe_table *gpe = &i965->gpe_table;
5717 struct encoder_vme_mfc_context * vme_context = (struct encoder_vme_mfc_context *)encoder_context->vme_context;
5718 struct generic_encoder_context * generic_ctx = (struct generic_encoder_context *)vme_context->generic_enc_ctx;
5719 struct i965_avc_encoder_context * avc_ctx = (struct i965_avc_encoder_context *)vme_context->private_enc_ctx;
5720 struct generic_enc_codec_state * generic_state = (struct generic_enc_codec_state *)vme_context->generic_enc_state;
5721
5722 struct i965_gpe_context *gpe_context;
5723 struct gpe_media_object_walker_parameter media_object_walker_param;
5724 struct gpe_encoder_kernel_walker_parameter kernel_walker_param;
5725 unsigned int downscaled_width_in_mb, downscaled_height_in_mb;
5726 int media_function = 0;
5727 int kernel_idx = 0;
5728 struct me_param param ;
5729 unsigned int scale_factor = 0;
5730
5731 switch (hme_type) {
5732 case INTEL_ENC_HME_4x : {
5733 media_function = INTEL_MEDIA_STATE_4X_ME;
5734 scale_factor = 4;
5735 break;
5736 }
5737 case INTEL_ENC_HME_16x : {
5738 media_function = INTEL_MEDIA_STATE_16X_ME;
5739 scale_factor = 16;
5740 break;
5741 }
5742 case INTEL_ENC_HME_32x : {
5743 media_function = INTEL_MEDIA_STATE_32X_ME;
5744 scale_factor = 32;
5745 break;
5746 }
5747 default:
5748 assert(0);
5749
5750 }
5751
5752 downscaled_width_in_mb = ALIGN(generic_state->frame_width_in_pixel / scale_factor, 16) / 16;
5753 downscaled_height_in_mb = ALIGN(generic_state->frame_height_in_pixel / scale_factor, 16) / 16;
5754
5755 /* I frame should not come here.*/
5756 kernel_idx = (generic_state->frame_type == SLICE_TYPE_P) ? GEN9_AVC_KERNEL_ME_P_IDX : GEN9_AVC_KERNEL_ME_B_IDX;
5757 gpe_context = &(avc_ctx->context_me.gpe_contexts[kernel_idx]);
5758
5759 gpe->context_init(ctx, gpe_context);
5760 gpe->reset_binding_table(ctx, gpe_context);
5761
5762 /*set curbe*/
5763 memset(&param, 0, sizeof(param));
5764 param.hme_type = hme_type;
5765 generic_ctx->pfn_set_curbe_me(ctx, encode_state, gpe_context, encoder_context, &param);
5766
5767 /*send surface*/
5768 generic_ctx->pfn_send_me_surface(ctx, encode_state, gpe_context, encoder_context, &param);
5769
5770 gpe->setup_interface_data(ctx, gpe_context);
5771
5772 memset(&kernel_walker_param, 0, sizeof(kernel_walker_param));
5773 /* the scaling is based on 8x8 blk level */
5774 kernel_walker_param.resolution_x = downscaled_width_in_mb ;
5775 kernel_walker_param.resolution_y = downscaled_height_in_mb ;
5776 kernel_walker_param.no_dependency = 1;
5777
5778 i965_init_media_object_walker_parameter(&kernel_walker_param, &media_object_walker_param);
5779
5780 gen9_avc_run_kernel_media_object_walker(ctx, encoder_context,
5781 gpe_context,
5782 media_function,
5783 &media_object_walker_param);
5784
5785 return VA_STATUS_SUCCESS;
5786 }
5787
5788 /*
5789 wp related function
5790 */
5791 static void
5792 gen9_avc_set_curbe_wp(VADriverContextP ctx,
5793 struct encode_state *encode_state,
5794 struct i965_gpe_context *gpe_context,
5795 struct intel_encoder_context *encoder_context,
5796 void * param)
5797 {
5798 gen9_avc_wp_curbe_data *cmd;
5799 struct encoder_vme_mfc_context * vme_context = (struct encoder_vme_mfc_context *)encoder_context->vme_context;
5800 struct avc_enc_state * avc_state = (struct avc_enc_state *)vme_context->private_enc_state;
5801 VAEncSliceParameterBufferH264 * slice_param = avc_state->slice_param[0];
5802 struct wp_param * curbe_param = (struct wp_param *)param;
5803
5804 cmd = i965_gpe_context_map_curbe(gpe_context);
5805
5806 if (!cmd)
5807 return;
5808 memset(cmd, 0, sizeof(gen9_avc_wp_curbe_data));
5809 if (curbe_param->ref_list_idx) {
5810 cmd->dw0.default_weight = slice_param->luma_weight_l1[0];
5811 cmd->dw0.default_offset = slice_param->luma_offset_l1[0];
5812 } else {
5813 cmd->dw0.default_weight = slice_param->luma_weight_l0[0];
5814 cmd->dw0.default_offset = slice_param->luma_offset_l0[0];
5815 }
5816
5817 cmd->dw49.input_surface = GEN9_AVC_WP_INPUT_REF_SURFACE_INDEX;
5818 cmd->dw50.output_surface = GEN9_AVC_WP_OUTPUT_SCALED_SURFACE_INDEX;
5819
5820 i965_gpe_context_unmap_curbe(gpe_context);
5821
5822 }
5823
5824 static void
5825 gen9_avc_send_surface_wp(VADriverContextP ctx,
5826 struct encode_state *encode_state,
5827 struct i965_gpe_context *gpe_context,
5828 struct intel_encoder_context *encoder_context,
5829 void * param)
5830 {
5831 struct i965_driver_data *i965 = i965_driver_data(ctx);
5832 struct encoder_vme_mfc_context * vme_context = (struct encoder_vme_mfc_context *)encoder_context->vme_context;
5833 struct i965_avc_encoder_context * avc_ctx = (struct i965_avc_encoder_context *)vme_context->private_enc_ctx;
5834 struct avc_enc_state * avc_state = (struct avc_enc_state *)vme_context->private_enc_state;
5835 struct wp_param * curbe_param = (struct wp_param *)param;
5836 struct object_surface *obj_surface;
5837 VAEncSliceParameterBufferH264 * slice_param = avc_state->slice_param[0];
5838 VASurfaceID surface_id;
5839
5840 if (curbe_param->ref_list_idx) {
5841 surface_id = slice_param->RefPicList1[0].picture_id;
5842 obj_surface = SURFACE(surface_id);
5843 if (!obj_surface || !obj_surface->private_data)
5844 avc_state->weighted_ref_l1_enable = 0;
5845 else
5846 avc_state->weighted_ref_l1_enable = 1;
5847 } else {
5848 surface_id = slice_param->RefPicList0[0].picture_id;
5849 obj_surface = SURFACE(surface_id);
5850 if (!obj_surface || !obj_surface->private_data)
5851 avc_state->weighted_ref_l0_enable = 0;
5852 else
5853 avc_state->weighted_ref_l0_enable = 1;
5854 }
5855 if (!obj_surface)
5856 obj_surface = encode_state->reference_objects[0];
5857
5858
5859 i965_add_adv_gpe_surface(ctx, gpe_context,
5860 obj_surface,
5861 GEN9_AVC_WP_INPUT_REF_SURFACE_INDEX);
5862
5863 obj_surface = avc_ctx->wp_output_pic_select_surface_obj[curbe_param->ref_list_idx];
5864 i965_add_adv_gpe_surface(ctx, gpe_context,
5865 obj_surface,
5866 GEN9_AVC_WP_OUTPUT_SCALED_SURFACE_INDEX);
5867 }
5868
5869
5870 static VAStatus
5871 gen9_avc_kernel_wp(VADriverContextP ctx,
5872 struct encode_state *encode_state,
5873 struct intel_encoder_context *encoder_context,
5874 unsigned int list1_in_use)
5875 {
5876 struct i965_driver_data *i965 = i965_driver_data(ctx);
5877 struct i965_gpe_table *gpe = &i965->gpe_table;
5878 struct encoder_vme_mfc_context * vme_context = (struct encoder_vme_mfc_context *)encoder_context->vme_context;
5879 struct i965_avc_encoder_context * avc_ctx = (struct i965_avc_encoder_context *)vme_context->private_enc_ctx;
5880 struct generic_enc_codec_state * generic_state = (struct generic_enc_codec_state *)vme_context->generic_enc_state;
5881 struct generic_encoder_context * generic_ctx = (struct generic_encoder_context *)vme_context->generic_enc_ctx;
5882
5883 struct i965_gpe_context *gpe_context;
5884 struct gpe_media_object_walker_parameter media_object_walker_param;
5885 struct gpe_encoder_kernel_walker_parameter kernel_walker_param;
5886 int media_function = INTEL_MEDIA_STATE_ENC_WP;
5887 struct wp_param param;
5888
5889 gpe_context = &(avc_ctx->context_wp.gpe_contexts);
5890
5891 gpe->context_init(ctx, gpe_context);
5892 gpe->reset_binding_table(ctx, gpe_context);
5893
5894 memset(&param, 0, sizeof(param));
5895 param.ref_list_idx = (list1_in_use == 1) ? 1 : 0;
5896 /*set curbe*/
5897 generic_ctx->pfn_set_curbe_wp(ctx, encode_state, gpe_context, encoder_context, &param);
5898
5899 /*send surface*/
5900 generic_ctx->pfn_send_wp_surface(ctx, encode_state, gpe_context, encoder_context, &param);
5901
5902 gpe->setup_interface_data(ctx, gpe_context);
5903
5904 memset(&kernel_walker_param, 0, sizeof(kernel_walker_param));
5905 /* the scaling is based on 8x8 blk level */
5906 kernel_walker_param.resolution_x = generic_state->frame_width_in_mbs;
5907 kernel_walker_param.resolution_y = generic_state->frame_height_in_mbs;
5908 kernel_walker_param.no_dependency = 1;
5909
5910 i965_init_media_object_walker_parameter(&kernel_walker_param, &media_object_walker_param);
5911
5912 gen9_avc_run_kernel_media_object_walker(ctx, encoder_context,
5913 gpe_context,
5914 media_function,
5915 &media_object_walker_param);
5916
5917 return VA_STATUS_SUCCESS;
5918 }
5919
5920
5921 /*
5922 sfd related function
5923 */
5924 static void
5925 gen9_avc_set_curbe_sfd(VADriverContextP ctx,
5926 struct encode_state *encode_state,
5927 struct i965_gpe_context *gpe_context,
5928 struct intel_encoder_context *encoder_context,
5929 void * param)
5930 {
5931 gen9_avc_sfd_curbe_data *cmd;
5932 struct encoder_vme_mfc_context * vme_context = (struct encoder_vme_mfc_context *)encoder_context->vme_context;
5933 struct generic_enc_codec_state * generic_state = (struct generic_enc_codec_state *)vme_context->generic_enc_state;
5934 struct avc_enc_state * avc_state = (struct avc_enc_state *)vme_context->private_enc_state;
5935 VAEncSliceParameterBufferH264 * slice_param = avc_state->slice_param[0];
5936
5937 cmd = i965_gpe_context_map_curbe(gpe_context);
5938
5939 if (!cmd)
5940 return;
5941 memset(cmd, 0, sizeof(gen9_avc_sfd_curbe_data));
5942
5943 cmd->dw0.enable_intra_cost_scaling_for_static_frame = 1 ;
5944 cmd->dw0.enable_adaptive_mv_stream_in = 0 ;
5945 cmd->dw0.stream_in_type = 7 ;
5946 cmd->dw0.slice_type = slice_type_kernel[generic_state->frame_type] ;
5947 cmd->dw0.brc_mode_enable = generic_state->brc_enabled ;
5948 cmd->dw0.vdenc_mode_disable = 1 ;
5949
5950 cmd->dw1.hme_stream_in_ref_cost = 5 ;
5951 cmd->dw1.num_of_refs = slice_param->num_ref_idx_l0_active_minus1 ;
5952 cmd->dw1.qp_value = avc_state->pic_param->pic_init_qp + slice_param->slice_qp_delta ;
5953
5954 cmd->dw2.frame_width_in_mbs = generic_state->frame_width_in_mbs ;
5955 cmd->dw2.frame_height_in_mbs = generic_state->frame_height_in_mbs ;
5956
5957 cmd->dw3.large_mv_threshold = 128 ;
5958 cmd->dw4.total_large_mv_threshold = (generic_state->frame_width_in_mbs * generic_state->frame_height_in_mbs) / 100 ;
5959 cmd->dw5.zmv_threshold = 4 ;
5960 cmd->dw6.total_zmv_threshold = (generic_state->frame_width_in_mbs * generic_state->frame_height_in_mbs * avc_state->zero_mv_threshold) / 100 ; // zero_mv_threshold = 60;
5961 cmd->dw7.min_dist_threshold = 10 ;
5962
5963 if (generic_state->frame_type == SLICE_TYPE_P) {
5964 memcpy(cmd->cost_table, gen9_avc_sfd_cost_table_p_frame, AVC_QP_MAX * sizeof(unsigned char));
5965
5966 } else if (generic_state->frame_type == SLICE_TYPE_B) {
5967 memcpy(cmd->cost_table, gen9_avc_sfd_cost_table_b_frame, AVC_QP_MAX * sizeof(unsigned char));
5968 }
5969
5970 cmd->dw21.actual_width_in_mb = cmd->dw2.frame_width_in_mbs ;
5971 cmd->dw21.actual_height_in_mb = cmd->dw2.frame_height_in_mbs ;
5972 cmd->dw24.vdenc_input_image_state_index = GEN9_AVC_SFD_VDENC_INPUT_IMAGE_STATE_INDEX ;
5973 cmd->dw26.mv_data_surface_index = GEN9_AVC_SFD_MV_DATA_SURFACE_INDEX ;
5974 cmd->dw27.inter_distortion_surface_index = GEN9_AVC_SFD_INTER_DISTORTION_SURFACE_INDEX ;
5975 cmd->dw28.output_data_surface_index = GEN9_AVC_SFD_OUTPUT_DATA_SURFACE_INDEX ;
5976 cmd->dw29.vdenc_output_image_state_index = GEN9_AVC_SFD_VDENC_OUTPUT_IMAGE_STATE_INDEX ;
5977
5978 i965_gpe_context_unmap_curbe(gpe_context);
5979
5980 }
5981
5982 static void
5983 gen9_avc_send_surface_sfd(VADriverContextP ctx,
5984 struct encode_state *encode_state,
5985 struct i965_gpe_context *gpe_context,
5986 struct intel_encoder_context *encoder_context,
5987 void * param)
5988 {
5989 struct encoder_vme_mfc_context * vme_context = (struct encoder_vme_mfc_context *)encoder_context->vme_context;
5990 struct i965_avc_encoder_context * avc_ctx = (struct i965_avc_encoder_context *)vme_context->private_enc_ctx;
5991 struct i965_gpe_resource *gpe_resource;
5992 int size = 0;
5993
5994 /*HME mv data surface memv output 4x*/
5995 gpe_resource = &avc_ctx->s4x_memv_data_buffer;
5996 i965_add_buffer_2d_gpe_surface(ctx, gpe_context,
5997 gpe_resource,
5998 1,
5999 I965_SURFACEFORMAT_R8_UNORM,
6000 GEN9_AVC_SFD_MV_DATA_SURFACE_INDEX);
6001
6002 /* memv distortion */
6003 gpe_resource = &avc_ctx->s4x_memv_distortion_buffer;
6004 i965_add_buffer_2d_gpe_surface(ctx, gpe_context,
6005 gpe_resource,
6006 1,
6007 I965_SURFACEFORMAT_R8_UNORM,
6008 GEN9_AVC_SFD_INTER_DISTORTION_SURFACE_INDEX);
6009 /*buffer output*/
6010 size = 32 * 4 * 4;
6011 gpe_resource = &avc_ctx->res_sfd_output_buffer;
6012 i965_add_buffer_gpe_surface(ctx,
6013 gpe_context,
6014 gpe_resource,
6015 0,
6016 size / 4,
6017 0,
6018 GEN9_AVC_SFD_OUTPUT_DATA_SURFACE_INDEX);
6019
6020 }
6021
6022 static VAStatus
6023 gen9_avc_kernel_sfd(VADriverContextP ctx,
6024 struct encode_state *encode_state,
6025 struct intel_encoder_context *encoder_context)
6026 {
6027 struct i965_driver_data *i965 = i965_driver_data(ctx);
6028 struct i965_gpe_table *gpe = &i965->gpe_table;
6029 struct encoder_vme_mfc_context * vme_context = (struct encoder_vme_mfc_context *)encoder_context->vme_context;
6030 struct i965_avc_encoder_context * avc_ctx = (struct i965_avc_encoder_context *)vme_context->private_enc_ctx;
6031 struct generic_encoder_context * generic_ctx = (struct generic_encoder_context *)vme_context->generic_enc_ctx;
6032
6033 struct i965_gpe_context *gpe_context;
6034 struct gpe_media_object_parameter media_object_param;
6035 struct gpe_media_object_inline_data media_object_inline_data;
6036 int media_function = INTEL_MEDIA_STATE_STATIC_FRAME_DETECTION;
6037 gpe_context = &(avc_ctx->context_sfd.gpe_contexts);
6038
6039 gpe->context_init(ctx, gpe_context);
6040 gpe->reset_binding_table(ctx, gpe_context);
6041
6042 /*set curbe*/
6043 generic_ctx->pfn_set_curbe_sfd(ctx, encode_state, gpe_context, encoder_context, NULL);
6044
6045 /*send surface*/
6046 generic_ctx->pfn_send_sfd_surface(ctx, encode_state, gpe_context, encoder_context, NULL);
6047
6048 gpe->setup_interface_data(ctx, gpe_context);
6049
6050 memset(&media_object_param, 0, sizeof(media_object_param));
6051 memset(&media_object_inline_data, 0, sizeof(media_object_inline_data));
6052 media_object_param.pinline_data = &media_object_inline_data;
6053 media_object_param.inline_size = sizeof(media_object_inline_data);
6054
6055 gen9_avc_run_kernel_media_object(ctx, encoder_context,
6056 gpe_context,
6057 media_function,
6058 &media_object_param);
6059
6060 return VA_STATUS_SUCCESS;
6061 }
6062
6063 /**************** PreEnc Scaling *************************************/
6064 /* function to run preenc scaling: gen9_avc_preenc_kernel_scaling()
6065 * function to set preenc scaling curbe is the same one using for avc encode
6066 == gen95_avc_set_curbe_scaling4x()
6067 * function to send buffer/surface resources is the same one using for avc encode
6068 == gen9_avc_send_surface_scaling()
6069 */
6070 static VAStatus
6071 gen9_avc_preenc_kernel_scaling(VADriverContextP ctx,
6072 struct encode_state *encode_state,
6073 struct intel_encoder_context *encoder_context,
6074 int hme_type,
6075 int scale_surface_type)
6076 {
6077 struct i965_driver_data *i965 = i965_driver_data(ctx);
6078 struct i965_gpe_table *gpe = &i965->gpe_table;
6079 struct encoder_vme_mfc_context * vme_context = (struct encoder_vme_mfc_context *)encoder_context->vme_context;
6080 struct i965_avc_encoder_context * avc_ctx = (struct i965_avc_encoder_context *)vme_context->private_enc_ctx;
6081 struct generic_enc_codec_state * generic_state = (struct generic_enc_codec_state *)vme_context->generic_enc_state;
6082 struct avc_enc_state * avc_state = (struct avc_enc_state *)vme_context->private_enc_state;
6083 struct generic_encoder_context * generic_ctx = (struct generic_encoder_context *)vme_context->generic_enc_ctx;
6084 VAStatsStatisticsParameterH264 *stat_param_h264 = NULL;
6085 VAStatsStatisticsParameter *stat_param = NULL;
6086 struct i965_gpe_context *gpe_context;
6087 struct scaling_param surface_param;
6088 struct object_surface *obj_surface = NULL;
6089 struct gpe_media_object_walker_parameter media_object_walker_param;
6090 struct gpe_encoder_kernel_walker_parameter kernel_walker_param;
6091 unsigned int downscaled_width_in_mb, downscaled_height_in_mb;
6092 int media_function = 0;
6093 int kernel_idx = 0;
6094 int enable_statistics_output;
6095
6096 stat_param_h264 = avc_state->stat_param;
6097 assert(stat_param_h264);
6098 stat_param = &stat_param_h264->stats_params;
6099 enable_statistics_output = !stat_param_h264->disable_statistics_output;
6100
6101 memset(&surface_param, 0, sizeof(struct scaling_param));
6102 media_function = INTEL_MEDIA_STATE_4X_SCALING;
6103 kernel_idx = GEN9_AVC_KERNEL_SCALING_4X_IDX;
6104 downscaled_width_in_mb = generic_state->downscaled_width_4x_in_mb;
6105 downscaled_height_in_mb = generic_state->downscaled_height_4x_in_mb;
6106
6107 surface_param.input_frame_width = generic_state->frame_width_in_pixel;
6108 surface_param.input_frame_height = generic_state->frame_height_in_pixel;
6109 surface_param.output_frame_width = generic_state->frame_width_4x;
6110 surface_param.output_frame_height = generic_state->frame_height_4x;
6111 surface_param.use_4x_scaling = 1 ;
6112 surface_param.use_16x_scaling = 0 ;
6113 surface_param.use_32x_scaling = 0 ;
6114 surface_param.enable_mb_flatness_check = enable_statistics_output;
6115 surface_param.enable_mb_variance_output = enable_statistics_output;
6116 surface_param.enable_mb_pixel_average_output = enable_statistics_output;
6117 surface_param.blk8x8_stat_enabled = stat_param_h264->enable_8x8_statistics;
6118
6119 switch (scale_surface_type) {
6120
6121 case SCALE_CUR_PIC:
6122 surface_param.input_surface = encode_state->input_yuv_object ;
6123 surface_param.output_surface = avc_ctx->preenc_scaled_4x_surface_obj ;
6124
6125 if (enable_statistics_output) {
6126 surface_param.pres_mbv_proc_stat_buffer =
6127 &avc_ctx->preproc_stat_data_out_buffer;
6128 surface_param.mbv_proc_stat_enabled = 1;
6129 } else {
6130 surface_param.mbv_proc_stat_enabled = 0;
6131 surface_param.pres_mbv_proc_stat_buffer = NULL;
6132 }
6133 break;
6134
6135 case SCALE_PAST_REF_PIC:
6136 obj_surface = SURFACE(stat_param->past_references[0].picture_id);
6137 assert(obj_surface);
6138 surface_param.input_surface = obj_surface;
6139 surface_param.output_surface = avc_ctx->preenc_past_ref_scaled_4x_surface_obj;
6140
6141 if (stat_param->past_ref_stat_buf) {
6142 surface_param.pres_mbv_proc_stat_buffer =
6143 &avc_ctx->preenc_past_ref_stat_data_out_buffer;
6144 surface_param.mbv_proc_stat_enabled = 1;
6145 } else {
6146 surface_param.mbv_proc_stat_enabled = 0;
6147 surface_param.pres_mbv_proc_stat_buffer = NULL;
6148 }
6149 break;
6150
6151 case SCALE_FUTURE_REF_PIC:
6152
6153 obj_surface = SURFACE(stat_param->future_references[0].picture_id);
6154 assert(obj_surface);
6155 surface_param.input_surface = obj_surface;
6156 surface_param.output_surface = avc_ctx->preenc_future_ref_scaled_4x_surface_obj;
6157
6158 if (stat_param->future_ref_stat_buf) {
6159 surface_param.pres_mbv_proc_stat_buffer =
6160 &avc_ctx->preenc_future_ref_stat_data_out_buffer;
6161 surface_param.mbv_proc_stat_enabled = 1;
6162 } else {
6163 surface_param.mbv_proc_stat_enabled = 0;
6164 surface_param.pres_mbv_proc_stat_buffer = NULL;
6165 }
6166 break;
6167 default :
6168 assert(0);
6169 }
6170
6171 gpe_context = &(avc_ctx->context_scaling.gpe_contexts[kernel_idx]);
6172
6173 gpe->context_init(ctx, gpe_context);
6174 gpe->reset_binding_table(ctx, gpe_context);
6175
6176 generic_ctx->pfn_set_curbe_scaling4x(ctx, encode_state, gpe_context, encoder_context, &surface_param);
6177
6178 surface_param.scaling_out_use_16unorm_surf_fmt = 0 ;
6179 surface_param.scaling_out_use_32unorm_surf_fmt = 1 ;
6180
6181 /* No need of explicit flatness_check surface allocation. The field mb_is_flat
6182 * VAStatsStatisticsH264 will be used to store the output. */
6183 surface_param.enable_mb_flatness_check = 0;
6184 generic_ctx->pfn_send_scaling_surface(ctx, encode_state, gpe_context, encoder_context, &surface_param);
6185
6186 /* setup the interface data */
6187 gpe->setup_interface_data(ctx, gpe_context);
6188
6189 memset(&kernel_walker_param, 0, sizeof(kernel_walker_param));
6190 /* the scaling is based on 8x8 blk level */
6191 kernel_walker_param.resolution_x = downscaled_width_in_mb * 2;
6192 kernel_walker_param.resolution_y = downscaled_height_in_mb * 2;
6193 kernel_walker_param.no_dependency = 1;
6194
6195 i965_init_media_object_walker_parameter(&kernel_walker_param, &media_object_walker_param);
6196
6197 gen9_avc_run_kernel_media_object_walker(ctx, encoder_context,
6198 gpe_context,
6199 media_function,
6200 &media_object_walker_param);
6201
6202 return VA_STATUS_SUCCESS;
6203 }
6204
6205 /**************** PreEnc HME *************************************/
6206 /* function to run preenc hme is the same one we using in avc encode:
6207 == gen9_avc_kernel_me()
6208 * function to set preenc hme curbe: gen9_avc_preenc_set_curbe_me()
6209 * function to send hme buffer/surface: gen9_avc_preenc_send_surface_me()
6210 */
6211 static void
6212 gen9_avc_preenc_set_curbe_me(VADriverContextP ctx,
6213 struct encode_state *encode_state,
6214 struct i965_gpe_context *gpe_context,
6215 struct intel_encoder_context *encoder_context,
6216 void * param)
6217 {
6218 gen9_avc_fei_me_curbe_data *curbe_cmd;
6219 struct encoder_vme_mfc_context * vme_context = (struct encoder_vme_mfc_context *)encoder_context->vme_context;
6220 struct generic_enc_codec_state * generic_state = (struct generic_enc_codec_state *)vme_context->generic_enc_state;
6221 struct avc_enc_state * avc_state = (struct avc_enc_state *)vme_context->private_enc_state;
6222 VAStatsStatisticsParameterH264 * stat_param_h264 = avc_state->stat_param;
6223 VAStatsStatisticsParameter *stat_param = &stat_param_h264->stats_params;
6224
6225 struct me_param * curbe_param = (struct me_param *)param ;
6226 unsigned char use_mv_from_prev_step = 0;
6227 unsigned char write_distortions = 0;
6228 unsigned char me_method = gen9_avc_p_me_method[generic_state->preset];
6229 unsigned char seach_table_idx = 0;
6230 unsigned char mv_shift_factor = 0, prev_mv_read_pos_factor = 0;
6231 unsigned int downscaled_width_in_mb, downscaled_height_in_mb;
6232 unsigned int scale_factor = 0;
6233
6234 switch (curbe_param->hme_type) {
6235 case INTEL_ENC_HME_4x:
6236 use_mv_from_prev_step = 0;
6237 write_distortions = 0;
6238 mv_shift_factor = 2;
6239 scale_factor = 4;
6240 prev_mv_read_pos_factor = 0;
6241 break;
6242
6243 default:
6244 assert(0);
6245 }
6246
6247 curbe_cmd = i965_gpe_context_map_curbe(gpe_context);
6248 if (!curbe_cmd)
6249 return;
6250
6251 downscaled_width_in_mb = ALIGN(generic_state->frame_width_in_pixel / scale_factor, 16) / 16;
6252 downscaled_height_in_mb = ALIGN(generic_state->frame_height_in_pixel / scale_factor, 16) / 16;
6253
6254 memcpy(curbe_cmd, gen9_avc_me_curbe_init_data, sizeof(gen9_avc_me_curbe_init_data));
6255
6256 curbe_cmd->dw3.sub_pel_mode = stat_param_h264->sub_pel_mode;
6257 if (avc_state->field_scaling_output_interleaved) {
6258 /*frame set to zero,field specified*/
6259 curbe_cmd->dw3.src_access = 0;
6260 curbe_cmd->dw3.ref_access = 0;
6261 curbe_cmd->dw7.src_field_polarity = 0;
6262 }
6263 curbe_cmd->dw4.picture_height_minus1 = downscaled_height_in_mb - 1;
6264 curbe_cmd->dw4.picture_width = downscaled_width_in_mb;
6265 curbe_cmd->dw5.qp_prime_y = stat_param_h264->frame_qp;
6266
6267 curbe_cmd->dw6.use_mv_from_prev_step = use_mv_from_prev_step;
6268 curbe_cmd->dw6.write_distortions = write_distortions;
6269 curbe_cmd->dw6.super_combine_dist = gen9_avc_super_combine_dist[generic_state->preset];
6270 curbe_cmd->dw6.max_vmvr = i965_avc_get_max_mv_len(INTEL_AVC_LEVEL_52) * 4;//frame only
6271
6272 if (generic_state->frame_type == SLICE_TYPE_B) {
6273 curbe_cmd->dw1.bi_weight = 32;
6274 curbe_cmd->dw13.num_ref_idx_l1_minus1 = stat_param->num_future_references - 1;
6275 me_method = gen9_avc_b_me_method[generic_state->preset];
6276 seach_table_idx = 1;
6277 }
6278
6279 if (generic_state->frame_type == SLICE_TYPE_P ||
6280 generic_state->frame_type == SLICE_TYPE_B)
6281 curbe_cmd->dw13.num_ref_idx_l0_minus1 = stat_param->num_past_references - 1;
6282
6283 curbe_cmd->dw15.prev_mv_read_pos_factor = prev_mv_read_pos_factor;
6284 curbe_cmd->dw15.mv_shift_factor = mv_shift_factor;
6285
6286 memcpy(&curbe_cmd->dw16, table_enc_search_path[seach_table_idx][me_method], 14 * sizeof(int));
6287
6288 curbe_cmd->dw32._4x_memv_output_data_surf_index = GEN9_AVC_ME_MV_DATA_SURFACE_INDEX;
6289 curbe_cmd->dw33._16x_32x_memv_input_data_surf_index = (curbe_param->hme_type == INTEL_ENC_HME_32x) ? GEN9_AVC_32XME_MV_DATA_SURFACE_INDEX : GEN9_AVC_16XME_MV_DATA_SURFACE_INDEX ;
6290 curbe_cmd->dw34._4x_me_output_dist_surf_index = GEN9_AVC_ME_DISTORTION_SURFACE_INDEX;
6291 curbe_cmd->dw35._4x_me_output_brc_dist_surf_index = GEN9_AVC_ME_BRC_DISTORTION_INDEX;
6292 curbe_cmd->dw36.vme_fwd_inter_pred_surf_index = GEN9_AVC_ME_CURR_FOR_FWD_REF_INDEX;
6293 curbe_cmd->dw37.vme_bdw_inter_pred_surf_index = GEN9_AVC_ME_CURR_FOR_BWD_REF_INDEX;
6294 curbe_cmd->dw38.reserved = 0;
6295
6296 i965_gpe_context_unmap_curbe(gpe_context);
6297 return;
6298 }
6299
6300 static void
6301 gen9_avc_preenc_send_surface_me(VADriverContextP ctx,
6302 struct encode_state *encode_state,
6303 struct i965_gpe_context *gpe_context,
6304 struct intel_encoder_context *encoder_context,
6305 void * param)
6306 {
6307 struct encoder_vme_mfc_context * vme_context = (struct encoder_vme_mfc_context *)encoder_context->vme_context;
6308 struct i965_avc_encoder_context * avc_ctx = (struct i965_avc_encoder_context *)vme_context->private_enc_ctx;
6309 struct avc_enc_state * avc_state = (struct avc_enc_state *)vme_context->private_enc_state;
6310 VAStatsStatisticsParameterH264 * stat_param_h264 = avc_state->stat_param;
6311 VAStatsStatisticsParameter *stat_param = &stat_param_h264->stats_params;
6312 struct object_surface *input_surface;
6313 struct i965_gpe_resource *gpe_resource;
6314 struct me_param * curbe_param = (struct me_param *)param ;
6315 int i = 0;
6316
6317 /* PreEnc Only supports 4xme */
6318 assert(curbe_param->hme_type == INTEL_ENC_HME_4x);
6319
6320 switch (curbe_param->hme_type) {
6321 case INTEL_ENC_HME_4x : {
6322 /*memv output 4x*/
6323 gpe_resource = &avc_ctx->s4x_memv_data_buffer;
6324 i965_add_buffer_2d_gpe_surface(ctx, gpe_context,
6325 gpe_resource,
6326 1,
6327 I965_SURFACEFORMAT_R8_UNORM,
6328 GEN9_AVC_ME_MV_DATA_SURFACE_INDEX);
6329
6330 /* memv distortion output*/
6331 gpe_resource = &avc_ctx->s4x_memv_distortion_buffer;
6332 i965_add_buffer_2d_gpe_surface(ctx, gpe_context,
6333 gpe_resource,
6334 1,
6335 I965_SURFACEFORMAT_R8_UNORM,
6336 GEN9_AVC_ME_DISTORTION_SURFACE_INDEX);
6337
6338 /* brc distortion output*/
6339 gpe_resource = &avc_ctx->res_brc_dist_data_surface;
6340 i965_add_buffer_2d_gpe_surface(ctx, gpe_context,
6341 gpe_resource,
6342 1,
6343 I965_SURFACEFORMAT_R8_UNORM,
6344 GEN9_AVC_ME_BRC_DISTORTION_INDEX);
6345
6346 /* input past ref scaled YUV surface*/
6347 for (i = 0; i < stat_param->num_past_references; i++) {
6348 /*input current down scaled YUV surface for forward refef */
6349 input_surface = avc_ctx->preenc_scaled_4x_surface_obj;
6350 i965_add_adv_gpe_surface(ctx, gpe_context,
6351 input_surface,
6352 GEN9_AVC_ME_CURR_FOR_FWD_REF_INDEX);
6353
6354 input_surface = avc_ctx->preenc_past_ref_scaled_4x_surface_obj;
6355 i965_add_adv_gpe_surface(ctx, gpe_context,
6356 input_surface,
6357 GEN9_AVC_ME_CURR_FOR_FWD_REF_INDEX + i * 2 + 1);
6358 }
6359
6360 /* input future ref scaled YUV surface*/
6361 for (i = 0; i < stat_param->num_future_references; i++) {
6362 /*input current down scaled YUV surface for backward ref */
6363 input_surface = avc_ctx->preenc_scaled_4x_surface_obj;
6364 i965_add_adv_gpe_surface(ctx, gpe_context,
6365 input_surface,
6366 GEN9_AVC_ME_CURR_FOR_BWD_REF_INDEX);
6367
6368 input_surface = avc_ctx->preenc_future_ref_scaled_4x_surface_obj;
6369 i965_add_adv_gpe_surface(ctx, gpe_context,
6370 input_surface,
6371 GEN9_AVC_ME_CURR_FOR_BWD_REF_INDEX + i * 2 + 1);
6372 }
6373 break;
6374
6375 }
6376 default:
6377 break;
6378
6379 }
6380 }
6381
6382 /**************** PreEnc PreProc *************************************/
6383 /* function to run preenc preproc: gen9_avc_preenc_kernel_preproc()
6384 * function to set preenc preproc curbe: gen9_avc_preenc_set_curbe_preproc()
6385 * function to send preproc buffer/surface: gen9_avc_preenc_send_surface_preproc ()
6386 */
6387 static void
6388 gen9_avc_preenc_set_curbe_preproc(VADriverContextP ctx,
6389 struct encode_state *encode_state,
6390 struct i965_gpe_context *gpe_context,
6391 struct intel_encoder_context *encoder_context,
6392 void * param)
6393 {
6394 gen9_avc_preproc_curbe_data *cmd;
6395 struct encoder_vme_mfc_context * vme_context = (struct encoder_vme_mfc_context *)encoder_context->vme_context;
6396 struct generic_enc_codec_state * generic_state = (struct generic_enc_codec_state *)vme_context->generic_enc_state;
6397 struct avc_enc_state * avc_state = (struct avc_enc_state *)vme_context->private_enc_state;
6398 VAStatsStatisticsParameterH264 *stat_param_h264 = avc_state->stat_param;
6399 VAStatsStatisticsParameter *stat_param = &stat_param_h264->stats_params;
6400 unsigned char me_method = 0;
6401 unsigned int table_idx = 0;
6402 int ref_width, ref_height, len_sp;
6403 int is_bframe = (generic_state->frame_type == SLICE_TYPE_B);
6404 int is_pframe = (generic_state->frame_type == SLICE_TYPE_P);
6405 unsigned int preset = generic_state->preset;
6406
6407 cmd = (gen9_avc_preproc_curbe_data *)i965_gpe_context_map_curbe(gpe_context);
6408 if (!cmd)
6409 return;
6410 memset(cmd, 0, sizeof(gen9_avc_preproc_curbe_data));
6411
6412 switch (generic_state->frame_type) {
6413 case SLICE_TYPE_I:
6414 memcpy(cmd, gen9_avc_preenc_preproc_curbe_i_frame_init_data,
6415 sizeof(gen9_avc_preproc_curbe_data));
6416 break;
6417 case SLICE_TYPE_P:
6418 memcpy(cmd, gen9_avc_preenc_preproc_curbe_p_frame_init_data,
6419 sizeof(gen9_avc_preproc_curbe_data));
6420 break;
6421 case SLICE_TYPE_B:
6422 memcpy(cmd, gen9_avc_preenc_preproc_curbe_b_frame_init_data,
6423 sizeof(gen9_avc_preproc_curbe_data));
6424 break;
6425 default:
6426 assert(0);
6427 }
6428 /* 4 means full search, 6 means diamand search */
6429 me_method = (stat_param_h264->search_window == 5) ||
6430 (stat_param_h264->search_window == 8) ? 4 : 6;
6431
6432 ref_width = stat_param_h264->ref_width;
6433 ref_height = stat_param_h264->ref_height;
6434 len_sp = stat_param_h264->len_sp;
6435 /* If there is a serch_window, discard user provided ref_width, ref_height
6436 * and search_path length */
6437 switch (stat_param_h264->search_window) {
6438 case 0:
6439 /* not use predefined search window, there should be a search_path input */
6440 if ((stat_param_h264->search_path != 0) &&
6441 (stat_param_h264->search_path != 1) &&
6442 (stat_param_h264->search_path != 2)) {
6443 WARN_ONCE("Invalid input search_path for SearchWindow=0 \n");
6444 assert(0);
6445 }
6446 /* 4 means full search, 6 means diamand search */
6447 me_method = (stat_param_h264->search_path == 1) ? 6 : 4;
6448 if (((ref_width * ref_height) > 2048) || (ref_width > 64) || (ref_height > 64)) {
6449 WARN_ONCE("Invalid input ref_width/ref_height in"
6450 "SearchWindow=0 case! \n");
6451 assert(0);
6452 }
6453 break;
6454
6455 case 1:
6456 /* Tiny - 4 SUs 24x24 window */
6457 ref_width = 24;
6458 ref_height = 24;
6459 len_sp = 4;
6460 break;
6461
6462 case 2:
6463 /* Small - 9 SUs 28x28 window */
6464 ref_width = 28;
6465 ref_height = 28;
6466 len_sp = 9;
6467 break;
6468 case 3:
6469 /* Diamond - 16 SUs 48x40 window */
6470 ref_width = 48;
6471 ref_height = 40;
6472 len_sp = 16;
6473 break;
6474 case 4:
6475 /* Large Diamond - 32 SUs 48x40 window */
6476 ref_width = 48;
6477 ref_height = 40;
6478 len_sp = 32;
6479 break;
6480 case 5:
6481 /* Exhaustive - 48 SUs 48x40 window */
6482 ref_width = 48;
6483 ref_height = 40;
6484 len_sp = 48;
6485 break;
6486 case 6:
6487 /* Diamond - 16 SUs 64x32 window */
6488 ref_width = 64;
6489 ref_height = 32;
6490 len_sp = 16;
6491 break;
6492 case 7:
6493 /* Large Diamond - 32 SUs 64x32 window */
6494 ref_width = 64;
6495 ref_height = 32;
6496 len_sp = 32;
6497 break;
6498 case 8:
6499 /* Exhaustive - 48 SUs 64x32 window */
6500 ref_width = 64;
6501 ref_height = 32;
6502 len_sp = 48;
6503 break;
6504
6505 default:
6506 assert(0);
6507 }
6508
6509 /* ref_width*ref_height = Max 64x32 one direction, Max 32x32 two directions */
6510 if (is_bframe) {
6511 CLIP(ref_width, 4, 32);
6512 CLIP(ref_height, 4, 32);
6513 } else if (is_pframe) {
6514 CLIP(ref_width, 4, 64);
6515 CLIP(ref_height, 4, 32);
6516 }
6517
6518 cmd->dw0.adaptive_enable =
6519 cmd->dw37.adaptive_enable = stat_param_h264->adaptive_search;
6520 cmd->dw2.max_len_sp = len_sp;
6521 cmd->dw38.max_len_sp = 0; // HLD mandates this field to be Zero
6522 cmd->dw2.max_num_su = cmd->dw38.max_num_su = 57;
6523 cmd->dw3.src_access =
6524 cmd->dw3.ref_access = 0; // change it to (is_frame ? 0: 1) when interlace is suppoted
6525
6526 if (generic_state->frame_type != SLICE_TYPE_I && avc_state->ftq_enable)
6527 cmd->dw3.ft_enable = stat_param_h264->ft_enable;
6528 else
6529 cmd->dw3.ft_enable = 0;
6530
6531 cmd->dw2.pic_width = generic_state->frame_width_in_mbs;
6532 cmd->dw6.pic_height = cmd->dw5.slice_mb_height = generic_state->frame_height_in_mbs;
6533 cmd->dw3.sub_mb_part_mask = stat_param_h264->sub_mb_part_mask;
6534 cmd->dw3.sub_pel_mode = stat_param_h264->sub_pel_mode;
6535 cmd->dw3.inter_sad = stat_param_h264->inter_sad;
6536 cmd->dw3.intra_sad = stat_param_h264->intra_sad;
6537 cmd->dw4.hme_enable = generic_state->hme_enabled;
6538 cmd->dw4.frame_qp = stat_param_h264->frame_qp;
6539 cmd->dw4.per_mb_qp_enable = stat_param_h264->mb_qp;
6540
6541 cmd->dw4.multiple_mv_predictor_per_mb_enable =
6542 (generic_state->frame_type != SLICE_TYPE_I) ? 0 : stat_param_h264->mv_predictor_ctrl;
6543
6544 cmd->dw4.disable_mv_output = (generic_state->frame_type == SLICE_TYPE_I) ? 1 : stat_param_h264->disable_mv_output;
6545 cmd->dw4.disable_mb_stats = stat_param_h264->disable_statistics_output;
6546
6547 cmd->dw4.fwd_ref_pic_enable = (stat_param->num_past_references > 0) ? 1 : 0;
6548 cmd->dw4.bwd_ref_pic_enable = (stat_param->num_future_references > 0) ? 1 : 0;
6549
6550 cmd->dw7.intra_part_mask = stat_param_h264->intra_part_mask;
6551
6552 /* mv mode cost */
6553 memcpy(&(cmd->dw8), gen75_avc_mode_mv_cost_table[slice_type_kernel[generic_state->frame_type]][stat_param_h264->frame_qp], 8 * sizeof(unsigned int));
6554
6555 /* reset all except sic_fwd_trans_coeff_threshold_* from dw8 to dw15 */
6556 memset(&(cmd->dw8), 0, 6 * (sizeof(unsigned int)));
6557
6558 /* search path tables */
6559 table_idx = (generic_state->frame_type == SLICE_TYPE_B) ? 1 : 0;
6560 memcpy(&(cmd->dw16), table_enc_search_path[table_idx][me_method], 16 * sizeof(unsigned int));
6561
6562 if (stat_param_h264->intra_part_mask == 0x07)
6563 cmd->dw31.intra_compute_type = 3;
6564
6565 cmd->dw38.ref_threshold = 400;
6566 cmd->dw39.hme_ref_windows_comb_threshold = (generic_state->frame_type == SLICE_TYPE_B) ? gen9_avc_hme_b_combine_len[preset] : gen9_avc_hme_combine_len[preset];
6567
6568 if (generic_state->frame_type == SLICE_TYPE_I) {
6569 cmd->dw0.skip_mode_enable = cmd->dw37.skip_mode_enable = 0;
6570 cmd->dw36.hme_combine_overlap = 0;
6571 } else if (generic_state->frame_type == SLICE_TYPE_P) {
6572 cmd->dw1.max_num_mvs = i965_avc_get_max_mv_per_2mb(INTEL_AVC_LEVEL_52) / 2;
6573 cmd->dw3.bme_disable_fbr = 1;
6574 cmd->dw5.ref_width = cmd->dw39.ref_width = ref_width;
6575 cmd->dw5.ref_height = cmd->dw39.ref_height = ref_height;
6576 cmd->dw7.non_skip_zmv_added = 1;
6577 cmd->dw7.non_skip_mode_added = 1;
6578 cmd->dw7.skip_center_mask = 1;
6579 cmd->dw32.max_vmv_r =
6580 i965_avc_get_max_mv_len(INTEL_AVC_LEVEL_52) * 4;
6581 cmd->dw36.hme_combine_overlap = 1;
6582
6583 } else if (generic_state->frame_type == SLICE_TYPE_P) { /* B slice */
6584
6585 cmd->dw1.max_num_mvs = i965_avc_get_max_mv_per_2mb(INTEL_AVC_LEVEL_52) / 2;
6586 cmd->dw3.search_ctrl = 0;
6587 cmd->dw3.skip_type = 1;
6588 cmd->dw5.ref_width = cmd->dw39.ref_width = ref_width;
6589 cmd->dw5.ref_height = cmd->dw39.ref_height = ref_height;
6590 cmd->dw7.skip_center_mask = 0xff;
6591 cmd->dw32.max_vmv_r =
6592 i965_avc_get_max_mv_len(INTEL_AVC_LEVEL_52) * 4;
6593 cmd->dw36.hme_combine_overlap = 1;
6594 }
6595
6596 cmd->dw40.curr_pic_surf_index = GEN9_AVC_PREPROC_CURR_Y_INDEX;
6597 cmd->dw41.hme_mv_dat_surf_index = GEN9_AVC_PREPROC_HME_MV_DATA_INDEX;
6598 cmd->dw42.mv_predictor_surf_index = GEN9_AVC_PREPROC_MV_PREDICTOR_INDEX;
6599 cmd->dw43.mb_qp_surf_index = GEN9_AVC_PREPROC_MBQP_INDEX;
6600 cmd->dw44.mv_data_out_surf_index = GEN9_AVC_PREPROC_MV_DATA_INDEX;
6601 cmd->dw45.mb_stats_out_surf_index = GEN9_AVC_PREPROC_MB_STATS_INDEX;
6602 cmd->dw46.vme_inter_prediction_surf_index = GEN9_AVC_PREPROC_VME_CURR_PIC_IDX_0_INDEX;
6603 cmd->dw47.vme_Inter_prediction_mr_surf_index = GEN9_AVC_PREPROC_VME_CURR_PIC_IDX_1_INDEX;
6604 cmd->dw48.ftq_lut_surf_index = GEN9_AVC_PREPROC_FTQ_LUT_INDEX;
6605
6606 i965_gpe_context_unmap_curbe(gpe_context);
6607 }
6608
6609 static void
6610 gen9_avc_preenc_send_surface_preproc(VADriverContextP ctx,
6611 struct encode_state *encode_state,
6612 struct i965_gpe_context *gpe_context,
6613 struct intel_encoder_context *encoder_context,
6614 void * param)
6615 {
6616 struct i965_driver_data *i965 = i965_driver_data(ctx);
6617 struct encoder_vme_mfc_context * vme_context = (struct encoder_vme_mfc_context *)encoder_context->vme_context;
6618 struct i965_avc_encoder_context * avc_ctx = (struct i965_avc_encoder_context *)vme_context->private_enc_ctx;
6619 struct generic_enc_codec_state * generic_state = (struct generic_enc_codec_state *)vme_context->generic_enc_state;
6620 struct avc_enc_state * avc_state = (struct avc_enc_state *)vme_context->private_enc_state;
6621 struct object_surface *obj_surface;
6622 struct i965_gpe_resource *gpe_resource;
6623 VASurfaceID surface_id;
6624 VAStatsStatisticsParameterH264 *stat_param_h264 = avc_state->stat_param;
6625 VAStatsStatisticsParameter *stat_param = &stat_param_h264->stats_params;
6626 unsigned int size = 0, frame_mb_nums = 0;
6627
6628 frame_mb_nums = generic_state->frame_width_in_mbs * generic_state->frame_height_in_mbs;
6629
6630 /* input yuv surface, Y index */
6631 obj_surface = encode_state->input_yuv_object;
6632 i965_add_2d_gpe_surface(ctx,
6633 gpe_context,
6634 obj_surface,
6635 0,
6636 1,
6637 I965_SURFACEFORMAT_R8_UNORM,
6638 GEN9_AVC_PREPROC_CURR_Y_INDEX);
6639
6640 /* input yuv surface, UV index */
6641 i965_add_2d_gpe_surface(ctx,
6642 gpe_context,
6643 obj_surface,
6644 1,
6645 1,
6646 I965_SURFACEFORMAT_R16_UINT,
6647 GEN9_AVC_MBENC_CURR_UV_INDEX);
6648
6649
6650 if (generic_state->hme_enabled) {
6651 /* HME mv data buffer */
6652 gpe_resource = &avc_ctx->s4x_memv_data_buffer;
6653 i965_add_buffer_2d_gpe_surface(ctx, gpe_context,
6654 gpe_resource,
6655 1,
6656 I965_SURFACEFORMAT_R8_UNORM,
6657 GEN9_AVC_PREPROC_HME_MV_DATA_INDEX);
6658 }
6659
6660 /* mv predictor buffer */
6661 if (stat_param_h264->mv_predictor_ctrl) {
6662 size = frame_mb_nums * FEI_AVC_MV_PREDICTOR_BUFFER_SIZE;
6663 gpe_resource = &avc_ctx->preproc_mv_predictor_buffer;
6664 i965_add_buffer_gpe_surface(ctx,
6665 gpe_context,
6666 gpe_resource,
6667 0,
6668 size / 4,
6669 0,
6670 GEN9_AVC_PREPROC_MV_PREDICTOR_INDEX);
6671 }
6672
6673 /* MB qp buffer */
6674 if (stat_param_h264->mb_qp) {
6675 size = frame_mb_nums * FEI_AVC_QP_BUFFER_SIZE;
6676 gpe_resource = &avc_ctx->preproc_mb_qp_buffer;
6677 i965_add_buffer_gpe_surface(ctx,
6678 gpe_context,
6679 gpe_resource,
6680 0,
6681 size / 4,
6682 0,
6683 GEN9_AVC_PREPROC_MBQP_INDEX);
6684
6685 gpe_resource = &avc_ctx->res_mbbrc_const_data_buffer;
6686 size = 16 * AVC_QP_MAX * 4;
6687 i965_add_buffer_gpe_surface(ctx,
6688 gpe_context,
6689 gpe_resource,
6690 0,
6691 size / 4,
6692 0,
6693 GEN9_AVC_PREPROC_FTQ_LUT_INDEX);
6694
6695 }
6696
6697 /* mv data output buffer */
6698 if (!stat_param_h264->disable_mv_output) {
6699 gpe_resource = &avc_ctx->preproc_mv_data_out_buffer;
6700 size = frame_mb_nums * FEI_AVC_MV_DATA_BUFFER_SIZE;
6701 i965_add_buffer_gpe_surface(ctx,
6702 gpe_context,
6703 gpe_resource,
6704 0,
6705 size / 4,
6706 0,
6707 GEN9_AVC_PREPROC_MV_DATA_INDEX);
6708 }
6709
6710 /* statistics output buffer */
6711 if (!stat_param_h264->disable_statistics_output) {
6712 gpe_resource = &avc_ctx->preproc_stat_data_out_buffer;
6713 size = frame_mb_nums * PREENC_AVC_STATISTICS_BUFFER_SIZE;
6714 i965_add_buffer_gpe_surface(ctx,
6715 gpe_context,
6716 gpe_resource,
6717 0,
6718 size / 4,
6719 0,
6720 GEN9_AVC_PREPROC_MB_STATS_INDEX);
6721 }
6722
6723 /* vme cur pic y */
6724 obj_surface = encode_state->input_yuv_object;
6725 i965_add_2d_gpe_surface(ctx,
6726 gpe_context,
6727 obj_surface,
6728 0,
6729 1,
6730 I965_SURFACEFORMAT_R8_UNORM,
6731 GEN9_AVC_PREPROC_VME_CURR_PIC_IDX_0_INDEX);
6732
6733 /* vme cur pic y (repeating based on required BTI order for mediakerel)*/
6734 obj_surface = encode_state->input_yuv_object;
6735 i965_add_2d_gpe_surface(ctx,
6736 gpe_context,
6737 obj_surface,
6738 0,
6739 1,
6740 I965_SURFACEFORMAT_R8_UNORM,
6741 GEN9_AVC_PREPROC_VME_CURR_PIC_IDX_1_INDEX);
6742
6743 /* vme forward ref */
6744 /* Only supports one past ref */
6745 if (stat_param->num_past_references > 0) {
6746 surface_id = stat_param->past_references[0].picture_id;
6747 assert(surface_id != VA_INVALID_ID);
6748 obj_surface = SURFACE(surface_id);
6749 if (!obj_surface)
6750 return;
6751 i965_add_adv_gpe_surface(ctx, gpe_context,
6752 obj_surface,
6753 GEN9_AVC_PREPROC_VME_FWD_PIC_IDX0_INDEX);
6754
6755 }
6756
6757 /* vme future ref */
6758 /* Only supports one future ref */
6759 if (stat_param->num_future_references > 0) {
6760 surface_id = stat_param->future_references[0].picture_id;
6761 assert(surface_id != VA_INVALID_ID);
6762 obj_surface = SURFACE(surface_id);
6763 if (!obj_surface)
6764 return;
6765 i965_add_adv_gpe_surface(ctx, gpe_context,
6766 obj_surface,
6767 GEN9_AVC_PREPROC_VME_BWD_PIC_IDX0_0_INDEX);
6768
6769 surface_id = stat_param->future_references[0].picture_id;
6770 assert(surface_id != VA_INVALID_ID);
6771 obj_surface = SURFACE(surface_id);
6772 if (!obj_surface)
6773 return;
6774 i965_add_adv_gpe_surface(ctx, gpe_context,
6775 obj_surface,
6776 GEN9_AVC_PREPROC_VME_BWD_PIC_IDX0_1_INDEX);
6777 }
6778
6779 return;
6780
6781 }
6782
6783 static VAStatus
6784 gen9_avc_preenc_kernel_preproc(VADriverContextP ctx,
6785 struct encode_state *encode_state,
6786 struct intel_encoder_context *encoder_context)
6787 {
6788 struct i965_driver_data *i965 = i965_driver_data(ctx);
6789 struct i965_gpe_table *gpe = &i965->gpe_table;
6790 struct encoder_vme_mfc_context * vme_context = (struct encoder_vme_mfc_context *)encoder_context->vme_context;
6791 struct generic_encoder_context * generic_ctx = (struct generic_encoder_context *)vme_context->generic_enc_ctx;
6792 struct i965_avc_encoder_context * avc_ctx = (struct i965_avc_encoder_context *)vme_context->private_enc_ctx;
6793 struct generic_enc_codec_state * generic_state = (struct generic_enc_codec_state *)vme_context->generic_enc_state;
6794 struct avc_enc_state * avc_state = (struct avc_enc_state *)vme_context->private_enc_state;
6795 VAStatsStatisticsParameterH264 * stat_param_h264 = avc_state->stat_param;
6796 struct i965_gpe_context *gpe_context;
6797 struct gpe_media_object_walker_parameter media_object_walker_param;
6798 struct gpe_encoder_kernel_walker_parameter kernel_walker_param;
6799 int media_function = INTEL_MEDIA_STATE_PREPROC;
6800 struct i965_gpe_resource *gpe_resource = NULL;
6801 unsigned int * data = NULL;
6802 unsigned int ftq_lut_table_size = 16 * 52; /* 16 DW per QP for each qp*/
6803
6804 gpe_context = &(avc_ctx->context_preproc.gpe_contexts);
6805 gpe->context_init(ctx, gpe_context);
6806 gpe->reset_binding_table(ctx, gpe_context);
6807
6808 /*set curbe*/
6809 generic_ctx->pfn_set_curbe_preproc(ctx, encode_state, gpe_context, encoder_context, NULL);
6810
6811 /*send surface*/
6812 generic_ctx->pfn_send_preproc_surface(ctx, encode_state, gpe_context, encoder_context, NULL);
6813
6814 gpe->setup_interface_data(ctx, gpe_context);
6815
6816 /* Set up FtqLut Buffer if there is QP change within a frame */
6817 if (stat_param_h264->mb_qp) {
6818 gpe_resource = &(avc_ctx->res_mbbrc_const_data_buffer);
6819 assert(gpe_resource);
6820 data = i965_map_gpe_resource(gpe_resource);
6821 assert(data);
6822 memcpy(data, gen9_avc_preenc_preproc_ftq_lut, ftq_lut_table_size * sizeof(unsigned int));
6823 }
6824
6825 memset(&kernel_walker_param, 0, sizeof(kernel_walker_param));
6826 kernel_walker_param.resolution_x = generic_state->frame_width_in_mbs ;
6827 kernel_walker_param.resolution_y = generic_state->frame_height_in_mbs ;
6828 kernel_walker_param.no_dependency = 1;
6829
6830 i965_init_media_object_walker_parameter(&kernel_walker_param, &media_object_walker_param);
6831
6832 gen9_avc_run_kernel_media_object_walker(ctx, encoder_context,
6833 gpe_context,
6834 media_function,
6835 &media_object_walker_param);
6836
6837 return VA_STATUS_SUCCESS;
6838 }
6839
6840
6841 static void
6842 gen8_avc_set_curbe_mbenc(VADriverContextP ctx,
6843 struct encode_state *encode_state,
6844 struct i965_gpe_context *gpe_context,
6845 struct intel_encoder_context *encoder_context,
6846 void * param)
6847 {
6848 struct i965_driver_data *i965 = i965_driver_data(ctx);
6849 gen8_avc_mbenc_curbe_data *cmd;
6850 struct encoder_vme_mfc_context * vme_context = (struct encoder_vme_mfc_context *)encoder_context->vme_context;
6851 struct generic_enc_codec_state * generic_state = (struct generic_enc_codec_state *)vme_context->generic_enc_state;
6852 struct avc_enc_state * avc_state = (struct avc_enc_state *)vme_context->private_enc_state;
6853
6854 VAEncSliceParameterBufferH264 * slice_param = avc_state->slice_param[0];
6855 VAEncPictureParameterBufferH264 *pic_param = avc_state->pic_param;
6856 VASurfaceID surface_id;
6857 struct object_surface *obj_surface;
6858
6859 struct mbenc_param * curbe_param = (struct mbenc_param *)param ;
6860 unsigned char qp = 0;
6861 unsigned char me_method = 0;
6862 unsigned int mbenc_i_frame_dist_in_use = curbe_param->mbenc_i_frame_dist_in_use;
6863 unsigned int table_idx = 0;
6864 unsigned int curbe_size = 0;
6865
6866 unsigned int preset = generic_state->preset;
6867
6868 cmd = (gen8_avc_mbenc_curbe_data *)i965_gpe_context_map_curbe(gpe_context);
6869 if (!cmd)
6870 return;
6871 curbe_size = sizeof(gen8_avc_mbenc_curbe_data);
6872 memset(cmd, 0, curbe_size);
6873
6874 if (mbenc_i_frame_dist_in_use) {
6875 memcpy(cmd, gen8_avc_mbenc_curbe_i_frame_dist_init_data, curbe_size);
6876 } else {
6877 switch (generic_state->frame_type) {
6878 case SLICE_TYPE_I:
6879 memcpy(cmd, gen8_avc_mbenc_curbe_normal_i_frame_init_data, curbe_size);
6880 break;
6881 case SLICE_TYPE_P:
6882 memcpy(cmd, gen8_avc_mbenc_curbe_normal_p_frame_init_data, curbe_size);
6883 break;
6884 case SLICE_TYPE_B:
6885 memcpy(cmd, gen8_avc_mbenc_curbe_normal_b_frame_init_data, curbe_size);
6886 break;
6887 default:
6888 assert(0);
6889 }
6890 }
6891
6892 me_method = (generic_state->frame_type == SLICE_TYPE_B) ? gen9_avc_b_me_method[preset] : gen9_avc_p_me_method[preset];
6893 qp = pic_param->pic_init_qp + slice_param->slice_qp_delta;
6894
6895 cmd->dw0.adaptive_enable = gen9_avc_enable_adaptive_search[preset];
6896 cmd->dw37.adaptive_enable = gen9_avc_enable_adaptive_search[preset];
6897 cmd->dw0.t8x8_flag_for_inter_enable = avc_state->transform_8x8_mode_enable;
6898 cmd->dw37.t8x8_flag_for_inter_enable = avc_state->transform_8x8_mode_enable;
6899
6900 cmd->dw2.max_len_sp = gen9_avc_max_len_sp[preset];
6901 cmd->dw38.max_len_sp = 0;
6902
6903 cmd->dw3.src_access = 0;
6904 cmd->dw3.ref_access = 0;
6905
6906 if (avc_state->ftq_enable && (generic_state->frame_type != SLICE_TYPE_I)) {
6907 //disable ftq_override by now.
6908 if (avc_state->ftq_override) {
6909 cmd->dw3.ftq_enable = avc_state->ftq_enable;
6910
6911 } else {
6912 if (generic_state->frame_type == SLICE_TYPE_P) {
6913 cmd->dw3.ftq_enable = gen9_avc_max_ftq_based_skip[preset] & 0x01;
6914
6915 } else {
6916 cmd->dw3.ftq_enable = (gen9_avc_max_ftq_based_skip[preset] >> 1) & 0x01;
6917 }
6918 }
6919 } else {
6920 cmd->dw3.ftq_enable = 0;
6921 }
6922
6923 if (avc_state->disable_sub_mb_partion)
6924 cmd->dw3.sub_mb_part_mask = 0x70;
6925
6926 if (mbenc_i_frame_dist_in_use) {
6927 cmd->dw2.pitch_width = generic_state->downscaled_width_4x_in_mb;
6928 cmd->dw4.picture_height_minus1 = generic_state->downscaled_height_4x_in_mb - 1;
6929 cmd->dw5.slice_mb_height = (avc_state->slice_height + 4 - 1) / 4;
6930 cmd->dw6.batch_buffer_end = 0;
6931 cmd->dw31.intra_compute_type = 1;
6932 } else {
6933 cmd->dw2.pitch_width = generic_state->frame_width_in_mbs;
6934 cmd->dw4.picture_height_minus1 = generic_state->frame_height_in_mbs - 1;
6935 cmd->dw5.slice_mb_height = (avc_state->arbitrary_num_mbs_in_slice) ? generic_state->frame_height_in_mbs : avc_state->slice_height;
6936
6937 memcpy(&(cmd->dw8), gen9_avc_mode_mv_cost_table[slice_type_kernel[generic_state->frame_type]][qp], 8 * sizeof(unsigned int));
6938 if ((generic_state->frame_type == SLICE_TYPE_I) && avc_state->old_mode_cost_enable) {
6939 } else if (avc_state->skip_bias_adjustment_enable) {
6940 /* Load different MvCost for P picture when SkipBiasAdjustment is enabled
6941 // No need to check for P picture as the flag is only enabled for P picture */
6942 cmd->dw11.value = gen9_avc_mv_cost_p_skip_adjustment[qp];
6943 }
6944 table_idx = (generic_state->frame_type == SLICE_TYPE_B) ? 1 : 0;
6945 memcpy(&(cmd->dw16), table_enc_search_path[table_idx][me_method], 16 * sizeof(unsigned int));
6946 }
6947 cmd->dw4.enable_intra_cost_scaling_for_static_frame = avc_state->sfd_enable && generic_state->hme_enabled;
6948 cmd->dw4.field_parity_flag = 0;//bottom field
6949 cmd->dw4.enable_cur_fld_idr = 0;//field realted
6950 cmd->dw4.contrained_intra_pred_flag = pic_param->pic_fields.bits.constrained_intra_pred_flag;
6951 cmd->dw4.hme_enable = generic_state->hme_enabled;
6952 cmd->dw4.picture_type = slice_type_kernel[generic_state->frame_type];
6953 cmd->dw4.use_actual_ref_qp_value = generic_state->hme_enabled && (gen9_avc_mr_disable_qp_check[preset] == 0);
6954
6955 cmd->dw7.intra_part_mask = avc_state->transform_8x8_mode_enable ? 0 : 0x02;
6956 cmd->dw7.src_field_polarity = 0;//field related
6957
6958 /*ftq_skip_threshold_lut set,dw14 /15*/
6959
6960 /*r5 disable NonFTQSkipThresholdLUT*/
6961 if (generic_state->frame_type == SLICE_TYPE_P) {
6962 cmd->dw32.skip_val = gen9_avc_skip_value_p[avc_state->block_based_skip_enable][avc_state->transform_8x8_mode_enable][qp];
6963 } else if (generic_state->frame_type == SLICE_TYPE_B) {
6964 cmd->dw32.skip_val = gen9_avc_skip_value_b[avc_state->block_based_skip_enable][avc_state->transform_8x8_mode_enable][qp];
6965 }
6966
6967 cmd->dw13.qp_prime_y = qp;
6968 cmd->dw13.qp_prime_cb = qp;
6969 cmd->dw13.qp_prime_cr = qp;
6970 cmd->dw13.target_size_in_word = 0xff;//hardcode for brc disable
6971
6972 if ((generic_state->frame_type != SLICE_TYPE_I) && avc_state->multi_pre_enable) {
6973 switch (gen9_avc_multi_pred[preset]) {
6974 case 0:
6975 cmd->dw32.mult_pred_l0_disable = 128;
6976 cmd->dw32.mult_pred_l1_disable = 128;
6977 break;
6978 case 1:
6979 cmd->dw32.mult_pred_l0_disable = (generic_state->frame_type == SLICE_TYPE_P) ? 1 : 128;
6980 cmd->dw32.mult_pred_l1_disable = 128;
6981 break;
6982 case 2:
6983 cmd->dw32.mult_pred_l0_disable = (generic_state->frame_type == SLICE_TYPE_B) ? 1 : 128;
6984 cmd->dw32.mult_pred_l1_disable = (generic_state->frame_type == SLICE_TYPE_B) ? 1 : 128;
6985 break;
6986 case 3:
6987 cmd->dw32.mult_pred_l0_disable = 1;
6988 cmd->dw32.mult_pred_l1_disable = (generic_state->frame_type == SLICE_TYPE_B) ? 1 : 128;
6989 break;
6990 }
6991
6992 } else {
6993 cmd->dw32.mult_pred_l0_disable = 128;
6994 cmd->dw32.mult_pred_l1_disable = 128;
6995 }
6996
6997 if (generic_state->frame_type == SLICE_TYPE_B) {
6998 cmd->dw34.list1_ref_id0_frm_field_parity = 0; //frame only
6999 cmd->dw34.list1_ref_id0_frm_field_parity = 0;
7000 cmd->dw34.b_direct_mode = slice_param->direct_spatial_mv_pred_flag;
7001 }
7002
7003 cmd->dw34.b_original_bff = 0; //frame only
7004 cmd->dw34.enable_mb_flatness_check_optimization = avc_state->flatness_check_enable;
7005 cmd->dw34.roi_enable_flag = curbe_param->roi_enabled;
7006 cmd->dw34.mad_enable_falg = avc_state->mad_enable;
7007 cmd->dw34.mb_brc_enable = avc_state->mb_qp_data_enable || generic_state->mb_brc_enabled;
7008 cmd->dw34.arbitray_num_mbs_per_slice = avc_state->arbitrary_num_mbs_in_slice;
7009 cmd->dw34.force_non_skip_check = avc_state->mb_disable_skip_map_enable;
7010
7011 if (!cmd->dw34.force_non_skip_check) {
7012 cmd->dw34.disable_enc_skip_check = avc_state->skip_check_disable;
7013 }
7014
7015 cmd->dw36.check_all_fractional_enable = avc_state->caf_enable;
7016 cmd->dw38.ref_threshold = 400;
7017 cmd->dw39.hme_ref_windows_comb_threshold = (generic_state->frame_type == SLICE_TYPE_B) ? gen9_avc_hme_b_combine_len[preset] : gen9_avc_hme_combine_len[preset];
7018 cmd->dw47.mb_qp_read_factor = (avc_state->mb_qp_data_enable) ? 0 : 2;
7019
7020 if (mbenc_i_frame_dist_in_use) {
7021 cmd->dw13.qp_prime_y = 0;
7022 cmd->dw13.qp_prime_cb = 0;
7023 cmd->dw13.qp_prime_cr = 0;
7024 cmd->dw33.intra_16x16_nondc_penalty = 0;
7025 cmd->dw33.intra_8x8_nondc_penalty = 0;
7026 cmd->dw33.intra_4x4_nondc_penalty = 0;
7027 }
7028 if (cmd->dw4.use_actual_ref_qp_value) {
7029 cmd->dw44.actual_qp_value_for_ref_id0_list0 = gen9_avc_get_qp_from_ref_list(ctx, slice_param, 0, 0);
7030 cmd->dw44.actual_qp_value_for_ref_id1_list0 = gen9_avc_get_qp_from_ref_list(ctx, slice_param, 0, 1);
7031 cmd->dw44.actual_qp_value_for_ref_id2_list0 = gen9_avc_get_qp_from_ref_list(ctx, slice_param, 0, 2);
7032 cmd->dw44.actual_qp_value_for_ref_id3_list0 = gen9_avc_get_qp_from_ref_list(ctx, slice_param, 0, 3);
7033 cmd->dw45.actual_qp_value_for_ref_id4_list0 = gen9_avc_get_qp_from_ref_list(ctx, slice_param, 0, 4);
7034 cmd->dw45.actual_qp_value_for_ref_id5_list0 = gen9_avc_get_qp_from_ref_list(ctx, slice_param, 0, 5);
7035 cmd->dw45.actual_qp_value_for_ref_id6_list0 = gen9_avc_get_qp_from_ref_list(ctx, slice_param, 0, 6);
7036 cmd->dw45.actual_qp_value_for_ref_id7_list0 = gen9_avc_get_qp_from_ref_list(ctx, slice_param, 0, 7);
7037 cmd->dw46.actual_qp_value_for_ref_id0_list1 = gen9_avc_get_qp_from_ref_list(ctx, slice_param, 1, 0);
7038 cmd->dw46.actual_qp_value_for_ref_id1_list1 = gen9_avc_get_qp_from_ref_list(ctx, slice_param, 1, 1);
7039 }
7040
7041 table_idx = slice_type_kernel[generic_state->frame_type];
7042 cmd->dw46.ref_cost = gen8_avc_ref_cost[table_idx][qp];
7043 if (generic_state->frame_type == SLICE_TYPE_I) {
7044 cmd->dw0.skip_mode_enable = 0;
7045 cmd->dw37.skip_mode_enable = 0;
7046 cmd->dw36.hme_combine_overlap = 0;
7047 cmd->dw47.intra_cost_sf = 16;
7048 cmd->dw34.enable_direct_bias_adjustment = 0;
7049 cmd->dw34.enable_global_motion_bias_adjustment = 0;
7050
7051 } else if (generic_state->frame_type == SLICE_TYPE_P) {
7052 cmd->dw1.max_num_mvs = i965_avc_get_max_mv_per_2mb(avc_state->seq_param->level_idc) / 2;
7053 cmd->dw3.bme_disable_fbr = 1;
7054 cmd->dw5.ref_width = gen9_avc_search_x[preset];
7055 cmd->dw5.ref_height = gen9_avc_search_y[preset];
7056 cmd->dw7.non_skip_zmv_added = 1;
7057 cmd->dw7.non_skip_mode_added = 1;
7058 cmd->dw7.skip_center_mask = 1;
7059 cmd->dw47.intra_cost_sf = (avc_state->adaptive_intra_scaling_enable) ? gen9_avc_adaptive_intra_scaling_factor[qp] : gen9_avc_intra_scaling_factor[qp];
7060 cmd->dw47.max_vmv_r = i965_avc_get_max_mv_len(avc_state->seq_param->level_idc) * 4;//frame onlys
7061 cmd->dw36.hme_combine_overlap = 1;
7062 cmd->dw36.num_ref_idx_l0_minus_one = (avc_state->multi_pre_enable) ? slice_param->num_ref_idx_l0_active_minus1 : 0;
7063 cmd->dw39.ref_width = gen9_avc_search_x[preset];
7064 cmd->dw39.ref_height = gen9_avc_search_y[preset];
7065 cmd->dw34.enable_direct_bias_adjustment = 0;
7066 cmd->dw34.enable_global_motion_bias_adjustment = avc_state->global_motion_bias_adjustment_enable;
7067 if (avc_state->global_motion_bias_adjustment_enable)
7068 cmd->dw58.hme_mv_cost_scaling_factor = avc_state->hme_mv_cost_scaling_factor;
7069 } else {
7070 cmd->dw1.max_num_mvs = i965_avc_get_max_mv_per_2mb(avc_state->seq_param->level_idc) / 2;
7071 cmd->dw1.bi_weight = avc_state->bi_weight;
7072 cmd->dw3.search_ctrl = 7;
7073 cmd->dw3.skip_type = 1;
7074 cmd->dw5.ref_width = gen9_avc_b_search_x[preset];
7075 cmd->dw5.ref_height = gen9_avc_b_search_y[preset];
7076 cmd->dw7.skip_center_mask = 0xff;
7077 cmd->dw47.intra_cost_sf = (avc_state->adaptive_intra_scaling_enable) ? gen9_avc_adaptive_intra_scaling_factor[qp] : gen9_avc_intra_scaling_factor[qp];
7078 cmd->dw47.max_vmv_r = i965_avc_get_max_mv_len(avc_state->seq_param->level_idc) * 4;//frame only
7079 cmd->dw36.hme_combine_overlap = 1;
7080 surface_id = slice_param->RefPicList1[0].picture_id;
7081 obj_surface = SURFACE(surface_id);
7082 if (!obj_surface) {
7083 WARN_ONCE("Invalid backward reference frame\n");
7084 return;
7085 }
7086 cmd->dw36.is_fwd_frame_short_term_ref = !!(slice_param->RefPicList1[0].flags & VA_PICTURE_H264_SHORT_TERM_REFERENCE);
7087 cmd->dw36.num_ref_idx_l0_minus_one = (avc_state->multi_pre_enable) ? slice_param->num_ref_idx_l0_active_minus1 : 0;
7088 cmd->dw36.num_ref_idx_l1_minus_one = (avc_state->multi_pre_enable) ? slice_param->num_ref_idx_l1_active_minus1 : 0;
7089 cmd->dw39.ref_width = gen9_avc_b_search_x[preset];
7090 cmd->dw39.ref_height = gen9_avc_b_search_y[preset];
7091 cmd->dw40.dist_scale_factor_ref_id0_list0 = avc_state->dist_scale_factor_list0[0];
7092 cmd->dw40.dist_scale_factor_ref_id1_list0 = avc_state->dist_scale_factor_list0[1];
7093 cmd->dw41.dist_scale_factor_ref_id2_list0 = avc_state->dist_scale_factor_list0[2];
7094 cmd->dw41.dist_scale_factor_ref_id3_list0 = avc_state->dist_scale_factor_list0[3];
7095 cmd->dw42.dist_scale_factor_ref_id4_list0 = avc_state->dist_scale_factor_list0[4];
7096 cmd->dw42.dist_scale_factor_ref_id5_list0 = avc_state->dist_scale_factor_list0[5];
7097 cmd->dw43.dist_scale_factor_ref_id6_list0 = avc_state->dist_scale_factor_list0[6];
7098 cmd->dw43.dist_scale_factor_ref_id7_list0 = avc_state->dist_scale_factor_list0[7];
7099 cmd->dw34.enable_direct_bias_adjustment = avc_state->direct_bias_adjustment_enable;
7100 if (cmd->dw34.enable_direct_bias_adjustment) {
7101 cmd->dw7.non_skip_zmv_added = 1;
7102 cmd->dw7.non_skip_mode_added = 1;
7103 }
7104
7105 cmd->dw34.enable_global_motion_bias_adjustment = avc_state->global_motion_bias_adjustment_enable;
7106 if (avc_state->global_motion_bias_adjustment_enable)
7107 cmd->dw58.hme_mv_cost_scaling_factor = avc_state->hme_mv_cost_scaling_factor;
7108
7109 cmd->dw64.l1_list_ref0_pic_coding_type = 0; // always frame
7110 }
7111 avc_state->block_based_skip_enable = cmd->dw3.block_based_skip_enable;
7112
7113 if (avc_state->rolling_intra_refresh_enable) {
7114 /*by now disable it*/
7115 if (generic_state->brc_enabled) {
7116 cmd->dw4.enable_intra_refresh = false;
7117 cmd->dw34.widi_intra_refresh_en = avc_state->rolling_intra_refresh_enable;
7118 cmd->dw48.widi_intra_refresh_mbx = 0;
7119 cmd->dw58.widi_intra_refresh_mby = 0;
7120 } else {
7121 cmd->dw4.enable_intra_refresh = true;
7122 cmd->dw34.widi_intra_refresh_en = avc_state->rolling_intra_refresh_enable;
7123 }
7124 cmd->dw32.mult_pred_l0_disable = 128;
7125 /* Pass the same IntraRefreshUnit to the kernel w/o the adjustment by -1, so as to have an overlap of one MB row or column of Intra macroblocks
7126 across one P frame to another P frame, as needed by the RollingI algo */
7127 cmd->dw48.widi_intra_refresh_mbx = 0;
7128 cmd->dw48.widi_intra_refresh_unit_in_mb_minus1 = 0;
7129 cmd->dw48.widi_intra_refresh_qp_delta = 0;
7130
7131 } else {
7132 cmd->dw34.widi_intra_refresh_en = 0;
7133 }
7134
7135 /*roi set disable by now. 49-56*/
7136 if (curbe_param->roi_enabled) {
7137 cmd->dw49.roi_1_x_left = generic_state->roi[0].left;
7138 cmd->dw49.roi_1_y_top = generic_state->roi[0].top;
7139 cmd->dw50.roi_1_x_right = generic_state->roi[0].right;
7140 cmd->dw50.roi_1_y_bottom = generic_state->roi[0].bottom;
7141
7142 cmd->dw51.roi_2_x_left = generic_state->roi[1].left;
7143 cmd->dw51.roi_2_y_top = generic_state->roi[1].top;
7144 cmd->dw52.roi_2_x_right = generic_state->roi[1].right;
7145 cmd->dw52.roi_2_y_bottom = generic_state->roi[1].bottom;
7146
7147 cmd->dw53.roi_3_x_left = generic_state->roi[2].left;
7148 cmd->dw53.roi_3_y_top = generic_state->roi[2].top;
7149 cmd->dw54.roi_3_x_right = generic_state->roi[2].right;
7150 cmd->dw54.roi_3_y_bottom = generic_state->roi[2].bottom;
7151
7152 cmd->dw55.roi_4_x_left = generic_state->roi[3].left;
7153 cmd->dw55.roi_4_y_top = generic_state->roi[3].top;
7154 cmd->dw56.roi_4_x_right = generic_state->roi[3].right;
7155 cmd->dw56.roi_4_y_bottom = generic_state->roi[3].bottom;
7156
7157 if (!generic_state->brc_enabled) {
7158 char tmp = 0;
7159 tmp = generic_state->roi[0].value;
7160 CLIP(tmp, -qp, AVC_QP_MAX - qp);
7161 cmd->dw57.roi_1_dqp_prime_y = tmp;
7162 tmp = generic_state->roi[1].value;
7163 CLIP(tmp, -qp, AVC_QP_MAX - qp);
7164 cmd->dw57.roi_2_dqp_prime_y = tmp;
7165 tmp = generic_state->roi[2].value;
7166 CLIP(tmp, -qp, AVC_QP_MAX - qp);
7167 cmd->dw57.roi_3_dqp_prime_y = tmp;
7168 tmp = generic_state->roi[3].value;
7169 CLIP(tmp, -qp, AVC_QP_MAX - qp);
7170 cmd->dw57.roi_4_dqp_prime_y = tmp;
7171 } else {
7172 cmd->dw34.roi_enable_flag = 0;
7173 }
7174 }
7175
7176 //IPCM QP and threshold
7177 cmd->dw65.ipcm_qp0 = gen8_avc_ipcm_threshold_table[0].qp;
7178 cmd->dw65.ipcm_qp1 = gen8_avc_ipcm_threshold_table[1].qp;
7179 cmd->dw65.ipcm_qp2 = gen8_avc_ipcm_threshold_table[2].qp;
7180 cmd->dw65.ipcm_qp3 = gen8_avc_ipcm_threshold_table[3].qp;
7181 cmd->dw66.ipcm_qp4 = gen8_avc_ipcm_threshold_table[4].qp;
7182 cmd->dw66.ipcm_thresh0 = gen8_avc_ipcm_threshold_table[0].threshold;
7183 cmd->dw67.ipcm_thresh1 = gen8_avc_ipcm_threshold_table[1].threshold;
7184 cmd->dw67.ipcm_thresh2 = gen8_avc_ipcm_threshold_table[2].threshold;
7185 cmd->dw68.ipcm_thresh3 = gen8_avc_ipcm_threshold_table[3].threshold;
7186 cmd->dw68.ipcm_thresh4 = gen8_avc_ipcm_threshold_table[4].threshold;
7187
7188 cmd->dw73.mb_data_surf_index = GEN8_AVC_MBENC_MFC_AVC_PAK_OBJ_CM;
7189 cmd->dw74.mv_data_surf_index = GEN8_AVC_MBENC_IND_MV_DATA_CM;
7190 cmd->dw75.i_dist_surf_index = GEN8_AVC_MBENC_BRC_DISTORTION_CM;
7191 cmd->dw76.src_y_surf_index = GEN8_AVC_MBENC_CURR_Y_CM;
7192 cmd->dw77.mb_specific_data_surf_index = GEN8_AVC_MBENC_MB_SPECIFIC_DATA_CM;
7193 cmd->dw78.aux_vme_out_surf_index = GEN8_AVC_MBENC_AUX_VME_OUT_CM;
7194 cmd->dw79.curr_ref_pic_sel_surf_index = GEN8_AVC_MBENC_REFPICSELECT_L0_CM;
7195 cmd->dw80.hme_mv_pred_fwd_bwd_surf_index = GEN8_AVC_MBENC_MV_DATA_FROM_ME_CM;
7196 cmd->dw81.hme_dist_surf_index = GEN8_AVC_MBENC_4xME_DISTORTION_CM;
7197 cmd->dw82.slice_map_surf_index = GEN8_AVC_MBENC_SLICEMAP_DATA_CM;
7198 cmd->dw83.fwd_frm_mb_data_surf_index = GEN8_AVC_MBENC_FWD_MB_DATA_CM;
7199 cmd->dw84.fwd_frm_mv_surf_index = GEN8_AVC_MBENC_FWD_MV_DATA_CM;
7200 cmd->dw85.mb_qp_buffer = GEN8_AVC_MBENC_MBQP_CM;
7201 cmd->dw86.mb_brc_lut = GEN8_AVC_MBENC_MBBRC_CONST_DATA_CM;
7202 cmd->dw87.vme_inter_prediction_surf_index = GEN8_AVC_MBENC_VME_INTER_PRED_CURR_PIC_IDX_0_CM;
7203 cmd->dw88.vme_inter_prediction_mr_surf_index = GEN8_AVC_MBENC_VME_INTER_PRED_CURR_PIC_IDX_1_CM;
7204 cmd->dw89.flatness_chk_surf_index = GEN8_AVC_MBENC_FLATNESS_CHECK_CM;
7205 cmd->dw90.mad_surf_index = GEN8_AVC_MBENC_MAD_DATA_CM;
7206 cmd->dw91.force_non_skip_mb_map_surface = GEN8_AVC_MBENC_FORCE_NONSKIP_MB_MAP_CM;
7207 cmd->dw92.widi_wa_surf_index = GEN8_AVC_MBENC_WIDI_WA_DATA_CM;
7208 cmd->dw93.brc_curbe_surf_index = GEN8_AVC_MBENC_BRC_CURBE_DATA_CM;
7209 cmd->dw94.static_detection_cost_table_index = GEN8_AVC_MBENC_STATIC_FRAME_DETECTION_OUTPUT_CM;
7210
7211 i965_gpe_context_unmap_curbe(gpe_context);
7212
7213 return;
7214 }
7215
7216 static void
7217 gen8_avc_set_curbe_scaling4x(VADriverContextP ctx,
7218 struct encode_state *encode_state,
7219 struct i965_gpe_context *gpe_context,
7220 struct intel_encoder_context *encoder_context,
7221 void *param)
7222 {
7223 gen8_avc_scaling4x_curbe_data *curbe_cmd;
7224 struct scaling_param *surface_param = (struct scaling_param *)param;
7225
7226 curbe_cmd = i965_gpe_context_map_curbe(gpe_context);
7227
7228 if (!curbe_cmd)
7229 return;
7230
7231 memset(curbe_cmd, 0, sizeof(gen9_avc_scaling4x_curbe_data));
7232
7233 curbe_cmd->dw0.input_picture_width = surface_param->input_frame_width;
7234 curbe_cmd->dw0.input_picture_height = surface_param->input_frame_height;
7235
7236 curbe_cmd->dw1.input_y_bti = GEN8_SCALING_FRAME_SRC_Y_CM;
7237 curbe_cmd->dw2.output_y_bti = GEN8_SCALING_FRAME_DST_Y_CM;
7238
7239 curbe_cmd->dw5.flatness_threshold = 0;
7240 if (surface_param->enable_mb_flatness_check) {
7241 curbe_cmd->dw5.flatness_threshold = 128;
7242 curbe_cmd->dw8.flatness_output_bti_top_field = 4;
7243 }
7244
7245 curbe_cmd->dw6.enable_mb_flatness_check = surface_param->enable_mb_flatness_check;
7246 curbe_cmd->dw6.enable_mb_variance_output = surface_param->enable_mb_variance_output;
7247 curbe_cmd->dw6.enable_mb_pixel_average_output = surface_param->enable_mb_pixel_average_output;
7248
7249 if (curbe_cmd->dw6.enable_mb_variance_output ||
7250 curbe_cmd->dw6.enable_mb_pixel_average_output) {
7251 curbe_cmd->dw10.mbv_proc_states_bti_top_field = GEN8_SCALING_FIELD_TOP_MBVPROCSTATS_DST_CM;
7252 curbe_cmd->dw11.mbv_proc_states_bti_bottom_field = GEN8_SCALING_FIELD_BOT_MBVPROCSTATS_DST_CM;
7253 }
7254
7255 i965_gpe_context_unmap_curbe(gpe_context);
7256 return;
7257 }
7258
7259 static void
7260 gen8_avc_set_curbe_me(VADriverContextP ctx,
7261 struct encode_state *encode_state,
7262 struct i965_gpe_context *gpe_context,
7263 struct intel_encoder_context *encoder_context,
7264 void * param)
7265 {
7266 gen8_avc_me_curbe_data *curbe_cmd;
7267 struct encoder_vme_mfc_context * vme_context = (struct encoder_vme_mfc_context *)encoder_context->vme_context;
7268 struct generic_enc_codec_state * generic_state = (struct generic_enc_codec_state *)vme_context->generic_enc_state;
7269 struct avc_enc_state * avc_state = (struct avc_enc_state *)vme_context->private_enc_state;
7270
7271 VAEncSliceParameterBufferH264 * slice_param = avc_state->slice_param[0];
7272
7273 struct me_param * curbe_param = (struct me_param *)param ;
7274 unsigned char use_mv_from_prev_step = 0;
7275 unsigned char write_distortions = 0;
7276 unsigned char qp_prime_y = 0;
7277 unsigned char me_method = gen9_avc_p_me_method[generic_state->preset];
7278 unsigned char seach_table_idx = 0;
7279 unsigned char mv_shift_factor = 0, prev_mv_read_pos_factor = 0;
7280 unsigned int downscaled_width_in_mb, downscaled_height_in_mb;
7281 unsigned int scale_factor = 0;
7282
7283 qp_prime_y = avc_state->pic_param->pic_init_qp + slice_param->slice_qp_delta;
7284 switch (curbe_param->hme_type) {
7285 case INTEL_ENC_HME_4x : {
7286 use_mv_from_prev_step = (generic_state->b16xme_enabled) ? 1 : 0;
7287 write_distortions = 1;
7288 mv_shift_factor = 2;
7289 scale_factor = 4;
7290 prev_mv_read_pos_factor = 0;
7291 break;
7292 }
7293 case INTEL_ENC_HME_16x : {
7294 use_mv_from_prev_step = (generic_state->b32xme_enabled) ? 1 : 0;
7295 write_distortions = 0;
7296 mv_shift_factor = 2;
7297 scale_factor = 16;
7298 prev_mv_read_pos_factor = 1;
7299 break;
7300 }
7301 case INTEL_ENC_HME_32x : {
7302 use_mv_from_prev_step = 0;
7303 write_distortions = 0;
7304 mv_shift_factor = 1;
7305 scale_factor = 32;
7306 prev_mv_read_pos_factor = 0;
7307 break;
7308 }
7309 default:
7310 assert(0);
7311
7312 }
7313 curbe_cmd = i965_gpe_context_map_curbe(gpe_context);
7314
7315 if (!curbe_cmd)
7316 return;
7317
7318 downscaled_width_in_mb = ALIGN(generic_state->frame_width_in_pixel / scale_factor, 16) / 16;
7319 downscaled_height_in_mb = ALIGN(generic_state->frame_height_in_pixel / scale_factor, 16) / 16;
7320
7321 memcpy(curbe_cmd, gen8_avc_me_curbe_init_data, sizeof(gen8_avc_me_curbe_data));
7322
7323 curbe_cmd->dw3.sub_pel_mode = 3;
7324 if (avc_state->field_scaling_output_interleaved) {
7325 /*frame set to zero,field specified*/
7326 curbe_cmd->dw3.src_access = 0;
7327 curbe_cmd->dw3.ref_access = 0;
7328 curbe_cmd->dw7.src_field_polarity = 0;
7329 }
7330 curbe_cmd->dw4.picture_height_minus1 = downscaled_height_in_mb - 1;
7331 curbe_cmd->dw4.picture_width = downscaled_width_in_mb;
7332 curbe_cmd->dw5.qp_prime_y = qp_prime_y;
7333
7334 curbe_cmd->dw6.use_mv_from_prev_step = use_mv_from_prev_step;
7335 curbe_cmd->dw6.write_distortions = write_distortions;
7336 curbe_cmd->dw6.super_combine_dist = gen9_avc_super_combine_dist[generic_state->preset];
7337 curbe_cmd->dw6.max_vmvr = i965_avc_get_max_mv_len(avc_state->seq_param->level_idc) * 4;//frame only
7338
7339 if (generic_state->frame_type == SLICE_TYPE_B) {
7340 curbe_cmd->dw1.bi_weight = 32;
7341 curbe_cmd->dw13.num_ref_idx_l1_minus1 = slice_param->num_ref_idx_l1_active_minus1;
7342 me_method = gen9_avc_b_me_method[generic_state->preset];
7343 seach_table_idx = 1;
7344 }
7345
7346 if (generic_state->frame_type == SLICE_TYPE_P ||
7347 generic_state->frame_type == SLICE_TYPE_B)
7348 curbe_cmd->dw13.num_ref_idx_l0_minus1 = slice_param->num_ref_idx_l0_active_minus1;
7349
7350 curbe_cmd->dw15.prev_mv_read_pos_factor = prev_mv_read_pos_factor;
7351 curbe_cmd->dw15.mv_shift_factor = mv_shift_factor;
7352
7353 memcpy(&curbe_cmd->dw16, table_enc_search_path[seach_table_idx][me_method], 14 * sizeof(int));
7354
7355 curbe_cmd->dw32._4x_memv_output_data_surf_index = GEN8_AVC_ME_MV_DATA_SURFACE_CM;
7356 curbe_cmd->dw33._16x_32x_memv_input_data_surf_index = (curbe_param->hme_type == INTEL_ENC_HME_32x) ? GEN8_AVC_32xME_MV_DATA_SURFACE_CM : GEN8_AVC_16xME_MV_DATA_SURFACE_CM ;
7357 curbe_cmd->dw34._4x_me_output_dist_surf_index = GEN8_AVC_ME_DISTORTION_SURFACE_CM;
7358 curbe_cmd->dw35._4x_me_output_brc_dist_surf_index = GEN8_AVC_ME_BRC_DISTORTION_CM;
7359 curbe_cmd->dw36.vme_fwd_inter_pred_surf_index = GEN8_AVC_ME_CURR_FOR_FWD_REF_CM;
7360 curbe_cmd->dw37.vme_bdw_inter_pred_surf_index = GEN8_AVC_ME_CURR_FOR_BWD_REF_CM;
7361 curbe_cmd->dw38.reserved = 0;
7362
7363 i965_gpe_context_unmap_curbe(gpe_context);
7364 return;
7365 }
7366
7367 static void
7368 gen8_avc_set_curbe_brc_frame_update(VADriverContextP ctx,
7369 struct encode_state *encode_state,
7370 struct i965_gpe_context *gpe_context,
7371 struct intel_encoder_context *encoder_context,
7372 void * param)
7373 {
7374 gen8_avc_frame_brc_update_curbe_data *cmd;
7375 struct encoder_vme_mfc_context * vme_context = (struct encoder_vme_mfc_context *)encoder_context->vme_context;
7376 struct generic_enc_codec_state * generic_state = (struct generic_enc_codec_state *)vme_context->generic_enc_state;
7377 struct avc_enc_state * avc_state = (struct avc_enc_state *)vme_context->private_enc_state;
7378 struct object_surface *obj_surface;
7379 struct gen9_surface_avc *avc_priv_surface;
7380 struct avc_param common_param;
7381 VAEncSequenceParameterBufferH264 * seq_param = avc_state->seq_param;
7382
7383 obj_surface = encode_state->reconstructed_object;
7384
7385 if (!obj_surface || !obj_surface->private_data)
7386 return;
7387 avc_priv_surface = obj_surface->private_data;
7388
7389 cmd = i965_gpe_context_map_curbe(gpe_context);
7390
7391 if (!cmd)
7392 return;
7393
7394 memcpy(cmd, &gen8_avc_frame_brc_update_curbe_init_data, sizeof(gen8_avc_frame_brc_update_curbe_data));
7395
7396 cmd->dw5.target_size_flag = 0 ;
7397 if (generic_state->brc_init_current_target_buf_full_in_bits > (double)generic_state->brc_init_reset_buf_size_in_bits) {
7398 /*overflow*/
7399 generic_state->brc_init_current_target_buf_full_in_bits -= (double)generic_state->brc_init_reset_buf_size_in_bits;
7400 cmd->dw5.target_size_flag = 1 ;
7401 }
7402
7403 if (generic_state->skip_frame_enbale) {
7404 cmd->dw6.num_skip_frames = generic_state->num_skip_frames ;
7405 cmd->dw7.size_skip_frames = generic_state->size_skip_frames;
7406
7407 generic_state->brc_init_current_target_buf_full_in_bits += generic_state->brc_init_reset_input_bits_per_frame * generic_state->num_skip_frames;
7408
7409 }
7410 cmd->dw0.target_size = (unsigned int)generic_state->brc_init_current_target_buf_full_in_bits ;
7411 cmd->dw1.frame_number = generic_state->seq_frame_number ;
7412 cmd->dw2.size_of_pic_headers = generic_state->herder_bytes_inserted << 3 ;
7413 cmd->dw5.cur_frame_type = generic_state->frame_type ;
7414 cmd->dw5.brc_flag = 0 ;
7415 cmd->dw5.brc_flag |= (avc_priv_surface->is_as_ref) ? INTEL_ENCODE_BRCUPDATE_IS_REFERENCE : 0 ;
7416
7417 if (avc_state->multi_pre_enable) {
7418 cmd->dw5.brc_flag |= INTEL_ENCODE_BRCUPDATE_IS_ACTUALQP ;
7419 cmd->dw14.qp_index_of_cur_pic = avc_priv_surface->frame_idx ; //do not know this. use -1
7420 }
7421
7422 cmd->dw5.max_num_paks = generic_state->num_pak_passes ;
7423 if (avc_state->min_max_qp_enable) {
7424 switch (generic_state->frame_type) {
7425 case SLICE_TYPE_I:
7426 cmd->dw6.minimum_qp = avc_state->min_qp_i ;
7427 cmd->dw6.maximum_qp = avc_state->max_qp_i ;
7428 break;
7429 case SLICE_TYPE_P:
7430 cmd->dw6.minimum_qp = avc_state->min_qp_p ;
7431 cmd->dw6.maximum_qp = avc_state->max_qp_p ;
7432 break;
7433 case SLICE_TYPE_B:
7434 cmd->dw6.minimum_qp = avc_state->min_qp_b ;
7435 cmd->dw6.maximum_qp = avc_state->max_qp_b ;
7436 break;
7437 }
7438 } else {
7439 cmd->dw6.minimum_qp = 0 ;
7440 cmd->dw6.maximum_qp = 0 ;
7441 }
7442
7443 cmd->dw6.enable_force_to_skip = 1;
7444 cmd->dw6.enable_sliding_window = 0;
7445
7446 generic_state->brc_init_current_target_buf_full_in_bits += generic_state->brc_init_reset_input_bits_per_frame;
7447
7448 if (generic_state->internal_rate_mode == INTEL_BRC_AVBR) {
7449 cmd->dw3.start_gadj_frame0 = (unsigned int)((10 * generic_state->avbr_convergence) / (double)150);
7450 cmd->dw3.start_gadj_frame1 = (unsigned int)((50 * generic_state->avbr_convergence) / (double)150);
7451 cmd->dw4.start_gadj_frame2 = (unsigned int)((100 * generic_state->avbr_convergence) / (double)150);
7452 cmd->dw4.start_gadj_frame3 = (unsigned int)((150 * generic_state->avbr_convergence) / (double)150);
7453 cmd->dw11.g_rate_ratio_threshold_0 = (unsigned int)((100 - (generic_state->avbr_curracy / (double)30) * (100 - 40)));
7454 cmd->dw11.g_rate_ratio_threshold_1 = (unsigned int)((100 - (generic_state->avbr_curracy / (double)30) * (100 - 75)));
7455 cmd->dw12.g_rate_ratio_threshold_2 = (unsigned int)((100 - (generic_state->avbr_curracy / (double)30) * (100 - 97)));
7456 cmd->dw12.g_rate_ratio_threshold_3 = (unsigned int)((100 + (generic_state->avbr_curracy / (double)30) * (103 - 100)));
7457 cmd->dw12.g_rate_ratio_threshold_4 = (unsigned int)((100 + (generic_state->avbr_curracy / (double)30) * (125 - 100)));
7458 cmd->dw12.g_rate_ratio_threshold_5 = (unsigned int)((100 + (generic_state->avbr_curracy / (double)30) * (160 - 100)));
7459
7460 }
7461
7462 memset(&common_param, 0, sizeof(common_param));
7463 common_param.frame_width_in_pixel = generic_state->frame_width_in_pixel;
7464 common_param.frame_height_in_pixel = generic_state->frame_height_in_pixel;
7465 common_param.frame_width_in_mbs = generic_state->frame_width_in_mbs;
7466 common_param.frame_height_in_mbs = generic_state->frame_height_in_mbs;
7467 common_param.frames_per_100s = generic_state->frames_per_100s;
7468 common_param.vbv_buffer_size_in_bit = generic_state->vbv_buffer_size_in_bit;
7469 common_param.target_bit_rate = generic_state->target_bit_rate;
7470
7471 cmd->dw19.user_max_frame = i965_avc_get_profile_level_max_frame(&common_param, seq_param->level_idc);
7472
7473 i965_gpe_context_unmap_curbe(gpe_context);
7474
7475 return;
7476 }
7477
7478 /*
7479 kernel related function:init/destroy etc
7480 */
7481 static void
7482 gen9_avc_kernel_init_scaling(VADriverContextP ctx,
7483 struct generic_encoder_context *generic_context,
7484 struct gen_avc_scaling_context *kernel_context,
7485 int preenc_enabled)
7486 {
7487 struct i965_driver_data *i965 = i965_driver_data(ctx);
7488 struct i965_gpe_table *gpe = &i965->gpe_table;
7489 struct i965_gpe_context *gpe_context = NULL;
7490 struct encoder_kernel_parameter kernel_param ;
7491 struct encoder_scoreboard_parameter scoreboard_param;
7492 struct i965_kernel common_kernel;
7493
7494 memset(&kernel_param, 0, sizeof(kernel_param));
7495 if (IS_SKL(i965->intel.device_info) ||
7496 IS_BXT(i965->intel.device_info)) {
7497 if (!preenc_enabled) {
7498 kernel_param.curbe_size = sizeof(gen9_avc_scaling4x_curbe_data);
7499 kernel_param.inline_data_size = sizeof(gen9_avc_scaling4x_curbe_data);
7500 } else {
7501 /* Skylake PreEnc using GEN95/gen10 DS kernel */
7502 kernel_param.curbe_size = sizeof(gen95_avc_scaling4x_curbe_data);
7503 kernel_param.inline_data_size = sizeof(gen95_avc_scaling4x_curbe_data);
7504 }
7505 } else if (IS_KBL(i965->intel.device_info) ||
7506 IS_GEN10(i965->intel.device_info) ||
7507 IS_GLK(i965->intel.device_info)) {
7508 kernel_param.curbe_size = sizeof(gen95_avc_scaling4x_curbe_data);
7509 kernel_param.inline_data_size = sizeof(gen95_avc_scaling4x_curbe_data);
7510 } else if (IS_GEN8(i965->intel.device_info)) {
7511 kernel_param.curbe_size = sizeof(gen8_avc_scaling4x_curbe_data);
7512 kernel_param.inline_data_size = sizeof(gen8_avc_scaling4x_curbe_data);
7513 } else
7514 assert(0);
7515
7516 /* 4x scaling kernel*/
7517 kernel_param.sampler_size = 0;
7518
7519 memset(&scoreboard_param, 0, sizeof(scoreboard_param));
7520 scoreboard_param.mask = 0xFF;
7521 scoreboard_param.enable = generic_context->use_hw_scoreboard;
7522 scoreboard_param.type = generic_context->use_hw_non_stalling_scoreboard;
7523 scoreboard_param.walkpat_flag = 0;
7524
7525 gpe_context = &kernel_context->gpe_contexts[GEN9_AVC_KERNEL_SCALING_4X_IDX];
7526 gen9_init_gpe_context_avc(ctx, gpe_context, &kernel_param);
7527 gen9_init_vfe_scoreboard_avc(gpe_context, &scoreboard_param);
7528
7529 memset(&common_kernel, 0, sizeof(common_kernel));
7530
7531 generic_context->get_kernel_header_and_size((void *)(generic_context->enc_kernel_ptr),
7532 generic_context->enc_kernel_size,
7533 INTEL_GENERIC_ENC_SCALING4X,
7534 0,
7535 &common_kernel);
7536
7537 gpe->load_kernels(ctx,
7538 gpe_context,
7539 &common_kernel,
7540 1);
7541
7542 /* PreEnc using only the 4X scaling */
7543 if (preenc_enabled)
7544 return;
7545
7546 /*2x scaling kernel*/
7547 kernel_param.curbe_size = sizeof(gen9_avc_scaling2x_curbe_data);
7548 kernel_param.inline_data_size = 0;
7549 kernel_param.sampler_size = 0;
7550
7551 gpe_context = &kernel_context->gpe_contexts[GEN9_AVC_KERNEL_SCALING_2X_IDX];
7552 gen9_init_gpe_context_avc(ctx, gpe_context, &kernel_param);
7553 gen9_init_vfe_scoreboard_avc(gpe_context, &scoreboard_param);
7554
7555 memset(&common_kernel, 0, sizeof(common_kernel));
7556
7557 if (IS_GEN8(i965->intel.device_info))
7558 gen8_avc_get_kernel_header_and_size((void *)(generic_context->enc_kernel_ptr),
7559 generic_context->enc_kernel_size,
7560 INTEL_GENERIC_ENC_SCALING2X,
7561 0,
7562 &common_kernel);
7563 else
7564 intel_avc_get_kernel_header_and_size((void *)(generic_context->enc_kernel_ptr),
7565 generic_context->enc_kernel_size,
7566 INTEL_GENERIC_ENC_SCALING2X,
7567 0,
7568 &common_kernel);
7569
7570 gpe->load_kernels(ctx,
7571 gpe_context,
7572 &common_kernel,
7573 1);
7574
7575 }
7576
7577 static void
7578 gen9_avc_kernel_init_me(VADriverContextP ctx,
7579 struct generic_encoder_context *generic_context,
7580 struct gen_avc_me_context *kernel_context,
7581 int preenc_enabled)
7582 {
7583 struct i965_driver_data *i965 = i965_driver_data(ctx);
7584 struct i965_gpe_table *gpe = &i965->gpe_table;
7585 struct i965_gpe_context *gpe_context = NULL;
7586 struct encoder_kernel_parameter kernel_param ;
7587 struct encoder_scoreboard_parameter scoreboard_param;
7588 struct i965_kernel common_kernel;
7589 int i = 0;
7590 unsigned int curbe_size = 0;
7591
7592 if (IS_GEN8(i965->intel.device_info)) {
7593 curbe_size = sizeof(gen8_avc_me_curbe_data);
7594 } else {
7595 if (!preenc_enabled)
7596 curbe_size = sizeof(gen9_avc_me_curbe_data);
7597 else
7598 curbe_size = sizeof(gen9_avc_fei_me_curbe_data);
7599 }
7600
7601 kernel_param.curbe_size = curbe_size;
7602 kernel_param.inline_data_size = 0;
7603 kernel_param.sampler_size = 0;
7604
7605 memset(&scoreboard_param, 0, sizeof(scoreboard_param));
7606 scoreboard_param.mask = 0xFF;
7607 scoreboard_param.enable = generic_context->use_hw_scoreboard;
7608 scoreboard_param.type = generic_context->use_hw_non_stalling_scoreboard;
7609 scoreboard_param.walkpat_flag = 0;
7610
7611 /* There is two hme kernel, one for P and other for B frame */
7612 for (i = 0; i < 2; i++) {
7613 gpe_context = &kernel_context->gpe_contexts[i];
7614 gen9_init_gpe_context_avc(ctx, gpe_context, &kernel_param);
7615 gen9_init_vfe_scoreboard_avc(gpe_context, &scoreboard_param);
7616
7617 memset(&common_kernel, 0, sizeof(common_kernel));
7618
7619 generic_context->get_kernel_header_and_size((void *)(generic_context->enc_kernel_ptr),
7620 generic_context->enc_kernel_size,
7621 INTEL_GENERIC_ENC_ME,
7622 i,
7623 &common_kernel);
7624
7625 gpe->load_kernels(ctx,
7626 gpe_context,
7627 &common_kernel,
7628 1);
7629 }
7630
7631 }
7632
7633 static void
7634 gen9_avc_kernel_init_preproc(VADriverContextP ctx,
7635 struct generic_encoder_context *generic_context,
7636 struct gen_avc_preproc_context *kernel_context)
7637 {
7638 struct i965_driver_data *i965 = i965_driver_data(ctx);
7639 struct i965_gpe_table *gpe = &i965->gpe_table;
7640 struct i965_gpe_context *gpe_context = NULL;
7641 struct encoder_kernel_parameter kernel_param ;
7642 struct encoder_scoreboard_parameter scoreboard_param;
7643 struct i965_kernel common_kernel;
7644
7645 kernel_param.curbe_size = sizeof(gen9_avc_preproc_curbe_data);
7646 kernel_param.inline_data_size = 0;
7647 kernel_param.sampler_size = 0;
7648
7649 memset(&scoreboard_param, 0, sizeof(scoreboard_param));
7650 scoreboard_param.mask = 0xFF;
7651 scoreboard_param.enable = generic_context->use_hw_scoreboard;
7652 scoreboard_param.type = generic_context->use_hw_non_stalling_scoreboard;
7653 scoreboard_param.walkpat_flag = 0;
7654
7655 gpe_context = &kernel_context->gpe_contexts;
7656 gen9_init_gpe_context_avc(ctx, gpe_context, &kernel_param);
7657 gen9_init_vfe_scoreboard_avc(gpe_context, &scoreboard_param);
7658
7659 memset(&common_kernel, 0, sizeof(common_kernel));
7660
7661 intel_avc_fei_get_kernel_header_and_size((void *)(generic_context->enc_kernel_ptr),
7662 generic_context->enc_kernel_size,
7663 INTEL_GENERIC_ENC_PREPROC,
7664 0,
7665 &common_kernel);
7666
7667 gpe->load_kernels(ctx,
7668 gpe_context,
7669 &common_kernel,
7670 1);
7671
7672 }
7673
7674 static void
7675 gen9_avc_kernel_init_mbenc(VADriverContextP ctx,
7676 struct generic_encoder_context *generic_context,
7677 struct gen_avc_mbenc_context *kernel_context,
7678 int fei_enabled)
7679 {
7680 struct i965_driver_data *i965 = i965_driver_data(ctx);
7681 struct i965_gpe_table *gpe = &i965->gpe_table;
7682 struct i965_gpe_context *gpe_context = NULL;
7683 struct encoder_kernel_parameter kernel_param ;
7684 struct encoder_scoreboard_parameter scoreboard_param;
7685 struct i965_kernel common_kernel;
7686 int i = 0;
7687 unsigned int curbe_size = 0;
7688 unsigned int num_mbenc_kernels = 0;
7689
7690 if (IS_SKL(i965->intel.device_info) ||
7691 IS_BXT(i965->intel.device_info)) {
7692 if (!fei_enabled) {
7693 curbe_size = sizeof(gen9_avc_mbenc_curbe_data);
7694 num_mbenc_kernels = NUM_GEN9_AVC_KERNEL_MBENC;
7695 } else {
7696 curbe_size = sizeof(gen9_avc_fei_mbenc_curbe_data);
7697 num_mbenc_kernels = NUM_GEN9_AVC_FEI_KERNEL_MBENC;
7698 }
7699 } else if (IS_KBL(i965->intel.device_info) ||
7700 IS_GEN10(i965->intel.device_info) ||
7701 IS_GLK(i965->intel.device_info)) {
7702 curbe_size = sizeof(gen95_avc_mbenc_curbe_data);
7703 num_mbenc_kernels = NUM_GEN9_AVC_KERNEL_MBENC;
7704 } else if (IS_GEN8(i965->intel.device_info)) {
7705 curbe_size = sizeof(gen8_avc_mbenc_curbe_data);
7706 num_mbenc_kernels = NUM_GEN9_AVC_KERNEL_MBENC;
7707 }
7708
7709 assert(curbe_size > 0);
7710 kernel_param.curbe_size = curbe_size;
7711 kernel_param.inline_data_size = 0;
7712 kernel_param.sampler_size = 0;
7713
7714 memset(&scoreboard_param, 0, sizeof(scoreboard_param));
7715 scoreboard_param.mask = 0xFF;
7716 scoreboard_param.enable = generic_context->use_hw_scoreboard;
7717 scoreboard_param.type = generic_context->use_hw_non_stalling_scoreboard;
7718 scoreboard_param.walkpat_flag = 0;
7719
7720 for (i = 0; i < num_mbenc_kernels ; i++) {
7721 gpe_context = &kernel_context->gpe_contexts[i];
7722 gen9_init_gpe_context_avc(ctx, gpe_context, &kernel_param);
7723 gen9_init_vfe_scoreboard_avc(gpe_context, &scoreboard_param);
7724
7725 memset(&common_kernel, 0, sizeof(common_kernel));
7726
7727 generic_context->get_kernel_header_and_size((void *)(generic_context->enc_kernel_ptr),
7728 generic_context->enc_kernel_size,
7729 INTEL_GENERIC_ENC_MBENC,
7730 i,
7731 &common_kernel);
7732
7733 gpe->load_kernels(ctx,
7734 gpe_context,
7735 &common_kernel,
7736 1);
7737 }
7738
7739 }
7740
7741 static void
7742 gen9_avc_kernel_init_brc(VADriverContextP ctx,
7743 struct generic_encoder_context *generic_context,
7744 struct gen_avc_brc_context *kernel_context)
7745 {
7746 struct i965_driver_data *i965 = i965_driver_data(ctx);
7747 struct i965_gpe_table *gpe = &i965->gpe_table;
7748 struct i965_gpe_context *gpe_context = NULL;
7749 struct encoder_kernel_parameter kernel_param ;
7750 struct encoder_scoreboard_parameter scoreboard_param;
7751 struct i965_kernel common_kernel;
7752 int num_brc_init_kernels = 0;
7753 int i = 0;
7754
7755 if (IS_GEN8(i965->intel.device_info)) {
7756 num_brc_init_kernels = NUM_GEN9_AVC_KERNEL_BRC - 1;
7757 } else {
7758 num_brc_init_kernels = NUM_GEN9_AVC_KERNEL_BRC;
7759 }
7760
7761 const int gen8_brc_curbe_size[NUM_GEN9_AVC_KERNEL_BRC - 1] = {
7762 (sizeof(gen9_avc_brc_init_reset_curbe_data)),
7763 (sizeof(gen8_avc_frame_brc_update_curbe_data)),
7764 (sizeof(gen9_avc_brc_init_reset_curbe_data)),
7765 (sizeof(gen8_avc_mbenc_curbe_data)),
7766 0,
7767 };
7768 const int gen9_brc_curbe_size[NUM_GEN9_AVC_KERNEL_BRC] = {
7769 (sizeof(gen9_avc_brc_init_reset_curbe_data)),
7770 (sizeof(gen9_avc_frame_brc_update_curbe_data)),
7771 (sizeof(gen9_avc_brc_init_reset_curbe_data)),
7772 ((IS_SKL(i965->intel.device_info) || IS_BXT(i965->intel.device_info)) ? sizeof(gen9_avc_mbenc_curbe_data) : sizeof(gen95_avc_mbenc_curbe_data)),
7773 0,
7774 (sizeof(gen9_avc_mb_brc_curbe_data))
7775 };
7776
7777 kernel_param.inline_data_size = 0;
7778 kernel_param.sampler_size = 0;
7779
7780 memset(&scoreboard_param, 0, sizeof(scoreboard_param));
7781 scoreboard_param.mask = 0xFF;
7782 scoreboard_param.enable = generic_context->use_hw_scoreboard;
7783 scoreboard_param.type = generic_context->use_hw_non_stalling_scoreboard;
7784 scoreboard_param.walkpat_flag = 0;
7785
7786 for (i = 0; i < num_brc_init_kernels; i++) {
7787 if (IS_GEN8(i965->intel.device_info)) {
7788 kernel_param.curbe_size = gen8_brc_curbe_size[i];
7789 } else {
7790 kernel_param.curbe_size = gen9_brc_curbe_size[i];
7791 }
7792 gpe_context = &kernel_context->gpe_contexts[i];
7793 gen9_init_gpe_context_avc(ctx, gpe_context, &kernel_param);
7794 gen9_init_vfe_scoreboard_avc(gpe_context, &scoreboard_param);
7795
7796 memset(&common_kernel, 0, sizeof(common_kernel));
7797
7798 if (IS_GEN8(i965->intel.device_info))
7799 gen8_avc_get_kernel_header_and_size((void *)(generic_context->enc_kernel_ptr),
7800 generic_context->enc_kernel_size,
7801 INTEL_GENERIC_ENC_BRC,
7802 i,
7803 &common_kernel);
7804 else
7805 intel_avc_get_kernel_header_and_size((void *)(generic_context->enc_kernel_ptr),
7806 generic_context->enc_kernel_size,
7807 INTEL_GENERIC_ENC_BRC,
7808 i,
7809 &common_kernel);
7810
7811 gpe->load_kernels(ctx,
7812 gpe_context,
7813 &common_kernel,
7814 1);
7815 }
7816
7817 }
7818
7819 static void
7820 gen9_avc_kernel_init_wp(VADriverContextP ctx,
7821 struct generic_encoder_context *generic_context,
7822 struct gen_avc_wp_context *kernel_context)
7823 {
7824 struct i965_driver_data *i965 = i965_driver_data(ctx);
7825 struct i965_gpe_table *gpe = &i965->gpe_table;
7826 struct i965_gpe_context *gpe_context = NULL;
7827 struct encoder_kernel_parameter kernel_param ;
7828 struct encoder_scoreboard_parameter scoreboard_param;
7829 struct i965_kernel common_kernel;
7830
7831 kernel_param.curbe_size = sizeof(gen9_avc_wp_curbe_data);
7832 kernel_param.inline_data_size = 0;
7833 kernel_param.sampler_size = 0;
7834
7835 memset(&scoreboard_param, 0, sizeof(scoreboard_param));
7836 scoreboard_param.mask = 0xFF;
7837 scoreboard_param.enable = generic_context->use_hw_scoreboard;
7838 scoreboard_param.type = generic_context->use_hw_non_stalling_scoreboard;
7839 scoreboard_param.walkpat_flag = 0;
7840
7841 gpe_context = &kernel_context->gpe_contexts;
7842 gen9_init_gpe_context_avc(ctx, gpe_context, &kernel_param);
7843 gen9_init_vfe_scoreboard_avc(gpe_context, &scoreboard_param);
7844
7845 memset(&common_kernel, 0, sizeof(common_kernel));
7846
7847 if (IS_GEN8(i965->intel.device_info))
7848 gen8_avc_get_kernel_header_and_size((void *)(generic_context->enc_kernel_ptr),
7849 generic_context->enc_kernel_size,
7850 INTEL_GENERIC_ENC_WP,
7851 0,
7852 &common_kernel);
7853 else
7854 intel_avc_get_kernel_header_and_size((void *)(generic_context->enc_kernel_ptr),
7855 generic_context->enc_kernel_size,
7856 INTEL_GENERIC_ENC_WP,
7857 0,
7858 &common_kernel);
7859
7860 gpe->load_kernels(ctx,
7861 gpe_context,
7862 &common_kernel,
7863 1);
7864
7865 }
7866
7867 static void
7868 gen9_avc_kernel_init_sfd(VADriverContextP ctx,
7869 struct generic_encoder_context *generic_context,
7870 struct gen_avc_sfd_context *kernel_context)
7871 {
7872 struct i965_driver_data *i965 = i965_driver_data(ctx);
7873 struct i965_gpe_table *gpe = &i965->gpe_table;
7874 struct i965_gpe_context *gpe_context = NULL;
7875 struct encoder_kernel_parameter kernel_param ;
7876 struct encoder_scoreboard_parameter scoreboard_param;
7877 struct i965_kernel common_kernel;
7878
7879 kernel_param.curbe_size = sizeof(gen9_avc_sfd_curbe_data);
7880 kernel_param.inline_data_size = 0;
7881 kernel_param.sampler_size = 0;
7882
7883 memset(&scoreboard_param, 0, sizeof(scoreboard_param));
7884 scoreboard_param.mask = 0xFF;
7885 scoreboard_param.enable = generic_context->use_hw_scoreboard;
7886 scoreboard_param.type = generic_context->use_hw_non_stalling_scoreboard;
7887 scoreboard_param.walkpat_flag = 0;
7888
7889 gpe_context = &kernel_context->gpe_contexts;
7890 gen9_init_gpe_context_avc(ctx, gpe_context, &kernel_param);
7891 gen9_init_vfe_scoreboard_avc(gpe_context, &scoreboard_param);
7892
7893 memset(&common_kernel, 0, sizeof(common_kernel));
7894
7895 if (IS_GEN8(i965->intel.device_info))
7896 gen8_avc_get_kernel_header_and_size((void *)(generic_context->enc_kernel_ptr),
7897 generic_context->enc_kernel_size,
7898 INTEL_GENERIC_ENC_SFD,
7899 0,
7900 &common_kernel);
7901 else
7902 intel_avc_get_kernel_header_and_size((void *)(generic_context->enc_kernel_ptr),
7903 generic_context->enc_kernel_size,
7904 INTEL_GENERIC_ENC_SFD,
7905 0,
7906 &common_kernel);
7907
7908 gpe->load_kernels(ctx,
7909 gpe_context,
7910 &common_kernel,
7911 1);
7912
7913 }
7914
7915 static void
7916 gen9_avc_kernel_destroy(struct encoder_vme_mfc_context * vme_context)
7917 {
7918
7919 struct i965_avc_encoder_context * avc_ctx = (struct i965_avc_encoder_context *)vme_context->private_enc_ctx;
7920 struct i965_driver_data *i965 = i965_driver_data(avc_ctx->ctx);
7921 struct i965_gpe_table *gpe = &i965->gpe_table;
7922
7923 int i = 0;
7924
7925 gen9_avc_free_resources(vme_context);
7926
7927 for (i = 0; i < NUM_GEN9_AVC_KERNEL_SCALING; i++)
7928 gpe->context_destroy(&avc_ctx->context_scaling.gpe_contexts[i]);
7929
7930 for (i = 0; i < NUM_GEN9_AVC_KERNEL_BRC; i++)
7931 gpe->context_destroy(&avc_ctx->context_brc.gpe_contexts[i]);
7932
7933 for (i = 0; i < NUM_GEN9_AVC_KERNEL_ME; i++)
7934 gpe->context_destroy(&avc_ctx->context_me.gpe_contexts[i]);
7935
7936 for (i = 0; i < NUM_GEN9_AVC_KERNEL_MBENC; i++)
7937 gpe->context_destroy(&avc_ctx->context_mbenc.gpe_contexts[i]);
7938
7939 gpe->context_destroy(&avc_ctx->context_wp.gpe_contexts);
7940
7941 gpe->context_destroy(&avc_ctx->context_sfd.gpe_contexts);
7942
7943 gpe->context_destroy(&avc_ctx->context_preproc.gpe_contexts);
7944
7945 }
7946
7947 /*
7948 vme pipeline
7949 */
7950 static void
7951 gen9_avc_update_parameters(VADriverContextP ctx,
7952 VAProfile profile,
7953 struct encode_state *encode_state,
7954 struct intel_encoder_context *encoder_context)
7955 {
7956 struct encoder_vme_mfc_context * vme_context = (struct encoder_vme_mfc_context *)encoder_context->vme_context;
7957 struct generic_enc_codec_state * generic_state = (struct generic_enc_codec_state *)vme_context->generic_enc_state;
7958 struct avc_enc_state * avc_state = (struct avc_enc_state *)vme_context->private_enc_state;
7959 VAEncSequenceParameterBufferH264 *seq_param;
7960 VAEncSliceParameterBufferH264 *slice_param;
7961 VAEncMiscParameterBuffer *fei_misc_param;
7962 int i, j, slice_index;
7963 unsigned int preset = generic_state->preset;
7964 unsigned int fei_enabled = encoder_context->fei_enabled;
7965
7966 /* seq/pic/slice parameter setting */
7967 generic_state->b16xme_supported = gen9_avc_super_hme[preset];
7968 generic_state->b32xme_supported = gen9_avc_ultra_hme[preset];
7969
7970 avc_state->seq_param = (VAEncSequenceParameterBufferH264 *)encode_state->seq_param_ext->buffer;
7971 avc_state->pic_param = (VAEncPictureParameterBufferH264 *)encode_state->pic_param_ext->buffer;
7972
7973 if (fei_enabled &&
7974 encode_state->misc_param[VAEncMiscParameterTypeFEIFrameControl][0] &&
7975 encode_state->misc_param[VAEncMiscParameterTypeFEIFrameControl][0]->buffer) {
7976 fei_misc_param = (VAEncMiscParameterBuffer*)encode_state->misc_param[VAEncMiscParameterTypeFEIFrameControl][0]->buffer;
7977 avc_state->fei_framectl_param =
7978 (VAEncMiscParameterFEIFrameControlH264 *)fei_misc_param->data;
7979 }
7980
7981 avc_state->slice_num = 0;
7982 slice_index = 0;
7983 for (j = 0; j < encode_state->num_slice_params_ext; j++) {
7984 slice_param = (VAEncSliceParameterBufferH264 *)encode_state->slice_params_ext[j]->buffer;
7985 for (i = 0; i < encode_state->slice_params_ext[j]->num_elements; i++) {
7986 avc_state->slice_param[slice_index] = slice_param;
7987 slice_param++;
7988 slice_index++;
7989 avc_state->slice_num++;
7990 }
7991 }
7992
7993 /* how many slices support by now? 1 slice or multi slices, but row slice.not slice group. */
7994 seq_param = avc_state->seq_param;
7995 slice_param = avc_state->slice_param[0];
7996
7997 generic_state->frame_type = avc_state->slice_param[0]->slice_type;
7998
7999 if (slice_param->slice_type == SLICE_TYPE_I ||
8000 slice_param->slice_type == SLICE_TYPE_SI)
8001 generic_state->frame_type = SLICE_TYPE_I;
8002 else if (slice_param->slice_type == SLICE_TYPE_P)
8003 generic_state->frame_type = SLICE_TYPE_P;
8004 else if (slice_param->slice_type == SLICE_TYPE_B)
8005 generic_state->frame_type = SLICE_TYPE_B;
8006 if (profile == VAProfileH264High)
8007 avc_state->transform_8x8_mode_enable = 0;//work around for high profile to disabel pic_param->pic_fields.bits.transform_8x8_mode_flag
8008 else
8009 avc_state->transform_8x8_mode_enable = 0;
8010
8011 /* rc init*/
8012 generic_state->brc_need_reset = (generic_state->brc_inited && encoder_context->brc.need_reset);
8013
8014 if (generic_state->brc_enabled && (!generic_state->brc_inited || generic_state->brc_need_reset)) {
8015 generic_state->target_bit_rate = ALIGN(seq_param->bits_per_second, 1000) / 1000;
8016 generic_state->init_vbv_buffer_fullness_in_bit = seq_param->bits_per_second;
8017 generic_state->vbv_buffer_size_in_bit = (uint64_t)seq_param->bits_per_second << 1;
8018 generic_state->frames_per_100s = 3000; /* 30fps */
8019 }
8020
8021 generic_state->gop_size = seq_param->intra_period;
8022 generic_state->gop_ref_distance = seq_param->ip_period;
8023
8024 if (generic_state->internal_rate_mode == VA_RC_CBR) {
8025 generic_state->max_bit_rate = generic_state->target_bit_rate;
8026 generic_state->min_bit_rate = generic_state->target_bit_rate;
8027 }
8028
8029 if (generic_state->frame_type == SLICE_TYPE_I || generic_state->first_frame || generic_state->brc_need_reset) {
8030 gen9_avc_update_misc_parameters(ctx, encode_state, encoder_context);
8031 }
8032
8033 generic_state->preset = encoder_context->quality_level;
8034 if (encoder_context->quality_level == INTEL_PRESET_UNKNOWN) {
8035 generic_state->preset = INTEL_PRESET_RT_SPEED;
8036 }
8037 generic_state->kernel_mode = gen9_avc_kernel_mode[generic_state->preset];
8038
8039 if (!generic_state->brc_inited || generic_state->brc_need_reset) {
8040 generic_state->brc_init_reset_input_bits_per_frame = ((double)(generic_state->max_bit_rate * 1000) * 100) / generic_state->frames_per_100s;
8041 if (!generic_state->brc_inited)
8042 generic_state->brc_init_current_target_buf_full_in_bits = generic_state->init_vbv_buffer_fullness_in_bit;
8043 generic_state->brc_init_reset_buf_size_in_bits = generic_state->vbv_buffer_size_in_bit;
8044 generic_state->brc_target_size = generic_state->init_vbv_buffer_fullness_in_bit;
8045 }
8046
8047
8048 generic_state->curr_pak_pass = 0;
8049 generic_state->num_pak_passes = MAX_AVC_PAK_PASS_NUM;
8050
8051 if (generic_state->internal_rate_mode == VA_RC_CBR ||
8052 generic_state->internal_rate_mode == VA_RC_VBR)
8053 generic_state->brc_enabled = 1;
8054 else
8055 generic_state->brc_enabled = 0;
8056
8057 if (generic_state->brc_enabled &&
8058 (!generic_state->init_vbv_buffer_fullness_in_bit ||
8059 !generic_state->vbv_buffer_size_in_bit ||
8060 !generic_state->max_bit_rate ||
8061 !generic_state->target_bit_rate ||
8062 !generic_state->frames_per_100s)) {
8063 WARN_ONCE("Rate control parameter is required for BRC\n");
8064 generic_state->brc_enabled = 0;
8065 }
8066
8067 if (!generic_state->brc_enabled) {
8068 generic_state->target_bit_rate = 0;
8069 generic_state->max_bit_rate = 0;
8070 generic_state->min_bit_rate = 0;
8071 generic_state->init_vbv_buffer_fullness_in_bit = 0;
8072 generic_state->vbv_buffer_size_in_bit = 0;
8073 generic_state->num_pak_passes = 1;
8074 } else {
8075 generic_state->num_pak_passes = MAX_AVC_PAK_PASS_NUM;
8076 }
8077
8078
8079 generic_state->frame_width_in_mbs = seq_param->picture_width_in_mbs;
8080 generic_state->frame_height_in_mbs = seq_param->picture_height_in_mbs;
8081 generic_state->frame_width_in_pixel = generic_state->frame_width_in_mbs * 16;
8082 generic_state->frame_height_in_pixel = generic_state->frame_height_in_mbs * 16;
8083
8084 generic_state->frame_width_4x = ALIGN(generic_state->frame_width_in_pixel / 4, 16);
8085 generic_state->frame_height_4x = ALIGN(generic_state->frame_height_in_pixel / 4, 16);
8086 generic_state->downscaled_width_4x_in_mb = generic_state->frame_width_4x / 16 ;
8087 generic_state->downscaled_height_4x_in_mb = generic_state->frame_height_4x / 16;
8088
8089 generic_state->frame_width_16x = ALIGN(generic_state->frame_width_in_pixel / 16, 16);
8090 generic_state->frame_height_16x = ALIGN(generic_state->frame_height_in_pixel / 16, 16);
8091 generic_state->downscaled_width_16x_in_mb = generic_state->frame_width_16x / 16 ;
8092 generic_state->downscaled_height_16x_in_mb = generic_state->frame_height_16x / 16;
8093
8094 generic_state->frame_width_32x = ALIGN(generic_state->frame_width_in_pixel / 32, 16);
8095 generic_state->frame_height_32x = ALIGN(generic_state->frame_height_in_pixel / 32, 16);
8096 generic_state->downscaled_width_32x_in_mb = generic_state->frame_width_32x / 16 ;
8097 generic_state->downscaled_height_32x_in_mb = generic_state->frame_height_32x / 16;
8098
8099 if (generic_state->hme_supported) {
8100 generic_state->hme_enabled = 1;
8101 } else {
8102 generic_state->hme_enabled = 0;
8103 }
8104
8105 if (generic_state->b16xme_supported) {
8106 generic_state->b16xme_enabled = 1;
8107 } else {
8108 generic_state->b16xme_enabled = 0;
8109 }
8110
8111 if (generic_state->b32xme_supported) {
8112 generic_state->b32xme_enabled = 1;
8113 } else {
8114 generic_state->b32xme_enabled = 0;
8115 }
8116 /* disable HME/16xME if the size is too small */
8117 if (generic_state->frame_width_4x <= INTEL_VME_MIN_ALLOWED_WIDTH_HEIGHT) {
8118 generic_state->b32xme_supported = 0;
8119 generic_state->b32xme_enabled = 0;
8120 generic_state->b16xme_supported = 0;
8121 generic_state->b16xme_enabled = 0;
8122 generic_state->frame_width_4x = INTEL_VME_MIN_ALLOWED_WIDTH_HEIGHT;
8123 generic_state->downscaled_width_4x_in_mb = WIDTH_IN_MACROBLOCKS(INTEL_VME_MIN_ALLOWED_WIDTH_HEIGHT);
8124 }
8125 if (generic_state->frame_height_4x <= INTEL_VME_MIN_ALLOWED_WIDTH_HEIGHT) {
8126 generic_state->b32xme_supported = 0;
8127 generic_state->b32xme_enabled = 0;
8128 generic_state->b16xme_supported = 0;
8129 generic_state->b16xme_enabled = 0;
8130 generic_state->frame_height_4x = INTEL_VME_MIN_ALLOWED_WIDTH_HEIGHT;
8131 generic_state->downscaled_height_4x_in_mb = WIDTH_IN_MACROBLOCKS(INTEL_VME_MIN_ALLOWED_WIDTH_HEIGHT);
8132 }
8133
8134 if (generic_state->frame_width_16x < INTEL_VME_MIN_ALLOWED_WIDTH_HEIGHT) {
8135 generic_state->b32xme_supported = 0;
8136 generic_state->b32xme_enabled = 0;
8137 generic_state->frame_width_16x = INTEL_VME_MIN_ALLOWED_WIDTH_HEIGHT;
8138 generic_state->downscaled_width_16x_in_mb = WIDTH_IN_MACROBLOCKS(INTEL_VME_MIN_ALLOWED_WIDTH_HEIGHT);
8139 }
8140 if (generic_state->frame_height_16x < INTEL_VME_MIN_ALLOWED_WIDTH_HEIGHT) {
8141 generic_state->b32xme_supported = 0;
8142 generic_state->b32xme_enabled = 0;
8143 generic_state->frame_height_16x = INTEL_VME_MIN_ALLOWED_WIDTH_HEIGHT;
8144 generic_state->downscaled_height_16x_in_mb = WIDTH_IN_MACROBLOCKS(INTEL_VME_MIN_ALLOWED_WIDTH_HEIGHT);
8145 }
8146
8147 if (generic_state->frame_width_32x < INTEL_VME_MIN_ALLOWED_WIDTH_HEIGHT) {
8148 generic_state->frame_width_32x = INTEL_VME_MIN_ALLOWED_WIDTH_HEIGHT;
8149 generic_state->downscaled_width_32x_in_mb = WIDTH_IN_MACROBLOCKS(INTEL_VME_MIN_ALLOWED_WIDTH_HEIGHT);
8150 }
8151 if (generic_state->frame_height_32x < INTEL_VME_MIN_ALLOWED_WIDTH_HEIGHT) {
8152 generic_state->frame_height_32x = INTEL_VME_MIN_ALLOWED_WIDTH_HEIGHT;
8153 generic_state->downscaled_height_32x_in_mb = WIDTH_IN_MACROBLOCKS(INTEL_VME_MIN_ALLOWED_WIDTH_HEIGHT);
8154 }
8155
8156 }
8157
8158 static VAStatus
8159 gen9_avc_encode_check_parameter(VADriverContextP ctx,
8160 struct encode_state *encode_state,
8161 struct intel_encoder_context *encoder_context)
8162 {
8163 struct encoder_vme_mfc_context * vme_context = (struct encoder_vme_mfc_context *)encoder_context->vme_context;
8164 struct generic_enc_codec_state * generic_state = (struct generic_enc_codec_state *)vme_context->generic_enc_state;
8165 struct avc_enc_state * avc_state = (struct avc_enc_state *)vme_context->private_enc_state;
8166 unsigned int rate_control_mode = encoder_context->rate_control_mode;
8167 unsigned int preset = generic_state->preset;
8168 VAEncPictureParameterBufferH264 *pic_param = avc_state->pic_param ;
8169 VAEncSliceParameterBufferH264 * slice_param = avc_state->slice_param[0];
8170 int i = 0;
8171 int slice_qp = pic_param->pic_init_qp + slice_param->slice_qp_delta;
8172 /*avbr init*/
8173 generic_state->avbr_curracy = 30;
8174 generic_state->avbr_convergence = 150;
8175
8176 switch (rate_control_mode & 0x7f) {
8177 case VA_RC_CBR:
8178 generic_state->internal_rate_mode = VA_RC_CBR;
8179 break;
8180
8181 case VA_RC_VBR:
8182 generic_state->internal_rate_mode = VA_RC_VBR;
8183 break;
8184
8185 case VA_RC_CQP:
8186 default:
8187 generic_state->internal_rate_mode = VA_RC_CQP;
8188 break;
8189 }
8190
8191 if (rate_control_mode != VA_RC_NONE &&
8192 rate_control_mode != VA_RC_CQP) {
8193 generic_state->brc_enabled = 1;
8194 generic_state->brc_distortion_buffer_supported = 1;
8195 generic_state->brc_constant_buffer_supported = 1;
8196 generic_state->num_pak_passes = MAX_AVC_PAK_PASS_NUM;
8197 }
8198
8199 /*check brc parameter*/
8200 if (generic_state->brc_enabled) {
8201 avc_state->mb_qp_data_enable = 0;
8202 }
8203
8204 /*set the brc init and reset accordingly*/
8205 if (generic_state->brc_need_reset &&
8206 (generic_state->brc_distortion_buffer_supported == 0 ||
8207 rate_control_mode == VA_RC_CQP)) {
8208 generic_state->brc_need_reset = 0;// not support by CQP
8209 }
8210 if (generic_state->internal_rate_mode == VA_RC_CBR || generic_state->internal_rate_mode == VA_RC_VBR || generic_state->frame_type == SLICE_TYPE_I) {
8211 avc_state->sfd_enable = 0;
8212 } else {
8213 avc_state->sfd_enable = 1;
8214 }
8215
8216 if (generic_state->frames_per_window_size == 0) {
8217 generic_state->frames_per_window_size = (generic_state->frames_per_100s / 100 < 60) ? (generic_state->frames_per_100s / 100) : 60;
8218 } else if (generic_state->frames_per_window_size > 2 * generic_state->frames_per_100s / 100) {
8219 generic_state->frames_per_window_size = (generic_state->frames_per_100s / 100 < 60) ? (generic_state->frames_per_100s / 100) : 60;
8220 }
8221
8222 if (generic_state->brc_enabled) {
8223 generic_state->hme_enabled = generic_state->frame_type != SLICE_TYPE_I;
8224 if (avc_state->min_max_qp_enable) {
8225 generic_state->num_pak_passes = 1;
8226 }
8227 generic_state->brc_roi_enable = (rate_control_mode != VA_RC_CQP) && (generic_state->num_roi > 0);// only !CQP
8228 generic_state->mb_brc_enabled = generic_state->mb_brc_enabled || generic_state->brc_roi_enable;
8229 } else {
8230 generic_state->num_pak_passes = 1;// CQP only one pass
8231 }
8232
8233 avc_state->mbenc_i_frame_dist_in_use = 0;
8234 avc_state->mbenc_i_frame_dist_in_use = (generic_state->brc_enabled) && (generic_state->brc_distortion_buffer_supported) && (generic_state->frame_type == SLICE_TYPE_I);
8235
8236 /*ROI must enable mbbrc.*/
8237
8238 /*CAD check*/
8239 if (avc_state->caf_supported) {
8240 switch (generic_state->frame_type) {
8241 case SLICE_TYPE_I:
8242 avc_state->caf_enable = 0;
8243 break;
8244 case SLICE_TYPE_P:
8245 avc_state->caf_enable = gen9_avc_all_fractional[preset] & 0x01;
8246 break;
8247 case SLICE_TYPE_B:
8248 avc_state->caf_enable = (gen9_avc_all_fractional[preset] >> 1) & 0x01;
8249 break;
8250 }
8251
8252 if (avc_state->caf_enable && avc_state->caf_disable_hd && gen9_avc_disable_all_fractional_check_for_high_res[preset]) {
8253 if (generic_state->frame_width_in_pixel >= 1280 && generic_state->frame_height_in_pixel >= 720)
8254 avc_state->caf_enable = 0;
8255 }
8256 }
8257
8258 avc_state->adaptive_transform_decision_enable &= gen9_avc_enable_adaptive_tx_decision[preset & 0x7];
8259
8260 /* Flatness check is enabled only if scaling will be performed and CAF is enabled. here only frame */
8261 if (avc_state->flatness_check_supported) {
8262 avc_state->flatness_check_enable = ((avc_state->caf_enable) && (generic_state->brc_enabled || generic_state->hme_supported)) ;
8263 } else {
8264 avc_state->flatness_check_enable = 0;
8265 }
8266
8267 /* check mb_status_supported/enbale*/
8268 if (avc_state->adaptive_transform_decision_enable) {
8269 avc_state->mb_status_enable = 1;
8270 } else {
8271 avc_state->mb_status_enable = 0;
8272 }
8273 /*slice check,all the slices use the same slice height except the last slice*/
8274 avc_state->arbitrary_num_mbs_in_slice = 0;
8275 for (i = 0; i < avc_state->slice_num; i++) {
8276 if (avc_state->slice_param[i]->num_macroblocks % generic_state->frame_width_in_mbs > 0) {
8277 avc_state->arbitrary_num_mbs_in_slice = 1;
8278 avc_state->slice_height = 1; /* slice height will be ignored by kernel ans here set it as default value */
8279 } else {
8280 avc_state->slice_height = avc_state->slice_param[i]->num_macroblocks / generic_state->frame_width_in_mbs;
8281 }
8282 }
8283
8284 if (avc_state->slice_num > 1)
8285 avc_state->arbitrary_num_mbs_in_slice = 1;
8286
8287 if (generic_state->frame_type == SLICE_TYPE_I) {
8288 generic_state->hme_enabled = 0;
8289 generic_state->b16xme_enabled = 0;
8290 generic_state->b32xme_enabled = 0;
8291 }
8292
8293 if (generic_state->frame_type == SLICE_TYPE_B) {
8294 gen9_avc_get_dist_scale_factor(ctx, encode_state, encoder_context);
8295 avc_state->bi_weight = gen9_avc_get_biweight(avc_state->dist_scale_factor_list0[0], pic_param->pic_fields.bits.weighted_bipred_idc);
8296 }
8297
8298 /* Determine if SkipBiasAdjustment should be enabled for P picture 1. No B frame 2. Qp >= 22 3. CQP mode */
8299 avc_state->skip_bias_adjustment_enable = avc_state->skip_bias_adjustment_supported && (generic_state->frame_type == SLICE_TYPE_P)
8300 && (generic_state->gop_ref_distance == 1) && (avc_state->pic_param->pic_init_qp + avc_state->slice_param[0]->slice_qp_delta >= 22) && !generic_state->brc_enabled;
8301
8302 if (generic_state->kernel_mode == INTEL_ENC_KERNEL_QUALITY) {
8303 avc_state->tq_enable = 1;
8304 avc_state->tq_rounding = 6;
8305 if (generic_state->brc_enabled) {
8306 generic_state->mb_brc_enabled = 1;
8307 }
8308 }
8309
8310 //check the inter rounding
8311 avc_state->rounding_value = 0;
8312 avc_state->rounding_inter_p = 255;//default
8313 avc_state->rounding_inter_b = 255; //default
8314 avc_state->rounding_inter_b_ref = 255; //default
8315
8316 if (generic_state->frame_type == SLICE_TYPE_P) {
8317 if (avc_state->rounding_inter_p == AVC_INVALID_ROUNDING_VALUE) {
8318 if (avc_state->adaptive_rounding_inter_enable && !(generic_state->brc_enabled)) {
8319 if (generic_state->gop_ref_distance == 1)
8320 avc_state->rounding_value = gen9_avc_adaptive_inter_rounding_p_without_b[slice_qp];
8321 else
8322 avc_state->rounding_value = gen9_avc_adaptive_inter_rounding_p[slice_qp];
8323 } else {
8324 avc_state->rounding_value = gen9_avc_inter_rounding_p[generic_state->preset];
8325 }
8326
8327 } else {
8328 avc_state->rounding_value = avc_state->rounding_inter_p;
8329 }
8330 } else if (generic_state->frame_type == SLICE_TYPE_B) {
8331 if (pic_param->pic_fields.bits.reference_pic_flag) {
8332 if (avc_state->rounding_inter_b_ref == AVC_INVALID_ROUNDING_VALUE)
8333 avc_state->rounding_value = gen9_avc_inter_rounding_b_ref[generic_state->preset];
8334 else
8335 avc_state->rounding_value = avc_state->rounding_inter_b_ref;
8336 } else {
8337 if (avc_state->rounding_inter_b == AVC_INVALID_ROUNDING_VALUE) {
8338 if (avc_state->adaptive_rounding_inter_enable && !(generic_state->brc_enabled))
8339 avc_state->rounding_value = gen9_avc_adaptive_inter_rounding_b[slice_qp];
8340 else
8341 avc_state->rounding_value = gen9_avc_inter_rounding_b[generic_state->preset];
8342 } else {
8343 avc_state->rounding_value = avc_state->rounding_inter_b;
8344 }
8345 }
8346 }
8347 return VA_STATUS_SUCCESS;
8348 }
8349
8350 static VAStatus
8351 gen9_avc_vme_gpe_kernel_prepare(VADriverContextP ctx,
8352 struct encode_state *encode_state,
8353 struct intel_encoder_context *encoder_context)
8354 {
8355 VAStatus va_status;
8356 struct encoder_vme_mfc_context * vme_context = (struct encoder_vme_mfc_context *)encoder_context->vme_context;
8357 struct generic_encoder_context * generic_ctx = (struct generic_encoder_context *)vme_context->generic_enc_ctx;
8358 struct i965_avc_encoder_context * avc_ctx = (struct i965_avc_encoder_context *)vme_context->private_enc_ctx;
8359 struct generic_enc_codec_state * generic_state = (struct generic_enc_codec_state *)vme_context->generic_enc_state;
8360 struct avc_enc_state * avc_state = (struct avc_enc_state *)vme_context->private_enc_state;
8361
8362 struct object_surface *obj_surface;
8363 struct object_buffer *obj_buffer;
8364 VAEncSliceParameterBufferH264 * slice_param = avc_state->slice_param[0];
8365 VAEncPictureParameterBufferH264 *pic_param = avc_state->pic_param;
8366 struct i965_coded_buffer_segment *coded_buffer_segment;
8367
8368 struct gen9_surface_avc *avc_priv_surface;
8369 dri_bo *bo;
8370 struct avc_surface_param surface_param;
8371 int i, j = 0;
8372 unsigned char * pdata;
8373
8374 /* Setup current reconstruct frame */
8375 obj_surface = encode_state->reconstructed_object;
8376 va_status = i965_check_alloc_surface_bo(ctx, obj_surface, 1, VA_FOURCC_NV12, SUBSAMPLE_YUV420);
8377
8378 if (va_status != VA_STATUS_SUCCESS)
8379 return va_status;
8380
8381 memset(&surface_param, 0, sizeof(surface_param));
8382 surface_param.frame_width = generic_state->frame_width_in_pixel;
8383 surface_param.frame_height = generic_state->frame_height_in_pixel;
8384 va_status = gen9_avc_init_check_surfaces(ctx,
8385 obj_surface,
8386 encoder_context,
8387 &surface_param);
8388 if (va_status != VA_STATUS_SUCCESS)
8389 return va_status;
8390 {
8391 /* init the member of avc_priv_surface,frame_store_id,qp_value*/
8392 avc_priv_surface = (struct gen9_surface_avc *)obj_surface->private_data;
8393 avc_state->top_field_poc[NUM_MFC_AVC_DMV_BUFFERS - 2] = 0;
8394 avc_state->top_field_poc[NUM_MFC_AVC_DMV_BUFFERS - 1] = 0;
8395 i965_free_gpe_resource(&avc_ctx->res_direct_mv_buffersr[NUM_MFC_AVC_DMV_BUFFERS - 2]);
8396 i965_free_gpe_resource(&avc_ctx->res_direct_mv_buffersr[NUM_MFC_AVC_DMV_BUFFERS - 1]);
8397 i965_dri_object_to_buffer_gpe_resource(&avc_ctx->res_direct_mv_buffersr[NUM_MFC_AVC_DMV_BUFFERS - 2], avc_priv_surface->dmv_top);
8398 i965_dri_object_to_buffer_gpe_resource(&avc_ctx->res_direct_mv_buffersr[NUM_MFC_AVC_DMV_BUFFERS - 1], avc_priv_surface->dmv_bottom);
8399 avc_priv_surface->qp_value = pic_param->pic_init_qp + slice_param->slice_qp_delta;
8400 avc_priv_surface->frame_store_id = 0;
8401 avc_priv_surface->frame_idx = pic_param->CurrPic.frame_idx;
8402 avc_priv_surface->top_field_order_cnt = pic_param->CurrPic.TopFieldOrderCnt;
8403 avc_priv_surface->is_as_ref = pic_param->pic_fields.bits.reference_pic_flag;
8404 avc_state->top_field_poc[NUM_MFC_AVC_DMV_BUFFERS - 2] = avc_priv_surface->top_field_order_cnt;
8405 avc_state->top_field_poc[NUM_MFC_AVC_DMV_BUFFERS - 1] = avc_priv_surface->top_field_order_cnt + 1;
8406 }
8407 i965_free_gpe_resource(&generic_ctx->res_reconstructed_surface);
8408 i965_object_surface_to_2d_gpe_resource_with_align(&generic_ctx->res_reconstructed_surface, obj_surface, GPE_RESOURCE_ALIGNMENT);
8409
8410 /* input YUV surface*/
8411 obj_surface = encode_state->input_yuv_object;
8412 va_status = i965_check_alloc_surface_bo(ctx, obj_surface, 1, VA_FOURCC_NV12, SUBSAMPLE_YUV420);
8413
8414 if (va_status != VA_STATUS_SUCCESS)
8415 return va_status;
8416 i965_free_gpe_resource(&generic_ctx->res_uncompressed_input_surface);
8417 i965_object_surface_to_2d_gpe_resource_with_align(&generic_ctx->res_uncompressed_input_surface, obj_surface, GPE_RESOURCE_ALIGNMENT);
8418
8419 /* Reference surfaces */
8420 for (i = 0; i < ARRAY_ELEMS(avc_ctx->list_reference_res); i++) {
8421 i965_free_gpe_resource(&avc_ctx->list_reference_res[i]);
8422 i965_free_gpe_resource(&avc_ctx->res_direct_mv_buffersr[i * 2]);
8423 i965_free_gpe_resource(&avc_ctx->res_direct_mv_buffersr[i * 2 + 1]);
8424 obj_surface = encode_state->reference_objects[i];
8425 avc_state->top_field_poc[2 * i] = 0;
8426 avc_state->top_field_poc[2 * i + 1] = 0;
8427
8428 if (obj_surface && obj_surface->bo) {
8429 i965_object_surface_to_2d_gpe_resource_with_align(&avc_ctx->list_reference_res[i], obj_surface, GPE_RESOURCE_ALIGNMENT);
8430
8431 /* actually it should be handled when it is reconstructed surface*/
8432 va_status = gen9_avc_init_check_surfaces(ctx,
8433 obj_surface, encoder_context,
8434 &surface_param);
8435 if (va_status != VA_STATUS_SUCCESS)
8436 return va_status;
8437 avc_priv_surface = (struct gen9_surface_avc *)obj_surface->private_data;
8438 i965_dri_object_to_buffer_gpe_resource(&avc_ctx->res_direct_mv_buffersr[i * 2], avc_priv_surface->dmv_top);
8439 i965_dri_object_to_buffer_gpe_resource(&avc_ctx->res_direct_mv_buffersr[i * 2 + 1], avc_priv_surface->dmv_bottom);
8440 avc_state->top_field_poc[2 * i] = avc_priv_surface->top_field_order_cnt;
8441 avc_state->top_field_poc[2 * i + 1] = avc_priv_surface->top_field_order_cnt + 1;
8442 avc_priv_surface->frame_store_id = i;
8443 } else {
8444 break;
8445 }
8446 }
8447
8448 /* Encoded bitstream ?*/
8449 obj_buffer = encode_state->coded_buf_object;
8450 bo = obj_buffer->buffer_store->bo;
8451 i965_free_gpe_resource(&generic_ctx->compressed_bitstream.res);
8452 i965_dri_object_to_buffer_gpe_resource(&generic_ctx->compressed_bitstream.res, bo);
8453 generic_ctx->compressed_bitstream.start_offset = I965_CODEDBUFFER_HEADER_SIZE;
8454 generic_ctx->compressed_bitstream.end_offset = ALIGN(obj_buffer->size_element - 0x1000, 0x1000);
8455
8456 /*status buffer */
8457 avc_ctx->status_buffer.bo = bo;
8458
8459 /* set the internal flag to 0 to indicate the coded size is unknown */
8460 dri_bo_map(bo, 1);
8461 coded_buffer_segment = (struct i965_coded_buffer_segment *)bo->virtual;
8462 coded_buffer_segment->mapped = 0;
8463 coded_buffer_segment->codec = encoder_context->codec;
8464 coded_buffer_segment->status_support = 1;
8465
8466 pdata = bo->virtual + avc_ctx->status_buffer.base_offset;
8467 memset(pdata, 0, avc_ctx->status_buffer.status_buffer_size);
8468 dri_bo_unmap(bo);
8469
8470 //frame id, it is the ref pic id in the reference_objects list.
8471 avc_state->num_refs[0] = 0;
8472 avc_state->num_refs[1] = 0;
8473 if (generic_state->frame_type == SLICE_TYPE_P) {
8474 avc_state->num_refs[0] = pic_param->num_ref_idx_l0_active_minus1 + 1;
8475
8476 if (slice_param->num_ref_idx_active_override_flag)
8477 avc_state->num_refs[0] = slice_param->num_ref_idx_l0_active_minus1 + 1;
8478 } else if (generic_state->frame_type == SLICE_TYPE_B) {
8479 avc_state->num_refs[0] = pic_param->num_ref_idx_l0_active_minus1 + 1;
8480 avc_state->num_refs[1] = pic_param->num_ref_idx_l1_active_minus1 + 1;
8481
8482 if (slice_param->num_ref_idx_active_override_flag) {
8483 avc_state->num_refs[0] = slice_param->num_ref_idx_l0_active_minus1 + 1;
8484 avc_state->num_refs[1] = slice_param->num_ref_idx_l1_active_minus1 + 1;
8485 }
8486 }
8487
8488 if (avc_state->num_refs[0] > ARRAY_ELEMS(avc_state->list_ref_idx[0]))
8489 return VA_STATUS_ERROR_INVALID_VALUE;
8490 if (avc_state->num_refs[1] > ARRAY_ELEMS(avc_state->list_ref_idx[1]))
8491 return VA_STATUS_ERROR_INVALID_VALUE;
8492
8493 for (i = 0; i < ARRAY_ELEMS(avc_state->list_ref_idx[0]); i++) {
8494 VAPictureH264 *va_pic;
8495
8496 assert(ARRAY_ELEMS(slice_param->RefPicList0) == ARRAY_ELEMS(avc_state->list_ref_idx[0]));
8497 avc_state->list_ref_idx[0][i] = 0;
8498
8499 if (i >= avc_state->num_refs[0])
8500 continue;
8501
8502 va_pic = &slice_param->RefPicList0[i];
8503
8504 for (j = 0; j < ARRAY_ELEMS(encode_state->reference_objects); j++) {
8505 obj_surface = encode_state->reference_objects[j];
8506
8507 if (obj_surface &&
8508 obj_surface->bo &&
8509 obj_surface->base.id == va_pic->picture_id) {
8510
8511 assert(obj_surface->base.id != VA_INVALID_SURFACE);
8512 avc_state->list_ref_idx[0][i] = j;
8513
8514 break;
8515 }
8516 }
8517 }
8518 for (i = 0; i < ARRAY_ELEMS(avc_state->list_ref_idx[1]); i++) {
8519 VAPictureH264 *va_pic;
8520
8521 assert(ARRAY_ELEMS(slice_param->RefPicList1) == ARRAY_ELEMS(avc_state->list_ref_idx[1]));
8522 avc_state->list_ref_idx[1][i] = 0;
8523
8524 if (i >= avc_state->num_refs[1])
8525 continue;
8526
8527 va_pic = &slice_param->RefPicList1[i];
8528
8529 for (j = 0; j < ARRAY_ELEMS(encode_state->reference_objects); j++) {
8530 obj_surface = encode_state->reference_objects[j];
8531
8532 if (obj_surface &&
8533 obj_surface->bo &&
8534 obj_surface->base.id == va_pic->picture_id) {
8535
8536 assert(obj_surface->base.id != VA_INVALID_SURFACE);
8537 avc_state->list_ref_idx[1][i] = j;
8538
8539 break;
8540 }
8541 }
8542 }
8543
8544 return VA_STATUS_SUCCESS;
8545 }
8546
8547 static VAStatus
8548 gen9_avc_vme_gpe_kernel_init(VADriverContextP ctx,
8549 struct encode_state *encode_state,
8550 struct intel_encoder_context *encoder_context)
8551 {
8552 return VA_STATUS_SUCCESS;
8553 }
8554
8555 static VAStatus
8556 gen9_avc_vme_gpe_kernel_final(VADriverContextP ctx,
8557 struct encode_state *encode_state,
8558 struct intel_encoder_context *encoder_context)
8559 {
8560
8561 struct encoder_vme_mfc_context * vme_context = (struct encoder_vme_mfc_context *)encoder_context->vme_context;
8562 struct generic_enc_codec_state * generic_state = (struct generic_enc_codec_state *)vme_context->generic_enc_state;
8563 struct avc_enc_state * avc_state = (struct avc_enc_state *)vme_context->private_enc_state;
8564
8565 /*set this flag when all kernel is finished*/
8566 if (generic_state->brc_enabled) {
8567 generic_state->brc_inited = 1;
8568 generic_state->brc_need_reset = 0;
8569 avc_state->mbenc_curbe_set_in_brc_update = 0;
8570 }
8571 return VA_STATUS_SUCCESS;
8572 }
8573
8574 static VAStatus
8575 gen9_avc_vme_gpe_kernel_run(VADriverContextP ctx,
8576 struct encode_state *encode_state,
8577 struct intel_encoder_context *encoder_context)
8578 {
8579 struct encoder_vme_mfc_context * vme_context = (struct encoder_vme_mfc_context *)encoder_context->vme_context;
8580 struct generic_enc_codec_state * generic_state = (struct generic_enc_codec_state *)vme_context->generic_enc_state;
8581 struct avc_enc_state * avc_state = (struct avc_enc_state *)vme_context->private_enc_state;
8582 int fei_enabled = encoder_context->fei_enabled;
8583
8584 VAEncPictureParameterBufferH264 *pic_param = avc_state->pic_param;
8585 VAEncSliceParameterBufferH264 *slice_param = avc_state->slice_param[0];
8586 int sfd_in_use = 0;
8587
8588 /* BRC init/reset needs to be called before HME since it will reset the Brc Distortion surface*/
8589 if (!fei_enabled && generic_state->brc_enabled && (!generic_state->brc_inited || generic_state->brc_need_reset)) {
8590 gen9_avc_kernel_brc_init_reset(ctx, encode_state, encoder_context);
8591 }
8592
8593 /*down scaling*/
8594 if (generic_state->hme_supported) {
8595 gen9_avc_kernel_scaling(ctx, encode_state, encoder_context, INTEL_ENC_HME_4x);
8596 if (generic_state->b16xme_supported) {
8597 gen9_avc_kernel_scaling(ctx, encode_state, encoder_context, INTEL_ENC_HME_16x);
8598 if (generic_state->b32xme_supported) {
8599 gen9_avc_kernel_scaling(ctx, encode_state, encoder_context, INTEL_ENC_HME_32x);
8600 }
8601 }
8602 }
8603
8604 /*me kernel*/
8605 if (generic_state->hme_enabled) {
8606 if (generic_state->b16xme_enabled) {
8607 if (generic_state->b32xme_enabled) {
8608 gen9_avc_kernel_me(ctx, encode_state, encoder_context, INTEL_ENC_HME_32x);
8609 }
8610 gen9_avc_kernel_me(ctx, encode_state, encoder_context, INTEL_ENC_HME_16x);
8611 }
8612 gen9_avc_kernel_me(ctx, encode_state, encoder_context, INTEL_ENC_HME_4x);
8613 }
8614
8615 /*call SFD kernel after HME in same command buffer*/
8616 sfd_in_use = avc_state->sfd_enable && generic_state->hme_enabled;
8617 sfd_in_use = sfd_in_use && !avc_state->sfd_mb_enable;
8618 if (sfd_in_use) {
8619 gen9_avc_kernel_sfd(ctx, encode_state, encoder_context);
8620 }
8621
8622 /* BRC and MbEnc are included in the same task phase*/
8623 if (generic_state->brc_enabled) {
8624 if (avc_state->mbenc_i_frame_dist_in_use) {
8625 gen9_avc_kernel_mbenc(ctx, encode_state, encoder_context, true);
8626 }
8627 gen9_avc_kernel_brc_frame_update(ctx, encode_state, encoder_context);
8628
8629 if (avc_state->brc_split_enable && generic_state->mb_brc_enabled) {
8630 gen9_avc_kernel_brc_mb_update(ctx, encode_state, encoder_context);
8631 }
8632 }
8633
8634 /*weight prediction,disable by now */
8635 avc_state->weighted_ref_l0_enable = 0;
8636 avc_state->weighted_ref_l1_enable = 0;
8637 if (avc_state->weighted_prediction_supported &&
8638 ((generic_state->frame_type == SLICE_TYPE_P && pic_param->pic_fields.bits.weighted_pred_flag) ||
8639 (generic_state->frame_type == SLICE_TYPE_B && pic_param->pic_fields.bits.weighted_bipred_idc == INTEL_AVC_WP_MODE_EXPLICIT))) {
8640 if (slice_param->luma_weight_l0_flag & 1) {
8641 gen9_avc_kernel_wp(ctx, encode_state, encoder_context, 0);
8642
8643 } else if (!(slice_param->chroma_weight_l0_flag & 1)) {
8644 pic_param->pic_fields.bits.weighted_pred_flag = 0;// it should be handled in app
8645 }
8646
8647 if (generic_state->frame_type == SLICE_TYPE_B && pic_param->pic_fields.bits.weighted_bipred_idc == INTEL_AVC_WP_MODE_EXPLICIT) {
8648 if (slice_param->luma_weight_l1_flag & 1) {
8649 gen9_avc_kernel_wp(ctx, encode_state, encoder_context, 1);
8650 } else if (!((slice_param->luma_weight_l0_flag & 1) ||
8651 (slice_param->chroma_weight_l0_flag & 1) ||
8652 (slice_param->chroma_weight_l1_flag & 1))) {
8653 pic_param->pic_fields.bits.weighted_bipred_idc = INTEL_AVC_WP_MODE_DEFAULT;// it should be handled in app
8654 }
8655 }
8656 }
8657
8658 /*mbenc kernel*/
8659 gen9_avc_kernel_mbenc(ctx, encode_state, encoder_context, false);
8660
8661 /*ignore the reset vertical line kernel*/
8662
8663 return VA_STATUS_SUCCESS;
8664 }
8665
8666 static VAStatus
8667 gen9_avc_vme_pipeline(VADriverContextP ctx,
8668 VAProfile profile,
8669 struct encode_state *encode_state,
8670 struct intel_encoder_context *encoder_context)
8671 {
8672 VAStatus va_status;
8673
8674 gen9_avc_update_parameters(ctx, profile, encode_state, encoder_context);
8675
8676 va_status = gen9_avc_encode_check_parameter(ctx, encode_state, encoder_context);
8677 if (va_status != VA_STATUS_SUCCESS)
8678 return va_status;
8679
8680 va_status = gen9_avc_allocate_resources(ctx, encode_state, encoder_context);
8681 if (va_status != VA_STATUS_SUCCESS)
8682 return va_status;
8683
8684 va_status = gen9_avc_vme_gpe_kernel_prepare(ctx, encode_state, encoder_context);
8685 if (va_status != VA_STATUS_SUCCESS)
8686 return va_status;
8687
8688 va_status = gen9_avc_vme_gpe_kernel_init(ctx, encode_state, encoder_context);
8689 if (va_status != VA_STATUS_SUCCESS)
8690 return va_status;
8691
8692 va_status = gen9_avc_vme_gpe_kernel_run(ctx, encode_state, encoder_context);
8693 if (va_status != VA_STATUS_SUCCESS)
8694 return va_status;
8695
8696 gen9_avc_vme_gpe_kernel_final(ctx, encode_state, encoder_context);
8697
8698 return VA_STATUS_SUCCESS;
8699 }
8700
8701 /* Update PreEnc specific parameters */
8702 static VAStatus
8703 gen9_avc_preenc_update_parameters(VADriverContextP ctx,
8704 VAProfile profile,
8705 struct encode_state *encode_state,
8706 struct intel_encoder_context *encoder_context)
8707 {
8708 struct i965_driver_data *i965 = i965_driver_data(ctx);
8709 struct encoder_vme_mfc_context * vme_context = (struct encoder_vme_mfc_context *)encoder_context->vme_context;
8710 struct generic_enc_codec_state * generic_state = (struct generic_enc_codec_state *)vme_context->generic_enc_state;
8711 struct i965_avc_encoder_context * avc_ctx = (struct i965_avc_encoder_context *)vme_context->private_enc_ctx;
8712 struct avc_enc_state * avc_state = (struct avc_enc_state *)vme_context->private_enc_state;
8713 VAStatsStatisticsParameterH264 *stat_param_h264 = NULL;
8714 VAStatsStatisticsParameter *stat_param = NULL;
8715 struct object_buffer *obj_buffer = NULL;
8716 struct object_buffer *obj_buffer_mv = NULL, *obj_buffer_stat = NULL;
8717 struct buffer_store *buffer_store = NULL;
8718 unsigned int size = 0, i = 0;
8719 unsigned int frame_mb_nums = 0;
8720
8721 if (!encoder_context->preenc_enabled ||
8722 !encode_state->stat_param_ext ||
8723 !encode_state->stat_param_ext->buffer)
8724 return VA_STATUS_ERROR_OPERATION_FAILED;
8725
8726 stat_param_h264 = avc_state->stat_param =
8727 (VAStatsStatisticsParameterH264 *)encode_state->stat_param_ext->buffer;
8728 stat_param = &stat_param_h264->stats_params;
8729
8730 /* Assume the frame type based on number of past/future ref frames */
8731 if (!stat_param->num_past_references && !stat_param->num_future_references)
8732 generic_state->frame_type = SLICE_TYPE_I;
8733 else if (stat_param->num_future_references > 0)
8734 generic_state->frame_type = SLICE_TYPE_B;
8735 else
8736 generic_state->frame_type = SLICE_TYPE_P;
8737
8738 generic_state->preset = INTEL_PRESET_RT_SPEED;
8739 generic_state->kernel_mode = gen9_avc_kernel_mode[generic_state->preset];
8740
8741 /* frame width and height */
8742 generic_state->frame_width_in_pixel = encoder_context->frame_width_in_pixel;
8743 generic_state->frame_height_in_pixel = encoder_context->frame_height_in_pixel;
8744 generic_state->frame_width_in_mbs = ALIGN(generic_state->frame_width_in_pixel, 16) / 16;
8745 generic_state->frame_height_in_mbs = ALIGN(generic_state->frame_height_in_pixel, 16) / 16;
8746
8747 /* 4x downscaled width and height */
8748 generic_state->frame_width_4x = ALIGN(generic_state->frame_width_in_pixel / 4, 16);
8749 generic_state->frame_height_4x = ALIGN(generic_state->frame_height_in_pixel / 4, 16);
8750 generic_state->downscaled_width_4x_in_mb = generic_state->frame_width_4x / 16 ;
8751 generic_state->downscaled_height_4x_in_mb = generic_state->frame_height_4x / 16;
8752
8753 /* reset hme types for preenc */
8754 if (generic_state->frame_type != SLICE_TYPE_I)
8755 generic_state->hme_enabled = 1;
8756
8757 /* ensure frame width is not too small */
8758 if (generic_state->frame_width_4x <= INTEL_VME_MIN_ALLOWED_WIDTH_HEIGHT) {
8759 generic_state->frame_width_4x = INTEL_VME_MIN_ALLOWED_WIDTH_HEIGHT;
8760 generic_state->downscaled_width_4x_in_mb =
8761 WIDTH_IN_MACROBLOCKS(INTEL_VME_MIN_ALLOWED_WIDTH_HEIGHT);
8762 }
8763
8764 /* ensure frame height is not too small*/
8765 if (generic_state->frame_height_4x <= INTEL_VME_MIN_ALLOWED_WIDTH_HEIGHT) {
8766 generic_state->frame_height_4x = INTEL_VME_MIN_ALLOWED_WIDTH_HEIGHT;
8767 generic_state->downscaled_height_4x_in_mb =
8768 WIDTH_IN_MACROBLOCKS(INTEL_VME_MIN_ALLOWED_WIDTH_HEIGHT);
8769 }
8770
8771 /********** Ensure buffer object parameters ********/
8772 frame_mb_nums = generic_state->frame_width_in_mbs * generic_state->frame_height_in_mbs;
8773
8774 /* mv predictor buffer */
8775 if (stat_param_h264->mv_predictor_ctrl) {
8776 if (stat_param->mv_predictor == VA_INVALID_ID)
8777 goto error;
8778 size = frame_mb_nums * FEI_AVC_MV_PREDICTOR_BUFFER_SIZE;
8779 obj_buffer = BUFFER(stat_param->mv_predictor);
8780 if (!obj_buffer)
8781 goto error;
8782 buffer_store = obj_buffer->buffer_store;
8783 if (buffer_store->bo->size < size)
8784 goto error;
8785 if (avc_ctx->preproc_mv_predictor_buffer.bo != NULL)
8786 i965_free_gpe_resource(&avc_ctx->preproc_mv_predictor_buffer);
8787 i965_dri_object_to_buffer_gpe_resource(
8788 &avc_ctx->preproc_mv_predictor_buffer,
8789 buffer_store->bo);
8790 }
8791
8792 /* MB qp buffer */
8793 if (stat_param_h264->mb_qp) {
8794 if (stat_param->qp == VA_INVALID_ID)
8795 goto error;
8796 size = frame_mb_nums * FEI_AVC_QP_BUFFER_SIZE;
8797 obj_buffer = BUFFER(stat_param->qp);
8798 buffer_store = obj_buffer->buffer_store;
8799 if (buffer_store->bo->size < size)
8800 goto error;
8801 if (avc_ctx->preproc_mb_qp_buffer.bo != NULL)
8802 i965_free_gpe_resource(&avc_ctx->preproc_mb_qp_buffer);
8803 i965_dri_object_to_buffer_gpe_resource(
8804 &avc_ctx->preproc_mb_qp_buffer,
8805 buffer_store->bo);
8806 }
8807
8808 /* locate mv and stat buffer */
8809 if (!stat_param_h264->disable_mv_output ||
8810 !stat_param_h264->disable_statistics_output) {
8811
8812 if (!stat_param->outputs)
8813 goto error;
8814
8815 for (i = 0; i < 2 ; i++) {
8816 if (stat_param->outputs[i] != VA_INVALID_ID) {
8817 obj_buffer = BUFFER(stat_param->outputs[i]);
8818 switch (obj_buffer->type) {
8819 case VAStatsMVBufferType:
8820 obj_buffer_mv = obj_buffer;
8821 break;
8822 case VAStatsStatisticsBufferType:
8823 obj_buffer_stat = obj_buffer;
8824 break;
8825 default:
8826 assert(0);
8827 }
8828 }
8829 if (!(!stat_param_h264->disable_mv_output &&
8830 !stat_param_h264->disable_statistics_output))
8831 break;
8832 }
8833 }
8834 /* mv data output buffer */
8835 if (!stat_param_h264->disable_mv_output && obj_buffer_mv) {
8836 size = frame_mb_nums * FEI_AVC_MV_DATA_BUFFER_SIZE;
8837 buffer_store = obj_buffer_mv->buffer_store;
8838 if (buffer_store->bo->size < size)
8839 goto error;
8840 if (avc_ctx->preproc_mv_data_out_buffer.bo != NULL)
8841 i965_free_gpe_resource(&avc_ctx->preproc_mv_data_out_buffer);
8842 i965_dri_object_to_buffer_gpe_resource(
8843 &avc_ctx->preproc_mv_data_out_buffer,
8844 buffer_store->bo);
8845 }
8846 /* statistics output buffer */
8847 if (!stat_param_h264->disable_statistics_output && obj_buffer_stat) {
8848 size = frame_mb_nums * PREENC_AVC_STATISTICS_BUFFER_SIZE;
8849 buffer_store = obj_buffer_stat->buffer_store;
8850 if (buffer_store->bo->size < size)
8851 goto error;
8852 if (avc_ctx->preproc_stat_data_out_buffer.bo != NULL)
8853 i965_free_gpe_resource(&avc_ctx->preproc_stat_data_out_buffer);
8854 i965_dri_object_to_buffer_gpe_resource(
8855 &avc_ctx->preproc_stat_data_out_buffer,
8856 buffer_store->bo);
8857 }
8858
8859 /* past ref stat out buffer */
8860 if (stat_param->num_past_references && stat_param->past_ref_stat_buf &&
8861 stat_param->past_ref_stat_buf[0] != VA_INVALID_ID) {
8862 size = frame_mb_nums * PREENC_AVC_STATISTICS_BUFFER_SIZE;
8863 obj_buffer = BUFFER(stat_param->past_ref_stat_buf[0]);
8864 buffer_store = obj_buffer->buffer_store;
8865 if (buffer_store->bo->size < size)
8866 goto error;
8867 if (avc_ctx->preenc_past_ref_stat_data_out_buffer.bo != NULL)
8868 i965_free_gpe_resource(&avc_ctx->preenc_past_ref_stat_data_out_buffer);
8869 i965_dri_object_to_buffer_gpe_resource(
8870 &avc_ctx->preenc_past_ref_stat_data_out_buffer,
8871 buffer_store->bo);
8872 }
8873 /* future ref stat out buffer */
8874 if (stat_param->num_past_references && stat_param->future_ref_stat_buf &&
8875 stat_param->future_ref_stat_buf[0] != VA_INVALID_ID) {
8876 size = frame_mb_nums * PREENC_AVC_STATISTICS_BUFFER_SIZE;
8877 obj_buffer = BUFFER(stat_param->future_ref_stat_buf[0]);
8878 buffer_store = obj_buffer->buffer_store;
8879 if (buffer_store->bo->size < size)
8880 goto error;
8881 if (avc_ctx->preenc_future_ref_stat_data_out_buffer.bo != NULL)
8882 i965_free_gpe_resource(&avc_ctx->preenc_future_ref_stat_data_out_buffer);
8883 i965_dri_object_to_buffer_gpe_resource(
8884 &avc_ctx->preenc_future_ref_stat_data_out_buffer,
8885 buffer_store->bo);
8886 }
8887 return VA_STATUS_SUCCESS;
8888
8889 error:
8890 return VA_STATUS_ERROR_INVALID_BUFFER;
8891 }
8892
8893 /* allocate internal resouces required for PreEenc */
8894 static VAStatus
8895 gen9_avc_preenc_allocate_internal_resources(VADriverContextP ctx,
8896 struct encode_state *encode_state,
8897 struct intel_encoder_context *encoder_context)
8898 {
8899 struct i965_driver_data *i965 = i965_driver_data(ctx);
8900 struct encoder_vme_mfc_context * vme_context = (struct encoder_vme_mfc_context *)encoder_context->vme_context;
8901 struct i965_avc_encoder_context * avc_ctx = (struct i965_avc_encoder_context *)vme_context->private_enc_ctx;
8902 struct generic_enc_codec_state * generic_state = (struct generic_enc_codec_state *)vme_context->generic_enc_state;
8903 unsigned int width = 0;
8904 unsigned int height = 0;
8905 unsigned int size = 0;
8906 int allocate_flag = 1;
8907
8908 /* 4x MEMV data buffer */
8909 width = ALIGN(generic_state->downscaled_width_4x_in_mb * 32, 64);
8910 height = generic_state->downscaled_height_4x_in_mb * 4 * 2 * 10;
8911 i965_free_gpe_resource(&avc_ctx->s4x_memv_data_buffer);
8912 allocate_flag = i965_gpe_allocate_2d_resource(i965->intel.bufmgr,
8913 &avc_ctx->s4x_memv_data_buffer,
8914 width, height,
8915 width,
8916 "4x MEMV data buffer");
8917 if (!allocate_flag)
8918 goto failed_allocation;
8919 i965_zero_gpe_resource(&avc_ctx->s4x_memv_data_buffer);
8920
8921 /* Output DISTORTION surface from 4x ME */
8922 width = generic_state->downscaled_width_4x_in_mb * 8;
8923 height = generic_state->downscaled_height_4x_in_mb * 4 * 10;
8924 i965_free_gpe_resource(&avc_ctx->s4x_memv_distortion_buffer);
8925 allocate_flag = i965_gpe_allocate_2d_resource(i965->intel.bufmgr,
8926 &avc_ctx->s4x_memv_distortion_buffer,
8927 width, height,
8928 ALIGN(width, 64),
8929 "4x MEMV distortion buffer");
8930 if (!allocate_flag)
8931 goto failed_allocation;
8932 i965_zero_gpe_resource(&avc_ctx->s4x_memv_distortion_buffer);
8933
8934 /* output BRC DISTORTION surface from 4x ME */
8935 width = (generic_state->downscaled_width_4x_in_mb + 7) / 8 * 64;
8936 height = (generic_state->downscaled_height_4x_in_mb + 1) / 2 * 8;
8937 i965_free_gpe_resource(&avc_ctx->res_brc_dist_data_surface);
8938 allocate_flag = i965_gpe_allocate_2d_resource(i965->intel.bufmgr,
8939 &avc_ctx->res_brc_dist_data_surface,
8940 width, height,
8941 width,
8942 "brc dist data buffer");
8943 if (!allocate_flag)
8944 goto failed_allocation;
8945 i965_zero_gpe_resource(&avc_ctx->res_brc_dist_data_surface);
8946
8947
8948 /* FTQ Lut buffer,whichs is the mbbrc_const_data_buffer */
8949 i965_free_gpe_resource(&avc_ctx->res_mbbrc_const_data_buffer);
8950 size = 16 * AVC_QP_MAX * 4;
8951 allocate_flag = i965_allocate_gpe_resource(i965->intel.bufmgr,
8952 &avc_ctx->res_mbbrc_const_data_buffer,
8953 ALIGN(size, 0x1000),
8954 "mbbrc const data buffer");
8955 if (!allocate_flag)
8956 goto failed_allocation;
8957 i965_zero_gpe_resource(&avc_ctx->res_mbbrc_const_data_buffer);
8958
8959 /* 4x downscaled surface */
8960 if (!avc_ctx->preenc_scaled_4x_surface_obj) {
8961 i965_CreateSurfaces(ctx,
8962 generic_state->frame_width_4x,
8963 generic_state->frame_height_4x,
8964 VA_RT_FORMAT_YUV420,
8965 1,
8966 &avc_ctx->preenc_scaled_4x_surface_id);
8967 avc_ctx->preenc_scaled_4x_surface_obj = SURFACE(avc_ctx->preenc_scaled_4x_surface_id);
8968 if (!avc_ctx->preenc_scaled_4x_surface_obj)
8969 goto failed_allocation;
8970 i965_check_alloc_surface_bo(ctx, avc_ctx->preenc_scaled_4x_surface_obj, 1,
8971 VA_FOURCC('N', 'V', '1', '2'), SUBSAMPLE_YUV420);
8972 }
8973
8974 /* 4x downscaled past ref surface */
8975 if (!avc_ctx->preenc_past_ref_scaled_4x_surface_obj) {
8976 i965_CreateSurfaces(ctx,
8977 generic_state->frame_width_4x,
8978 generic_state->frame_height_4x,
8979 VA_RT_FORMAT_YUV420,
8980 1,
8981 &avc_ctx->preenc_past_ref_scaled_4x_surface_id);
8982 avc_ctx->preenc_past_ref_scaled_4x_surface_obj =
8983 SURFACE(avc_ctx->preenc_past_ref_scaled_4x_surface_id);
8984 if (!avc_ctx->preenc_past_ref_scaled_4x_surface_obj)
8985 goto failed_allocation;
8986 i965_check_alloc_surface_bo(ctx, avc_ctx->preenc_past_ref_scaled_4x_surface_obj, 1,
8987 VA_FOURCC('N', 'V', '1', '2'), SUBSAMPLE_YUV420);
8988 }
8989
8990 /* 4x downscaled future ref surface */
8991 if (!avc_ctx->preenc_future_ref_scaled_4x_surface_obj) {
8992 i965_CreateSurfaces(ctx,
8993 generic_state->frame_width_4x,
8994 generic_state->frame_height_4x,
8995 VA_RT_FORMAT_YUV420,
8996 1,
8997 &avc_ctx->preenc_future_ref_scaled_4x_surface_id);
8998 avc_ctx->preenc_future_ref_scaled_4x_surface_obj =
8999 SURFACE(avc_ctx->preenc_future_ref_scaled_4x_surface_id);
9000 if (!avc_ctx->preenc_future_ref_scaled_4x_surface_obj)
9001 goto failed_allocation;
9002 i965_check_alloc_surface_bo(ctx, avc_ctx->preenc_future_ref_scaled_4x_surface_obj, 1,
9003 VA_FOURCC('N', 'V', '1', '2'), SUBSAMPLE_YUV420);
9004 }
9005
9006 /* FeiPreEncFixme: dummy coded buffer. This is a tweak which helps to use
9007 * the generic AVC Encdoe codepath which allocate status buffer as extension
9008 * to CodedBuffer */
9009 if (!avc_ctx->status_buffer.bo) {
9010 size =
9011 generic_state->frame_width_in_pixel * generic_state->frame_height_in_pixel * 12;
9012 size += I965_CODEDBUFFER_HEADER_SIZE;
9013 size += 0x1000;
9014 avc_ctx->status_buffer.bo = dri_bo_alloc(i965->intel.bufmgr,
9015 "Dummy Coded Buffer",
9016 size, 64);
9017 }
9018
9019 return VA_STATUS_SUCCESS;
9020
9021 failed_allocation:
9022 return VA_STATUS_ERROR_ALLOCATION_FAILED;
9023 }
9024
9025
9026 static VAStatus
9027 gen9_avc_preenc_gpe_kernel_run(VADriverContextP ctx,
9028 struct encode_state *encode_state,
9029 struct intel_encoder_context *encoder_context)
9030 {
9031 struct encoder_vme_mfc_context * vme_context = (struct encoder_vme_mfc_context *)encoder_context->vme_context;
9032 struct generic_enc_codec_state * generic_state = (struct generic_enc_codec_state *)vme_context->generic_enc_state;
9033 struct avc_enc_state * avc_state = (struct avc_enc_state *)vme_context->private_enc_state;
9034 VAStatsStatisticsParameterH264 *stat_param_h264 = avc_state->stat_param;;
9035 VAStatsStatisticsParameter *stat_param = &stat_param_h264->stats_params;
9036
9037 /* FeiPreEncFixme: Optimize the scaling. Keep a cache of already scaled surfaces
9038 * to avoid repeated scaling of same surfaces */
9039
9040 /* down scaling */
9041 gen9_avc_preenc_kernel_scaling(ctx, encode_state, encoder_context,
9042 INTEL_ENC_HME_4x, SCALE_CUR_PIC);
9043 if (stat_param->num_past_references > 0) {
9044 gen9_avc_preenc_kernel_scaling(ctx, encode_state, encoder_context,
9045 INTEL_ENC_HME_4x, SCALE_PAST_REF_PIC);
9046 }
9047 if (stat_param->num_future_references > 0) {
9048 gen9_avc_preenc_kernel_scaling(ctx, encode_state, encoder_context,
9049 INTEL_ENC_HME_4x, SCALE_FUTURE_REF_PIC);
9050 }
9051
9052 /* me kernel */
9053 if (generic_state->hme_enabled) {
9054 gen9_avc_kernel_me(ctx, encode_state, encoder_context, INTEL_ENC_HME_4x);
9055 }
9056
9057 /* preproc kernel */
9058 if (!stat_param_h264->disable_mv_output || !stat_param_h264->disable_statistics_output) {
9059 gen9_avc_preenc_kernel_preproc(ctx, encode_state, encoder_context);
9060 }
9061
9062 return VA_STATUS_SUCCESS;
9063 }
9064
9065 static VAStatus
9066 gen9_avc_preenc_pipeline(VADriverContextP ctx,
9067 VAProfile profile,
9068 struct encode_state *encode_state,
9069 struct intel_encoder_context *encoder_context)
9070 {
9071 VAStatus va_status;
9072
9073 va_status = gen9_avc_preenc_update_parameters(ctx, profile, encode_state, encoder_context);
9074 if (va_status != VA_STATUS_SUCCESS)
9075 return va_status;
9076
9077 va_status = gen9_avc_preenc_allocate_internal_resources(ctx, encode_state, encoder_context);
9078 if (va_status != VA_STATUS_SUCCESS)
9079 return va_status;
9080
9081 va_status = gen9_avc_preenc_gpe_kernel_run(ctx, encode_state, encoder_context);
9082 if (va_status != VA_STATUS_SUCCESS)
9083 return va_status;
9084
9085 return VA_STATUS_SUCCESS;
9086 }
9087
9088 static void
9089 gen9_avc_vme_context_destroy(void * context)
9090 {
9091 struct encoder_vme_mfc_context *vme_context = (struct encoder_vme_mfc_context *)context;
9092 struct generic_encoder_context *generic_ctx;
9093 struct i965_avc_encoder_context *avc_ctx;
9094 struct generic_enc_codec_state *generic_state;
9095 struct avc_enc_state *avc_state;
9096
9097 if (!vme_context)
9098 return;
9099
9100 generic_ctx = (struct generic_encoder_context *)vme_context->generic_enc_ctx;
9101 avc_ctx = (struct i965_avc_encoder_context *)vme_context->private_enc_ctx;
9102 generic_state = (struct generic_enc_codec_state *)vme_context->generic_enc_state;
9103 avc_state = (struct avc_enc_state *)vme_context->private_enc_state;
9104
9105 gen9_avc_kernel_destroy(vme_context);
9106
9107 free(generic_ctx);
9108 free(avc_ctx);
9109 free(generic_state);
9110 free(avc_state);
9111 free(vme_context);
9112 return;
9113
9114 }
9115
9116 static void
9117 gen8_avc_kernel_init(VADriverContextP ctx,
9118 struct intel_encoder_context *encoder_context)
9119 {
9120 struct encoder_vme_mfc_context * vme_context = (struct encoder_vme_mfc_context *)encoder_context->vme_context;
9121 struct i965_avc_encoder_context * avc_ctx = (struct i965_avc_encoder_context *)vme_context->private_enc_ctx;
9122 struct generic_encoder_context * generic_ctx = (struct generic_encoder_context *)vme_context->generic_enc_ctx;
9123 int fei_enabled = encoder_context->fei_enabled;
9124
9125 generic_ctx->get_kernel_header_and_size = fei_enabled ?
9126 intel_avc_fei_get_kernel_header_and_size :
9127 gen8_avc_get_kernel_header_and_size ;
9128 gen9_avc_kernel_init_scaling(ctx, generic_ctx, &avc_ctx->context_scaling, false);
9129 gen9_avc_kernel_init_brc(ctx, generic_ctx, &avc_ctx->context_brc);
9130 gen9_avc_kernel_init_me(ctx, generic_ctx, &avc_ctx->context_me, false);
9131 gen9_avc_kernel_init_mbenc(ctx, generic_ctx, &avc_ctx->context_mbenc, fei_enabled);
9132 gen9_avc_kernel_init_sfd(ctx, generic_ctx, &avc_ctx->context_sfd);
9133
9134 //function pointer
9135 generic_ctx->pfn_set_curbe_scaling2x = gen9_avc_set_curbe_scaling2x;
9136 generic_ctx->pfn_set_curbe_scaling4x = gen8_avc_set_curbe_scaling4x;
9137 generic_ctx->pfn_set_curbe_me = gen8_avc_set_curbe_me;
9138 generic_ctx->pfn_set_curbe_mbenc = gen8_avc_set_curbe_mbenc;
9139 generic_ctx->pfn_set_curbe_brc_init_reset = gen9_avc_set_curbe_brc_init_reset;
9140 generic_ctx->pfn_set_curbe_brc_frame_update = gen8_avc_set_curbe_brc_frame_update;
9141 generic_ctx->pfn_set_curbe_sfd = gen9_avc_set_curbe_sfd;
9142
9143 generic_ctx->pfn_send_scaling_surface = gen9_avc_send_surface_scaling;
9144 generic_ctx->pfn_send_me_surface = gen9_avc_send_surface_me;
9145 generic_ctx->pfn_send_mbenc_surface = gen9_avc_send_surface_mbenc;
9146 generic_ctx->pfn_send_brc_init_reset_surface = gen9_avc_send_surface_brc_init_reset;
9147 generic_ctx->pfn_send_brc_frame_update_surface = gen9_avc_send_surface_brc_frame_update;
9148 generic_ctx->pfn_send_sfd_surface = gen9_avc_send_surface_sfd;
9149 }
9150 static void
9151 gen9_avc_kernel_init(VADriverContextP ctx,
9152 struct intel_encoder_context *encoder_context)
9153 {
9154 struct i965_driver_data *i965 = i965_driver_data(ctx);
9155 struct encoder_vme_mfc_context * vme_context = (struct encoder_vme_mfc_context *)encoder_context->vme_context;
9156 struct i965_avc_encoder_context * avc_ctx = (struct i965_avc_encoder_context *)vme_context->private_enc_ctx;
9157 struct generic_encoder_context * generic_ctx = (struct generic_encoder_context *)vme_context->generic_enc_ctx;
9158 int fei_enabled = encoder_context->fei_enabled;
9159 int preenc_enabled = encoder_context->preenc_enabled;
9160
9161 generic_ctx->get_kernel_header_and_size = (fei_enabled || preenc_enabled) ?
9162 intel_avc_fei_get_kernel_header_and_size :
9163 intel_avc_get_kernel_header_and_size ;
9164
9165 if (!fei_enabled && !preenc_enabled) {
9166 /* generic AVC Encoder */
9167 gen9_avc_kernel_init_scaling(ctx, generic_ctx, &avc_ctx->context_scaling, false);
9168 gen9_avc_kernel_init_brc(ctx, generic_ctx, &avc_ctx->context_brc);
9169 gen9_avc_kernel_init_me(ctx, generic_ctx, &avc_ctx->context_me, false);
9170 gen9_avc_kernel_init_mbenc(ctx, generic_ctx, &avc_ctx->context_mbenc,
9171 encoder_context->fei_enabled);
9172 gen9_avc_kernel_init_wp(ctx, generic_ctx, &avc_ctx->context_wp);
9173 gen9_avc_kernel_init_sfd(ctx, generic_ctx, &avc_ctx->context_sfd);
9174
9175 //function pointer
9176 generic_ctx->pfn_set_curbe_scaling2x = gen9_avc_set_curbe_scaling2x;
9177 generic_ctx->pfn_set_curbe_scaling4x = gen9_avc_set_curbe_scaling4x;
9178 generic_ctx->pfn_set_curbe_me = gen9_avc_set_curbe_me;
9179 generic_ctx->pfn_set_curbe_mbenc = gen9_avc_set_curbe_mbenc;
9180 generic_ctx->pfn_set_curbe_brc_init_reset = gen9_avc_set_curbe_brc_init_reset;
9181 generic_ctx->pfn_set_curbe_brc_frame_update = gen9_avc_set_curbe_brc_frame_update;
9182 generic_ctx->pfn_set_curbe_brc_mb_update = gen9_avc_set_curbe_brc_mb_update;
9183 generic_ctx->pfn_set_curbe_sfd = gen9_avc_set_curbe_sfd;
9184 generic_ctx->pfn_set_curbe_wp = gen9_avc_set_curbe_wp;
9185
9186 generic_ctx->pfn_send_scaling_surface = gen9_avc_send_surface_scaling;
9187 generic_ctx->pfn_send_me_surface = gen9_avc_send_surface_me;
9188 generic_ctx->pfn_send_mbenc_surface = gen9_avc_send_surface_mbenc;
9189 generic_ctx->pfn_send_brc_init_reset_surface = gen9_avc_send_surface_brc_init_reset;
9190 generic_ctx->pfn_send_brc_frame_update_surface = gen9_avc_send_surface_brc_frame_update;
9191 generic_ctx->pfn_send_brc_mb_update_surface = gen9_avc_send_surface_brc_mb_update;
9192 generic_ctx->pfn_send_sfd_surface = gen9_avc_send_surface_sfd;
9193 generic_ctx->pfn_send_wp_surface = gen9_avc_send_surface_wp;
9194
9195 if (IS_SKL(i965->intel.device_info) ||
9196 IS_BXT(i965->intel.device_info))
9197 generic_ctx->pfn_set_curbe_scaling4x = gen9_avc_set_curbe_scaling4x;
9198 else if (IS_KBL(i965->intel.device_info) ||
9199 IS_GEN10(i965->intel.device_info) ||
9200 IS_GLK(i965->intel.device_info))
9201 generic_ctx->pfn_set_curbe_scaling4x = gen95_avc_set_curbe_scaling4x;
9202
9203 } else if (fei_enabled) {
9204 /* FEI AVC Encoding */
9205 gen9_avc_kernel_init_mbenc(ctx, generic_ctx, &avc_ctx->context_mbenc,
9206 encoder_context->fei_enabled);
9207 generic_ctx->pfn_set_curbe_mbenc = gen9_avc_fei_set_curbe_mbenc;
9208 generic_ctx->pfn_send_mbenc_surface = gen9_avc_fei_send_surface_mbenc;
9209
9210 } else {
9211 /* PreEnc for AVC */
9212 gen9_avc_kernel_init_scaling(ctx, generic_ctx, &avc_ctx->context_scaling,
9213 encoder_context->preenc_enabled);
9214 gen9_avc_kernel_init_me(ctx, generic_ctx, &avc_ctx->context_me,
9215 encoder_context->preenc_enabled);
9216 gen9_avc_kernel_init_preproc(ctx, generic_ctx, &avc_ctx->context_preproc);
9217
9218 /* preenc 4x scaling uses the gen95 kernel */
9219 generic_ctx->pfn_set_curbe_scaling4x = gen95_avc_set_curbe_scaling4x;
9220 generic_ctx->pfn_set_curbe_me = gen9_avc_preenc_set_curbe_me;
9221 generic_ctx->pfn_set_curbe_preproc = gen9_avc_preenc_set_curbe_preproc;
9222
9223 generic_ctx->pfn_send_scaling_surface = gen9_avc_send_surface_scaling;
9224 generic_ctx->pfn_send_me_surface = gen9_avc_preenc_send_surface_me;
9225 generic_ctx->pfn_send_preproc_surface = gen9_avc_preenc_send_surface_preproc;
9226 }
9227 }
9228
9229 /*
9230 PAK pipeline related function
9231 */
9232 extern int
9233 intel_avc_enc_slice_type_fixup(int slice_type);
9234
9235 /* Allocate resources needed for PAK only mode (get invoked only in FEI encode) */
9236 static VAStatus
9237 gen9_avc_allocate_pak_resources(VADriverContextP ctx,
9238 struct encode_state *encode_state,
9239 struct intel_encoder_context *encoder_context)
9240 {
9241 struct i965_driver_data *i965 = i965_driver_data(ctx);
9242 struct encoder_vme_mfc_context * vme_context = (struct encoder_vme_mfc_context *)encoder_context->vme_context;
9243 struct i965_avc_encoder_context * avc_ctx = (struct i965_avc_encoder_context *)vme_context->private_enc_ctx;
9244 struct generic_enc_codec_state * generic_state = (struct generic_enc_codec_state *)vme_context->generic_enc_state;
9245 unsigned int size = 0;
9246 int allocate_flag = 1;
9247
9248 /*second level batch buffer for image state write when cqp etc*/
9249 i965_free_gpe_resource(&avc_ctx->res_image_state_batch_buffer_2nd_level);
9250 size = INTEL_AVC_IMAGE_STATE_CMD_SIZE ;
9251 allocate_flag = i965_allocate_gpe_resource(i965->intel.bufmgr,
9252 &avc_ctx->res_image_state_batch_buffer_2nd_level,
9253 ALIGN(size, 0x1000),
9254 "second levle batch (image state write) buffer");
9255 if (!allocate_flag)
9256 goto failed_allocation;
9257
9258 if (!generic_state->brc_allocated) {
9259 i965_free_gpe_resource(&avc_ctx->res_brc_pre_pak_statistics_output_buffer);
9260 size = 64;//44
9261 allocate_flag = i965_allocate_gpe_resource(i965->intel.bufmgr,
9262 &avc_ctx->res_brc_pre_pak_statistics_output_buffer,
9263 ALIGN(size, 0x1000),
9264 "brc pak statistic buffer");
9265 if (!allocate_flag)
9266 goto failed_allocation;
9267 }
9268
9269 return VA_STATUS_SUCCESS;
9270
9271 failed_allocation:
9272 return VA_STATUS_ERROR_ALLOCATION_FAILED;
9273 }
9274
9275 static void
9276 gen9_mfc_avc_pipe_mode_select(VADriverContextP ctx,
9277 struct encode_state *encode_state,
9278 struct intel_encoder_context *encoder_context)
9279 {
9280 struct encoder_vme_mfc_context * pak_context = (struct encoder_vme_mfc_context *)encoder_context->vme_context;
9281 struct i965_avc_encoder_context * avc_ctx = (struct i965_avc_encoder_context *)pak_context->private_enc_ctx;
9282 struct generic_enc_codec_state * generic_state = (struct generic_enc_codec_state *)pak_context->generic_enc_state;
9283 struct intel_batchbuffer *batch = encoder_context->base.batch;
9284
9285 BEGIN_BCS_BATCH(batch, 5);
9286
9287 OUT_BCS_BATCH(batch, MFX_PIPE_MODE_SELECT | (5 - 2));
9288 OUT_BCS_BATCH(batch,
9289 (0 << 29) |
9290 (MFX_LONG_MODE << 17) | /* Must be long format for encoder */
9291 (MFD_MODE_VLD << 15) |
9292 (0 << 13) | /* Non-VDEnc mode is 0*/
9293 ((generic_state->curr_pak_pass != (generic_state->num_pak_passes - 1)) << 10) | /* Stream-Out Enable */
9294 ((!!avc_ctx->res_post_deblocking_output.bo) << 9) | /* Post Deblocking Output */
9295 ((!!avc_ctx->res_pre_deblocking_output.bo) << 8) | /* Pre Deblocking Output */
9296 (0 << 7) | /* Scaled surface enable */
9297 (0 << 6) | /* Frame statistics stream out enable */
9298 (0 << 5) | /* not in stitch mode */
9299 (1 << 4) | /* encoding mode */
9300 (MFX_FORMAT_AVC << 0));
9301 OUT_BCS_BATCH(batch,
9302 (0 << 7) | /* expand NOA bus flag */
9303 (0 << 6) | /* disable slice-level clock gating */
9304 (0 << 5) | /* disable clock gating for NOA */
9305 (0 << 4) | /* terminate if AVC motion and POC table error occurs */
9306 (0 << 3) | /* terminate if AVC mbdata error occurs */
9307 (0 << 2) | /* terminate if AVC CABAC/CAVLC decode error occurs */
9308 (0 << 1) |
9309 (0 << 0));
9310 OUT_BCS_BATCH(batch, 0);
9311 OUT_BCS_BATCH(batch, 0);
9312
9313 ADVANCE_BCS_BATCH(batch);
9314 }
9315
9316 static void
9317 gen9_mfc_avc_surface_state(VADriverContextP ctx,
9318 struct intel_encoder_context *encoder_context,
9319 struct i965_gpe_resource *gpe_resource,
9320 int id)
9321 {
9322 struct intel_batchbuffer *batch = encoder_context->base.batch;
9323
9324 BEGIN_BCS_BATCH(batch, 6);
9325
9326 OUT_BCS_BATCH(batch, MFX_SURFACE_STATE | (6 - 2));
9327 OUT_BCS_BATCH(batch, id);
9328 OUT_BCS_BATCH(batch,
9329 ((gpe_resource->height - 1) << 18) |
9330 ((gpe_resource->width - 1) << 4));
9331 OUT_BCS_BATCH(batch,
9332 (MFX_SURFACE_PLANAR_420_8 << 28) | /* 420 planar YUV surface */
9333 (1 << 27) | /* must be 1 for interleave U/V, hardware requirement */
9334 ((gpe_resource->pitch - 1) << 3) | /* pitch */
9335 (0 << 2) | /* must be 0 for interleave U/V */
9336 (1 << 1) | /* must be tiled */
9337 (I965_TILEWALK_YMAJOR << 0)); /* tile walk, TILEWALK_YMAJOR */
9338 OUT_BCS_BATCH(batch,
9339 (0 << 16) | /* must be 0 for interleave U/V */
9340 (gpe_resource->y_cb_offset)); /* y offset for U(cb) */
9341 OUT_BCS_BATCH(batch,
9342 (0 << 16) | /* must be 0 for interleave U/V */
9343 (gpe_resource->y_cb_offset)); /* y offset for U(cb) */
9344
9345 ADVANCE_BCS_BATCH(batch);
9346 }
9347
9348 static void
9349 gen9_mfc_avc_pipe_buf_addr_state(VADriverContextP ctx, struct intel_encoder_context *encoder_context)
9350 {
9351 struct i965_driver_data *i965 = i965_driver_data(ctx);
9352 struct encoder_vme_mfc_context * pak_context = (struct encoder_vme_mfc_context *)encoder_context->vme_context;
9353 struct generic_encoder_context * generic_ctx = (struct generic_encoder_context *)pak_context->generic_enc_ctx;
9354 struct i965_avc_encoder_context * avc_ctx = (struct i965_avc_encoder_context *)pak_context->private_enc_ctx;
9355 struct intel_batchbuffer *batch = encoder_context->base.batch;
9356 int i;
9357 unsigned int cmd_len = 65;
9358
9359 if (IS_GEN10(i965->intel.device_info))
9360 cmd_len = 68;
9361
9362 BEGIN_BCS_BATCH(batch, cmd_len);
9363
9364 OUT_BCS_BATCH(batch, MFX_PIPE_BUF_ADDR_STATE | (cmd_len - 2));
9365
9366 /* the DW1-3 is for pre_deblocking */
9367 OUT_BUFFER_3DW(batch, avc_ctx->res_pre_deblocking_output.bo, 1, 0, i965->intel.mocs_state);
9368
9369 /* the DW4-6 is for the post_deblocking */
9370 OUT_BUFFER_3DW(batch, avc_ctx->res_post_deblocking_output.bo, 1, 0, i965->intel.mocs_state);
9371
9372 /* the DW7-9 is for the uncompressed_picture */
9373 OUT_BUFFER_3DW(batch, generic_ctx->res_uncompressed_input_surface.bo, 0, 0, i965->intel.mocs_state);
9374
9375 /* the DW10-12 is for PAK information (write) */
9376 OUT_BUFFER_3DW(batch, avc_ctx->res_pak_mb_status_buffer.bo, 1, 0, i965->intel.mocs_state);//?
9377
9378 /* the DW13-15 is for the intra_row_store_scratch */
9379 OUT_BUFFER_3DW(batch, avc_ctx->res_intra_row_store_scratch_buffer.bo, 1, 0, i965->intel.mocs_state);
9380
9381 /* the DW16-18 is for the deblocking filter */
9382 OUT_BUFFER_3DW(batch, avc_ctx->res_deblocking_filter_row_store_scratch_buffer.bo, 1, 0, i965->intel.mocs_state);
9383
9384 /* the DW 19-50 is for Reference pictures*/
9385 for (i = 0; i < ARRAY_ELEMS(avc_ctx->list_reference_res); i++) {
9386 OUT_BUFFER_2DW(batch, avc_ctx->list_reference_res[i].bo, 0, 0);
9387 }
9388
9389 /* DW 51, reference picture attributes */
9390 OUT_BCS_BATCH(batch, i965->intel.mocs_state);
9391
9392 /* The DW 52-54 is for PAK information (read) */
9393 OUT_BUFFER_3DW(batch, avc_ctx->res_pak_mb_status_buffer.bo, 1, 0, i965->intel.mocs_state);
9394
9395 /* the DW 55-57 is the ILDB buffer */
9396 OUT_BUFFER_3DW(batch, NULL, 0, 0, 0);
9397
9398 /* the DW 58-60 is the second ILDB buffer */
9399 OUT_BUFFER_3DW(batch, NULL, 0, 0, 0);
9400
9401 /* DW 61, memory compress enable & mode */
9402 OUT_BCS_BATCH(batch, 0);
9403
9404 /* the DW 62-64 is the buffer */
9405 OUT_BUFFER_3DW(batch, NULL, 0, 0, 0);
9406
9407 /*65-67 for CNL */
9408 if (IS_GEN10(i965->intel.device_info)) {
9409 OUT_BCS_BATCH(batch, 0);
9410 OUT_BCS_BATCH(batch, 0);
9411 OUT_BCS_BATCH(batch, 0);
9412 }
9413
9414 ADVANCE_BCS_BATCH(batch);
9415 }
9416
9417 static void
9418 gen9_mfc_avc_ind_obj_base_addr_state(VADriverContextP ctx,
9419 struct encode_state *encode_state,
9420 struct intel_encoder_context *encoder_context)
9421 {
9422 struct i965_driver_data *i965 = i965_driver_data(ctx);
9423 struct encoder_vme_mfc_context * pak_context = (struct encoder_vme_mfc_context *)encoder_context->vme_context;
9424 struct generic_encoder_context * generic_ctx = (struct generic_encoder_context *)pak_context->generic_enc_ctx;
9425 struct generic_enc_codec_state * generic_state = (struct generic_enc_codec_state *)pak_context->generic_enc_state;
9426 struct intel_batchbuffer *batch = encoder_context->base.batch;
9427 struct object_surface *obj_surface;
9428 struct gen9_surface_avc *avc_priv_surface;
9429 unsigned int size = 0;
9430 unsigned int w_mb = generic_state->frame_width_in_mbs;
9431 unsigned int h_mb = generic_state->frame_height_in_mbs;
9432
9433 obj_surface = encode_state->reconstructed_object;
9434
9435 if (!obj_surface || !obj_surface->private_data)
9436 return;
9437 avc_priv_surface = obj_surface->private_data;
9438
9439 BEGIN_BCS_BATCH(batch, 26);
9440
9441 OUT_BCS_BATCH(batch, MFX_IND_OBJ_BASE_ADDR_STATE | (26 - 2));
9442 /* The DW1-5 is for the MFX indirect bistream offset */
9443 OUT_BUFFER_3DW(batch, NULL, 0, 0, 0);
9444 OUT_BUFFER_2DW(batch, NULL, 0, 0);
9445
9446 /* the DW6-10 is for MFX Indirect MV Object Base Address */
9447 size = w_mb * h_mb * 32 * 4;
9448 OUT_BUFFER_3DW(batch,
9449 avc_priv_surface->res_mv_data_surface.bo,
9450 1,
9451 0,
9452 i965->intel.mocs_state);
9453 OUT_BUFFER_2DW(batch,
9454 avc_priv_surface->res_mv_data_surface.bo,
9455 1,
9456 ALIGN(size, 0x1000));
9457
9458 /* The DW11-15 is for MFX IT-COFF. Not used on encoder */
9459 OUT_BUFFER_3DW(batch, NULL, 0, 0, 0);
9460 OUT_BUFFER_2DW(batch, NULL, 0, 0);
9461
9462 /* The DW16-20 is for MFX indirect DBLK. Not used on encoder */
9463 OUT_BUFFER_3DW(batch, NULL, 0, 0, 0);
9464 OUT_BUFFER_2DW(batch, NULL, 0, 0);
9465
9466 /* The DW21-25 is for MFC Indirect PAK-BSE Object Base Address for Encoder
9467 * Note: an offset is specified in MFX_AVC_SLICE_STATE
9468 */
9469 OUT_BUFFER_3DW(batch,
9470 generic_ctx->compressed_bitstream.res.bo,
9471 1,
9472 0,
9473 i965->intel.mocs_state);
9474 OUT_BUFFER_2DW(batch,
9475 generic_ctx->compressed_bitstream.res.bo,
9476 1,
9477 generic_ctx->compressed_bitstream.end_offset);
9478
9479 ADVANCE_BCS_BATCH(batch);
9480 }
9481
9482 static void
9483 gen9_mfc_avc_bsp_buf_base_addr_state(VADriverContextP ctx, struct intel_encoder_context *encoder_context)
9484 {
9485 struct i965_driver_data *i965 = i965_driver_data(ctx);
9486 struct encoder_vme_mfc_context * pak_context = (struct encoder_vme_mfc_context *)encoder_context->vme_context;
9487 struct i965_avc_encoder_context * avc_ctx = (struct i965_avc_encoder_context *)pak_context->private_enc_ctx;
9488 struct intel_batchbuffer *batch = encoder_context->base.batch;
9489
9490 BEGIN_BCS_BATCH(batch, 10);
9491
9492 OUT_BCS_BATCH(batch, MFX_BSP_BUF_BASE_ADDR_STATE | (10 - 2));
9493
9494 /* The DW1-3 is for bsd/mpc row store scratch buffer */
9495 OUT_BUFFER_3DW(batch, avc_ctx->res_bsd_mpc_row_store_scratch_buffer.bo, 1, 0, i965->intel.mocs_state);
9496
9497 /* The DW4-6 is for MPR Row Store Scratch Buffer Base Address, ignore for encoder */
9498 OUT_BUFFER_3DW(batch, NULL, 0, 0, 0);
9499
9500 /* The DW7-9 is for Bitplane Read Buffer Base Address, ignore for encoder */
9501 OUT_BUFFER_3DW(batch, NULL, 0, 0, 0);
9502
9503 ADVANCE_BCS_BATCH(batch);
9504 }
9505
9506 static void
9507 gen9_mfc_avc_directmode_state(VADriverContextP ctx,
9508 struct intel_encoder_context *encoder_context)
9509 {
9510 struct i965_driver_data *i965 = i965_driver_data(ctx);
9511 struct intel_batchbuffer *batch = encoder_context->base.batch;
9512 struct encoder_vme_mfc_context * pak_context = (struct encoder_vme_mfc_context *)encoder_context->vme_context;
9513 struct i965_avc_encoder_context * avc_ctx = (struct i965_avc_encoder_context *)pak_context->private_enc_ctx;
9514 struct avc_enc_state * avc_state = (struct avc_enc_state *)pak_context->private_enc_state;
9515
9516 int i;
9517
9518 BEGIN_BCS_BATCH(batch, 71);
9519
9520 OUT_BCS_BATCH(batch, MFX_AVC_DIRECTMODE_STATE | (71 - 2));
9521
9522 /* Reference frames and Current frames */
9523 /* the DW1-32 is for the direct MV for reference */
9524 for (i = 0; i < NUM_MFC_AVC_DMV_BUFFERS - 2; i += 2) {
9525 if (avc_ctx->res_direct_mv_buffersr[i].bo != NULL) {
9526 OUT_BCS_RELOC64(batch, avc_ctx->res_direct_mv_buffersr[i].bo,
9527 I915_GEM_DOMAIN_INSTRUCTION, 0,
9528 0);
9529 } else {
9530 OUT_BCS_BATCH(batch, 0);
9531 OUT_BCS_BATCH(batch, 0);
9532 }
9533 }
9534
9535 OUT_BCS_BATCH(batch, i965->intel.mocs_state);
9536
9537 /* the DW34-36 is the MV for the current frame */
9538 OUT_BCS_RELOC64(batch, avc_ctx->res_direct_mv_buffersr[NUM_MFC_AVC_DMV_BUFFERS - 2].bo,
9539 I915_GEM_DOMAIN_INSTRUCTION, I915_GEM_DOMAIN_INSTRUCTION,
9540 0);
9541
9542 OUT_BCS_BATCH(batch, i965->intel.mocs_state);
9543
9544 /* POL list */
9545 for (i = 0; i < 32; i++) {
9546 OUT_BCS_BATCH(batch, avc_state->top_field_poc[i]);
9547 }
9548 OUT_BCS_BATCH(batch, avc_state->top_field_poc[NUM_MFC_AVC_DMV_BUFFERS - 2]);
9549 OUT_BCS_BATCH(batch, avc_state->top_field_poc[NUM_MFC_AVC_DMV_BUFFERS - 1]);
9550
9551 ADVANCE_BCS_BATCH(batch);
9552 }
9553
9554 static void
9555 gen9_mfc_qm_state(VADriverContextP ctx,
9556 int qm_type,
9557 const unsigned int *qm,
9558 int qm_length,
9559 struct intel_encoder_context *encoder_context)
9560 {
9561 struct intel_batchbuffer *batch = encoder_context->base.batch;
9562 unsigned int qm_buffer[16];
9563
9564 assert(qm_length <= 16);
9565 assert(sizeof(*qm) == 4);
9566 memset(qm_buffer, 0, 16 * 4);
9567 memcpy(qm_buffer, qm, qm_length * 4);
9568
9569 BEGIN_BCS_BATCH(batch, 18);
9570 OUT_BCS_BATCH(batch, MFX_QM_STATE | (18 - 2));
9571 OUT_BCS_BATCH(batch, qm_type << 0);
9572 intel_batchbuffer_data(batch, qm_buffer, 16 * 4);
9573 ADVANCE_BCS_BATCH(batch);
9574 }
9575
9576 static void
9577 gen9_mfc_avc_qm_state(VADriverContextP ctx,
9578 struct encode_state *encode_state,
9579 struct intel_encoder_context *encoder_context)
9580 {
9581 struct encoder_vme_mfc_context * pak_context = (struct encoder_vme_mfc_context *)encoder_context->vme_context;
9582 struct avc_enc_state * avc_state = (struct avc_enc_state *)pak_context->private_enc_state;
9583 VAEncSequenceParameterBufferH264 *seq_param = avc_state->seq_param;
9584 VAEncPictureParameterBufferH264 *pic_param = avc_state->pic_param;
9585
9586
9587 const unsigned int *qm_4x4_intra;
9588 const unsigned int *qm_4x4_inter;
9589 const unsigned int *qm_8x8_intra;
9590 const unsigned int *qm_8x8_inter;
9591
9592 if (!seq_param->seq_fields.bits.seq_scaling_matrix_present_flag
9593 && !pic_param->pic_fields.bits.pic_scaling_matrix_present_flag) {
9594 qm_4x4_intra = qm_4x4_inter = qm_8x8_intra = qm_8x8_inter = qm_flat;
9595 } else {
9596 VAIQMatrixBufferH264 *qm;
9597 assert(encode_state->q_matrix && encode_state->q_matrix->buffer);
9598 qm = (VAIQMatrixBufferH264 *)encode_state->q_matrix->buffer;
9599 qm_4x4_intra = (unsigned int *)qm->ScalingList4x4[0];
9600 qm_4x4_inter = (unsigned int *)qm->ScalingList4x4[3];
9601 qm_8x8_intra = (unsigned int *)qm->ScalingList8x8[0];
9602 qm_8x8_inter = (unsigned int *)qm->ScalingList8x8[1];
9603 }
9604
9605 gen9_mfc_qm_state(ctx, MFX_QM_AVC_4X4_INTRA_MATRIX, qm_4x4_intra, 12, encoder_context);
9606 gen9_mfc_qm_state(ctx, MFX_QM_AVC_4X4_INTER_MATRIX, qm_4x4_inter, 12, encoder_context);
9607 gen9_mfc_qm_state(ctx, MFX_QM_AVC_8x8_INTRA_MATRIX, qm_8x8_intra, 16, encoder_context);
9608 gen9_mfc_qm_state(ctx, MFX_QM_AVC_8x8_INTER_MATRIX, qm_8x8_inter, 16, encoder_context);
9609 }
9610
9611 static void
9612 gen9_mfc_fqm_state(VADriverContextP ctx,
9613 int fqm_type,
9614 const unsigned int *fqm,
9615 int fqm_length,
9616 struct intel_encoder_context *encoder_context)
9617 {
9618 struct intel_batchbuffer *batch = encoder_context->base.batch;
9619 unsigned int fqm_buffer[32];
9620
9621 assert(fqm_length <= 32);
9622 assert(sizeof(*fqm) == 4);
9623 memset(fqm_buffer, 0, 32 * 4);
9624 memcpy(fqm_buffer, fqm, fqm_length * 4);
9625
9626 BEGIN_BCS_BATCH(batch, 34);
9627 OUT_BCS_BATCH(batch, MFX_FQM_STATE | (34 - 2));
9628 OUT_BCS_BATCH(batch, fqm_type << 0);
9629 intel_batchbuffer_data(batch, fqm_buffer, 32 * 4);
9630 ADVANCE_BCS_BATCH(batch);
9631 }
9632
9633 static void
9634 gen9_mfc_fill_fqm(uint8_t *qm, uint16_t *fqm, int len)
9635 {
9636 int i, j;
9637 for (i = 0; i < len; i++)
9638 for (j = 0; j < len; j++) {
9639 assert(qm[j * len + i]);
9640 fqm[i * len + j] = (1 << 16) / qm[j * len + i];
9641 }
9642 }
9643
9644 static void
9645 gen9_mfc_avc_fqm_state(VADriverContextP ctx,
9646 struct encode_state *encode_state,
9647 struct intel_encoder_context *encoder_context)
9648 {
9649 struct encoder_vme_mfc_context * pak_context = (struct encoder_vme_mfc_context *)encoder_context->vme_context;
9650 struct avc_enc_state * avc_state = (struct avc_enc_state *)pak_context->private_enc_state;
9651 VAEncSequenceParameterBufferH264 *seq_param = avc_state->seq_param;
9652 VAEncPictureParameterBufferH264 *pic_param = avc_state->pic_param;
9653
9654 if (!seq_param->seq_fields.bits.seq_scaling_matrix_present_flag
9655 && !pic_param->pic_fields.bits.pic_scaling_matrix_present_flag) {
9656 gen9_mfc_fqm_state(ctx, MFX_QM_AVC_4X4_INTRA_MATRIX, fqm_flat, 24, encoder_context);
9657 gen9_mfc_fqm_state(ctx, MFX_QM_AVC_4X4_INTER_MATRIX, fqm_flat, 24, encoder_context);
9658 gen9_mfc_fqm_state(ctx, MFX_QM_AVC_8x8_INTRA_MATRIX, fqm_flat, 32, encoder_context);
9659 gen9_mfc_fqm_state(ctx, MFX_QM_AVC_8x8_INTER_MATRIX, fqm_flat, 32, encoder_context);
9660 } else {
9661 int i;
9662 uint32_t fqm[32];
9663 VAIQMatrixBufferH264 *qm;
9664 assert(encode_state->q_matrix && encode_state->q_matrix->buffer);
9665 qm = (VAIQMatrixBufferH264 *)encode_state->q_matrix->buffer;
9666
9667 for (i = 0; i < 3; i++)
9668 gen9_mfc_fill_fqm(qm->ScalingList4x4[i], (uint16_t *)fqm + 16 * i, 4);
9669 gen9_mfc_fqm_state(ctx, MFX_QM_AVC_4X4_INTRA_MATRIX, fqm, 24, encoder_context);
9670
9671 for (i = 3; i < 6; i++)
9672 gen9_mfc_fill_fqm(qm->ScalingList4x4[i], (uint16_t *)fqm + 16 * (i - 3), 4);
9673 gen9_mfc_fqm_state(ctx, MFX_QM_AVC_4X4_INTER_MATRIX, fqm, 24, encoder_context);
9674
9675 gen9_mfc_fill_fqm(qm->ScalingList8x8[0], (uint16_t *)fqm, 8);
9676 gen9_mfc_fqm_state(ctx, MFX_QM_AVC_8x8_INTRA_MATRIX, fqm, 32, encoder_context);
9677
9678 gen9_mfc_fill_fqm(qm->ScalingList8x8[1], (uint16_t *)fqm, 8);
9679 gen9_mfc_fqm_state(ctx, MFX_QM_AVC_8x8_INTER_MATRIX, fqm, 32, encoder_context);
9680 }
9681 }
9682
9683 static void
9684 gen9_mfc_avc_insert_object(VADriverContextP ctx,
9685 struct intel_encoder_context *encoder_context,
9686 unsigned int *insert_data, int lenght_in_dws, int data_bits_in_last_dw,
9687 int skip_emul_byte_count, int is_last_header, int is_end_of_slice, int emulation_flag,
9688 int slice_header_indicator,
9689 struct intel_batchbuffer *batch)
9690 {
9691 if (data_bits_in_last_dw == 0)
9692 data_bits_in_last_dw = 32;
9693
9694 BEGIN_BCS_BATCH(batch, lenght_in_dws + 2);
9695
9696 OUT_BCS_BATCH(batch, MFX_INSERT_OBJECT | (lenght_in_dws));
9697 OUT_BCS_BATCH(batch,
9698 (0 << 16) | /* always start at offset 0 */
9699 (slice_header_indicator << 14) |
9700 (data_bits_in_last_dw << 8) |
9701 (skip_emul_byte_count << 4) |
9702 (!!emulation_flag << 3) |
9703 ((!!is_last_header) << 2) |
9704 ((!!is_end_of_slice) << 1) |
9705 (0 << 0)); /* check this flag */
9706 intel_batchbuffer_data(batch, insert_data, lenght_in_dws * 4);
9707
9708 ADVANCE_BCS_BATCH(batch);
9709 }
9710
9711 static void
9712 gen9_mfc_avc_insert_aud_packed_data(VADriverContextP ctx,
9713 struct encode_state *encode_state,
9714 struct intel_encoder_context *encoder_context,
9715 struct intel_batchbuffer *batch)
9716 {
9717 VAEncPackedHeaderParameterBuffer *param = NULL;
9718 unsigned int length_in_bits;
9719 unsigned int *header_data = NULL;
9720 unsigned char *nal_type = NULL;
9721 int count, i, start_index;
9722
9723 count = encode_state->slice_rawdata_count[0];
9724 start_index = (encode_state->slice_rawdata_index[0] & SLICE_PACKED_DATA_INDEX_MASK);
9725
9726 for (i = 0; i < count; i++) {
9727 unsigned int skip_emul_byte_cnt;
9728
9729 header_data = (unsigned int *)encode_state->packed_header_data_ext[start_index + i]->buffer;
9730 nal_type = (unsigned char *)header_data;
9731
9732 param = (VAEncPackedHeaderParameterBuffer *)(encode_state->packed_header_params_ext[start_index + i]->buffer);
9733 if (param->type != VAEncPackedHeaderRawData)
9734 continue;
9735
9736 length_in_bits = param->bit_length;
9737
9738 skip_emul_byte_cnt = intel_avc_find_skipemulcnt((unsigned char *)header_data, length_in_bits);
9739
9740 if ((*(nal_type + skip_emul_byte_cnt - 1) & 0x1f) == AVC_NAL_DELIMITER) {
9741 gen9_mfc_avc_insert_object(ctx,
9742 encoder_context,
9743 header_data,
9744 ALIGN(length_in_bits, 32) >> 5,
9745 length_in_bits & 0x1f,
9746 skip_emul_byte_cnt,
9747 0,
9748 0,
9749 !param->has_emulation_bytes,
9750 0,
9751 batch);
9752 break;
9753 }
9754 }
9755 }
9756
9757 static void
9758 gen9_mfc_avc_insert_slice_packed_data(VADriverContextP ctx,
9759 struct encode_state *encode_state,
9760 struct intel_encoder_context *encoder_context,
9761 int slice_index,
9762 struct intel_batchbuffer *batch)
9763 {
9764 VAEncPackedHeaderParameterBuffer *param = NULL;
9765 unsigned int length_in_bits;
9766 unsigned int *header_data = NULL;
9767 int count, i, start_index;
9768 int slice_header_index;
9769 unsigned char *nal_type = NULL;
9770
9771 if (encode_state->slice_header_index[slice_index] == 0)
9772 slice_header_index = -1;
9773 else
9774 slice_header_index = (encode_state->slice_header_index[slice_index] & SLICE_PACKED_DATA_INDEX_MASK);
9775
9776 count = encode_state->slice_rawdata_count[slice_index];
9777 start_index = (encode_state->slice_rawdata_index[slice_index] & SLICE_PACKED_DATA_INDEX_MASK);
9778
9779 for (i = 0; i < count; i++) {
9780 unsigned int skip_emul_byte_cnt;
9781
9782 header_data = (unsigned int *)encode_state->packed_header_data_ext[start_index + i]->buffer;
9783 nal_type = (unsigned char *)header_data;
9784
9785 param = (VAEncPackedHeaderParameterBuffer *)(encode_state->packed_header_params_ext[start_index + i]->buffer);
9786
9787 length_in_bits = param->bit_length;
9788
9789 skip_emul_byte_cnt = intel_avc_find_skipemulcnt((unsigned char *)header_data, length_in_bits);
9790
9791 /* skip the slice header packed data type as it is lastly inserted */
9792 if (param->type == VAEncPackedHeaderSlice || (*(nal_type + skip_emul_byte_cnt - 1) & 0x1f) == AVC_NAL_DELIMITER)
9793 continue;
9794
9795 /* as the slice header is still required, the last header flag is set to
9796 * zero.
9797 */
9798 gen9_mfc_avc_insert_object(ctx,
9799 encoder_context,
9800 header_data,
9801 ALIGN(length_in_bits, 32) >> 5,
9802 length_in_bits & 0x1f,
9803 skip_emul_byte_cnt,
9804 0,
9805 0,
9806 !param->has_emulation_bytes,
9807 0,
9808 batch);
9809 }
9810
9811 if (slice_header_index == -1) {
9812 VAEncSequenceParameterBufferH264 *seq_param = (VAEncSequenceParameterBufferH264 *)encode_state->seq_param_ext->buffer;
9813 VAEncPictureParameterBufferH264 *pic_param = (VAEncPictureParameterBufferH264 *)encode_state->pic_param_ext->buffer;
9814 VAEncSliceParameterBufferH264 *slice_params = (VAEncSliceParameterBufferH264 *)encode_state->slice_params_ext[slice_index]->buffer;
9815 unsigned char *slice_header = NULL;
9816 int slice_header_length_in_bits = 0;
9817
9818 /* No slice header data is passed. And the driver needs to generate it */
9819 /* For the Normal H264 */
9820 slice_header_length_in_bits = build_avc_slice_header(seq_param,
9821 pic_param,
9822 slice_params,
9823 &slice_header);
9824 gen9_mfc_avc_insert_object(ctx,
9825 encoder_context,
9826 (unsigned int *)slice_header,
9827 ALIGN(slice_header_length_in_bits, 32) >> 5,
9828 slice_header_length_in_bits & 0x1f,
9829 5, /* first 5 bytes are start code + nal unit type */
9830 1, 0, 1,
9831 1,
9832 batch);
9833
9834 free(slice_header);
9835 } else {
9836 unsigned int skip_emul_byte_cnt;
9837
9838 header_data = (unsigned int *)encode_state->packed_header_data_ext[slice_header_index]->buffer;
9839
9840 param = (VAEncPackedHeaderParameterBuffer *)(encode_state->packed_header_params_ext[slice_header_index]->buffer);
9841 length_in_bits = param->bit_length;
9842
9843 /* as the slice header is the last header data for one slice,
9844 * the last header flag is set to one.
9845 */
9846 skip_emul_byte_cnt = intel_avc_find_skipemulcnt((unsigned char *)header_data, length_in_bits);
9847
9848 gen9_mfc_avc_insert_object(ctx,
9849 encoder_context,
9850 header_data,
9851 ALIGN(length_in_bits, 32) >> 5,
9852 length_in_bits & 0x1f,
9853 skip_emul_byte_cnt,
9854 1,
9855 0,
9856 !param->has_emulation_bytes,
9857 1,
9858 batch);
9859 }
9860
9861 return;
9862 }
9863
9864 static void
9865 gen9_mfc_avc_inset_headers(VADriverContextP ctx,
9866 struct encode_state *encode_state,
9867 struct intel_encoder_context *encoder_context,
9868 VAEncSliceParameterBufferH264 *slice_param,
9869 int slice_index,
9870 struct intel_batchbuffer *batch)
9871 {
9872 struct encoder_vme_mfc_context * pak_context = (struct encoder_vme_mfc_context *)encoder_context->vme_context;
9873 struct generic_enc_codec_state * generic_state = (struct generic_enc_codec_state *)pak_context->generic_enc_state;
9874 int idx = va_enc_packed_type_to_idx(VAEncPackedHeaderH264_SPS);
9875 unsigned int internal_rate_mode = generic_state->internal_rate_mode;
9876 unsigned int skip_emul_byte_cnt;
9877
9878 if (slice_index == 0) {
9879
9880 /* if AUD exist and insert it firstly */
9881 gen9_mfc_avc_insert_aud_packed_data(ctx, encode_state, encoder_context, batch);
9882
9883 if (encode_state->packed_header_data[idx]) {
9884 VAEncPackedHeaderParameterBuffer *param = NULL;
9885 unsigned int *header_data = (unsigned int *)encode_state->packed_header_data[idx]->buffer;
9886 unsigned int length_in_bits;
9887
9888 assert(encode_state->packed_header_param[idx]);
9889 param = (VAEncPackedHeaderParameterBuffer *)encode_state->packed_header_param[idx]->buffer;
9890 length_in_bits = param->bit_length;
9891
9892 skip_emul_byte_cnt = intel_avc_find_skipemulcnt((unsigned char *)header_data, length_in_bits);
9893 gen9_mfc_avc_insert_object(ctx,
9894 encoder_context,
9895 header_data,
9896 ALIGN(length_in_bits, 32) >> 5,
9897 length_in_bits & 0x1f,
9898 skip_emul_byte_cnt,
9899 0,
9900 0,
9901 !param->has_emulation_bytes,
9902 0,
9903 batch);
9904 }
9905
9906 idx = va_enc_packed_type_to_idx(VAEncPackedHeaderH264_PPS);
9907
9908 if (encode_state->packed_header_data[idx]) {
9909 VAEncPackedHeaderParameterBuffer *param = NULL;
9910 unsigned int *header_data = (unsigned int *)encode_state->packed_header_data[idx]->buffer;
9911 unsigned int length_in_bits;
9912
9913 assert(encode_state->packed_header_param[idx]);
9914 param = (VAEncPackedHeaderParameterBuffer *)encode_state->packed_header_param[idx]->buffer;
9915 length_in_bits = param->bit_length;
9916
9917 skip_emul_byte_cnt = intel_avc_find_skipemulcnt((unsigned char *)header_data, length_in_bits);
9918
9919 gen9_mfc_avc_insert_object(ctx,
9920 encoder_context,
9921 header_data,
9922 ALIGN(length_in_bits, 32) >> 5,
9923 length_in_bits & 0x1f,
9924 skip_emul_byte_cnt,
9925 0,
9926 0,
9927 !param->has_emulation_bytes,
9928 0,
9929 batch);
9930 }
9931
9932 idx = va_enc_packed_type_to_idx(VAEncPackedHeaderH264_SEI);
9933
9934 if (encode_state->packed_header_data[idx]) {
9935 VAEncPackedHeaderParameterBuffer *param = NULL;
9936 unsigned int *header_data = (unsigned int *)encode_state->packed_header_data[idx]->buffer;
9937 unsigned int length_in_bits;
9938
9939 assert(encode_state->packed_header_param[idx]);
9940 param = (VAEncPackedHeaderParameterBuffer *)encode_state->packed_header_param[idx]->buffer;
9941 length_in_bits = param->bit_length;
9942
9943 skip_emul_byte_cnt = intel_avc_find_skipemulcnt((unsigned char *)header_data, length_in_bits);
9944 gen9_mfc_avc_insert_object(ctx,
9945 encoder_context,
9946 header_data,
9947 ALIGN(length_in_bits, 32) >> 5,
9948 length_in_bits & 0x1f,
9949 skip_emul_byte_cnt,
9950 0,
9951 0,
9952 !param->has_emulation_bytes,
9953 0,
9954 batch);
9955 } else if (internal_rate_mode == VA_RC_CBR) {
9956 /* insert others */
9957 }
9958 }
9959
9960 gen9_mfc_avc_insert_slice_packed_data(ctx,
9961 encode_state,
9962 encoder_context,
9963 slice_index,
9964 batch);
9965 }
9966
9967 static void
9968 gen9_mfc_avc_slice_state(VADriverContextP ctx,
9969 struct encode_state *encode_state,
9970 struct intel_encoder_context *encoder_context,
9971 VAEncPictureParameterBufferH264 *pic_param,
9972 VAEncSliceParameterBufferH264 *slice_param,
9973 VAEncSliceParameterBufferH264 *next_slice_param,
9974 struct intel_batchbuffer *batch)
9975 {
9976 struct encoder_vme_mfc_context * pak_context = (struct encoder_vme_mfc_context *)encoder_context->vme_context;
9977 struct generic_encoder_context * generic_ctx = (struct generic_encoder_context *)pak_context->generic_enc_ctx;
9978 struct generic_enc_codec_state * generic_state = (struct generic_enc_codec_state *)pak_context->generic_enc_state;
9979 struct avc_enc_state * avc_state = (struct avc_enc_state *)pak_context->private_enc_state;
9980 unsigned int luma_log2_weight_denom = slice_param->luma_log2_weight_denom;
9981 unsigned int chroma_log2_weight_denom = slice_param->chroma_log2_weight_denom;
9982 unsigned char correct[6], grow, shrink;
9983 int slice_hor_pos, slice_ver_pos, next_slice_hor_pos, next_slice_ver_pos;
9984 int max_qp_n, max_qp_p;
9985 int i;
9986 int weighted_pred_idc = 0;
9987 int num_ref_l0 = 0, num_ref_l1 = 0;
9988 int slice_type = intel_avc_enc_slice_type_fixup(slice_param->slice_type);
9989 int slice_qp = pic_param->pic_init_qp + slice_param->slice_qp_delta;
9990 unsigned int rc_panic_enable = 0;
9991 unsigned int rate_control_counter_enable = 0;
9992 unsigned int rounding_value = 0;
9993 unsigned int rounding_inter_enable = 0;
9994
9995 slice_hor_pos = slice_param->macroblock_address % generic_state->frame_width_in_mbs;
9996 slice_ver_pos = slice_param->macroblock_address / generic_state->frame_width_in_mbs;
9997
9998 if (next_slice_param) {
9999 next_slice_hor_pos = next_slice_param->macroblock_address % generic_state->frame_width_in_mbs;
10000 next_slice_ver_pos = next_slice_param->macroblock_address / generic_state->frame_width_in_mbs;
10001 } else {
10002 next_slice_hor_pos = 0;
10003 next_slice_ver_pos = generic_state->frame_height_in_mbs;
10004 }
10005
10006 if (slice_type == SLICE_TYPE_I) {
10007 luma_log2_weight_denom = 0;
10008 chroma_log2_weight_denom = 0;
10009 } else if (slice_type == SLICE_TYPE_P) {
10010 weighted_pred_idc = pic_param->pic_fields.bits.weighted_pred_flag;
10011 num_ref_l0 = pic_param->num_ref_idx_l0_active_minus1 + 1;
10012 rounding_inter_enable = avc_state->rounding_inter_enable;
10013 rounding_value = avc_state->rounding_value;
10014
10015 if (slice_param->num_ref_idx_active_override_flag)
10016 num_ref_l0 = slice_param->num_ref_idx_l0_active_minus1 + 1;
10017 } else if (slice_type == SLICE_TYPE_B) {
10018 weighted_pred_idc = pic_param->pic_fields.bits.weighted_bipred_idc;
10019 num_ref_l0 = pic_param->num_ref_idx_l0_active_minus1 + 1;
10020 num_ref_l1 = pic_param->num_ref_idx_l1_active_minus1 + 1;
10021 rounding_inter_enable = avc_state->rounding_inter_enable;
10022 rounding_value = avc_state->rounding_value;
10023
10024 if (slice_param->num_ref_idx_active_override_flag) {
10025 num_ref_l0 = slice_param->num_ref_idx_l0_active_minus1 + 1;
10026 num_ref_l1 = slice_param->num_ref_idx_l1_active_minus1 + 1;
10027 }
10028
10029 if (weighted_pred_idc == 2) {
10030 /* 8.4.3 - Derivation process for prediction weights (8-279) */
10031 luma_log2_weight_denom = 5;
10032 chroma_log2_weight_denom = 5;
10033 }
10034 }
10035
10036 max_qp_n = 0;
10037 max_qp_p = 0;
10038 grow = 0;
10039 shrink = 0;
10040
10041 rate_control_counter_enable = (generic_state->brc_enabled && (generic_state->curr_pak_pass != 0));
10042 rc_panic_enable = (avc_state->rc_panic_enable &&
10043 (!avc_state->min_max_qp_enable) &&
10044 (encoder_context->rate_control_mode != VA_RC_CQP) &&
10045 (generic_state->curr_pak_pass == (generic_state->num_pak_passes - 1)));
10046
10047 for (i = 0; i < 6; i++)
10048 correct[i] = 0;
10049
10050 BEGIN_BCS_BATCH(batch, 11);
10051
10052 OUT_BCS_BATCH(batch, MFX_AVC_SLICE_STATE | (11 - 2));
10053 OUT_BCS_BATCH(batch, slice_type);
10054 OUT_BCS_BATCH(batch,
10055 (num_ref_l1 << 24) |
10056 (num_ref_l0 << 16) |
10057 (chroma_log2_weight_denom << 8) |
10058 (luma_log2_weight_denom << 0));
10059 OUT_BCS_BATCH(batch,
10060 (weighted_pred_idc << 30) |
10061 (((slice_type == SLICE_TYPE_B) ? slice_param->direct_spatial_mv_pred_flag : 0) << 29) |
10062 (slice_param->disable_deblocking_filter_idc << 27) |
10063 (slice_param->cabac_init_idc << 24) |
10064 (slice_qp << 16) |
10065 ((slice_param->slice_beta_offset_div2 & 0xf) << 8) |
10066 ((slice_param->slice_alpha_c0_offset_div2 & 0xf) << 0));
10067
10068 OUT_BCS_BATCH(batch,
10069 slice_ver_pos << 24 |
10070 slice_hor_pos << 16 |
10071 slice_param->macroblock_address);
10072 OUT_BCS_BATCH(batch,
10073 next_slice_ver_pos << 16 |
10074 next_slice_hor_pos);
10075
10076 OUT_BCS_BATCH(batch,
10077 (rate_control_counter_enable << 31) |
10078 (1 << 30) | /* ResetRateControlCounter */
10079 (2 << 28) | /* Loose Rate Control */
10080 (0 << 24) | /* RC Stable Tolerance */
10081 (rc_panic_enable << 23) | /* RC Panic Enable */
10082 (1 << 22) | /* CBP mode */
10083 (0 << 21) | /* MB Type Direct Conversion, 0: Enable, 1: Disable */
10084 (0 << 20) | /* MB Type Skip Conversion, 0: Enable, 1: Disable */
10085 (!next_slice_param << 19) | /* Is Last Slice */
10086 (0 << 18) | /* BitstreamOutputFlag Compressed BitStream Output Disable Flag 0:enable 1:disable */
10087 (1 << 17) | /* HeaderPresentFlag */
10088 (1 << 16) | /* SliceData PresentFlag */
10089 (0 << 15) | /* TailPresentFlag */
10090 (1 << 13) | /* RBSP NAL TYPE */
10091 (1 << 12)); /* CabacZeroWordInsertionEnable */
10092
10093 OUT_BCS_BATCH(batch, generic_ctx->compressed_bitstream.start_offset);
10094
10095 OUT_BCS_BATCH(batch,
10096 (max_qp_n << 24) | /*Target QP - 24 is lowest QP*/
10097 (max_qp_p << 16) | /*Target QP + 20 is highest QP*/
10098 (shrink << 8) |
10099 (grow << 0));
10100 OUT_BCS_BATCH(batch,
10101 (rounding_inter_enable << 31) |
10102 (rounding_value << 28) |
10103 (1 << 27) |
10104 (5 << 24) |
10105 (correct[5] << 20) |
10106 (correct[4] << 16) |
10107 (correct[3] << 12) |
10108 (correct[2] << 8) |
10109 (correct[1] << 4) |
10110 (correct[0] << 0));
10111 OUT_BCS_BATCH(batch, 0);
10112
10113 ADVANCE_BCS_BATCH(batch);
10114 }
10115
10116 static uint8_t
10117 gen9_mfc_avc_get_ref_idx_state(VAPictureH264 *va_pic, unsigned int frame_store_id)
10118 {
10119 unsigned int is_long_term =
10120 !!(va_pic->flags & VA_PICTURE_H264_LONG_TERM_REFERENCE);
10121 unsigned int is_top_field =
10122 !!(va_pic->flags & VA_PICTURE_H264_TOP_FIELD);
10123 unsigned int is_bottom_field =
10124 !!(va_pic->flags & VA_PICTURE_H264_BOTTOM_FIELD);
10125
10126 return ((is_long_term << 6) |
10127 (0 << 5) |
10128 (frame_store_id << 1) |
10129 ((is_top_field ^ 1) & is_bottom_field));
10130 }
10131
10132 static void
10133 gen9_mfc_avc_ref_idx_state(VADriverContextP ctx,
10134 struct encode_state *encode_state,
10135 struct intel_encoder_context *encoder_context,
10136 VAEncSliceParameterBufferH264 *slice_param,
10137 struct intel_batchbuffer *batch)
10138 {
10139 struct encoder_vme_mfc_context * pak_context = (struct encoder_vme_mfc_context *)encoder_context->vme_context;
10140 struct avc_enc_state * avc_state = (struct avc_enc_state *)pak_context->private_enc_state;
10141 VAPictureH264 *ref_pic;
10142 int i, slice_type, ref_idx_shift;
10143 unsigned int fwd_ref_entry;
10144 unsigned int bwd_ref_entry;
10145
10146 /* max 4 ref frames are allowed for l0 and l1 */
10147 fwd_ref_entry = 0x80808080;
10148 slice_type = intel_avc_enc_slice_type_fixup(slice_param->slice_type);
10149
10150 if ((slice_type == SLICE_TYPE_P) ||
10151 (slice_type == SLICE_TYPE_B)) {
10152 for (i = 0; i < MIN(avc_state->num_refs[0], 4); i++) {
10153 ref_pic = &slice_param->RefPicList0[i];
10154 ref_idx_shift = i * 8;
10155
10156 fwd_ref_entry &= ~(0xFF << ref_idx_shift);
10157 fwd_ref_entry += (gen9_mfc_avc_get_ref_idx_state(ref_pic, avc_state->list_ref_idx[0][i]) << ref_idx_shift);
10158 }
10159 }
10160
10161 bwd_ref_entry = 0x80808080;
10162 if (slice_type == SLICE_TYPE_B) {
10163 for (i = 0; i < MIN(avc_state->num_refs[1], 4); i++) {
10164 ref_pic = &slice_param->RefPicList1[i];
10165 ref_idx_shift = i * 8;
10166
10167 bwd_ref_entry &= ~(0xFF << ref_idx_shift);
10168 bwd_ref_entry += (gen9_mfc_avc_get_ref_idx_state(ref_pic, avc_state->list_ref_idx[1][i]) << ref_idx_shift);
10169 }
10170 }
10171
10172 if ((slice_type == SLICE_TYPE_P) ||
10173 (slice_type == SLICE_TYPE_B)) {
10174 BEGIN_BCS_BATCH(batch, 10);
10175 OUT_BCS_BATCH(batch, MFX_AVC_REF_IDX_STATE | 8);
10176 OUT_BCS_BATCH(batch, 0); // L0
10177 OUT_BCS_BATCH(batch, fwd_ref_entry);
10178
10179 for (i = 0; i < 7; i++) {
10180 OUT_BCS_BATCH(batch, 0x80808080);
10181 }
10182
10183 ADVANCE_BCS_BATCH(batch);
10184 }
10185
10186 if (slice_type == SLICE_TYPE_B) {
10187 BEGIN_BCS_BATCH(batch, 10);
10188 OUT_BCS_BATCH(batch, MFX_AVC_REF_IDX_STATE | 8);
10189 OUT_BCS_BATCH(batch, 1); //Select L1
10190 OUT_BCS_BATCH(batch, bwd_ref_entry); //max 4 reference allowed
10191 for (i = 0; i < 7; i++) {
10192 OUT_BCS_BATCH(batch, 0x80808080);
10193 }
10194 ADVANCE_BCS_BATCH(batch);
10195 }
10196 }
10197
10198 static void
10199 gen9_mfc_avc_weightoffset_state(VADriverContextP ctx,
10200 struct encode_state *encode_state,
10201 struct intel_encoder_context *encoder_context,
10202 VAEncPictureParameterBufferH264 *pic_param,
10203 VAEncSliceParameterBufferH264 *slice_param,
10204 struct intel_batchbuffer *batch)
10205 {
10206 int i, slice_type;
10207 short weightoffsets[32 * 6];
10208
10209 slice_type = intel_avc_enc_slice_type_fixup(slice_param->slice_type);
10210
10211 if (slice_type == SLICE_TYPE_P &&
10212 pic_param->pic_fields.bits.weighted_pred_flag == 1) {
10213 memset(weightoffsets, 0, 32 * 6 * sizeof(short));
10214 for (i = 0; i < 32; i++) {
10215 weightoffsets[i * 6 + 0] = slice_param->luma_weight_l0[i];
10216 weightoffsets[i * 6 + 1] = slice_param->luma_offset_l0[i];
10217 weightoffsets[i * 6 + 2] = slice_param->chroma_weight_l0[i][0];
10218 weightoffsets[i * 6 + 3] = slice_param->chroma_offset_l0[i][0];
10219 weightoffsets[i * 6 + 4] = slice_param->chroma_weight_l0[i][1];
10220 weightoffsets[i * 6 + 5] = slice_param->chroma_offset_l0[i][1];
10221 }
10222
10223 BEGIN_BCS_BATCH(batch, 98);
10224 OUT_BCS_BATCH(batch, MFX_AVC_WEIGHTOFFSET_STATE | (98 - 2));
10225 OUT_BCS_BATCH(batch, 0);
10226 intel_batchbuffer_data(batch, weightoffsets, sizeof(weightoffsets));
10227
10228 ADVANCE_BCS_BATCH(batch);
10229 }
10230
10231 if (slice_type == SLICE_TYPE_B &&
10232 (pic_param->pic_fields.bits.weighted_bipred_idc == 1)) {
10233 memset(weightoffsets, 0, 32 * 6 * sizeof(short));
10234 for (i = 0; i < 32; i++) {
10235 weightoffsets[i * 6 + 0] = slice_param->luma_weight_l0[i];
10236 weightoffsets[i * 6 + 1] = slice_param->luma_offset_l0[i];
10237 weightoffsets[i * 6 + 2] = slice_param->chroma_weight_l0[i][0];
10238 weightoffsets[i * 6 + 3] = slice_param->chroma_offset_l0[i][0];
10239 weightoffsets[i * 6 + 4] = slice_param->chroma_weight_l0[i][1];
10240 weightoffsets[i * 6 + 5] = slice_param->chroma_offset_l0[i][1];
10241 }
10242
10243 BEGIN_BCS_BATCH(batch, 98);
10244 OUT_BCS_BATCH(batch, MFX_AVC_WEIGHTOFFSET_STATE | (98 - 2));
10245 OUT_BCS_BATCH(batch, 0);
10246 intel_batchbuffer_data(batch, weightoffsets, sizeof(weightoffsets));
10247 ADVANCE_BCS_BATCH(batch);
10248
10249 memset(weightoffsets, 0, 32 * 6 * sizeof(short));
10250 for (i = 0; i < 32; i++) {
10251 weightoffsets[i * 6 + 0] = slice_param->luma_weight_l1[i];
10252 weightoffsets[i * 6 + 1] = slice_param->luma_offset_l1[i];
10253 weightoffsets[i * 6 + 2] = slice_param->chroma_weight_l1[i][0];
10254 weightoffsets[i * 6 + 3] = slice_param->chroma_offset_l1[i][0];
10255 weightoffsets[i * 6 + 4] = slice_param->chroma_weight_l1[i][1];
10256 weightoffsets[i * 6 + 5] = slice_param->chroma_offset_l1[i][1];
10257 }
10258
10259 BEGIN_BCS_BATCH(batch, 98);
10260 OUT_BCS_BATCH(batch, MFX_AVC_WEIGHTOFFSET_STATE | (98 - 2));
10261 OUT_BCS_BATCH(batch, 1);
10262 intel_batchbuffer_data(batch, weightoffsets, sizeof(weightoffsets));
10263 ADVANCE_BCS_BATCH(batch);
10264 }
10265 }
10266
10267 static void
10268 gen9_mfc_avc_single_slice(VADriverContextP ctx,
10269 struct encode_state *encode_state,
10270 struct intel_encoder_context *encoder_context,
10271 VAEncSliceParameterBufferH264 *slice_param,
10272 VAEncSliceParameterBufferH264 *next_slice_param,
10273 int slice_index)
10274 {
10275 struct i965_driver_data *i965 = i965_driver_data(ctx);
10276 struct i965_gpe_table *gpe = &i965->gpe_table;
10277 struct encoder_vme_mfc_context * pak_context = (struct encoder_vme_mfc_context *)encoder_context->vme_context;
10278 struct i965_avc_encoder_context * avc_ctx = (struct i965_avc_encoder_context *)pak_context->private_enc_ctx;
10279 struct generic_enc_codec_state * generic_state = (struct generic_enc_codec_state *)pak_context->generic_enc_state;
10280 struct avc_enc_state * avc_state = (struct avc_enc_state *)pak_context->private_enc_state;
10281 struct intel_batchbuffer *batch = encoder_context->base.batch;
10282 struct intel_batchbuffer *slice_batch = avc_ctx->pres_slice_batch_buffer_2nd_level;
10283 VAEncPictureParameterBufferH264 *pic_param = (VAEncPictureParameterBufferH264 *)encode_state->pic_param_ext->buffer;
10284 struct gpe_mi_batch_buffer_start_parameter second_level_batch;
10285 struct object_surface *obj_surface;
10286 struct gen9_surface_avc *avc_priv_surface;
10287
10288 unsigned int slice_offset = 0;
10289
10290 if (generic_state->curr_pak_pass == 0) {
10291 slice_offset = intel_batchbuffer_used_size(slice_batch);
10292 avc_state->slice_batch_offset[slice_index] = slice_offset;
10293 gen9_mfc_avc_ref_idx_state(ctx, encode_state, encoder_context, slice_param, slice_batch);
10294 gen9_mfc_avc_weightoffset_state(ctx,
10295 encode_state,
10296 encoder_context,
10297 pic_param,
10298 slice_param,
10299 slice_batch);
10300 gen9_mfc_avc_slice_state(ctx,
10301 encode_state,
10302 encoder_context,
10303 pic_param,
10304 slice_param,
10305 next_slice_param,
10306 slice_batch);
10307 gen9_mfc_avc_inset_headers(ctx,
10308 encode_state,
10309 encoder_context,
10310 slice_param,
10311 slice_index,
10312 slice_batch);
10313
10314 BEGIN_BCS_BATCH(slice_batch, 2);
10315 OUT_BCS_BATCH(slice_batch, 0);
10316 OUT_BCS_BATCH(slice_batch, MI_BATCH_BUFFER_END);
10317 ADVANCE_BCS_BATCH(slice_batch);
10318
10319 } else {
10320 slice_offset = avc_state->slice_batch_offset[slice_index];
10321 }
10322 /* insert slice as second level.*/
10323 memset(&second_level_batch, 0, sizeof(second_level_batch));
10324 second_level_batch.is_second_level = 1; /* Must be the second level batch buffer */
10325 second_level_batch.offset = slice_offset;
10326 second_level_batch.bo = slice_batch->buffer;
10327 gpe->mi_batch_buffer_start(ctx, batch, &second_level_batch);
10328
10329 /* insert mb code as second level.*/
10330 obj_surface = encode_state->reconstructed_object;
10331 assert(obj_surface->private_data);
10332 avc_priv_surface = (struct gen9_surface_avc *)obj_surface->private_data;
10333
10334 memset(&second_level_batch, 0, sizeof(second_level_batch));
10335 second_level_batch.is_second_level = 1; /* Must be the second level batch buffer */
10336 second_level_batch.offset = slice_param->macroblock_address * 16 * 4;
10337 second_level_batch.bo = avc_priv_surface->res_mb_code_surface.bo;
10338 gpe->mi_batch_buffer_start(ctx, batch, &second_level_batch);
10339
10340 }
10341
10342 static void
10343 gen9_avc_pak_slice_level(VADriverContextP ctx,
10344 struct encode_state *encode_state,
10345 struct intel_encoder_context *encoder_context)
10346 {
10347 struct i965_driver_data *i965 = i965_driver_data(ctx);
10348 struct i965_gpe_table *gpe = &i965->gpe_table;
10349 struct encoder_vme_mfc_context * pak_context = (struct encoder_vme_mfc_context *)encoder_context->vme_context;
10350 struct avc_enc_state * avc_state = (struct avc_enc_state *)pak_context->private_enc_state;
10351 struct intel_batchbuffer *batch = encoder_context->base.batch;
10352 struct gpe_mi_flush_dw_parameter mi_flush_dw_params;
10353 VAEncSliceParameterBufferH264 *slice_param, *next_slice_param, *next_slice_group_param;
10354 int i, j;
10355 int slice_index = 0;
10356 int is_frame_level = (avc_state->slice_num > 1) ? 0 : 1; /* check it for SKL,now single slice per frame */
10357 int has_tail = 0; /* check it later */
10358
10359 for (j = 0; j < encode_state->num_slice_params_ext; j++) {
10360 slice_param = (VAEncSliceParameterBufferH264 *)encode_state->slice_params_ext[j]->buffer;
10361
10362 if (j == encode_state->num_slice_params_ext - 1)
10363 next_slice_group_param = NULL;
10364 else
10365 next_slice_group_param = (VAEncSliceParameterBufferH264 *)encode_state->slice_params_ext[j + 1]->buffer;
10366
10367 for (i = 0; i < encode_state->slice_params_ext[j]->num_elements; i++) {
10368 if (i < encode_state->slice_params_ext[j]->num_elements - 1)
10369 next_slice_param = slice_param + 1;
10370 else
10371 next_slice_param = next_slice_group_param;
10372
10373 gen9_mfc_avc_single_slice(ctx,
10374 encode_state,
10375 encoder_context,
10376 slice_param,
10377 next_slice_param,
10378 slice_index);
10379 slice_param++;
10380 slice_index++;
10381
10382 if (is_frame_level)
10383 break;
10384 }
10385
10386 if (is_frame_level)
10387 break;
10388 }
10389
10390 if (has_tail) {
10391 /* insert a tail if required */
10392 }
10393
10394 memset(&mi_flush_dw_params, 0, sizeof(mi_flush_dw_params));
10395 mi_flush_dw_params.video_pipeline_cache_invalidate = 1;
10396 gpe->mi_flush_dw(ctx, batch, &mi_flush_dw_params);
10397 }
10398 static void
10399 gen9_avc_pak_picture_level(VADriverContextP ctx,
10400 struct encode_state *encode_state,
10401 struct intel_encoder_context *encoder_context)
10402 {
10403 struct i965_driver_data *i965 = i965_driver_data(ctx);
10404 struct i965_gpe_table *gpe = &i965->gpe_table;
10405 struct encoder_vme_mfc_context * pak_context = (struct encoder_vme_mfc_context *)encoder_context->vme_context;
10406 struct generic_encoder_context * generic_ctx = (struct generic_encoder_context *)pak_context->generic_enc_ctx;
10407 struct i965_avc_encoder_context * avc_ctx = (struct i965_avc_encoder_context *)pak_context->private_enc_ctx;
10408 struct generic_enc_codec_state * generic_state = (struct generic_enc_codec_state *)pak_context->generic_enc_state;
10409 struct gpe_mi_batch_buffer_start_parameter second_level_batch;
10410 struct intel_batchbuffer *batch = encoder_context->base.batch;
10411
10412 if (generic_state->brc_enabled &&
10413 generic_state->curr_pak_pass) {
10414 struct gpe_mi_conditional_batch_buffer_end_parameter mi_conditional_batch_buffer_end_params;
10415 struct encoder_status_buffer_internal *status_buffer;
10416 status_buffer = &(avc_ctx->status_buffer);
10417
10418 memset(&mi_conditional_batch_buffer_end_params, 0, sizeof(mi_conditional_batch_buffer_end_params));
10419 mi_conditional_batch_buffer_end_params.offset = status_buffer->image_status_mask_offset;
10420 mi_conditional_batch_buffer_end_params.bo = status_buffer->bo;
10421 mi_conditional_batch_buffer_end_params.compare_data = 0;
10422 mi_conditional_batch_buffer_end_params.compare_mask_mode_disabled = 0;
10423 gpe->mi_conditional_batch_buffer_end(ctx, batch, &mi_conditional_batch_buffer_end_params);
10424 }
10425
10426 gen9_mfc_avc_pipe_mode_select(ctx, encode_state, encoder_context);
10427 gen9_mfc_avc_surface_state(ctx, encoder_context, &(generic_ctx->res_reconstructed_surface), 0);
10428 gen9_mfc_avc_surface_state(ctx, encoder_context, &(generic_ctx->res_uncompressed_input_surface), 4);
10429 gen9_mfc_avc_pipe_buf_addr_state(ctx, encoder_context);
10430 gen9_mfc_avc_ind_obj_base_addr_state(ctx, encode_state, encoder_context);
10431 gen9_mfc_avc_bsp_buf_base_addr_state(ctx, encoder_context);
10432
10433 if (generic_state->brc_enabled) {
10434 memset(&second_level_batch, 0, sizeof(second_level_batch));
10435 if (generic_state->curr_pak_pass == 0) {
10436 second_level_batch.offset = 0;
10437 } else {
10438 second_level_batch.offset = generic_state->curr_pak_pass * INTEL_AVC_IMAGE_STATE_CMD_SIZE;
10439 }
10440 second_level_batch.is_second_level = 1;
10441 second_level_batch.bo = avc_ctx->res_brc_image_state_write_buffer.bo;
10442 gpe->mi_batch_buffer_start(ctx, batch, &second_level_batch);
10443 } else {
10444 /*generate a new image state */
10445 gen9_avc_set_image_state_non_brc(ctx, encode_state, encoder_context, &(avc_ctx->res_image_state_batch_buffer_2nd_level));
10446 memset(&second_level_batch, 0, sizeof(second_level_batch));
10447 second_level_batch.offset = 0;
10448 second_level_batch.is_second_level = 1;
10449 second_level_batch.bo = avc_ctx->res_image_state_batch_buffer_2nd_level.bo;
10450 gpe->mi_batch_buffer_start(ctx, batch, &second_level_batch);
10451 }
10452
10453 gen9_mfc_avc_qm_state(ctx, encode_state, encoder_context);
10454 gen9_mfc_avc_fqm_state(ctx, encode_state, encoder_context);
10455 gen9_mfc_avc_directmode_state(ctx, encoder_context);
10456
10457 }
10458
10459 static void
10460 gen9_avc_read_mfc_status(VADriverContextP ctx, struct intel_encoder_context *encoder_context)
10461 {
10462 struct i965_driver_data *i965 = i965_driver_data(ctx);
10463 struct i965_gpe_table *gpe = &i965->gpe_table;
10464 struct intel_batchbuffer *batch = encoder_context->base.batch;
10465 struct encoder_vme_mfc_context * pak_context = (struct encoder_vme_mfc_context *)encoder_context->vme_context;
10466 struct i965_avc_encoder_context * avc_ctx = (struct i965_avc_encoder_context *)pak_context->private_enc_ctx;
10467 struct generic_enc_codec_state * generic_state = (struct generic_enc_codec_state *)pak_context->generic_enc_state;
10468
10469 struct gpe_mi_store_register_mem_parameter mi_store_reg_mem_param;
10470 struct gpe_mi_store_data_imm_parameter mi_store_data_imm_param;
10471 struct gpe_mi_flush_dw_parameter mi_flush_dw_param;
10472 struct encoder_status_buffer_internal *status_buffer;
10473
10474 status_buffer = &(avc_ctx->status_buffer);
10475
10476 memset(&mi_flush_dw_param, 0, sizeof(mi_flush_dw_param));
10477 gpe->mi_flush_dw(ctx, batch, &mi_flush_dw_param);
10478
10479 /* read register and store into status_buffer and pak_statitistic info */
10480 memset(&mi_store_reg_mem_param, 0, sizeof(mi_store_reg_mem_param));
10481 mi_store_reg_mem_param.bo = status_buffer->bo;
10482 mi_store_reg_mem_param.offset = status_buffer->bs_byte_count_frame_offset;
10483 mi_store_reg_mem_param.mmio_offset = status_buffer->bs_byte_count_frame_reg_offset;
10484 gpe->mi_store_register_mem(ctx, batch, &mi_store_reg_mem_param);
10485
10486 mi_store_reg_mem_param.bo = status_buffer->bo;
10487 mi_store_reg_mem_param.offset = status_buffer->image_status_mask_offset;
10488 mi_store_reg_mem_param.mmio_offset = status_buffer->image_status_mask_reg_offset;
10489 gpe->mi_store_register_mem(ctx, batch, &mi_store_reg_mem_param);
10490
10491 /*update the status in the pak_statistic_surface */
10492 mi_store_reg_mem_param.bo = avc_ctx->res_brc_pre_pak_statistics_output_buffer.bo;
10493 mi_store_reg_mem_param.offset = 0;
10494 mi_store_reg_mem_param.mmio_offset = status_buffer->bs_byte_count_frame_reg_offset;
10495 gpe->mi_store_register_mem(ctx, batch, &mi_store_reg_mem_param);
10496
10497 mi_store_reg_mem_param.bo = avc_ctx->res_brc_pre_pak_statistics_output_buffer.bo;
10498 mi_store_reg_mem_param.offset = 4;
10499 mi_store_reg_mem_param.mmio_offset = status_buffer->bs_byte_count_frame_nh_reg_offset;
10500 gpe->mi_store_register_mem(ctx, batch, &mi_store_reg_mem_param);
10501
10502 memset(&mi_store_data_imm_param, 0, sizeof(mi_store_data_imm_param));
10503 mi_store_data_imm_param.bo = avc_ctx->res_brc_pre_pak_statistics_output_buffer.bo;
10504 mi_store_data_imm_param.offset = sizeof(unsigned int) * 2;
10505 mi_store_data_imm_param.dw0 = (generic_state->curr_pak_pass + 1);
10506 gpe->mi_store_data_imm(ctx, batch, &mi_store_data_imm_param);
10507
10508 mi_store_reg_mem_param.bo = avc_ctx->res_brc_pre_pak_statistics_output_buffer.bo;
10509 mi_store_reg_mem_param.offset = sizeof(unsigned int) * (4 + generic_state->curr_pak_pass) ;
10510 mi_store_reg_mem_param.mmio_offset = status_buffer->image_status_ctrl_reg_offset;
10511 gpe->mi_store_register_mem(ctx, batch, &mi_store_reg_mem_param);
10512
10513 memset(&mi_flush_dw_param, 0, sizeof(mi_flush_dw_param));
10514 gpe->mi_flush_dw(ctx, batch, &mi_flush_dw_param);
10515
10516 return;
10517 }
10518
10519 static void
10520 gen9_avc_pak_brc_prepare(struct encode_state *encode_state,
10521 struct intel_encoder_context *encoder_context)
10522 {
10523 struct encoder_vme_mfc_context * pak_context = (struct encoder_vme_mfc_context *)encoder_context->vme_context;
10524 struct generic_enc_codec_state * generic_state = (struct generic_enc_codec_state *)pak_context->generic_enc_state;
10525 unsigned int rate_control_mode = encoder_context->rate_control_mode;
10526
10527 switch (rate_control_mode & 0x7f) {
10528 case VA_RC_CBR:
10529 generic_state->internal_rate_mode = VA_RC_CBR;
10530 break;
10531
10532 case VA_RC_VBR:
10533 generic_state->internal_rate_mode = VA_RC_VBR;//AVBR
10534 break;
10535
10536 case VA_RC_CQP:
10537 default:
10538 generic_state->internal_rate_mode = VA_RC_CQP;
10539 break;
10540 }
10541
10542 if (encoder_context->quality_level == 0)
10543 encoder_context->quality_level = ENCODER_DEFAULT_QUALITY_AVC;
10544 }
10545
10546 /* allcate resources for pak only (fei mode) */
10547 static VAStatus
10548 gen9_avc_fei_pak_pipeline_prepare(VADriverContextP ctx,
10549 VAProfile profile,
10550 struct encode_state *encode_state,
10551 struct intel_encoder_context *encoder_context)
10552 {
10553 VAStatus va_status;
10554 struct i965_driver_data *i965 = i965_driver_data(ctx);
10555 struct encoder_vme_mfc_context * pak_context = (struct encoder_vme_mfc_context *)encoder_context->vme_context;
10556 struct generic_encoder_context * generic_ctx = (struct generic_encoder_context *)pak_context->generic_enc_ctx;
10557 struct i965_avc_encoder_context * avc_ctx = (struct i965_avc_encoder_context *)pak_context->private_enc_ctx;
10558 struct generic_enc_codec_state * generic_state = (struct generic_enc_codec_state *)pak_context->generic_enc_state;
10559 struct avc_enc_state * avc_state = (struct avc_enc_state *)pak_context->private_enc_state;
10560 struct gen9_surface_avc *avc_priv_surface;
10561 VAEncPictureParameterBufferH264 *pic_param;
10562 VAEncSliceParameterBufferH264 *slice_param;
10563 VAEncMiscParameterFEIFrameControlH264 *fei_param = NULL;
10564 unsigned int size = 0, i, j;
10565 unsigned int frame_mb_nums;
10566 struct object_buffer *obj_buffer = NULL;
10567 struct buffer_store *buffer_store = NULL;
10568 struct object_surface *obj_surface = NULL;
10569 struct avc_surface_param surface_param;
10570 struct i965_coded_buffer_segment *coded_buffer_segment;
10571 dri_bo *bo;
10572 unsigned char * pdata;
10573
10574 gen9_avc_update_parameters(ctx, profile, encode_state, encoder_context);
10575
10576 pic_param = avc_state->pic_param;
10577 slice_param = avc_state->slice_param[0];
10578
10579 va_status = gen9_avc_encode_check_parameter(ctx, encode_state, encoder_context);
10580 if (va_status != VA_STATUS_SUCCESS)
10581 return va_status;
10582
10583 va_status = gen9_avc_allocate_pak_resources(ctx, encode_state, encoder_context);
10584 if (va_status != VA_STATUS_SUCCESS)
10585 return va_status;
10586
10587 /* Encoded bitstream ?*/
10588 obj_buffer = encode_state->coded_buf_object;
10589 bo = obj_buffer->buffer_store->bo;
10590 i965_free_gpe_resource(&generic_ctx->compressed_bitstream.res);
10591 i965_dri_object_to_buffer_gpe_resource(&generic_ctx->compressed_bitstream.res, bo);
10592 generic_ctx->compressed_bitstream.start_offset = I965_CODEDBUFFER_HEADER_SIZE;
10593 generic_ctx->compressed_bitstream.end_offset =
10594 ALIGN(obj_buffer->size_element - 0x1000, 0x1000);
10595
10596 /*status buffer */
10597 dri_bo_unreference(avc_ctx->status_buffer.bo);
10598 avc_ctx->status_buffer.bo = bo;
10599 dri_bo_reference(bo);
10600
10601 /* set the internal flag to 0 to indicate the coded size is unknown */
10602 dri_bo_map(bo, 1);
10603 coded_buffer_segment = (struct i965_coded_buffer_segment *)bo->virtual;
10604 coded_buffer_segment->mapped = 0;
10605 coded_buffer_segment->codec = encoder_context->codec;
10606 coded_buffer_segment->status_support = 1;
10607
10608 pdata = bo->virtual + avc_ctx->status_buffer.base_offset;
10609 memset(pdata, 0, avc_ctx->status_buffer.status_buffer_size);
10610 dri_bo_unmap(bo);
10611 //frame id, it is the ref pic id in the reference_objects list.
10612 avc_state->num_refs[0] = 0;
10613 avc_state->num_refs[1] = 0;
10614 if (generic_state->frame_type == SLICE_TYPE_P) {
10615 avc_state->num_refs[0] = pic_param->num_ref_idx_l0_active_minus1 + 1;
10616
10617 if (slice_param->num_ref_idx_active_override_flag)
10618 avc_state->num_refs[0] = slice_param->num_ref_idx_l0_active_minus1 + 1;
10619 } else if (generic_state->frame_type == SLICE_TYPE_B) {
10620 avc_state->num_refs[0] = pic_param->num_ref_idx_l0_active_minus1 + 1;
10621 avc_state->num_refs[1] = pic_param->num_ref_idx_l1_active_minus1 + 1;
10622
10623 if (slice_param->num_ref_idx_active_override_flag) {
10624 avc_state->num_refs[0] = slice_param->num_ref_idx_l0_active_minus1 + 1;
10625 avc_state->num_refs[1] = slice_param->num_ref_idx_l1_active_minus1 + 1;
10626 }
10627 }
10628 for (i = 0; i < ARRAY_ELEMS(avc_state->list_ref_idx[0]); i++) {
10629 VAPictureH264 *va_pic;
10630
10631 assert(ARRAY_ELEMS(slice_param->RefPicList0) == ARRAY_ELEMS(avc_state->list_ref_idx[0]));
10632 avc_state->list_ref_idx[0][i] = 0;
10633
10634 if (i >= avc_state->num_refs[0])
10635 continue;
10636
10637 va_pic = &slice_param->RefPicList0[i];
10638
10639 for (j = 0; j < ARRAY_ELEMS(encode_state->reference_objects); j++) {
10640 obj_surface = encode_state->reference_objects[j];
10641
10642 if (obj_surface &&
10643 obj_surface->bo &&
10644 obj_surface->base.id == va_pic->picture_id) {
10645
10646 assert(obj_surface->base.id != VA_INVALID_SURFACE);
10647 avc_state->list_ref_idx[0][i] = j;
10648
10649 break;
10650 }
10651 }
10652 }
10653 for (i = 0; i < ARRAY_ELEMS(avc_state->list_ref_idx[1]); i++) {
10654 VAPictureH264 *va_pic;
10655
10656 assert(ARRAY_ELEMS(slice_param->RefPicList1) == ARRAY_ELEMS(avc_state->list_ref_idx[1]));
10657 avc_state->list_ref_idx[1][i] = 0;
10658
10659 if (i >= avc_state->num_refs[1])
10660 continue;
10661
10662 va_pic = &slice_param->RefPicList1[i];
10663
10664 for (j = 0; j < ARRAY_ELEMS(encode_state->reference_objects); j++) {
10665 obj_surface = encode_state->reference_objects[j];
10666
10667
10668 if (obj_surface &&
10669 obj_surface->bo &&
10670 obj_surface->base.id == va_pic->picture_id) {
10671
10672 assert(obj_surface->base.id != VA_INVALID_SURFACE);
10673 avc_state->list_ref_idx[1][i] = j;
10674
10675 break;
10676 break;
10677 }
10678 }
10679 }
10680
10681 obj_surface = encode_state->reconstructed_object;
10682 fei_param = avc_state->fei_framectl_param;
10683 frame_mb_nums = generic_state->frame_width_in_mbs * generic_state->frame_height_in_mbs;
10684
10685 /* Setup current reconstruct frame */
10686 obj_surface = encode_state->reconstructed_object;
10687 va_status = i965_check_alloc_surface_bo(ctx, obj_surface, 1, VA_FOURCC_NV12, SUBSAMPLE_YUV420);
10688
10689 if (va_status != VA_STATUS_SUCCESS)
10690 return va_status;
10691
10692 memset(&surface_param, 0, sizeof(surface_param));
10693 surface_param.frame_width = generic_state->frame_width_in_pixel;
10694 surface_param.frame_height = generic_state->frame_height_in_pixel;
10695 va_status = gen9_avc_init_check_surfaces(ctx,
10696 obj_surface, encoder_context,
10697 &surface_param);
10698 avc_priv_surface = obj_surface->private_data;
10699
10700 /* res_mb_code_surface for MB code */
10701 /* PAK only mode must have the mb_code_surface from middleware,
10702 * so the code shouldn't reach here without an externally provided
10703 * MB Code buffer */
10704 assert(fei_param->mb_code_data != VA_INVALID_ID);
10705 size = frame_mb_nums * FEI_AVC_MB_CODE_BUFFER_SIZE;
10706 obj_buffer = BUFFER(fei_param->mb_code_data);
10707 assert(obj_buffer != NULL);
10708 buffer_store = obj_buffer->buffer_store;
10709 assert(size <= buffer_store->bo->size);
10710 if (avc_priv_surface->res_mb_code_surface.bo != NULL)
10711 i965_free_gpe_resource(&avc_priv_surface->res_mb_code_surface);
10712 i965_dri_object_to_buffer_gpe_resource(&avc_priv_surface->res_mb_code_surface,
10713 buffer_store->bo);
10714 /* res_mv_data_surface for MV data */
10715 size = frame_mb_nums * FEI_AVC_MV_DATA_BUFFER_SIZE;
10716 if (fei_param->mv_data != VA_INVALID_ID) {
10717 obj_buffer = BUFFER(fei_param->mv_data);
10718 assert(obj_buffer != NULL);
10719 buffer_store = obj_buffer->buffer_store;
10720 assert(size <= buffer_store->bo->size);
10721 if (avc_priv_surface->res_mv_data_surface.bo != NULL)
10722 i965_free_gpe_resource(&avc_priv_surface->res_mv_data_surface);
10723 i965_dri_object_to_buffer_gpe_resource(&avc_priv_surface->res_mv_data_surface,
10724 buffer_store->bo);
10725 }
10726
10727 return VA_STATUS_SUCCESS;
10728
10729 }
10730
10731 static VAStatus
10732 gen9_avc_pak_pipeline_prepare(VADriverContextP ctx,
10733 VAProfile profile,
10734 struct encode_state *encode_state,
10735 struct intel_encoder_context *encoder_context)
10736 {
10737 VAStatus va_status;
10738 struct i965_driver_data *i965 = i965_driver_data(ctx);
10739 struct encoder_vme_mfc_context * pak_context = (struct encoder_vme_mfc_context *)encoder_context->vme_context;
10740 struct generic_encoder_context * generic_ctx = (struct generic_encoder_context *)pak_context->generic_enc_ctx;
10741 struct i965_avc_encoder_context * avc_ctx = (struct i965_avc_encoder_context *)pak_context->private_enc_ctx;
10742 struct generic_enc_codec_state * generic_state = (struct generic_enc_codec_state *)pak_context->generic_enc_state;
10743 struct avc_enc_state * avc_state = (struct avc_enc_state *)pak_context->private_enc_state;
10744
10745 struct object_surface *obj_surface;
10746 VAEncPictureParameterBufferH264 *pic_param;
10747 VAEncSliceParameterBufferH264 *slice_param;
10748
10749 struct gen9_surface_avc *avc_priv_surface;
10750 struct avc_surface_param surface_param;
10751 int i, j, enable_avc_ildb = 0;
10752 unsigned int allocate_flag = 1;
10753 unsigned int size, w_mb, h_mb;
10754
10755 if (encoder_context->fei_function_mode == VA_FEI_FUNCTION_PAK) {
10756 va_status = gen9_avc_fei_pak_pipeline_prepare(ctx, profile, encode_state, encoder_context);
10757 if (va_status != VA_STATUS_SUCCESS)
10758 return va_status;
10759 }
10760
10761 pic_param = avc_state->pic_param;
10762 slice_param = avc_state->slice_param[0];
10763 w_mb = generic_state->frame_width_in_mbs;
10764 h_mb = generic_state->frame_height_in_mbs;
10765
10766 /* update the parameter and check slice parameter */
10767 for (j = 0; j < encode_state->num_slice_params_ext && enable_avc_ildb == 0; j++) {
10768 assert(encode_state->slice_params_ext && encode_state->slice_params_ext[j]->buffer);
10769 slice_param = (VAEncSliceParameterBufferH264 *)encode_state->slice_params_ext[j]->buffer;
10770
10771 for (i = 0; i < encode_state->slice_params_ext[j]->num_elements; i++) {
10772 assert((slice_param->slice_type == SLICE_TYPE_I) ||
10773 (slice_param->slice_type == SLICE_TYPE_SI) ||
10774 (slice_param->slice_type == SLICE_TYPE_P) ||
10775 (slice_param->slice_type == SLICE_TYPE_SP) ||
10776 (slice_param->slice_type == SLICE_TYPE_B));
10777
10778 if (slice_param->disable_deblocking_filter_idc != 1) {
10779 enable_avc_ildb = 1;
10780 break;
10781 }
10782
10783 slice_param++;
10784 }
10785 }
10786 avc_state->enable_avc_ildb = enable_avc_ildb;
10787
10788 /* setup the all surface and buffer for PAK */
10789 /* Setup current reconstruct frame */
10790 obj_surface = encode_state->reconstructed_object;
10791 va_status = i965_check_alloc_surface_bo(ctx, obj_surface, 1, VA_FOURCC_NV12, SUBSAMPLE_YUV420);
10792
10793 if (va_status != VA_STATUS_SUCCESS)
10794 return va_status;
10795
10796 memset(&surface_param, 0, sizeof(surface_param));
10797 surface_param.frame_width = generic_state->frame_width_in_pixel;
10798 surface_param.frame_height = generic_state->frame_height_in_pixel;
10799 va_status = gen9_avc_init_check_surfaces(ctx,
10800 obj_surface, encoder_context,
10801 &surface_param);
10802 if (va_status != VA_STATUS_SUCCESS)
10803 return va_status;
10804 /* init the member of avc_priv_surface,frame_store_id,qp_value */
10805 {
10806 avc_priv_surface = (struct gen9_surface_avc *)obj_surface->private_data;
10807 avc_state->top_field_poc[NUM_MFC_AVC_DMV_BUFFERS - 2] = 0;
10808 avc_state->top_field_poc[NUM_MFC_AVC_DMV_BUFFERS - 1] = 0;
10809 i965_free_gpe_resource(&avc_ctx->res_direct_mv_buffersr[NUM_MFC_AVC_DMV_BUFFERS - 2]);
10810 i965_free_gpe_resource(&avc_ctx->res_direct_mv_buffersr[NUM_MFC_AVC_DMV_BUFFERS - 1]);
10811 i965_dri_object_to_buffer_gpe_resource(&avc_ctx->res_direct_mv_buffersr[NUM_MFC_AVC_DMV_BUFFERS - 2], avc_priv_surface->dmv_top);
10812 i965_dri_object_to_buffer_gpe_resource(&avc_ctx->res_direct_mv_buffersr[NUM_MFC_AVC_DMV_BUFFERS - 1], avc_priv_surface->dmv_bottom);
10813 avc_priv_surface->qp_value = pic_param->pic_init_qp + slice_param->slice_qp_delta;
10814 avc_priv_surface->frame_store_id = 0;
10815 avc_priv_surface->frame_idx = pic_param->CurrPic.frame_idx;
10816 avc_priv_surface->top_field_order_cnt = pic_param->CurrPic.TopFieldOrderCnt;
10817 avc_priv_surface->is_as_ref = pic_param->pic_fields.bits.reference_pic_flag;
10818 avc_state->top_field_poc[NUM_MFC_AVC_DMV_BUFFERS - 2] = avc_priv_surface->top_field_order_cnt;
10819 avc_state->top_field_poc[NUM_MFC_AVC_DMV_BUFFERS - 1] = avc_priv_surface->top_field_order_cnt + 1;
10820 }
10821 i965_free_gpe_resource(&generic_ctx->res_reconstructed_surface);
10822 i965_free_gpe_resource(&avc_ctx->res_post_deblocking_output);
10823 i965_free_gpe_resource(&avc_ctx->res_pre_deblocking_output);
10824 i965_object_surface_to_2d_gpe_resource_with_align(&generic_ctx->res_reconstructed_surface, obj_surface, GPE_RESOURCE_ALIGNMENT);
10825
10826
10827 if (avc_state->enable_avc_ildb) {
10828 i965_object_surface_to_2d_gpe_resource_with_align(&avc_ctx->res_post_deblocking_output, obj_surface, GPE_RESOURCE_ALIGNMENT);
10829 } else {
10830 i965_object_surface_to_2d_gpe_resource_with_align(&avc_ctx->res_pre_deblocking_output, obj_surface, GPE_RESOURCE_ALIGNMENT);
10831 }
10832 /* input YUV surface */
10833 obj_surface = encode_state->input_yuv_object;
10834 va_status = i965_check_alloc_surface_bo(ctx, obj_surface, 1, VA_FOURCC_NV12, SUBSAMPLE_YUV420);
10835
10836 if (va_status != VA_STATUS_SUCCESS)
10837 return va_status;
10838 i965_free_gpe_resource(&generic_ctx->res_uncompressed_input_surface);
10839 i965_object_surface_to_2d_gpe_resource_with_align(&generic_ctx->res_uncompressed_input_surface, obj_surface, GPE_RESOURCE_ALIGNMENT);
10840
10841 /* Reference surfaces */
10842 for (i = 0; i < ARRAY_ELEMS(avc_ctx->list_reference_res); i++) {
10843 i965_free_gpe_resource(&avc_ctx->list_reference_res[i]);
10844 i965_free_gpe_resource(&avc_ctx->res_direct_mv_buffersr[i * 2]);
10845 i965_free_gpe_resource(&avc_ctx->res_direct_mv_buffersr[i * 2 + 1]);
10846 obj_surface = encode_state->reference_objects[i];
10847 avc_state->top_field_poc[2 * i] = 0;
10848 avc_state->top_field_poc[2 * i + 1] = 0;
10849
10850 if (obj_surface && obj_surface->bo) {
10851 i965_object_surface_to_2d_gpe_resource_with_align(&avc_ctx->list_reference_res[i], obj_surface, GPE_RESOURCE_ALIGNMENT);
10852
10853 /* actually it should be handled when it is reconstructed surface */
10854 va_status = gen9_avc_init_check_surfaces(ctx,
10855 obj_surface, encoder_context,
10856 &surface_param);
10857 if (va_status != VA_STATUS_SUCCESS)
10858 return va_status;
10859 avc_priv_surface = (struct gen9_surface_avc *)obj_surface->private_data;
10860 i965_dri_object_to_buffer_gpe_resource(&avc_ctx->res_direct_mv_buffersr[i * 2], avc_priv_surface->dmv_top);
10861 i965_dri_object_to_buffer_gpe_resource(&avc_ctx->res_direct_mv_buffersr[i * 2 + 1], avc_priv_surface->dmv_bottom);
10862 avc_priv_surface->frame_store_id = i;
10863 avc_state->top_field_poc[2 * i] = avc_priv_surface->top_field_order_cnt;
10864 avc_state->top_field_poc[2 * i + 1] = avc_priv_surface->top_field_order_cnt + 1;
10865 } else {
10866 break;
10867 }
10868 }
10869
10870 if (avc_ctx->pres_slice_batch_buffer_2nd_level) {
10871 intel_batchbuffer_free(avc_ctx->pres_slice_batch_buffer_2nd_level);
10872 avc_ctx->pres_slice_batch_buffer_2nd_level = NULL;
10873 }
10874
10875 avc_ctx->pres_slice_batch_buffer_2nd_level =
10876 intel_batchbuffer_new(&i965->intel, I915_EXEC_BSD,
10877 4096 *
10878 encode_state->num_slice_params_ext);
10879 if (!avc_ctx->pres_slice_batch_buffer_2nd_level)
10880 return VA_STATUS_ERROR_ALLOCATION_FAILED;
10881
10882 for (i = 0; i < MAX_AVC_SLICE_NUM; i++) {
10883 avc_state->slice_batch_offset[i] = 0;
10884 }
10885
10886
10887 size = w_mb * 64;
10888 i965_free_gpe_resource(&avc_ctx->res_intra_row_store_scratch_buffer);
10889 allocate_flag = i965_allocate_gpe_resource(i965->intel.bufmgr,
10890 &avc_ctx->res_intra_row_store_scratch_buffer,
10891 size,
10892 "PAK Intra row store scratch buffer");
10893 if (!allocate_flag)
10894 goto failed_allocation;
10895
10896 size = w_mb * 4 * 64;
10897 i965_free_gpe_resource(&avc_ctx->res_deblocking_filter_row_store_scratch_buffer);
10898 allocate_flag = i965_allocate_gpe_resource(i965->intel.bufmgr,
10899 &avc_ctx->res_deblocking_filter_row_store_scratch_buffer,
10900 size,
10901 "PAK Deblocking filter row store scratch buffer");
10902 if (!allocate_flag)
10903 goto failed_allocation;
10904
10905 size = w_mb * 2 * 64;
10906 i965_free_gpe_resource(&avc_ctx->res_bsd_mpc_row_store_scratch_buffer);
10907 allocate_flag = i965_allocate_gpe_resource(i965->intel.bufmgr,
10908 &avc_ctx->res_bsd_mpc_row_store_scratch_buffer,
10909 size,
10910 "PAK BSD/MPC row store scratch buffer");
10911 if (!allocate_flag)
10912 goto failed_allocation;
10913
10914 size = w_mb * h_mb * 16;
10915 i965_free_gpe_resource(&avc_ctx->res_pak_mb_status_buffer);
10916 allocate_flag = i965_allocate_gpe_resource(i965->intel.bufmgr,
10917 &avc_ctx->res_pak_mb_status_buffer,
10918 size,
10919 "PAK MB status buffer");
10920 if (!allocate_flag)
10921 goto failed_allocation;
10922
10923 return VA_STATUS_SUCCESS;
10924
10925 failed_allocation:
10926 return VA_STATUS_ERROR_ALLOCATION_FAILED;
10927 }
10928
10929 static VAStatus
10930 gen9_avc_encode_picture(VADriverContextP ctx,
10931 VAProfile profile,
10932 struct encode_state *encode_state,
10933 struct intel_encoder_context *encoder_context)
10934 {
10935 VAStatus va_status;
10936 struct i965_driver_data *i965 = i965_driver_data(ctx);
10937 struct i965_gpe_table *gpe = &i965->gpe_table;
10938 struct encoder_vme_mfc_context * vme_context = (struct encoder_vme_mfc_context *)encoder_context->vme_context;
10939 struct i965_avc_encoder_context * avc_ctx = (struct i965_avc_encoder_context *)vme_context->private_enc_ctx;
10940 struct generic_enc_codec_state * generic_state = (struct generic_enc_codec_state *)vme_context->generic_enc_state;
10941 struct intel_batchbuffer *batch = encoder_context->base.batch;
10942
10943 va_status = gen9_avc_pak_pipeline_prepare(ctx, profile, encode_state, encoder_context);
10944
10945 if (va_status != VA_STATUS_SUCCESS)
10946 return va_status;
10947
10948 if (i965->intel.has_bsd2)
10949 intel_batchbuffer_start_atomic_bcs_override(batch, 0x1000, BSD_RING0);
10950 else
10951 intel_batchbuffer_start_atomic_bcs(batch, 0x1000);
10952 intel_batchbuffer_emit_mi_flush(batch);
10953 for (generic_state->curr_pak_pass = 0;
10954 generic_state->curr_pak_pass < generic_state->num_pak_passes;
10955 generic_state->curr_pak_pass++) {
10956
10957 if (generic_state->curr_pak_pass == 0) {
10958 /* Initialize the avc Image Ctrl reg for the first pass,write 0 to staturs/control register, is it needed in AVC? */
10959 struct gpe_mi_load_register_imm_parameter mi_load_reg_imm;
10960 struct encoder_status_buffer_internal *status_buffer;
10961
10962 status_buffer = &(avc_ctx->status_buffer);
10963 memset(&mi_load_reg_imm, 0, sizeof(mi_load_reg_imm));
10964 mi_load_reg_imm.mmio_offset = status_buffer->image_status_ctrl_reg_offset;
10965 mi_load_reg_imm.data = 0;
10966 gpe->mi_load_register_imm(ctx, batch, &mi_load_reg_imm);
10967 }
10968 gen9_avc_pak_picture_level(ctx, encode_state, encoder_context);
10969 gen9_avc_pak_slice_level(ctx, encode_state, encoder_context);
10970 gen9_avc_read_mfc_status(ctx, encoder_context);
10971 }
10972
10973 if (avc_ctx->pres_slice_batch_buffer_2nd_level) {
10974 intel_batchbuffer_free(avc_ctx->pres_slice_batch_buffer_2nd_level);
10975 avc_ctx->pres_slice_batch_buffer_2nd_level = NULL;
10976 }
10977
10978 intel_batchbuffer_end_atomic(batch);
10979 intel_batchbuffer_flush(batch);
10980
10981 generic_state->seq_frame_number++;
10982 generic_state->total_frame_number++;
10983 generic_state->first_frame = 0;
10984 return VA_STATUS_SUCCESS;
10985 }
10986
10987 static VAStatus
10988 gen9_avc_pak_pipeline(VADriverContextP ctx,
10989 VAProfile profile,
10990 struct encode_state *encode_state,
10991 struct intel_encoder_context *encoder_context)
10992 {
10993 VAStatus vaStatus;
10994
10995 switch (profile) {
10996 case VAProfileH264ConstrainedBaseline:
10997 case VAProfileH264Main:
10998 case VAProfileH264High:
10999 case VAProfileH264MultiviewHigh:
11000 case VAProfileH264StereoHigh:
11001 vaStatus = gen9_avc_encode_picture(ctx, profile, encode_state, encoder_context);
11002 break;
11003
11004 default:
11005 vaStatus = VA_STATUS_ERROR_UNSUPPORTED_PROFILE;
11006 break;
11007 }
11008
11009 return vaStatus;
11010 }
11011
11012 static void
11013 gen9_avc_pak_context_destroy(void * context)
11014 {
11015 struct encoder_vme_mfc_context * pak_context = (struct encoder_vme_mfc_context *)context;
11016 struct generic_encoder_context * generic_ctx;
11017 struct i965_avc_encoder_context * avc_ctx;
11018 int i = 0;
11019
11020 if (!pak_context)
11021 return;
11022
11023 generic_ctx = (struct generic_encoder_context *)pak_context->generic_enc_ctx;
11024 avc_ctx = (struct i965_avc_encoder_context *)pak_context->private_enc_ctx;
11025
11026 // other things
11027 i965_free_gpe_resource(&generic_ctx->res_reconstructed_surface);
11028 i965_free_gpe_resource(&avc_ctx->res_post_deblocking_output);
11029 i965_free_gpe_resource(&avc_ctx->res_pre_deblocking_output);
11030 i965_free_gpe_resource(&generic_ctx->res_uncompressed_input_surface);
11031
11032 i965_free_gpe_resource(&generic_ctx->compressed_bitstream.res);
11033 i965_free_gpe_resource(&avc_ctx->res_intra_row_store_scratch_buffer);
11034 i965_free_gpe_resource(&avc_ctx->res_deblocking_filter_row_store_scratch_buffer);
11035 i965_free_gpe_resource(&avc_ctx->res_bsd_mpc_row_store_scratch_buffer);
11036 i965_free_gpe_resource(&avc_ctx->res_pak_mb_status_buffer);
11037
11038 for (i = 0 ; i < MAX_MFC_AVC_REFERENCE_SURFACES; i++) {
11039 i965_free_gpe_resource(&avc_ctx->list_reference_res[i]);
11040 }
11041
11042 for (i = 0 ; i < NUM_MFC_AVC_DMV_BUFFERS; i++) {
11043 i965_free_gpe_resource(&avc_ctx->res_direct_mv_buffersr[i]);
11044 }
11045
11046 if (avc_ctx->pres_slice_batch_buffer_2nd_level) {
11047 intel_batchbuffer_free(avc_ctx->pres_slice_batch_buffer_2nd_level);
11048 avc_ctx->pres_slice_batch_buffer_2nd_level = NULL;
11049 }
11050
11051 }
11052
11053 static VAStatus
11054 gen9_avc_get_coded_status(VADriverContextP ctx,
11055 struct intel_encoder_context *encoder_context,
11056 struct i965_coded_buffer_segment *coded_buf_seg)
11057 {
11058 struct encoder_status *avc_encode_status;
11059
11060 if (!encoder_context || !coded_buf_seg)
11061 return VA_STATUS_ERROR_INVALID_BUFFER;
11062
11063 avc_encode_status = (struct encoder_status *)coded_buf_seg->codec_private_data;
11064 coded_buf_seg->base.size = avc_encode_status->bs_byte_count_frame;
11065
11066 return VA_STATUS_SUCCESS;
11067 }
11068
11069 Bool
11070 gen9_avc_vme_context_init(VADriverContextP ctx, struct intel_encoder_context *encoder_context)
11071 {
11072 /* VME & PAK share the same context */
11073 struct i965_driver_data *i965 = i965_driver_data(ctx);
11074 struct encoder_vme_mfc_context * vme_context = NULL;
11075 struct generic_encoder_context * generic_ctx = NULL;
11076 struct i965_avc_encoder_context * avc_ctx = NULL;
11077 struct generic_enc_codec_state * generic_state = NULL;
11078 struct avc_enc_state * avc_state = NULL;
11079 struct encoder_status_buffer_internal *status_buffer;
11080 uint32_t base_offset = offsetof(struct i965_coded_buffer_segment, codec_private_data);
11081
11082 vme_context = calloc(1, sizeof(struct encoder_vme_mfc_context));
11083 generic_ctx = calloc(1, sizeof(struct generic_encoder_context));
11084 avc_ctx = calloc(1, sizeof(struct i965_avc_encoder_context));
11085 generic_state = calloc(1, sizeof(struct generic_enc_codec_state));
11086 avc_state = calloc(1, sizeof(struct avc_enc_state));
11087
11088 if (!vme_context || !generic_ctx || !avc_ctx || !generic_state || !avc_state)
11089 goto allocate_structure_failed;
11090
11091 memset(vme_context, 0, sizeof(struct encoder_vme_mfc_context));
11092 memset(generic_ctx, 0, sizeof(struct generic_encoder_context));
11093 memset(avc_ctx, 0, sizeof(struct i965_avc_encoder_context));
11094 memset(generic_state, 0, sizeof(struct generic_enc_codec_state));
11095 memset(avc_state, 0, sizeof(struct avc_enc_state));
11096
11097 encoder_context->vme_context = vme_context;
11098 vme_context->generic_enc_ctx = generic_ctx;
11099 vme_context->private_enc_ctx = avc_ctx;
11100 vme_context->generic_enc_state = generic_state;
11101 vme_context->private_enc_state = avc_state;
11102
11103 if (IS_SKL(i965->intel.device_info) ||
11104 IS_BXT(i965->intel.device_info)) {
11105 if (!encoder_context->fei_enabled && !encoder_context->preenc_enabled) {
11106 generic_ctx->enc_kernel_ptr = (void *)skl_avc_encoder_kernels;
11107 generic_ctx->enc_kernel_size = sizeof(skl_avc_encoder_kernels);
11108 } else {
11109 /* FEI and PreEnc operation kernels are included in
11110 * the monolithic kernel binary */
11111 generic_ctx->enc_kernel_ptr = (void *)skl_avc_fei_encoder_kernels;
11112 generic_ctx->enc_kernel_size = sizeof(skl_avc_fei_encoder_kernels);
11113 }
11114 } else if (IS_GEN8(i965->intel.device_info)) {
11115 generic_ctx->enc_kernel_ptr = (void *)bdw_avc_encoder_kernels;
11116 generic_ctx->enc_kernel_size = sizeof(bdw_avc_encoder_kernels);
11117 } else if (IS_KBL(i965->intel.device_info) ||
11118 IS_GLK(i965->intel.device_info)) {
11119 generic_ctx->enc_kernel_ptr = (void *)kbl_avc_encoder_kernels;
11120 generic_ctx->enc_kernel_size = sizeof(kbl_avc_encoder_kernels);
11121 } else if (IS_GEN10(i965->intel.device_info)) {
11122 generic_ctx->enc_kernel_ptr = (void *)cnl_avc_encoder_kernels;
11123 generic_ctx->enc_kernel_size = sizeof(cnl_avc_encoder_kernels);
11124 } else
11125 goto allocate_structure_failed;
11126
11127 /* initialize misc ? */
11128 avc_ctx->ctx = ctx;
11129 generic_ctx->use_hw_scoreboard = 1;
11130 generic_ctx->use_hw_non_stalling_scoreboard = 1;
11131
11132 /* initialize generic state */
11133
11134 generic_state->kernel_mode = INTEL_ENC_KERNEL_NORMAL;
11135 generic_state->preset = INTEL_PRESET_RT_SPEED;
11136 generic_state->seq_frame_number = 0;
11137 generic_state->total_frame_number = 0;
11138 generic_state->frame_type = 0;
11139 generic_state->first_frame = 1;
11140
11141 generic_state->frame_width_in_pixel = 0;
11142 generic_state->frame_height_in_pixel = 0;
11143 generic_state->frame_width_in_mbs = 0;
11144 generic_state->frame_height_in_mbs = 0;
11145 generic_state->frame_width_4x = 0;
11146 generic_state->frame_height_4x = 0;
11147 generic_state->frame_width_16x = 0;
11148 generic_state->frame_height_16x = 0;
11149 generic_state->frame_width_32x = 0;
11150 generic_state->downscaled_width_4x_in_mb = 0;
11151 generic_state->downscaled_height_4x_in_mb = 0;
11152 generic_state->downscaled_width_16x_in_mb = 0;
11153 generic_state->downscaled_height_16x_in_mb = 0;
11154 generic_state->downscaled_width_32x_in_mb = 0;
11155 generic_state->downscaled_height_32x_in_mb = 0;
11156
11157 generic_state->hme_supported = 1;
11158 generic_state->b16xme_supported = 1;
11159 generic_state->b32xme_supported = 0;
11160 generic_state->hme_enabled = 0;
11161 generic_state->b16xme_enabled = 0;
11162 generic_state->b32xme_enabled = 0;
11163
11164 if (encoder_context->fei_enabled) {
11165 /* Disabling HME in FEI encode */
11166 generic_state->hme_supported = 0;
11167 generic_state->b16xme_supported = 0;
11168 } else if (encoder_context->preenc_enabled) {
11169 /* Disabling 16x16ME in PreEnc */
11170 generic_state->b16xme_supported = 0;
11171 }
11172
11173 generic_state->brc_distortion_buffer_supported = 1;
11174 generic_state->brc_constant_buffer_supported = 0;
11175
11176 generic_state->frame_rate = 30;
11177 generic_state->brc_allocated = 0;
11178 generic_state->brc_inited = 0;
11179 generic_state->brc_need_reset = 0;
11180 generic_state->is_low_delay = 0;
11181 generic_state->brc_enabled = 0;//default
11182 generic_state->internal_rate_mode = 0;
11183 generic_state->curr_pak_pass = 0;
11184 generic_state->num_pak_passes = MAX_AVC_PAK_PASS_NUM;
11185 generic_state->is_first_pass = 1;
11186 generic_state->is_last_pass = 0;
11187 generic_state->mb_brc_enabled = 0; // enable mb brc
11188 generic_state->brc_roi_enable = 0;
11189 generic_state->brc_dirty_roi_enable = 0;
11190 generic_state->skip_frame_enbale = 0;
11191
11192 generic_state->target_bit_rate = 0;
11193 generic_state->max_bit_rate = 0;
11194 generic_state->min_bit_rate = 0;
11195 generic_state->init_vbv_buffer_fullness_in_bit = 0;
11196 generic_state->vbv_buffer_size_in_bit = 0;
11197 generic_state->frames_per_100s = 0;
11198 generic_state->gop_size = 0;
11199 generic_state->gop_ref_distance = 0;
11200 generic_state->brc_target_size = 0;
11201 generic_state->brc_mode = 0;
11202 generic_state->brc_init_current_target_buf_full_in_bits = 0.0;
11203 generic_state->brc_init_reset_input_bits_per_frame = 0.0;
11204 generic_state->brc_init_reset_buf_size_in_bits = 0;
11205 generic_state->brc_init_previous_target_buf_full_in_bits = 0;
11206 generic_state->frames_per_window_size = 0;//default
11207 generic_state->target_percentage = 0;
11208
11209 generic_state->avbr_curracy = 0;
11210 generic_state->avbr_convergence = 0;
11211
11212 generic_state->num_skip_frames = 0;
11213 generic_state->size_skip_frames = 0;
11214
11215 generic_state->num_roi = 0;
11216 generic_state->max_delta_qp = 0;
11217 generic_state->min_delta_qp = 0;
11218
11219 if (encoder_context->rate_control_mode != VA_RC_NONE &&
11220 encoder_context->rate_control_mode != VA_RC_CQP) {
11221 generic_state->brc_enabled = 1;
11222 generic_state->brc_distortion_buffer_supported = 1;
11223 generic_state->brc_constant_buffer_supported = 1;
11224 generic_state->num_pak_passes = MAX_AVC_PAK_PASS_NUM;
11225 }
11226 /*avc state initialization */
11227 avc_state->mad_enable = 0;
11228 avc_state->mb_disable_skip_map_enable = 0;
11229 avc_state->sfd_enable = 1;//default
11230 avc_state->sfd_mb_enable = 1;//set it true
11231 avc_state->adaptive_search_window_enable = 1;//default
11232 avc_state->mb_qp_data_enable = 0;
11233 avc_state->intra_refresh_i_enable = 0;
11234 avc_state->min_max_qp_enable = 0;
11235 avc_state->skip_bias_adjustment_enable = 0;//default,same as skip_bias_adjustment_supporte? no
11236
11237 //external input
11238 avc_state->non_ftq_skip_threshold_lut_input_enable = 0;
11239 avc_state->ftq_skip_threshold_lut_input_enable = 0;
11240 avc_state->ftq_override = 0;
11241
11242 avc_state->direct_bias_adjustment_enable = 0;
11243 avc_state->global_motion_bias_adjustment_enable = 0;
11244 avc_state->disable_sub_mb_partion = 0;
11245 avc_state->arbitrary_num_mbs_in_slice = 0;
11246 avc_state->adaptive_transform_decision_enable = 0;//default
11247 avc_state->skip_check_disable = 0;
11248 avc_state->tq_enable = 0;
11249 avc_state->enable_avc_ildb = 0;
11250 avc_state->mbaff_flag = 0;
11251 avc_state->enable_force_skip = 1;//default
11252 avc_state->rc_panic_enable = 1;//default
11253 avc_state->suppress_recon_enable = 1;//default
11254
11255 avc_state->ref_pic_select_list_supported = 1;
11256 avc_state->mb_brc_supported = 1;//?,default
11257 avc_state->multi_pre_enable = 1;//default
11258 avc_state->ftq_enable = 1;//default
11259 avc_state->caf_supported = 1; //default
11260 avc_state->caf_enable = 0;
11261 avc_state->caf_disable_hd = 1;//default
11262 avc_state->skip_bias_adjustment_supported = 1;//default
11263
11264 avc_state->adaptive_intra_scaling_enable = 1;//default
11265 avc_state->old_mode_cost_enable = 0;//default
11266 avc_state->multi_ref_qp_enable = 1;//default
11267 avc_state->weighted_ref_l0_enable = 1;//default
11268 avc_state->weighted_ref_l1_enable = 1;//default
11269 avc_state->weighted_prediction_supported = 0;
11270 avc_state->brc_split_enable = 0;
11271 avc_state->slice_level_report_supported = 0;
11272
11273 avc_state->fbr_bypass_enable = 1;//default
11274 avc_state->field_scaling_output_interleaved = 0;
11275 avc_state->mb_variance_output_enable = 0;
11276 avc_state->mb_pixel_average_output_enable = 0;
11277 avc_state->rolling_intra_refresh_enable = 0;// same as intra_refresh_i_enable?
11278 avc_state->mbenc_curbe_set_in_brc_update = 0;
11279 avc_state->rounding_inter_enable = 1; //default
11280 avc_state->adaptive_rounding_inter_enable = 1;//default
11281
11282 avc_state->mbenc_i_frame_dist_in_use = 0;
11283 avc_state->mb_status_supported = 1; //set in intialization for gen9
11284 avc_state->mb_status_enable = 0;
11285 avc_state->mb_vproc_stats_enable = 0;
11286 avc_state->flatness_check_enable = 0;
11287 avc_state->flatness_check_supported = 1;//default
11288 avc_state->block_based_skip_enable = 0;
11289 avc_state->use_widi_mbenc_kernel = 0;
11290 avc_state->kernel_trellis_enable = 0;
11291 avc_state->generic_reserved = 0;
11292
11293 avc_state->rounding_value = 0;
11294 avc_state->rounding_inter_p = AVC_INVALID_ROUNDING_VALUE;//default
11295 avc_state->rounding_inter_b = AVC_INVALID_ROUNDING_VALUE; //default
11296 avc_state->rounding_inter_b_ref = AVC_INVALID_ROUNDING_VALUE; //default
11297 avc_state->min_qp_i = INTEL_AVC_MIN_QP;
11298 avc_state->min_qp_p = INTEL_AVC_MIN_QP;
11299 avc_state->min_qp_b = INTEL_AVC_MIN_QP;
11300 avc_state->max_qp_i = INTEL_AVC_MAX_QP;
11301 avc_state->max_qp_p = INTEL_AVC_MAX_QP;
11302 avc_state->max_qp_b = INTEL_AVC_MAX_QP;
11303
11304 memset(avc_state->non_ftq_skip_threshold_lut, 0, AVC_QP_MAX * sizeof(uint8_t));
11305 memset(avc_state->ftq_skip_threshold_lut, 0, AVC_QP_MAX * sizeof(uint8_t));
11306 memset(avc_state->lamda_value_lut, 0, AVC_QP_MAX * 2 * sizeof(uint32_t));
11307
11308 avc_state->intra_refresh_qp_threshold = 0;
11309 avc_state->trellis_flag = 0;
11310 avc_state->hme_mv_cost_scaling_factor = 0;
11311 avc_state->slice_height = 1;
11312 avc_state->slice_num = 1;
11313 memset(avc_state->dist_scale_factor_list0, 0, 32 * sizeof(uint32_t));
11314 avc_state->bi_weight = 0;
11315
11316 avc_state->lambda_table_enable = 0;
11317
11318 if (IS_GEN8(i965->intel.device_info)) {
11319 avc_state->brc_const_data_surface_width = 64;
11320 avc_state->brc_const_data_surface_height = 44;
11321 avc_state->mb_status_supported = 0;
11322 } else if (IS_SKL(i965->intel.device_info) ||
11323 IS_BXT(i965->intel.device_info)) {
11324 avc_state->brc_const_data_surface_width = 64;
11325 avc_state->brc_const_data_surface_height = 44;
11326 avc_state->brc_split_enable = 1;
11327 } else if (IS_KBL(i965->intel.device_info) ||
11328 IS_GEN10(i965->intel.device_info) ||
11329 IS_GLK(i965->intel.device_info)) {
11330 avc_state->brc_const_data_surface_width = 64;
11331 avc_state->brc_const_data_surface_height = 53;
11332 //gen95
11333 avc_state->decouple_mbenc_curbe_from_brc_enable = 1;
11334 avc_state->extended_mv_cost_range_enable = 0;
11335 avc_state->reserved_g95 = 0;
11336 avc_state->mbenc_brc_buffer_size = 128;
11337 avc_state->kernel_trellis_enable = 1;
11338 avc_state->lambda_table_enable = 1;
11339 avc_state->brc_split_enable = 1;
11340
11341 if (IS_GEN10(i965->intel.device_info))
11342 avc_state->adaptive_transform_decision_enable = 1;// CNL
11343 }
11344
11345 avc_state->num_refs[0] = 0;
11346 avc_state->num_refs[1] = 0;
11347 memset(avc_state->list_ref_idx, 0, 32 * 2 * sizeof(uint32_t));
11348 memset(avc_state->top_field_poc, 0, NUM_MFC_AVC_DMV_BUFFERS * sizeof(int32_t));
11349 avc_state->tq_rounding = 0;
11350 avc_state->zero_mv_threshold = 0;
11351 avc_state->slice_second_levle_batch_buffer_in_use = 0;
11352
11353 //1. seq/pic/slice
11354
11355 /* the definition of status buffer offset for Encoder */
11356
11357 status_buffer = &avc_ctx->status_buffer;
11358 memset(status_buffer, 0, sizeof(struct encoder_status_buffer_internal));
11359
11360 status_buffer->base_offset = base_offset;
11361 status_buffer->bs_byte_count_frame_offset = base_offset + offsetof(struct encoder_status, bs_byte_count_frame);
11362 status_buffer->bs_byte_count_frame_nh_offset = base_offset + offsetof(struct encoder_status, bs_byte_count_frame_nh);
11363 status_buffer->image_status_mask_offset = base_offset + offsetof(struct encoder_status, image_status_mask);
11364 status_buffer->image_status_ctrl_offset = base_offset + offsetof(struct encoder_status, image_status_ctrl);
11365 status_buffer->mfc_qp_status_count_offset = base_offset + offsetof(struct encoder_status, mfc_qp_status_count);
11366 status_buffer->media_index_offset = base_offset + offsetof(struct encoder_status, media_index);
11367
11368 status_buffer->status_buffer_size = sizeof(struct encoder_status);
11369 status_buffer->bs_byte_count_frame_reg_offset = MFC_BITSTREAM_BYTECOUNT_FRAME_REG;
11370 status_buffer->bs_byte_count_frame_nh_reg_offset = MFC_BITSTREAM_BYTECOUNT_SLICE_REG;
11371 status_buffer->image_status_mask_reg_offset = MFC_IMAGE_STATUS_MASK_REG;
11372 status_buffer->image_status_ctrl_reg_offset = MFC_IMAGE_STATUS_CTRL_REG;
11373 status_buffer->mfc_qp_status_count_reg_offset = MFC_QP_STATUS_COUNT_REG;
11374
11375 if (IS_GEN8(i965->intel.device_info)) {
11376 gen8_avc_kernel_init(ctx, encoder_context);
11377 } else {
11378 gen9_avc_kernel_init(ctx, encoder_context);
11379 }
11380 encoder_context->vme_context = vme_context;
11381 /* Handling PreEnc operations separately since it gives better
11382 * code readability, avoid possible vme operations mess-up */
11383 encoder_context->vme_pipeline =
11384 !encoder_context->preenc_enabled ? gen9_avc_vme_pipeline : gen9_avc_preenc_pipeline;
11385 encoder_context->vme_context_destroy = gen9_avc_vme_context_destroy;
11386
11387 return true;
11388
11389 allocate_structure_failed:
11390
11391 free(vme_context);
11392 free(generic_ctx);
11393 free(avc_ctx);
11394 free(generic_state);
11395 free(avc_state);
11396 return false;
11397 }
11398
11399 Bool
11400 gen9_avc_pak_context_init(VADriverContextP ctx, struct intel_encoder_context *encoder_context)
11401 {
11402 /* VME & PAK share the same context */
11403 struct encoder_vme_mfc_context * pak_context = (struct encoder_vme_mfc_context *)encoder_context->vme_context;
11404
11405 if (!pak_context)
11406 return false;
11407
11408 encoder_context->mfc_context = pak_context;
11409 encoder_context->mfc_context_destroy = gen9_avc_pak_context_destroy;
11410 encoder_context->mfc_pipeline = gen9_avc_pak_pipeline;
11411 encoder_context->mfc_brc_prepare = gen9_avc_pak_brc_prepare;
11412 encoder_context->get_status = gen9_avc_get_coded_status;
11413 return true;
11414 }