| /* | |
| * gstvaapiencoder.c - VA encoder abstraction | |
| * | |
| * Copyright (C) 2013-2014 Intel Corporation | |
| * Author: Wind Yuan <feng.yuan@intel.com> | |
| * Author: Gwenole Beauchesne <gwenole.beauchesne@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 "gstvaapicompat.h" | |
| #include "gstvaapiencoder.h" | |
| #include "gstvaapiencoder_priv.h" | |
| #include "gstvaapicontext.h" | |
| #include "gstvaapidisplay_priv.h" | |
| #include "gstvaapiutils.h" | |
| #include "gstvaapiutils_core.h" | |
| #include "gstvaapivalue.h" | |
| #define DEBUG 1 | |
| #include "gstvaapidebug.h" | |
| gboolean | |
| gst_vaapi_encoder_ensure_param_quality_level (GstVaapiEncoder * encoder, | |
| GstVaapiEncPicture * picture) | |
| { | |
| GstVaapiEncMiscParam *misc; | |
| /* quality level param is not supported */ | |
| if (GST_VAAPI_ENCODER_QUALITY_LEVEL (encoder) == 0) | |
| return TRUE; | |
| misc = GST_VAAPI_ENC_QUALITY_LEVEL_MISC_PARAM_NEW (encoder); | |
| if (!misc) | |
| return FALSE; | |
| memcpy (misc->data, &encoder->va_quality_level, | |
| sizeof (encoder->va_quality_level)); | |
| gst_vaapi_enc_picture_add_misc_param (picture, misc); | |
| gst_vaapi_codec_object_replace (&misc, NULL); | |
| return TRUE; | |
| } | |
| gboolean | |
| gst_vaapi_encoder_ensure_param_control_rate (GstVaapiEncoder * encoder, | |
| GstVaapiEncPicture * picture) | |
| { | |
| GstVaapiEncMiscParam *misc; | |
| if (GST_VAAPI_ENCODER_RATE_CONTROL (encoder) == GST_VAAPI_RATECONTROL_CQP) | |
| return TRUE; | |
| /* HRD params */ | |
| misc = GST_VAAPI_ENC_MISC_PARAM_NEW (HRD, encoder); | |
| if (!misc) | |
| return FALSE; | |
| memcpy (misc->data, &GST_VAAPI_ENCODER_VA_HRD (encoder), | |
| sizeof (VAEncMiscParameterHRD)); | |
| gst_vaapi_enc_picture_add_misc_param (picture, misc); | |
| gst_vaapi_codec_object_replace (&misc, NULL); | |
| /* RateControl params */ | |
| misc = GST_VAAPI_ENC_MISC_PARAM_NEW (RateControl, encoder); | |
| if (!misc) | |
| return FALSE; | |
| memcpy (misc->data, &GST_VAAPI_ENCODER_VA_RATE_CONTROL (encoder), | |
| sizeof (VAEncMiscParameterRateControl)); | |
| gst_vaapi_enc_picture_add_misc_param (picture, misc); | |
| gst_vaapi_codec_object_replace (&misc, NULL); | |
| /* FrameRate params */ | |
| if (GST_VAAPI_ENCODER_VA_FRAME_RATE (encoder).framerate == 0) | |
| return TRUE; | |
| misc = GST_VAAPI_ENC_MISC_PARAM_NEW (FrameRate, encoder); | |
| if (!misc) | |
| return FALSE; | |
| memcpy (misc->data, &GST_VAAPI_ENCODER_VA_FRAME_RATE (encoder), | |
| sizeof (VAEncMiscParameterFrameRate)); | |
| gst_vaapi_enc_picture_add_misc_param (picture, misc); | |
| gst_vaapi_codec_object_replace (&misc, NULL); | |
| return TRUE; | |
| } | |
| gboolean | |
| gst_vaapi_encoder_ensure_param_trellis (GstVaapiEncoder * encoder, | |
| GstVaapiEncPicture * picture) | |
| { | |
| #if VA_CHECK_VERSION(1,0,0) | |
| GstVaapiEncMiscParam *misc; | |
| VAEncMiscParameterQuantization *param; | |
| if (!encoder->trellis) | |
| return TRUE; | |
| misc = GST_VAAPI_ENC_QUANTIZATION_MISC_PARAM_NEW (encoder); | |
| if (!misc) | |
| return FALSE; | |
| if (!misc->data) | |
| return FALSE; | |
| param = (VAEncMiscParameterQuantization *) misc->data; | |
| param->quantization_flags.bits.disable_trellis = 0; | |
| param->quantization_flags.bits.enable_trellis_I = 1; | |
| param->quantization_flags.bits.enable_trellis_B = 1; | |
| param->quantization_flags.bits.enable_trellis_P = 1; | |
| gst_vaapi_enc_picture_add_misc_param (picture, misc); | |
| gst_vaapi_codec_object_replace (&misc, NULL); | |
| #endif | |
| return TRUE; | |
| } | |
| gboolean | |
| gst_vaapi_encoder_ensure_param_roi_regions (GstVaapiEncoder * encoder, | |
| GstVaapiEncPicture * picture) | |
| { | |
| #if VA_CHECK_VERSION(0,39,1) | |
| GstVaapiContextInfo *const cip = &encoder->context_info; | |
| const GstVaapiConfigInfoEncoder *const config = &cip->config.encoder; | |
| VAEncMiscParameterBufferROI *roi_param; | |
| GstVaapiEncMiscParam *misc; | |
| VAEncROI *region_roi; | |
| GstBuffer *input; | |
| guint num_roi, i; | |
| gpointer state = NULL; | |
| if (!config->roi_capability) | |
| return TRUE; | |
| if (!picture->frame) | |
| return FALSE; | |
| input = picture->frame->input_buffer; | |
| if (!input) | |
| return FALSE; | |
| num_roi = | |
| gst_buffer_get_n_meta (input, GST_VIDEO_REGION_OF_INTEREST_META_API_TYPE); | |
| if (num_roi == 0) | |
| return TRUE; | |
| num_roi = CLAMP (num_roi, 1, config->roi_num_supported); | |
| misc = | |
| gst_vaapi_enc_misc_param_new (encoder, VAEncMiscParameterTypeROI, | |
| sizeof (VAEncMiscParameterBufferROI) + num_roi * sizeof (VAEncROI)); | |
| if (!misc) | |
| return FALSE; | |
| region_roi = | |
| (VAEncROI *) ((guint8 *) misc->param + sizeof (VAEncMiscParameterBuffer) + | |
| sizeof (VAEncMiscParameterBufferROI)); | |
| roi_param = misc->data; | |
| roi_param->num_roi = num_roi; | |
| roi_param->roi = region_roi; | |
| /* roi_value in VAEncROI should be used as ROI delta QP */ | |
| roi_param->roi_flags.bits.roi_value_is_qp_delta = 1; | |
| roi_param->max_delta_qp = 10; | |
| roi_param->min_delta_qp = -10; | |
| for (i = 0; i < num_roi; i++) { | |
| GstVideoRegionOfInterestMeta *roi; | |
| GstStructure *s; | |
| roi = (GstVideoRegionOfInterestMeta *) | |
| gst_buffer_iterate_meta_filtered (input, &state, | |
| GST_VIDEO_REGION_OF_INTEREST_META_API_TYPE); | |
| if (!roi) | |
| continue; | |
| /* ignore roi if overflow */ | |
| if ((roi->x > G_MAXINT16) || (roi->y > G_MAXINT16) | |
| || (roi->w > G_MAXUINT16) || (roi->h > G_MAXUINT16)) | |
| continue; | |
| GST_LOG ("Input buffer ROI: type=%s id=%d (%d, %d) %dx%d", | |
| g_quark_to_string (roi->roi_type), roi->id, roi->x, roi->y, roi->w, | |
| roi->h); | |
| picture->has_roi = TRUE; | |
| region_roi[i].roi_rectangle.x = roi->x; | |
| region_roi[i].roi_rectangle.y = roi->y; | |
| region_roi[i].roi_rectangle.width = roi->w; | |
| region_roi[i].roi_rectangle.height = roi->h; | |
| s = gst_video_region_of_interest_meta_get_param (roi, "roi/vaapi"); | |
| if (s) { | |
| int value = 0; | |
| if (!gst_structure_get_int (s, "delta-qp", &value)) | |
| continue; | |
| value = CLAMP (value, roi_param->min_delta_qp, roi_param->max_delta_qp); | |
| region_roi[i].roi_value = value; | |
| } else { | |
| region_roi[i].roi_value = encoder->default_roi_value; | |
| GST_LOG ("No ROI value specified upstream, use default (%d)", | |
| encoder->default_roi_value); | |
| } | |
| } | |
| if (picture->has_roi) | |
| gst_vaapi_enc_picture_add_misc_param (picture, misc); | |
| gst_vaapi_codec_object_replace (&misc, NULL); | |
| #endif | |
| return TRUE; | |
| } | |
| /** | |
| * gst_vaapi_encoder_replace: | |
| * @old_encoder_ptr: a pointer to a #GstVaapiEncoder | |
| * @new_encoder: a #GstVaapiEncoder | |
| * | |
| * Atomically replaces the encoder encoder held in @old_encoder_ptr | |
| * with @new_encoder. This means that @old_encoder_ptr shall reference | |
| * a valid encoder. However, @new_encoder can be NULL. | |
| */ | |
| void | |
| gst_vaapi_encoder_replace (GstVaapiEncoder ** old_encoder_ptr, | |
| GstVaapiEncoder * new_encoder) | |
| { | |
| gst_object_replace ((GstObject **) old_encoder_ptr, | |
| (GstObject *) new_encoder); | |
| } | |
| /* Notifies gst_vaapi_encoder_create_coded_buffer() that a new buffer is free */ | |
| static void | |
| _coded_buffer_proxy_released_notify (GstVaapiEncoder * encoder) | |
| { | |
| g_mutex_lock (&encoder->mutex); | |
| g_cond_signal (&encoder->codedbuf_free); | |
| g_mutex_unlock (&encoder->mutex); | |
| } | |
| /* Creates a new VA coded buffer object proxy, backed from a pool */ | |
| static GstVaapiCodedBufferProxy * | |
| gst_vaapi_encoder_create_coded_buffer (GstVaapiEncoder * encoder) | |
| { | |
| GstVaapiCodedBufferPool *const pool = | |
| GST_VAAPI_CODED_BUFFER_POOL (encoder->codedbuf_pool); | |
| GstVaapiCodedBufferProxy *codedbuf_proxy; | |
| g_mutex_lock (&encoder->mutex); | |
| do { | |
| codedbuf_proxy = gst_vaapi_coded_buffer_proxy_new_from_pool (pool); | |
| if (codedbuf_proxy) | |
| break; | |
| /* Wait for a free coded buffer to become available */ | |
| g_cond_wait (&encoder->codedbuf_free, &encoder->mutex); | |
| codedbuf_proxy = gst_vaapi_coded_buffer_proxy_new_from_pool (pool); | |
| } while (0); | |
| g_mutex_unlock (&encoder->mutex); | |
| if (!codedbuf_proxy) | |
| return NULL; | |
| gst_vaapi_coded_buffer_proxy_set_destroy_notify (codedbuf_proxy, | |
| (GDestroyNotify) _coded_buffer_proxy_released_notify, encoder); | |
| return codedbuf_proxy; | |
| } | |
| /* Notifies gst_vaapi_encoder_create_surface() that a new surface is free */ | |
| static void | |
| _surface_proxy_released_notify (GstVaapiEncoder * encoder) | |
| { | |
| g_mutex_lock (&encoder->mutex); | |
| g_cond_signal (&encoder->surface_free); | |
| g_mutex_unlock (&encoder->mutex); | |
| } | |
| /* Creates a new VA surface object proxy, backed from a pool and | |
| useful to allocate reconstructed surfaces */ | |
| GstVaapiSurfaceProxy * | |
| gst_vaapi_encoder_create_surface (GstVaapiEncoder * encoder) | |
| { | |
| GstVaapiSurfaceProxy *proxy; | |
| g_return_val_if_fail (encoder->context != NULL, NULL); | |
| g_mutex_lock (&encoder->mutex); | |
| for (;;) { | |
| proxy = gst_vaapi_context_get_surface_proxy (encoder->context); | |
| if (proxy) | |
| break; | |
| /* Wait for a free surface proxy to become available */ | |
| g_cond_wait (&encoder->surface_free, &encoder->mutex); | |
| } | |
| g_mutex_unlock (&encoder->mutex); | |
| gst_vaapi_surface_proxy_set_destroy_notify (proxy, | |
| (GDestroyNotify) _surface_proxy_released_notify, encoder); | |
| return proxy; | |
| } | |
| /* Create a coded buffer proxy where the picture is going to be | |
| * decoded, the subclass encode vmethod is called and, if it doesn't | |
| * fail, the coded buffer is pushed into the async queue */ | |
| static GstVaapiEncoderStatus | |
| gst_vaapi_encoder_encode_and_queue (GstVaapiEncoder * encoder, | |
| GstVaapiEncPicture * picture) | |
| { | |
| GstVaapiEncoderClass *const klass = GST_VAAPI_ENCODER_GET_CLASS (encoder); | |
| GstVaapiCodedBufferProxy *codedbuf_proxy; | |
| GstVaapiEncoderStatus status; | |
| codedbuf_proxy = gst_vaapi_encoder_create_coded_buffer (encoder); | |
| if (!codedbuf_proxy) | |
| goto error_create_coded_buffer; | |
| status = klass->encode (encoder, picture, codedbuf_proxy); | |
| if (status != GST_VAAPI_ENCODER_STATUS_SUCCESS) | |
| goto error_encode; | |
| gst_vaapi_coded_buffer_proxy_set_user_data (codedbuf_proxy, | |
| picture, (GDestroyNotify) gst_vaapi_mini_object_unref); | |
| g_async_queue_push (encoder->codedbuf_queue, codedbuf_proxy); | |
| encoder->num_codedbuf_queued++; | |
| return status; | |
| /* ERRORS */ | |
| error_create_coded_buffer: | |
| { | |
| GST_ERROR ("failed to allocate coded buffer"); | |
| return GST_VAAPI_ENCODER_STATUS_ERROR_ALLOCATION_FAILED; | |
| } | |
| error_encode: | |
| { | |
| GST_ERROR ("failed to encode frame (status = %d)", status); | |
| gst_vaapi_coded_buffer_proxy_unref (codedbuf_proxy); | |
| return status; | |
| } | |
| } | |
| /** | |
| * gst_vaapi_encoder_put_frame: | |
| * @encoder: a #GstVaapiEncoder | |
| * @frame: a #GstVideoCodecFrame | |
| * | |
| * Queues a #GstVideoCodedFrame to the HW encoder. The encoder holds | |
| * an extra reference to the @frame. | |
| * | |
| * Return value: a #GstVaapiEncoderStatus | |
| */ | |
| GstVaapiEncoderStatus | |
| gst_vaapi_encoder_put_frame (GstVaapiEncoder * encoder, | |
| GstVideoCodecFrame * frame) | |
| { | |
| GstVaapiEncoderClass *const klass = GST_VAAPI_ENCODER_GET_CLASS (encoder); | |
| GstVaapiEncoderStatus status; | |
| GstVaapiEncPicture *picture; | |
| for (;;) { | |
| picture = NULL; | |
| status = klass->reordering (encoder, frame, &picture); | |
| if (status == GST_VAAPI_ENCODER_STATUS_NO_SURFACE) | |
| break; | |
| if (status != GST_VAAPI_ENCODER_STATUS_SUCCESS) | |
| goto error_reorder_frame; | |
| status = gst_vaapi_encoder_encode_and_queue (encoder, picture); | |
| if (status != GST_VAAPI_ENCODER_STATUS_SUCCESS) | |
| goto error_encode; | |
| /* Try again with any pending reordered frame now available for encoding */ | |
| frame = NULL; | |
| } | |
| return GST_VAAPI_ENCODER_STATUS_SUCCESS; | |
| /* ERRORS */ | |
| error_reorder_frame: | |
| { | |
| GST_ERROR ("failed to process reordered frames"); | |
| return status; | |
| } | |
| error_encode: | |
| { | |
| gst_vaapi_enc_picture_unref (picture); | |
| return status; | |
| } | |
| } | |
| /** | |
| * gst_vaapi_encoder_get_buffer_with_timeout: | |
| * @encoder: a #GstVaapiEncoder | |
| * @out_codedbuf_proxy_ptr: the next coded buffer as a #GstVaapiCodedBufferProxy | |
| * @timeout: the number of microseconds to wait for the coded buffer, at most | |
| * | |
| * Upon successful return, *@out_codedbuf_proxy_ptr contains the next | |
| * coded buffer as a #GstVaapiCodedBufferProxy. The caller owns this | |
| * object, so gst_vaapi_coded_buffer_proxy_unref() shall be called | |
| * after usage. Otherwise, @GST_VAAPI_DECODER_STATUS_ERROR_NO_BUFFER | |
| * is returned if no coded buffer is available so far (timeout). | |
| * | |
| * The parent frame is available as a #GstVideoCodecFrame attached to | |
| * the user-data anchor of the output coded buffer. Ownership of the | |
| * frame is transferred to the coded buffer. | |
| * | |
| * Return value: a #GstVaapiEncoderStatus | |
| */ | |
| GstVaapiEncoderStatus | |
| gst_vaapi_encoder_get_buffer_with_timeout (GstVaapiEncoder * encoder, | |
| GstVaapiCodedBufferProxy ** out_codedbuf_proxy_ptr, guint64 timeout) | |
| { | |
| GstVaapiEncPicture *picture; | |
| GstVaapiCodedBufferProxy *codedbuf_proxy; | |
| codedbuf_proxy = g_async_queue_timeout_pop (encoder->codedbuf_queue, timeout); | |
| if (!codedbuf_proxy) | |
| return GST_VAAPI_ENCODER_STATUS_NO_BUFFER; | |
| /* Wait for completion of all operations and report any error that occurred */ | |
| picture = gst_vaapi_coded_buffer_proxy_get_user_data (codedbuf_proxy); | |
| if (!gst_vaapi_surface_sync (picture->surface)) | |
| goto error_invalid_buffer; | |
| gst_vaapi_coded_buffer_proxy_set_user_data (codedbuf_proxy, | |
| gst_video_codec_frame_ref (picture->frame), | |
| (GDestroyNotify) gst_video_codec_frame_unref); | |
| if (out_codedbuf_proxy_ptr) | |
| *out_codedbuf_proxy_ptr = gst_vaapi_coded_buffer_proxy_ref (codedbuf_proxy); | |
| gst_vaapi_coded_buffer_proxy_unref (codedbuf_proxy); | |
| return GST_VAAPI_ENCODER_STATUS_SUCCESS; | |
| /* ERRORS */ | |
| error_invalid_buffer: | |
| { | |
| GST_ERROR ("failed to encode the frame"); | |
| gst_vaapi_coded_buffer_proxy_unref (codedbuf_proxy); | |
| return GST_VAAPI_ENCODER_STATUS_ERROR_INVALID_SURFACE; | |
| } | |
| } | |
| static inline gboolean | |
| _get_pending_reordered (GstVaapiEncoder * encoder, | |
| GstVaapiEncPicture ** picture, gpointer * state) | |
| { | |
| GstVaapiEncoderClass *const klass = GST_VAAPI_ENCODER_GET_CLASS (encoder); | |
| if (!klass->get_pending_reordered) | |
| return FALSE; | |
| return klass->get_pending_reordered (encoder, picture, state); | |
| } | |
| /** | |
| * gst_vaapi_encoder_flush: | |
| * @encoder: a #GstVaapiEncoder | |
| * | |
| * Submits any pending (reordered) frame for encoding. | |
| * | |
| * Return value: a #GstVaapiEncoderStatus | |
| */ | |
| GstVaapiEncoderStatus | |
| gst_vaapi_encoder_flush (GstVaapiEncoder * encoder) | |
| { | |
| GstVaapiEncoderClass *const klass = GST_VAAPI_ENCODER_GET_CLASS (encoder); | |
| GstVaapiEncPicture *picture; | |
| GstVaapiEncoderStatus status; | |
| gpointer iter = NULL; | |
| picture = NULL; | |
| while (_get_pending_reordered (encoder, &picture, &iter)) { | |
| if (!picture) | |
| continue; | |
| status = gst_vaapi_encoder_encode_and_queue (encoder, picture); | |
| if (status != GST_VAAPI_ENCODER_STATUS_SUCCESS) | |
| goto error_encode; | |
| } | |
| g_free (iter); | |
| return klass->flush (encoder); | |
| /* ERRORS */ | |
| error_encode: | |
| { | |
| gst_vaapi_enc_picture_unref (picture); | |
| return status; | |
| } | |
| } | |
| /** | |
| * gst_vaapi_encoder_get_codec_data: | |
| * @encoder: a #GstVaapiEncoder | |
| * @out_codec_data_ptr: the pointer to the resulting codec-data (#GstBuffer) | |
| * | |
| * Returns a codec-data buffer that best represents the encoded | |
| * bitstream. Upon successful return, and if the @out_codec_data_ptr | |
| * contents is not NULL, then the caller function shall deallocates | |
| * that buffer with gst_buffer_unref(). | |
| * | |
| * Return value: a #GstVaapiEncoderStatus | |
| */ | |
| GstVaapiEncoderStatus | |
| gst_vaapi_encoder_get_codec_data (GstVaapiEncoder * encoder, | |
| GstBuffer ** out_codec_data_ptr) | |
| { | |
| GstVaapiEncoderStatus ret = GST_VAAPI_ENCODER_STATUS_SUCCESS; | |
| GstVaapiEncoderClass *const klass = GST_VAAPI_ENCODER_GET_CLASS (encoder); | |
| *out_codec_data_ptr = NULL; | |
| if (!klass->get_codec_data) | |
| return GST_VAAPI_ENCODER_STATUS_SUCCESS; | |
| ret = klass->get_codec_data (encoder, out_codec_data_ptr); | |
| return ret; | |
| } | |
| /* Checks video info */ | |
| static GstVaapiEncoderStatus | |
| check_video_info (GstVaapiEncoder * encoder, const GstVideoInfo * vip) | |
| { | |
| if (!vip->width || !vip->height) | |
| goto error_invalid_resolution; | |
| if (vip->fps_n < 0 || vip->fps_d <= 0) | |
| goto error_invalid_framerate; | |
| return GST_VAAPI_ENCODER_STATUS_SUCCESS; | |
| /* ERRORS */ | |
| error_invalid_resolution: | |
| { | |
| GST_ERROR ("invalid resolution (%dx%d)", vip->width, vip->height); | |
| return GST_VAAPI_ENCODER_STATUS_ERROR_INVALID_PARAMETER; | |
| } | |
| error_invalid_framerate: | |
| { | |
| GST_ERROR ("invalid framerate (%d/%d)", vip->fps_n, vip->fps_d); | |
| return GST_VAAPI_ENCODER_STATUS_ERROR_INVALID_PARAMETER; | |
| } | |
| } | |
| /* Gets a compatible profile for the active codec */ | |
| static GstVaapiProfile | |
| get_compatible_profile (GstVaapiEncoder * encoder) | |
| { | |
| const GstVaapiEncoderClassData *const cdata = | |
| GST_VAAPI_ENCODER_GET_CLASS (encoder)->class_data; | |
| GstVaapiProfile profile; | |
| GArray *profiles; | |
| guint i; | |
| profiles = gst_vaapi_display_get_encode_profiles (encoder->display); | |
| if (!profiles) | |
| return GST_VAAPI_PROFILE_UNKNOWN; | |
| // Pick a profile matching the class codec | |
| for (i = 0; i < profiles->len; i++) { | |
| profile = g_array_index (profiles, GstVaapiProfile, i); | |
| if (gst_vaapi_profile_get_codec (profile) == cdata->codec) | |
| break; | |
| } | |
| if (i == profiles->len) | |
| profile = GST_VAAPI_PROFILE_UNKNOWN; | |
| g_array_unref (profiles); | |
| return profile; | |
| } | |
| /* Gets a supported profile for the active codec */ | |
| static GstVaapiProfile | |
| get_profile (GstVaapiEncoder * encoder) | |
| { | |
| if (!encoder->profile) | |
| encoder->profile = get_compatible_profile (encoder); | |
| return encoder->profile; | |
| } | |
| /* Gets config attribute for the supplied profile */ | |
| static gboolean | |
| get_config_attribute (GstVaapiEncoder * encoder, VAConfigAttribType type, | |
| guint * out_value_ptr) | |
| { | |
| GstVaapiProfile profile; | |
| VAProfile va_profile; | |
| VAEntrypoint va_entrypoint; | |
| profile = get_profile (encoder); | |
| if (!profile) | |
| return FALSE; | |
| va_profile = gst_vaapi_profile_get_va_profile (profile); | |
| va_entrypoint = | |
| gst_vaapi_entrypoint_get_va_entrypoint (encoder->context_info.entrypoint); | |
| return gst_vaapi_get_config_attribute (encoder->display, va_profile, | |
| va_entrypoint, type, out_value_ptr); | |
| } | |
| /* Determines the set of supported packed headers */ | |
| static guint | |
| get_packed_headers (GstVaapiEncoder * encoder) | |
| { | |
| const GstVaapiEncoderClassData *const cdata = | |
| GST_VAAPI_ENCODER_GET_CLASS (encoder)->class_data; | |
| guint value; | |
| if (encoder->got_packed_headers) | |
| return encoder->packed_headers; | |
| if (!get_config_attribute (encoder, VAConfigAttribEncPackedHeaders, &value)) | |
| value = 0; | |
| GST_INFO ("supported packed headers: 0x%08x", value); | |
| encoder->got_packed_headers = TRUE; | |
| encoder->packed_headers = cdata->packed_headers & value; | |
| return encoder->packed_headers; | |
| } | |
| static gboolean | |
| get_roi_capability (GstVaapiEncoder * encoder, guint * num_roi_supported) | |
| { | |
| #if VA_CHECK_VERSION(0,39,1) | |
| VAConfigAttribValEncROI *roi_config; | |
| guint value; | |
| if (!get_config_attribute (encoder, VAConfigAttribEncROI, &value)) | |
| return FALSE; | |
| roi_config = (VAConfigAttribValEncROI *) & value; | |
| if (roi_config->bits.num_roi_regions == 0) | |
| return FALSE; | |
| /* Only support QP delta, and it only makes sense when rate control | |
| * is not CQP */ | |
| if ((GST_VAAPI_ENCODER_RATE_CONTROL (encoder) != GST_VAAPI_RATECONTROL_CQP) | |
| && (VA_ROI_RC_QP_DELTA_SUPPORT (roi_config) == 0)) | |
| return FALSE; | |
| GST_INFO ("Support for ROI - number of regions supported: %d", | |
| roi_config->bits.num_roi_regions); | |
| *num_roi_supported = roi_config->bits.num_roi_regions; | |
| return TRUE; | |
| #else | |
| return FALSE; | |
| #endif | |
| } | |
| static inline gboolean | |
| is_chroma_type_supported (GstVaapiEncoder * encoder) | |
| { | |
| GstVaapiContextInfo *const cip = &encoder->context_info; | |
| const GstVideoFormat fmt = | |
| GST_VIDEO_INFO_FORMAT (GST_VAAPI_ENCODER_VIDEO_INFO (encoder)); | |
| guint format = 0; | |
| if (fmt == GST_VIDEO_FORMAT_ENCODED) | |
| return TRUE; | |
| if (cip->chroma_type != GST_VAAPI_CHROMA_TYPE_YUV420 && | |
| cip->chroma_type != GST_VAAPI_CHROMA_TYPE_YUV422 && | |
| cip->chroma_type != GST_VAAPI_CHROMA_TYPE_YUV420_10BPP && | |
| cip->chroma_type != GST_VAAPI_CHROMA_TYPE_YUV444 && | |
| cip->chroma_type != GST_VAAPI_CHROMA_TYPE_YUV444_10BPP && | |
| cip->chroma_type != GST_VAAPI_CHROMA_TYPE_YUV422_10BPP && | |
| cip->chroma_type != GST_VAAPI_CHROMA_TYPE_YUV420_12BPP) | |
| goto unsupported; | |
| if (!get_config_attribute (encoder, VAConfigAttribRTFormat, &format)) | |
| return FALSE; | |
| if (!(format & from_GstVaapiChromaType (cip->chroma_type))) | |
| goto unsupported; | |
| return TRUE; | |
| /* ERRORS */ | |
| unsupported: | |
| { | |
| GST_ERROR ("The encoding format %s is not supported, " | |
| "Please try to use vaapipostproc to convert the input format.", | |
| gst_video_format_to_string (fmt)); | |
| return FALSE; | |
| } | |
| } | |
| static guint | |
| get_default_chroma_type (GstVaapiEncoder * encoder, | |
| const GstVaapiContextInfo * cip) | |
| { | |
| guint value; | |
| if (!gst_vaapi_get_config_attribute (encoder->display, | |
| gst_vaapi_profile_get_va_profile (cip->profile), | |
| gst_vaapi_entrypoint_get_va_entrypoint (cip->entrypoint), | |
| VAConfigAttribRTFormat, &value)) | |
| return 0; | |
| return to_GstVaapiChromaType (value); | |
| } | |
| static void | |
| init_context_info (GstVaapiEncoder * encoder, GstVaapiContextInfo * cip) | |
| { | |
| cip->usage = GST_VAAPI_CONTEXT_USAGE_ENCODE; | |
| cip->chroma_type = get_default_chroma_type (encoder, cip); | |
| cip->width = 0; | |
| cip->height = 0; | |
| cip->ref_frames = encoder->num_ref_frames; | |
| } | |
| /* Updates video context */ | |
| static gboolean | |
| set_context_info (GstVaapiEncoder * encoder) | |
| { | |
| GstVaapiContextInfo *const cip = &encoder->context_info; | |
| GstVaapiConfigInfoEncoder *const config = &cip->config.encoder; | |
| const GstVideoFormat format = | |
| GST_VIDEO_INFO_FORMAT (GST_VAAPI_ENCODER_VIDEO_INFO (encoder)); | |
| g_assert (cip->profile != GST_VAAPI_PROFILE_UNKNOWN); | |
| g_assert (cip->entrypoint != GST_VAAPI_ENTRYPOINT_INVALID); | |
| init_context_info (encoder, cip); | |
| cip->chroma_type = gst_vaapi_video_format_get_chroma_type (format); | |
| cip->width = GST_VAAPI_ENCODER_WIDTH (encoder); | |
| cip->height = GST_VAAPI_ENCODER_HEIGHT (encoder); | |
| if (!is_chroma_type_supported (encoder)) | |
| goto error_unsupported_format; | |
| memset (config, 0, sizeof (*config)); | |
| config->rc_mode = GST_VAAPI_ENCODER_RATE_CONTROL (encoder); | |
| config->packed_headers = get_packed_headers (encoder); | |
| config->roi_capability = | |
| get_roi_capability (encoder, &config->roi_num_supported); | |
| return TRUE; | |
| /* ERRORS */ | |
| error_unsupported_format: | |
| { | |
| GST_ERROR ("failed to determine chroma type for format %s", | |
| gst_vaapi_video_format_to_string (format)); | |
| return FALSE; | |
| } | |
| } | |
| /* Ensures the underlying VA context for encoding is created */ | |
| static gboolean | |
| gst_vaapi_encoder_ensure_context (GstVaapiEncoder * encoder) | |
| { | |
| GstVaapiContextInfo *const cip = &encoder->context_info; | |
| if (!set_context_info (encoder)) | |
| return FALSE; | |
| if (encoder->context) { | |
| if (!gst_vaapi_context_reset (encoder->context, cip)) | |
| return FALSE; | |
| } else { | |
| encoder->context = gst_vaapi_context_new (encoder->display, cip); | |
| if (!encoder->context) | |
| return FALSE; | |
| } | |
| encoder->va_context = gst_vaapi_context_get_id (encoder->context); | |
| return TRUE; | |
| } | |
| /* Reconfigures the encoder with the new properties */ | |
| static GstVaapiEncoderStatus | |
| gst_vaapi_encoder_reconfigure_internal (GstVaapiEncoder * encoder) | |
| { | |
| GstVaapiEncoderClass *const klass = GST_VAAPI_ENCODER_GET_CLASS (encoder); | |
| GstVideoInfo *const vip = GST_VAAPI_ENCODER_VIDEO_INFO (encoder); | |
| GstVaapiEncoderStatus status; | |
| GstVaapiVideoPool *pool; | |
| guint codedbuf_size, target_percentage; | |
| guint fps_d, fps_n; | |
| guint quality_level_max = 0; | |
| fps_d = GST_VIDEO_INFO_FPS_D (vip); | |
| fps_n = GST_VIDEO_INFO_FPS_N (vip); | |
| /* Generate a keyframe every second */ | |
| if (!encoder->keyframe_period) | |
| encoder->keyframe_period = (fps_n + fps_d - 1) / fps_d; | |
| /* Default frame rate parameter */ | |
| if (fps_d > 0 && fps_n > 0) | |
| GST_VAAPI_ENCODER_VA_FRAME_RATE (encoder).framerate = fps_d << 16 | fps_n; | |
| target_percentage = | |
| (GST_VAAPI_ENCODER_RATE_CONTROL (encoder) == GST_VAAPI_RATECONTROL_CBR) ? | |
| 100 : encoder->target_percentage; | |
| /* *INDENT-OFF* */ | |
| /* Default values for rate control parameter */ | |
| GST_VAAPI_ENCODER_VA_RATE_CONTROL (encoder) = (VAEncMiscParameterRateControl) { | |
| .bits_per_second = encoder->bitrate * 1000, | |
| .target_percentage = target_percentage, | |
| .window_size = 500, | |
| }; | |
| /* *INDENT-ON* */ | |
| status = klass->reconfigure (encoder); | |
| if (status != GST_VAAPI_ENCODER_STATUS_SUCCESS) | |
| return status; | |
| if (!gst_vaapi_encoder_ensure_context (encoder)) | |
| goto error_reset_context; | |
| if (get_config_attribute (encoder, VAConfigAttribEncQualityRange, | |
| &quality_level_max) && quality_level_max > 0) { | |
| GST_VAAPI_ENCODER_QUALITY_LEVEL (encoder) = | |
| CLAMP (GST_VAAPI_ENCODER_QUALITY_LEVEL (encoder), 1, quality_level_max); | |
| } else { | |
| GST_VAAPI_ENCODER_QUALITY_LEVEL (encoder) = 0; | |
| } | |
| GST_INFO ("Quality level is fixed to %d", | |
| GST_VAAPI_ENCODER_QUALITY_LEVEL (encoder)); | |
| if (encoder->trellis) { | |
| #if VA_CHECK_VERSION(1,0,0) | |
| guint quantization_method = 0; | |
| if (get_config_attribute (encoder, VAConfigAttribEncQuantization, | |
| &quantization_method) == FALSE | |
| || !(quantization_method & VA_ENC_QUANTIZATION_TRELLIS_SUPPORTED)) { | |
| GST_INFO ("Trellis Quantization is not supported," | |
| " trellis will be disabled"); | |
| encoder->trellis = FALSE; | |
| } | |
| #else | |
| GST_INFO ("The encode trellis quantization option is not supported" | |
| " in this VAAPI version."); | |
| encoder->trellis = FALSE; | |
| #endif | |
| } | |
| codedbuf_size = encoder->codedbuf_pool ? | |
| gst_vaapi_coded_buffer_pool_get_buffer_size (GST_VAAPI_CODED_BUFFER_POOL | |
| (encoder)) : 0; | |
| if (codedbuf_size != encoder->codedbuf_size) { | |
| pool = gst_vaapi_coded_buffer_pool_new (encoder, encoder->codedbuf_size); | |
| if (!pool) | |
| goto error_alloc_codedbuf_pool; | |
| gst_vaapi_video_pool_set_capacity (pool, 5); | |
| gst_vaapi_video_pool_replace (&encoder->codedbuf_pool, pool); | |
| gst_vaapi_video_pool_unref (pool); | |
| } | |
| return GST_VAAPI_ENCODER_STATUS_SUCCESS; | |
| /* ERRORS */ | |
| error_alloc_codedbuf_pool: | |
| { | |
| GST_ERROR ("failed to initialize coded buffer pool"); | |
| return GST_VAAPI_ENCODER_STATUS_ERROR_ALLOCATION_FAILED; | |
| } | |
| error_reset_context: | |
| { | |
| GST_ERROR ("failed to update VA context"); | |
| return GST_VAAPI_ENCODER_STATUS_ERROR_OPERATION_FAILED; | |
| } | |
| } | |
| /** | |
| * gst_vaapi_encoder_set_codec_state: | |
| * @encoder: a #GstVaapiEncoder | |
| * @state : a #GstVideoCodecState | |
| * | |
| * Notifies the encoder about the source surface properties. The | |
| * accepted set of properties is: video resolution, colorimetry, | |
| * pixel-aspect-ratio and framerate. | |
| * | |
| * This function is a synchronization point for codec configuration. | |
| * This means that, at this point, the encoder is reconfigured to | |
| * match the new properties and any other change beyond this point has | |
| * zero effect. | |
| * | |
| * Return value: a #GstVaapiEncoderStatus | |
| */ | |
| GstVaapiEncoderStatus | |
| gst_vaapi_encoder_set_codec_state (GstVaapiEncoder * encoder, | |
| GstVideoCodecState * state) | |
| { | |
| GstVaapiEncoderStatus status; | |
| g_return_val_if_fail (encoder != NULL, | |
| GST_VAAPI_ENCODER_STATUS_ERROR_INVALID_PARAMETER); | |
| g_return_val_if_fail (state != NULL, | |
| GST_VAAPI_ENCODER_STATUS_ERROR_INVALID_PARAMETER); | |
| if (!gst_video_info_is_equal (&state->info, &encoder->video_info)) { | |
| status = check_video_info (encoder, &state->info); | |
| if (status != GST_VAAPI_ENCODER_STATUS_SUCCESS) | |
| return status; | |
| encoder->video_info = state->info; | |
| } | |
| return gst_vaapi_encoder_reconfigure_internal (encoder); | |
| } | |
| /* Determine the supported rate control modes */ | |
| static guint | |
| get_rate_control_mask (GstVaapiEncoder * encoder) | |
| { | |
| const GstVaapiEncoderClassData *const cdata = | |
| GST_VAAPI_ENCODER_GET_CLASS (encoder)->class_data; | |
| guint i, value, rate_control_mask = 0; | |
| if (encoder->got_rate_control_mask) | |
| return encoder->rate_control_mask; | |
| if (get_config_attribute (encoder, VAConfigAttribRateControl, &value)) { | |
| for (i = 0; i < 32; i++) { | |
| if (!(value & (1U << i))) | |
| continue; | |
| rate_control_mask |= 1 << to_GstVaapiRateControl (1 << i); | |
| } | |
| GST_INFO ("supported rate controls: 0x%08x", rate_control_mask); | |
| encoder->got_rate_control_mask = TRUE; | |
| encoder->rate_control_mask = cdata->rate_control_mask & rate_control_mask; | |
| } | |
| return encoder->rate_control_mask; | |
| } | |
| /** | |
| * gst_vaapi_encoder_set_rate_control: | |
| * @encoder: a #GstVaapiEncoder | |
| * @rate_control: the requested rate control | |
| * | |
| * Notifies the @encoder to use the supplied @rate_control mode. | |
| * | |
| * If the underlying encoder does not support that rate control mode, | |
| * then @GST_VAAPI_ENCODER_STATUS_ERROR_UNSUPPORTED_RATE_CONTROL is | |
| * returned. | |
| * | |
| * The rate control mode can only be specified before the first frame | |
| * is to be encoded. Afterwards, any change to this parameter is | |
| * invalid and @GST_VAAPI_ENCODER_STATUS_ERROR_OPERATION_FAILED is | |
| * returned. | |
| * | |
| * Return value: a #GstVaapiEncoderStatus | |
| */ | |
| GstVaapiEncoderStatus | |
| gst_vaapi_encoder_set_rate_control (GstVaapiEncoder * encoder, | |
| GstVaapiRateControl rate_control) | |
| { | |
| guint32 rate_control_mask; | |
| g_return_val_if_fail (encoder != NULL, | |
| GST_VAAPI_ENCODER_STATUS_ERROR_INVALID_PARAMETER); | |
| if (encoder->rate_control != rate_control && encoder->num_codedbuf_queued > 0) | |
| goto error_operation_failed; | |
| rate_control_mask = get_rate_control_mask (encoder); | |
| if (rate_control_mask && !(rate_control_mask & (1U << rate_control))) | |
| goto error_unsupported_rate_control; | |
| encoder->rate_control = rate_control; | |
| return GST_VAAPI_ENCODER_STATUS_SUCCESS; | |
| /* ERRORS */ | |
| error_operation_failed: | |
| { | |
| GST_ERROR ("could not change rate control mode after encoding started"); | |
| return GST_VAAPI_ENCODER_STATUS_ERROR_OPERATION_FAILED; | |
| } | |
| error_unsupported_rate_control: | |
| { | |
| GST_ERROR ("unsupported rate control mode (%d)", rate_control); | |
| return GST_VAAPI_ENCODER_STATUS_ERROR_UNSUPPORTED_RATE_CONTROL; | |
| } | |
| } | |
| /** | |
| * gst_vaapi_encoder_set_bitrate: | |
| * @encoder: a #GstVaapiEncoder | |
| * @bitrate: the requested bitrate (in kbps) | |
| * | |
| * Notifies the @encoder to use the supplied @bitrate value. | |
| * | |
| * Note: currently, the bitrate can only be specified before the first | |
| * frame is encoded. Afterwards, any change to this parameter is | |
| * invalid and @GST_VAAPI_ENCODER_STATUS_ERROR_OPERATION_FAILED is | |
| * returned. | |
| * | |
| * Return value: a #GstVaapiEncoderStatus | |
| */ | |
| GstVaapiEncoderStatus | |
| gst_vaapi_encoder_set_bitrate (GstVaapiEncoder * encoder, guint bitrate) | |
| { | |
| g_return_val_if_fail (encoder != NULL, 0); | |
| if (encoder->bitrate != bitrate && encoder->num_codedbuf_queued > 0) { | |
| GST_INFO ("Bitrate is changed to %d on runtime", bitrate); | |
| encoder->bitrate = bitrate; | |
| return gst_vaapi_encoder_reconfigure_internal (encoder); | |
| } | |
| encoder->bitrate = bitrate; | |
| return GST_VAAPI_ENCODER_STATUS_SUCCESS; | |
| } | |
| GstVaapiEncoderStatus | |
| gst_vaapi_encoder_set_target_percentage (GstVaapiEncoder * encoder, | |
| guint target_percentage) | |
| { | |
| g_return_val_if_fail (encoder != NULL, 0); | |
| if (encoder->target_percentage != target_percentage | |
| && encoder->num_codedbuf_queued > 0) { | |
| if (GST_VAAPI_ENCODER_RATE_CONTROL (encoder) != GST_VAAPI_RATECONTROL_CBR) { | |
| GST_INFO ("Target percentage is changed to %d on runtime", | |
| target_percentage); | |
| encoder->target_percentage = target_percentage; | |
| return gst_vaapi_encoder_reconfigure_internal (encoder); | |
| } | |
| GST_WARNING ("Target percentage is ignored for CBR rate-control"); | |
| return GST_VAAPI_ENCODER_STATUS_SUCCESS; | |
| } | |
| encoder->target_percentage = target_percentage; | |
| return GST_VAAPI_ENCODER_STATUS_SUCCESS; | |
| } | |
| /** | |
| * gst_vaapi_encoder_set_keyframe_period: | |
| * @encoder: a #GstVaapiEncoder | |
| * @keyframe_period: the maximal distance between two keyframes | |
| * | |
| * Notifies the @encoder to use the supplied @keyframe_period value. | |
| * | |
| * Note: currently, the keyframe period can only be specified before | |
| * the last call to gst_vaapi_encoder_set_codec_state(), which shall | |
| * occur before the first frame is encoded. Afterwards, any change to | |
| * this parameter causes gst_vaapi_encoder_set_keyframe_period() to | |
| * return @GST_VAAPI_ENCODER_STATUS_ERROR_OPERATION_FAILED. | |
| * | |
| * Return value: a #GstVaapiEncoderStatus | |
| */ | |
| GstVaapiEncoderStatus | |
| gst_vaapi_encoder_set_keyframe_period (GstVaapiEncoder * encoder, | |
| guint keyframe_period) | |
| { | |
| g_return_val_if_fail (encoder != NULL, 0); | |
| if (encoder->keyframe_period != keyframe_period | |
| && encoder->num_codedbuf_queued > 0) | |
| goto error_operation_failed; | |
| encoder->keyframe_period = keyframe_period; | |
| return GST_VAAPI_ENCODER_STATUS_SUCCESS; | |
| /* ERRORS */ | |
| error_operation_failed: | |
| { | |
| GST_ERROR ("could not change keyframe period after encoding started"); | |
| return GST_VAAPI_ENCODER_STATUS_ERROR_OPERATION_FAILED; | |
| } | |
| } | |
| /** | |
| * gst_vaapi_encoder_set_tuning: | |
| * @encoder: a #GstVaapiEncoder | |
| * @tuning: the #GstVaapiEncoderTune option | |
| * | |
| * Notifies the @encoder to use the supplied @tuning option. | |
| * | |
| * Note: currently, the tuning option can only be specified before the | |
| * last call to gst_vaapi_encoder_set_codec_state(), which shall occur | |
| * before the first frame is encoded. Afterwards, any change to this | |
| * parameter causes gst_vaapi_encoder_set_tuning() to return | |
| * @GST_VAAPI_ENCODER_STATUS_ERROR_OPERATION_FAILED. | |
| * | |
| * Return value: a #GstVaapiEncoderStatus | |
| */ | |
| GstVaapiEncoderStatus | |
| gst_vaapi_encoder_set_tuning (GstVaapiEncoder * encoder, | |
| GstVaapiEncoderTune tuning) | |
| { | |
| g_return_val_if_fail (encoder != NULL, 0); | |
| if (encoder->tune != tuning && encoder->num_codedbuf_queued > 0) | |
| goto error_operation_failed; | |
| encoder->tune = tuning; | |
| return GST_VAAPI_ENCODER_STATUS_SUCCESS; | |
| /* ERRORS */ | |
| error_operation_failed: | |
| { | |
| GST_ERROR ("could not change tuning options after encoding started"); | |
| return GST_VAAPI_ENCODER_STATUS_ERROR_OPERATION_FAILED; | |
| } | |
| } | |
| /** | |
| * gst_vaapi_encoder_set_quality_level: | |
| * @encoder: a #GstVaapiEncoder | |
| * @quality_level: the encoder quality level | |
| * | |
| * Notifies the @encoder to use the supplied @quality_level value. | |
| * | |
| * Note: currently, the quality_level can only be specified before | |
| * the last call to gst_vaapi_encoder_set_codec_state(), which shall | |
| * occur before the first frame is encoded. Afterwards, any change to | |
| * this parameter causes gst_vaapi_encoder_set_quality_level() to | |
| * return @GST_VAAPI_ENCODER_STATUS_ERROR_OPERATION_FAILED. | |
| * | |
| * Return value: a #GstVaapiEncoderStatus | |
| */ | |
| GstVaapiEncoderStatus | |
| gst_vaapi_encoder_set_quality_level (GstVaapiEncoder * encoder, | |
| guint quality_level) | |
| { | |
| g_return_val_if_fail (encoder != NULL, 0); | |
| if (GST_VAAPI_ENCODER_QUALITY_LEVEL (encoder) != quality_level | |
| && encoder->num_codedbuf_queued > 0) | |
| goto error_operation_failed; | |
| GST_VAAPI_ENCODER_QUALITY_LEVEL (encoder) = quality_level; | |
| return GST_VAAPI_ENCODER_STATUS_SUCCESS; | |
| /* ERRORS */ | |
| error_operation_failed: | |
| { | |
| GST_ERROR ("could not change quality level after encoding started"); | |
| return GST_VAAPI_ENCODER_STATUS_ERROR_OPERATION_FAILED; | |
| } | |
| } | |
| /** | |
| * gst_vaapi_encoder_set_trellis: | |
| * @encoder: a #GstVaapiEncoder | |
| * @trellis: whether to use trellis quantization | |
| * | |
| * Notifies the @encoder to use the supplied @trellis option. | |
| * | |
| * Note: currently, the tuning option can only be specified before the | |
| * last call to gst_vaapi_encoder_set_codec_state(), which shall occur | |
| * before the first frame is encoded. Afterwards, any change to this | |
| * parameter causes gst_vaapi_encoder_set_tuning() to return | |
| * @GST_VAAPI_ENCODER_STATUS_ERROR_OPERATION_FAILED. | |
| * | |
| * Return value: a #GstVaapiEncoderStatus | |
| */ | |
| GstVaapiEncoderStatus | |
| gst_vaapi_encoder_set_trellis (GstVaapiEncoder * encoder, gboolean trellis) | |
| { | |
| g_return_val_if_fail (encoder != NULL, 0); | |
| if (encoder->trellis != trellis && encoder->num_codedbuf_queued > 0) | |
| goto error_operation_failed; | |
| encoder->trellis = trellis; | |
| return GST_VAAPI_ENCODER_STATUS_SUCCESS; | |
| /* ERRORS */ | |
| error_operation_failed: | |
| { | |
| GST_ERROR ("could not change trellis options after encoding started"); | |
| return GST_VAAPI_ENCODER_STATUS_ERROR_OPERATION_FAILED; | |
| } | |
| } | |
| G_DEFINE_ABSTRACT_TYPE (GstVaapiEncoder, gst_vaapi_encoder, GST_TYPE_OBJECT); | |
| /** | |
| * GstVaapiEncoderProp: | |
| * @ENCODER_PROP_DISPLAY: The display. | |
| * @ENCODER_PROP_BITRATE: Bitrate expressed in kbps (uint). | |
| * @ENCODER_PROP_TARGET_PERCENTAGE: Desired target percentage of | |
| * bitrate for variable rate controls. | |
| * @ENCODER_PROP_KEYFRAME_PERIOD: The maximal distance | |
| * between two keyframes (uint). | |
| * @ENCODER_PROP_DEFAULT_ROI_VALUE: The default delta qp to apply | |
| * to each region of interest. | |
| * @ENCODER_PROP_TRELLIS: Use trellis quantization method (gboolean). | |
| * | |
| * The set of configurable properties for the encoder. | |
| */ | |
| enum | |
| { | |
| ENCODER_PROP_DISPLAY = 1, | |
| ENCODER_PROP_BITRATE, | |
| ENCODER_PROP_TARGET_PERCENTAGE, | |
| ENCODER_PROP_KEYFRAME_PERIOD, | |
| ENCODER_PROP_QUALITY_LEVEL, | |
| ENCODER_PROP_DEFAULT_ROI_VALUE, | |
| ENCODER_PROP_TRELLIS, | |
| ENCODER_N_PROPERTIES | |
| }; | |
| static GParamSpec *properties[ENCODER_N_PROPERTIES]; | |
| static void | |
| gst_vaapi_encoder_set_property (GObject * object, guint prop_id, | |
| const GValue * value, GParamSpec * pspec) | |
| { | |
| GstVaapiEncoder *encoder = GST_VAAPI_ENCODER (object); | |
| GstVaapiEncoderStatus status = GST_VAAPI_ENCODER_STATUS_SUCCESS; | |
| switch (prop_id) { | |
| case ENCODER_PROP_DISPLAY: | |
| g_assert (encoder->display == NULL); | |
| encoder->display = g_value_dup_object (value); | |
| g_assert (encoder->display != NULL); | |
| encoder->va_display = GST_VAAPI_DISPLAY_VADISPLAY (encoder->display); | |
| break; | |
| case ENCODER_PROP_BITRATE: | |
| status = gst_vaapi_encoder_set_bitrate (encoder, | |
| g_value_get_uint (value)); | |
| break; | |
| case ENCODER_PROP_TARGET_PERCENTAGE: | |
| status = | |
| gst_vaapi_encoder_set_target_percentage (encoder, | |
| g_value_get_uint (value)); | |
| break; | |
| case ENCODER_PROP_KEYFRAME_PERIOD: | |
| status = | |
| gst_vaapi_encoder_set_keyframe_period (encoder, | |
| g_value_get_uint (value)); | |
| break; | |
| case ENCODER_PROP_QUALITY_LEVEL: | |
| status = | |
| gst_vaapi_encoder_set_quality_level (encoder, | |
| g_value_get_uint (value)); | |
| break; | |
| case ENCODER_PROP_DEFAULT_ROI_VALUE: | |
| encoder->default_roi_value = g_value_get_int (value); | |
| status = GST_VAAPI_ENCODER_STATUS_SUCCESS; | |
| break; | |
| case ENCODER_PROP_TRELLIS: | |
| status = | |
| gst_vaapi_encoder_set_trellis (encoder, g_value_get_boolean (value)); | |
| break; | |
| default: | |
| G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); | |
| break; | |
| } | |
| if (status) | |
| GST_WARNING_OBJECT (encoder, "Failed to set the property:%s, error is %d", | |
| g_param_spec_get_name (pspec), status); | |
| } | |
| static void | |
| gst_vaapi_encoder_get_property (GObject * object, guint prop_id, | |
| GValue * value, GParamSpec * pspec) | |
| { | |
| GstVaapiEncoder *encoder = GST_VAAPI_ENCODER (object); | |
| switch (prop_id) { | |
| case ENCODER_PROP_DISPLAY: | |
| g_value_set_object (value, encoder->display); | |
| break; | |
| case ENCODER_PROP_BITRATE: | |
| g_value_set_uint (value, encoder->bitrate); | |
| break; | |
| case ENCODER_PROP_TARGET_PERCENTAGE: | |
| g_value_set_uint (value, encoder->target_percentage); | |
| break; | |
| case ENCODER_PROP_KEYFRAME_PERIOD: | |
| g_value_set_uint (value, encoder->keyframe_period); | |
| break; | |
| case ENCODER_PROP_QUALITY_LEVEL: | |
| g_value_set_uint (value, GST_VAAPI_ENCODER_QUALITY_LEVEL (encoder)); | |
| break; | |
| case ENCODER_PROP_DEFAULT_ROI_VALUE: | |
| g_value_set_int (value, encoder->default_roi_value); | |
| break; | |
| case ENCODER_PROP_TRELLIS: | |
| g_value_set_boolean (value, encoder->trellis); | |
| break; | |
| default: | |
| G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); | |
| break; | |
| } | |
| } | |
| static void | |
| gst_vaapi_encoder_init (GstVaapiEncoder * encoder) | |
| { | |
| encoder->va_context = VA_INVALID_ID; | |
| gst_video_info_init (&encoder->video_info); | |
| g_mutex_init (&encoder->mutex); | |
| g_cond_init (&encoder->surface_free); | |
| g_cond_init (&encoder->codedbuf_free); | |
| encoder->codedbuf_queue = g_async_queue_new_full ((GDestroyNotify) | |
| gst_vaapi_coded_buffer_proxy_unref); | |
| } | |
| /* Base encoder cleanup (internal) */ | |
| static void | |
| gst_vaapi_encoder_finalize (GObject * object) | |
| { | |
| GstVaapiEncoder *encoder = GST_VAAPI_ENCODER (object); | |
| if (encoder->context) | |
| gst_vaapi_context_unref (encoder->context); | |
| encoder->context = NULL; | |
| gst_vaapi_display_replace (&encoder->display, NULL); | |
| encoder->va_display = NULL; | |
| if (encoder->properties) { | |
| g_ptr_array_unref (encoder->properties); | |
| encoder->properties = NULL; | |
| } | |
| gst_vaapi_video_pool_replace (&encoder->codedbuf_pool, NULL); | |
| if (encoder->codedbuf_queue) { | |
| g_async_queue_unref (encoder->codedbuf_queue); | |
| encoder->codedbuf_queue = NULL; | |
| } | |
| g_cond_clear (&encoder->surface_free); | |
| g_cond_clear (&encoder->codedbuf_free); | |
| g_mutex_clear (&encoder->mutex); | |
| G_OBJECT_CLASS (gst_vaapi_encoder_parent_class)->finalize (object); | |
| } | |
| static void | |
| gst_vaapi_encoder_class_init (GstVaapiEncoderClass * klass) | |
| { | |
| GObjectClass *const object_class = G_OBJECT_CLASS (klass); | |
| object_class->set_property = gst_vaapi_encoder_set_property; | |
| object_class->get_property = gst_vaapi_encoder_get_property; | |
| object_class->finalize = gst_vaapi_encoder_finalize; | |
| /** | |
| * GstVaapiDecoder:display: | |
| * | |
| * #GstVaapiDisplay to be used. | |
| */ | |
| properties[ENCODER_PROP_DISPLAY] = | |
| g_param_spec_object ("display", "Gst VA-API Display", | |
| "The VA-API display object to use", GST_TYPE_VAAPI_DISPLAY, | |
| G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_NAME); | |
| /** | |
| * GstVaapiEncoder:bitrate: | |
| * | |
| * The desired bitrate, expressed in kbps. | |
| * This is available when rate-control is CBR or VBR. | |
| * | |
| * CBR: This applies equally to minimum, maximum and target bitrate in the driver. | |
| * VBR: This applies to maximum bitrate in the driver. | |
| * Minimum bitrate will be calculated like the following in the driver. | |
| * if (target percentage < 50) minimum bitrate = 0 | |
| * else minimum bitrate = maximum bitrate * (2 * target percentage -100) / 100 | |
| * Target bitrate will be calculated like the following in the driver. | |
| * target bitrate = maximum bitrate * target percentage / 100 | |
| */ | |
| properties[ENCODER_PROP_BITRATE] = | |
| g_param_spec_uint ("bitrate", | |
| "Bitrate (kbps)", | |
| "The desired bitrate expressed in kbps (0: auto-calculate)", | |
| 0, 2000 * 1024, 0, | |
| G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | G_PARAM_CONSTRUCT | | |
| GST_VAAPI_PARAM_ENCODER_EXPOSURE); | |
| /** | |
| * GstVaapiEncoder:target-percentage: | |
| * | |
| * The desired target percentage of bitrate for variable rate controls. | |
| */ | |
| properties[ENCODER_PROP_TARGET_PERCENTAGE] = | |
| g_param_spec_uint ("target-percentage", | |
| "Target Percentage", | |
| "The desired target percentage of bitrate for variable rate " | |
| "controls.", 1, 100, 70, | |
| G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | G_PARAM_CONSTRUCT | | |
| GST_VAAPI_PARAM_ENCODER_EXPOSURE); | |
| /** | |
| * GstVaapiEncoder:keyframe-period: | |
| * | |
| * The maximal distance between two keyframes. | |
| */ | |
| properties[ENCODER_PROP_KEYFRAME_PERIOD] = | |
| g_param_spec_uint ("keyframe-period", | |
| "Keyframe Period", | |
| "Maximal distance between two keyframes (0: auto-calculate)", 0, | |
| G_MAXUINT32, 30, | |
| G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | G_PARAM_CONSTRUCT | | |
| GST_VAAPI_PARAM_ENCODER_EXPOSURE); | |
| /** | |
| * GstVaapiEncoder:quality-level: | |
| * | |
| * The Encoding quality level. | |
| */ | |
| properties[ENCODER_PROP_QUALITY_LEVEL] = | |
| g_param_spec_uint ("quality-level", | |
| "Quality Level", "Encoding Quality Level " | |
| "(lower value means higher-quality/slow-encode, " | |
| " higher value means lower-quality/fast-encode)", | |
| 1, 7, 4, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | G_PARAM_CONSTRUCT | | |
| GST_VAAPI_PARAM_ENCODER_EXPOSURE); | |
| /** | |
| * GstVapiEncoder:roi-default-delta-qp | |
| * | |
| * Default delta-qp to apply to each Region of Interest | |
| */ | |
| properties[ENCODER_PROP_DEFAULT_ROI_VALUE] = | |
| g_param_spec_int ("default-roi-delta-qp", "Default ROI delta QP", | |
| "The default delta-qp to apply to each Region of Interest" | |
| "(lower value means higher-quality, " | |
| "higher value means lower-quality)", | |
| -10, 10, -10, | |
| G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | G_PARAM_CONSTRUCT | | |
| GST_VAAPI_PARAM_ENCODER_EXPOSURE); | |
| /** | |
| * GstVaapiEncoder: trellis: | |
| * | |
| * The trellis quantization method the encoder can use. | |
| * Trellis is an improved quantization algorithm. | |
| * | |
| */ | |
| properties[ENCODER_PROP_TRELLIS] = | |
| g_param_spec_boolean ("trellis", | |
| "Trellis Quantization", | |
| "The Trellis Quantization Method of Encoder", | |
| FALSE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | G_PARAM_CONSTRUCT | | |
| GST_VAAPI_PARAM_ENCODER_EXPOSURE); | |
| g_object_class_install_properties (object_class, ENCODER_N_PROPERTIES, | |
| properties); | |
| } | |
| static GstVaapiContext * | |
| create_test_context_config (GstVaapiEncoder * encoder, GstVaapiProfile profile) | |
| { | |
| GstVaapiContextInfo cip = { 0, }; | |
| GstVaapiContext *ctxt; | |
| g_assert (profile != GST_VAAPI_PROFILE_UNKNOWN); | |
| cip.profile = profile; | |
| cip.entrypoint = gst_vaapi_encoder_get_entrypoint (encoder, profile); | |
| if (cip.entrypoint == GST_VAAPI_ENTRYPOINT_INVALID) { | |
| GST_INFO ("can not find %s entrypoint for profile %s to create" | |
| " text context. Ignore this profile", | |
| GST_VAAPI_ENCODER_TUNE (encoder) == GST_VAAPI_ENCODER_TUNE_LOW_POWER ? | |
| "the low-power" : "an available", | |
| gst_vaapi_profile_get_va_name (profile)); | |
| return NULL; | |
| } | |
| init_context_info (encoder, &cip); | |
| ctxt = gst_vaapi_context_new (encoder->display, &cip); | |
| return ctxt; | |
| } | |
| static gboolean | |
| get_profile_surface_attributes (GstVaapiEncoder * encoder, | |
| GstVaapiProfile profile, GstVaapiConfigSurfaceAttributes * attribs) | |
| { | |
| GstVaapiContext *ctxt = NULL; | |
| gboolean ret; | |
| g_return_val_if_fail (attribs != NULL, FALSE); | |
| g_return_val_if_fail (profile != GST_VAAPI_PROFILE_UNKNOWN, FALSE); | |
| ctxt = create_test_context_config (encoder, profile); | |
| if (!ctxt) | |
| return FALSE; | |
| ret = gst_vaapi_context_get_surface_attributes (ctxt, attribs); | |
| if (ret) { | |
| attribs->formats = gst_vaapi_context_get_surface_formats (ctxt); | |
| if (!attribs->formats) | |
| ret = FALSE; | |
| } | |
| gst_vaapi_context_unref (ctxt); | |
| return ret; | |
| } | |
| static gboolean | |
| merge_profile_surface_attributes (GstVaapiEncoder * encoder, | |
| GstVaapiProfile profile, GstVaapiConfigSurfaceAttributes * attribs) | |
| { | |
| GstVaapiConfigSurfaceAttributes attr = { 0, }; | |
| guint i, j; | |
| GstVideoFormat fmt, sfmt; | |
| if (profile == GST_VAAPI_PROFILE_UNKNOWN) | |
| return FALSE; | |
| if (!get_profile_surface_attributes (encoder, profile, &attr)) | |
| return FALSE; | |
| for (i = 0; i < attr.formats->len; i++) { | |
| sfmt = g_array_index (attr.formats, GstVideoFormat, i); | |
| for (j = 0; j < attribs->formats->len; j++) { | |
| fmt = g_array_index (attribs->formats, GstVideoFormat, j); | |
| if (fmt == sfmt) | |
| break; | |
| } | |
| if (j >= attribs->formats->len) | |
| g_array_append_val (attribs->formats, sfmt); | |
| } | |
| g_array_unref (attr.formats); | |
| attribs->min_width = MIN (attribs->min_width, attr.min_width); | |
| attribs->min_height = MIN (attribs->min_height, attr.min_height); | |
| attribs->max_width = MAX (attribs->max_width, attr.max_width); | |
| attribs->max_height = MAX (attribs->max_height, attr.max_height); | |
| attribs->mem_types &= attr.mem_types; | |
| return TRUE; | |
| } | |
| /** | |
| * gst_vaapi_encoder_get_surface_attributres: | |
| * @encoder: a #GstVaapiEncoder instances | |
| * @profiles: a #GArray of #GstVaapiProfile to be test | |
| * @min_width (out): the minimal surface width | |
| * @min_height (out): the minimal surface height | |
| * @max_width (out): the maximal surface width | |
| * @max_height (out): the maximal surface height | |
| * | |
| * Fetches the valid surface's attributes for the specified @profiles | |
| * | |
| * Returns: a #GArray of valid formats we get or %NULL if failed. | |
| **/ | |
| GArray * | |
| gst_vaapi_encoder_get_surface_attributes (GstVaapiEncoder * encoder, | |
| GArray * profiles, gint * min_width, gint * min_height, | |
| gint * max_width, gint * max_height, guint * mem_types) | |
| { | |
| GstVaapiConfigSurfaceAttributes attribs = { | |
| G_MAXINT, G_MAXINT, 1, 1, G_MAXUINT, NULL | |
| }; | |
| GstVaapiProfile profile; | |
| guint i; | |
| attribs.formats = g_array_new (FALSE, FALSE, sizeof (GstVideoFormat)); | |
| for (i = 0; i < profiles->len; i++) { | |
| profile = g_array_index (profiles, GstVaapiProfile, i); | |
| g_assert (profile != GST_VAAPI_PROFILE_UNKNOWN); | |
| GST_LOG ("Detect input formats of profile %s", | |
| gst_vaapi_profile_get_va_name (profile)); | |
| if (!merge_profile_surface_attributes (encoder, profile, &attribs)) { | |
| GST_INFO ("Can not get surface formats for profile %s", | |
| gst_vaapi_profile_get_va_name (profile)); | |
| continue; | |
| } | |
| } | |
| if (attribs.formats->len == 0) { | |
| g_array_unref (attribs.formats); | |
| return NULL; | |
| } | |
| if (min_width) | |
| *min_width = attribs.min_width; | |
| if (min_height) | |
| *min_height = attribs.min_height; | |
| if (max_width) | |
| *max_width = attribs.max_width; | |
| if (max_height) | |
| *max_height = attribs.max_height; | |
| if (mem_types) | |
| *mem_types = attribs.mem_types; | |
| return attribs.formats; | |
| } | |
| /** | |
| * gst_vaapi_encoder_ensure_num_slices: | |
| * @encoder: a #GstVaapiEncoder | |
| * @profile: a #GstVaapiProfile | |
| * @entrypoint: a #GstVaapiEntrypoint | |
| * @media_max_slices: the number of the slices permitted by the stream | |
| * @num_slices: (out): the possible number of slices to process | |
| * | |
| * This function will clamp the @num_slices provided by the user, | |
| * according the limit of the number of slices permitted by the stream | |
| * and by the hardware. | |
| * | |
| * We need to pass the @profile and the @entrypoint, because at the | |
| * moment the encoder base class, still doesn't have them assigned, | |
| * and this function is meant to be called by the derived classes | |
| * while they are configured. | |
| * | |
| * Returns: %TRUE if the number of slices is different than zero. | |
| **/ | |
| gboolean | |
| gst_vaapi_encoder_ensure_num_slices (GstVaapiEncoder * encoder, | |
| GstVaapiProfile profile, GstVaapiEntrypoint entrypoint, | |
| guint media_max_slices, guint * num_slices) | |
| { | |
| VAProfile va_profile; | |
| VAEntrypoint va_entrypoint; | |
| guint max_slices, num; | |
| va_profile = gst_vaapi_profile_get_va_profile (profile); | |
| va_entrypoint = gst_vaapi_entrypoint_get_va_entrypoint (entrypoint); | |
| if (!gst_vaapi_get_config_attribute (encoder->display, va_profile, | |
| va_entrypoint, VAConfigAttribEncMaxSlices, &max_slices)) { | |
| *num_slices = 1; | |
| return TRUE; | |
| } | |
| num = *num_slices; | |
| if (num > max_slices) | |
| num = max_slices; | |
| if (num > media_max_slices) | |
| num = media_max_slices; | |
| if (num == 0) | |
| return FALSE; | |
| *num_slices = num; | |
| return TRUE; | |
| } | |
| /** | |
| * gst_vaapi_encoder_ensure_max_num_ref_frames: | |
| * @encoder: a #GstVaapiEncoder | |
| * @profile: a #GstVaapiProfile | |
| * @entrypoint: a #GstVaapiEntrypoint | |
| * | |
| * This function will query VAConfigAttribEncMaxRefFrames to get the | |
| * maximum number of reference frames in the driver, | |
| * for both the reference picture list 0 (bottom 16 bits) and | |
| * the reference picture list 1 (top 16 bits). | |
| * | |
| * We need to pass the @profile and the @entrypoint, because at the | |
| * moment the encoder base class, still doesn't have them assigned, | |
| * and this function is meant to be called by the derived classes | |
| * while they are configured. | |
| * | |
| * Returns: %TRUE if the number of reference frames is different than zero. | |
| **/ | |
| gboolean | |
| gst_vaapi_encoder_ensure_max_num_ref_frames (GstVaapiEncoder * encoder, | |
| GstVaapiProfile profile, GstVaapiEntrypoint entrypoint) | |
| { | |
| VAProfile va_profile; | |
| VAEntrypoint va_entrypoint; | |
| guint max_ref_frames; | |
| va_profile = gst_vaapi_profile_get_va_profile (profile); | |
| va_entrypoint = gst_vaapi_entrypoint_get_va_entrypoint (entrypoint); | |
| if (!gst_vaapi_get_config_attribute (encoder->display, va_profile, | |
| va_entrypoint, VAConfigAttribEncMaxRefFrames, &max_ref_frames)) { | |
| /* Set the default the number of reference frames */ | |
| encoder->max_num_ref_frames_0 = 1; | |
| encoder->max_num_ref_frames_1 = 0; | |
| return TRUE; | |
| } | |
| encoder->max_num_ref_frames_0 = max_ref_frames & 0xffff; | |
| encoder->max_num_ref_frames_1 = (max_ref_frames >> 16) & 0xffff; | |
| return TRUE; | |
| } | |
| /** | |
| * gst_vaapi_encoder_ensure_tile_support: | |
| * @encoder: a #GstVaapiEncoder | |
| * @profile: a #GstVaapiProfile | |
| * @entrypoint: a #GstVaapiEntrypoint | |
| * | |
| * This function will query VAConfigAttribEncTileSupport to check | |
| * whether the encoder support tile. | |
| * | |
| * We need to pass the @profile and the @entrypoint, because at the | |
| * moment the encoder base class, still doesn't have them assigned, | |
| * and this function is meant to be called by the derived classes | |
| * while they are configured. | |
| * | |
| * Returns: %TRUE if supported, %FALSE if not. | |
| **/ | |
| gboolean | |
| gst_vaapi_encoder_ensure_tile_support (GstVaapiEncoder * encoder, | |
| GstVaapiProfile profile, GstVaapiEntrypoint entrypoint) | |
| { | |
| guint tile = 0; | |
| #if VA_CHECK_VERSION(1,0,1) | |
| VAProfile va_profile; | |
| VAEntrypoint va_entrypoint; | |
| va_profile = gst_vaapi_profile_get_va_profile (profile); | |
| va_entrypoint = gst_vaapi_entrypoint_get_va_entrypoint (entrypoint); | |
| if (!gst_vaapi_get_config_attribute (encoder->display, va_profile, | |
| va_entrypoint, VAConfigAttribEncTileSupport, &tile)) | |
| return FALSE; | |
| #endif | |
| return tile > 0; | |
| } | |
| GstVaapiProfile | |
| gst_vaapi_encoder_get_profile (GstVaapiEncoder * encoder) | |
| { | |
| g_return_val_if_fail (encoder, GST_VAAPI_PROFILE_UNKNOWN); | |
| return encoder->profile; | |
| } | |
| /* Get the entrypoint based on the tune option. */ | |
| /** | |
| * gst_vaapi_encoder_get_entrypoint: | |
| * @encoder: a #GstVaapiEncoder | |
| * @profile: a #GstVaapiProfile | |
| * | |
| * This function will return the valid entrypoint of the @encoder for | |
| * @profile. If the low-power mode(tune option) is set, only LP | |
| * entrypoints will be considered. If not, the first available entry | |
| * point will be return. | |
| * | |
| * Returns: The #GstVaapiEntrypoint. | |
| **/ | |
| GstVaapiEntrypoint | |
| gst_vaapi_encoder_get_entrypoint (GstVaapiEncoder * encoder, | |
| GstVaapiProfile profile) | |
| { | |
| /* XXX: The profile may not be the same with encoder->profile */ | |
| g_return_val_if_fail (encoder, GST_VAAPI_ENTRYPOINT_INVALID); | |
| g_return_val_if_fail (profile != GST_VAAPI_PROFILE_UNKNOWN, | |
| GST_VAAPI_ENTRYPOINT_INVALID); | |
| if (profile == GST_VAAPI_PROFILE_JPEG_BASELINE) | |
| return GST_VAAPI_ENTRYPOINT_PICTURE_ENCODE; | |
| if (GST_VAAPI_ENCODER_TUNE (encoder) == GST_VAAPI_ENCODER_TUNE_LOW_POWER) { | |
| if (gst_vaapi_display_has_encoder (GST_VAAPI_ENCODER_DISPLAY (encoder), | |
| profile, GST_VAAPI_ENTRYPOINT_SLICE_ENCODE_LP)) | |
| return GST_VAAPI_ENTRYPOINT_SLICE_ENCODE_LP; | |
| } else { | |
| /* If not set, choose the available one */ | |
| if (gst_vaapi_display_has_encoder (GST_VAAPI_ENCODER_DISPLAY (encoder), | |
| profile, GST_VAAPI_ENTRYPOINT_SLICE_ENCODE)) | |
| return GST_VAAPI_ENTRYPOINT_SLICE_ENCODE; | |
| if (gst_vaapi_display_has_encoder (GST_VAAPI_ENCODER_DISPLAY (encoder), | |
| profile, GST_VAAPI_ENTRYPOINT_SLICE_ENCODE_LP)) | |
| return GST_VAAPI_ENTRYPOINT_SLICE_ENCODE_LP; | |
| } | |
| return GST_VAAPI_ENTRYPOINT_INVALID; | |
| } | |
| /** | |
| * gst_vaapi_encoder_get_available_profiles: | |
| * @encoder: a #GstVaapiEncoder | |
| * | |
| * Collect all supported #GstVaapiProfile of current @encoder's #GstVaapiCodec, | |
| * and return them as a #GArray | |
| * | |
| * Returns: An #GArray of #GstVaapiProfile. | |
| **/ | |
| GArray * | |
| gst_vaapi_encoder_get_available_profiles (GstVaapiEncoder * encoder) | |
| { | |
| GstVaapiCodec codec; | |
| GArray *all_profiles = NULL; | |
| GArray *profiles = NULL; | |
| GstVaapiProfile profile; | |
| guint i; | |
| g_return_val_if_fail (encoder != NULL, 0); | |
| codec = GST_VAAPI_ENCODER_GET_CLASS (encoder)->class_data->codec; | |
| all_profiles = gst_vaapi_display_get_encode_profiles | |
| (GST_VAAPI_ENCODER_DISPLAY (encoder)); | |
| if (!all_profiles) | |
| goto out; | |
| /* Add all supported profiles belong to current codec */ | |
| profiles = g_array_new (FALSE, FALSE, sizeof (GstVaapiProfile)); | |
| if (!profiles) | |
| goto out; | |
| for (i = 0; i < all_profiles->len; i++) { | |
| profile = g_array_index (all_profiles, GstVaapiProfile, i); | |
| if (gst_vaapi_profile_get_codec (profile) == codec) | |
| g_array_append_val (profiles, profile); | |
| } | |
| out: | |
| if (all_profiles) | |
| g_array_unref (all_profiles); | |
| if (profiles && profiles->len == 0) { | |
| g_array_unref (profiles); | |
| profiles = NULL; | |
| } | |
| return profiles; | |
| } | |
| /** Returns a GType for the #GstVaapiEncoderTune set */ | |
| GType | |
| gst_vaapi_encoder_tune_get_type (void) | |
| { | |
| static gsize g_type = 0; | |
| static const GEnumValue encoder_tune_values[] = { | |
| /* *INDENT-OFF* */ | |
| { GST_VAAPI_ENCODER_TUNE_NONE, | |
| "None", "none" }, | |
| { GST_VAAPI_ENCODER_TUNE_HIGH_COMPRESSION, | |
| "High compression", "high-compression" }, | |
| { GST_VAAPI_ENCODER_TUNE_LOW_LATENCY, | |
| "Low latency", "low-latency" }, | |
| { GST_VAAPI_ENCODER_TUNE_LOW_POWER, | |
| "Low power mode", "low-power" }, | |
| { 0, NULL, NULL }, | |
| /* *INDENT-ON* */ | |
| }; | |
| if (g_once_init_enter (&g_type)) { | |
| GType type = | |
| g_enum_register_static ("GstVaapiEncoderTune", encoder_tune_values); | |
| g_once_init_leave (&g_type, type); | |
| } | |
| return g_type; | |
| } | |
| /** Returns a GType for the #GstVaapiEncoderMbbrc set */ | |
| GType | |
| gst_vaapi_encoder_mbbrc_get_type (void) | |
| { | |
| static gsize g_type = 0; | |
| if (g_once_init_enter (&g_type)) { | |
| static const GEnumValue encoder_mbbrc_values[] = { | |
| {GST_VAAPI_ENCODER_MBBRC_AUTO, "Auto", "auto"}, | |
| {GST_VAAPI_ENCODER_MBBRC_ON, "On", "on"}, | |
| {GST_VAAPI_ENCODER_MBBRC_OFF, "Off", "off"}, | |
| {0, NULL, NULL}, | |
| }; | |
| GType type = | |
| g_enum_register_static (g_intern_static_string ("GstVaapiEncoderMbbrc"), | |
| encoder_mbbrc_values); | |
| g_once_init_leave (&g_type, type); | |
| } | |
| return g_type; | |
| } |