| /* | |
| * gstvaapiencoder_objects.c - VA encoder objects abstraction | |
| * | |
| * Copyright (C) 2013-2014 Intel Corporation | |
| * Author: Wind Yuan <feng.yuan@intel.com> | |
| * | |
| * This library is free software; you can redistribute it and/or | |
| * modify it under the terms of the GNU Lesser General Public License | |
| * as published by the Free Software Foundation; either version 2.1 | |
| * of the License, or (at your option) any later version. | |
| * | |
| * This library is distributed in the hope that it will be useful, | |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
| * Lesser General Public License for more details. | |
| * | |
| * You should have received a copy of the GNU Lesser General Public | |
| * License along with this library; if not, write to the Free | |
| * Software Foundation, Inc., 51 Franklin Street, Fifth Floor, | |
| * Boston, MA 02110-1301 USA | |
| */ | |
| #include "sysdeps.h" | |
| #include "gstvaapiencoder_objects.h" | |
| #include "gstvaapiencoder_priv.h" | |
| #include "gstvaapisurfaceproxy_priv.h" | |
| #include "gstvaapicompat.h" | |
| #include "gstvaapiutils.h" | |
| #define DEBUG 1 | |
| #include "gstvaapidebug.h" | |
| #define GET_ENCODER(obj) GST_VAAPI_ENCODER_CAST((obj)->parent_instance.codec) | |
| #define GET_VA_DISPLAY(obj) GET_ENCODER(obj)->va_display | |
| #define GET_VA_CONTEXT(obj) GET_ENCODER(obj)->va_context | |
| /* ------------------------------------------------------------------------- */ | |
| /* --- Encoder Packed Header --- */ | |
| /* ------------------------------------------------------------------------- */ | |
| GST_VAAPI_CODEC_DEFINE_TYPE (GstVaapiEncPackedHeader, | |
| gst_vaapi_enc_packed_header); | |
| void | |
| gst_vaapi_enc_packed_header_destroy (GstVaapiEncPackedHeader * header) | |
| { | |
| vaapi_destroy_buffer (GET_VA_DISPLAY (header), &header->param_id); | |
| vaapi_destroy_buffer (GET_VA_DISPLAY (header), &header->data_id); | |
| header->param = NULL; | |
| header->data = NULL; | |
| } | |
| gboolean | |
| gst_vaapi_enc_packed_header_create (GstVaapiEncPackedHeader * header, | |
| const GstVaapiCodecObjectConstructorArgs * args) | |
| { | |
| gboolean success; | |
| header->param_id = VA_INVALID_ID; | |
| header->data_id = VA_INVALID_ID; | |
| success = vaapi_create_buffer (GET_VA_DISPLAY (header), | |
| GET_VA_CONTEXT (header), | |
| VAEncPackedHeaderParameterBufferType, | |
| args->param_size, args->param, &header->param_id, &header->param); | |
| if (!success) | |
| return FALSE; | |
| if (!args->data_size) | |
| return TRUE; | |
| success = vaapi_create_buffer (GET_VA_DISPLAY (header), | |
| GET_VA_CONTEXT (header), | |
| VAEncPackedHeaderDataBufferType, | |
| args->data_size, args->data, &header->data_id, &header->data); | |
| if (!success) | |
| return FALSE; | |
| return TRUE; | |
| } | |
| GstVaapiEncPackedHeader * | |
| gst_vaapi_enc_packed_header_new (GstVaapiEncoder * encoder, | |
| gconstpointer param, guint param_size, gconstpointer data, guint data_size) | |
| { | |
| GstVaapiCodecObject *object; | |
| object = gst_vaapi_codec_object_new (&GstVaapiEncPackedHeaderClass, | |
| GST_VAAPI_CODEC_BASE (encoder), param, param_size, data, data_size, 0); | |
| return GST_VAAPI_ENC_PACKED_HEADER (object); | |
| } | |
| gboolean | |
| gst_vaapi_enc_packed_header_set_data (GstVaapiEncPackedHeader * header, | |
| gconstpointer data, guint data_size) | |
| { | |
| gboolean success; | |
| vaapi_destroy_buffer (GET_VA_DISPLAY (header), &header->data_id); | |
| header->data = NULL; | |
| success = vaapi_create_buffer (GET_VA_DISPLAY (header), | |
| GET_VA_CONTEXT (header), | |
| VAEncPackedHeaderDataBufferType, | |
| data_size, data, &header->data_id, &header->data); | |
| if (!success) | |
| return FALSE; | |
| return TRUE; | |
| } | |
| /* ------------------------------------------------------------------------- */ | |
| /* --- Encoder Sequence --- */ | |
| /* ------------------------------------------------------------------------- */ | |
| GST_VAAPI_CODEC_DEFINE_TYPE (GstVaapiEncSequence, gst_vaapi_enc_sequence); | |
| void | |
| gst_vaapi_enc_sequence_destroy (GstVaapiEncSequence * sequence) | |
| { | |
| vaapi_destroy_buffer (GET_VA_DISPLAY (sequence), &sequence->param_id); | |
| sequence->param = NULL; | |
| } | |
| gboolean | |
| gst_vaapi_enc_sequence_create (GstVaapiEncSequence * sequence, | |
| const GstVaapiCodecObjectConstructorArgs * args) | |
| { | |
| gboolean success; | |
| sequence->param_id = VA_INVALID_ID; | |
| success = vaapi_create_buffer (GET_VA_DISPLAY (sequence), | |
| GET_VA_CONTEXT (sequence), | |
| VAEncSequenceParameterBufferType, | |
| args->param_size, args->param, &sequence->param_id, &sequence->param); | |
| if (!success) | |
| return FALSE; | |
| return TRUE; | |
| } | |
| GstVaapiEncSequence * | |
| gst_vaapi_enc_sequence_new (GstVaapiEncoder * encoder, | |
| gconstpointer param, guint param_size) | |
| { | |
| GstVaapiCodecObject *object; | |
| object = gst_vaapi_codec_object_new (&GstVaapiEncSequenceClass, | |
| GST_VAAPI_CODEC_BASE (encoder), param, param_size, NULL, 0, 0); | |
| return GST_VAAPI_ENC_SEQUENCE (object); | |
| } | |
| /* ------------------------------------------------------------------------- */ | |
| /* --- Encoder Slice --- */ | |
| /* ------------------------------------------------------------------------- */ | |
| GST_VAAPI_CODEC_DEFINE_TYPE (GstVaapiEncSlice, gst_vaapi_enc_slice); | |
| void | |
| gst_vaapi_enc_slice_destroy (GstVaapiEncSlice * slice) | |
| { | |
| if (slice->packed_headers) { | |
| g_ptr_array_unref (slice->packed_headers); | |
| slice->packed_headers = NULL; | |
| } | |
| vaapi_destroy_buffer (GET_VA_DISPLAY (slice), &slice->param_id); | |
| slice->param = NULL; | |
| } | |
| gboolean | |
| gst_vaapi_enc_slice_create (GstVaapiEncSlice * slice, | |
| const GstVaapiCodecObjectConstructorArgs * args) | |
| { | |
| gboolean success; | |
| slice->param_id = VA_INVALID_ID; | |
| success = vaapi_create_buffer (GET_VA_DISPLAY (slice), | |
| GET_VA_CONTEXT (slice), | |
| VAEncSliceParameterBufferType, | |
| args->param_size, args->param, &slice->param_id, &slice->param); | |
| if (!success) | |
| return FALSE; | |
| slice->packed_headers = g_ptr_array_new_with_free_func ((GDestroyNotify) | |
| gst_vaapi_mini_object_unref); | |
| if (!slice->packed_headers) | |
| return FALSE; | |
| return TRUE; | |
| } | |
| GstVaapiEncSlice * | |
| gst_vaapi_enc_slice_new (GstVaapiEncoder * encoder, | |
| gconstpointer param, guint param_size) | |
| { | |
| GstVaapiCodecObject *object; | |
| object = gst_vaapi_codec_object_new (&GstVaapiEncSliceClass, | |
| GST_VAAPI_CODEC_BASE (encoder), param, param_size, NULL, 0, 0); | |
| return GST_VAAPI_ENC_SLICE (object); | |
| } | |
| /* ------------------------------------------------------------------------- */ | |
| /* --- Encoder Misc Parameter Buffer --- */ | |
| /* ------------------------------------------------------------------------- */ | |
| GST_VAAPI_CODEC_DEFINE_TYPE (GstVaapiEncMiscParam, gst_vaapi_enc_misc_param); | |
| void | |
| gst_vaapi_enc_misc_param_destroy (GstVaapiEncMiscParam * misc) | |
| { | |
| vaapi_destroy_buffer (GET_VA_DISPLAY (misc), &misc->param_id); | |
| misc->param = NULL; | |
| misc->data = NULL; | |
| } | |
| gboolean | |
| gst_vaapi_enc_misc_param_create (GstVaapiEncMiscParam * misc, | |
| const GstVaapiCodecObjectConstructorArgs * args) | |
| { | |
| gboolean success; | |
| misc->param_id = VA_INVALID_ID; | |
| success = vaapi_create_buffer (GET_VA_DISPLAY (misc), | |
| GET_VA_CONTEXT (misc), | |
| VAEncMiscParameterBufferType, | |
| args->param_size, args->param, &misc->param_id, &misc->param); | |
| if (!success) | |
| return FALSE; | |
| return TRUE; | |
| } | |
| GstVaapiEncMiscParam * | |
| gst_vaapi_enc_misc_param_new (GstVaapiEncoder * encoder, | |
| VAEncMiscParameterType type, guint data_size) | |
| { | |
| GstVaapiCodecObject *object; | |
| GstVaapiEncMiscParam *misc; | |
| VAEncMiscParameterBuffer *va_misc; | |
| object = gst_vaapi_codec_object_new (&GstVaapiEncMiscParamClass, | |
| GST_VAAPI_CODEC_BASE (encoder), | |
| NULL, sizeof (VAEncMiscParameterBuffer) + data_size, NULL, 0, 0); | |
| if (!object) | |
| return NULL; | |
| misc = GST_VAAPI_ENC_MISC_PARAM (object); | |
| va_misc = misc->param; | |
| va_misc->type = type; | |
| misc->data = va_misc->data; | |
| return misc; | |
| } | |
| /* ------------------------------------------------------------------------- */ | |
| /* --- Quantization Matrices --- */ | |
| /* ------------------------------------------------------------------------- */ | |
| GST_VAAPI_CODEC_DEFINE_TYPE (GstVaapiEncQMatrix, gst_vaapi_enc_q_matrix); | |
| void | |
| gst_vaapi_enc_q_matrix_destroy (GstVaapiEncQMatrix * q_matrix) | |
| { | |
| vaapi_destroy_buffer (GET_VA_DISPLAY (q_matrix), &q_matrix->param_id); | |
| q_matrix->param = NULL; | |
| } | |
| gboolean | |
| gst_vaapi_enc_q_matrix_create (GstVaapiEncQMatrix * q_matrix, | |
| const GstVaapiCodecObjectConstructorArgs * args) | |
| { | |
| q_matrix->param_id = VA_INVALID_ID; | |
| return vaapi_create_buffer (GET_VA_DISPLAY (q_matrix), | |
| GET_VA_CONTEXT (q_matrix), VAQMatrixBufferType, | |
| args->param_size, args->param, &q_matrix->param_id, &q_matrix->param); | |
| } | |
| GstVaapiEncQMatrix * | |
| gst_vaapi_enc_q_matrix_new (GstVaapiEncoder * encoder, | |
| gconstpointer param, guint param_size) | |
| { | |
| GstVaapiCodecObject *object; | |
| object = gst_vaapi_codec_object_new (&GstVaapiEncQMatrixClass, | |
| GST_VAAPI_CODEC_BASE (encoder), param, param_size, NULL, 0, 0); | |
| if (!object) | |
| return NULL; | |
| return GST_VAAPI_ENC_Q_MATRIX_CAST (object); | |
| } | |
| /* ------------------------------------------------------------------------- */ | |
| /* --- JPEG Huffman Tables --- */ | |
| /* ------------------------------------------------------------------------- */ | |
| GST_VAAPI_CODEC_DEFINE_TYPE (GstVaapiEncHuffmanTable, | |
| gst_vaapi_enc_huffman_table); | |
| void | |
| gst_vaapi_enc_huffman_table_destroy (GstVaapiEncHuffmanTable * huf_table) | |
| { | |
| vaapi_destroy_buffer (GET_VA_DISPLAY (huf_table), &huf_table->param_id); | |
| huf_table->param = NULL; | |
| } | |
| gboolean | |
| gst_vaapi_enc_huffman_table_create (GstVaapiEncHuffmanTable * huf_table, | |
| const GstVaapiCodecObjectConstructorArgs * args) | |
| { | |
| huf_table->param_id = VA_INVALID_ID; | |
| return vaapi_create_buffer (GET_VA_DISPLAY (huf_table), | |
| GET_VA_CONTEXT (huf_table), VAHuffmanTableBufferType, args->param_size, | |
| args->param, &huf_table->param_id, (void **) &huf_table->param); | |
| } | |
| GstVaapiEncHuffmanTable * | |
| gst_vaapi_enc_huffman_table_new (GstVaapiEncoder * encoder, | |
| guint8 * data, guint data_size) | |
| { | |
| GstVaapiCodecObject *object; | |
| object = gst_vaapi_codec_object_new (&GstVaapiEncHuffmanTableClass, | |
| GST_VAAPI_CODEC_BASE (encoder), data, data_size, NULL, 0, 0); | |
| if (!object) | |
| return NULL; | |
| return GST_VAAPI_ENC_HUFFMAN_TABLE_CAST (object); | |
| } | |
| /* ------------------------------------------------------------------------- */ | |
| /* --- Encoder Picture --- */ | |
| /* ------------------------------------------------------------------------- */ | |
| GST_VAAPI_CODEC_DEFINE_TYPE (GstVaapiEncPicture, gst_vaapi_enc_picture); | |
| void | |
| gst_vaapi_enc_picture_destroy (GstVaapiEncPicture * picture) | |
| { | |
| if (picture->packed_headers) { | |
| g_ptr_array_unref (picture->packed_headers); | |
| picture->packed_headers = NULL; | |
| } | |
| if (picture->misc_params) { | |
| g_ptr_array_unref (picture->misc_params); | |
| picture->misc_params = NULL; | |
| } | |
| if (picture->slices) { | |
| g_ptr_array_unref (picture->slices); | |
| picture->slices = NULL; | |
| } | |
| gst_vaapi_codec_object_replace (&picture->q_matrix, NULL); | |
| gst_vaapi_codec_object_replace (&picture->huf_table, NULL); | |
| gst_vaapi_codec_object_replace (&picture->sequence, NULL); | |
| gst_vaapi_surface_proxy_replace (&picture->proxy, NULL); | |
| picture->surface_id = VA_INVALID_ID; | |
| picture->surface = NULL; | |
| vaapi_destroy_buffer (GET_VA_DISPLAY (picture), &picture->param_id); | |
| picture->param = NULL; | |
| if (picture->frame) { | |
| gst_video_codec_frame_unref (picture->frame); | |
| picture->frame = NULL; | |
| } | |
| } | |
| gboolean | |
| gst_vaapi_enc_picture_create (GstVaapiEncPicture * picture, | |
| const GstVaapiCodecObjectConstructorArgs * args) | |
| { | |
| GstVideoCodecFrame *const frame = (GstVideoCodecFrame *) args->data; | |
| gboolean success; | |
| picture->proxy = gst_video_codec_frame_get_user_data (frame); | |
| if (!gst_vaapi_surface_proxy_ref (picture->proxy)) | |
| return FALSE; | |
| picture->surface = GST_VAAPI_SURFACE_PROXY_SURFACE (picture->proxy); | |
| if (!picture->surface) | |
| return FALSE; | |
| picture->surface_id = GST_VAAPI_SURFACE_ID (picture->surface); | |
| if (picture->surface_id == VA_INVALID_ID) | |
| return FALSE; | |
| picture->type = GST_VAAPI_PICTURE_TYPE_NONE; | |
| picture->pts = GST_CLOCK_TIME_NONE; | |
| picture->frame_num = 0; | |
| picture->poc = 0; | |
| picture->param_id = VA_INVALID_ID; | |
| picture->param_size = args->param_size; | |
| success = vaapi_create_buffer (GET_VA_DISPLAY (picture), | |
| GET_VA_CONTEXT (picture), | |
| VAEncPictureParameterBufferType, | |
| args->param_size, args->param, &picture->param_id, &picture->param); | |
| if (!success) | |
| return FALSE; | |
| picture->param_size = args->param_size; | |
| picture->packed_headers = g_ptr_array_new_with_free_func ((GDestroyNotify) | |
| gst_vaapi_mini_object_unref); | |
| if (!picture->packed_headers) | |
| return FALSE; | |
| picture->misc_params = g_ptr_array_new_with_free_func ((GDestroyNotify) | |
| gst_vaapi_mini_object_unref); | |
| if (!picture->misc_params) | |
| return FALSE; | |
| picture->slices = g_ptr_array_new_with_free_func ((GDestroyNotify) | |
| gst_vaapi_mini_object_unref); | |
| if (!picture->slices) | |
| return FALSE; | |
| picture->frame = gst_video_codec_frame_ref (frame); | |
| return TRUE; | |
| } | |
| GstVaapiEncPicture * | |
| gst_vaapi_enc_picture_new (GstVaapiEncoder * encoder, | |
| gconstpointer param, guint param_size, GstVideoCodecFrame * frame) | |
| { | |
| GstVaapiCodecObject *object; | |
| g_return_val_if_fail (frame != NULL, NULL); | |
| object = gst_vaapi_codec_object_new (&GstVaapiEncPictureClass, | |
| GST_VAAPI_CODEC_BASE (encoder), param, param_size, frame, 0, 0); | |
| return GST_VAAPI_ENC_PICTURE (object); | |
| } | |
| void | |
| gst_vaapi_enc_picture_set_sequence (GstVaapiEncPicture * picture, | |
| GstVaapiEncSequence * sequence) | |
| { | |
| g_return_if_fail (picture != NULL); | |
| g_return_if_fail (sequence != NULL); | |
| gst_vaapi_codec_object_replace (&picture->sequence, sequence); | |
| } | |
| void | |
| gst_vaapi_enc_picture_add_packed_header (GstVaapiEncPicture * picture, | |
| GstVaapiEncPackedHeader * header) | |
| { | |
| g_return_if_fail (picture != NULL); | |
| g_return_if_fail (header != NULL); | |
| g_ptr_array_add (picture->packed_headers, | |
| gst_vaapi_codec_object_ref (header)); | |
| } | |
| void | |
| gst_vaapi_enc_picture_add_misc_param (GstVaapiEncPicture * picture, | |
| GstVaapiEncMiscParam * misc) | |
| { | |
| g_return_if_fail (picture != NULL); | |
| g_return_if_fail (misc != NULL); | |
| g_ptr_array_add (picture->misc_params, gst_vaapi_codec_object_ref (misc)); | |
| } | |
| void | |
| gst_vaapi_enc_picture_add_slice (GstVaapiEncPicture * picture, | |
| GstVaapiEncSlice * slice) | |
| { | |
| g_return_if_fail (picture != NULL); | |
| g_return_if_fail (slice != NULL); | |
| g_ptr_array_add (picture->slices, gst_vaapi_codec_object_ref (slice)); | |
| } | |
| void | |
| gst_vaapi_enc_slice_add_packed_header (GstVaapiEncSlice * slice, | |
| GstVaapiEncPackedHeader * header) | |
| { | |
| g_return_if_fail (slice != NULL); | |
| g_return_if_fail (header != NULL); | |
| g_ptr_array_add (slice->packed_headers, gst_vaapi_codec_object_ref (header)); | |
| } | |
| static gboolean | |
| do_encode (VADisplay dpy, VAContextID ctx, VABufferID * buf_id, void **buf_ptr) | |
| { | |
| VAStatus status; | |
| vaapi_unmap_buffer (dpy, *buf_id, buf_ptr); | |
| status = vaRenderPicture (dpy, ctx, buf_id, 1); | |
| if (!vaapi_check_status (status, "vaRenderPicture()")) | |
| return FALSE; | |
| /* XXX: vaRenderPicture() is meant to destroy the VA buffer implicitly */ | |
| vaapi_destroy_buffer (dpy, buf_id); | |
| return TRUE; | |
| } | |
| gboolean | |
| gst_vaapi_enc_picture_encode (GstVaapiEncPicture * picture) | |
| { | |
| GstVaapiEncSequence *sequence; | |
| GstVaapiEncQMatrix *q_matrix; | |
| GstVaapiEncHuffmanTable *huf_table; | |
| VADisplay va_display; | |
| VAContextID va_context; | |
| VAStatus status; | |
| guint i; | |
| g_return_val_if_fail (picture != NULL, FALSE); | |
| g_return_val_if_fail (picture->surface_id != VA_INVALID_SURFACE, FALSE); | |
| va_display = GET_VA_DISPLAY (picture); | |
| va_context = GET_VA_CONTEXT (picture); | |
| GST_DEBUG ("encode picture 0x%08x", picture->surface_id); | |
| status = vaBeginPicture (va_display, va_context, picture->surface_id); | |
| if (!vaapi_check_status (status, "vaBeginPicture()")) | |
| return FALSE; | |
| /* Submit Sequence parameter */ | |
| sequence = picture->sequence; | |
| if (sequence && !do_encode (va_display, va_context, | |
| &sequence->param_id, &sequence->param)) | |
| return FALSE; | |
| /* Submit Quantization matrix */ | |
| q_matrix = picture->q_matrix; | |
| if (q_matrix && !do_encode (va_display, va_context, | |
| &q_matrix->param_id, &q_matrix->param)) | |
| return FALSE; | |
| /* Submit huffman table */ | |
| huf_table = picture->huf_table; | |
| if (huf_table && !do_encode (va_display, va_context, | |
| &huf_table->param_id, (void **) &huf_table->param)) | |
| return FALSE; | |
| /* Submit Packed Headers */ | |
| for (i = 0; i < picture->packed_headers->len; i++) { | |
| GstVaapiEncPackedHeader *const header = | |
| g_ptr_array_index (picture->packed_headers, i); | |
| if (!do_encode (va_display, va_context, | |
| &header->param_id, &header->param) || | |
| !do_encode (va_display, va_context, &header->data_id, &header->data)) | |
| return FALSE; | |
| } | |
| /* Submit Picture parameter */ | |
| if (!do_encode (va_display, va_context, &picture->param_id, &picture->param)) | |
| return FALSE; | |
| /* Submit Misc Params */ | |
| for (i = 0; i < picture->misc_params->len; i++) { | |
| GstVaapiEncMiscParam *const misc = | |
| g_ptr_array_index (picture->misc_params, i); | |
| if (!do_encode (va_display, va_context, &misc->param_id, &misc->param)) | |
| return FALSE; | |
| } | |
| /* Submit Slice parameters */ | |
| for (i = 0; i < picture->slices->len; i++) { | |
| GstVaapiEncSlice *const slice = g_ptr_array_index (picture->slices, i); | |
| guint j; | |
| /* Submit packed_slice_header and packed_raw_data */ | |
| for (j = 0; j < slice->packed_headers->len; j++) { | |
| GstVaapiEncPackedHeader *const header = | |
| g_ptr_array_index (slice->packed_headers, j); | |
| if (!do_encode (va_display, va_context, | |
| &header->param_id, &header->param) || | |
| !do_encode (va_display, va_context, &header->data_id, &header->data)) | |
| return FALSE; | |
| } | |
| if (!do_encode (va_display, va_context, &slice->param_id, &slice->param)) | |
| return FALSE; | |
| } | |
| status = vaEndPicture (va_display, va_context); | |
| if (!vaapi_check_status (status, "vaEndPicture()")) | |
| return FALSE; | |
| return TRUE; | |
| } |