2
* Copyright � 2009 Intel Corporation
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:
12
* The above copyright notice and this permission notice (including the
13
* next paragraph) shall be included in all copies or substantial portions
16
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
17
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
18
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
19
* IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
20
* ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
21
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
22
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
25
* Xiang Haihao <haihao.xiang@intel.com>
26
* Zou Nan hai <nanhai.zou@intel.com>
35
#include "intel_batchbuffer.h"
36
#include "intel_driver.h"
37
#include "i965_defines.h"
38
#include "i965_drv_video.h"
39
#include "i965_decoder_utils.h"
41
#include "i965_media.h"
42
#include "i965_media_mpeg2.h"
44
#define SURFACE_TARGET 0
45
#define SURFACE_FORWARD 1
46
#define SURFACE_BACKWARD 2
47
#define SURFACE_BIDIRECT 3
51
FRAME_FRAME_PRED_FORWARD,
52
FRAME_FRAME_PRED_BACKWARD,
53
FRAME_FRAME_PRED_BIDIRECT,
54
FRAME_FIELD_PRED_FORWARD,
55
FRAME_FIELD_PRED_BACKWARD,
56
FRAME_FIELD_PRED_BIDIRECT,
76
const uint32_t idct_table[] = {
77
C4, C1, C2, C3, C4, C5, C6, C7, //g5
78
C4, C1, C2, C3, C4, C5, C6, C7,
79
C4, C3, C6,-C7,-C4,-C1,-C2,-C5,
80
C4, C3, C6,-C7,-C4,-C1,-C2,-C5,
81
C4, C5,-C6,-C1,-C4, C7, C2, C3,
82
C4, C5,-C6,-C1,-C4, C7, C2, C3,
83
C4, C7,-C2,-C5, C4, C3,-C6,-C1,
84
C4, C7,-C2,-C5, C4, C3,-C6,-C1,
85
C4,-C7,-C2, C5, C4,-C3,-C6, C1,
86
C4,-C7,-C2, C5, C4,-C3,-C6, C1,
87
C4,-C5,-C6, C1,-C4,-C7, C2,-C3,
88
C4,-C5,-C6, C1,-C4,-C7, C2,-C3,
89
C4,-C3, C6, C7,-C4, C1,-C2, C5,
90
C4,-C3, C6, C7,-C4, C1,-C2, C5,
91
C4,-C1, C2,-C3, C4,-C5, C6,-C7,
92
C4,-C1, C2,-C3, C4,-C5, C6,-C7 //g20
103
const uint32_t zigzag_direct[64] = {
104
0, 1, 8, 16, 9, 2, 3, 10,
105
17, 24, 32, 25, 18, 11, 4, 5,
106
12, 19, 26, 33, 40, 48, 41, 34,
107
27, 20, 13, 6, 7, 14, 21, 28,
108
35, 42, 49, 56, 57, 50, 43, 36,
109
29, 22, 15, 23, 30, 37, 44, 51,
110
58, 59, 52, 45, 38, 31, 39, 46,
111
53, 60, 61, 54, 47, 55, 62, 63
114
static const uint32_t frame_intra_kernel[][4] = {
115
#include "shaders/mpeg2/vld/frame_intra.g4b"
117
static const uint32_t frame_frame_pred_forward_kernel[][4] = {
118
#include "shaders/mpeg2/vld/frame_frame_pred_forward.g4b"
120
static const uint32_t frame_frame_pred_backward_kernel[][4] = {
121
#include "shaders/mpeg2/vld/frame_frame_pred_backward.g4b"
123
static const uint32_t frame_frame_pred_bidirect_kernel[][4] = {
124
#include "shaders/mpeg2/vld/frame_frame_pred_bidirect.g4b"
126
static const uint32_t frame_field_pred_forward_kernel[][4] = {
127
#include "shaders/mpeg2/vld/frame_field_pred_forward.g4b"
129
static const uint32_t frame_field_pred_backward_kernel[][4] = {
130
#include "shaders/mpeg2/vld/frame_field_pred_backward.g4b"
132
static const uint32_t frame_field_pred_bidirect_kernel[][4] = {
133
#include "shaders/mpeg2/vld/frame_field_pred_bidirect.g4b"
135
static const uint32_t lib_kernel[][4] = {
136
#include "shaders/mpeg2/vld/lib.g4b"
139
static const uint32_t field_intra_kernel[][4] = {
140
#include "shaders/mpeg2/vld/field_intra.g4b"
142
static const uint32_t field_forward_kernel[][4] = {
143
#include "shaders/mpeg2/vld/field_forward.g4b"
145
static const uint32_t field_forward_16x8_kernel[][4] = {
146
#include "shaders/mpeg2/vld/field_forward_16x8.g4b"
148
static const uint32_t field_backward_kernel[][4] = {
149
#include "shaders/mpeg2/vld/field_backward.g4b"
151
static const uint32_t field_backward_16x8_kernel[][4] = {
152
#include "shaders/mpeg2/vld/field_backward_16x8.g4b"
154
static const uint32_t field_bidirect_kernel[][4] = {
155
#include "shaders/mpeg2/vld/field_bidirect.g4b"
157
static const uint32_t field_bidirect_16x8_kernel[][4] = {
158
#include "shaders/mpeg2/vld/field_bidirect_16x8.g4b"
161
static struct i965_kernel mpeg2_vld_kernels_gen4[] = {
166
sizeof(frame_intra_kernel),
171
"FRAME_FRAME_PRED_FORWARD",
172
FRAME_FRAME_PRED_FORWARD,
173
frame_frame_pred_forward_kernel,
174
sizeof(frame_frame_pred_forward_kernel),
179
"FRAME_FRAME_PRED_BACKWARD",
180
FRAME_FRAME_PRED_BACKWARD,
181
frame_frame_pred_backward_kernel,
182
sizeof(frame_frame_pred_backward_kernel),
187
"FRAME_FRAME_PRED_BIDIRECT",
188
FRAME_FRAME_PRED_BIDIRECT,
189
frame_frame_pred_bidirect_kernel,
190
sizeof(frame_frame_pred_bidirect_kernel),
195
"FRAME_FIELD_PRED_FORWARD",
196
FRAME_FIELD_PRED_FORWARD,
197
frame_field_pred_forward_kernel,
198
sizeof(frame_field_pred_forward_kernel),
203
"FRAME_FIELD_PRED_BACKWARD",
204
FRAME_FIELD_PRED_BACKWARD,
205
frame_field_pred_backward_kernel,
206
sizeof(frame_field_pred_backward_kernel),
211
"FRAME_FIELD_PRED_BIDIRECT",
212
FRAME_FIELD_PRED_BIDIRECT,
213
frame_field_pred_bidirect_kernel,
214
sizeof(frame_field_pred_bidirect_kernel),
230
sizeof(field_intra_kernel),
237
field_forward_kernel,
238
sizeof(field_forward_kernel),
243
"FIELD_FORWARD_16X8",
245
field_forward_16x8_kernel,
246
sizeof(field_forward_16x8_kernel),
253
field_backward_kernel,
254
sizeof(field_backward_kernel),
259
"FIELD_BACKWARD_16X8",
261
field_backward_16x8_kernel,
262
sizeof(field_backward_16x8_kernel),
269
field_bidirect_kernel,
270
sizeof(field_bidirect_kernel),
275
"FIELD_BIDIRECT_16X8",
277
field_bidirect_16x8_kernel,
278
sizeof(field_bidirect_16x8_kernel),
284
static const uint32_t frame_intra_kernel_gen5[][4] = {
285
#include "shaders/mpeg2/vld/frame_intra.g4b.gen5"
287
static const uint32_t frame_frame_pred_forward_kernel_gen5[][4] = {
288
#include "shaders/mpeg2/vld/frame_frame_pred_forward.g4b.gen5"
290
static const uint32_t frame_frame_pred_backward_kernel_gen5[][4] = {
291
#include "shaders/mpeg2/vld/frame_frame_pred_backward.g4b.gen5"
293
static const uint32_t frame_frame_pred_bidirect_kernel_gen5[][4] = {
294
#include "shaders/mpeg2/vld/frame_frame_pred_bidirect.g4b.gen5"
296
static const uint32_t frame_field_pred_forward_kernel_gen5[][4] = {
297
#include "shaders/mpeg2/vld/frame_field_pred_forward.g4b.gen5"
299
static const uint32_t frame_field_pred_backward_kernel_gen5[][4] = {
300
#include "shaders/mpeg2/vld/frame_field_pred_backward.g4b.gen5"
302
static const uint32_t frame_field_pred_bidirect_kernel_gen5[][4] = {
303
#include "shaders/mpeg2/vld/frame_field_pred_bidirect.g4b.gen5"
305
static const uint32_t lib_kernel_gen5[][4] = {
306
#include "shaders/mpeg2/vld/lib.g4b.gen5"
309
static const uint32_t field_intra_kernel_gen5[][4] = {
310
#include "shaders/mpeg2/vld/field_intra.g4b.gen5"
312
static const uint32_t field_forward_kernel_gen5[][4] = {
313
#include "shaders/mpeg2/vld/field_forward.g4b.gen5"
315
static const uint32_t field_forward_16x8_kernel_gen5[][4] = {
316
#include "shaders/mpeg2/vld/field_forward_16x8.g4b.gen5"
318
static const uint32_t field_backward_kernel_gen5[][4] = {
319
#include "shaders/mpeg2/vld/field_backward.g4b.gen5"
321
static const uint32_t field_backward_16x8_kernel_gen5[][4] = {
322
#include "shaders/mpeg2/vld/field_backward_16x8.g4b.gen5"
324
static const uint32_t field_bidirect_kernel_gen5[][4] = {
325
#include "shaders/mpeg2/vld/field_bidirect.g4b.gen5"
327
static const uint32_t field_bidirect_16x8_kernel_gen5[][4] = {
328
#include "shaders/mpeg2/vld/field_bidirect_16x8.g4b.gen5"
331
static struct i965_kernel mpeg2_vld_kernels_gen5[] = {
335
frame_intra_kernel_gen5,
336
sizeof(frame_intra_kernel_gen5),
341
"FRAME_FRAME_PRED_FORWARD",
342
FRAME_FRAME_PRED_FORWARD,
343
frame_frame_pred_forward_kernel_gen5,
344
sizeof(frame_frame_pred_forward_kernel_gen5),
349
"FRAME_FRAME_PRED_BACKWARD",
350
FRAME_FRAME_PRED_BACKWARD,
351
frame_frame_pred_backward_kernel_gen5,
352
sizeof(frame_frame_pred_backward_kernel_gen5),
357
"FRAME_FRAME_PRED_BIDIRECT",
358
FRAME_FRAME_PRED_BIDIRECT,
359
frame_frame_pred_bidirect_kernel_gen5,
360
sizeof(frame_frame_pred_bidirect_kernel_gen5),
365
"FRAME_FIELD_PRED_FORWARD",
366
FRAME_FIELD_PRED_FORWARD,
367
frame_field_pred_forward_kernel_gen5,
368
sizeof(frame_field_pred_forward_kernel_gen5),
373
"FRAME_FIELD_PRED_BACKWARD",
374
FRAME_FIELD_PRED_BACKWARD,
375
frame_field_pred_backward_kernel_gen5,
376
sizeof(frame_field_pred_backward_kernel_gen5),
381
"FRAME_FIELD_PRED_BIDIRECT",
382
FRAME_FIELD_PRED_BIDIRECT,
383
frame_field_pred_bidirect_kernel_gen5,
384
sizeof(frame_field_pred_bidirect_kernel_gen5),
392
sizeof(lib_kernel_gen5),
399
field_intra_kernel_gen5,
400
sizeof(field_intra_kernel_gen5),
407
field_forward_kernel_gen5,
408
sizeof(field_forward_kernel_gen5),
413
"FIELD_FORWARD_16X8",
415
field_forward_16x8_kernel_gen5,
416
sizeof(field_forward_16x8_kernel_gen5),
423
field_backward_kernel_gen5,
424
sizeof(field_backward_kernel_gen5),
429
"FIELD_BACKWARD_16X8",
431
field_backward_16x8_kernel_gen5,
432
sizeof(field_backward_16x8_kernel_gen5),
439
field_bidirect_kernel_gen5,
440
sizeof(field_bidirect_kernel_gen5),
445
"FIELD_BIDIRECT_16X8",
447
field_bidirect_16x8_kernel_gen5,
448
sizeof(field_bidirect_16x8_kernel_gen5),
454
i965_media_mpeg2_surface_state(VADriverContextP ctx,
456
struct object_surface *obj_surface,
457
unsigned long offset,
460
int vert_line_stride,
461
int vert_line_stride_ofs,
462
struct i965_media_context *media_context)
464
struct i965_driver_data *i965 = i965_driver_data(ctx);
465
struct i965_surface_state *ss;
467
uint32_t write_domain, read_domain;
469
bo = dri_bo_alloc(i965->intel.bufmgr,
471
sizeof(struct i965_surface_state), 32);
476
memset(ss, 0, sizeof(*ss));
477
ss->ss0.surface_type = I965_SURFACE_2D;
478
ss->ss0.surface_format = I965_SURFACEFORMAT_R8_SINT;
479
ss->ss0.vert_line_stride = vert_line_stride;
480
ss->ss0.vert_line_stride_ofs = vert_line_stride_ofs;
481
ss->ss1.base_addr = obj_surface->bo->offset + offset;
482
ss->ss2.width = w - 1;
483
ss->ss2.height = h - 1;
484
ss->ss3.pitch = w - 1;
487
write_domain = I915_GEM_DOMAIN_RENDER;
488
read_domain = I915_GEM_DOMAIN_RENDER;
491
read_domain = I915_GEM_DOMAIN_SAMPLER;
494
dri_bo_emit_reloc(bo,
495
read_domain, write_domain,
497
offsetof(struct i965_surface_state, ss1),
501
assert(index < MAX_MEDIA_SURFACES);
502
// assert(media_context->surface_state[index].bo == NULL);
503
media_context->surface_state[index].bo = bo;
507
i965_media_mpeg2_surface_setup(VADriverContextP ctx,
509
struct object_surface *obj_surface,
511
int picture_structure,
513
struct i965_media_context *media_context)
515
int w = obj_surface->width;
516
int h = obj_surface->height;
518
i965_check_alloc_surface_bo(ctx, obj_surface, 0, VA_FOURCC_I420, SUBSAMPLE_YUV420);
520
if (picture_structure == MPEG_FRAME) {
521
i965_media_mpeg2_surface_state(ctx, base_index + 0, obj_surface,
525
i965_media_mpeg2_surface_state(ctx, base_index + 1, obj_surface,
529
i965_media_mpeg2_surface_state(ctx, base_index + 2, obj_surface,
530
w * h + w * h / 4, w / 2, h / 2,
534
if (surface == SURFACE_TARGET) {
535
i965_media_mpeg2_surface_state(ctx, 3, obj_surface,
539
i965_media_mpeg2_surface_state(ctx, 10, obj_surface,
543
i965_media_mpeg2_surface_state(ctx, 11, obj_surface,
544
w * h + w * h / 4, w / 2, h / 2,
547
if (picture_structure == MPEG_TOP_FIELD) {
548
i965_media_mpeg2_surface_state(ctx, base_index + 0, obj_surface,
552
i965_media_mpeg2_surface_state(ctx, base_index + 1, obj_surface,
556
i965_media_mpeg2_surface_state(ctx, base_index + 2, obj_surface,
557
w * h + w * h / 4, w / 2, h / 2,
561
assert(picture_structure == MPEG_BOTTOM_FIELD);
562
i965_media_mpeg2_surface_state(ctx, base_index + 0, obj_surface,
566
i965_media_mpeg2_surface_state(ctx, base_index + 1, obj_surface,
570
i965_media_mpeg2_surface_state(ctx, base_index + 2, obj_surface,
571
w * h + w * h / 4, w / 2, h / 2,
576
i965_media_mpeg2_surface_state(ctx, base_index + 0, obj_surface,
580
i965_media_mpeg2_surface_state(ctx, base_index + 1, obj_surface,
584
i965_media_mpeg2_surface_state(ctx, base_index + 2, obj_surface,
585
w * h + w * h / 4, w / 2, h / 2,
593
i965_media_mpeg2_surfaces_setup(VADriverContextP ctx,
594
struct decode_state *decode_state,
595
struct i965_media_context *media_context)
597
struct object_surface *obj_surface;
598
VAPictureParameterBufferMPEG2 *param;
600
assert(decode_state->pic_param && decode_state->pic_param->buffer);
601
param = (VAPictureParameterBufferMPEG2 *)decode_state->pic_param->buffer;
603
obj_surface = decode_state->render_object;
605
i965_media_mpeg2_surface_setup(ctx, 0, obj_surface, True,
606
param->picture_coding_extension.bits.picture_structure,
610
obj_surface = decode_state->reference_objects[0];
613
// assert(param->picture_coding_type == 1); /* I-picture */
615
i965_media_mpeg2_surface_setup(ctx, 4, obj_surface, False,
616
param->picture_coding_extension.bits.picture_structure,
620
obj_surface = decode_state->reference_objects[1];
623
assert(param->picture_coding_type == 2); /* P-picture */
625
obj_surface = decode_state->reference_objects[0];
626
i965_media_mpeg2_surface_setup(ctx, 7, obj_surface, False,
627
param->picture_coding_extension.bits.picture_structure,
631
assert(param->picture_coding_type == 3); /* B-picture */
632
i965_media_mpeg2_surface_setup(ctx, 7, obj_surface, False,
633
param->picture_coding_extension.bits.picture_structure,
641
i965_media_mpeg2_binding_table(VADriverContextP ctx, struct i965_media_context *media_context)
644
unsigned int *binding_table;
645
dri_bo *bo = media_context->binding_table.bo;
649
binding_table = bo->virtual;
650
memset(binding_table, 0, bo->size);
652
for (i = 0; i < MAX_MEDIA_SURFACES; i++) {
653
if (media_context->surface_state[i].bo) {
654
binding_table[i] = media_context->surface_state[i].bo->offset;
655
dri_bo_emit_reloc(bo,
656
I915_GEM_DOMAIN_INSTRUCTION, 0,
658
i * sizeof(*binding_table),
659
media_context->surface_state[i].bo);
663
dri_bo_unmap(media_context->binding_table.bo);
667
i965_media_mpeg2_vfe_state(VADriverContextP ctx, struct i965_media_context *media_context)
669
struct i965_vfe_state *vfe_state;
672
bo = media_context->vfe_state.bo;
675
vfe_state = bo->virtual;
676
memset(vfe_state, 0, sizeof(*vfe_state));
677
vfe_state->vfe0.extend_vfe_state_present = 1;
678
vfe_state->vfe1.vfe_mode = VFE_VLD_MODE;
679
vfe_state->vfe1.num_urb_entries = media_context->urb.num_vfe_entries;
680
vfe_state->vfe1.children_present = 0;
681
vfe_state->vfe1.urb_entry_alloc_size = media_context->urb.size_vfe_entry - 1;
682
vfe_state->vfe1.max_threads = media_context->urb.num_vfe_entries - 1;
683
vfe_state->vfe2.interface_descriptor_base =
684
media_context->idrt.bo->offset >> 4; /* reloc */
685
dri_bo_emit_reloc(bo,
686
I915_GEM_DOMAIN_INSTRUCTION, 0,
688
offsetof(struct i965_vfe_state, vfe2),
689
media_context->idrt.bo);
694
i965_media_mpeg2_interface_descriptor_remap_table(VADriverContextP ctx, struct i965_media_context *media_context)
696
struct i965_mpeg2_context *i965_mpeg2_context = (struct i965_mpeg2_context *)media_context->private_context;
697
struct i965_interface_descriptor *desc;
701
bo = media_context->idrt.bo;
706
for (i = 0; i < NUM_MPEG2_VLD_KERNELS; i++) {
707
memset(desc, 0, sizeof(*desc));
708
desc->desc0.grf_reg_blocks = 15;
709
desc->desc0.kernel_start_pointer = i965_mpeg2_context->vld_kernels[i].bo->offset >> 6; /* reloc */
710
desc->desc1.const_urb_entry_read_offset = 0;
711
desc->desc1.const_urb_entry_read_len = 30;
712
desc->desc3.binding_table_entry_count = 0;
713
desc->desc3.binding_table_pointer =
714
media_context->binding_table.bo->offset >> 5; /*reloc */
716
dri_bo_emit_reloc(bo,
717
I915_GEM_DOMAIN_INSTRUCTION, 0,
718
desc->desc0.grf_reg_blocks,
719
i * sizeof(*desc) + offsetof(struct i965_interface_descriptor, desc0),
720
i965_mpeg2_context->vld_kernels[i].bo);
722
dri_bo_emit_reloc(bo,
723
I915_GEM_DOMAIN_INSTRUCTION, 0,
724
desc->desc3.binding_table_entry_count,
725
i * sizeof(*desc) + offsetof(struct i965_interface_descriptor, desc3),
726
media_context->binding_table.bo);
734
i965_media_mpeg2_vld_state(VADriverContextP ctx,
735
struct decode_state *decode_state,
736
struct i965_media_context *media_context)
738
struct i965_vld_state *vld_state;
739
VAPictureParameterBufferMPEG2 *param;
741
assert(decode_state->pic_param && decode_state->pic_param->buffer);
742
param = (VAPictureParameterBufferMPEG2 *)decode_state->pic_param->buffer;
744
assert(media_context->extended_state.bo);
745
dri_bo_map(media_context->extended_state.bo, 1);
746
assert(media_context->extended_state.bo->virtual);
747
vld_state = media_context->extended_state.bo->virtual;
748
memset(vld_state, 0, sizeof(*vld_state));
750
vld_state->vld0.f_code_0_0 = ((param->f_code >> 12) & 0xf);
751
vld_state->vld0.f_code_0_1 = ((param->f_code >> 8) & 0xf);
752
vld_state->vld0.f_code_1_0 = ((param->f_code >> 4) & 0xf);
753
vld_state->vld0.f_code_1_1 = (param->f_code & 0xf);
754
vld_state->vld0.intra_dc_precision = param->picture_coding_extension.bits.intra_dc_precision;
755
vld_state->vld0.picture_structure = param->picture_coding_extension.bits.picture_structure;
756
vld_state->vld0.top_field_first = param->picture_coding_extension.bits.top_field_first;
757
vld_state->vld0.frame_predict_frame_dct = param->picture_coding_extension.bits.frame_pred_frame_dct;
758
vld_state->vld0.concealment_motion_vector = param->picture_coding_extension.bits.concealment_motion_vectors;
759
vld_state->vld0.quantizer_scale_type = param->picture_coding_extension.bits.q_scale_type;
760
vld_state->vld0.intra_vlc_format = param->picture_coding_extension.bits.intra_vlc_format;
761
vld_state->vld0.scan_order = param->picture_coding_extension.bits.alternate_scan;
763
vld_state->vld1.picture_coding_type = param->picture_coding_type;
765
if (vld_state->vld0.picture_structure == MPEG_FRAME) {
767
vld_state->desc_remap_table0.index_0 = FRAME_INTRA;
768
vld_state->desc_remap_table0.index_1 = FRAME_FRAME_PRED_FORWARD;
769
vld_state->desc_remap_table0.index_2 = FRAME_FIELD_PRED_FORWARD;
770
vld_state->desc_remap_table0.index_3 = FRAME_FIELD_PRED_BIDIRECT; /* dual prime */
771
vld_state->desc_remap_table0.index_4 = FRAME_FRAME_PRED_BACKWARD;
772
vld_state->desc_remap_table0.index_5 = FRAME_FIELD_PRED_BACKWARD;
773
vld_state->desc_remap_table0.index_6 = FRAME_FRAME_PRED_BIDIRECT;
774
vld_state->desc_remap_table0.index_7 = FRAME_FIELD_PRED_BIDIRECT;
776
vld_state->desc_remap_table1.index_8 = FRAME_INTRA;
777
vld_state->desc_remap_table1.index_9 = FRAME_FRAME_PRED_FORWARD;
778
vld_state->desc_remap_table1.index_10 = FRAME_FIELD_PRED_FORWARD;
779
vld_state->desc_remap_table1.index_11 = FRAME_FIELD_PRED_BIDIRECT;
780
vld_state->desc_remap_table1.index_12 = FRAME_FRAME_PRED_BACKWARD;
781
vld_state->desc_remap_table1.index_13 = FRAME_FIELD_PRED_BACKWARD;
782
vld_state->desc_remap_table1.index_14 = FRAME_FRAME_PRED_BIDIRECT;
783
vld_state->desc_remap_table1.index_15 = FRAME_FIELD_PRED_BIDIRECT;
786
vld_state->desc_remap_table0.index_0 = FIELD_INTRA;
787
vld_state->desc_remap_table0.index_1 = FIELD_FORWARD;
788
vld_state->desc_remap_table0.index_2 = FIELD_FORWARD_16X8;
789
vld_state->desc_remap_table0.index_3 = FIELD_BIDIRECT; /* dual prime */
790
vld_state->desc_remap_table0.index_4 = FIELD_BACKWARD;
791
vld_state->desc_remap_table0.index_5 = FIELD_BACKWARD_16X8;
792
vld_state->desc_remap_table0.index_6 = FIELD_BIDIRECT;
793
vld_state->desc_remap_table0.index_7 = FIELD_BIDIRECT_16X8;
796
dri_bo_unmap(media_context->extended_state.bo);
800
i965_media_mpeg2_upload_constants(VADriverContextP ctx,
801
struct decode_state *decode_state,
802
struct i965_media_context *media_context)
804
struct i965_mpeg2_context *i965_mpeg2_context = (struct i965_mpeg2_context *)media_context->private_context;
805
VAIQMatrixBufferMPEG2 * const gen_iq_matrix = &i965_mpeg2_context->iq_matrix;
807
unsigned char *constant_buffer;
808
unsigned int *lib_reloc;
809
int lib_reloc_offset = 0;
811
dri_bo_map(media_context->curbe.bo, 1);
812
assert(media_context->curbe.bo->virtual);
813
constant_buffer = media_context->curbe.bo->virtual;
816
if (decode_state->iq_matrix && decode_state->iq_matrix->buffer) {
817
VAIQMatrixBufferMPEG2 * const iq_matrix =
818
(VAIQMatrixBufferMPEG2 *)decode_state->iq_matrix->buffer;
820
gen_iq_matrix->load_intra_quantiser_matrix =
821
iq_matrix->load_intra_quantiser_matrix;
822
if (iq_matrix->load_intra_quantiser_matrix) {
823
for (i = 0; i < 64; i++)
824
gen_iq_matrix->intra_quantiser_matrix[zigzag_direct[i]] =
825
iq_matrix->intra_quantiser_matrix[i];
828
gen_iq_matrix->load_non_intra_quantiser_matrix =
829
iq_matrix->load_non_intra_quantiser_matrix;
830
if (iq_matrix->load_non_intra_quantiser_matrix) {
831
for (i = 0; i < 64; i++)
832
gen_iq_matrix->non_intra_quantiser_matrix[zigzag_direct[i]] =
833
iq_matrix->non_intra_quantiser_matrix[i];
836
/* no chroma quantisation matrices for 4:2:0 data */
839
if (gen_iq_matrix->load_intra_quantiser_matrix) {
840
unsigned char * const qm = constant_buffer;
841
memcpy(qm, gen_iq_matrix->intra_quantiser_matrix, 64);
844
if (gen_iq_matrix->load_non_intra_quantiser_matrix) {
845
unsigned char * const qm = constant_buffer + 64;
846
memcpy(qm, gen_iq_matrix->non_intra_quantiser_matrix, 64);
850
memcpy(constant_buffer + 128, idct_table, sizeof(idct_table));
853
lib_reloc_offset = 128 + sizeof(idct_table);
854
lib_reloc = (unsigned int *)(constant_buffer + lib_reloc_offset);
855
for (i = 0; i < 8; i++) {
856
lib_reloc[i] = i965_mpeg2_context->vld_kernels[LIB_INTERFACE].bo->offset;
857
dri_bo_emit_reloc(media_context->curbe.bo,
858
I915_GEM_DOMAIN_INSTRUCTION, 0,
860
lib_reloc_offset + i * sizeof(unsigned int),
861
i965_mpeg2_context->vld_kernels[LIB_INTERFACE].bo);
864
dri_bo_unmap(media_context->curbe.bo);
868
i965_media_mpeg2_states_setup(VADriverContextP ctx,
869
struct decode_state *decode_state,
870
struct i965_media_context *media_context)
872
i965_media_mpeg2_surfaces_setup(ctx, decode_state, media_context);
873
i965_media_mpeg2_binding_table(ctx, media_context);
874
i965_media_mpeg2_interface_descriptor_remap_table(ctx, media_context);
875
i965_media_mpeg2_vld_state(ctx, decode_state, media_context);
876
i965_media_mpeg2_vfe_state(ctx, media_context);
877
i965_media_mpeg2_upload_constants(ctx, decode_state, media_context);
881
i965_media_mpeg2_objects(VADriverContextP ctx,
882
struct decode_state *decode_state,
883
struct i965_media_context *media_context)
885
struct i965_mpeg2_context * const i965_mpeg2_context = media_context->private_context;
886
struct intel_batchbuffer *batch = media_context->base.batch;
887
VASliceParameterBufferMPEG2 *slice_param;
888
VAPictureParameterBufferMPEG2 *pic_param;
891
assert(decode_state->pic_param && decode_state->pic_param->buffer);
892
pic_param = (VAPictureParameterBufferMPEG2 *)decode_state->pic_param->buffer;
894
if (i965_mpeg2_context->wa_slice_vertical_position < 0)
895
i965_mpeg2_context->wa_slice_vertical_position =
896
mpeg2_wa_slice_vertical_position(decode_state, pic_param);
898
for (j = 0; j < decode_state->num_slice_params; j++) {
899
assert(decode_state->slice_params[j] && decode_state->slice_params[j]->buffer);
900
assert(decode_state->slice_datas[j] && decode_state->slice_datas[j]->bo);
901
slice_param = (VASliceParameterBufferMPEG2 *)decode_state->slice_params[j]->buffer;
903
for (i = 0; i < decode_state->slice_params[j]->num_elements; i++) {
904
int vpos, hpos, is_field_pic = 0;
906
if (i965_mpeg2_context->wa_slice_vertical_position > 0 &&
907
(pic_param->picture_coding_extension.bits.picture_structure == MPEG_TOP_FIELD ||
908
pic_param->picture_coding_extension.bits.picture_structure == MPEG_BOTTOM_FIELD))
911
assert(slice_param->slice_data_flag == VA_SLICE_DATA_FLAG_ALL);
912
vpos = slice_param->slice_vertical_position / (1 + is_field_pic);
913
hpos = slice_param->slice_horizontal_position;
915
BEGIN_BATCH(batch, 6);
916
OUT_BATCH(batch, CMD_MEDIA_OBJECT | 4);
918
OUT_BATCH(batch, slice_param->slice_data_size - (slice_param->macroblock_offset >> 3));
919
OUT_RELOC(batch, decode_state->slice_datas[j]->bo,
920
I915_GEM_DOMAIN_SAMPLER, 0,
921
slice_param->slice_data_offset + (slice_param->macroblock_offset >> 3));
926
(slice_param->macroblock_offset & 0x7)));
927
OUT_BATCH(batch, slice_param->quantiser_scale_code << 24);
928
ADVANCE_BATCH(batch);
935
i965_media_mpeg2_free_private_context(void **data)
937
struct i965_mpeg2_context *i965_mpeg2_context = *data;
940
if (i965_mpeg2_context == NULL)
943
for (i = 0; i < NUM_MPEG2_VLD_KERNELS; i++) {
944
struct i965_kernel *kernel = &i965_mpeg2_context->vld_kernels[i];
946
dri_bo_unreference(kernel->bo);
950
free(i965_mpeg2_context);
955
i965_media_mpeg2_decode_init(VADriverContextP ctx,
956
struct decode_state *decode_state,
957
struct i965_media_context *media_context)
959
struct i965_driver_data *i965 = i965_driver_data(ctx);
962
dri_bo_unreference(media_context->indirect_object.bo);
963
media_context->indirect_object.bo = NULL;
965
media_context->extended_state.enabled = 1;
966
dri_bo_unreference(media_context->extended_state.bo);
967
bo = dri_bo_alloc(i965->intel.bufmgr,
969
sizeof(struct i965_vld_state), 32);
971
media_context->extended_state.bo = bo;
975
i965_media_mpeg2_dec_context_init(VADriverContextP ctx, struct i965_media_context *media_context)
977
struct i965_driver_data *i965 = i965_driver_data(ctx);
978
struct i965_mpeg2_context *i965_mpeg2_context;
981
i965_mpeg2_context = calloc(1, sizeof(struct i965_mpeg2_context));
982
assert(i965_mpeg2_context);
983
i965_mpeg2_context->wa_slice_vertical_position = -1;
986
assert(NUM_MPEG2_VLD_KERNELS == (sizeof(mpeg2_vld_kernels_gen4) /
987
sizeof(mpeg2_vld_kernels_gen4[0])));
988
assert(NUM_MPEG2_VLD_KERNELS == (sizeof(mpeg2_vld_kernels_gen5) /
989
sizeof(mpeg2_vld_kernels_gen5[0])));
990
assert(NUM_MPEG2_VLD_KERNELS <= MAX_INTERFACE_DESC);
992
if (IS_IRONLAKE(i965->intel.device_info))
993
memcpy(i965_mpeg2_context->vld_kernels, mpeg2_vld_kernels_gen5, sizeof(i965_mpeg2_context->vld_kernels));
995
memcpy(i965_mpeg2_context->vld_kernels, mpeg2_vld_kernels_gen4, sizeof(i965_mpeg2_context->vld_kernels));
997
for (i = 0; i < NUM_MPEG2_VLD_KERNELS; i++) {
998
struct i965_kernel *kernel = &i965_mpeg2_context->vld_kernels[i];
999
kernel->bo = dri_bo_alloc(i965->intel.bufmgr,
1003
dri_bo_subdata(kernel->bo, 0, kernel->size, kernel->bin);
1007
media_context->urb.num_vfe_entries = 28;
1008
media_context->urb.size_vfe_entry = 13;
1010
media_context->urb.num_cs_entries = 1;
1011
media_context->urb.size_cs_entry = 16;
1013
media_context->urb.vfe_start = 0;
1014
media_context->urb.cs_start = media_context->urb.vfe_start +
1015
media_context->urb.num_vfe_entries * media_context->urb.size_vfe_entry;
1016
assert(media_context->urb.cs_start +
1017
media_context->urb.num_cs_entries * media_context->urb.size_cs_entry <= i965->intel.device_info->urb_size);
1019
/* hook functions */
1020
media_context->media_states_setup = i965_media_mpeg2_states_setup;
1021
media_context->media_objects = i965_media_mpeg2_objects;
1022
media_context->private_context = i965_mpeg2_context;
1023
media_context->free_private_context = i965_media_mpeg2_free_private_context;
added
removed
src/i965_media_mpeg2.c
