i965_drv_vidoe: update packed header iterface

Signed-off-by: Xiang, Haihao <haihao.xiang@intel.com>

diff --git a/src/gen6_mfc.c b/src/gen6_mfc.c
index a96c840..6e1bb70 100644 (file)
--- a/src/gen6_mfc.c
+++ b/src/gen6_mfc.c
@@ -648,7 +648,7 @@ gen6_mfc_avc_insert_object(VADriverContextP ctx, struct gen6_encoder_context *ge
                   (0 << 16) |   /* always start at offset 0 */
                   (data_bits_in_last_dw << 8) |
                   (skip_emul_byte_count << 4) |
-                  (emulation_flag << 3) |
+                  (!!emulation_flag << 3) |
                   ((!!is_last_header) << 2) |
                   ((!!is_end_of_slice) << 1) |
                   (0 << 0));    /* FIXME: ??? */
@@ -823,14 +823,6 @@ static void gen6_mfc_init(VADriverContextP ctx, struct gen6_encoder_context *gen
     mfc_context->bsd_mpc_row_store_scratch_buffer.bo = bo;
 }
 
-struct packed_data_format
-{
-    unsigned int length_in_bits;
-    unsigned char flag;
-    unsigned char num_skip_bytes;
-    unsigned char pad[2];
-};
-
 void gen6_mfc_avc_pipeline_programing(VADriverContextP ctx,
                                       struct encode_state *encode_state,
                                       struct gen6_encoder_context *gen6_encoder_context)
@@ -857,17 +849,10 @@ void gen6_mfc_avc_pipeline_programing(VADriverContextP ctx,
     unsigned char *slice_header = NULL;
     int slice_header_length_in_bits = 0;
     unsigned int tail_data[] = { 0x0 };
-    struct packed_data_format *packed_sps = NULL, *packed_pps = NULL;
 
     if (encode_state->dec_ref_pic_marking)
         pDecRefPicMarking = (VAEncH264DecRefPicMarkingBuffer *)encode_state->dec_ref_pic_marking->buffer;
 
-    if (encode_state->packed_sps)
-        packed_sps = (struct packed_data_format *)encode_state->packed_sps->buffer;
-
-    if (encode_state->packed_pps)
-        packed_pps = (struct packed_data_format *)encode_state->packed_pps->buffer;
-
     slice_header_length_in_bits = build_avc_slice_header(pSequenceParameter, pPicParameter, pSliceParameter, pDecRefPicMarking, &slice_header);
 
     if ( rate_control_mode != 2) {
@@ -921,16 +906,44 @@ void gen6_mfc_avc_pipeline_programing(VADriverContextP ctx,
                                          encode_state, gen6_encoder_context, 
                                          rate_control_mode == 0, qp);
 
-                if (packed_sps) {
-                    gen6_mfc_avc_insert_object(ctx, gen6_encoder_context,
-                                               (unsigned int *)(packed_sps + 1), ALIGN(packed_sps->length_in_bits, 32) >> 5, packed_sps->length_in_bits & 0x1f,
-                                               packed_sps->num_skip_bytes, 0, 0, !!(packed_sps->flag & 0x1));
+                if (encode_state->packed_header_data[VAEncPackedHeaderSPS]) {
+                    VAEncPackedHeaderParameterBuffer *param = NULL;
+                    unsigned int *header_data = (unsigned int *)encode_state->packed_header_data[VAEncPackedHeaderSPS]->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];
+
+                    gen6_mfc_avc_insert_object(ctx, 
+                                               gen6_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);
                 }
 
-                if (packed_pps) {
-                    gen6_mfc_avc_insert_object(ctx, gen6_encoder_context,
-                                               (unsigned int *)(packed_pps + 1), ALIGN(packed_pps->length_in_bits, 32) >> 5, packed_pps->length_in_bits & 0x1f,
-                                               packed_pps->num_skip_bytes, 0, 0, !!(packed_pps->flag & 0x1));
+                if (encode_state->packed_header_data[VAEncPackedHeaderPPS]) {
+                    VAEncPackedHeaderParameterBuffer *param = NULL;
+                    unsigned int *header_data = (unsigned int *)encode_state->packed_header_data[VAEncPackedHeaderPPS]->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];
+
+                    gen6_mfc_avc_insert_object(ctx, 
+                                               gen6_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);
                 }
 
                 gen6_mfc_avc_insert_object(ctx, gen6_encoder_context,

diff --git a/src/i965_drv_video.c b/src/i965_drv_video.c
index ab2f58a..f2ec4b8 100644 (file)
--- a/src/i965_drv_video.c
+++ b/src/i965_drv_video.c
@@ -863,9 +863,12 @@ i965_destroy_context(struct object_heap *heap, struct object_base *obj)
         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);
-        i965_release_buffer_store(&obj_context->codec_state.encode.packed_sps);
-        i965_release_buffer_store(&obj_context->codec_state.encode.packed_pps);
-        i965_release_buffer_store(&obj_context->codec_state.encode.packed_slice_header);
+
+        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]);
+
+        for (i = 0; i < ARRAY_ELEMS(obj_context->codec_state.encode.packed_header_data); i++)
+            i965_release_buffer_store(&obj_context->codec_state.encode.packed_header_data[i]);
 
         for (i = 0; i < obj_context->codec_state.encode.num_slice_params_ext; i++)
             i965_release_buffer_store(&obj_context->codec_state.encode.slice_params_ext[i]);
@@ -1058,9 +1061,8 @@ i965_create_buffer_internal(VADriverContextP ctx,
     case VAEncPictureParameterBufferExtType:
     case VAEncSliceParameterBufferExtType:
     case VAEncDecRefPicMarkingBufferH264Type:
-    case VAEncPackedSequenceParameterBufferType:
-    case VAEncPackedPictureParameterBufferType:
-    case VAEncPackedSliceParameterBufferType:
+    case VAEncPackedHeaderParameterBufferType:
+    case VAEncPackedHeaderDataBufferType:
     case VAProcPipelineParameterBufferType:
     case VAProcInputParameterBufferType:
     case VAProcFilterBaseParameterBufferType:
@@ -1123,12 +1125,36 @@ i965_create_buffer_internal(VADriverContextP ctx,
             dri_bo_subdata(buffer_store->bo, 0, size * num_elements, data);
         }
 
+    } 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;
         
-        if (type == VAEncPackedSequenceParameterBufferType ||
-            type == VAEncPackedPictureParameterBufferType ||
-            type == VAEncPackedSliceParameterBufferType) {
+        if (type == VAEncPackedHeaderDataBufferType) {
             msize = ALIGN(size, 4);
         }
 
@@ -1347,16 +1373,20 @@ i965_BeginPicture(VADriverContextP ctx,
         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);
-        i965_release_buffer_store(&obj_context->codec_state.encode.packed_sps);
-        i965_release_buffer_store(&obj_context->codec_state.encode.packed_pps);
-        i965_release_buffer_store(&obj_context->codec_state.encode.packed_slice_header);
+
+
+        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]);
+
+        for (i = 0; i < ARRAY_ELEMS(obj_context->codec_state.encode.packed_header_data); i++)
+            i965_release_buffer_store(&obj_context->codec_state.encode.packed_header_data[i]);
 
         for (i = 0; i < obj_context->codec_state.encode.num_slice_params_ext; i++)
             i965_release_buffer_store(&obj_context->codec_state.encode.slice_params_ext[i]);
 
         obj_context->codec_state.encode.num_slice_params_ext = 0;
-
         obj_context->codec_state.encode.current_render_target = render_target;     /*This is input new frame*/
+        obj_context->codec_state.encode.last_packed_header_type = 0;
     } else {
         obj_context->codec_state.decode.current_render_target = render_target;
         i965_release_buffer_store(&obj_context->codec_state.decode.pic_param);
@@ -1477,14 +1507,43 @@ DEF_RENDER_ENCODE_SINGLE_BUFFER_FUNC(iqmatrix, iq_matrix)
 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)
-DEF_RENDER_ENCODE_SINGLE_BUFFER_FUNC(packed_sps, packed_sps)
-DEF_RENDER_ENCODE_SINGLE_BUFFER_FUNC(packed_pps, packed_pps)
-DEF_RENDER_ENCODE_SINGLE_BUFFER_FUNC(packed_slice_header, packed_slice_header)
 
 #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)
 DEF_RENDER_ENCODE_MULTI_BUFFER_FUNC(slice_parameter_ext, slice_params_ext)
 
+static VAStatus
+i965_encoder_render_packed_header_parameter_buffer(VADriverContextP ctx,
+                                                   struct object_context *obj_context,
+                                                   struct object_buffer *obj_buffer,
+                                                   VAEncPackedHeaderType type)
+{
+    struct encode_state *encode = &obj_context->codec_state.encode;
+
+    assert(obj_buffer->buffer_store->bo == NULL);
+    assert(obj_buffer->buffer_store->buffer);
+    i965_release_buffer_store(&encode->packed_header_param[type]);
+    i965_reference_buffer_store(&encode->packed_header_param[type], obj_buffer->buffer_store);
+
+    return VA_STATUS_SUCCESS;
+}
+
+static VAStatus
+i965_encoder_render_packed_header_data_buffer(VADriverContextP ctx,
+                                              struct object_context *obj_context,
+                                              struct object_buffer *obj_buffer,
+                                              VAEncPackedHeaderType type)
+{
+    struct encode_state *encode = &obj_context->codec_state.encode;
+
+    assert(obj_buffer->buffer_store->bo == NULL);
+    assert(obj_buffer->buffer_store->buffer);
+    i965_release_buffer_store(&encode->packed_header_data[type]);
+    i965_reference_buffer_store(&encode->packed_header_data[type], obj_buffer->buffer_store);
+
+    return VA_STATUS_SUCCESS;
+}
+
 static VAStatus 
 i965_encoder_render_picture(VADriverContextP ctx,
                             VAContextID context,
@@ -1541,17 +1600,32 @@ i965_encoder_render_picture(VADriverContextP ctx,
             vaStatus = I965_RENDER_ENCODE_BUFFER(dec_ref_pic_marking);
             break;
 
-        case VAEncPackedSequenceParameterBufferType:
-            vaStatus = I965_RENDER_ENCODE_BUFFER(packed_sps);
+        case VAEncPackedHeaderParameterBufferType:
+        {
+            struct encode_state *encode = &obj_context->codec_state.encode;
+            VAEncPackedHeaderParameterBuffer *param = (VAEncPackedHeaderParameterBuffer *)obj_buffer->buffer_store->buffer;
+            encode->last_packed_header_type = param->type;
+
+            vaStatus = i965_encoder_render_packed_header_parameter_buffer(ctx,
+                                                                          obj_context,
+                                                                          obj_buffer,
+                                                                          encode->last_packed_header_type);
             break;
+        }
 
-        case VAEncPackedPictureParameterBufferType:
-            vaStatus = I965_RENDER_ENCODE_BUFFER(packed_pps);
-            break;
-            
-        case VAEncPackedSliceParameterBufferType:
-            vaStatus = I965_RENDER_ENCODE_BUFFER(packed_slice_header);
-            break;
+        case VAEncPackedHeaderDataBufferType:
+        {
+            struct encode_state *encode = &obj_context->codec_state.encode;
+
+            assert(encode->last_packed_header_type == VAEncPackedHeaderSPS ||
+                   encode->last_packed_header_type == VAEncPackedHeaderPPS ||
+                   encode->last_packed_header_type == VAEncPackedHeaderSlice);
+            vaStatus = i965_encoder_render_packed_header_data_buffer(ctx, 
+                                                                     obj_context,
+                                                                     obj_buffer,
+                                                                     encode->last_packed_header_type);
+            break;       
+        }
 
         default:
             vaStatus = VA_STATUS_ERROR_UNSUPPORTED_BUFFERTYPE;

diff --git a/src/i965_drv_video.h b/src/i965_drv_video.h
index c2d9b1d..6285d7f 100644 (file)
--- a/src/i965_drv_video.h
+++ b/src/i965_drv_video.h
@@ -113,12 +113,12 @@ struct encode_state
     struct buffer_store *seq_param_ext;
     struct buffer_store *pic_param_ext;
     struct buffer_store *dec_ref_pic_marking;
-    struct buffer_store *packed_sps;
-    struct buffer_store *packed_pps;
-    struct buffer_store *packed_slice_header;
+    struct buffer_store *packed_header_param[4];
+    struct buffer_store *packed_header_data[4];
     struct buffer_store **slice_params_ext;
     int max_slice_params_ext;
     int num_slice_params_ext;
+    int last_packed_header_type;
 
     VASurfaceID current_render_target;
 };

diff --git a/src/i965_encoder_utils.c b/src/i965_encoder_utils.c
index 6bfac36..ab120b5 100644 (file)
--- a/src/i965_encoder_utils.c
+++ b/src/i965_encoder_utils.c
@@ -196,7 +196,7 @@ slice_header(avc_bitstream *bs,
              VAEncSliceParameterBufferH264Ext *slice_param,
              VAEncH264DecRefPicMarkingBuffer *dec_ref_pic_marking_param)
 {
-    int first_mb_in_slice = sps_param->picture_width_in_mbs * slice_param->start_row_number;
+    int first_mb_in_slice = slice_param->starting_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 */