(pPicParameter->pic_fields.bits.entropy_coding_mode_flag << 7) | /*0:CAVLC encoding mode,1:CABAC*/
(0 << 6) | /*Only valid for VLD decoding mode*/
(0 << 5) | /*Constrained Intra Predition Flag, from PPS*/
- (pSequenceParameter->direct_8x8_inference_flag << 4) | /*Direct 8x8 inference flag*/
+ (pSequenceParameter->seq_fields.bits.direct_8x8_inference_flag << 4) | /*Direct 8x8 inference flag*/
(pPicParameter->pic_fields.bits.transform_8x8_mode_flag << 3) | /*8x8 or 4x4 IDCT Transform Mode Flag*/
(1 << 2) | /*Frame MB only flag*/
(0 << 1) | /*MBAFF mode is in active*/
VAEncSliceParameterBufferH264 *pSliceParameter = (VAEncSliceParameterBufferH264 *)encode_state->slice_params_ext[0]->buffer; /* TODO: multi slices support */
int width_in_mbs = (mfc_context->surface_state.width + 15) / 16;
int height_in_mbs = (mfc_context->surface_state.height + 15) / 16;
- int beginmb = pSliceParameter->starting_macroblock_address;
- int endmb = beginmb + pSliceParameter->number_of_mbs;
+ int beginmb = pSliceParameter->macroblock_address;
+ int endmb = beginmb + pSliceParameter->num_macroblocks;
int beginx = beginmb % width_in_mbs;
int beginy = beginmb / width_in_mbs;
int nextx = endmb % width_in_mbs;
int nexty = endmb / width_in_mbs;
- int last_slice = (pSliceParameter->starting_macroblock_address + pSliceParameter->number_of_mbs) == (width_in_mbs * height_in_mbs);
+ int last_slice = (pSliceParameter->macroblock_address + pSliceParameter->num_macroblocks) == (width_in_mbs * height_in_mbs);
int bit_rate_control_target;
if ( slice_type == SLICE_TYPE_I )
bit_rate_control_target = 0;
0x0202 );
OUT_BCS_BATCH(batch, (beginy << 24) | /*First MB X&Y , the begin postion of current slice*/
(beginx << 16) |
- pSliceParameter->starting_macroblock_address );
+ pSliceParameter->macroblock_address );
OUT_BCS_BATCH(batch, (nexty << 16) | nextx); /*Next slice first MB X&Y*/
OUT_BCS_BATCH(batch,
(rate_control_enable<<31) | /*in CBR mode RateControlCounterEnable = enable*/
{
static int count = 0;
VAEncSequenceParameterBufferH264 *pSequenceParameter = (VAEncSequenceParameterBufferH264 *)encode_state->seq_param_ext->buffer;
- int rate_control_mode = pSequenceParameter->rate_control_method;
+ int rate_control_mode = 0; /* FIXME: */
- if (encode_state->packed_header_data[VAEncPackedHeaderSPS]) {
+ if (encode_state->packed_header_data[VAEncPackedHeaderH264_SPS]) {
VAEncPackedHeaderParameterBuffer *param = NULL;
- unsigned int *header_data = (unsigned int *)encode_state->packed_header_data[VAEncPackedHeaderSPS]->buffer;
+ unsigned int *header_data = (unsigned int *)encode_state->packed_header_data[VAEncPackedHeaderH264_SPS]->buffer;
unsigned int length_in_bits;
- assert(encode_state->packed_header_param[VAEncPackedHeaderSPS]);
- param = (VAEncPackedHeaderParameterBuffer *)encode_state->packed_header_param[VAEncPackedHeaderSPS]->buffer;
- length_in_bits = param->length_in_bits[0];
+ assert(encode_state->packed_header_param[VAEncPackedHeaderH264_SPS]);
+ param = (VAEncPackedHeaderParameterBuffer *)encode_state->packed_header_param[VAEncPackedHeaderH264_SPS]->buffer;
+ length_in_bits = param->bit_length;
gen6_mfc_avc_insert_object(ctx,
- encoder_context,
- header_data,
- ALIGN(length_in_bits, 32) >> 5,
- length_in_bits & 0x1f,
- param->skip_emulation_check_count,
- 0,
- 0,
- param->insert_emulation_bytes);
+ encoder_context,
+ header_data,
+ ALIGN(length_in_bits, 32) >> 5,
+ length_in_bits & 0x1f,
+ 5, /* FIXME: check it */
+ 0,
+ 0,
+ !param->has_emulation_bytes);
}
- if (encode_state->packed_header_data[VAEncPackedHeaderPPS]) {
+ if (encode_state->packed_header_data[VAEncPackedHeaderH264_PPS]) {
VAEncPackedHeaderParameterBuffer *param = NULL;
- unsigned int *header_data = (unsigned int *)encode_state->packed_header_data[VAEncPackedHeaderPPS]->buffer;
+ unsigned int *header_data = (unsigned int *)encode_state->packed_header_data[VAEncPackedHeaderH264_PPS]->buffer;
unsigned int length_in_bits;
- assert(encode_state->packed_header_param[VAEncPackedHeaderPPS]);
- param = (VAEncPackedHeaderParameterBuffer *)encode_state->packed_header_param[VAEncPackedHeaderPPS]->buffer;
- length_in_bits = param->length_in_bits[0];
+ assert(encode_state->packed_header_param[VAEncPackedHeaderH264_PPS]);
+ param = (VAEncPackedHeaderParameterBuffer *)encode_state->packed_header_param[VAEncPackedHeaderH264_PPS]->buffer;
+ length_in_bits = param->bit_length;
gen6_mfc_avc_insert_object(ctx,
- encoder_context,
- header_data,
- ALIGN(length_in_bits, 32) >> 5,
- length_in_bits & 0x1f,
- param->skip_emulation_check_count,
- 0,
- 0,
- param->insert_emulation_bytes);
+ encoder_context,
+ header_data,
+ ALIGN(length_in_bits, 32) >> 5,
+ length_in_bits & 0x1f,
+ 5, /* FIXME: check it */
+ 0,
+ 0,
+ !param->has_emulation_bytes);
}
- if ( (rate_control_mode == 0) && encode_state->packed_header_data[VAEncPackedHeaderSPS]) { // this is frist AU
+ if ( (rate_control_mode == 0) && encode_state->packed_header_data[VAEncPackedHeaderH264_SPS]) { // this is frist AU
struct gen6_mfc_context *mfc_context = encoder_context->mfc_context;
unsigned char *sei_data = NULL;
VAEncSequenceParameterBufferH264 *pSequenceParameter = (VAEncSequenceParameterBufferH264 *)encode_state->seq_param_ext->buffer;
VAEncPictureParameterBufferH264 *pPicParameter = (VAEncPictureParameterBufferH264 *)encode_state->pic_param_ext->buffer;
VAEncSliceParameterBufferH264 *pSliceParameter = (VAEncSliceParameterBufferH264 *)encode_state->slice_params_ext[slice_index]->buffer;
- VAEncH264DecRefPicMarkingBuffer *pDecRefPicMarking = NULL;
unsigned int *msg = NULL, offset = 0;
int is_intra = pSliceParameter->slice_type == SLICE_TYPE_I;
int width_in_mbs = (mfc_context->surface_state.width + 15) / 16;
int height_in_mbs = (mfc_context->surface_state.height + 15) / 16;
- int last_slice = (pSliceParameter->starting_macroblock_address + pSliceParameter->number_of_mbs) == (width_in_mbs * height_in_mbs);
+ int last_slice = (pSliceParameter->macroblock_address + pSliceParameter->num_macroblocks) == (width_in_mbs * height_in_mbs);
int i,x,y;
int qp = pPicParameter->pic_init_qp + pSliceParameter->slice_qp_delta;
- int rate_control_mode = pSequenceParameter->rate_control_method;
+ int rate_control_mode = 0; /* FIXME: */
unsigned char *slice_header = NULL;
int slice_header_length_in_bits = 0;
unsigned int tail_data[] = { 0x0, 0x0 };
if ( slice_index == 0)
gen6_mfc_avc_pipeline_header_programing(ctx, encode_state, encoder_context);
- if (encode_state->dec_ref_pic_marking)
- pDecRefPicMarking = (VAEncH264DecRefPicMarkingBuffer *)encode_state->dec_ref_pic_marking->buffer;
- slice_header_length_in_bits = build_avc_slice_header(pSequenceParameter, pPicParameter, pSliceParameter, pDecRefPicMarking, &slice_header);
+ slice_header_length_in_bits = build_avc_slice_header(pSequenceParameter, pPicParameter, pSliceParameter, &slice_header);
// slice hander
gen6_mfc_avc_insert_object(ctx, encoder_context,
msg = (unsigned int *)vme_context->vme_output.bo->virtual;
}
- for (i = pSliceParameter->starting_macroblock_address;
- i < pSliceParameter->starting_macroblock_address + pSliceParameter->number_of_mbs; i++) {
- int last_mb = (i == (pSliceParameter->starting_macroblock_address + pSliceParameter->number_of_mbs - 1) );
+ for (i = pSliceParameter->macroblock_address;
+ i < pSliceParameter->macroblock_address + pSliceParameter->num_macroblocks; i++) {
+ int last_mb = (i == (pSliceParameter->macroblock_address + pSliceParameter->num_macroblocks - 1) );
x = i % width_in_mbs;
y = i / width_in_mbs;
struct gen6_mfc_context *mfc_context)
{
VAEncSequenceParameterBufferH264 *pSequenceParameter = (VAEncSequenceParameterBufferH264 *)encode_state->seq_param_ext->buffer;
- int rate_control_mode = pSequenceParameter->rate_control_method;
+ int rate_control_mode = 0; /* FIXME: */
int target_bit_rate = pSequenceParameter->bits_per_second;
// current we only support CBR mode.
dri_bo *bo;
VAEncPictureParameterBufferH264 *pPicParameter = (VAEncPictureParameterBufferH264 *)encode_state->pic_param_ext->buffer;
VAEncSequenceParameterBufferH264 *pSequenceParameter = (VAEncSequenceParameterBufferH264 *)encode_state->seq_param_ext->buffer;
- int rate_control_mode = pSequenceParameter->rate_control_method;
+ int rate_control_mode = 0; /* FIXME: */
VAStatus vaStatus = VA_STATUS_SUCCESS;
int i;
mfc_context->uncompressed_picture_source.bo = obj_surface->bo;
dri_bo_reference(mfc_context->uncompressed_picture_source.bo);
- obj_buffer = BUFFER (pPicParameter->CodedBuf); /* FIXME: fix this later */
+ obj_buffer = BUFFER (pPicParameter->coded_buf); /* FIXME: fix this later */
bo = obj_buffer->buffer_store->bo;
assert(bo);
mfc_context->mfc_indirect_pak_bse_object.bo = bo;
{
VAEncSequenceParameterBufferH264 *pSequenceParameter = (VAEncSequenceParameterBufferH264 *)encode_state->seq_param_ext->buffer;
struct gen6_mfc_context *mfc_context = encoder_context->mfc_context;
- int rate_control_mode = pSequenceParameter->rate_control_method;
+ int rate_control_mode = 0; /* FIXME */
int MAX_CBR_INTERATE = 4;
int current_frame_bits_size;
int i;
VAEncSequenceParameterBufferH264 *pSequenceParameter = (VAEncSequenceParameterBufferH264 *)encode_state->seq_param_ext->buffer;
VAEncPictureParameterBufferH264 *pPicParameter = (VAEncPictureParameterBufferH264 *)encode_state->pic_param_ext->buffer;
VAEncSliceParameterBufferH264 *pSliceParameter = (VAEncSliceParameterBufferH264 *)encode_state->slice_params_ext[0]->buffer; /* FIXME: multi slices */
- VAEncH264DecRefPicMarkingBuffer *pDecRefPicMarking = NULL;
unsigned int *msg = NULL, offset = 0;
int emit_new_state = 1, object_len_in_bytes;
int is_intra = pSliceParameter->slice_type == SLICE_TYPE_I;
int width_in_mbs = (mfc_context->surface_state.width + 15) / 16;
int height_in_mbs = (mfc_context->surface_state.height + 15) / 16;
int x,y;
- int rate_control_mode = pSequenceParameter->rate_control_method;
+ int rate_control_mode = 0; /* FIXME: */
unsigned char target_mb_size = mfc_context->bit_rate_control_context[1-is_intra].TargetSizeInWord;
unsigned char max_mb_size = mfc_context->bit_rate_control_context[1-is_intra].MaxSizeInWord;
int qp = pPicParameter->pic_init_qp + pSliceParameter->slice_qp_delta;
int slice_header_length_in_bits = 0;
unsigned int tail_data[] = { 0x0 };
- if (encode_state->dec_ref_pic_marking)
- pDecRefPicMarking = (VAEncH264DecRefPicMarkingBuffer *)encode_state->dec_ref_pic_marking->buffer;
-
- slice_header_length_in_bits = build_avc_slice_header(pSequenceParameter, pPicParameter, pSliceParameter, pDecRefPicMarking, &slice_header);
+ slice_header_length_in_bits = build_avc_slice_header(pSequenceParameter, pPicParameter, pSliceParameter, &slice_header);
if ( rate_control_mode == 0) {
qp = mfc_context->bit_rate_control_context[1-is_intra].QpPrimeY;
encode_state, encoder_context,
rate_control_mode == 0, pPicParameter->pic_init_qp + pSliceParameter->slice_qp_delta);
- if (encode_state->packed_header_data[VAEncPackedHeaderSPS]) {
+ if (encode_state->packed_header_data[VAEncPackedHeaderH264_SPS]) {
VAEncPackedHeaderParameterBuffer *param = NULL;
- unsigned int *header_data = (unsigned int *)encode_state->packed_header_data[VAEncPackedHeaderSPS]->buffer;
+ unsigned int *header_data = (unsigned int *)encode_state->packed_header_data[VAEncPackedHeaderH264_SPS]->buffer;
unsigned int length_in_bits;
- assert(encode_state->packed_header_param[VAEncPackedHeaderSPS]);
- param = (VAEncPackedHeaderParameterBuffer *)encode_state->packed_header_param[VAEncPackedHeaderSPS]->buffer;
- length_in_bits = param->length_in_bits[0];
+ assert(encode_state->packed_header_param[VAEncPackedHeaderH264_SPS]);
+ param = (VAEncPackedHeaderParameterBuffer *)encode_state->packed_header_param[VAEncPackedHeaderH264_SPS]->buffer;
+ length_in_bits = param->bit_length;
gen7_mfc_avc_insert_object(ctx,
encoder_context,
header_data,
ALIGN(length_in_bits, 32) >> 5,
length_in_bits & 0x1f,
- param->skip_emulation_check_count,
+ 5, /* FIXME: check it */
0,
0,
- param->insert_emulation_bytes);
+ !param->has_emulation_bytes);
}
- if (encode_state->packed_header_data[VAEncPackedHeaderPPS]) {
+ if (encode_state->packed_header_data[VAEncPackedHeaderH264_PPS]) {
VAEncPackedHeaderParameterBuffer *param = NULL;
- unsigned int *header_data = (unsigned int *)encode_state->packed_header_data[VAEncPackedHeaderPPS]->buffer;
+ unsigned int *header_data = (unsigned int *)encode_state->packed_header_data[VAEncPackedHeaderH264_PPS]->buffer;
unsigned int length_in_bits;
- assert(encode_state->packed_header_param[VAEncPackedHeaderPPS]);
- param = (VAEncPackedHeaderParameterBuffer *)encode_state->packed_header_param[VAEncPackedHeaderPPS]->buffer;
- length_in_bits = param->length_in_bits[0];
+ assert(encode_state->packed_header_param[VAEncPackedHeaderH264_PPS]);
+ param = (VAEncPackedHeaderParameterBuffer *)encode_state->packed_header_param[VAEncPackedHeaderH264_PPS]->buffer;
+ length_in_bits = param->bit_length;
gen7_mfc_avc_insert_object(ctx,
encoder_context,
header_data,
ALIGN(length_in_bits, 32) >> 5,
length_in_bits & 0x1f,
- param->skip_emulation_check_count,
+ 5, /* FIXME: check it */
0,
0,
- param->insert_emulation_bytes);
+ !param->has_emulation_bytes);
}
gen7_mfc_avc_insert_object(ctx, encoder_context,
mfc_context->uncompressed_picture_source.bo = obj_surface->bo;
dri_bo_reference(mfc_context->uncompressed_picture_source.bo);
- obj_buffer = BUFFER (pPicParameter->CodedBuf); /* FIXME: fix this later */
+ obj_buffer = BUFFER (pPicParameter->coded_buf); /* FIXME: fix this later */
bo = obj_buffer->buffer_store->bo;
assert(bo);
mfc_context->mfc_indirect_pak_bse_object.bo = bo;
{
VAEncSequenceParameterBufferH264 *pSequenceParameter = (VAEncSequenceParameterBufferH264 *)encode_state->seq_param_ext->buffer;
struct gen7_mfc_context *mfc_context = encoder_context->mfc_context;
- int rate_control_mode = pSequenceParameter->rate_control_method;
+ int rate_control_mode = 0; /* FIXME: */
int MAX_CBR_INTERATE = 4;
int current_frame_bits_size;
int i;
break;
case VAConfigAttribRateControl:
- attrib_list[i].value = VA_RC_VBR;
- break;
+ if (entrypoint == VAEntrypointEncSlice) {
+ attrib_list[i].value = VA_RC_VBR; /* FIXME: */
+ break;
+ }
- case VAConfigAttribEncHeaderPacking:
+ case VAConfigAttribEncPackedHeaders:
if (entrypoint == VAEntrypointEncSlice) {
- attrib_list[i].value = VA_ENC_HEADER_PACKING_SLICE;
+ attrib_list[i].value = VA_ENC_PACKED_HEADER_SEQUENCE | VA_ENC_PACKED_HEADER_PICTURE;
break;
}
if (obj_context->codec_type == CODEC_PROC) {
i965_release_buffer_store(&obj_context->codec_state.proc.pipeline_param);
- i965_release_buffer_store(&obj_context->codec_state.proc.input_param);
- for (i = 0; i < VA_PROC_PIPELINE_MAX_NUM_FILTERS; i++)
+ for (i = 0; i < VAProcFilterCount; i++)
i965_release_buffer_store(&obj_context->codec_state.proc.filter_param[i]);
} else if (obj_context->codec_type == CODEC_ENC) {
assert(obj_context->codec_state.encode.num_slice_params <= obj_context->codec_state.encode.max_slice_params);
assert(obj_context->codec_state.encode.num_slice_params_ext <= obj_context->codec_state.encode.max_slice_params_ext);
i965_release_buffer_store(&obj_context->codec_state.encode.pic_param_ext);
i965_release_buffer_store(&obj_context->codec_state.encode.seq_param_ext);
- i965_release_buffer_store(&obj_context->codec_state.encode.dec_ref_pic_marking);
for (i = 0; i < ARRAY_ELEMS(obj_context->codec_state.encode.packed_header_param); i++)
i965_release_buffer_store(&obj_context->codec_state.encode.packed_header_param[i]);
case VAEncSequenceParameterBufferType:
case VAEncPictureParameterBufferType:
case VAEncSliceParameterBufferType:
- case VAEncDecRefPicMarkingBufferH264Type:
case VAEncPackedHeaderParameterBufferType:
case VAEncPackedHeaderDataBufferType:
case VAProcPipelineParameterBufferType:
- case VAProcInputParameterBufferType:
- case VAProcFilterBaseParameterBufferType:
- case VAProcFilterDeinterlacingParameterBufferType:
- case VAProcFilterProcAmpParameterBufferType:
+ case VAProcFilterParameterBufferType:
#ifdef HAVE_JPEG_DECODING
case VAHuffmanTableBufferType:
#endif
} else if (type == VAEncPackedHeaderParameterBufferType) {
VAEncPackedHeaderParameterBuffer *param;
- int msize;
assert(data);
assert(num_elements == 1);
assert(size == sizeof(*param));
param = (VAEncPackedHeaderParameterBuffer *)data;
- msize = ALIGN(size, 32) + param->num_headers * sizeof(int) * 2;
- buffer_store->buffer = malloc(msize);
- assert(buffer_store->buffer);
-
memcpy(buffer_store->buffer,
data,
size);
- memcpy((unsigned char *)buffer_store->buffer + ALIGN(size, 32),
- param->length_in_bits,
- param->num_headers * sizeof(int));
- memcpy((unsigned char *)buffer_store->buffer + ALIGN(size, 32) + param->num_headers * sizeof(int),
- param->offset_in_bytes,
- param->num_headers * sizeof(int));
-
- param = (VAEncPackedHeaderParameterBuffer *)buffer_store->buffer;
- param->length_in_bits = (unsigned int *)((unsigned char *)buffer_store->buffer + ALIGN(size, 32));
- param->offset_in_bytes = (unsigned int *)((unsigned char *)buffer_store->buffer + ALIGN(size, 32) + param->num_headers * sizeof(int));
} else {
int msize = size;
/* ext */
i965_release_buffer_store(&obj_context->codec_state.encode.pic_param_ext);
i965_release_buffer_store(&obj_context->codec_state.encode.seq_param_ext);
- i965_release_buffer_store(&obj_context->codec_state.encode.dec_ref_pic_marking);
-
for (i = 0; i < ARRAY_ELEMS(obj_context->codec_state.encode.packed_header_param); i++)
i965_release_buffer_store(&obj_context->codec_state.encode.packed_header_param[i]);
/* extended buffer */
DEF_RENDER_ENCODE_SINGLE_BUFFER_FUNC(sequence_parameter_ext, seq_param_ext)
DEF_RENDER_ENCODE_SINGLE_BUFFER_FUNC(picture_parameter_ext, pic_param_ext)
-DEF_RENDER_ENCODE_SINGLE_BUFFER_FUNC(dec_ref_pic_marking, dec_ref_pic_marking)
#define DEF_RENDER_ENCODE_MULTI_BUFFER_FUNC(name, member) DEF_RENDER_MULTI_BUFFER_FUNC(encode, name, member)
DEF_RENDER_ENCODE_MULTI_BUFFER_FUNC(slice_parameter, slice_params)
vaStatus = I965_RENDER_ENCODE_BUFFER(slice_parameter_ext);
break;
- case VAEncDecRefPicMarkingBufferH264Type:
- vaStatus = I965_RENDER_ENCODE_BUFFER(dec_ref_pic_marking);
- break;
-
case VAEncPackedHeaderParameterBufferType:
{
struct encode_state *encode = &obj_context->codec_state.encode;
{
struct encode_state *encode = &obj_context->codec_state.encode;
- assert(encode->last_packed_header_type == VAEncPackedHeaderSPS ||
- encode->last_packed_header_type == VAEncPackedHeaderPPS ||
+ assert(encode->last_packed_header_type == VAEncPackedHeaderSequence ||
+ encode->last_packed_header_type == VAEncPackedHeaderPicture ||
encode->last_packed_header_type == VAEncPackedHeaderSlice);
vaStatus = i965_encoder_render_packed_header_data_buffer(ctx,
obj_context,
#define DEF_RENDER_PROC_SINGLE_BUFFER_FUNC(name, member) DEF_RENDER_SINGLE_BUFFER_FUNC(proc, name, member)
DEF_RENDER_PROC_SINGLE_BUFFER_FUNC(pipeline_parameter, pipeline_param)
-DEF_RENDER_PROC_SINGLE_BUFFER_FUNC(input_parameter, input_param)
static VAStatus
i965_render_proc_filter_parameter_buffer(VADriverContextP ctx,
switch (obj_buffer->type) {
case VAProcPipelineParameterBufferType:
+ /* FIXME: */
vaStatus = I965_RENDER_PROC_BUFFER(pipeline_parameter);
break;
- case VAProcInputParameterBufferType:
- vaStatus = I965_RENDER_PROC_BUFFER(input_parameter);
- break;
-
- case VAProcFilterBaseParameterBufferType:
+ case VAProcFilterParameterBufferType:
{
- VAProcFilterBaseParameterBuffer *param = (VAProcFilterBaseParameterBuffer *)obj_buffer->buffer_store->buffer;
- vaStatus = i965_render_proc_filter_parameter_buffer(ctx, obj_context, obj_buffer, param->filter);
+ /* FIXME: */
+ VAProcFilterParameterBuffer *param = (VAProcFilterParameterBuffer *)obj_buffer->buffer_store->buffer;
+ vaStatus = i965_render_proc_filter_parameter_buffer(ctx, obj_context, obj_buffer, param->type);
break;
}
- case VAProcFilterDeinterlacingParameterBufferType:
- vaStatus = i965_render_proc_filter_parameter_buffer(ctx, obj_context, obj_buffer, VAProcFilterDeinterlacing);
- break;
-
- case VAProcFilterProcAmpParameterBufferType:
- vaStatus = i965_render_proc_filter_parameter_buffer(ctx, obj_context, obj_buffer, VAProcFilterProcAmp);
- break;
-
default:
vaStatus = VA_STATUS_ERROR_UNSUPPORTED_BUFFERTYPE;
break;
/*
* Query video processing pipeline
*/
-VAStatus i965_QueryVideoProcPipelineCap(
- VADriverContextP ctx,
- VAContextID context,
- VAProcPipelineCap *pipeline_cap /* out */
+VAStatus i965_QueryVideoProcFilters(
+ VADriverContextP ctx,
+ VAContextID context,
+ VAProcFilterType *filters,
+ unsigned int *num_filters
)
{
- struct i965_driver_data * const i965 = i965_driver_data(ctx);
- int i = 0;
-
+ struct i965_driver_data *const i965 = i965_driver_data(ctx);
+ unsigned int i = 0;
+
if (HAS_VPP(i965)) {
- pipeline_cap->filter_pipeline[i] = VAProcFilterNoiseReduction;
- pipeline_cap->bypass[i++] = 1;
- pipeline_cap->filter_pipeline[i] = VAProcFilterDeinterlacing;
- pipeline_cap->bypass[i++] = 1;
+ filters[i++] = VAProcFilterNoiseReduction;
+ filters[i++] = VAProcFilterDeinterlacing;
}
- for (; i < VA_PROC_PIPELINE_MAX_NUM_FILTERS; i++) {
- pipeline_cap->filter_pipeline[i] = VAProcFilterNone;
- pipeline_cap->bypass[i] = 1;
- }
+ *num_filters = i;
return VA_STATUS_SUCCESS;
}
-VAStatus i965_QueryVideoProcFilterCap(
- VADriverContextP ctx,
- VAContextID context,
- VAProcFilterType filter,
- void *cap /* out */
- )
+VAStatus i965_QueryVideoProcFilterCaps(
+ VADriverContextP ctx,
+ VAContextID context,
+ VAProcFilterType type,
+ void *filter_caps,
+ unsigned int *num_filter_caps
+ )
{
- assert(cap);
+ unsigned int i = 0;
- if (filter == VAProcFilterNoiseReduction) {
- VAProcFilterCapBase *base_cap = cap;
- base_cap->range.min = 0.0;
- base_cap->range.max = 1.0;
- base_cap->range.default_value = 0.5;
- base_cap->range.step = 0.03125; /* 1.0 / 32 */
+ if (type == VAProcFilterNoiseReduction) {
+ VAProcFilterCap *cap = filter_caps;
+
+ cap->range.min_value = 0.0;
+ cap->range.max_value = 1.0;
+ cap->range.default_value = 0.5;
+ cap->range.step = 0.03125; /* 1.0 / 32 */
+ i++;
+ } else if (type == VAProcFilterDeinterlacing) {
+ VAProcFilterCapDeinterlacing *cap = filter_caps;
+
+ cap->type = VAProcDeinterlacingBob;
+ i++;
+ cap++;
+ cap->type = VAProcDeinterlacingWeave;
+ i++;
+ cap++;
}
+ *num_filter_caps = i;
+
return VA_STATUS_SUCCESS;
}
-VAStatus i965_QueryVideoProcReferenceFramesCap(
+VAStatus i965_QueryVideoProcPipelineCaps(
VADriverContextP ctx,
VAContextID context,
- unsigned int *num_forward_reference, /* out */
- unsigned int *num_backward_reference /* out */
+ VABufferID *filters,
+ unsigned int num_filters,
+ VAProcPipelineCaps *pipeline_cap /* out */
)
{
-
- *num_forward_reference = 0;
- *num_backward_reference = 0;
+ struct i965_driver_data * const i965 = i965_driver_data(ctx);
+ unsigned int i = 0;
+
+ pipeline_cap->flags = 0;
+ pipeline_cap->pipeline_flags = 0;
+ pipeline_cap->filter_flags = 0;
+ pipeline_cap->num_forward_references = 0;
+ pipeline_cap->num_backward_references = 0;
+ pipeline_cap->num_input_color_standards = 0;
+ pipeline_cap->input_color_standards[pipeline_cap->num_input_color_standards++] = VAProcColorStandardBT601;
+ pipeline_cap->num_output_color_standards = 0;
+ pipeline_cap->output_color_standards[pipeline_cap->num_output_color_standards++] = VAProcColorStandardBT601;
+
+ for (i = 0; i < num_filters; i++) {
+ struct object_buffer *obj_buffer = BUFFER(filters[i]);
+ VAProcFilterParameterBufferBase *base = (VAProcFilterParameterBufferBase *)obj_buffer->buffer_store->buffer;
+
+ if (base->type == VAProcFilterNoiseReduction) {
+ VAProcFilterParameterBuffer *denoise = (VAProcFilterParameterBuffer *)base;
+ (void)denoise;
+ } else if (base->type == VAProcFilterDeinterlacing) {
+ VAProcFilterParameterBufferDeinterlacing *deint = (VAProcFilterParameterBufferDeinterlacing *)base;
+
+ assert(deint->algorithm == VAProcDeinterlacingWeave ||
+ deint->algorithm == VAProcDeinterlacingBob);
+ }
+ }
return VA_STATUS_SUCCESS;
}
VA_DRIVER_INIT_FUNC( VADriverContextP ctx )
{
struct VADriverVTable * const vtable = ctx->vtable;
+ struct VADriverVTableVPP * const vtable_vpp = ctx->vtable_vpp;
+
struct i965_driver_data *i965;
int result;
vtable->vaBufferInfo = i965_BufferInfo;
vtable->vaLockSurface = i965_LockSurface;
vtable->vaUnlockSurface = i965_UnlockSurface;
- vtable->vaQueryVideoProcPipelineCap = i965_QueryVideoProcPipelineCap;
- vtable->vaQueryVideoProcFilterCap = i965_QueryVideoProcFilterCap;
- vtable->vaQueryVideoProcReferenceFramesCap = i965_QueryVideoProcReferenceFramesCap;
- // vtable->vaDbgCopySurfaceToBuffer = i965_DbgCopySurfaceToBuffer;
+ vtable_vpp->vaQueryVideoProcFilters = i965_QueryVideoProcFilters;
+ vtable_vpp->vaQueryVideoProcFilterCaps = i965_QueryVideoProcFilterCaps;
+ vtable_vpp->vaQueryVideoProcPipelineCaps = i965_QueryVideoProcPipelineCaps;
i965 = (struct i965_driver_data *)calloc(1, sizeof(*i965));
assert(i965);
#define _I965_DRV_VIDEO_H_
#include <va/va.h>
+#include <va/va_enc_h264.h>
+#include <va/va_vpp.h>
#include <va/va_backend.h>
+#include <va/va_backend_vpp.h>
#include "i965_mutext.h"
#include "object_heap.h"
/* for ext */
struct buffer_store *seq_param_ext;
struct buffer_store *pic_param_ext;
- struct buffer_store *dec_ref_pic_marking;
struct buffer_store *packed_header_param[4];
struct buffer_store *packed_header_data[4];
struct buffer_store **slice_params_ext;
struct proc_state
{
struct buffer_store *pipeline_param;
- struct buffer_store *input_param;
- struct buffer_store *filter_param[VA_PROC_PIPELINE_MAX_NUM_FILTERS];
+ struct buffer_store *filter_param[VAProcFilterCount];
VASurfaceID current_render_target;
};
#include <assert.h>
#include <va/va.h>
+#include <va/va_enc_h264.h>
#include "i965_encoder_utils.h"
slice_header(avc_bitstream *bs,
VAEncSequenceParameterBufferH264 *sps_param,
VAEncPictureParameterBufferH264 *pic_param,
- VAEncSliceParameterBufferH264 *slice_param,
- VAEncH264DecRefPicMarkingBuffer *dec_ref_pic_marking_param)
+ VAEncSliceParameterBufferH264 *slice_param)
{
- int first_mb_in_slice = slice_param->starting_macroblock_address;
+ int first_mb_in_slice = slice_param->macroblock_address;
avc_bitstream_put_ue(bs, first_mb_in_slice); /* first_mb_in_slice: 0 */
avc_bitstream_put_ue(bs, slice_param->slice_type); /* slice_type */
avc_bitstream_put_ue(bs, slice_param->pic_parameter_set_id); /* pic_parameter_set_id: 0 */
- avc_bitstream_put_ui(bs, pic_param->frame_num, sps_param->log2_max_frame_num_minus4 + 4); /* frame_num */
+ avc_bitstream_put_ui(bs, pic_param->frame_num, sps_param->seq_fields.bits.log2_max_frame_num_minus4 + 4); /* frame_num */
/* frame_mbs_only_flag == 1 */
- if (!sps_param->frame_mbs_only_flag) {
+ if (!sps_param->seq_fields.bits.frame_mbs_only_flag) {
/* FIXME: */
assert(0);
}
if (pic_param->pic_fields.bits.idr_pic_flag)
avc_bitstream_put_ue(bs, slice_param->idr_pic_id); /* idr_pic_id: 0 */
- if (sps_param->pic_order_cnt_type == 0) {
- avc_bitstream_put_ui(bs, pic_param->CurrPic.TopFieldOrderCnt, sps_param->log2_max_pic_order_cnt_lsb_minus4 + 4);
+ if (sps_param->seq_fields.bits.pic_order_cnt_type == 0) {
+ avc_bitstream_put_ui(bs, pic_param->CurrPic.TopFieldOrderCnt, sps_param->seq_fields.bits.log2_max_pic_order_cnt_lsb_minus4 + 4);
/* pic_order_present_flag == 0 */
} else {
/* FIXME: */
avc_bitstream_put_ui(bs, 0, 1); /* num_ref_idx_active_override_flag: 0 */
/* ref_pic_list_reordering */
- assert(slice_param->ref_pic_list_modification_flag_l0 == 0);
- avc_bitstream_put_ui(bs, slice_param->ref_pic_list_modification_flag_l0, 1); /* ref_pic_list_reordering_flag_l0: 0 */
+ avc_bitstream_put_ui(bs, 0, 1); /* ref_pic_list_reordering_flag_l0: 0 */
} else if (IS_B_SLICE(slice_param->slice_type)) {
avc_bitstream_put_ui(bs, slice_param->direct_spatial_mv_pred_flag, 1); /* direct_spatial_mv_pred: 1 */
avc_bitstream_put_ui(bs, 0, 1); /* num_ref_idx_active_override_flag: 0 */
/* ref_pic_list_reordering */
- assert(slice_param->ref_pic_list_modification_flag_l0 == 0);
- assert(slice_param->ref_pic_list_modification_flag_l1 == 0);
- avc_bitstream_put_ui(bs, slice_param->ref_pic_list_modification_flag_l0, 1); /* ref_pic_list_reordering_flag_l0: 0 */
- avc_bitstream_put_ui(bs, slice_param->ref_pic_list_modification_flag_l1, 1); /* ref_pic_list_reordering_flag_l1: 0 */
+ avc_bitstream_put_ui(bs, 0, 1); /* ref_pic_list_reordering_flag_l0: 0 */
+ avc_bitstream_put_ui(bs, 0, 1); /* ref_pic_list_reordering_flag_l1: 0 */
}
if ((pic_param->pic_fields.bits.weighted_pred_flag &&
unsigned char long_term_reference_flag = 0;
unsigned char adaptive_ref_pic_marking_mode_flag = 0;
- if (dec_ref_pic_marking_param) {
- no_output_of_prior_pics_flag = dec_ref_pic_marking_param->no_output_of_prior_pics_flag;
- long_term_reference_flag = dec_ref_pic_marking_param->long_term_reference_flag;
- adaptive_ref_pic_marking_mode_flag = dec_ref_pic_marking_param->adaptive_ref_pic_marking_mode_flag;
- /* FIXME: XXX */
- assert(adaptive_ref_pic_marking_mode_flag == 0);
- }
-
if (pic_param->pic_fields.bits.idr_pic_flag) {
avc_bitstream_put_ui(bs, no_output_of_prior_pics_flag, 1); /* no_output_of_prior_pics_flag: 0 */
avc_bitstream_put_ui(bs, long_term_reference_flag, 1); /* long_term_reference_flag: 0 */
build_avc_slice_header(VAEncSequenceParameterBufferH264 *sps_param,
VAEncPictureParameterBufferH264 *pic_param,
VAEncSliceParameterBufferH264 *slice_param,
- VAEncH264DecRefPicMarkingBuffer *dec_ref_pic_marking_param,
unsigned char **slice_header_buffer)
{
avc_bitstream bs;
nal_header(&bs, NAL_REF_IDC_NONE, is_idr ? NAL_IDR : NAL_NON_IDR);
}
- slice_header(&bs, sps_param, pic_param, slice_param, dec_ref_pic_marking_param);
+ slice_header(&bs, sps_param, pic_param, slice_param);
avc_bitstream_end(&bs);
*slice_header_buffer = (unsigned char *)bs.buffer;
#define __I965_ENCODER_UTILS_H__
int
-build_avc_slice_header(VAEncSequenceParameterBufferH264 *sps_param,
+build_avc_slice_header(VAEncSequenceParameterBufferH264 *sps_param,
VAEncPictureParameterBufferH264 *pic_param,
VAEncSliceParameterBufferH264 *slice_param,
- VAEncH264DecRefPicMarkingBuffer *dec_ref_pic_marking_param,
unsigned char **slice_header_buffer);
int
build_avc_sei_buffering_period(int cpb_removal_length,
struct i965_sampler_dndi *sampler_dndi;
struct pp_static_parameter *pp_static_parameter = pp_context->pp_static_parameter;
struct pp_inline_parameter *pp_inline_parameter = pp_context->pp_inline_parameter;
- VAProcFilterBaseParameterBuffer *dn_filter_param = filter_param;
+ VAProcFilterParameterBuffer *dn_filter_param = filter_param; /* FIXME: parameter */
int index;
int w, h;
int orig_w, orig_h;
}
if (dn_filter_param) {
- int value = dn_filter_param->value;
+ float value = dn_filter_param->value;
if (value > 1.0)
value = 1.0;
struct gen7_pp_static_parameter *pp_static_parameter = pp_context->pp_static_parameter;
struct object_surface *obj_surface;
struct gen7_sampler_dndi *sampler_dn;
- VAProcFilterBaseParameterBuffer *dn_filter_param = filter_param;
+ VAProcFilterParameterBuffer *dn_filter_param = filter_param; /* FIXME: parameter */
int index;
int w, h;
int orig_w, orig_h;
}
if (dn_filter_param) {
- int value = dn_filter_param->value;
+ float value = dn_filter_param->value;
if (value > 1.0)
value = 1.0;
struct i965_proc_context *proc_context = (struct i965_proc_context *)hw_context;
struct proc_state *proc_state = &codec_state->proc;
VAProcPipelineParameterBuffer *pipeline_param = (VAProcPipelineParameterBuffer *)proc_state->pipeline_param->buffer;
- VAProcInputParameterBuffer *input_param = (VAProcInputParameterBuffer *)proc_state->input_param->buffer;
struct object_surface *obj_surface;
struct i965_surface src_surface, dst_surface;
+ VARectangle src_rect, dst_rect;
VAStatus status;
int i;
- VASurfaceID tmp_surfaces[VA_PROC_PIPELINE_MAX_NUM_FILTERS + 4];
+ VASurfaceID tmp_surfaces[VAProcFilterCount + 4];
int num_tmp_surfaces = 0;
unsigned int tiling = 0, swizzle = 0;
int in_width, in_height;
- assert(input_param->surface != VA_INVALID_ID);
+ assert(pipeline_param->surface != VA_INVALID_ID);
assert(proc_state->current_render_target != VA_INVALID_ID);
- obj_surface = SURFACE(input_param->surface);
+ obj_surface = SURFACE(pipeline_param->surface);
in_width = obj_surface->orig_width;
in_height = obj_surface->orig_height;
dri_bo_get_tiling(obj_surface->bo, &tiling, &swizzle);
- src_surface.id = input_param->surface;
+ src_surface.id = pipeline_param->surface;
src_surface.type = I965_SURFACE_TYPE_SURFACE;
- src_surface.flags = proc_frame_to_pp_frame[input_param->flags];
+ src_surface.flags = proc_frame_to_pp_frame[pipeline_param->filter_flags & 0x3];
if (obj_surface->fourcc != VA_FOURCC('N', 'V', '1', '2')) {
- struct i965_surface src_surface, dst_surface;
- VARectangle src_rect, dst_rect;
VASurfaceID out_surface_id = VA_INVALID_ID;
- src_surface.id = input_param->surface;
+ src_surface.id = pipeline_param->surface;
src_surface.type = I965_SURFACE_TYPE_SURFACE;
src_surface.flags = I965_SURFACE_FLAG_FRAME;
src_rect.x = 0;
src_surface.id = out_surface_id;
src_surface.type = I965_SURFACE_TYPE_SURFACE;
- src_surface.flags = proc_frame_to_pp_frame[input_param->flags];
+ src_surface.flags = proc_frame_to_pp_frame[pipeline_param->filter_flags & 0x3];
+ }
+
+ if (pipeline_param->surface_region) {
+ src_rect.x = pipeline_param->surface_region->x;
+ src_rect.y = pipeline_param->surface_region->y;
+ src_rect.width = pipeline_param->surface_region->width;
+ src_rect.height = pipeline_param->surface_region->height;
+ } else {
+ src_rect.x = 0;
+ src_rect.y = 0;
+ src_rect.width = in_width;
+ src_rect.height = in_height;
+ }
+
+ if (pipeline_param->output_region) {
+ dst_rect.x = pipeline_param->output_region->x;
+ dst_rect.y = pipeline_param->output_region->y;
+ dst_rect.width = pipeline_param->output_region->width;
+ dst_rect.height = pipeline_param->output_region->height;
+ } else {
+ dst_rect.x = 0;
+ dst_rect.y = 0;
+ dst_rect.width = in_width;
+ dst_rect.height = in_height;
}
obj_surface = SURFACE(proc_state->current_render_target);
i965_check_alloc_surface_bo(ctx, obj_surface, !!tiling, VA_FOURCC('N','V','1','2'), SUBSAMPLE_YUV420);
- for (i = 0; i < VA_PROC_PIPELINE_MAX_NUM_FILTERS; i++) {
- VAProcFilterType filter_type = pipeline_param->filter_pipeline[i];
+ for (i = 0; i < pipeline_param->num_filters; i++) {
+ struct object_buffer *obj_buffer = BUFFER(pipeline_param->filters[i]);
+ VAProcFilterParameterBufferBase *base = (VAProcFilterParameterBufferBase *)obj_buffer->buffer_store->buffer;
+ VAProcFilterType filter_type = base->type;
VASurfaceID out_surface_id = VA_INVALID_ID;
void *filter_param = NULL;
dst_surface.type = I965_SURFACE_TYPE_SURFACE;
status = i965_post_processing_internal(ctx, &proc_context->pp_context,
&src_surface,
- &input_param->region,
+ &src_rect,
&dst_surface,
- &input_param->region,
+ &src_rect,
procfilter_to_pp_flag[filter_type],
filter_param);
dst_surface.type = I965_SURFACE_TYPE_SURFACE;
i965_post_processing_internal(ctx, &proc_context->pp_context,
&src_surface,
- &input_param->region,
+ &src_rect,
&dst_surface,
- &pipeline_param->output_region,
- (pipeline_param->flags & VA_FILTER_SCALING_MASK) == VA_FILTER_SCALING_NL_ANAMORPHIC ?
+ &dst_rect,
+ (pipeline_param->filter_flags & VA_FILTER_SCALING_MASK) == VA_FILTER_SCALING_NL_ANAMORPHIC ?
PP_NV12_AVS : PP_NV12_SCALING,
NULL);
projects / platform / upstream / libva-intel-driver.git / commitdiff