#include "gst/gstclock.h"
#include "gst/gstvalue.h"
-#include "gst/vaapi/gstvaapiobject.h"
-#include "gst/vaapi/gstvaapiobject_priv.h"
-#include "gst/vaapi/gstvaapicontext.h"
-#include "gst/vaapi/gstvaapisurface.h"
-#include "gst/vaapi/gstvaapisurfacepool.h"
-#include "gst/vaapi/gstvaapivideobuffer.h"
-#include "gst/vaapi/gstvaapidisplay_priv.h"
-#include "gst/vaapi/gstvaapidebug.h"
+#include "gstvaapiobject.h"
+#include "gstvaapiobject_priv.h"
+#include "gstvaapicontext.h"
+#include "gstvaapisurface.h"
+#include "gstvaapisurfacepool.h"
+#include "gstvaapivideobuffer.h"
+#include "gstvaapidisplay_priv.h"
+#include "gstvaapidebug.h"
GST_DEBUG_CATEGORY_STATIC (gst_vaapi_base_encoder_debug);
#define GST_CAT_DEFAULT gst_vaapi_base_encoder_debug
guint need_flush : 1;
};
-G_DEFINE_TYPE(GstVaapiBaseEncoder, gst_vaapi_base_encoder, GST_TYPE_VAAPI_ENCODER);
+G_DEFINE_TYPE(GstVaapiBaseEncoder, gst_vaapi_base_encoder, GST_TYPE_VAAPI_ENCODER)
+
+static VABufferID *
+pop_available_coded_buffer(GstVaapiBaseEncoderPrivate *priv);
+
+static gboolean
+push_available_coded_buffer(
+ GstVaapiBaseEncoderPrivate *priv,
+ VABufferID *buf
+);
-static VABufferID *pop_available_coded_buffer(GstVaapiBaseEncoderPrivate *priv);
-static gboolean push_available_coded_buffer(
- GstVaapiBaseEncoderPrivate *priv, VABufferID *buf);
void
-gst_vaapi_base_encoder_set_frame_notify(GstVaapiBaseEncoder *encoder, gboolean flag)
+gst_vaapi_base_encoder_set_frame_notify(
+ GstVaapiBaseEncoder *encoder,
+ gboolean flag
+)
{
GstVaapiBaseEncoderPrivate *priv = encoder->priv;
priv->frame_notify_flag = flag;
}
gboolean
-gst_vaapi_base_encoder_set_va_profile(GstVaapiBaseEncoder *encoder, guint profile)
+gst_vaapi_base_encoder_set_va_profile(
+ GstVaapiBaseEncoder *encoder,
+ guint profile
+)
{
GstVaapiBaseEncoderPrivate *priv = encoder->priv;
priv->profile = profile;
}
void
-gst_vaapi_base_encoder_set_input_format(GstVaapiBaseEncoder* encoder, guint32 format)
+gst_vaapi_base_encoder_set_input_format(
+ GstVaapiBaseEncoder* encoder,
+ guint32 format
+)
{
GstVaapiBaseEncoderPrivate *priv = encoder->priv;
priv->format = format;
}
static gboolean
-default_validate_encoder_parameters(GstVaapiBaseEncoder *encoder)
+default_validate_encoder_parameters(
+ GstVaapiBaseEncoder *encoder
+)
{
- if (!ENCODER_WIDTH(encoder) || !ENCODER_HEIGHT(encoder) || !ENCODER_FPS(encoder)) {
+ if (!ENCODER_WIDTH(encoder) ||
+ !ENCODER_HEIGHT(encoder) ||
+ !ENCODER_FPS(encoder)) {
return FALSE;
}
return TRUE;
gboolean is_locked = FALSE;
guint i = 0;
gboolean ret = TRUE;
- guint32 buffer_size = (ENCODER_WIDTH(base_encoder) * ENCODER_HEIGHT(base_encoder) * 400) / (16*16);
+ guint32 buffer_size =
+ (ENCODER_WIDTH(base_encoder) * ENCODER_HEIGHT(base_encoder) * 400) /
+ (16*16);
ENCODER_ASSERT(display && context);
ENCODER_ASSERT(priv->available_code_buffers);
va_dpy = ENCODER_VA_DISPLAY(base_encoder);
context_id = gst_vaapi_context_get_id(context);
- priv->coded_bufs = (VABufferID*)g_malloc0(priv->coded_buf_num * sizeof(priv->coded_bufs[0]));
+ priv->coded_bufs = (VABufferID*)
+ g_malloc0(priv->coded_buf_num * sizeof(priv->coded_bufs[0]));
ENCODER_ACQUIRE_DISPLAY_LOCK(display);
for (i = 0; i < priv->coded_buf_num; i++) {
- va_status = vaCreateBuffer(va_dpy, context_id,VAEncCodedBufferType,
- buffer_size, 1, NULL, &priv->coded_bufs[i]);
+ va_status = vaCreateBuffer(va_dpy,
+ context_id,
+ VAEncCodedBufferType,
+ buffer_size, 1,
+ NULL,
+ &priv->coded_bufs[i]);
if (VA_STATUS_SUCCESS != va_status)
break;
}
ENCODER_RELEASE_DISPLAY_LOCK(display);
- ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS == va_status, FALSE, "create coded buffer failed.");
+ ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS == va_status,
+ FALSE,
+ "create coded buffer failed.");
/* init queue available_code_buffers */
g_mutex_lock(priv->code_buffer_lock);
}
static EncoderStatus
-base_encoder_release_coded_buffers(GstVaapiBaseEncoder *base_encoder)
+release_coded_buffers(GstVaapiBaseEncoder *base_encoder)
{
VAStatus va_status = VA_STATUS_SUCCESS;
GstVaapiBaseEncoderPrivate *priv = base_encoder->priv;
gst_vaapi_base_encoder_close_default(GstVaapiEncoder* encoder)
{
GstVaapiBaseEncoder* base_encoder = GST_VAAPI_BASE_ENCODER(encoder);
- GstVaapiBaseEncoderClass *base_class = GST_VAAPI_BASE_ENCODER_GET_CLASS(encoder);
+ GstVaapiBaseEncoderClass *base_class =
+ GST_VAAPI_BASE_ENCODER_GET_CLASS(encoder);
GstVaapiBaseEncoderPrivate *priv = base_encoder->priv;
EncoderStatus ret = ENCODER_NO_ERROR;
if (base_class->release_resource) {
base_class->release_resource(base_encoder);
}
- base_encoder_release_coded_buffers(base_encoder);
+ release_coded_buffers(base_encoder);
priv->frame_count = 0;
return ret;
)
{
GstVaapiBaseEncoder* base_encoder = GST_VAAPI_BASE_ENCODER(encoder);
- GstVaapiBaseEncoderClass *base_class = GST_VAAPI_BASE_ENCODER_GET_CLASS(encoder);
+ GstVaapiBaseEncoderClass *base_class =
+ GST_VAAPI_BASE_ENCODER_GET_CLASS(encoder);
GstVaapiBaseEncoderPrivate *priv = base_encoder->priv;
GstVaapiDisplay *display = ENCODER_DISPLAY(encoder);
} else {
check_attri_ret = default_validate_encoder_parameters(base_encoder);
}
- ENCODER_CHECK_STATUS(check_attri_ret, ENCODER_PARAMETER_ERR, "vaapi encoder paramerter error.");
- ENCODER_CHECK_STATUS(VA_INVALID_PROFILE != priv->profile, ENCODER_PROFILE_ERR, "vaapi encoder profile not set.");
+ ENCODER_CHECK_STATUS(check_attri_ret,
+ ENCODER_PARAMETER_ERR,
+ "vaapi encoder paramerter error.");
+ ENCODER_CHECK_STATUS(VA_INVALID_PROFILE != priv->profile,
+ ENCODER_PROFILE_ERR,
+ "vaapi encoder profile not set.");
ENCODER_ASSERT(ENCODER_DISPLAY(encoder));
gst_vaapi_entrypoint(VAEntrypointEncSlice),
ENCODER_WIDTH(encoder),
ENCODER_HEIGHT(encoder));
- ENCODER_CHECK_STATUS(out_context, ENCODER_CONTEXT_ERR, "gst_vaapi_context_new failed.");
- ENCODER_CHECK_STATUS(VA_INVALID_ID != GST_VAAPI_OBJECT_ID(out_context), ENCODER_CONTEXT_ERR, "gst_vaapi_context_new failed.");
+ ENCODER_CHECK_STATUS(out_context,
+ ENCODER_CONTEXT_ERR,
+ "gst_vaapi_context_new failed.");
+ ENCODER_CHECK_STATUS(VA_INVALID_ID != GST_VAAPI_OBJECT_ID(out_context),
+ ENCODER_CONTEXT_ERR,
+ "gst_vaapi_context_new failed.");
if (base_class->pre_alloc_resource) {
- ENCODER_CHECK_STATUS(base_class->pre_alloc_resource(base_encoder, out_context),
- ENCODER_MEM_ERR, "encoder <pre_alloc_resource> failed.");
+ ENCODER_CHECK_STATUS(
+ base_class->pre_alloc_resource(base_encoder, out_context),
+ ENCODER_MEM_ERR,
+ "encoder <pre_alloc_resource> failed."
+ );
}
ENCODER_CHECK_STATUS(
base_encoder_alloc_coded_buffers(base_encoder, out_context),
}
static GstBuffer *
-gst_vaapi_base_encoder_copy_buffer_default(GstVaapiBaseEncoder *encoder,
- guint8 *frame,
- guint32 frame_size,
- VABufferID *coded_buf)
+gst_vaapi_base_encoder_copy_buffer_default(
+ GstVaapiBaseEncoder *encoder,
+ guint8 *frame,
+ guint32 frame_size,
+ VABufferID *coded_buf
+)
{
GstBuffer *ret_buffer = NULL;
#if SHARE_CODED_BUF
}
static EncoderStatus
-base_query_encoding_status(GstVaapiBaseEncoder *base_encoder,
- GstVaapiSurface *buffer_surface,
- gboolean is_key,
- GstVaapiVideoBuffer *surface_buffer,
- VABufferID *coded_buf,
- GList **coded_pics)
+base_query_encoding_status(
+ GstVaapiBaseEncoder *base_encoder,
+ GstVaapiSurface *buffer_surface,
+ gboolean is_key,
+ GstVaapiVideoBuffer *surface_buffer,
+ VABufferID *coded_buf,
+ GList **coded_pics
+)
{
EncoderStatus ret = ENCODER_NO_ERROR;
VAStatus va_status = VA_STATUS_SUCCESS;
GstBuffer* ret_buffer = NULL;
gboolean has_coded_data = FALSE;
gboolean is_locked = FALSE;
- GstVaapiBaseEncoderClass *base_class = GST_VAAPI_BASE_ENCODER_GET_CLASS(base_encoder);
+ GstVaapiBaseEncoderClass *base_class =
+ GST_VAAPI_BASE_ENCODER_GET_CLASS(base_encoder);
GstVaapiBaseEncoderPrivate *priv = base_encoder->priv;
GstVaapiDisplay *display = ENCODER_DISPLAY(base_encoder);
ENCODER_ACQUIRE_DISPLAY_LOCK(display);
va_status = vaSyncSurface(va_dpy, surface_id);
- ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS ==va_status, ENCODER_QUERY_STATUS_ERR, "vaSyncSurface failed.");
+ ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS ==va_status,
+ ENCODER_QUERY_STATUS_ERR,
+ "vaSyncSurface failed.");
va_status = vaQuerySurfaceStatus(va_dpy, surface_id, &surface_status);
- ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS ==va_status, ENCODER_QUERY_STATUS_ERR, "vaQuerySurfaceStatus failed.");
- if (VASurfaceSkipped&surface_status) {
- ENCODER_LOG_ERROR("frame skipped, dts:%" GST_TIME_FORMAT, GST_TIME_ARGS(GST_BUFFER_TIMESTAMP(surface_buffer)));
+ ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS ==va_status,
+ ENCODER_QUERY_STATUS_ERR,
+ "vaQuerySurfaceStatus failed.");
+ if (VASurfaceSkipped & surface_status) {
+ ENCODER_LOG_ERROR("frame skipped, dts:%" GST_TIME_FORMAT,
+ GST_TIME_ARGS(GST_BUFFER_TIMESTAMP(surface_buffer)));
}
va_status = vaMapBuffer(va_dpy, *coded_buf, (void **)(&buf_list));
- ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS ==va_status, ENCODER_QUERY_STATUS_ERR, "vaMapBuffer failed.");
+ ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS ==va_status,
+ ENCODER_QUERY_STATUS_ERR,
+ "vaMapBuffer failed.");
/*unlock display*/
ENCODER_RELEASE_DISPLAY_LOCK(display);
while (buf_list != NULL) {
if (priv->frame_notify_flag && base_class->notify_frame) {
- base_class->notify_frame(base_encoder, buf_list->buf, buf_list->size);
+ base_class->notify_frame(base_encoder,
+ buf_list->buf,
+ buf_list->size);
}
if (base_class->copy_coded_frame) {
ret_buffer = base_class->copy_coded_frame(
- base_encoder, buf_list->buf,
- buf_list->size, coded_buf);
+ base_encoder,
+ buf_list->buf,
+ buf_list->size,
+ coded_buf);
} else {
ret_buffer = gst_vaapi_base_encoder_copy_buffer_default(
- base_encoder, buf_list->buf,
- buf_list->size, coded_buf);
+ base_encoder,
+ buf_list->buf,
+ buf_list->size,
+ coded_buf);
}
GST_BUFFER_TIMESTAMP(ret_buffer) = GST_BUFFER_TIMESTAMP(surface_buffer);
GST_BUFFER_DURATION(ret_buffer) = GST_BUFFER_DURATION(surface_buffer);
if (!is_key) {
GST_BUFFER_FLAG_SET(ret_buffer, GST_BUFFER_FLAG_DELTA_UNIT);
}
- GST_BUFFER_OFFSET_END(ret_buffer) = GST_BUFFER_OFFSET_END(surface_buffer);
+ GST_BUFFER_OFFSET_END(ret_buffer) =
+ GST_BUFFER_OFFSET_END(surface_buffer);
*coded_pics = g_list_append(*coded_pics, ret_buffer);
buf_list = (VACodedBufferSegment*)buf_list->next;
ENCODER_ASSERT(NULL == buf_list);
}
static EncoderStatus
-gst_vaapi_base_encoder_encode_default(GstVaapiEncoder* encoder,
+gst_vaapi_base_encoder_encode_default(
+ GstVaapiEncoder* encoder,
GstBuffer *raw_pic,
GList **coded_pics
)
{
GstVaapiBaseEncoder* base_encoder = GST_VAAPI_BASE_ENCODER(encoder);
- GstVaapiBaseEncoderClass *base_class = GST_VAAPI_BASE_ENCODER_GET_CLASS(encoder);
+ GstVaapiBaseEncoderClass *base_class =
+ GST_VAAPI_BASE_ENCODER_GET_CLASS(encoder);
GstVaapiBaseEncoderPrivate *priv = base_encoder->priv;
GstVaapiDisplay *display = ENCODER_DISPLAY(encoder);
GstVaapiContext *context = ENCODER_CONTEXT(encoder);
GstVaapiVideoBuffer *video_buffer = NULL;
ENCODER_CHECK_STATUS(raw_pic || base_class->prepare_next_input_buffer,
- ENCODER_DATA_ERR, "Need a picture to encode");
+ ENCODER_DATA_ERR,
+ "Need a picture to encode");
if (raw_pic) {
/* load picture to surface */
if (GST_VAAPI_IS_VIDEO_BUFFER(raw_pic)) {
again:
if (base_class->prepare_next_input_buffer) {
GstVaapiVideoBuffer* tmp_buf = NULL;
- ret = base_class->prepare_next_input_buffer(base_encoder, video_buffer, priv->need_flush, &tmp_buf);
+ ret = base_class->prepare_next_input_buffer(base_encoder,
+ video_buffer,
+ priv->need_flush,
+ &tmp_buf);
priv->need_flush = FALSE;
if (video_buffer) {
gst_buffer_unref(GST_BUFFER_CAST(video_buffer));
buffer_surface = gst_vaapi_video_buffer_get_surface(video_buffer);
buffer_surface_id = (VASurfaceID)GST_VAAPI_OBJECT_ID(buffer_surface);
- ENCODER_CHECK_STATUS(buffer_surface_id != VA_INVALID_SURFACE, ENCODER_SURFACE_ERR, "surface id == VA_INVALID_SURFACE.");
+ ENCODER_CHECK_STATUS(buffer_surface_id != VA_INVALID_SURFACE,
+ ENCODER_SURFACE_ERR,
+ "surface id == VA_INVALID_SURFACE");
/* begin surface*/
ENCODER_ACQUIRE_DISPLAY_LOCK(display);
va_status = vaBeginPicture(va_dpy, context_id, buffer_surface_id);
//ENCODER_RELEASE_DISPLAY_LOCK(display);
- ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS == va_status, ENCODER_PICTURE_ERR, "vaBeginPicture error.");
+ ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS == va_status,
+ ENCODER_PICTURE_ERR,
+ "vaBeginPicture error");
/*get valid coded buffer*/
coded_buf = pop_available_coded_buffer(priv);
- ENCODER_CHECK_STATUS(coded_buf, ENCODER_ENC_RES_ERR, "dequeue_available_coded_buffer error.");
+ ENCODER_CHECK_STATUS(coded_buf,
+ ENCODER_ENC_RES_ERR,
+ "dequeue_available_coded_buffer error");
/* prepare frame*/
ret = base_class->render_frame(base_encoder,
if (ENCODER_NO_ERROR != ret) {
push_available_coded_buffer(priv, coded_buf);
}
- ENCODER_CHECK_STATUS(ENCODER_NO_ERROR == ret, ENCODER_PICTURE_ERR, "base_prepare_encoding failed.");
+ ENCODER_CHECK_STATUS(ENCODER_NO_ERROR == ret,
+ ENCODER_PICTURE_ERR,
+ "base_prepare_encoding failed");
/* end picture */
//ENCODER_ACQUIRE_DISPLAY_LOCK(display);
va_status = vaEndPicture(va_dpy, context_id);
ENCODER_RELEASE_DISPLAY_LOCK(display);
- ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS == va_status, ENCODER_PICTURE_ERR, "vaEndPicture error.");
+ ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS == va_status,
+ ENCODER_PICTURE_ERR,
+ "vaEndPicture error");
/*query surface result*/
- ret = base_query_encoding_status(base_encoder, buffer_surface,
- is_key, video_buffer, coded_buf, coded_pics);
+ ret = base_query_encoding_status(base_encoder,
+ buffer_surface,
+ is_key,
+ video_buffer,
+ coded_buf,
+ coded_pics);
if (ENCODER_NO_ERROR != ret) {
goto end;
}
g_mutex_lock(priv->code_buffer_lock);
- ENCODER_CHECK_STATUS(priv->available_code_buffers, FALSE, "coded buffer not found");
+ ENCODER_CHECK_STATUS(priv->available_code_buffers,
+ FALSE,
+ "coded buffer not found");
while (g_queue_is_empty(priv->available_code_buffers)) {
g_cond_wait(priv->code_buffer_cond, priv->code_buffer_lock);
}
}
static gboolean
-push_available_coded_buffer(GstVaapiBaseEncoderPrivate *priv, VABufferID *buf)
+push_available_coded_buffer(
+ GstVaapiBaseEncoderPrivate *priv,
+ VABufferID *buf
+)
{
g_mutex_lock(priv->code_buffer_lock);
g_queue_push_head(priv->available_code_buffers, buf);
{
/*free private buffers*/
GstVaapiEncoder *encoder = GST_VAAPI_ENCODER(object);
- GstVaapiBaseEncoderPrivate *priv = GST_VAAPI_BASE_ENCODER_GET_PRIVATE(object);
+ GstVaapiBaseEncoderPrivate *priv =
+ GST_VAAPI_BASE_ENCODER_GET_PRIVATE(object);
if (gst_vaapi_encoder_get_state(encoder) != VAAPI_ENC_NULL) {
gst_vaapi_encoder_uninitialize(encoder);
static void
gst_vaapi_base_encoder_init(GstVaapiBaseEncoder *encoder)
{
- GstVaapiBaseEncoderPrivate *priv = GST_VAAPI_BASE_ENCODER_GET_PRIVATE(encoder);
+ GstVaapiBaseEncoderPrivate *priv =
+ GST_VAAPI_BASE_ENCODER_GET_PRIVATE(encoder);
ENCODER_ASSERT(priv);
encoder->priv = priv;
GstVaapiEncoderClass * const encoder_class = GST_VAAPI_ENCODER_CLASS(klass);
g_type_class_add_private(klass, sizeof(GstVaapiBaseEncoderPrivate));
- GST_DEBUG_CATEGORY_INIT (gst_vaapi_base_encoder_debug, "gst_vaapi_base_encoder", 0,
- "gst_vaapi_base_encoder element");
+ GST_DEBUG_CATEGORY_INIT (gst_vaapi_base_encoder_debug,
+ "gst_vaapi_base_encoder",
+ 0,
+ "gst_vaapi_base_encoder element");
object_class->finalize = gst_vaapi_base_encoder_finalize;
#ifndef GST_VAAPI_BASE_ENCODER_H
#define GST_VAAPI_BASE_ENCODER_H
-#include "gstvaapiencoder.h"
+#include "gst/vaapi/gstvaapiencoder.h"
#include "gst/vaapi/gstvaapivideobuffer.h"
G_BEGIN_DECLS
typedef struct _GstVaapiBaseEncoderPrivate GstVaapiBaseEncoderPrivate;
typedef struct _GstVaapiBaseEncoderClass GstVaapiBaseEncoderClass;
-#define GST_TYPE_VAAPI_BASE_ENCODER (gst_vaapi_base_encoder_get_type())
-#define GST_IS_VAAPI_BASE_ENCODER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GST_TYPE_VAAPI_BASE_ENCODER))
-#define GST_IS_VAAPI_BASE_ENCODER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GST_TYPE_VAAPI_BASE_ENCODER))
-#define GST_VAAPI_BASE_ENCODER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GST_TYPE_VAAPI_BASE_ENCODER, GstVaapiBaseEncoderClass))
-#define GST_VAAPI_BASE_ENCODER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GST_TYPE_VAAPI_BASE_ENCODER, GstVaapiBaseEncoder))
-#define GST_VAAPI_BASE_ENCODER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GST_TYPE_VAAPI_BASE_ENCODER, GstVaapiBaseEncoderClass))
-#define GST_VAAPI_BASE_ENCODER_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE((obj),GST_TYPE_VAAPI_BASE_ENCODER, GstVaapiBaseEncoderPrivate))
+#define GST_TYPE_VAAPI_BASE_ENCODER \
+ (gst_vaapi_base_encoder_get_type())
+
+#define GST_IS_VAAPI_BASE_ENCODER(obj) \
+ (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GST_TYPE_VAAPI_BASE_ENCODER))
+
+#define GST_IS_VAAPI_BASE_ENCODER_CLASS(klass) \
+ (G_TYPE_CHECK_CLASS_TYPE ((klass), GST_TYPE_VAAPI_BASE_ENCODER))
+
+#define GST_VAAPI_BASE_ENCODER_GET_CLASS(obj) \
+ (G_TYPE_INSTANCE_GET_CLASS ((obj), \
+ GST_TYPE_VAAPI_BASE_ENCODER, \
+ GstVaapiBaseEncoderClass))
+
+#define GST_VAAPI_BASE_ENCODER(obj) \
+(G_TYPE_CHECK_INSTANCE_CAST ((obj), \
+ GST_TYPE_VAAPI_BASE_ENCODER, \
+ GstVaapiBaseEncoder))
+
+#define GST_VAAPI_BASE_ENCODER_CLASS(klass) \
+ (G_TYPE_CHECK_CLASS_CAST ((klass), \
+ GST_TYPE_VAAPI_BASE_ENCODER, \
+ GstVaapiBaseEncoderClass))
+
+#define GST_VAAPI_BASE_ENCODER_GET_PRIVATE(obj) \
+ (G_TYPE_INSTANCE_GET_PRIVATE((obj), \
+ GST_TYPE_VAAPI_BASE_ENCODER, \
+ GstVaapiBaseEncoderPrivate))
struct _GstVaapiBaseEncoder {
GstVaapiEncoder parent;
/* in <open> function*/
gboolean (*validate_attributes) (GstVaapiBaseEncoder* encoder);
- gboolean (*pre_alloc_resource) (GstVaapiBaseEncoder *encoder, GstVaapiContext* context);
+ gboolean (*pre_alloc_resource) (GstVaapiBaseEncoder *encoder,
+ GstVaapiContext* context);
/* in <close> function */
gboolean (*release_resource) (GstVaapiBaseEncoder* encoder);
GstVaapiVideoBuffer *display_buf,
gboolean need_flush,
GstVaapiVideoBuffer **out_buf);
- EncoderStatus (*render_frame) (GstVaapiBaseEncoder *encoder, GstVaapiSurface *surface,
- guint frame_index, VABufferID coded_buf, gboolean *is_key);
- void (*encode_frame_failed) (GstVaapiBaseEncoder *encoder, GstVaapiVideoBuffer* buffer);
- void (*notify_frame) (GstVaapiBaseEncoder *encoder, guint8 *buf, guint32 size);
- GstBuffer *(*copy_coded_frame) (GstVaapiBaseEncoder *encoder, guint8 *buf, guint32 size, VABufferID *coded_buf);
-};
-GType gst_vaapi_base_encoder_get_type(void);
-void gst_vaapi_base_encoder_set_frame_notify(GstVaapiBaseEncoder *encoder, gboolean flag);
-gboolean gst_vaapi_base_encoder_set_va_profile(GstVaapiBaseEncoder *encoder, guint profile);
-void gst_vaapi_base_encoder_set_input_format(GstVaapiBaseEncoder* encoder, guint32 format);
+ EncoderStatus (*render_frame) (GstVaapiBaseEncoder *encoder,
+ GstVaapiSurface *surface,
+ guint frame_index,
+ VABufferID coded_buf,
+ gboolean *is_key);
+ void (*encode_frame_failed) (GstVaapiBaseEncoder *encoder,
+ GstVaapiVideoBuffer* buffer);
-G_END_DECLS
+ void (*notify_frame) (GstVaapiBaseEncoder *encoder,
+ guint8 *buf, guint32 size);
+
+ GstBuffer *(*copy_coded_frame) (GstVaapiBaseEncoder *encoder,
+ guint8 *buf, guint32 size,
+ VABufferID *coded_buf);
+};
+
+GType
+gst_vaapi_base_encoder_get_type(void);
+
+void
+gst_vaapi_base_encoder_set_frame_notify(
+ GstVaapiBaseEncoder *encoder,
+ gboolean flag
+);
+
+gboolean
+gst_vaapi_base_encoder_set_va_profile(
+ GstVaapiBaseEncoder *encoder,
+ guint profile
+);
+void
+gst_vaapi_base_encoder_set_input_format(
+ GstVaapiBaseEncoder* encoder,
+ guint32 format
+);
-#endif
+G_END_DECLS
+#endif /* GST_VAAPI_BASE_ENCODER_H */
#include <string.h>
-#include "gst/vaapi/gstvaapidisplay_x11.h"
+#include "gstvaapidisplay_x11.h"
GST_DEBUG_CATEGORY_STATIC (gst_vaapi_encoder_debug);
#define GST_CAT_DEFAULT gst_vaapi_encoder_debug
-G_DEFINE_TYPE(GstVaapiEncoder, gst_vaapi_encoder, G_TYPE_OBJECT);
+G_DEFINE_TYPE(GstVaapiEncoder, gst_vaapi_encoder, G_TYPE_OBJECT)
gboolean
-gst_vaapi_encoder_set_display(GstVaapiEncoder* encoder, GstVaapiDisplay *display)
+gst_vaapi_encoder_set_display(
+ GstVaapiEncoder* encoder,
+ GstVaapiDisplay *display
+)
{
GstVaapiEncoderPrivate *priv = encoder->priv;
if (display == priv->display) {
/* create va_dpy*/
if (!priv->display) {
priv->display = gst_vaapi_display_x11_new(NULL);
- ENCODER_CHECK_STATUS(priv->display, ENCODER_DISPLAY_ERR, "gst_vaapi_display_x11_new failed.");
+ ENCODER_CHECK_STATUS(priv->display,
+ ENCODER_DISPLAY_ERR,
+ "gst_vaapi_display_x11_new failed.");
priv->va_display = gst_vaapi_display_get_display(priv->display);
}
if (encoder_class->initialize) {
ret = encoder_class->initialize(encoder);
- ENCODER_CHECK_STATUS (ENCODER_NO_ERROR == ret, ret, "encoder <initialize> failed.");
+ ENCODER_CHECK_STATUS (ENCODER_NO_ERROR == ret,
+ ret,
+ "encoder <initialize> failed.");
}
priv->state = VAAPI_ENC_INIT;
}
ENCODER_ASSERT(!priv->context);
- ENCODER_CHECK_STATUS(encoder_class->open, ENCODER_FUNC_PTR_ERR, "encoder <open> function pointer empty.");
+ ENCODER_CHECK_STATUS(encoder_class->open,
+ ENCODER_FUNC_PTR_ERR,
+ "encoder <open> function pointer empty.");
ret = encoder_class->open(encoder, &priv->context);
- ENCODER_CHECK_STATUS(ENCODER_NO_ERROR == ret, ret, "encoder <open> failed.");
- ENCODER_CHECK_STATUS(priv->context, ENCODER_CONTEXT_ERR, "encoder <open> context failed.");
+ ENCODER_CHECK_STATUS(ENCODER_NO_ERROR == ret,
+ ret,
+ "encoder <open> failed.");
+ ENCODER_CHECK_STATUS(priv->context,
+ ENCODER_CONTEXT_ERR,
+ "encoder <open> context failed.");
priv->va_context = gst_vaapi_context_get_id(priv->context);
priv->state = VAAPI_ENC_OPENED;
}
EncoderStatus
-gst_vaapi_encoder_encode(GstVaapiEncoder* encoder, GstBuffer *raw_pic, GList **coded_pics)
+gst_vaapi_encoder_encode(
+ GstVaapiEncoder* encoder,
+ GstBuffer *raw_pic,
+ GList **coded_pics
+)
{
EncoderStatus ret = ENCODER_NO_ERROR;
GstVaapiEncoderClass *encoder_class = GST_VAAPI_ENCODER_GET_CLASS(encoder);
GstVaapiEncoderPrivate *priv = encoder->priv;
- ENCODER_CHECK_STATUS(priv->state >= VAAPI_ENC_OPENED, ENCODER_STATE_ERR, "encoder was not opened before <encode>.");
- ENCODER_CHECK_STATUS(encoder_class->encode, ENCODER_FUNC_PTR_ERR, "encoder <encode> function pointer empty.");
+ ENCODER_CHECK_STATUS(priv->state >= VAAPI_ENC_OPENED,
+ ENCODER_STATE_ERR,
+ "encoder was not opened before <encode>.");
+ ENCODER_CHECK_STATUS(encoder_class->encode,
+ ENCODER_FUNC_PTR_ERR,
+ "encoder <encode> function pointer empty.");
ret = encoder_class->encode(encoder, raw_pic, coded_pics);
- ENCODER_CHECK_STATUS(ENCODER_NO_ERROR == ret, ret, "encoder <encode> failed.");
+ ENCODER_CHECK_STATUS(ENCODER_NO_ERROR == ret,
+ ret,
+ "encoder <encode> failed.");
if (priv->state < VAAPI_ENC_ENCODING) {
priv->state = VAAPI_ENC_ENCODING;
}
return ret;
}
-EncoderStatus gst_vaapi_encoder_get_codec_data(GstVaapiEncoder* encoder, GstBuffer **codec_data)
+EncoderStatus
+gst_vaapi_encoder_get_codec_data(
+ GstVaapiEncoder* encoder,
+ GstBuffer **codec_data
+)
{
EncoderStatus ret = ENCODER_NO_ERROR;
GstVaapiEncoderClass *encoder_class = GST_VAAPI_ENCODER_GET_CLASS(encoder);
GstVaapiEncoderPrivate *priv = encoder->priv;
- ENCODER_CHECK_STATUS(priv->state >= VAAPI_ENC_OPENED, ENCODER_STATE_ERR, "encoder was not opened before <get_codec_data>.");
+ ENCODER_CHECK_STATUS(priv->state >= VAAPI_ENC_OPENED,
+ ENCODER_STATE_ERR,
+ "encoder was not opened before <get_codec_data>.");
if (!encoder_class->get_codec_data) {
*codec_data = NULL;
ENCODER_LOG_INFO("There's no codec_data");
}
EncoderStatus
-gst_vaapi_encoder_flush(GstVaapiEncoder* encoder, GList **coded_pics)
+gst_vaapi_encoder_flush(
+ GstVaapiEncoder* encoder,
+ GList **coded_pics
+)
{
EncoderStatus ret = ENCODER_NO_ERROR;
GstVaapiEncoderClass *encoder_class = GST_VAAPI_ENCODER_GET_CLASS(encoder);
if (priv->state < VAAPI_ENC_OPENED) {
return ENCODER_STATE_ERR;
}
- ENCODER_CHECK_STATUS(encoder_class->flush, ENCODER_FUNC_PTR_ERR, "encoder <flush> function pointer empty.");
+ ENCODER_CHECK_STATUS(encoder_class->flush,
+ ENCODER_FUNC_PTR_ERR,
+ "encoder <flush> function pointer empty.");
ret = encoder_class->flush(encoder, coded_pics);
- ENCODER_CHECK_STATUS(ENCODER_NO_ERROR == ret, ret, "encoder <flush> failed.");
+ ENCODER_CHECK_STATUS(ENCODER_NO_ERROR == ret,
+ ret,
+ "encoder <flush> failed.");
if (priv->state > VAAPI_ENC_OPENED) {
priv->state = VAAPI_ENC_OPENED;
}
if (VAAPI_ENC_INIT >= priv->state) {
return ENCODER_NO_ERROR;
}
- ENCODER_CHECK_STATUS(encoder_class->close, ENCODER_FUNC_PTR_ERR, "encoder <close> function pointers empty.");
+ ENCODER_CHECK_STATUS(encoder_class->close,
+ ENCODER_FUNC_PTR_ERR,
+ "encoder <close> function pointers empty.");
ret = encoder_class->close(encoder);
- ENCODER_CHECK_STATUS(ENCODER_NO_ERROR == ret, ret, "encoder <close> failed.");
+ ENCODER_CHECK_STATUS(ENCODER_NO_ERROR == ret,
+ ret,
+ "encoder <close> failed.");
end:
if (priv->context) {
g_object_unref(priv->context);
ENCODER_ASSERT(VAAPI_ENC_INIT == priv->state);
if (encoder_class->uninitialize) {
ret = encoder_class->uninitialize(encoder);
- ENCODER_CHECK_STATUS(ENCODER_NO_ERROR == ret, ret, "encoder <uninitialize> failed.");
+ ENCODER_CHECK_STATUS(ENCODER_NO_ERROR == ret,
+ ret,
+ "encoder <uninitialize> failed.");
}
end:
}
-char *vaapi_encoder_dump_bytes(const guint8 *buf, guint32 num)
+char *
+vaapi_encoder_dump_bytes(const guint8 *buf, guint32 num)
{
static char tmp[1024];
guint32 i = 0;
g_type_class_add_private(kclass, sizeof(GstVaapiEncoderPrivate));
- GST_DEBUG_CATEGORY_INIT (gst_vaapi_encoder_debug, "gst_va_encoder", 0,
- "gst_va_encoder element");
+ GST_DEBUG_CATEGORY_INIT (gst_vaapi_encoder_debug,
+ "gst_va_encoder",
+ 0,
+ "gst_va_encoder element");
object_class->finalize = gst_vaapi_encoder_finalize;
}
#include "gst/gstinfo.h"
#include "gst/gstbuffer.h"
-#include "gstvaapidisplay.h"
-#include "gstvaapicontext.h"
+
+#include "gst/vaapi/gstvaapidisplay.h"
+#include "gst/vaapi/gstvaapicontext.h"
G_BEGIN_DECLS
#define ENCODER_FUNC_PTR_ERR -13
#ifdef DEBUG
- #define ENCODER_LOG_ERROR(str_fmt,...) fprintf(stdout, str_fmt "\n", ## __VA_ARGS__)
- #define ENCODER_LOG_WARNING(str_fmt,...) fprintf(stdout, str_fmt "\n", ## __VA_ARGS__)
- #define ENCODER_LOG_DEBUG(str_fmt,...) fprintf(stdout, str_fmt "\n", ## __VA_ARGS__)
- #define ENCODER_LOG_INFO(str_fmt,...) fprintf(stdout, str_fmt "\n", ## __VA_ARGS__)
+ #define ENCODER_LOG_ERROR(str_fmt,...) \
+ fprintf(stdout, str_fmt "\n", ## __VA_ARGS__)
+ #define ENCODER_LOG_WARNING(str_fmt,...) \
+ fprintf(stdout, str_fmt "\n", ## __VA_ARGS__)
+ #define ENCODER_LOG_DEBUG(str_fmt,...) \
+ fprintf(stdout, str_fmt "\n", ## __VA_ARGS__)
+ #define ENCODER_LOG_INFO(str_fmt,...) \
+ fprintf(stdout, str_fmt "\n", ## __VA_ARGS__)
#else
#define ENCODER_LOG_ERROR(...) GST_ERROR( __VA_ARGS__)
#define ENCODER_LOG_WARNING(...) GST_WARNING( __VA_ARGS__)
typedef struct _GstVaapiEncoderPrivate GstVaapiEncoderPrivate;
typedef struct _GstVaapiEncoderClass GstVaapiEncoderClass;
-#define GST_TYPE_VAAPI_ENCODER (gst_vaapi_encoder_get_type())
-#define GST_IS_VAAPI_ENCODER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GST_TYPE_VAAPI_ENCODER))
-#define GST_IS_VAAPI_ENCODER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GST_TYPE_VAAPI_ENCODER))
-#define GST_VAAPI_ENCODER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GST_TYPE_VAAPI_ENCODER, GstVaapiEncoderClass))
-#define GST_VAAPI_ENCODER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GST_TYPE_VAAPI_ENCODER, GstVaapiEncoder))
-#define GST_VAAPI_ENCODER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GST_TYPE_VAAPI_ENCODER, GstVaapiEncoderClass))
-#define GST_VAAPI_ENCODER_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE((obj),GST_TYPE_VAAPI_ENCODER, GstVaapiEncoderPrivate))
+#define GST_TYPE_VAAPI_ENCODER \
+ (gst_vaapi_encoder_get_type())
+
+#define GST_IS_VAAPI_ENCODER(obj) \
+ (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GST_TYPE_VAAPI_ENCODER))
+
+#define GST_IS_VAAPI_ENCODER_CLASS(klass) \
+ (G_TYPE_CHECK_CLASS_TYPE ((klass), GST_TYPE_VAAPI_ENCODER))
+
+#define GST_VAAPI_ENCODER_GET_CLASS(obj) \
+ (G_TYPE_INSTANCE_GET_CLASS ((obj), \
+ GST_TYPE_VAAPI_ENCODER, \
+ GstVaapiEncoderClass))
+
+#define GST_VAAPI_ENCODER(obj) \
+ (G_TYPE_CHECK_INSTANCE_CAST ((obj), \
+ GST_TYPE_VAAPI_ENCODER, \
+ GstVaapiEncoder))
+
+#define GST_VAAPI_ENCODER_CLASS(klass) \
+ (G_TYPE_CHECK_CLASS_CAST ((klass), \
+ GST_TYPE_VAAPI_ENCODER, \
+ GstVaapiEncoderClass))
+
+#define GST_VAAPI_ENCODER_GET_PRIVATE(obj) \
+ (G_TYPE_INSTANCE_GET_PRIVATE((obj), \
+ GST_TYPE_VAAPI_ENCODER, \
+ GstVaapiEncoderPrivate))
-#define GST_VAAPI_ENCODER_CAST(encoder) ((GstVaapiEncoder *)(encoder))
+#define GST_VAAPI_ENCODER_CAST(encoder) \
+ ((GstVaapiEncoder *)(encoder))
-#define ENCODER_DISPLAY(encoder) (((GstVaapiEncoder*)(encoder))->priv->display)
-#define ENCODER_VA_DISPLAY(encoder) (((GstVaapiEncoder*)(encoder))->priv->va_display)
+/* Get GstVaapiDisplay* */
+#define ENCODER_DISPLAY(encoder) \
+ (((GstVaapiEncoder*)(encoder))->priv->display)
-#define ENCODER_CONTEXT(encoder) (((GstVaapiEncoder*)(encoder))->priv->context)
-#define ENCODER_VA_CONTEXT(encoder) (((GstVaapiEncoder*)(encoder))->priv->va_context)
+/* Get VADisplay */
+#define ENCODER_VA_DISPLAY(encoder) \
+ (((GstVaapiEncoder*)(encoder))->priv->va_display)
+
+/* Get GstVaapiContext* */
+#define ENCODER_CONTEXT(encoder) \
+ (((GstVaapiEncoder*)(encoder))->priv->context)
+
+/* Get VAContext */
+#define ENCODER_VA_CONTEXT(encoder) \
+ (((GstVaapiEncoder*)(encoder))->priv->va_context)
#define ENCODER_WIDTH(encoder) (((GstVaapiEncoder*)(encoder))->width)
#define ENCODER_HEIGHT(encoder) (((GstVaapiEncoder*)(encoder))->height)
VAAPI_Encode_State state;
};
-GType gst_vaapi_encoder_get_type(void);
+GType
+gst_vaapi_encoder_get_type(void);
/* set/get display */
-gboolean gst_vaapi_encoder_set_display(GstVaapiEncoder* encoder, GstVaapiDisplay *display);
-GstVaapiDisplay *gst_vaapi_encoder_get_display(GstVaapiEncoder* encoder);
+gboolean
+gst_vaapi_encoder_set_display(
+ GstVaapiEncoder* encoder,
+ GstVaapiDisplay *display
+);
+GstVaapiDisplay *
+gst_vaapi_encoder_get_display(GstVaapiEncoder* encoder);
/* get context */
-GstVaapiContext *gst_vaapi_encoder_get_context(GstVaapiEncoder* encoder);
+GstVaapiContext *
+gst_vaapi_encoder_get_context(GstVaapiEncoder* encoder);
/* get encoding state */
-VAAPI_Encode_State gst_vaapi_encoder_get_state(GstVaapiEncoder* encoder);
+VAAPI_Encode_State
+gst_vaapi_encoder_get_state(GstVaapiEncoder* encoder);
/* check/open display */
-EncoderStatus gst_vaapi_encoder_initialize(GstVaapiEncoder* encoder);
+EncoderStatus
+gst_vaapi_encoder_initialize(GstVaapiEncoder* encoder);
/* check/open context */
-EncoderStatus gst_vaapi_encoder_open(GstVaapiEncoder* encoder);
+EncoderStatus
+gst_vaapi_encoder_open(GstVaapiEncoder* encoder);
/* encode one frame */
-EncoderStatus gst_vaapi_encoder_encode(GstVaapiEncoder* encoder, GstBuffer *raw_pic, GList **coded_pics);
-
-EncoderStatus gst_vaapi_encoder_get_codec_data(GstVaapiEncoder* encoder, GstBuffer **codec_data);
+EncoderStatus
+gst_vaapi_encoder_encode(
+ GstVaapiEncoder* encoder,
+ GstBuffer *raw_pic,
+ GList **coded_pics
+);
+
+EncoderStatus
+gst_vaapi_encoder_get_codec_data(
+ GstVaapiEncoder* encoder,
+ GstBuffer **codec_data
+);
/* flush all frames */
-EncoderStatus gst_vaapi_encoder_flush(GstVaapiEncoder* encoder, GList **coded_pics);
+EncoderStatus
+gst_vaapi_encoder_flush(GstVaapiEncoder* encoder, GList **coded_pics);
/* close context */
-EncoderStatus gst_vaapi_encoder_close(GstVaapiEncoder* encoder);
+EncoderStatus
+gst_vaapi_encoder_close(GstVaapiEncoder* encoder);
/* close display */
-EncoderStatus gst_vaapi_encoder_uninitialize(GstVaapiEncoder* encoder);
+EncoderStatus
+gst_vaapi_encoder_uninitialize(GstVaapiEncoder* encoder);
-static inline void gst_vaapi_encoder_unref (GstVaapiEncoder *encoder)
+static inline void
+gst_vaapi_encoder_unref (GstVaapiEncoder *encoder)
{
g_object_unref (encoder);
}
/* other functions */
char *vaapi_encoder_dump_bytes(const guint8 *buf, guint32 num);
-
G_END_DECLS
-#endif
-
+#endif /* GST_VAAPI_ENCODER_H */
#include <string.h>
#include <gst/gstclock.h>
-#include "gst/vaapi/gstvaapiobject.h"
-#include "gst/vaapi/gstvaapiobject_priv.h"
-#include "gst/vaapi/gstvaapicontext.h"
-#include "gst/vaapi/gstvaapisurface.h"
-#include "gst/vaapi/gstvaapivideobuffer.h"
-#include "gst/vaapi/gstvaapidisplay_priv.h"
+#include "gstvaapiobject.h"
+#include "gstvaapiobject_priv.h"
+#include "gstvaapicontext.h"
+#include "gstvaapisurface.h"
+#include "gstvaapivideobuffer.h"
+#include "gstvaapidisplay_priv.h"
GST_DEBUG_CATEGORY_STATIC (gst_vaapi_h263_encoder_debug);
#define GST_CAT_DEFAULT gst_vaapi_h263_encoder_debug
GstVaapiSurface *ref_surface; /* reference buffer*/
GstVaapiSurface *recon_surface; /* reconstruct buffer*/
- VABufferID seq_parameter;
- VABufferID pic_parameter;
- VABufferID slice_parameter;
+ VABufferID seq_param_id;
+ VABufferID pic_param_id;
+ VABufferID slic_param_id;
};
-G_DEFINE_TYPE(GstVaapiEncoderH263, gst_vaapi_encoder_h263, GST_TYPE_VAAPI_BASE_ENCODER);
+G_DEFINE_TYPE(GstVaapiEncoderH263, gst_vaapi_encoder_h263, GST_TYPE_VAAPI_BASE_ENCODER)
GstVaapiEncoderH263 *
gst_vaapi_encoder_h263_new(void)
}
static gboolean
-gst_h263_validate_parameters(GstVaapiBaseEncoder* base)
+gst_vaapi_encoder_h263_validate_attributes(
+ GstVaapiBaseEncoder* base
+)
{
GstVaapiEncoderH263 *encoder = GST_VAAPI_ENCODER_H263_CAST(base);
- if (!ENCODER_WIDTH(encoder) || !ENCODER_HEIGHT(encoder) || !ENCODER_FPS(encoder)) {
+ if (!ENCODER_WIDTH(encoder) ||
+ !ENCODER_HEIGHT(encoder) ||
+ !ENCODER_FPS(encoder))
+ {
return FALSE;
}
if (!encoder->intra_period) {
/* default compress ratio 1: (4*8*1.5) */
if (!encoder->bitrate) {
- encoder->bitrate = ENCODER_WIDTH(encoder)*ENCODER_HEIGHT(encoder)*ENCODER_FPS(encoder)/4;
+ encoder->bitrate =
+ ENCODER_WIDTH(encoder)*ENCODER_HEIGHT(encoder)*ENCODER_FPS(encoder)/4;
}
- gst_vaapi_base_encoder_set_va_profile(GST_VAAPI_BASE_ENCODER(encoder), VAProfileH263Baseline);
+ gst_vaapi_base_encoder_set_va_profile(GST_VAAPI_BASE_ENCODER(encoder),
+ VAProfileH263Baseline);
return TRUE;
}
static void
-h263_release_parameters(GstVaapiEncoderH263 *encoder)
+h263_release_parameters(
+ GstVaapiEncoderH263 *encoder
+)
{
GstVaapiEncoderH263Private *priv = encoder->priv;
VADisplay va_dpy = ENCODER_VA_DISPLAY(encoder);
VAAPI_UNUSED_ARG(va_status);
- if (VA_INVALID_ID != priv->seq_parameter) {
- va_status = vaDestroyBuffer(va_dpy, priv->seq_parameter);
- priv->seq_parameter = VA_INVALID_ID;
+ if (VA_INVALID_ID != priv->seq_param_id) {
+ va_status = vaDestroyBuffer(va_dpy, priv->seq_param_id);
+ priv->seq_param_id = VA_INVALID_ID;
}
- if (VA_INVALID_ID != priv->pic_parameter) {
- va_status = vaDestroyBuffer(va_dpy, priv->pic_parameter);
- priv->pic_parameter = VA_INVALID_ID;
+ if (VA_INVALID_ID != priv->pic_param_id) {
+ va_status = vaDestroyBuffer(va_dpy, priv->pic_param_id);
+ priv->pic_param_id = VA_INVALID_ID;
}
- if (VA_INVALID_ID != priv->slice_parameter) {
- va_status = vaDestroyBuffer(va_dpy, priv->slice_parameter);
- priv->slice_parameter = VA_INVALID_ID;
+ if (VA_INVALID_ID != priv->slic_param_id) {
+ va_status = vaDestroyBuffer(va_dpy, priv->slic_param_id);
+ priv->slic_param_id = VA_INVALID_ID;
}
}
static gboolean
-gst_vaapi_encoder_h263_release_resource(GstVaapiBaseEncoder* base)
+gst_vaapi_encoder_h263_release_resource(
+ GstVaapiBaseEncoder* base
+)
{
GstVaapiEncoderH263 *encoder = GST_VAAPI_ENCODER_H263_CAST(base);
GstVaapiEncoderH263Private *priv = encoder->priv;
*is_key = (frame_index % encoder->intra_period == 0);
/* initialize sequence parameter set, only first time */
- if (VA_INVALID_ID == priv->seq_parameter) { /*only the first time*/
- VAEncSequenceParameterBufferH263 seq_h263 = {0};
+ if (VA_INVALID_ID == priv->seq_param_id) { /*only the first time*/
+ VAEncSequenceParameterBufferH263 seq_param = {0};
- seq_h263.intra_period = encoder->intra_period;
- seq_h263.bits_per_second = encoder->bitrate;
- seq_h263.frame_rate = ENCODER_FPS(encoder);
- seq_h263.initial_qp = encoder->init_qp;
- seq_h263.min_qp = encoder->min_qp;
+ seq_param.intra_period = encoder->intra_period;
+ seq_param.bits_per_second = encoder->bitrate;
+ seq_param.frame_rate = ENCODER_FPS(encoder);
+ seq_param.initial_qp = encoder->init_qp;
+ seq_param.min_qp = encoder->min_qp;
va_status = vaCreateBuffer(va_dpy, context_id,
VAEncSequenceParameterBufferType,
- sizeof(seq_h263), 1, &seq_h263, &priv->seq_parameter);
- ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS == va_status, ENCODER_ENC_RES_ERR, "h263 alloc seq-buffer failed.");
- va_status = vaRenderPicture(va_dpy, context_id, &priv->seq_parameter, 1);
- ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS == va_status, ENCODER_PICTURE_ERR, "h263 vaRenderPicture seq-parameters failed.");
+ sizeof(seq_param), 1,
+ &seq_param,
+ &priv->seq_param_id);
+ ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS == va_status,
+ ENCODER_ENC_RES_ERR,
+ "h263 alloc seq-buffer failed.");
+ va_status = vaRenderPicture(va_dpy, context_id, &priv->seq_param_id, 1);
+ ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS == va_status,
+ ENCODER_PICTURE_ERR,
+ "h263 vaRenderPicture seq-parameters failed.");
}
/* set reference and reconstructed surfaces */
if (!priv->ref_surface) {
priv->ref_surface = gst_vaapi_context_get_surface(context);
- ENCODER_CHECK_STATUS(priv->ref_surface, ENCODER_SURFACE_ERR, "h263 reference surface, h263_pop_free_surface failed.");
+ ENCODER_CHECK_STATUS(priv->ref_surface,
+ ENCODER_SURFACE_ERR,
+ "h263 reference surface, h263_pop_free_surface failed.");
}
if (!priv->recon_surface) {
priv->recon_surface = gst_vaapi_context_get_surface(context);
- ENCODER_CHECK_STATUS(priv->recon_surface, ENCODER_SURFACE_ERR, "h263 reconstructed surface, h263_pop_free_surface failed.");
+ ENCODER_CHECK_STATUS(priv->recon_surface,
+ ENCODER_SURFACE_ERR,
+ "h263 reconstructed surface, h263_pop_free_surface failed.");
}
/* initialize picture, every time, every frame */
- VAEncPictureParameterBufferH263 pic_h263 = {0};
- pic_h263.reference_picture = GST_VAAPI_OBJECT_ID(priv->ref_surface);
- pic_h263.reconstructed_picture = GST_VAAPI_OBJECT_ID(priv->recon_surface);
- pic_h263.coded_buf = coded_buf;
- pic_h263.picture_width = ENCODER_WIDTH(encoder);
- pic_h263.picture_height = ENCODER_HEIGHT(encoder);
- pic_h263.picture_type = (*is_key) ? VAEncPictureTypeIntra : VAEncPictureTypePredictive;
- if (VA_INVALID_ID != priv->pic_parameter) { /* destroy first*/
- va_status = vaDestroyBuffer(va_dpy, priv->pic_parameter);
- priv->pic_parameter = VA_INVALID_ID;
+ VAEncPictureParameterBufferH263 pic_param = {0};
+ pic_param.reference_picture = GST_VAAPI_OBJECT_ID(priv->ref_surface);
+ pic_param.reconstructed_picture = GST_VAAPI_OBJECT_ID(priv->recon_surface);
+ pic_param.coded_buf = coded_buf;
+ pic_param.picture_width = ENCODER_WIDTH(encoder);
+ pic_param.picture_height = ENCODER_HEIGHT(encoder);
+ pic_param.picture_type = (*is_key) ? VAEncPictureTypeIntra : VAEncPictureTypePredictive;
+ if (VA_INVALID_ID != priv->pic_param_id) { /* destroy first*/
+ va_status = vaDestroyBuffer(va_dpy, priv->pic_param_id);
+ priv->pic_param_id = VA_INVALID_ID;
}
va_status = vaCreateBuffer(va_dpy, context_id, VAEncPictureParameterBufferType,
- sizeof(pic_h263), 1, &pic_h263, &priv->pic_parameter);
+ sizeof(pic_param), 1, &pic_param, &priv->pic_param_id);
ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS ==va_status,
ENCODER_ENC_RES_ERR, "h263 creating pic-param buffer failed.");
- va_status = vaRenderPicture(va_dpy, context_id, &priv->pic_parameter, 1);
+ va_status = vaRenderPicture(va_dpy, context_id, &priv->pic_param_id, 1);
ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS ==va_status,
ENCODER_PICTURE_ERR, "h263 rendering pic-param buffer failed.");
/*initialize slice parameters, only ONE slice for h263*/
- VAEncSliceParameterBuffer slice_h263 = { 0 };
- slice_h263.start_row_number = 0;
- slice_h263.slice_height = (ENCODER_HEIGHT(encoder)+15)/16; /*MB?*/
- slice_h263.slice_flags.bits.is_intra = *is_key;
- slice_h263.slice_flags.bits.disable_deblocking_filter_idc = 0;
- if (VA_INVALID_ID != priv->slice_parameter) {
- vaDestroyBuffer(va_dpy, priv->slice_parameter);
- priv->slice_parameter = VA_INVALID_ID;
+ VAEncSliceParameterBuffer slice_param = { 0 };
+ slice_param.start_row_number = 0;
+ slice_param.slice_height = (ENCODER_HEIGHT(encoder)+15)/16; /*MB?*/
+ slice_param.slice_flags.bits.is_intra = *is_key;
+ slice_param.slice_flags.bits.disable_deblocking_filter_idc = 0;
+ if (VA_INVALID_ID != priv->slic_param_id) {
+ vaDestroyBuffer(va_dpy, priv->slic_param_id);
+ priv->slic_param_id = VA_INVALID_ID;
}
va_status = vaCreateBuffer(va_dpy,
context_id,
VAEncSliceParameterBufferType,
- sizeof(slice_h263),
+ sizeof(slice_param),
1,
- &slice_h263,
- &priv->slice_parameter);
+ &slice_param,
+ &priv->slic_param_id);
ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS ==va_status,
ENCODER_ENC_RES_ERR,
"h263 creating slice-parameters buffer failed.");
- va_status = vaRenderPicture(va_dpy, context_id, &priv->slice_parameter, 1);
+ va_status = vaRenderPicture(va_dpy, context_id, &priv->slic_param_id, 1);
ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS ==va_status,
ENCODER_PICTURE_ERR,
"h263 rendering slice-parameters buffer failed.");
priv->ref_surface = NULL;
priv->recon_surface = NULL;
- priv->seq_parameter = VA_INVALID_ID;
- priv->pic_parameter = VA_INVALID_ID;
- priv->slice_parameter = VA_INVALID_ID;
+ priv->seq_param_id = VA_INVALID_ID;
+ priv->pic_param_id = VA_INVALID_ID;
+ priv->slic_param_id = VA_INVALID_ID;
}
static void
object_class->finalize = gst_vaapi_encoder_h263_finalize;
- base_class->validate_attributes = gst_h263_validate_parameters;
+ base_class->validate_attributes = gst_vaapi_encoder_h263_validate_attributes;
base_class->pre_alloc_resource = NULL;
base_class->release_resource = gst_vaapi_encoder_h263_release_resource;
base_class->render_frame = gst_vaapi_encoder_h263_rendering;
* Boston, MA 02110-1301 USA
*/
-#ifndef _GST_VAAPI_ENCODER_H263_H_
-#define _GST_VAAPI_ENCODER_H263_H_
-
+#ifndef GST_VAAPI_ENCODER_H263_H
+#define GST_VAAPI_ENCODER_H263_H
#include "gst/vaapi/gstvaapisurfacepool.h"
-
-#include "gstvaapibaseencoder.h"
+#include "gst/vaapi/gstvaapibaseencoder.h"
G_BEGIN_DECLS
typedef struct _GstVaapiEncoderH263Class GstVaapiEncoderH263Class;
-#define GST_TYPE_VAAPI_ENCODER_H263 (gst_vaapi_encoder_h263_get_type())
-#define GST_IS_VAAPI_ENCODER_H263(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GST_TYPE_VAAPI_ENCODER_H263))
-#define GST_IS_VAAPI_ENCODER_H263_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GST_TYPE_VAAPI_ENCODER_H263))
-#define GST_VAAPI_ENCODER_H263_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GST_TYPE_VAAPI_ENCODER_H263, GstVaapiEncoderH263Class))
-#define GST_VAAPI_ENCODER_H263(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GST_TYPE_VAAPI_ENCODER_H263, GstVaapiEncoderH263))
-#define GST_VAAPI_ENCODER_H263_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GST_TYPE_VAAPI_ENCODER_H263, GstVaapiEncoderH263Class))
-#define GST_VAAPI_ENCODER_H263_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE((obj),GST_TYPE_VAAPI_ENCODER_H263,GstVaapiEncoderH263Private))
+#define GST_TYPE_VAAPI_ENCODER_H263 \
+ (gst_vaapi_encoder_h263_get_type())
+
+#define GST_IS_VAAPI_ENCODER_H263(obj) \
+ (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GST_TYPE_VAAPI_ENCODER_H263))
+
+#define GST_IS_VAAPI_ENCODER_H263_CLASS(klass) \
+ (G_TYPE_CHECK_CLASS_TYPE ((klass), GST_TYPE_VAAPI_ENCODER_H263))
+
+#define GST_VAAPI_ENCODER_H263_GET_CLASS(obj) \
+ (G_TYPE_INSTANCE_GET_CLASS ((obj), \
+ GST_TYPE_VAAPI_ENCODER_H263, \
+ GstVaapiEncoderH263Class))
+
+#define GST_VAAPI_ENCODER_H263(obj) \
+ (G_TYPE_CHECK_INSTANCE_CAST ((obj), \
+ GST_TYPE_VAAPI_ENCODER_H263, \
+ GstVaapiEncoderH263))
+
+#define GST_VAAPI_ENCODER_H263_CLASS(klass) \
+ (G_TYPE_CHECK_CLASS_CAST ((klass), \
+ GST_TYPE_VAAPI_ENCODER_H263, \
+ GstVaapiEncoderH263Class))
+
+#define GST_VAAPI_ENCODER_H263_GET_PRIVATE(obj) \
+ (G_TYPE_INSTANCE_GET_PRIVATE((obj), \
+ GST_TYPE_VAAPI_ENCODER_H263, \
+ GstVaapiEncoderH263Private))
struct _GstVaapiEncoderH263 {
GstVaapiBaseEncoder parent; /*based on gobject*/
};
-GType gst_vaapi_encoder_h263_get_type(void);
+GType
+gst_vaapi_encoder_h263_get_type(void);
-GstVaapiEncoderH263 *gst_vaapi_encoder_h263_new(void);
-static inline void gst_vaapi_encoder_h263_unref (GstVaapiEncoderH263 * encoder)
+GstVaapiEncoderH263 *
+gst_vaapi_encoder_h263_new(void);
+
+static inline void
+gst_vaapi_encoder_h263_unref (GstVaapiEncoderH263 * encoder)
{
g_object_unref (encoder);
}
G_END_DECLS
-#endif /* _GST_VAAPI_ENCODER_H263_H_ */
-
+#endif /* GST_VAAPI_ENCODER_H263_H */
#include "gst/gstclock.h"
#include "gst/gstvalue.h"
-#include "gst/vaapi/gstvaapiobject.h"
-#include "gst/vaapi/gstvaapiobject_priv.h"
-#include "gst/vaapi/gstvaapicontext.h"
-#include "gst/vaapi/gstvaapisurface.h"
-#include "gst/vaapi/gstvaapivideobuffer.h"
-#include "gst/vaapi/gstvaapidisplay_priv.h"
-
-/* enable old lib va*/
-//#define _SIMPLE_LIB_VA_
+#include "gstvaapiobject.h"
+#include "gstvaapiobject_priv.h"
+#include "gstvaapicontext.h"
+#include "gstvaapisurface.h"
+#include "gstvaapivideobuffer.h"
+#include "gstvaapidisplay_priv.h"
GST_DEBUG_CATEGORY_STATIC (gst_vaapi_h264_encoder_debug);
+
#define GST_CAT_DEFAULT gst_vaapi_h264_encoder_debug
#define GST_VAAPI_ENCODER_H264_CAST(encoder) ((GstVaapiEncoderH264 *)(encoder))
GstVaapiSurface *ref_surface2; /* for B frames */
GstVaapiSurface *recon_surface; /* reconstruct buffer*/
- VABufferID seq_parameter;
- VABufferID pic_parameter;
- VABufferID slice_parameter;
- VABufferID packed_sps_par_buf;
- VABufferID packed_sps_data_buf;
- VABufferID packed_pps_par_buf;
- VABufferID packed_pps_data_buf;
+ VABufferID seq_param_id;
+ VABufferID pic_param_id;
+ VABufferID slice_param_id;
+ VABufferID packed_seq_param_id;
+ VABufferID packed_seq_data_id;
+ VABufferID packed_pic_param_id;
+ VABufferID packed_pic_data_id;
#ifdef _SIMPLE_LIB_VA_
VAEncSliceParameterBuffer *slice_param_buffers;
#else
guint16 idr_num;
};
-G_DEFINE_TYPE(GstVaapiEncoderH264, gst_vaapi_encoder_h264, GST_TYPE_VAAPI_BASE_ENCODER);
-
+G_DEFINE_TYPE(GstVaapiEncoderH264, gst_vaapi_encoder_h264, GST_TYPE_VAAPI_BASE_ENCODER)
// 4096-1
#define H264_BITSTREAM_ALLOC_ALIGN_MASK 0x0FFF
static const guint8 h264_bit_mask[9] = {0x00, 0x01, 0x03, 0x07, 0x0F, 0x1F, 0x3F, 0x7F, 0xFF};
-/*other functions*/
-static void gst_vaapi_encoder_h264_init_public_values(GstVaapiEncoderH264* encoder);
-
/* h264 bitstream functions */
-static void h264_bitstream_init(H264Bitstream *bitstream, guint32 bit_capability);
-static gboolean h264_bitstream_write_uint(H264Bitstream *bitstream, guint32 value, guint32 bit_size);
-static gboolean h264_bitstream_align(H264Bitstream *bitstream, guint32 value);
-static gboolean h264_bitstream_write_ue(H264Bitstream *bitstream, guint32 value);
-static gboolean h264_bitstream_write_se(H264Bitstream *bitstream, gint32 value);
-static gboolean h264_bitstream_write_trailing_bits(H264Bitstream *bitstream);
-
-static gboolean h264_bitstream_write_byte_array(H264Bitstream *bitstream, const guint8 *buf, guint32 byte_size);
-static void h264_bitstream_destroy(H264Bitstream *bitstream, gboolean free_flag);
-static gboolean h264_bitstream_auto_grow(H264Bitstream *bitstream, guint32 extra_bit_size);
-static gboolean h264_bitstream_write_sps(H264Bitstream *bitstream,
- VAEncSequenceParameterBufferH264 *seq, H264_Profile profile);
-static gboolean h264_bitstream_write_pps(H264Bitstream *bitstream, VAEncPictureParameterBufferH264 *pic);
-static gboolean h264_bitstream_write_nal_header(H264Bitstream *bitstream,
- guint nal_ref_idc, guint nal_unit_type);
-
-static const guint8 *h264_next_nal(const guint8 *buffer, guint32 len, guint32 *nal_size);
-static gboolean h264_read_sps_attributes(const guint8 *sps_data, guint32 sps_size,
- guint32 *profile_idc, guint32 *profile_comp, guint32 *level_idc);
+static void
+h264_bitstream_init(H264Bitstream *bitstream, guint32 bit_capability);
+
+static gboolean
+h264_bitstream_write_uint(
+ H264Bitstream *bitstream,
+ guint32 value,
+ guint32 bit_size
+);
+
+static gboolean
+h264_bitstream_align(H264Bitstream *bitstream, guint32 value);
+
+static gboolean
+h264_bitstream_write_ue(H264Bitstream *bitstream, guint32 value);
+
+static gboolean
+h264_bitstream_write_se(H264Bitstream *bitstream, gint32 value);
+
+static gboolean
+h264_bitstream_write_trailing_bits(H264Bitstream *bitstream);
+
+static gboolean
+h264_bitstream_write_byte_array(
+ H264Bitstream *bitstream,
+ const guint8 *buf,
+ guint32 byte_size
+);
+
+static void
+h264_bitstream_destroy(H264Bitstream *bitstream, gboolean free_flag);
+
+static gboolean
+h264_bitstream_auto_grow(H264Bitstream *bitstream, guint32 extra_bit_size);
+
+static gboolean
+h264_bitstream_write_sps(
+ H264Bitstream *bitstream,
+ VAEncSequenceParameterBufferH264 *seq,
+ H264_Profile profile
+);
+static gboolean
+h264_bitstream_write_pps(
+ H264Bitstream *bitstream,
+ VAEncPictureParameterBufferH264 *pic
+);
+
+static gboolean
+h264_bitstream_write_nal_header(
+ H264Bitstream *bitstream,
+ guint nal_ref_idc,
+ guint nal_unit_type
+);
static VAProfile
h264_get_va_profile(guint32 profile)
GstVaapiEncoderH264 *
gst_vaapi_encoder_h264_new(void)
{
- return GST_VAAPI_ENCODER_H264_CAST(g_object_new(GST_TYPE_VAAPI_ENCODER_H264, NULL));
+ return GST_VAAPI_ENCODER_H264_CAST(
+ g_object_new(GST_TYPE_VAAPI_ENCODER_H264, NULL));
}
static void
}
gboolean
-gst_h264_validate_parameters(GstVaapiBaseEncoder *base)
+gst_vaapi_encoder_h264_validate_attributes(GstVaapiBaseEncoder *base)
{
GstVaapiEncoderH264 *encoder = GST_VAAPI_ENCODER_H264_CAST(base);
GstVaapiEncoderH264Private *priv = encoder->priv;
- if (!ENCODER_WIDTH(encoder) || !ENCODER_HEIGHT(encoder) || !ENCODER_FPS(encoder)) {
+ if (!ENCODER_WIDTH(encoder) ||
+ !ENCODER_HEIGHT(encoder) ||
+ !ENCODER_FPS(encoder)) {
return FALSE;
}
if (!encoder->profile) {
VADisplay va_dpy = gst_vaapi_display_get_display(display);
ENCODER_ACQUIRE_DISPLAY_LOCK(display);
- if (VA_INVALID_ID != priv->seq_parameter) {
- va_status = vaDestroyBuffer(va_dpy, priv->seq_parameter);
- priv->seq_parameter = VA_INVALID_ID;
+ if (VA_INVALID_ID != priv->seq_param_id) {
+ va_status = vaDestroyBuffer(va_dpy, priv->seq_param_id);
+ priv->seq_param_id = VA_INVALID_ID;
}
- if (VA_INVALID_ID != priv->pic_parameter) {
- va_status = vaDestroyBuffer(va_dpy, priv->pic_parameter);
- priv->pic_parameter = VA_INVALID_ID;
+ if (VA_INVALID_ID != priv->pic_param_id) {
+ va_status = vaDestroyBuffer(va_dpy, priv->pic_param_id);
+ priv->pic_param_id = VA_INVALID_ID;
}
- if (VA_INVALID_ID != priv->slice_parameter) {
- va_status = vaDestroyBuffer(va_dpy, priv->slice_parameter);
- priv->slice_parameter = VA_INVALID_ID;
+ if (VA_INVALID_ID != priv->slice_param_id) {
+ va_status = vaDestroyBuffer(va_dpy, priv->slice_param_id);
+ priv->slice_param_id = VA_INVALID_ID;
}
- if (VA_INVALID_ID != priv->packed_sps_par_buf) {
- va_status = vaDestroyBuffer(va_dpy, priv->packed_sps_par_buf);
- priv->packed_sps_par_buf = VA_INVALID_ID;
+ if (VA_INVALID_ID != priv->packed_seq_param_id) {
+ va_status = vaDestroyBuffer(va_dpy, priv->packed_seq_param_id);
+ priv->packed_seq_param_id = VA_INVALID_ID;
}
- if (VA_INVALID_ID != priv->packed_sps_data_buf) {
- va_status = vaDestroyBuffer(va_dpy, priv->packed_sps_data_buf);
- priv->packed_sps_data_buf = VA_INVALID_ID;
+ if (VA_INVALID_ID != priv->packed_seq_data_id) {
+ va_status = vaDestroyBuffer(va_dpy, priv->packed_seq_data_id);
+ priv->packed_seq_data_id = VA_INVALID_ID;
}
- if (VA_INVALID_ID != priv->packed_pps_par_buf) {
- va_status = vaDestroyBuffer(va_dpy, priv->packed_pps_par_buf);
- priv->packed_pps_par_buf = VA_INVALID_ID;
+ if (VA_INVALID_ID != priv->packed_pic_param_id) {
+ va_status = vaDestroyBuffer(va_dpy, priv->packed_pic_param_id);
+ priv->packed_pic_param_id = VA_INVALID_ID;
}
- if (VA_INVALID_ID != priv->packed_pps_data_buf) {
- va_status = vaDestroyBuffer(va_dpy, priv->packed_pps_data_buf);
- priv->packed_pps_data_buf = VA_INVALID_ID;
+ if (VA_INVALID_ID != priv->packed_pic_data_id) {
+ va_status = vaDestroyBuffer(va_dpy, priv->packed_pic_data_id);
+ priv->packed_pic_data_id = VA_INVALID_ID;
}
ENCODER_RELEASE_DISPLAY_LOCK(display);
}
static void
-gst_vaapi_encoder_h264_frame_failed(GstVaapiBaseEncoder *base, GstVaapiVideoBuffer* buffer)
+gst_vaapi_encoder_h264_frame_failed(
+ GstVaapiBaseEncoder *base,
+ GstVaapiVideoBuffer* buffer
+)
{
GstVaapiEncoderH264 *encoder = GST_VAAPI_ENCODER_H264_CAST(base);
GstVaapiEncoderH264Private *priv = encoder->priv;
}
static EncoderStatus
-gst_vaapi_encoder_h264_prepare_next_buffer(GstVaapiBaseEncoder* base,
- GstVaapiVideoBuffer *display_buf, gboolean need_flush,
- GstVaapiVideoBuffer **out_buf)
+gst_vaapi_encoder_h264_prepare_next_buffer(
+ GstVaapiBaseEncoder* base,
+ GstVaapiVideoBuffer *display_buf,
+ gboolean need_flush,
+ GstVaapiVideoBuffer **out_buf
+)
{
EncoderStatus ret = ENCODER_NO_ERROR;
GstVaapiEncoderH264 *encoder = GST_VAAPI_ENCODER_H264_CAST(base);
} else {
return_buf = (GstVaapiVideoBuffer*)g_queue_pop_head(priv->queued_buffers);
priv->cur_slice_type = SLICE_TYPE_B;
- priv->cur_display_num = priv->gop_count - 2 - g_queue_get_length(priv->queued_buffers);
+ priv->cur_display_num =
+ priv->gop_count - 2 - g_queue_get_length(priv->queued_buffers);
}
}
VAStatus va_status = VA_STATUS_SUCCESS;
GstVaapiEncoderH264 *h264_encoder = GST_VAAPI_ENCODER_H264_CAST(encoder);
GstVaapiEncoderH264Private *priv = h264_encoder->priv;
- VAEncPictureParameterBufferH264 pic_h264;
- VAEncSliceParameterBuffer *slice_h264 = NULL;
+ VAEncPictureParameterBufferH264 pic_param;
+ VAEncSliceParameterBuffer *slice_param = NULL;
gboolean is_locked = FALSE;
ENCODER_ACQUIRE_DISPLAY_LOCK(display);
/*handle first surface_index*/
/*only need first frame*/
- if (VA_INVALID_ID == priv->seq_parameter) { /*first time*/
- VAEncSequenceParameterBufferH264 seq_h264 = { 0 };
- seq_h264.level_idc = h264_encoder->level; /* 3.0 */
- seq_h264.max_num_ref_frames = 1; /*Only I, P frames*/
- seq_h264.picture_width_in_mbs = (ENCODER_WIDTH(h264_encoder)+15)/16;
- seq_h264.picture_height_in_mbs = (ENCODER_HEIGHT(h264_encoder)+15)/16;
-
- seq_h264.bits_per_second = h264_encoder->bitrate;
- seq_h264.frame_rate = ENCODER_FPS(h264_encoder);
- seq_h264.initial_qp = h264_encoder->init_qp; /*qp_value; 15, 24, 26?*/
- seq_h264.min_qp = h264_encoder->min_qp; /*1, 6, 10*/
- seq_h264.basic_unit_size = 0;
- seq_h264.intra_period = h264_encoder->intra_period;
- seq_h264.intra_idr_period = h264_encoder->intra_period;
+ if (VA_INVALID_ID == priv->seq_param_id) { /*first time*/
+ VAEncSequenceParameterBufferH264 seq = { 0 };
+ seq.level_idc = h264_encoder->level; /* 3.0 */
+ seq.max_num_ref_frames = 1; /*Only I, P frames*/
+ seq.picture_width_in_mbs = (ENCODER_WIDTH(h264_encoder)+15)/16;
+ seq.picture_height_in_mbs = (ENCODER_HEIGHT(h264_encoder)+15)/16;
+
+ seq.bits_per_second = h264_encoder->bitrate;
+ seq.frame_rate = ENCODER_FPS(h264_encoder);
+ seq.initial_qp = h264_encoder->init_qp; /*qp_value; 15, 24, 26?*/
+ seq.min_qp = h264_encoder->min_qp; /*1, 6, 10*/
+ seq.basic_unit_size = 0;
+ seq.intra_period = h264_encoder->intra_period;
+ seq.intra_idr_period = h264_encoder->intra_period;
va_status = vaCreateBuffer(va_dpy, context_id,
VAEncSequenceParameterBufferType,
- sizeof(seq_h264), 1, &seq_h264, &priv->seq_parameter);
+ sizeof(seq), 1, &seq, &priv->seq_param_id);
ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS == va_status,
ENCODER_ENC_RES_ERR, "alloc seq-buffer failed.");
- va_status = vaRenderPicture(va_dpy, context_id, &priv->seq_parameter, 1);
+ va_status = vaRenderPicture(va_dpy, context_id, &priv->seq_param_id, 1);
ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS == va_status,
ENCODER_PICTURE_ERR, "vaRenderPicture seq-parameters failed.");
}
/* set pic_parameters*/
if (!priv->ref_surface1) {
priv->ref_surface1 = gst_vaapi_context_get_surface(context);
- ENCODER_CHECK_STATUS(priv->ref_surface1, ENCODER_SURFACE_ERR,
+ ENCODER_CHECK_STATUS(priv->ref_surface1,
+ ENCODER_SURFACE_ERR,
"reference surface, h264_pop_free_surface failed.");
}
if (!priv->recon_surface) {
priv->recon_surface = gst_vaapi_context_get_surface(context);
- ENCODER_CHECK_STATUS(priv->recon_surface, ENCODER_SURFACE_ERR,
+ ENCODER_CHECK_STATUS(priv->recon_surface,
+ ENCODER_SURFACE_ERR,
"reconstructed surface, h264_pop_free_surface failed.");
}
- pic_h264.reference_picture = GST_VAAPI_OBJECT_ID(priv->ref_surface1);
- pic_h264.reconstructed_picture = GST_VAAPI_OBJECT_ID(priv->recon_surface);
- pic_h264.coded_buf = coded_buf;
- pic_h264.picture_width = ENCODER_WIDTH(h264_encoder);
- pic_h264.picture_height = ENCODER_HEIGHT(h264_encoder);
- pic_h264.last_picture = 0; // last pic or not
+ pic_param.reference_picture = GST_VAAPI_OBJECT_ID(priv->ref_surface1);
+ pic_param.reconstructed_picture = GST_VAAPI_OBJECT_ID(priv->recon_surface);
+ pic_param.coded_buf = coded_buf;
+ pic_param.picture_width = ENCODER_WIDTH(h264_encoder);
+ pic_param.picture_height = ENCODER_HEIGHT(h264_encoder);
+ pic_param.last_picture = 0; // last pic or not
- if (VA_INVALID_ID != priv->pic_parameter) { /* share the same pic_parameter*/
- vaDestroyBuffer(va_dpy, priv->pic_parameter);
- priv->pic_parameter = VA_INVALID_ID;
+ if (VA_INVALID_ID != priv->pic_param_id) { /* share the same pic_param_id*/
+ vaDestroyBuffer(va_dpy, priv->pic_param_id);
+ priv->pic_param_id = VA_INVALID_ID;
}
va_status = vaCreateBuffer(va_dpy, context_id, VAEncPictureParameterBufferType,
- sizeof(pic_h264), 1, &pic_h264, &priv->pic_parameter);
+ sizeof(pic_param), 1, &pic_param, &priv->pic_param_id);
- ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS ==va_status,
- ENCODER_PICTURE_ERR, "creating pic-param buffer failed.");
+ ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS == va_status,
+ ENCODER_PICTURE_ERR,
+ "creating pic-param buffer failed.");
- va_status = vaRenderPicture(va_dpy, context_id, &priv->pic_parameter, 1);
- ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS ==va_status,
- ENCODER_PICTURE_ERR, "rendering pic-param buffer failed.");
+ va_status = vaRenderPicture(va_dpy, context_id, &priv->pic_param_id, 1);
+ ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS == va_status,
+ ENCODER_PICTURE_ERR,
+ "rendering pic-param buffer failed.");
/* set slice parameters, support multiple slices */
int i = 0;
memset(priv->slice_param_buffers, 0, h264_encoder->slice_num*sizeof(priv->slice_param_buffers[0]));
for (i = 0; i < h264_encoder->slice_num; ++i) {
- slice_h264 = &priv->slice_param_buffers[i];
- slice_h264->start_row_number = last_row_num; /* unit MB*/
- slice_h264->slice_height = priv->default_slice_height; /* unit MB */
+ slice_param = &priv->slice_param_buffers[i];
+ slice_param->start_row_number = last_row_num; /* unit MB*/
+ slice_param->slice_height = priv->default_slice_height; /* unit MB */
if (slice_mod_num) {
- ++slice_h264->slice_height;
+ ++slice_param->slice_height;
--slice_mod_num;
}
- last_row_num += slice_h264->slice_height;
- slice_h264->slice_flags.bits.is_intra = *is_key;
- slice_h264->slice_flags.bits.disable_deblocking_filter_idc = 0;
+ last_row_num += slice_param->slice_height;
+ slice_param->slice_flags.bits.is_intra = *is_key;
+ slice_param->slice_flags.bits.disable_deblocking_filter_idc = 0;
}
ENCODER_ASSERT(last_row_num == (ENCODER_HEIGHT(h264_encoder)+15)/16);
- if (VA_INVALID_ID != priv->slice_parameter) {
- vaDestroyBuffer(va_dpy, priv->slice_parameter);
- priv->slice_parameter = VA_INVALID_ID;
+ if (VA_INVALID_ID != priv->slice_param_id) {
+ vaDestroyBuffer(va_dpy, priv->slice_param_id);
+ priv->slice_param_id = VA_INVALID_ID;
}
va_status = vaCreateBuffer(va_dpy,
context_id,
sizeof(priv->slice_param_buffers[0]),
h264_encoder->slice_num,
priv->slice_param_buffers,
- &priv->slice_parameter);
+ &priv->slice_param_id);
ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS ==va_status,
- ENCODER_PICTURE_ERR, "creating slice-parameters buffer failed.");
+ ENCODER_PICTURE_ERR,
+ "creating slice-parameters buffer failed.");
- va_status = vaRenderPicture(va_dpy, context_id, &priv->slice_parameter, 1);
- ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS ==va_status,
- ENCODER_PICTURE_ERR, "rendering slice-parameters buffer failed.");
+ va_status = vaRenderPicture(va_dpy, context_id, &priv->slice_param_id, 1);
+ ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS == va_status,
+ ENCODER_PICTURE_ERR,
+ "rendering slice-parameters buffer failed.");
/*after finished, set ref_surface1_index, recon_surface_index */
GstVaapiSurface *swap = priv->ref_surface1;
#else /* extended libva, new parameter structures*/
static gboolean
-set_sequence_parameters(GstVaapiEncoderH264 *encoder,
- VAEncSequenceParameterBufferH264 *seq_param)
+set_sequence_parameters(
+ GstVaapiEncoderH264 *encoder,
+ VAEncSequenceParameterBufferH264 *seq_param
+)
{
GstVaapiEncoderH264Private *priv = encoder->priv;
guint width_in_mbs, height_in_mbs;
else
seq_param->bits_per_second = 0;
- seq_param->max_num_ref_frames = (encoder->b_frame_num < 2 ? 3 : encoder->b_frame_num+1); // ?, why 4
+ seq_param->max_num_ref_frames =
+ (encoder->b_frame_num < 2 ? 3 : encoder->b_frame_num+1); // ?, why 4
seq_param->picture_width_in_mbs = width_in_mbs;
seq_param->picture_height_in_mbs = height_in_mbs;
seq_param->seq_fields.bits.seq_scaling_matrix_present_flag = FALSE;
/* direct_8x8_inference_flag default false */
seq_param->seq_fields.bits.direct_8x8_inference_flag = FALSE;
- seq_param->seq_fields.bits.log2_max_frame_num_minus4 = 4; // log2(seq_h264.intra_period)-3 : 0
+ seq_param->seq_fields.bits.log2_max_frame_num_minus4 = 4; // log2(seq.intra_period)-3 : 0
/* picture order count */
seq_param->seq_fields.bits.pic_order_cnt_type = 0;
seq_param->seq_fields.bits.log2_max_pic_order_cnt_lsb_minus4 =
seq_param->seq_fields.bits.log2_max_frame_num_minus4 + 2;
seq_param->seq_fields.bits.delta_pic_order_always_zero_flag = TRUE;
- priv->max_frame_num = 1<<(seq_param->seq_fields.bits.log2_max_frame_num_minus4 + 4);
- priv->max_pic_order_cnt = 1 <<(seq_param->seq_fields.bits.log2_max_pic_order_cnt_lsb_minus4 + 4);
+ priv->max_frame_num =
+ 1<<(seq_param->seq_fields.bits.log2_max_frame_num_minus4 + 4);
+ priv->max_pic_order_cnt =
+ 1 <<(seq_param->seq_fields.bits.log2_max_pic_order_cnt_lsb_minus4 + 4);
seq_param->bit_depth_luma_minus8 = 0;
seq_param->bit_depth_chroma_minus8 = 0;
seq_param->num_ref_frames_in_pic_order_cnt_cycle = 0;
seq_param->offset_for_non_ref_pic = 0;
seq_param->offset_for_top_to_bottom_field = 0;
- memset(seq_param->offset_for_ref_frame, 0, sizeof(seq_param->offset_for_ref_frame));
+ memset(seq_param->offset_for_ref_frame,
+ 0,
+ sizeof(seq_param->offset_for_ref_frame));
if (height_in_mbs*16 - ENCODER_HEIGHT(encoder)) {
seq_param->frame_cropping_flag = 1;
}
#if 0
if (h264_encoder->init_qp == -1)
- seq_h264.rate_control_method = BR_CBR;
+ seq.rate_control_method = BR_CBR;
else if (h264_encoder->init_qp == -2)
- seq_h264.rate_control_method = BR_VBR;
+ seq.rate_control_method = BR_VBR;
else {
ENCODER_ASSERT(h264_encoder->init_qp >= 0 && h264_encoder->init_qp <= 51);
- seq_h264.rate_control_method = BR_CQP;
+ seq.rate_control_method = BR_CQP;
}
#endif
h264_fill_sequence_buffer(GstVaapiEncoderH264 *encoder)
{
GstVaapiEncoderH264Private *priv = encoder->priv;
- VAEncSequenceParameterBufferH264 seq_h264 = { 0 };
+ VAEncSequenceParameterBufferH264 seq_param = { 0 };
VADisplay va_dpy = ENCODER_VA_DISPLAY(encoder);
VAContextID context_id = ENCODER_VA_CONTEXT(encoder);
gboolean ret = TRUE;
VAStatus va_status = VA_STATUS_SUCCESS;
/* only once */
- if (VA_INVALID_ID != priv->seq_parameter)
+ if (VA_INVALID_ID != priv->seq_param_id)
return TRUE;
- set_sequence_parameters(encoder, &seq_h264);
+ set_sequence_parameters(encoder, &seq_param);
va_status = vaCreateBuffer(va_dpy, context_id,
VAEncSequenceParameterBufferType,
- sizeof(seq_h264), 1,
- &seq_h264, &priv->seq_parameter);
+ sizeof(seq_param), 1,
+ &seq_param, &priv->seq_param_id);
ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS == va_status,
- FALSE, "alloc seq-buffer failed.");
+ FALSE,
+ "alloc seq-buffer failed.");
/*pack sps header buffer/data */
if (NULL == priv->sps_data) {
h264_bitstream_init(&bitstream, 128*8);
h264_bitstream_write_uint(&bitstream, 0x00000001, 32); /* start code*/
h264_bitstream_write_nal_header(&bitstream, NAL_REF_IDC_HIGH, NAL_SPS);
- h264_bitstream_write_sps(&bitstream, &seq_h264, encoder->profile);
+ h264_bitstream_write_sps(&bitstream, &seq_param, encoder->profile);
ENCODER_ASSERT(BIT_STREAM_BIT_SIZE(&bitstream)%8 == 0);
length_in_bits = BIT_STREAM_BIT_SIZE(&bitstream);
packed_seq_buffer = BIT_STREAM_BUFFER(&bitstream);
/* set codec data sps */
priv->sps_data = gst_buffer_new_and_alloc((length_in_bits+7)/8);
GST_BUFFER_SIZE(priv->sps_data) = (length_in_bits+7)/8-4; /* start code size == 4*/
- memcpy(GST_BUFFER_DATA(priv->sps_data), packed_seq_buffer+4, GST_BUFFER_SIZE(priv->sps_data));
+ memcpy(GST_BUFFER_DATA(priv->sps_data),
+ packed_seq_buffer+4,
+ GST_BUFFER_SIZE(priv->sps_data));
packed_header_param_buffer.type = VAEncPackedHeaderSequence;
packed_header_param_buffer.bit_length = length_in_bits;
VAEncPackedHeaderParameterBufferType,
sizeof(packed_header_param_buffer), 1,
&packed_header_param_buffer,
- &priv->packed_sps_par_buf);
+ &priv->packed_seq_param_id);
ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS == va_status,
FALSE,
"EncPackedSeqHeaderParameterBuffer failed");
VAEncPackedHeaderDataBufferType,
(length_in_bits + 7) / 8, 1,
packed_seq_buffer,
- &priv->packed_sps_data_buf);
+ &priv->packed_seq_data_id);
h264_bitstream_destroy(&bitstream, TRUE);
ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS == va_status,
FALSE,
pic_param->last_picture = 0; /* means last encoding picture */
pic_param->frame_num = (priv->cur_slice_type == SLICE_TYPE_B ?
(priv->cur_decode_num + 1) : priv->cur_decode_num);
- //pic_h264.coding_type = 0;
+ //pic_param.coding_type = 0;
pic_param->pic_init_qp = (encoder->init_qp >= 0 ? encoder->init_qp : 26);
pic_param->num_ref_idx_l0_active_minus1 = 0; /* only 1 reference */
pic_param->num_ref_idx_l1_active_minus1 = 0; /* B frames only have 1 backward and 1 forward reference*/
return TRUE;
}
+static inline const char *
+get_slice_type(H264_SLICE_TYPE type)
+{
+ switch (type) {
+ case SLICE_TYPE_I:
+ return "I";
+ case SLICE_TYPE_P:
+ return "P";
+ case SLICE_TYPE_B:
+ return "B";
+ default:
+ return "Unknown";
+ }
+}
+
static gboolean
h264_fill_picture_buffer(
GstVaapiEncoderH264 *encoder,
)
{
GstVaapiEncoderH264Private *priv = encoder->priv;
- VAEncPictureParameterBufferH264 pic_h264;
+ VAEncPictureParameterBufferH264 pic_param;
VADisplay va_dpy = ENCODER_VA_DISPLAY(encoder);
VAContextID context_id = ENCODER_VA_CONTEXT(encoder);
gboolean ret = TRUE;
VAStatus va_status = VA_STATUS_SUCCESS;
VAAPI_UNUSED_ARG(va_status);
- memset(&pic_h264, 0, sizeof(pic_h264));
- set_picture_parameters(encoder, &pic_h264);
- pic_h264.CurrPic.picture_id = GST_VAAPI_OBJECT_ID(priv->recon_surface);
- pic_h264.CurrPic.TopFieldOrderCnt = priv->cur_display_num * 2; // ??? /**/
- pic_h264.ReferenceFrames[0].picture_id = GST_VAAPI_OBJECT_ID(priv->ref_surface1);
- pic_h264.ReferenceFrames[1].picture_id = GST_VAAPI_OBJECT_ID(priv->ref_surface2);
- pic_h264.ReferenceFrames[2].picture_id = VA_INVALID_ID;
- pic_h264.coded_buf = coded_buf;
-
- char *frame_type = "I";
- if (priv->cur_slice_type == SLICE_TYPE_P)
- frame_type = "P";
- if (priv->cur_slice_type == SLICE_TYPE_B)
- frame_type = "B";
+ memset(&pic_param, 0, sizeof(pic_param));
+ set_picture_parameters(encoder, &pic_param);
+ pic_param.CurrPic.picture_id = GST_VAAPI_OBJECT_ID(priv->recon_surface);
+ pic_param.CurrPic.TopFieldOrderCnt = priv->cur_display_num * 2; // ??? /**/
+ pic_param.ReferenceFrames[0].picture_id = GST_VAAPI_OBJECT_ID(priv->ref_surface1);
+ pic_param.ReferenceFrames[1].picture_id = GST_VAAPI_OBJECT_ID(priv->ref_surface2);
+ pic_param.ReferenceFrames[2].picture_id = VA_INVALID_ID;
+ pic_param.coded_buf = coded_buf;
+
ENCODER_LOG_INFO("type:%s, frame_num:%d, display_num:%d",
- frame_type, pic_h264.frame_num, pic_h264.CurrPic.TopFieldOrderCnt);
+ get_slice_type(priv->cur_slice_type),
+ pic_param.frame_num,
+ pic_param.CurrPic.TopFieldOrderCnt);
- if (VA_INVALID_ID != priv->pic_parameter) { /* share the same pic_parameter*/
- vaDestroyBuffer(va_dpy, priv->pic_parameter);
- priv->pic_parameter = VA_INVALID_ID;
+ if (VA_INVALID_ID != priv->pic_param_id) { /* share the same pic_param_id*/
+ vaDestroyBuffer(va_dpy, priv->pic_param_id);
+ priv->pic_param_id = VA_INVALID_ID;
}
- va_status = vaCreateBuffer(va_dpy, context_id, VAEncPictureParameterBufferType,
- sizeof(pic_h264), 1, &pic_h264, &priv->pic_parameter);
+ va_status = vaCreateBuffer(va_dpy,
+ context_id,
+ VAEncPictureParameterBufferType,
+ sizeof(pic_param), 1,
+ &pic_param,
+ &priv->pic_param_id);
- ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS ==va_status,
- FALSE, "creating pic-param buffer failed.");
+ ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS == va_status,
+ FALSE,
+ "creating pic-param buffer failed.");
- if (VA_INVALID_ID == priv->packed_pps_data_buf) {
+ if (VA_INVALID_ID == priv->packed_pic_data_id) {
VAEncPackedHeaderParameterBuffer packed_header_param_buffer = { 0 };
guint32 length_in_bits;
guint8 *packed_pic_buffer = NULL;
h264_bitstream_init(&bitstream, 128*8);
h264_bitstream_write_uint(&bitstream, 0x00000001, 32); /* start code*/
h264_bitstream_write_nal_header(&bitstream, NAL_REF_IDC_HIGH, NAL_PPS);
- h264_bitstream_write_pps(&bitstream, &pic_h264);
+ h264_bitstream_write_pps(&bitstream, &pic_param);
ENCODER_ASSERT(BIT_STREAM_BIT_SIZE(&bitstream)%8 == 0);
length_in_bits = BIT_STREAM_BIT_SIZE(&bitstream);
packed_pic_buffer = BIT_STREAM_BUFFER(&bitstream);
VAEncPackedHeaderParameterBufferType,
sizeof(packed_header_param_buffer), 1,
&packed_header_param_buffer,
- &priv->packed_pps_par_buf);
+ &priv->packed_pic_param_id);
ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS == va_status,
FALSE,
"EncPackedPicHeaderParameterBuffer failed");
VAEncPackedHeaderDataBufferType,
(length_in_bits + 7) / 8, 1,
packed_pic_buffer,
- &priv->packed_pps_data_buf);
+ &priv->packed_pic_data_id);
h264_bitstream_destroy(&bitstream, TRUE);
ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS == va_status,
FALSE,
)
{
GstVaapiEncoderH264Private *priv = encoder->priv;
- VAEncSliceParameterBufferH264 *slice_h264 = NULL;
+ VAEncSliceParameterBufferH264 *slice_param = NULL;
VADisplay va_dpy = ENCODER_VA_DISPLAY(encoder);
VAContextID context_id = ENCODER_VA_CONTEXT(encoder);
guint width_in_mbs;
encoder->slice_num*sizeof(priv->slice_param_buffers[0]));
for (i = 0; i < encoder->slice_num; ++i) {
int i_pic = 0;
- slice_h264 = &priv->slice_param_buffers[i];
+ slice_param = &priv->slice_param_buffers[i];
- slice_h264->macroblock_address = last_row_num*width_in_mbs;
- slice_h264->num_macroblocks = width_in_mbs*priv->default_slice_height;
+ slice_param->macroblock_address = last_row_num*width_in_mbs;
+ slice_param->num_macroblocks = width_in_mbs*priv->default_slice_height;
last_row_num += priv->default_slice_height;
if (slice_mod_num) {
- slice_h264->num_macroblocks += width_in_mbs;
+ slice_param->num_macroblocks += width_in_mbs;
++last_row_num;
--slice_mod_num;
}
- slice_h264->macroblock_info = VA_INVALID_ID;
- slice_h264->slice_type = priv->cur_slice_type;
- slice_h264->pic_parameter_set_id = 0;
- slice_h264->idr_pic_id = priv->idr_num;
- slice_h264->pic_order_cnt_lsb = (priv->cur_display_num*2) % priv->max_pic_order_cnt;
+ slice_param->macroblock_info = VA_INVALID_ID;
+ slice_param->slice_type = priv->cur_slice_type;
+ slice_param->pic_parameter_set_id = 0;
+ slice_param->idr_pic_id = priv->idr_num;
+ slice_param->pic_order_cnt_lsb =
+ (priv->cur_display_num*2) % priv->max_pic_order_cnt;
/* not used if pic_order_cnt_type = 0 */
- slice_h264->delta_pic_order_cnt_bottom = 0;
- memset(slice_h264->delta_pic_order_cnt, 0, sizeof(slice_h264->delta_pic_order_cnt));
+ slice_param->delta_pic_order_cnt_bottom = 0;
+ memset(slice_param->delta_pic_order_cnt,
+ 0,
+ sizeof(slice_param->delta_pic_order_cnt));
/*only works for B frames*/
- slice_h264->direct_spatial_mv_pred_flag = FALSE;
+ slice_param->direct_spatial_mv_pred_flag = FALSE;
/* default equal to picture parameters */
- slice_h264->num_ref_idx_active_override_flag = FALSE;
- slice_h264->num_ref_idx_l0_active_minus1 = 0;
- slice_h264->num_ref_idx_l1_active_minus1 = 0;
+ slice_param->num_ref_idx_active_override_flag = FALSE;
+ slice_param->num_ref_idx_l0_active_minus1 = 0;
+ slice_param->num_ref_idx_l1_active_minus1 = 0;
- slice_h264->RefPicList0[0].picture_id = GST_VAAPI_OBJECT_ID(priv->ref_surface1);
+ slice_param->RefPicList0[0].picture_id =
+ GST_VAAPI_OBJECT_ID(priv->ref_surface1);
for (i_pic = 1;
- i_pic < sizeof(slice_h264->RefPicList0)/sizeof(slice_h264->RefPicList0[0]);
+ i_pic < sizeof(slice_param->RefPicList0)/sizeof(slice_param->RefPicList0[0]);
i_pic++) {
- slice_h264->RefPicList0[i_pic].picture_id = VA_INVALID_ID;
+ slice_param->RefPicList0[i_pic].picture_id = VA_INVALID_ID;
}
if (SLICE_TYPE_B == priv->cur_slice_type) {
- slice_h264->RefPicList1[0].picture_id = GST_VAAPI_OBJECT_ID(priv->ref_surface2);
+ slice_param->RefPicList1[0].picture_id =
+ GST_VAAPI_OBJECT_ID(priv->ref_surface2);
i_pic = 1;
} else
i_pic = 0;
- for (; i_pic < sizeof(slice_h264->RefPicList1)/sizeof(slice_h264->RefPicList1[0]); i_pic++)
- slice_h264->RefPicList1[i_pic].picture_id = VA_INVALID_ID;
-
- /* not used if pic_h264.pic_fields.bits.weighted_pred_flag == FALSE */
- slice_h264->luma_log2_weight_denom = 0;
- slice_h264->chroma_log2_weight_denom = 0;
- slice_h264->luma_weight_l0_flag = FALSE;
- memset(slice_h264->luma_weight_l0, 0, sizeof(slice_h264->luma_weight_l0));
- memset(slice_h264->luma_offset_l0, 0, sizeof(slice_h264->luma_offset_l0));
- slice_h264->chroma_weight_l0_flag = FALSE;
- memset(slice_h264->chroma_weight_l0, 0, sizeof(slice_h264->chroma_weight_l0));
- memset(slice_h264->chroma_offset_l0, 0, sizeof(slice_h264->chroma_offset_l0));
- slice_h264->luma_weight_l1_flag = FALSE;
- memset(slice_h264->luma_weight_l1, 0, sizeof(slice_h264->luma_weight_l1));
- memset(slice_h264->luma_offset_l1, 0, sizeof(slice_h264->luma_offset_l1));
- slice_h264->chroma_weight_l1_flag = FALSE;
- memset(slice_h264->chroma_weight_l1, 0, sizeof(slice_h264->chroma_weight_l1));
- memset(slice_h264->chroma_offset_l1, 0, sizeof(slice_h264->chroma_offset_l1));
-
- slice_h264->cabac_init_idc = 0;
- slice_h264->slice_qp_delta = 0;
- slice_h264->disable_deblocking_filter_idc = 0;
- slice_h264->slice_alpha_c0_offset_div2 = 2;
- slice_h264->slice_beta_offset_div2 = 2;
+ for (;
+ i_pic < sizeof(slice_param->RefPicList1)/sizeof(slice_param->RefPicList1[0]);
+ i_pic++)
+ slice_param->RefPicList1[i_pic].picture_id = VA_INVALID_ID;
+
+ /* not used if pic_param.pic_fields.bits.weighted_pred_flag == FALSE */
+ slice_param->luma_log2_weight_denom = 0;
+ slice_param->chroma_log2_weight_denom = 0;
+ slice_param->luma_weight_l0_flag = FALSE;
+ memset(slice_param->luma_weight_l0, 0, sizeof(slice_param->luma_weight_l0));
+ memset(slice_param->luma_offset_l0, 0, sizeof(slice_param->luma_offset_l0));
+ slice_param->chroma_weight_l0_flag = FALSE;
+ memset(slice_param->chroma_weight_l0, 0, sizeof(slice_param->chroma_weight_l0));
+ memset(slice_param->chroma_offset_l0, 0, sizeof(slice_param->chroma_offset_l0));
+ slice_param->luma_weight_l1_flag = FALSE;
+ memset(slice_param->luma_weight_l1, 0, sizeof(slice_param->luma_weight_l1));
+ memset(slice_param->luma_offset_l1, 0, sizeof(slice_param->luma_offset_l1));
+ slice_param->chroma_weight_l1_flag = FALSE;
+ memset(slice_param->chroma_weight_l1, 0, sizeof(slice_param->chroma_weight_l1));
+ memset(slice_param->chroma_offset_l1, 0, sizeof(slice_param->chroma_offset_l1));
+
+ slice_param->cabac_init_idc = 0;
+ slice_param->slice_qp_delta = 0;
+ slice_param->disable_deblocking_filter_idc = 0;
+ slice_param->slice_alpha_c0_offset_div2 = 2;
+ slice_param->slice_beta_offset_div2 = 2;
}
ENCODER_ASSERT(last_row_num == (ENCODER_HEIGHT(encoder)+15)/16);
- if (VA_INVALID_ID != priv->slice_parameter) {
- vaDestroyBuffer(va_dpy, priv->slice_parameter);
- priv->slice_parameter = VA_INVALID_ID;
+ if (VA_INVALID_ID != priv->slice_param_id) {
+ vaDestroyBuffer(va_dpy, priv->slice_param_id);
+ priv->slice_param_id = VA_INVALID_ID;
}
va_status = vaCreateBuffer(va_dpy,
context_id,
sizeof(priv->slice_param_buffers[0]),
encoder->slice_num,
priv->slice_param_buffers,
- &priv->slice_parameter);
- ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS ==va_status,
- FALSE, "creating slice-parameters buffer failed.");
+ &priv->slice_param_id);
+ ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS == va_status,
+ FALSE,
+ "creating slice-parameters buffer failed.");
end:
return ret;
/* fill sequence parameters, need set every time */
is_params_ok = h264_fill_sequence_buffer(encoder);
- ENCODER_CHECK_STATUS(is_params_ok, ENCODER_PARAMETER_ERR,
+ ENCODER_CHECK_STATUS(is_params_ok,
+ ENCODER_PARAMETER_ERR,
"h264_recreate_seq_param failed");
/* set pic_parameters*/
is_params_ok = h264_fill_picture_buffer(encoder, coded_buf);
- ENCODER_CHECK_STATUS(is_params_ok, ENCODER_PARAMETER_ERR,
+ ENCODER_CHECK_STATUS(is_params_ok,
+ ENCODER_PARAMETER_ERR,
"h264_recreate_pic_param failed");
/* set slice parameters, support multiple slices */
is_params_ok = h264_fill_slice_buffers(encoder);
- ENCODER_CHECK_STATUS(is_params_ok, ENCODER_PARAMETER_ERR,
+ ENCODER_CHECK_STATUS(is_params_ok,
+ ENCODER_PARAMETER_ERR,
"h264_recreate_slice_param failed");
/* lock display */
ENCODER_ACQUIRE_DISPLAY_LOCK(display);
/*render all buffers*/
- if (VA_INVALID_ID != priv->seq_parameter) {
- va_buffers[va_buffers_count++] = priv->seq_parameter;
+ if (VA_INVALID_ID != priv->seq_param_id) {
+ va_buffers[va_buffers_count++] = priv->seq_param_id;
}
- if (VA_INVALID_ID != priv->pic_parameter) {
- va_buffers[va_buffers_count++] = priv->pic_parameter;
+ if (VA_INVALID_ID != priv->pic_param_id) {
+ va_buffers[va_buffers_count++] = priv->pic_param_id;
}
- if (VA_INVALID_ID != priv->slice_parameter) {
- va_buffers[va_buffers_count++] = priv->slice_parameter;
+ if (VA_INVALID_ID != priv->slice_param_id) {
+ va_buffers[va_buffers_count++] = priv->slice_param_id;
}
if (SLICE_TYPE_I == priv->cur_slice_type) {
- if (VA_INVALID_ID != priv->packed_sps_par_buf) {
- va_buffers[va_buffers_count++] = priv->packed_sps_par_buf;
+ if (VA_INVALID_ID != priv->packed_seq_param_id) {
+ va_buffers[va_buffers_count++] = priv->packed_seq_param_id;
}
- if (VA_INVALID_ID != priv->packed_sps_data_buf) {
- va_buffers[va_buffers_count++] = priv->packed_sps_data_buf;
+ if (VA_INVALID_ID != priv->packed_seq_data_id) {
+ va_buffers[va_buffers_count++] = priv->packed_seq_data_id;
}
- if (VA_INVALID_ID != priv->packed_pps_par_buf) {
- va_buffers[va_buffers_count++] = priv->packed_pps_par_buf;
+ if (VA_INVALID_ID != priv->packed_pic_param_id) {
+ va_buffers[va_buffers_count++] = priv->packed_pic_param_id;
}
- if (VA_INVALID_ID != priv->packed_pps_data_buf) {
- va_buffers[va_buffers_count++] = priv->packed_pps_data_buf;
+ if (VA_INVALID_ID != priv->packed_pic_data_id) {
+ va_buffers[va_buffers_count++] = priv->packed_pic_data_id;
}
}
- va_status = vaRenderPicture(va_dpy, context_id, va_buffers, va_buffers_count);
- ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS == va_status, ENCODER_PICTURE_ERR,
+ va_status = vaRenderPicture(va_dpy,
+ context_id,
+ va_buffers,
+ va_buffers_count);
+ ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS == va_status,
+ ENCODER_PICTURE_ERR,
"vaRenderH264Picture failed.");
/*after finished, swap recon and surface2*/
#endif
+static const guint8 *
+h264_next_nal(const guint8 *buffer, guint32 len, guint32 *nal_size)
+{
+ const guint8 *cur = buffer;
+ const guint8 *end = buffer + len;
+ const guint8 *nal_start = NULL;
+ guint32 flag = 0xFFFFFFFF;
+ guint32 nal_start_len = 0;
+
+ ENCODER_ASSERT(len >= 0 && buffer && nal_size);
+ if (len < 3) {
+ *nal_size = len;
+ nal_start = (len ? buffer : NULL);
+ return nal_start;
+ }
+
+ /*locate head postion*/
+ if (!buffer[0] && !buffer[1]) {
+ if (buffer[2] == 1) { // 0x000001
+ nal_start_len = 3;
+ } else if (!buffer[2] && len >=4 && buffer[3] == 1) { //0x00000001
+ nal_start_len = 4;
+ }
+ }
+ nal_start = buffer + nal_start_len;
+ cur = nal_start;
+
+ /*find next nal start position*/
+ while (cur < end) {
+ flag = ((flag<<8) | ((*cur++)&0xFF));
+ if (flag == 0x00000001) {
+ *nal_size = cur - 4 - nal_start;
+ break;
+ } else if ((flag&0x00FFFFFF) == 0x00000001) {
+ *nal_size = cur - 3 - nal_start;
+ break;
+ }
+ }
+ if (cur >= end) {
+ *nal_size = end - nal_start;
+ if (nal_start >= end) {
+ nal_start = NULL;
+ }
+ }
+ return nal_start;
+}
+
static GstBuffer *
-gst_vaapi_encoder_h264_copy_coded_buffer(GstVaapiBaseEncoder *base,
- guint8 *frame,
- guint32 frame_size,
- VABufferID *coded_buf)
+gst_vaapi_encoder_h264_copy_coded_buffer(
+ GstVaapiBaseEncoder *base,
+ guint8 *frame,
+ guint32 frame_size,
+ VABufferID *coded_buf
+)
{
GstVaapiEncoderH264 *encoder = GST_VAAPI_ENCODER_H264_CAST(base);
GstVaapiEncoderH264Private *priv = encoder->priv;
frame_end = frame + frame_size;
nal_start = frame;
nal_size = 0;
- while((nal_start = h264_next_nal(nal_start, frame_end-nal_start, &nal_size)) != NULL) {
+ while(NULL !=
+ (nal_start = h264_next_nal(nal_start, frame_end-nal_start, &nal_size))
+ ) {
ENCODER_ASSERT(nal_size);
if (!nal_size) {
nal_start += nal_size;
}
static EncoderStatus
-h264_encoder_read_sps_pps(GstVaapiEncoderH264Private *priv, const guint8 *buf, guint32 size)
+read_sps_pps(GstVaapiEncoderH264Private *priv, const guint8 *buf, guint32 size)
{
const guint8 *end = buf + size;
const guint8 *nal_start = buf;
guint8 nal_type;
GstBuffer *sps = NULL, *pps = NULL;
- while((!sps || !pps) && (nal_start = h264_next_nal(nal_start, end-nal_start, &nal_size)) != NULL) {
+ while((!sps || !pps) &&
+ (nal_start = h264_next_nal(nal_start, end-nal_start, &nal_size)) != NULL
+ ) {
if (!nal_size) {
nal_start += nal_size;
continue;
break;
}
nal_start += nal_size;
-
}
+
if (!sps || !pps) {
return ENCODER_DATA_NOT_READY;
}
+
return ENCODER_NO_ERROR;
}
static void
-gst_h264_notify_frame(GstVaapiBaseEncoder *base, guint8 *buf, guint32 size)
+gst_vaapi_encoder_h264_notify_frame(
+ GstVaapiBaseEncoder *base,
+ guint8 *buf,
+ guint32 size
+)
{
GstVaapiEncoderH264 *encoder = GST_VAAPI_ENCODER_H264_CAST(base);
GstVaapiEncoderH264Private *priv = encoder->priv;
if (!priv->sps_data || !priv->pps_data) {
- h264_encoder_read_sps_pps(priv, buf, size);
+ read_sps_pps(priv, buf, size);
}
if (priv->sps_data && priv->pps_data) {
gst_vaapi_base_encoder_set_frame_notify(base, FALSE);
}
}
-
static gboolean
-h264_read_sps_attributes(const guint8 *sps_data, guint32 sps_size,
- guint32 *profile_idc, guint32 *profile_comp, guint32 *level_idc)
+read_sps_attributes(
+ const guint8 *sps_data,
+ guint32 sps_size,
+ guint32 *profile_idc,
+ guint32 *profile_comp,
+ guint32 *level_idc
+)
{
ENCODER_ASSERT(profile_idc && profile_comp && level_idc);
ENCODER_ASSERT(sps_size >= 4);
return TRUE;
}
-
static EncoderStatus
gst_vaapi_encoder_h264_flush(
GstVaapiEncoder* base,
return ENCODER_DATA_NOT_READY;
}
- if (FALSE == h264_read_sps_attributes(GST_BUFFER_DATA(priv->sps_data),
+ if (FALSE == read_sps_attributes(GST_BUFFER_DATA(priv->sps_data),
GST_BUFFER_SIZE(priv->sps_data),
&profile, &profile_comp, &level_idc))
{
H264Bitstream bitstream;
h264_bitstream_init(&bitstream,
- (GST_BUFFER_SIZE(priv->sps_data)+GST_BUFFER_SIZE(priv->pps_data) + 32)*8);
+ (GST_BUFFER_SIZE(priv->sps_data) +
+ GST_BUFFER_SIZE(priv->pps_data) + 32)*8);
/*codec_data*/
h264_bitstream_write_uint(&bitstream, configuration_version, 8);
h264_bitstream_write_uint(&bitstream, 1, 5); /* sps count = 1*/
ENCODER_ASSERT( BIT_STREAM_BIT_SIZE(&bitstream)%8 == 0);
h264_bitstream_write_uint(&bitstream, GST_BUFFER_SIZE(priv->sps_data), 16);
- h264_bitstream_write_byte_array(&bitstream, GST_BUFFER_DATA(priv->sps_data),
- GST_BUFFER_SIZE(priv->sps_data));
+ h264_bitstream_write_byte_array(&bitstream,
+ GST_BUFFER_DATA(priv->sps_data),
+ GST_BUFFER_SIZE(priv->sps_data));
/*write pps*/
h264_bitstream_write_uint(&bitstream, 1, 8); /*pps count = 1*/
h264_bitstream_write_uint(&bitstream, GST_BUFFER_SIZE(priv->pps_data), 16);
- h264_bitstream_write_byte_array(&bitstream, GST_BUFFER_DATA(priv->pps_data),
- GST_BUFFER_SIZE(priv->pps_data));
+ h264_bitstream_write_byte_array(&bitstream,
+ GST_BUFFER_DATA(priv->pps_data),
+ GST_BUFFER_SIZE(priv->pps_data));
avc_codec = gst_buffer_new();
GST_BUFFER_MALLOCDATA(avc_codec) =
priv->ref_surface2 = NULL;
priv->recon_surface = NULL;
- priv->seq_parameter = VA_INVALID_ID;
- priv->pic_parameter = VA_INVALID_ID;
- priv->slice_parameter = VA_INVALID_ID;
- priv->packed_sps_par_buf = VA_INVALID_ID;
- priv->packed_sps_data_buf = VA_INVALID_ID;
- priv->packed_pps_par_buf = VA_INVALID_ID;
- priv->packed_pps_data_buf = VA_INVALID_ID;
+ priv->seq_param_id = VA_INVALID_ID;
+ priv->pic_param_id = VA_INVALID_ID;
+ priv->slice_param_id = VA_INVALID_ID;
+ priv->packed_seq_param_id = VA_INVALID_ID;
+ priv->packed_seq_data_id = VA_INVALID_ID;
+ priv->packed_pic_param_id = VA_INVALID_ID;
+ priv->packed_pic_data_id = VA_INVALID_ID;
priv->slice_param_buffers = NULL;
priv->default_slice_height = 0;
priv->slice_mod_mb_num = 0;
g_type_class_add_private(klass, sizeof(GstVaapiEncoderH264Private));
- GST_DEBUG_CATEGORY_INIT (gst_vaapi_h264_encoder_debug, "gst_va_h264_encoder", 0,
- "gst_va_h264_encoder element");
+ GST_DEBUG_CATEGORY_INIT (gst_vaapi_h264_encoder_debug,
+ "gst_va_h264_encoder",
+ 0,
+ "gst_va_h264_encoder element");
object_class->finalize = gst_vaapi_encoder_h264_finalize;
- base_class->validate_attributes = gst_h264_validate_parameters;
+ base_class->validate_attributes = gst_vaapi_encoder_h264_validate_attributes;
base_class->pre_alloc_resource = gst_vaapi_encoder_h264_alloc_slices;
base_class->release_resource = gst_vaapi_encoder_h264_release_resource;
- base_class->prepare_next_input_buffer = gst_vaapi_encoder_h264_prepare_next_buffer;
+ base_class->prepare_next_input_buffer =
+ gst_vaapi_encoder_h264_prepare_next_buffer;
base_class->render_frame = gst_vaapi_encoder_h264_rendering;
- base_class->notify_frame = gst_h264_notify_frame;
+ base_class->notify_frame = gst_vaapi_encoder_h264_notify_frame;
base_class->copy_coded_frame = gst_vaapi_encoder_h264_copy_coded_buffer;
base_class->encode_frame_failed = gst_vaapi_encoder_h264_frame_failed;
}
static gboolean
-h264_bitstream_write_uint(H264Bitstream *bitstream, guint32 value, guint32 bit_size)
+h264_bitstream_write_uint(
+ H264Bitstream *bitstream,
+ guint32 value,
+ guint32 bit_size
+)
{
gboolean ret = TRUE;
guint32 byte_pos, bit_offset;
}
VAAPI_UNUSED_ARG(ret);
- ENCODER_CHECK_STATUS(TRUE == h264_bitstream_auto_grow(bitstream, bit_size),
+ ENCODER_CHECK_STATUS(h264_bitstream_auto_grow(bitstream, bit_size),
FALSE,
"h264_bitstream_auto_grow failed.");
byte_pos = (bitstream->bit_size>>3);
bit_offset = (bitstream->bit_size&0x07);
cur_byte = bitstream->buffer + byte_pos;
- ENCODER_ASSERT(bit_offset < 8 && bitstream->bit_size <= bitstream->max_bit_capability);
+ ENCODER_ASSERT(bit_offset < 8 &&
+ bitstream->bit_size <= bitstream->max_bit_capability);
while (bit_size) {
fill_bits = ((8-bit_offset) < bit_size ? (8-bit_offset) : bit_size);
bit_size -= fill_bits;
bitstream->bit_size += fill_bits;
- *cur_byte |= ((value>>bit_size) & h264_bit_mask[fill_bits])<<(8-bit_offset-fill_bits);
+ *cur_byte |=
+ ((value>>bit_size) & h264_bit_mask[fill_bits])<<(8-bit_offset-fill_bits);
++cur_byte;
bit_offset = 0;
}
- ENCODER_ASSERT(cur_byte <= bitstream->buffer + bitstream->max_bit_capability/8);
+ ENCODER_ASSERT(cur_byte <=
+ (bitstream->buffer + bitstream->max_bit_capability/8));
end:
return ret;
static gboolean
-h264_bitstream_write_byte_array(H264Bitstream *bitstream, const guint8 *buf, guint32 byte_size)
+h264_bitstream_write_byte_array(
+ H264Bitstream *bitstream,
+ const guint8 *buf,
+ guint32 byte_size
+)
{
gboolean ret = TRUE;
if (!byte_size) {
}
VAAPI_UNUSED_ARG(ret);
- ENCODER_CHECK_STATUS(TRUE == h264_bitstream_auto_grow(bitstream, byte_size<<3),
+ ENCODER_CHECK_STATUS(h264_bitstream_auto_grow(bitstream, byte_size<<3),
FALSE,
"h264_bitstream_auto_grow failed.");
if (0 == (bitstream->bit_size&0x07)) {
}
static gboolean
-h264_bitstream_write_nal_header(H264Bitstream *bitstream,
- guint nal_ref_idc, guint nal_unit_type)
+h264_bitstream_write_nal_header(
+ H264Bitstream *bitstream,
+ guint nal_ref_idc,
+ guint nal_unit_type
+)
{
h264_bitstream_write_uint(bitstream, 0, 1);
h264_bitstream_write_uint(bitstream, nal_ref_idc, 2);
}
static gboolean
-h264_bitstream_write_sps(H264Bitstream *bitstream,
- VAEncSequenceParameterBufferH264 *seq, H264_Profile profile)
+h264_bitstream_write_sps(
+ H264Bitstream *bitstream,
+ VAEncSequenceParameterBufferH264 *seq,
+ H264_Profile profile
+)
{
- guint32 constraint_set0_flag, constraint_set1_flag, constraint_set2_flag, constraint_set3_flag;
+ guint32 constraint_set0_flag, constraint_set1_flag;
+ guint32 constraint_set2_flag, constraint_set3_flag;
guint32 gaps_in_frame_num_value_allowed_flag = 0; // ??
guint32 b_qpprime_y_zero_transform_bypass = 0;
guint32 residual_color_transform_flag = 0;
- guint32 pic_height_in_map_units = (seq->seq_fields.bits.frame_mbs_only_flag ?
- seq->picture_height_in_mbs :
- seq->picture_height_in_mbs/2);
+ guint32 pic_height_in_map_units =
+ (seq->seq_fields.bits.frame_mbs_only_flag ?
+ seq->picture_height_in_mbs :
+ seq->picture_height_in_mbs/2);
guint32 mb_adaptive_frame_field = !seq->seq_fields.bits.frame_mbs_only_flag;
guint32 i = 0;
constraint_set2_flag = 0;
constraint_set3_flag = 0;
- h264_bitstream_write_uint(bitstream, profile, 8); /* profile_idc */
- h264_bitstream_write_uint(bitstream, constraint_set0_flag, 1); /* constraint_set0_flag */
- h264_bitstream_write_uint(bitstream, constraint_set1_flag, 1); /* constraint_set1_flag */
- h264_bitstream_write_uint(bitstream, constraint_set2_flag, 1); /* constraint_set2_flag */
- h264_bitstream_write_uint(bitstream, constraint_set3_flag, 1); /* constraint_set3_flag */
- h264_bitstream_write_uint(bitstream, 0, 4); /* reserved_zero_4bits */
- h264_bitstream_write_uint(bitstream, seq->level_idc, 8); /* level_idc */
- h264_bitstream_write_ue(bitstream, seq->seq_parameter_set_id); /* seq_parameter_set_id */
+ /* profile_idc */
+ h264_bitstream_write_uint(bitstream, profile, 8);
+ /* constraint_set0_flag */
+ h264_bitstream_write_uint(bitstream, constraint_set0_flag, 1);
+ /* constraint_set1_flag */
+ h264_bitstream_write_uint(bitstream, constraint_set1_flag, 1);
+ /* constraint_set2_flag */
+ h264_bitstream_write_uint(bitstream, constraint_set2_flag, 1);
+ /* constraint_set3_flag */
+ h264_bitstream_write_uint(bitstream, constraint_set3_flag, 1);
+ /* reserved_zero_4bits */
+ h264_bitstream_write_uint(bitstream, 0, 4);
+ /* level_idc */
+ h264_bitstream_write_uint(bitstream, seq->level_idc, 8);
+ /* seq_parameter_set_id */
+ h264_bitstream_write_ue(bitstream, seq->seq_parameter_set_id);
if (profile >= H264_PROFILE_HIGH) {
/* for high profile */
ENCODER_ASSERT(0);
- h264_bitstream_write_ue(bitstream, seq->seq_fields.bits.chroma_format_idc); /* chroma_format_idc = 1, 4:2:0*/
+ /* chroma_format_idc = 1, 4:2:0*/
+ h264_bitstream_write_ue(bitstream, seq->seq_fields.bits.chroma_format_idc);
if (3 == seq->seq_fields.bits.chroma_format_idc) {
h264_bitstream_write_uint(bitstream, residual_color_transform_flag, 1);
}
- h264_bitstream_write_ue(bitstream, seq->bit_depth_luma_minus8); /* bit_depth_luma_minus8 */
- h264_bitstream_write_ue(bitstream, seq->bit_depth_chroma_minus8); /* bit_depth_chroma_minus8 */
- h264_bitstream_write_uint(bitstream, b_qpprime_y_zero_transform_bypass, 1); /* b_qpprime_y_zero_transform_bypass */
+ /* bit_depth_luma_minus8 */
+ h264_bitstream_write_ue(bitstream, seq->bit_depth_luma_minus8);
+ /* bit_depth_chroma_minus8 */
+ h264_bitstream_write_ue(bitstream, seq->bit_depth_chroma_minus8);
+ /* b_qpprime_y_zero_transform_bypass */
+ h264_bitstream_write_uint(bitstream, b_qpprime_y_zero_transform_bypass, 1);
ENCODER_ASSERT(seq->seq_fields.bits.seq_scaling_matrix_present_flag == 0);
- h264_bitstream_write_uint(bitstream, seq->seq_fields.bits.seq_scaling_matrix_present_flag, 1); /*seq_scaling_matrix_present_flag */
+ /*seq_scaling_matrix_present_flag */
+ h264_bitstream_write_uint(bitstream,
+ seq->seq_fields.bits.seq_scaling_matrix_present_flag,
+ 1);
#if 0
if (seq->seq_fields.bits.seq_scaling_matrix_present_flag) {
#endif
}
- h264_bitstream_write_ue(bitstream, seq->seq_fields.bits.log2_max_frame_num_minus4); /* log2_max_frame_num_minus4 */
- h264_bitstream_write_ue(bitstream, seq->seq_fields.bits.pic_order_cnt_type); /* pic_order_cnt_type */
+ /* log2_max_frame_num_minus4 */
+ h264_bitstream_write_ue(bitstream,
+ seq->seq_fields.bits.log2_max_frame_num_minus4);
+ /* pic_order_cnt_type */
+ h264_bitstream_write_ue(bitstream, seq->seq_fields.bits.pic_order_cnt_type);
- if (seq->seq_fields.bits.pic_order_cnt_type == 0)
- h264_bitstream_write_ue(bitstream, seq->seq_fields.bits.log2_max_pic_order_cnt_lsb_minus4);/* log2_max_pic_order_cnt_lsb_minus4 */
- else if (seq->seq_fields.bits.pic_order_cnt_type == 1) {
+ if (seq->seq_fields.bits.pic_order_cnt_type == 0) {
+ /* log2_max_pic_order_cnt_lsb_minus4 */
+ h264_bitstream_write_ue(bitstream,
+ seq->seq_fields.bits.log2_max_pic_order_cnt_lsb_minus4);
+ } else if (seq->seq_fields.bits.pic_order_cnt_type == 1) {
ENCODER_ASSERT(0);
- h264_bitstream_write_uint(bitstream, seq->seq_fields.bits.delta_pic_order_always_zero_flag, 1);
+ h264_bitstream_write_uint(bitstream,
+ seq->seq_fields.bits.delta_pic_order_always_zero_flag,
+ 1);
h264_bitstream_write_se(bitstream, seq->offset_for_non_ref_pic);
- h264_bitstream_write_se(bitstream, seq->offset_for_top_to_bottom_field);
- h264_bitstream_write_ue(bitstream, seq->num_ref_frames_in_pic_order_cnt_cycle);
+ h264_bitstream_write_se(bitstream,
+ seq->offset_for_top_to_bottom_field);
+ h264_bitstream_write_ue(bitstream,
+ seq->num_ref_frames_in_pic_order_cnt_cycle);
for ( i = 0; i < seq->num_ref_frames_in_pic_order_cnt_cycle; i++) {
h264_bitstream_write_se(bitstream, seq->offset_for_ref_frame[i]);
}
}
- h264_bitstream_write_ue(bitstream, seq->max_num_ref_frames); /* num_ref_frames */
- h264_bitstream_write_uint(bitstream, gaps_in_frame_num_value_allowed_flag, 1); /* gaps_in_frame_num_value_allowed_flag */
+ /* num_ref_frames */
+ h264_bitstream_write_ue(bitstream, seq->max_num_ref_frames);
+ /* gaps_in_frame_num_value_allowed_flag */
+ h264_bitstream_write_uint(bitstream,
+ gaps_in_frame_num_value_allowed_flag,
+ 1);
- h264_bitstream_write_ue(bitstream, seq->picture_width_in_mbs - 1); /* pic_width_in_mbs_minus1 */
- h264_bitstream_write_ue(bitstream, pic_height_in_map_units - 1); /* pic_height_in_map_units_minus1 */
- h264_bitstream_write_uint(bitstream, seq->seq_fields.bits.frame_mbs_only_flag, 1); /* frame_mbs_only_flag */
+ /* pic_width_in_mbs_minus1 */
+ h264_bitstream_write_ue(bitstream, seq->picture_width_in_mbs - 1);
+ /* pic_height_in_map_units_minus1 */
+ h264_bitstream_write_ue(bitstream, pic_height_in_map_units - 1);
+ /* frame_mbs_only_flag */
+ h264_bitstream_write_uint(bitstream,
+ seq->seq_fields.bits.frame_mbs_only_flag,
+ 1);
if (!seq->seq_fields.bits.frame_mbs_only_flag) { //ONLY mbs
ENCODER_ASSERT(0);
h264_bitstream_write_uint(bitstream, mb_adaptive_frame_field, 1);
}
- h264_bitstream_write_uint(bitstream, 0, 1); /* direct_8x8_inference_flag */
- h264_bitstream_write_uint(bitstream, seq->frame_cropping_flag, 1); /* frame_cropping_flag */
+ /* direct_8x8_inference_flag */
+ h264_bitstream_write_uint(bitstream, 0, 1);
+ /* frame_cropping_flag */
+ h264_bitstream_write_uint(bitstream, seq->frame_cropping_flag, 1);
if (seq->frame_cropping_flag) {
- h264_bitstream_write_ue(bitstream, seq->frame_crop_left_offset); /* frame_crop_left_offset */
- h264_bitstream_write_ue(bitstream, seq->frame_crop_right_offset); /* frame_crop_right_offset */
- h264_bitstream_write_ue(bitstream, seq->frame_crop_top_offset); /* frame_crop_top_offset */
- h264_bitstream_write_ue(bitstream, seq->frame_crop_bottom_offset); /* frame_crop_bottom_offset */
+ /* frame_crop_left_offset */
+ h264_bitstream_write_ue(bitstream, seq->frame_crop_left_offset);
+ /* frame_crop_right_offset */
+ h264_bitstream_write_ue(bitstream, seq->frame_crop_right_offset);
+ /* frame_crop_top_offset */
+ h264_bitstream_write_ue(bitstream, seq->frame_crop_top_offset);
+ /* frame_crop_bottom_offset */
+ h264_bitstream_write_ue(bitstream, seq->frame_crop_bottom_offset);
}
ENCODER_ASSERT(seq->vui_parameters_present_flag == FALSE);
- h264_bitstream_write_uint(bitstream, seq->vui_parameters_present_flag, 1); /* vui_parameters_present_flag */
+
+ /* vui_parameters_present_flag */
+ h264_bitstream_write_uint(bitstream, seq->vui_parameters_present_flag, 1);
if (seq->vui_parameters_present_flag) {
/*FIXME, to write vui parameters*/
}
- h264_bitstream_write_trailing_bits(bitstream); /* rbsp_trailing_bits */
+ /* rbsp_trailing_bits */
+ h264_bitstream_write_trailing_bits(bitstream);
return TRUE;
}
static gboolean
-h264_bitstream_write_pps(H264Bitstream *bitstream,
- VAEncPictureParameterBufferH264 *pic)
+h264_bitstream_write_pps(
+ H264Bitstream *bitstream,
+ VAEncPictureParameterBufferH264 *pic
+)
{
guint32 num_slice_groups_minus1 = 0;
guint32 pic_init_qs_minus26 = 0;
guint32 redundant_pic_cnt_present_flag = 0;
- h264_bitstream_write_ue(bitstream, pic->pic_parameter_set_id); /* pic_parameter_set_id */
- h264_bitstream_write_ue(bitstream, pic->seq_parameter_set_id); /* seq_parameter_set_id */
- h264_bitstream_write_uint(bitstream, pic->pic_fields.bits.entropy_coding_mode_flag, 1); /* entropy_coding_mode_flag */
- h264_bitstream_write_uint(bitstream, pic->pic_fields.bits.pic_order_present_flag, 1); /* pic_order_present_flag */
- h264_bitstream_write_ue(bitstream, num_slice_groups_minus1); /*slice_groups-1*/
+ /* pic_parameter_set_id */
+ h264_bitstream_write_ue(bitstream, pic->pic_parameter_set_id);
+ /* seq_parameter_set_id */
+ h264_bitstream_write_ue(bitstream, pic->seq_parameter_set_id);
+ /* entropy_coding_mode_flag */
+ h264_bitstream_write_uint(bitstream,
+ pic->pic_fields.bits.entropy_coding_mode_flag,
+ 1);
+ /* pic_order_present_flag */
+ h264_bitstream_write_uint(bitstream,
+ pic->pic_fields.bits.pic_order_present_flag,
+ 1);
+ /*slice_groups-1*/
+ h264_bitstream_write_ue(bitstream, num_slice_groups_minus1);
if (num_slice_groups_minus1 > 0) {
/*FIXME*/
}
h264_bitstream_write_ue(bitstream, pic->num_ref_idx_l0_active_minus1);
h264_bitstream_write_ue(bitstream, pic->num_ref_idx_l1_active_minus1);
- h264_bitstream_write_uint(bitstream, pic->pic_fields.bits.weighted_pred_flag, 1);
- h264_bitstream_write_uint(bitstream, pic->pic_fields.bits.weighted_bipred_idc, 2);
- h264_bitstream_write_se(bitstream, pic->pic_init_qp-26); /* pic_init_qp_minus26 */
- h264_bitstream_write_se(bitstream, pic_init_qs_minus26); /* pic_init_qs_minus26 */
- h264_bitstream_write_se(bitstream, pic->chroma_qp_index_offset); /*chroma_qp_index_offset*/
-
- h264_bitstream_write_uint(bitstream, pic->pic_fields.bits.deblocking_filter_control_present_flag, 1);
- h264_bitstream_write_uint(bitstream, pic->pic_fields.bits.constrained_intra_pred_flag, 1);
+ h264_bitstream_write_uint(bitstream,
+ pic->pic_fields.bits.weighted_pred_flag,
+ 1);
+ h264_bitstream_write_uint(bitstream,
+ pic->pic_fields.bits.weighted_bipred_idc,
+ 2);
+ /* pic_init_qp_minus26 */
+ h264_bitstream_write_se(bitstream, pic->pic_init_qp-26);
+ /* pic_init_qs_minus26 */
+ h264_bitstream_write_se(bitstream, pic_init_qs_minus26);
+ /*chroma_qp_index_offset*/
+ h264_bitstream_write_se(bitstream, pic->chroma_qp_index_offset);
+
+ h264_bitstream_write_uint(bitstream,
+ pic->pic_fields.bits.deblocking_filter_control_present_flag,
+ 1);
+ h264_bitstream_write_uint(bitstream,
+ pic->pic_fields.bits.constrained_intra_pred_flag,
+ 1);
h264_bitstream_write_uint(bitstream, redundant_pic_cnt_present_flag, 1);
/*more_rbsp_data*/
- h264_bitstream_write_uint(bitstream, pic->pic_fields.bits.transform_8x8_mode_flag, 1);
- h264_bitstream_write_uint(bitstream, pic->pic_fields.bits.pic_scaling_matrix_present_flag, 1);
+ h264_bitstream_write_uint(bitstream,
+ pic->pic_fields.bits.transform_8x8_mode_flag,
+ 1);
+ h264_bitstream_write_uint(bitstream,
+ pic->pic_fields.bits.pic_scaling_matrix_present_flag,
+ 1);
if (pic->pic_fields.bits.pic_scaling_matrix_present_flag) {
ENCODER_ASSERT(0);
/* FIXME */
h264_bitstream_write_trailing_bits(bitstream);
return TRUE;
}
-
-
-static const guint8 *
-h264_next_nal(const guint8 *buffer, guint32 len, guint32 *nal_size)
-{
- const guint8 *cur = buffer;
- const guint8 *end = buffer + len;
- const guint8 *nal_start = NULL;
- guint32 flag = 0xFFFFFFFF;
- guint32 nal_start_len = 0;
-
- ENCODER_ASSERT(len >= 0 && buffer && nal_size);
- if (len < 3) {
- *nal_size = len;
- nal_start = (len ? buffer : NULL);
- return nal_start;
- }
-
- /*locate head postion*/
- if (!buffer[0] && !buffer[1]) {
- if (buffer[2] == 1) { // 0x000001
- nal_start_len = 3;
- } else if (!buffer[2] && len >=4 && buffer[3] == 1) { //0x00000001
- nal_start_len = 4;
- }
- }
- nal_start = buffer + nal_start_len;
- cur = nal_start;
-
- /*find next nal start position*/
- while (cur < end) {
- flag = ((flag<<8) | ((*cur++)&0xFF));
- if (flag == 0x00000001) {
- *nal_size = cur - 4 - nal_start;
- break;
- } else if ((flag&0x00FFFFFF) == 0x00000001) {
- *nal_size = cur - 3 - nal_start;
- break;
- }
- }
- if (cur >= end) {
- *nal_size = end - nal_start;
- if (nal_start >= end) {
- nal_start = NULL;
- }
- }
- return nal_start;
-}
* Boston, MA 02110-1301 USA
*/
-#ifndef _GST_VAAPI_ENCODER_H264_H_
-#define _GST_VAAPI_ENCODER_H264_H_
-
+#ifndef GST_VAAPI_ENCODER_H264_H
+#define GST_VAAPI_ENCODER_H264_H
#include "gst/vaapi/gstvaapisurfacepool.h"
-
-#include "gstvaapibaseencoder.h"
+#include "gst/vaapi/gstvaapibaseencoder.h"
G_BEGIN_DECLS
typedef struct _GstVaapiEncoderH264Private GstVaapiEncoderH264Private;
typedef struct _GstVaapiEncoderH264Class GstVaapiEncoderH264Class;
+#define GST_TYPE_VAAPI_ENCODER_H264 \
+ (gst_vaapi_encoder_h264_get_type())
+
+#define GST_IS_VAAPI_ENCODER_H264(obj) \
+ (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GST_TYPE_VAAPI_ENCODER_H264))
+
+#define GST_IS_VAAPI_ENCODER_H264_CLASS(klass) \
+ (G_TYPE_CHECK_CLASS_TYPE ((klass), GST_TYPE_VAAPI_ENCODER_H264))
+
+#define GST_VAAPI_ENCODER_H264_GET_CLASS(obj) \
+ (G_TYPE_INSTANCE_GET_CLASS ((obj), \
+ GST_TYPE_VAAPI_ENCODER_H264, \
+ GstVaapiEncoderH264Class))
-#define GST_TYPE_VAAPI_ENCODER_H264 (gst_vaapi_encoder_h264_get_type())
-#define GST_IS_VAAPI_ENCODER_H264(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GST_TYPE_VAAPI_ENCODER_H264))
-#define GST_IS_VAAPI_ENCODER_H264_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GST_TYPE_VAAPI_ENCODER_H264))
-#define GST_VAAPI_ENCODER_H264_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GST_TYPE_VAAPI_ENCODER_H264, GstVaapiEncoderH264Class))
-#define GST_VAAPI_ENCODER_H264(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GST_TYPE_VAAPI_ENCODER_H264, GstVaapiEncoderH264))
-#define GST_VAAPI_ENCODER_H264_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GST_TYPE_VAAPI_ENCODER_H264, GstVaapiEncoderH264Class))
-#define GST_VAAPI_ENCODER_H264_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE((obj),GST_TYPE_VAAPI_ENCODER_H264,GstVaapiEncoderH264Private))
+#define GST_VAAPI_ENCODER_H264(obj) \
+ (G_TYPE_CHECK_INSTANCE_CAST ((obj), \
+ GST_TYPE_VAAPI_ENCODER_H264, \
+ GstVaapiEncoderH264))
+
+#define GST_VAAPI_ENCODER_H264_CLASS(klass) \
+ (G_TYPE_CHECK_CLASS_CAST ((klass), \
+ GST_TYPE_VAAPI_ENCODER_H264, \
+ GstVaapiEncoderH264Class))
+
+#define GST_VAAPI_ENCODER_H264_GET_PRIVATE(obj) \
+ (G_TYPE_INSTANCE_GET_PRIVATE((obj), \
+ GST_TYPE_VAAPI_ENCODER_H264, \
+ GstVaapiEncoderH264Private))
typedef enum {
H264_PROFILE_BASELINE = 66,
};
-GType gst_vaapi_encoder_h264_get_type(void);
+GType
+gst_vaapi_encoder_h264_get_type(void);
+
+GstVaapiEncoderH264 *
+gst_vaapi_encoder_h264_new(void);
-GstVaapiEncoderH264 *gst_vaapi_encoder_h264_new(void);
-static inline void gst_vaapi_encoder_h264_unref (GstVaapiEncoderH264 * encoder)
+static inline void
+gst_vaapi_encoder_h264_unref (GstVaapiEncoderH264 * encoder)
{
g_object_unref (encoder);
}
-void gst_vaapi_encoder_h264_set_avc_flag(GstVaapiEncoderH264* encoder, gboolean avc);
-gboolean gst_vaapi_encoder_h264_get_avc_flag(GstVaapiEncoderH264* encoder);
-
+void
+gst_vaapi_encoder_h264_set_avc_flag(
+ GstVaapiEncoderH264* encoder,
+ gboolean avc
+);
+gboolean
+gst_vaapi_encoder_h264_get_avc_flag(GstVaapiEncoderH264* encoder);
G_END_DECLS
-#endif /*_GST_VAAPI_ENCODER_H264_H_ */
-
+#endif /*GST_VAAPI_ENCODER_H264_H */
#include <string.h>
#include "gst/gstclock.h"
-#include "gst/vaapi/gstvaapiobject.h"
-#include "gst/vaapi/gstvaapiobject_priv.h"
-#include "gst/vaapi/gstvaapicontext.h"
-#include "gst/vaapi/gstvaapisurface.h"
-#include "gst/vaapi/gstvaapivideobuffer.h"
-#include "gst/vaapi/gstvaapidisplay_priv.h"
+#include "gstvaapiobject.h"
+#include "gstvaapiobject_priv.h"
+#include "gstvaapicontext.h"
+#include "gstvaapisurface.h"
+#include "gstvaapivideobuffer.h"
+#include "gstvaapidisplay_priv.h"
GST_DEBUG_CATEGORY_STATIC (gst_vaapi_mpeg4_encoder_debug);
#define GST_CAT_DEFAULT gst_vaapi_mpeg4_encoder_debug
GstVaapiSurface *ref_surface; /* reference buffer*/
GstVaapiSurface *recon_surface; /* reconstruct buffer*/
- VABufferID seq_parameter;
- VABufferID pic_parameter;
- VABufferID slice_parameter;
+ VABufferID seq_param_id;
+ VABufferID pic_param_id;
+ VABufferID slice_param_id;
GstBuffer *codec_data;
};
-G_DEFINE_TYPE(GstVaapiEncoderMpeg4, gst_vaapi_encoder_mpeg4, GST_TYPE_VAAPI_BASE_ENCODER);
+G_DEFINE_TYPE(GstVaapiEncoderMpeg4, gst_vaapi_encoder_mpeg4, GST_TYPE_VAAPI_BASE_ENCODER)
GstVaapiEncoderMpeg4 *
gst_vaapi_encoder_mpeg4_new(void)
{
- return GST_VAAPI_ENCODER_MPEG4_CAST(g_object_new(GST_TYPE_VAAPI_ENCODER_MPEG4, NULL));
+ return GST_VAAPI_ENCODER_MPEG4_CAST(
+ g_object_new(GST_TYPE_VAAPI_ENCODER_MPEG4, NULL));
}
gboolean
-gst_mpeg4_validate_parameters(GstVaapiBaseEncoder *base)
+gst_vaapi_encoder_mpeg4_validate_attributes(
+ GstVaapiBaseEncoder *base
+)
{
GstVaapiEncoderMpeg4 *encoder = GST_VAAPI_ENCODER_MPEG4_CAST(base);
- if (!ENCODER_WIDTH(encoder) || !ENCODER_HEIGHT(encoder) || !ENCODER_FPS(encoder)) {
+
+ if (!ENCODER_WIDTH(encoder) ||
+ !ENCODER_HEIGHT(encoder) ||
+ !ENCODER_FPS(encoder)) {
return FALSE;
}
- if (VAProfileMPEG4Simple != encoder->profile && VAProfileMPEG4AdvancedSimple != encoder->profile) {
+ if (VAProfileMPEG4Simple != encoder->profile &&
+ VAProfileMPEG4AdvancedSimple != encoder->profile) {
return FALSE;
}
gst_vaapi_base_encoder_set_va_profile(base, encoder->profile);
/* default compress ratio 1: (4*8*1.5) */
if (!encoder->bitrate) {
- encoder->bitrate = ENCODER_WIDTH(encoder)*ENCODER_HEIGHT(encoder)*ENCODER_FPS(encoder)/4;
+ encoder->bitrate =
+ ENCODER_WIDTH(encoder)*ENCODER_HEIGHT(encoder)*ENCODER_FPS(encoder)/4;
}
return TRUE;
}
static void
-mpeg4_release_parameters(GstVaapiEncoderMpeg4 *encoder)
+mpeg4_release_parameters(
+ GstVaapiEncoderMpeg4 *encoder
+)
{
GstVaapiEncoderMpeg4Private *priv = encoder->priv;
VADisplay va_dpy = ENCODER_DISPLAY(encoder);
VAAPI_UNUSED_ARG(va_status);
- if (VA_INVALID_ID != priv->seq_parameter) {
- va_status = vaDestroyBuffer(va_dpy, priv->seq_parameter);
- priv->seq_parameter = VA_INVALID_ID;
+ if (VA_INVALID_ID != priv->seq_param_id) {
+ va_status = vaDestroyBuffer(va_dpy, priv->seq_param_id);
+ priv->seq_param_id = VA_INVALID_ID;
}
- if (VA_INVALID_ID != priv->pic_parameter) {
- va_status = vaDestroyBuffer(va_dpy, priv->pic_parameter);
- priv->pic_parameter = VA_INVALID_ID;
+ if (VA_INVALID_ID != priv->pic_param_id) {
+ va_status = vaDestroyBuffer(va_dpy, priv->pic_param_id);
+ priv->pic_param_id = VA_INVALID_ID;
}
- if (VA_INVALID_ID != priv->slice_parameter) {
- va_status = vaDestroyBuffer(va_dpy, priv->slice_parameter);
- priv->slice_parameter = VA_INVALID_ID;
+ if (VA_INVALID_ID != priv->slice_param_id) {
+ va_status = vaDestroyBuffer(va_dpy, priv->slice_param_id);
+ priv->slice_param_id = VA_INVALID_ID;
}
}
static gboolean
-gst_vaapi_encoder_mpeg4_release_resource(GstVaapiBaseEncoder* base)
+gst_vaapi_encoder_mpeg4_release_resource(
+ GstVaapiBaseEncoder* base
+)
{
GstVaapiEncoderMpeg4 *encoder = GST_VAAPI_ENCODER_MPEG4_CAST(base);
GstVaapiEncoderMpeg4Private *priv = encoder->priv;
return 0;
}
-
static EncoderStatus
gst_vaapi_encoder_mpeg4_rendering(
GstVaapiBaseEncoder *base,
*is_key = (frame_index % encoder->intra_period == 0);
/* initialize sequence parameter set, only first time */
- if (VA_INVALID_ID == priv->seq_parameter) { /*only the first time*/
- VAEncSequenceParameterBufferMPEG4 seq_mpeg4 = {0};
-
- seq_mpeg4.profile_and_level_indication = mpeg4_get_profile_level_indication(encoder->profile);
- seq_mpeg4.intra_period = encoder->intra_period;
- seq_mpeg4.video_object_layer_width = ENCODER_WIDTH(encoder);
- seq_mpeg4.video_object_layer_height = ENCODER_HEIGHT(encoder);
- seq_mpeg4.vop_time_increment_resolution = ENCODER_FPS(encoder);
- seq_mpeg4.fixed_vop_rate = MPEG4_DEFAULT_FIXED_VOP_RATE;
- if (seq_mpeg4.fixed_vop_rate) {
- seq_mpeg4.fixed_vop_time_increment = 1;
+ if (VA_INVALID_ID == priv->seq_param_id) { /*only the first time*/
+ VAEncSequenceParameterBufferMPEG4 seq_param = {0};
+
+ seq_param.profile_and_level_indication =
+ mpeg4_get_profile_level_indication(encoder->profile);
+ seq_param.intra_period = encoder->intra_period;
+ seq_param.video_object_layer_width = ENCODER_WIDTH(encoder);
+ seq_param.video_object_layer_height = ENCODER_HEIGHT(encoder);
+ seq_param.vop_time_increment_resolution = ENCODER_FPS(encoder);
+ seq_param.fixed_vop_rate = MPEG4_DEFAULT_FIXED_VOP_RATE;
+ if (seq_param.fixed_vop_rate) {
+ seq_param.fixed_vop_time_increment = 1;
}
- seq_mpeg4.bits_per_second = encoder->bitrate;
- seq_mpeg4.frame_rate = ENCODER_FPS(encoder);
- seq_mpeg4.initial_qp = encoder->init_qp;
- seq_mpeg4.min_qp = encoder->min_qp; //mpeg4_encoder->min_qp;
+ seq_param.bits_per_second = encoder->bitrate;
+ seq_param.frame_rate = ENCODER_FPS(encoder);
+ seq_param.initial_qp = encoder->init_qp;
+ seq_param.min_qp = encoder->min_qp; //mpeg4_encoder->min_qp;
va_status = vaCreateBuffer(va_dpy, context_id,
VAEncSequenceParameterBufferType,
- sizeof(seq_mpeg4), 1, &seq_mpeg4, &priv->seq_parameter);
+ sizeof(seq_param), 1,
+ &seq_param,
+ &priv->seq_param_id);
ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS == va_status,
- ENCODER_ENC_RES_ERR, "mpeg4 alloc seq-buffer failed.");
- va_status = vaRenderPicture(va_dpy, context_id, &priv->seq_parameter, 1);
+ ENCODER_ENC_RES_ERR,
+ "mpeg4 alloc seq-buffer failed.");
+ va_status = vaRenderPicture(va_dpy, context_id, &priv->seq_param_id, 1);
ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS == va_status,
ENCODER_PICTURE_ERR,
"mpeg4 vaRenderPicture seq-parameters failed.");
}
/* initialize picture, every time, every frame */
- VAEncPictureParameterBufferMPEG4 pic_mpeg4 = {0};
- pic_mpeg4.reference_picture = GST_VAAPI_OBJECT_ID(priv->ref_surface);
- pic_mpeg4.reconstructed_picture = GST_VAAPI_OBJECT_ID(priv->recon_surface);
- pic_mpeg4.coded_buf = coded_buf;
- pic_mpeg4.picture_width = ENCODER_WIDTH(encoder);
- pic_mpeg4.picture_height = ENCODER_HEIGHT(encoder);
+ VAEncPictureParameterBufferMPEG4 pic_param = {0};
+ pic_param.reference_picture = GST_VAAPI_OBJECT_ID(priv->ref_surface);
+ pic_param.reconstructed_picture = GST_VAAPI_OBJECT_ID(priv->recon_surface);
+ pic_param.coded_buf = coded_buf;
+ pic_param.picture_width = ENCODER_WIDTH(encoder);
+ pic_param.picture_height = ENCODER_HEIGHT(encoder);
if (0 == frame_index) {
- pic_mpeg4.modulo_time_base = 0;
+ pic_param.modulo_time_base = 0;
} else {
- pic_mpeg4.modulo_time_base = ((frame_index%ENCODER_FPS(encoder)) == 0 ? 1 : 0);
+ pic_param.modulo_time_base =
+ ((frame_index%ENCODER_FPS(encoder)) == 0 ? 1 : 0);
}
- pic_mpeg4.vop_time_increment = 301%ENCODER_FPS(encoder);
- pic_mpeg4.picture_type = *is_key ? VAEncPictureTypeIntra : VAEncPictureTypePredictive;
+ pic_param.vop_time_increment = 301%ENCODER_FPS(encoder);
+ pic_param.picture_type =
+ (*is_key ? VAEncPictureTypeIntra : VAEncPictureTypePredictive);
- if (VA_INVALID_ID != priv->pic_parameter) { /* destroy first*/
- va_status = vaDestroyBuffer(va_dpy, priv->pic_parameter);
- priv->pic_parameter = VA_INVALID_ID;
+ if (VA_INVALID_ID != priv->pic_param_id) { /* destroy first*/
+ va_status = vaDestroyBuffer(va_dpy, priv->pic_param_id);
+ priv->pic_param_id = VA_INVALID_ID;
}
- va_status = vaCreateBuffer(va_dpy, context_id, VAEncPictureParameterBufferType,
- sizeof(pic_mpeg4), 1, &pic_mpeg4, &priv->pic_parameter);
+ va_status = vaCreateBuffer(va_dpy,
+ context_id,
+ VAEncPictureParameterBufferType,
+ sizeof(pic_param), 1,
+ &pic_param,
+ &priv->pic_param_id);
ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS ==va_status,
ENCODER_ENC_RES_ERR,
"mpeg4 creating pic-param buffer failed.");
- va_status = vaRenderPicture(va_dpy, context_id, &priv->pic_parameter, 1);
+
+ va_status = vaRenderPicture(va_dpy, context_id, &priv->pic_param_id, 1);
ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS ==va_status,
ENCODER_PICTURE_ERR,
"mpeg4 rendering pic-param buffer failed.");
+
/*initialize slice parameters, only ONE slice for mpeg4*/
- VAEncSliceParameterBuffer slice_mpeg4 = { 0 };
- slice_mpeg4.start_row_number = 0;
- slice_mpeg4.slice_height = (ENCODER_HEIGHT(encoder)+15)/16; /*MB?*/
- slice_mpeg4.slice_flags.bits.is_intra = *is_key;
- slice_mpeg4.slice_flags.bits.disable_deblocking_filter_idc = 0;
- if (VA_INVALID_ID != priv->slice_parameter) {
- vaDestroyBuffer(va_dpy, priv->slice_parameter);
- priv->slice_parameter = VA_INVALID_ID;
+ VAEncSliceParameterBuffer slice_param = { 0 };
+ slice_param.start_row_number = 0;
+ slice_param.slice_height = (ENCODER_HEIGHT(encoder)+15)/16; /*MB?*/
+ slice_param.slice_flags.bits.is_intra = *is_key;
+ slice_param.slice_flags.bits.disable_deblocking_filter_idc = 0;
+ if (VA_INVALID_ID != priv->slice_param_id) {
+ vaDestroyBuffer(va_dpy, priv->slice_param_id);
+ priv->slice_param_id = VA_INVALID_ID;
}
va_status = vaCreateBuffer(va_dpy,
context_id,
VAEncSliceParameterBufferType,
- sizeof(slice_mpeg4),
+ sizeof(slice_param),
1,
- &slice_mpeg4,
- &priv->slice_parameter);
- ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS ==va_status,
+ &slice_param,
+ &priv->slice_param_id);
+ ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS == va_status,
ENCODER_ENC_RES_ERR,
"mpeg4 creating slice-parameters buffer failed.");
- va_status = vaRenderPicture(va_dpy, context_id, &priv->slice_parameter, 1);
- ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS ==va_status,
+ va_status = vaRenderPicture(va_dpy, context_id, &priv->slice_param_id, 1);
+ ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS == va_status,
ENCODER_PICTURE_ERR,
"mpeg4 rendering slice-parameters buffer failed.");
#endif
static gboolean
-find_video_object_configuration_info(const guint8 *in_buffer, guint32 in_size,
- const guint8 **out_buffer, guint32 *out_size)
+find_video_object_configuration_info(
+ const guint8 *in_buffer,
+ guint32 in_size,
+ const guint8 **out_buffer,
+ guint32 *out_size
+)
{
guint32 value = 0x00;
const guint8 *end = in_buffer + in_size;
}
static void
-gst_mpeg4_notify_frame(GstVaapiBaseEncoder *base, guint8 *buf, guint32 size)
+gst_vaapi_encoder_mpeg4_notify_frame(
+ GstVaapiBaseEncoder *base,
+ guint8 *buf,
+ guint32 size
+)
{
GstVaapiEncoderMpeg4 *encoder = GST_VAAPI_ENCODER_MPEG4_CAST(base);
GstVaapiEncoderMpeg4Private *priv = encoder->priv;
if (!priv->codec_data) {
if (!mpeg4_encoder_generate_codec_data(buf, size, &priv->codec_data)) {
- ENCODER_LOG_ERROR("mpeg4 encoder coded data error, please check <mpeg4_encoder_generate_codec_data>.");
+ ENCODER_LOG_ERROR("mpeg4 encoder coded data error,"
+ "please check <mpeg4_encoder_generate_codec_data>.");
}
}
if (priv->codec_data) {
}
}
-
static EncoderStatus
gst_vaapi_encoder_mpeg4_flush(
GstVaapiEncoder* base,
- GList **coded_pics)
+ GList **coded_pics
+)
{
GstVaapiEncoderMpeg4 *encoder = GST_VAAPI_ENCODER_MPEG4_CAST(base);
return ENCODER_NO_ERROR;
}
-
static EncoderStatus
-gst_vaapi_encoder_mpeg4_get_codec_data(GstVaapiEncoder *base, GstBuffer **buffer)
+gst_vaapi_encoder_mpeg4_get_codec_data(
+ GstVaapiEncoder *base,
+ GstBuffer **buffer
+)
{
GstVaapiEncoderMpeg4 *encoder = GST_VAAPI_ENCODER_MPEG4_CAST(base);
GstVaapiEncoderMpeg4Private *priv = encoder->priv;
priv->ref_surface = NULL;
priv->recon_surface = NULL;
- priv->seq_parameter = VA_INVALID_ID;
- priv->pic_parameter = VA_INVALID_ID;
- priv->slice_parameter = VA_INVALID_ID;
+ priv->seq_param_id = VA_INVALID_ID;
+ priv->pic_param_id = VA_INVALID_ID;
+ priv->slice_param_id = VA_INVALID_ID;
priv->codec_data = NULL;
}
object_class->finalize = gst_vaapi_encoder_mpeg4_finalize;
- base_class->validate_attributes = gst_mpeg4_validate_parameters;
+ base_class->validate_attributes = gst_vaapi_encoder_mpeg4_validate_attributes;
base_class->pre_alloc_resource = NULL;
base_class->release_resource = gst_vaapi_encoder_mpeg4_release_resource;
base_class->render_frame = gst_vaapi_encoder_mpeg4_rendering;
- base_class->notify_frame = gst_mpeg4_notify_frame;
+ base_class->notify_frame = gst_vaapi_encoder_mpeg4_notify_frame;
base_class->copy_coded_frame = NULL;
encoder_class->flush = gst_vaapi_encoder_mpeg4_flush;
* Boston, MA 02110-1301 USA
*/
-#ifndef _GST_VAAPI_ENCODER_MPEG4_H_
-#define _GST_VAAPI__ENCODER_MPEG4_H_
-
+#ifndef GST_VAAPI_ENCODER_MPEG4_H
+#define GST_VAAPI_ENCODER_MPEG4_H
#include "gst/vaapi/gstvaapisurfacepool.h"
-
-#include "gstvaapibaseencoder.h"
+#include "gst/vaapi/gstvaapibaseencoder.h"
G_BEGIN_DECLS
typedef struct _GstVaapiEncoderMpeg4Class GstVaapiEncoderMpeg4Class;
-#define GST_TYPE_VAAPI_ENCODER_MPEG4 (gst_vaapi_encoder_mpeg4_get_type())
-#define GST_IS_VAAPI_ENCODER_MPEG4(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GST_TYPE_VAAPI_ENCODER_MPEG4))
-#define GST_IS_VAAPI_ENCODER_MPEG4_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GST_TYPE_VAAPI_ENCODER_MPEG4))
-#define GST_VAAPI_ENCODER_MPEG4_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GST_TYPE_VAAPI_ENCODER_MPEG4, GstVaapiEncoderMpeg4Class))
-#define GST_VAAPI_ENCODER_MPEG4(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GST_TYPE_VAAPI_ENCODER_MPEG4, GstVaapiEncoderMpeg4))
-#define GST_VAAPI_ENCODER_MPEG4_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GST_TYPE_VAAPI_ENCODER_MPEG4, GstVaapiEncoderMpeg4Class))
-#define GST_VAAPI_ENCODER_MPEG4_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE((obj),GST_TYPE_VAAPI_ENCODER_MPEG4,GstVaapiEncoderMpeg4Private))
+#define GST_TYPE_VAAPI_ENCODER_MPEG4 \
+ (gst_vaapi_encoder_mpeg4_get_type())
+
+#define GST_IS_VAAPI_ENCODER_MPEG4(obj) \
+ (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GST_TYPE_VAAPI_ENCODER_MPEG4))
+
+#define GST_IS_VAAPI_ENCODER_MPEG4_CLASS(klass) \
+ (G_TYPE_CHECK_CLASS_TYPE ((klass), GST_TYPE_VAAPI_ENCODER_MPEG4))
+
+#define GST_VAAPI_ENCODER_MPEG4_GET_CLASS(obj) \
+ (G_TYPE_INSTANCE_GET_CLASS ((obj), \
+ GST_TYPE_VAAPI_ENCODER_MPEG4, \
+ GstVaapiEncoderMpeg4Class))
+
+#define GST_VAAPI_ENCODER_MPEG4(obj) \
+ (G_TYPE_CHECK_INSTANCE_CAST ((obj), \
+ GST_TYPE_VAAPI_ENCODER_MPEG4, \
+ GstVaapiEncoderMpeg4))
+
+#define GST_VAAPI_ENCODER_MPEG4_CLASS(klass) \
+ (G_TYPE_CHECK_CLASS_CAST ((klass), \
+ GST_TYPE_VAAPI_ENCODER_MPEG4, \
+ GstVaapiEncoderMpeg4Class))
+
+#define GST_VAAPI_ENCODER_MPEG4_GET_PRIVATE(obj) \
+ (G_TYPE_INSTANCE_GET_PRIVATE((obj), \
+ GST_TYPE_VAAPI_ENCODER_MPEG4, \
+ GstVaapiEncoderMpeg4Private))
struct _GstVaapiEncoderMpeg4 {
GstVaapiBaseEncoder parent; /*based on gobject*/
GstVaapiBaseEncoderClass parent_class;
};
+GType
+gst_vaapi_encoder_mpeg4_get_type(void);
-GType gst_vaapi_encoder_mpeg4_get_type(void);
+GstVaapiEncoderMpeg4 *
+gst_vaapi_encoder_mpeg4_new(void);
-GstVaapiEncoderMpeg4 *gst_vaapi_encoder_mpeg4_new(void);
-static inline void gst_vaapi_encoder_mpeg4_unref (GstVaapiEncoderMpeg4 * encoder)
+static inline void
+gst_vaapi_encoder_mpeg4_unref (GstVaapiEncoderMpeg4 * encoder)
{
g_object_unref (encoder);
}
G_END_DECLS
-#endif /* _GST_VAAPI_ENCODER_MPEG4_H_ */
-
+#endif /* GST_VAAPI_ENCODER_MPEG4_H */
#include <string.h>
#include <X11/Xlib.h>
#include <gst/video/videocontext.h>
-
-#include "gst/vaapi/gstvaapiencode_h264.h"
-#include "gst/vaapi/gstvaapiencode_h263.h"
-#include "gst/vaapi/gstvaapiencode_mpeg4.h"
#include "gst/vaapi/gstvaapibaseencoder.h"
+#include "gstvaapiencode_h264.h"
+#include "gstvaapiencode_h263.h"
+#include "gstvaapiencode_mpeg4.h"
#include "gstvaapipluginutil.h"
#include "gstvaapipluginbuffer.h"
-
/* gst_debug
GST_DEBUG_CATEGORY_STATIC (gst_vaapi_encode_debug)
#define GST_CAT_DEFAULT gst_vaapi_encode_debug
GST_DEBUG_CATEGORY_STATIC (gst_vaapi_encode_debug);
#define GST_CAT_DEFAULT gst_vaapi_encode_debug
-#define GST_VAAPI_ENCODE_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GST_TYPE_VAAPI_ENCODE, GstVaapiEncodePrivate))
+#define GST_VAAPI_ENCODE_GET_PRIVATE(obj) \
+ (G_TYPE_INSTANCE_GET_PRIVATE ((obj), \
+ GST_TYPE_VAAPI_ENCODE, \
+ GstVaapiEncodePrivate))
typedef struct _GstVaapiEncodePrivate GstVaapiEncodePrivate;
-
#define GstVideoContextClass GstVideoContextInterface
+
GST_BOILERPLATE_WITH_INTERFACE(
GstVaapiEncode,
gst_vaapi_encode,
GST_TYPE_ELEMENT,
GstVideoContext,
GST_TYPE_VIDEO_CONTEXT,
- gst_video_context);
+ gst_video_context)
enum {
PROP_0,
};
+static char*
+_encode_dump_caps(GstCaps *cpas)
+{
+ guint i = 0, j = 0;
+ GstStructure const *structure;
+ GValue const *value;
+ static char caps_string[4096*5];
+ char *tmp;
-/*static extern*/
-static void gst_vaapi_encode_finalize(GObject *object);
-static void gst_vaapi_encode_set_property(GObject *object, guint prop_id,
- const GValue *value, GParamSpec *pspec);
-static void gst_vaapi_encode_get_property (GObject * object, guint prop_id,
- GValue * value, GParamSpec * pspec);
+ char *cur = caps_string;
+ memset(caps_string, 0, sizeof(caps_string));
+ for (i = 0; i < gst_caps_get_size(cpas); i++) {
+ structure = gst_caps_get_structure(cpas, i);
+ const char* caps_name = gst_structure_get_name (structure);
+ sprintf(cur, "cap_%02d:%s\n", i, caps_name);
+ cur += strlen(cur);
-static gboolean gst_vaapi_encode_set_caps(GstPad *sink_pad, GstCaps *caps);
-static GstCaps *gst_vaapi_encode_get_caps(GstPad *sink_pad);
-static GstFlowReturn gst_vaapi_encode_chain(GstPad *sink_pad, GstBuffer *buf);
-static GstStateChangeReturn gst_vaapi_encode_change_state(GstElement *element, GstStateChange transition);
-static GstFlowReturn gst_vaapi_encode_buffer_alloc(GstPad * pad, guint64 offset, guint size,
- GstCaps * caps, GstBuffer ** buf);
+ for (j = 0; j < gst_structure_n_fields(structure); j++) {
+ const char* name = gst_structure_nth_field_name(structure, j);
+ value = gst_structure_get_value(structure, name);
+ tmp = gst_value_serialize(value);
+ sprintf(cur, "\t%s:%s(%s)\n", name, tmp, G_VALUE_TYPE_NAME(value));
+ cur += strlen(cur);
+ g_free(tmp);
+ }
+ }
-static char* _encode_dump_caps(GstCaps *cpas);
+ return caps_string;
+}
/* context(display) interface */
static void
-gst_vaapi_encode_set_video_context(GstVideoContext *context, const gchar *type,
- const GValue *value)
+gst_vaapi_encode_set_video_context(
+ GstVideoContext *context,
+ const gchar *type,
+ const GValue *value
+)
{
GstVaapiEncode *encode = GST_VAAPI_ENCODE (context);
GstVaapiDisplay *display = NULL;
}
static gboolean
-gst_vaapi_encode_query (GstPad *pad, GstQuery *query) {
+gst_vaapi_encode_query (GstPad *pad, GstQuery *query)
+{
GstVaapiEncode *encode = GST_VAAPI_ENCODE (gst_pad_get_parent_element (pad));
gboolean res;
- if (encode->encoder && gst_vaapi_reply_to_query(query, ENCODER_DISPLAY(encode->encoder)))
+ if (encode->encoder &&
+ gst_vaapi_reply_to_query(query, ENCODER_DISPLAY(encode->encoder)))
res = TRUE;
else
res = gst_pad_query_default (pad, query);
return res;
}
-/*gst fix functions*/
-
-static void
-gst_vaapi_encode_base_init(gpointer klass)
-{
- #if 0
- GstElementClass * const element_class = GST_ELEMENT_CLASS(klass);
-
- gst_element_class_set_details(element_class, &gst_vaapi_encode_details);
-
- /* sink pad */
- gst_element_class_add_pad_template(
- element_class,
- gst_static_pad_template_get(&gst_vaapi_encode_sink_factory)
- );
-
- /* src pad */
- gst_element_class_add_pad_template(
- element_class,
- gst_static_pad_template_get(&gst_vaapi_encode_src_factory)
- );
- #endif
-}
-
-
-static void
-gst_vaapi_encode_class_init(GstVaapiEncodeClass *klass)
-{
- GObjectClass * const object_class = G_OBJECT_CLASS(klass);
- GstElementClass * const element_class = GST_ELEMENT_CLASS(klass);
-
- object_class->finalize = gst_vaapi_encode_finalize;
- object_class->set_property = gst_vaapi_encode_set_property;
- object_class->get_property = gst_vaapi_encode_get_property;
-
- GST_DEBUG_CATEGORY_INIT (gst_vaapi_encode_debug, "vaapiencode", 0,
- "vaapiencode element");
-
- element_class->change_state = gst_vaapi_encode_change_state;
-
- klass->set_encoder_src_caps = NULL;
-
- /* Registering debug symbols for function pointers */
- GST_DEBUG_REGISTER_FUNCPTR (gst_vaapi_encode_change_state);
- GST_DEBUG_REGISTER_FUNCPTR (gst_vaapi_encode_get_caps);
- GST_DEBUG_REGISTER_FUNCPTR (gst_vaapi_encode_set_caps);
- GST_DEBUG_REGISTER_FUNCPTR (gst_vaapi_encode_chain);
- GST_DEBUG_REGISTER_FUNCPTR (gst_vaapi_encode_buffer_alloc);
-}
-
-static void
-gst_vaapi_encode_finalize(GObject *object)
-{
- GstVaapiEncode * const encode = GST_VAAPI_ENCODE(object);
-
- if (encode->sinkpad_caps) {
- gst_caps_unref(encode->sinkpad_caps);
- encode->sinkpad_caps = NULL;
- }
- encode->sinkpad = NULL;
-
- if (encode->srcpad_caps) {
- gst_caps_unref(encode->srcpad_caps);
- encode->srcpad_caps = NULL;
- }
- encode->srcpad = NULL;
-
- if (encode->encoder) {
- gst_vaapi_encoder_close(encode->encoder);
- gst_vaapi_encoder_uninitialize(encode->encoder);
- gst_vaapi_encoder_unref(encode->encoder);
- encode->encoder = NULL;
- }
-
- G_OBJECT_CLASS(parent_class)->finalize(object);
-}
-
-static void
-gst_vaapi_encode_init(GstVaapiEncode *encode, GstVaapiEncodeClass *klass)
-{
- GstElementClass * const element_class = GST_ELEMENT_CLASS(klass);
-
- encode->sinkpad_caps = NULL;
- encode->srcpad_caps = NULL;
- encode->first_sink_frame = TRUE;
- encode->first_src_frame = TRUE;
-
- encode->encoder = NULL;
-
- /*sink pad */
- encode->sinkpad = gst_pad_new_from_template(
- gst_element_class_get_pad_template(element_class, "sink"),
- "sink"
- );
- gst_pad_set_getcaps_function(encode->sinkpad, gst_vaapi_encode_get_caps);
- gst_pad_set_setcaps_function(encode->sinkpad, gst_vaapi_encode_set_caps);
- gst_pad_set_chain_function(encode->sinkpad, gst_vaapi_encode_chain);
- gst_pad_set_bufferalloc_function(encode->sinkpad, gst_vaapi_encode_buffer_alloc);
- /*gst_pad_set_event_function(encode->sinkpad, gst_vaapi_encode_sink_event); */
- /*gst_pad_use_fixed_caps(encode->sinkpad);*/
- gst_pad_set_query_function(encode->sinkpad, gst_vaapi_encode_query);
- gst_element_add_pad(GST_ELEMENT(encode), encode->sinkpad);
-
- /* src pad */
- encode->srcpad = gst_pad_new_from_template(
- gst_element_class_get_pad_template(element_class, "src"),
- "src"
- );
- encode->srcpad_caps = NULL;
-
- gst_pad_use_fixed_caps(encode->srcpad);
- /*gst_pad_set_event_function(encode->srcpad, gst_vaapi_encode_src_event);*/
- gst_pad_set_query_function(encode->sinkpad, gst_vaapi_encode_query);
- gst_element_add_pad(GST_ELEMENT(encode), encode->srcpad);
-}
-
-
-static void
-gst_vaapi_encode_set_property(GObject *object, guint prop_id,
- const GValue *value, GParamSpec *pspec)
-{
- GstVaapiEncode *encode = GST_VAAPI_ENCODE(object);
- ENCODER_ASSERT(encode->encoder);
-
- switch (prop_id) {
- }
-}
-
-static void
-gst_vaapi_encode_get_property (GObject * object, guint prop_id,
- GValue * value, GParamSpec * pspec)
-{
- GstVaapiEncode *encode = GST_VAAPI_ENCODE(object);
- ENCODER_ASSERT(encode->encoder);
-
- switch (prop_id) {
- }
-}
-
static inline gboolean
gst_vaapi_encode_ensure_display(GstVaapiEncode *encode)
{
- return gst_vaapi_ensure_display(encode, GST_VAAPI_DISPLAY_TYPE_ANY,
- &ENCODER_DISPLAY(encode->encoder));
+ return gst_vaapi_ensure_display(encode,
+ GST_VAAPI_DISPLAY_TYPE_ANY,
+ &ENCODER_DISPLAY(encode->encoder));
}
-
static gboolean
gst_vaapi_encode_set_caps(GstPad *sink_pad, GstCaps *caps)
{
GstVaapiEncode *encode = GST_VAAPI_ENCODE(GST_OBJECT_PARENT(sink_pad));
+ GstVaapiEncodeClass *encode_class = GST_VAAPI_ENCODE_GET_CLASS(encode);
GstStructure *structure = NULL, *src_struct = NULL;
gint width = 0, height = 0;
gint fps_n = 0, fps_d = 0;
encode->sinkpad_caps = caps;
gst_caps_ref(caps);
- ENCODER_LOG_INFO("gst_vaapi_encode_set_caps,\n%s", _encode_dump_caps(caps));
+ ENCODER_LOG_INFO("gst_vaapi_encode_set_caps,\n%s",
+ _encode_dump_caps(caps));
structure = gst_caps_get_structure (caps, 0);
if (gst_structure_get_int (structure, "width", &width)) {
}
format_value = gst_structure_get_value (structure, "format");
if (format_value && GST_IS_VAAPI_ENCODE_H264(encode)) {
- ENCODER_CHECK_STATUS(format_value && GST_TYPE_FOURCC == G_VALUE_TYPE(format_value),
- FALSE, "1st buffer caps' format type is not fourcc.");
+ ENCODER_CHECK_STATUS((format_value &&
+ GST_TYPE_FOURCC == G_VALUE_TYPE(format_value)),
+ FALSE,
+ "1st buffer caps' format type is not fourcc.");
format = gst_value_get_fourcc (format_value);
if (format) {
- gst_vaapi_base_encoder_set_input_format(GST_VAAPI_BASE_ENCODER(encode->encoder), format);
+ gst_vaapi_base_encoder_set_input_format(
+ GST_VAAPI_BASE_ENCODER(encode->encoder),
+ format);
}
}
if (encode->srcpad_caps) {
gst_caps_unref(encode->srcpad_caps);
}
- encode->srcpad_caps = gst_caps_copy(gst_pad_get_pad_template_caps(encode->srcpad));
+ encode->srcpad_caps =
+ gst_caps_copy(gst_pad_get_pad_template_caps(encode->srcpad));
src_struct = gst_caps_get_structure(encode->srcpad_caps, 0);
- gst_structure_set(src_struct, "width", G_TYPE_INT, width,
+ gst_structure_set(src_struct,
+ "width", G_TYPE_INT, width,
"height", G_TYPE_INT, height,
- "framerate", GST_TYPE_FRACTION, fps_n, fps_d, NULL);
- GstVaapiEncodeClass *encode_class = GST_VAAPI_ENCODE_GET_CLASS(encode);
+ "framerate", GST_TYPE_FRACTION, fps_n, fps_d,
+ NULL);
if (encode_class->set_encoder_src_caps) {
encode_class->set_encoder_src_caps(encode, encode->srcpad_caps);
}
/*set display and initialize encoder*/
ENCODER_CHECK_STATUS(gst_vaapi_encode_ensure_display(encode),
- FALSE, "encoder ensure display failed on setting caps.")
+ FALSE,
+ "encoder ensure display failed on setting caps.");
+
encoder_ret = gst_vaapi_encoder_initialize(encode->encoder);
ENCODER_CHECK_STATUS (ENCODER_NO_ERROR == encoder_ret,
- FALSE, "gst_vaapi_encoder_initialize failed.");
+ FALSE,
+ "gst_vaapi_encoder_initialize failed.");
+
encoder_ret = gst_vaapi_encoder_open(encode->encoder);
ENCODER_CHECK_STATUS (ENCODER_NO_ERROR == encoder_ret,
- FALSE, "gst_vaapi_encoder_open failed.");
+ FALSE,
+ "gst_vaapi_encoder_open failed.");
end:
return ret;
}
gst_vaapi_encode_get_caps(GstPad *sink_pad)
{
GstCaps *caps = NULL;
- GstVaapiEncode * const encode = GST_VAAPI_ENCODE(GST_OBJECT_PARENT(sink_pad));
+ GstVaapiEncode * const encode =
+ GST_VAAPI_ENCODE(GST_OBJECT_PARENT(sink_pad));
+
if (encode->sinkpad_caps) {
gst_caps_ref(encode->sinkpad_caps);
- ENCODER_LOG_INFO("get caps,\n%s", _encode_dump_caps(encode->sinkpad_caps));
+ ENCODER_LOG_INFO("get caps,\n%s",
+ _encode_dump_caps(encode->sinkpad_caps));
return encode->sinkpad_caps;
}
caps = gst_caps_copy(gst_pad_get_pad_template_caps(sink_pad));
}
static GstStateChangeReturn
-gst_vaapi_encode_change_state(GstElement *element, GstStateChange transition)
+gst_vaapi_encode_change_state(
+ GstElement *element,
+ GstStateChange transition
+)
{
GstVaapiEncode * const encode = GST_VAAPI_ENCODE(element);
GstStateChangeReturn ret = GST_STATE_CHANGE_SUCCESS;
return GST_STATE_CHANGE_SUCCESS;
}
-
static GstFlowReturn
gst_vaapi_encode_chain(GstPad *sink_pad, GstBuffer *buf)
{
if (GST_VAAPI_IS_VIDEO_BUFFER(buf)) {
GstVaapiVideoBuffer *video_buffer = GST_VAAPI_VIDEO_BUFFER(buf);
ENCODER_ASSERT(video_buffer);
- ENCODER_ASSERT(gst_vaapi_video_buffer_get_display(video_buffer) == ENCODER_DISPLAY(encode->encoder));
+ ENCODER_ASSERT(gst_vaapi_video_buffer_get_display(video_buffer) ==
+ ENCODER_DISPLAY(encode->encoder));
}
encode->first_sink_frame = FALSE;
}
/*encoding frames*/
ENCODER_ASSERT(gst_vaapi_encoder_get_state(encode->encoder) >= VAAPI_ENC_OPENED);
encoder_ret = gst_vaapi_encoder_encode(encode->encoder, buf, &out_buffers);
- ENCODER_CHECK_STATUS (ENCODER_NO_ERROR == encoder_ret, GST_FLOW_ERROR, "gst_vaapi_encoder_encode failed.");
+ ENCODER_CHECK_STATUS (ENCODER_NO_ERROR == encoder_ret,
+ GST_FLOW_ERROR,
+ "gst_vaapi_encoder_encode failed.");
/*check results*/
while (out_buffers) {
GstBuffer *codec_data = NULL;
ENCODER_ASSERT(encode->srcpad_caps);
/*replace codec data in src pad caps*/
- if (ENCODER_NO_ERROR == gst_vaapi_encoder_get_codec_data(encode->encoder, &codec_data) && codec_data) {
- gst_caps_set_simple(encode->srcpad_caps, "codec_data",GST_TYPE_BUFFER, codec_data, NULL);
+ if ((ENCODER_NO_ERROR ==
+ gst_vaapi_encoder_get_codec_data(encode->encoder, &codec_data)) &&
+ codec_data) {
+ gst_caps_set_simple(encode->srcpad_caps,
+ "codec_data",GST_TYPE_BUFFER, codec_data,
+ NULL);
}
gst_pad_set_caps (encode->srcpad, encode->srcpad_caps);
+
GST_BUFFER_CAPS(tmp_buffer) = gst_caps_ref(encode->srcpad_caps);
- ENCODER_LOG_INFO("gst_vaapi_encode_chain 1st push-buffer caps,\n%s", _encode_dump_caps(encode->srcpad_caps));
+ ENCODER_LOG_INFO("gst_vaapi_encode_chain 1st push-buffer caps,\n%s",
+ _encode_dump_caps(encode->srcpad_caps));
encode->first_src_frame = FALSE;
}
- ENCODER_LOG_DEBUG("output:%" GST_TIME_FORMAT ", 0x%s",
- GST_TIME_ARGS(GST_BUFFER_TIMESTAMP(tmp_buffer)),
- vaapi_encoder_dump_bytes(GST_BUFFER_DATA(tmp_buffer),
- (GST_BUFFER_SIZE(tmp_buffer) > 16? 16: GST_BUFFER_SIZE(tmp_buffer))));
+ ENCODER_LOG_DEBUG(
+ "output:%" GST_TIME_FORMAT ", 0x%s",
+ GST_TIME_ARGS(GST_BUFFER_TIMESTAMP(tmp_buffer)),
+ vaapi_encoder_dump_bytes(GST_BUFFER_DATA(tmp_buffer),
+ (GST_BUFFER_SIZE(tmp_buffer) > 16 ?
+ 16: GST_BUFFER_SIZE(tmp_buffer)))
+ );
gst_pad_push(encode->srcpad, tmp_buffer);
}
}
static GstFlowReturn
-gst_vaapi_encode_buffer_alloc(GstPad * pad, guint64 offset, guint size,
- GstCaps * caps, GstBuffer ** buf)
+gst_vaapi_encode_buffer_alloc(
+ GstPad * pad,
+ guint64 offset,
+ guint size,
+ GstCaps * caps,
+ GstBuffer ** buf
+)
{
GstVaapiEncode * const encode = GST_VAAPI_ENCODE(GST_OBJECT_PARENT(pad));
GstStructure *structure = NULL;
if (caps) {
structure = gst_caps_get_structure(caps, 0);
}
- if (!structure || gst_structure_has_name(structure, "video/x-vaapi-surface")) {
+ if (!structure ||
+ gst_structure_has_name(structure, "video/x-vaapi-surface")) {
ENCODER_ASSERT(encode->encoder);
ENCODER_CHECK_STATUS(gst_vaapi_encode_ensure_display(encode),
- GST_FLOW_ERROR, "encoder ensure display failed.")
+ GST_FLOW_ERROR,
+ "encoder ensure display failed.")
display = ENCODER_DISPLAY(encode->encoder);
buffer = (GstBuffer*)gst_vaapi_video_buffer_new(display);
} else { /* video/x-raw-yuv */
buffer = gst_buffer_new_and_alloc(size);
}
- ENCODER_CHECK_STATUS(buffer, GST_FLOW_ERROR, "gst_vaapi_encode_buffer_alloc failed.");
+ ENCODER_CHECK_STATUS(buffer,
+ GST_FLOW_ERROR,
+ "gst_vaapi_encode_buffer_alloc failed.");
GST_BUFFER_OFFSET (buffer) = offset;
if (caps) {
return ret;
}
+static void
+gst_vaapi_encode_finalize(GObject *object)
+{
+ GstVaapiEncode * const encode = GST_VAAPI_ENCODE(object);
-static char*
-_encode_dump_caps(GstCaps *cpas)
+ if (encode->sinkpad_caps) {
+ gst_caps_unref(encode->sinkpad_caps);
+ encode->sinkpad_caps = NULL;
+ }
+ encode->sinkpad = NULL;
+
+ if (encode->srcpad_caps) {
+ gst_caps_unref(encode->srcpad_caps);
+ encode->srcpad_caps = NULL;
+ }
+ encode->srcpad = NULL;
+
+ if (encode->encoder) {
+ gst_vaapi_encoder_close(encode->encoder);
+ gst_vaapi_encoder_uninitialize(encode->encoder);
+ gst_vaapi_encoder_unref(encode->encoder);
+ encode->encoder = NULL;
+ }
+
+ G_OBJECT_CLASS(parent_class)->finalize(object);
+}
+
+static void
+gst_vaapi_encode_init(
+ GstVaapiEncode *encode,
+ GstVaapiEncodeClass *klass
+)
{
- guint i = 0, j = 0;
- GstStructure const *structure;
- GValue const *value;
- static char caps_string[4096*5];
- char *tmp;
+ GstElementClass * const element_class = GST_ELEMENT_CLASS(klass);
- char *cur = caps_string;
- memset(caps_string, 0, sizeof(caps_string));
- for (i = 0; i < gst_caps_get_size(cpas); i++) {
- structure = gst_caps_get_structure(cpas, i);
- const char* caps_name = gst_structure_get_name (structure);
- sprintf(cur, "cap_%02d:%s\n", i, caps_name);
- cur += strlen(cur);
+ encode->sinkpad_caps = NULL;
+ encode->srcpad_caps = NULL;
+ encode->first_sink_frame = TRUE;
+ encode->first_src_frame = TRUE;
- for (j = 0; j < gst_structure_n_fields(structure); j++) {
- const char* name = gst_structure_nth_field_name(structure, j);
- value = gst_structure_get_value(structure, name);
- tmp = gst_value_serialize(value);
- sprintf(cur, "\t%s:%s(%s)\n", name, tmp, G_VALUE_TYPE_NAME(value));
- cur += strlen(cur);
- g_free(tmp);
- }
+ encode->encoder = NULL;
+
+ /*sink pad */
+ encode->sinkpad = gst_pad_new_from_template(
+ gst_element_class_get_pad_template(element_class, "sink"),
+ "sink"
+ );
+ gst_pad_set_getcaps_function(encode->sinkpad, gst_vaapi_encode_get_caps);
+ gst_pad_set_setcaps_function(encode->sinkpad, gst_vaapi_encode_set_caps);
+ gst_pad_set_chain_function(encode->sinkpad, gst_vaapi_encode_chain);
+ gst_pad_set_bufferalloc_function(encode->sinkpad,
+ gst_vaapi_encode_buffer_alloc);
+ /*gst_pad_set_event_function(encode->sinkpad, gst_vaapi_encode_sink_event); */
+ /*gst_pad_use_fixed_caps(encode->sinkpad);*/
+ gst_pad_set_query_function(encode->sinkpad, gst_vaapi_encode_query);
+ gst_element_add_pad(GST_ELEMENT(encode), encode->sinkpad);
+
+ /* src pad */
+ encode->srcpad = gst_pad_new_from_template(
+ gst_element_class_get_pad_template(element_class, "src"),
+ "src"
+ );
+ encode->srcpad_caps = NULL;
+
+ gst_pad_use_fixed_caps(encode->srcpad);
+ /*gst_pad_set_event_function(encode->srcpad, gst_vaapi_encode_src_event);*/
+ gst_pad_set_query_function(encode->sinkpad, gst_vaapi_encode_query);
+ gst_element_add_pad(GST_ELEMENT(encode), encode->srcpad);
+}
+
+static void
+gst_vaapi_encode_set_property(
+ GObject *object,
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec)
+{
+ GstVaapiEncode *encode = GST_VAAPI_ENCODE(object);
+ ENCODER_ASSERT(encode->encoder);
+
+ switch (prop_id) {
}
+}
- return caps_string;
+static void
+gst_vaapi_encode_get_property (
+ GObject * object,
+ guint prop_id,
+ GValue * value,
+ GParamSpec * pspec
+)
+{
+ GstVaapiEncode *encode = GST_VAAPI_ENCODE(object);
+ ENCODER_ASSERT(encode->encoder);
+
+ switch (prop_id) {
+ }
}
+static void
+gst_vaapi_encode_base_init(gpointer klass)
+{
+ #if 0
+ GstElementClass * const element_class = GST_ELEMENT_CLASS(klass);
+
+ gst_element_class_set_details(element_class, &gst_vaapi_encode_details);
+
+ /* sink pad */
+ gst_element_class_add_pad_template(
+ element_class,
+ gst_static_pad_template_get(&gst_vaapi_encode_sink_factory)
+ );
+
+ /* src pad */
+ gst_element_class_add_pad_template(
+ element_class,
+ gst_static_pad_template_get(&gst_vaapi_encode_src_factory)
+ );
+ #endif
+}
+
+static void
+gst_vaapi_encode_class_init(GstVaapiEncodeClass *klass)
+{
+ GObjectClass * const object_class = G_OBJECT_CLASS(klass);
+ GstElementClass * const element_class = GST_ELEMENT_CLASS(klass);
+
+ object_class->finalize = gst_vaapi_encode_finalize;
+ object_class->set_property = gst_vaapi_encode_set_property;
+ object_class->get_property = gst_vaapi_encode_get_property;
+
+ GST_DEBUG_CATEGORY_INIT (gst_vaapi_encode_debug,
+ "vaapiencode",
+ 0,
+ "vaapiencode element");
+
+ element_class->change_state = gst_vaapi_encode_change_state;
+
+ klass->set_encoder_src_caps = NULL;
+
+ /* Registering debug symbols for function pointers */
+ GST_DEBUG_REGISTER_FUNCPTR (gst_vaapi_encode_change_state);
+ GST_DEBUG_REGISTER_FUNCPTR (gst_vaapi_encode_get_caps);
+ GST_DEBUG_REGISTER_FUNCPTR (gst_vaapi_encode_set_caps);
+ GST_DEBUG_REGISTER_FUNCPTR (gst_vaapi_encode_chain);
+ GST_DEBUG_REGISTER_FUNCPTR (gst_vaapi_encode_buffer_alloc);
+}
"height = (int) [ 1, MAX ]; "
-#define GST_TYPE_VAAPI_ENCODE (gst_vaapi_encode_get_type())
-#define GST_IS_VAAPI_ENCODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GST_TYPE_VAAPI_ENCODE))
-#define GST_IS_VAAPI_ENCODE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GST_TYPE_VAAPI_ENCODE))
-#define GST_VAAPI_ENCODE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GST_TYPE_VAAPI_ENCODE, GstVaapiEncodeClass))
-#define GST_VAAPI_ENCODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GST_TYPE_VAAPI_ENCODE, GstVaapiEncode))
-#define GST_VAAPI_ENCODE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GST_TYPE_VAAPI_ENCODE, GstVaapiEncodeClass))
+#define GST_TYPE_VAAPI_ENCODE \
+ (gst_vaapi_encode_get_type())
+#define GST_IS_VAAPI_ENCODE(obj) \
+ (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GST_TYPE_VAAPI_ENCODE))
+
+#define GST_IS_VAAPI_ENCODE_CLASS(klass) \
+ (G_TYPE_CHECK_CLASS_TYPE ((klass), GST_TYPE_VAAPI_ENCODE))
+
+#define GST_VAAPI_ENCODE_GET_CLASS(obj) \
+ (G_TYPE_INSTANCE_GET_CLASS ((obj), \
+ GST_TYPE_VAAPI_ENCODE, \
+ GstVaapiEncodeClass))
+
+#define GST_VAAPI_ENCODE(obj) \
+ (G_TYPE_CHECK_INSTANCE_CAST ((obj), \
+ GST_TYPE_VAAPI_ENCODE, \
+ GstVaapiEncode))
+
+#define GST_VAAPI_ENCODE_CLASS(klass) \
+ (G_TYPE_CHECK_CLASS_CAST ((klass), \
+ GST_TYPE_VAAPI_ENCODE, \
+ GstVaapiEncodeClass))
typedef struct _GstVaapiEncode GstVaapiEncode;
typedef struct _GstVaapiEncodeClass GstVaapiEncodeClass;
GST_DEBUG_CATEGORY_STATIC (gst_vaapi_h263_encode_debug);
#define GST_CAT_DEFAULT gst_vaapi_h263_encode_debug
-#define GST_VAAPI_ENCODE_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GST_TYPE_VAAPI_ENCODE, GstVaapiEncodePrivate))
+#define GST_VAAPI_ENCODE_GET_PRIVATE(obj) \
+ (G_TYPE_INSTANCE_GET_PRIVATE ((obj), \
+ GST_TYPE_VAAPI_ENCODE, \
+ GstVaapiEncodePrivate))
static const char gst_vaapi_encode_h263_sink_caps_str[] =
GST_VAAPI_SURFACE_CAPS;
GST_PAD_ALWAYS,
GST_STATIC_CAPS(gst_vaapi_encode_h263_src_caps_str));
-static void gst_vaapi_encode_h263_set_property(GObject *object, guint prop_id,
- const GValue *value, GParamSpec *pspec);
-static void gst_vaapi_encode_h263_get_property (GObject * object, guint prop_id,
- GValue * value, GParamSpec * pspec);
-
/* h263 encode */
GST_BOILERPLATE(
GstVaapiEncodeH263,
gst_vaapi_encode_h263,
GstVaapiEncode,
- GST_TYPE_VAAPI_ENCODE);
+ GST_TYPE_VAAPI_ENCODE)
enum {
H263_PROP_0,
H263_PROP_MIN_QP,
};
-
-static void
-gst_vaapi_encode_h263_base_init(gpointer klass)
-{
- GstElementClass * const element_class = GST_ELEMENT_CLASS(klass);
-
- gst_element_class_set_details(element_class, &gst_vaapi_encode_h263_details);
-
- /* sink pad */
- gst_element_class_add_pad_template(
- element_class,
- gst_static_pad_template_get(&gst_vaapi_encode_h263_sink_factory)
- );
-
- /* src pad */
- gst_element_class_add_pad_template(
- element_class,
- gst_static_pad_template_get(&gst_vaapi_encode_h263_src_factory)
- );
-}
-
-static void
-gst_vaapi_encode_h263_class_init(GstVaapiEncodeH263Class *klass)
-{
- GObjectClass * const object_class = G_OBJECT_CLASS(klass);
-
- GST_DEBUG_CATEGORY_INIT (gst_vaapi_h263_encode_debug, "vaapih263encode", 0,
- "vaapih263encode element");
-
- GST_DEBUG_CATEGORY_INIT (gst_vaapi_h263_encode_debug, "vaapih263encode", 0,
- "vaapih263encode element");
-
- /* object_class->finalize = gst_vaapi_encode_h263_finalize; */
- object_class->set_property = gst_vaapi_encode_h263_set_property;
- object_class->get_property = gst_vaapi_encode_h263_get_property;
-
- g_object_class_install_property (object_class, H263_PROP_BITRATE,
- g_param_spec_uint ("bitrate",
- "H263 encoding bitrate",
- "H263 encoding bitrate, 10k~100M, (0, auto-calculate)",
- 0,
- 100*1000*1000,
- 0,
- G_PARAM_READWRITE));
- g_object_class_install_property (object_class, H263_PROP_INTRA_PERIOD,
- g_param_spec_uint ("intra-period",
- "H263 encoding intra-period",
- "H263 encoding intra-period",
- 1,
- 300,
- H263_DEFAULT_INTRA_PERIOD,
- G_PARAM_READWRITE));
- g_object_class_install_property (object_class, H263_PROP_INIT_QP,
- g_param_spec_uint ("init-qp",
- "H263 init-qp",
- "H263 init-qp",
- 1,
- 51,
- H263_DEFAULT_INIT_QP,
- G_PARAM_READWRITE));
- g_object_class_install_property (object_class, H263_PROP_MIN_QP,
- g_param_spec_uint ("min-qp",
- "H263 min-qp",
- "H263 min-qp",
- 1,
- 51,
- H263_DEFAULT_MIN_QP,
- G_PARAM_READWRITE));
-
-}
-
static void
-gst_vaapi_encode_h263_init(GstVaapiEncodeH263 *h263_encode, GstVaapiEncodeH263Class *klass)
+gst_vaapi_encode_h263_init(
+ GstVaapiEncodeH263 *h263_encode,
+ GstVaapiEncodeH263Class *klass
+)
{
GstVaapiEncode *encode = GST_VAAPI_ENCODE(h263_encode);
encode->encoder = GST_VAAPI_ENCODER(gst_vaapi_encoder_h263_new());
}
static void
-gst_vaapi_encode_h263_set_property(GObject *object, guint prop_id,
- const GValue *value, GParamSpec *pspec)
+gst_vaapi_encode_h263_set_property(
+ GObject *object,
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec
+)
{
- GstVaapiEncode *encode = GST_VAAPI_ENCODE(object);
- GstVaapiEncoderH263 *h263encoder = GST_VAAPI_ENCODER_H263(encode->encoder);
+ GstVaapiEncode *base = GST_VAAPI_ENCODE(object);
+ GstVaapiEncoderH263 *encoder = GST_VAAPI_ENCODER_H263(base->encoder);
- ENCODER_ASSERT(h263encoder);
+ ENCODER_ASSERT(encoder);
switch (prop_id) {
case H263_PROP_BITRATE: {
- h263encoder->bitrate = g_value_get_uint(value);
+ encoder->bitrate = g_value_get_uint(value);
}
break;
case H263_PROP_INTRA_PERIOD: {
- h263encoder->intra_period = g_value_get_uint(value);
+ encoder->intra_period = g_value_get_uint(value);
}
break;
case H263_PROP_INIT_QP: {
- h263encoder->init_qp = g_value_get_uint(value);
+ encoder->init_qp = g_value_get_uint(value);
}
break;
case H263_PROP_MIN_QP: {
- h263encoder->min_qp = g_value_get_uint(value);
+ encoder->min_qp = g_value_get_uint(value);
}
break;
}
static void
-gst_vaapi_encode_h263_get_property (GObject * object, guint prop_id,
- GValue * value, GParamSpec * pspec)
+gst_vaapi_encode_h263_get_property (
+ GObject * object,
+ guint prop_id,
+ GValue * value,
+ GParamSpec * pspec
+)
{
- GstVaapiEncode *encode = GST_VAAPI_ENCODE(object);
- GstVaapiEncoderH263 *h263encoder = GST_VAAPI_ENCODER_H263(encode->encoder);
- ENCODER_ASSERT(h263encoder);
+ GstVaapiEncode *base = GST_VAAPI_ENCODE(object);
+ GstVaapiEncoderH263 *encoder = GST_VAAPI_ENCODER_H263(base->encoder);
+ ENCODER_ASSERT(encoder);
switch (prop_id) {
case H263_PROP_BITRATE:
- g_value_set_uint (value, h263encoder->bitrate);
+ g_value_set_uint (value, encoder->bitrate);
break;
case H263_PROP_INTRA_PERIOD:
- g_value_set_uint (value, h263encoder->intra_period);
+ g_value_set_uint (value, encoder->intra_period);
break;
case H263_PROP_INIT_QP:
- g_value_set_uint (value, h263encoder->init_qp);
+ g_value_set_uint (value, encoder->init_qp);
break;
case H263_PROP_MIN_QP:
- g_value_set_uint (value, h263encoder->min_qp);
+ g_value_set_uint (value, encoder->min_qp);
break;
default:
}
}
+static void
+gst_vaapi_encode_h263_base_init(gpointer klass)
+{
+ GstElementClass * const element_class = GST_ELEMENT_CLASS(klass);
+
+ gst_element_class_set_details(element_class, &gst_vaapi_encode_h263_details);
+
+ /* sink pad */
+ gst_element_class_add_pad_template(
+ element_class,
+ gst_static_pad_template_get(&gst_vaapi_encode_h263_sink_factory)
+ );
+
+ /* src pad */
+ gst_element_class_add_pad_template(
+ element_class,
+ gst_static_pad_template_get(&gst_vaapi_encode_h263_src_factory)
+ );
+}
+
+static void
+gst_vaapi_encode_h263_class_init(GstVaapiEncodeH263Class *klass)
+{
+ GObjectClass * const object_class = G_OBJECT_CLASS(klass);
+
+ GST_DEBUG_CATEGORY_INIT (gst_vaapi_h263_encode_debug,
+ "vaapih263encode",
+ 0,
+ "vaapih263encode element");
+
+ /* object_class->finalize = gst_vaapi_encode_h263_finalize; */
+ object_class->set_property = gst_vaapi_encode_h263_set_property;
+ object_class->get_property = gst_vaapi_encode_h263_get_property;
+
+ g_object_class_install_property (
+ object_class,
+ H263_PROP_BITRATE,
+ g_param_spec_uint (
+ "bitrate",
+ "H263 encoding bitrate",
+ "H263 encoding bitrate, 10k~100M, (0, auto-calculate)",
+ 0,
+ 100*1000*1000,
+ 0,
+ G_PARAM_READWRITE));
+
+ g_object_class_install_property (
+ object_class,
+ H263_PROP_INTRA_PERIOD,
+ g_param_spec_uint (
+ "intra-period",
+ "H263 encoding intra-period",
+ "H263 encoding intra-period",
+ 1,
+ 300,
+ H263_DEFAULT_INTRA_PERIOD,
+ G_PARAM_READWRITE));
+
+ g_object_class_install_property (
+ object_class,
+ H263_PROP_INIT_QP,
+ g_param_spec_uint (
+ "init-qp",
+ "H263 init-qp",
+ "H263 init-qp",
+ 1,
+ 51,
+ H263_DEFAULT_INIT_QP,
+ G_PARAM_READWRITE));
+
+ g_object_class_install_property (
+ object_class,
+ H263_PROP_MIN_QP,
+ g_param_spec_uint (
+ "min-qp",
+ "H263 min-qp",
+ "H263 min-qp",
+ 1,
+ 51,
+ H263_DEFAULT_MIN_QP,
+ G_PARAM_READWRITE));
+
+}
* Boston, MA 02110-1301 USA
*/
-#ifndef GST_VAAPI_H263_ENCODE_H
-#define GST_VAAPI_H263_ENCODE_H
+#ifndef GST_VAAPI_ENCODE_H263_H
+#define GST_VAAPI_ENCODE_H263_H
#include <gst/gst.h>
#include "gstvaapiencode.h"
G_BEGIN_DECLS
-#define GST_TYPE_VAAPI_ENCODE_H263 (gst_vaapi_encode_h263_get_type())
-#define GST_IS_VAAPI_ENCODE_H263(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GST_TYPE_VAAPI_ENCODE_H263))
-#define GST_IS_VAAPI_ENCODE_H263_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GST_TYPE_VAAPI_ENCODE_H263))
-#define GST_VAAPI_ENCODE_H263_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GST_TYPE_VAAPI_ENCODE_H263, GstVaapiEncodeH263Class))
-#define GST_VAAPI_ENCODE_H263(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GST_TYPE_VAAPI_ENCODE_H263, GstVaapiEncodeH263))
-#define GST_VAAPI_ENCODE_H263_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GST_TYPE_VAAPI_ENCODE_H263, GstVaapiEncodeH263Class))
+#define GST_TYPE_VAAPI_ENCODE_H263 \
+ (gst_vaapi_encode_h263_get_type())
+#define GST_IS_VAAPI_ENCODE_H263(obj) \
+ (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GST_TYPE_VAAPI_ENCODE_H263))
+
+#define GST_IS_VAAPI_ENCODE_H263_CLASS(klass) \
+ (G_TYPE_CHECK_CLASS_TYPE ((klass), GST_TYPE_VAAPI_ENCODE_H263))
+
+#define GST_VAAPI_ENCODE_H263_GET_CLASS(obj) \
+ (G_TYPE_INSTANCE_GET_CLASS ((obj), \
+ GST_TYPE_VAAPI_ENCODE_H263, \
+ GstVaapiEncodeH263Class))
+
+#define GST_VAAPI_ENCODE_H263(obj) \
+ (G_TYPE_CHECK_INSTANCE_CAST ((obj), \
+ GST_TYPE_VAAPI_ENCODE_H263, \
+ GstVaapiEncodeH263))
+
+#define GST_VAAPI_ENCODE_H263_CLASS(klass) \
+ (G_TYPE_CHECK_CLASS_CAST ((klass), \
+ GST_TYPE_VAAPI_ENCODE_H263, \
+ GstVaapiEncodeH263Class))
typedef struct _GstVaapiEncodeH263 GstVaapiEncodeH263;
typedef struct _GstVaapiEncodeH263Class GstVaapiEncodeH263Class;
GType gst_vaapi_encode_h263_get_type(void);
-
G_END_DECLS
-#endif /* GST_VAAPI_H263_ENCODE_H */
-
+#endif /* GST_VAAPI_ENCODE_H263_H */
GST_PAD_ALWAYS,
GST_STATIC_CAPS(gst_vaapi_encode_h264_src_caps_str));
-static void gst_vaapi_encode_h264_finalize(GObject *object);
-static void gst_vaapi_encode_h264_set_property(GObject *object, guint prop_id,
- const GValue *value, GParamSpec *pspec);
-static void gst_vaapi_encode_h264_get_property (GObject * object, guint prop_id,
- GValue * value, GParamSpec * pspec);
-static gboolean _h264_check_valid_profile(guint profile);
-static gboolean _h264_check_valid_level(guint level);
-static gboolean gst_vaapi_encode_h264_set_src_caps(GstVaapiEncode* encode, GstCaps *caps);
-
-
/* h264 encode */
GST_BOILERPLATE(
GstVaapiEncodeH264,
gst_vaapi_encode_h264,
GstVaapiEncode,
- GST_TYPE_VAAPI_ENCODE);
+ GST_TYPE_VAAPI_ENCODE)
enum {
H264_PROP_0,
H264_PROP_B_FRAME_NUM,
};
-
static void
-gst_vaapi_encode_h264_base_init(gpointer klass)
-{
- GstElementClass * const element_class = GST_ELEMENT_CLASS(klass);
-
- gst_element_class_set_details(element_class, &gst_vaapi_encode_h264_details);
-
- /* sink pad */
- gst_element_class_add_pad_template(
- element_class,
- gst_static_pad_template_get(&gst_vaapi_encode_h264_sink_factory)
- );
-
- /* src pad */
- gst_element_class_add_pad_template(
- element_class,
- gst_static_pad_template_get(&gst_vaapi_encode_h264_src_factory)
- );
-}
-
-static void
-gst_vaapi_encode_h264_class_init(GstVaapiEncodeH264Class *klass)
-{
- GObjectClass * const object_class = G_OBJECT_CLASS(klass);
- GstVaapiEncodeClass *const encode_class = GST_VAAPI_ENCODE_CLASS(klass);
- GST_DEBUG_CATEGORY_INIT (gst_vaapi_h264_encode_debug, "vaapih264encode", 0,
- "vaapih264encode element");
-
- GST_DEBUG_CATEGORY_INIT (gst_vaapi_h264_encode_debug, "vaapih264encode", 0,
- "vaapih264encode element");
-
- object_class->finalize = gst_vaapi_encode_h264_finalize;
- object_class->set_property = gst_vaapi_encode_h264_set_property;
- object_class->get_property = gst_vaapi_encode_h264_get_property;
-
- encode_class->set_encoder_src_caps = gst_vaapi_encode_h264_set_src_caps;
-
- g_object_class_install_property (object_class, H264_PROP_PROFILE,
- g_param_spec_uint ("profile",
- "H264 Profile",
- "Profile supports: 66(Baseline), 77(Main), 100(High)",
- H264_PROFILE_BASELINE,
- H264_PROFILE_HIGH10,
- H264_DEFAULT_PROFILE,
- G_PARAM_READWRITE));
- g_object_class_install_property (object_class, H264_PROP_LEVEL,
- g_param_spec_uint ("level",
- "H264 level idc",
- "Level idc supports: 10, 11, 12, 13, 20, 21, 22, 30, 31, 32, 40, 41",
- H264_LEVEL_10,
- H264_LEVEL_41,
- H264_DEFAULT_LEVEL,
- G_PARAM_READWRITE));
- g_object_class_install_property (object_class, H264_PROP_BITRATE,
- g_param_spec_uint ("bitrate",
- "H264 encoding bitrate",
- "H264 encoding bitrate, 10k~100M, (0, auto-calculate)",
- 0,
- 100*1000*1000,
- 0,
- G_PARAM_READWRITE));
- g_object_class_install_property (object_class, H264_PROP_INTRA_PERIOD,
- g_param_spec_uint ("intra-period",
- "H264 encoding intra-period",
- "H264 encoding intra-period",
- 1,
- 300,
- H264_DEFAULT_INTRA_PERIOD,
- G_PARAM_READWRITE));
- g_object_class_install_property (object_class, H264_PROP_INIT_QP,
- g_param_spec_uint ("init-qp",
- "H264 init-qp",
- "H264 init-qp",
- 1,
- 51,
- H264_DEFAULT_INIT_QP,
- G_PARAM_READWRITE));
- g_object_class_install_property (object_class, H264_PROP_MIN_QP,
- g_param_spec_uint ("min-qp",
- "H264 min-qp",
- "H264 min-qp",
- 1,
- 51,
- H264_DEFAULT_MIN_QP,
- G_PARAM_READWRITE));
- g_object_class_install_property (object_class, H264_PROP_SLICE_NUM,
- g_param_spec_uint ("slice-num",
- "H264 slice num",
- "H264 slice num",
- 1,
- 200,
- 1,
- G_PARAM_READWRITE));
- g_object_class_install_property (object_class, H264_PROP_B_FRAME_NUM,
- g_param_spec_uint ("b-frame-num",
- "B frams num",
- "B frams num",
- 0,
- 10,
- 0,
- G_PARAM_READWRITE));
-
-}
-
-static void
-gst_vaapi_encode_h264_init(GstVaapiEncodeH264 *h264_encode, GstVaapiEncodeH264Class *klass)
+gst_vaapi_encode_h264_init(
+ GstVaapiEncodeH264 *h264_encode,
+ GstVaapiEncodeH264Class *klass
+)
{
GstVaapiEncode *encode = GST_VAAPI_ENCODE(h264_encode);
encode->encoder = GST_VAAPI_ENCODER(gst_vaapi_encoder_h264_new());
G_OBJECT_CLASS(parent_class)->finalize(object);
}
+
+static inline gboolean
+h264_check_valid_profile(guint profile)
+{
+ static const guint limit_profiles[] = {
+ H264_PROFILE_BASELINE,
+ H264_PROFILE_MAIN,
+ H264_PROFILE_HIGH
+ };
+ guint n_profiles = sizeof(limit_profiles)/sizeof(limit_profiles[0]);
+ guint i;
+ for (i = 0; i < n_profiles; ++i) {
+ if (limit_profiles[i] == profile)
+ return TRUE;
+ }
+ return FALSE;
+}
+
+static inline gboolean
+h264_check_valid_level(guint level)
+{
+ static const guint limit_levels[] = {
+ H264_LEVEL_10,
+ H264_LEVEL_11,
+ H264_LEVEL_12,
+ H264_LEVEL_13,
+ H264_LEVEL_20,
+ H264_LEVEL_21,
+ H264_LEVEL_22,
+ H264_LEVEL_30,
+ H264_LEVEL_31,
+ H264_LEVEL_32,
+ H264_LEVEL_40,
+ H264_LEVEL_41,
+ H264_LEVEL_42,
+ H264_LEVEL_50,
+ H264_LEVEL_51
+ };
+ guint n_levels = sizeof(limit_levels)/sizeof(limit_levels[0]);
+ guint i;
+ for (i = 0; i < n_levels; ++i) {
+ if (limit_levels[i] == level)
+ return TRUE;
+ }
+ return FALSE;
+
+}
+
+
static void
-gst_vaapi_encode_h264_set_property(GObject *object, guint prop_id,
- const GValue *value, GParamSpec *pspec)
+gst_vaapi_encode_h264_set_property(
+ GObject *object,
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec
+)
{
GstVaapiEncode *encode = GST_VAAPI_ENCODE(object);
GstVaapiEncoderH264 *h264encoder = GST_VAAPI_ENCODER_H264(encode->encoder);
switch (prop_id) {
case H264_PROP_PROFILE: {
guint profile = g_value_get_uint(value);
- if (_h264_check_valid_profile(profile)) {
+ if (h264_check_valid_profile(profile)) {
h264encoder->profile = profile;
} else {
ENCODER_LOG_ERROR("h264encode set property <profile> failed.");
case H264_PROP_LEVEL: {
guint level = g_value_get_uint(value);
- if (_h264_check_valid_level(level)) {
+ if (h264_check_valid_level(level)) {
h264encoder->level= level;
} else {
ENCODER_LOG_ERROR("h264encode set property <level> failed.");
}
static void
-gst_vaapi_encode_h264_get_property (GObject * object, guint prop_id,
- GValue * value, GParamSpec * pspec)
+gst_vaapi_encode_h264_get_property (
+ GObject * object,
+ guint prop_id,
+ GValue * value,
+ GParamSpec * pspec
+)
{
GstVaapiEncode *encode = GST_VAAPI_ENCODE(object);
GstVaapiEncoderH264 *h264encoder = GST_VAAPI_ENCODER_H264(encode->encoder);
}
}
-
static gboolean
-_h264_check_valid_profile(guint profile)
-{
- static const guint limit_profiles[] = {
- H264_PROFILE_BASELINE,
- H264_PROFILE_MAIN,
- H264_PROFILE_HIGH
- };
- guint n_profiles = sizeof(limit_profiles)/sizeof(limit_profiles[0]);
- guint i;
- for (i = 0; i < n_profiles; ++i) {
- if (limit_profiles[i] == profile)
- return TRUE;
- }
- return FALSE;
-}
-
-static gboolean
-_h264_check_valid_level(guint level)
-{
- static const guint limit_levels[] = {
- H264_LEVEL_10,
- H264_LEVEL_11,
- H264_LEVEL_12,
- H264_LEVEL_13,
- H264_LEVEL_20,
- H264_LEVEL_21,
- H264_LEVEL_22,
- H264_LEVEL_30,
- H264_LEVEL_31,
- H264_LEVEL_32,
- H264_LEVEL_40,
- H264_LEVEL_41,
- H264_LEVEL_42,
- H264_LEVEL_50,
- H264_LEVEL_51
- };
- guint n_levels = sizeof(limit_levels)/sizeof(limit_levels[0]);
- guint i;
- for (i = 0; i < n_levels; ++i) {
- if (limit_levels[i] == level)
- return TRUE;
- }
- return FALSE;
-
-}
-
-
-static gboolean
-gst_vaapi_encode_h264_set_src_caps(GstVaapiEncode* encode, GstCaps *caps)
+gst_vaapi_encode_h264_set_src_caps(
+ GstVaapiEncode* encode,
+ GstCaps *caps
+)
{
GstVaapiEncoderH264 *h264encoder = GST_VAAPI_ENCODER_H264(encode->encoder);
GstCaps *peer_caps, *allowed_caps;
return TRUE;
}
+static void
+gst_vaapi_encode_h264_base_init(gpointer klass)
+{
+ GstElementClass * const element_class = GST_ELEMENT_CLASS(klass);
+
+ gst_element_class_set_details(element_class, &gst_vaapi_encode_h264_details);
+
+ /* sink pad */
+ gst_element_class_add_pad_template(
+ element_class,
+ gst_static_pad_template_get(&gst_vaapi_encode_h264_sink_factory)
+ );
+
+ /* src pad */
+ gst_element_class_add_pad_template(
+ element_class,
+ gst_static_pad_template_get(&gst_vaapi_encode_h264_src_factory)
+ );
+}
+
+static void
+gst_vaapi_encode_h264_class_init(GstVaapiEncodeH264Class *klass)
+{
+ GObjectClass * const object_class = G_OBJECT_CLASS(klass);
+ GstVaapiEncodeClass *const encode_class = GST_VAAPI_ENCODE_CLASS(klass);
+ GST_DEBUG_CATEGORY_INIT (gst_vaapi_h264_encode_debug,
+ "vaapih264encode",
+ 0,
+ "vaapih264encode element");
+
+ object_class->finalize = gst_vaapi_encode_h264_finalize;
+ object_class->set_property = gst_vaapi_encode_h264_set_property;
+ object_class->get_property = gst_vaapi_encode_h264_get_property;
+
+ encode_class->set_encoder_src_caps = gst_vaapi_encode_h264_set_src_caps;
+ g_object_class_install_property (
+ object_class,
+ H264_PROP_PROFILE,
+ g_param_spec_uint (
+ "profile",
+ "H264 Profile",
+ "Profile supports: 66(Baseline), 77(Main), 100(High)",
+ H264_PROFILE_BASELINE,
+ H264_PROFILE_HIGH10,
+ H264_DEFAULT_PROFILE,
+ G_PARAM_READWRITE));
+
+ g_object_class_install_property (
+ object_class,
+ H264_PROP_LEVEL,
+ g_param_spec_uint (
+ "level",
+ "H264 level idc",
+ "Level idc supports: 10, 11, 12, 13, 20, 21, 22, 30, 31, 32, 40, 41",
+ H264_LEVEL_10,
+ H264_LEVEL_41,
+ H264_DEFAULT_LEVEL,
+ G_PARAM_READWRITE));
+
+ g_object_class_install_property (
+ object_class,
+ H264_PROP_BITRATE,
+ g_param_spec_uint (
+ "bitrate",
+ "H264 encoding bitrate",
+ "H264 encoding bitrate, 10k~100M, (0, auto-calculate)",
+ 0,
+ 100*1000*1000,
+ 0,
+ G_PARAM_READWRITE));
+
+ g_object_class_install_property (
+ object_class,
+ H264_PROP_INTRA_PERIOD,
+ g_param_spec_uint (
+ "intra-period",
+ "H264 encoding intra-period",
+ "H264 encoding intra-period",
+ 1,
+ 300,
+ H264_DEFAULT_INTRA_PERIOD,
+ G_PARAM_READWRITE));
+
+ g_object_class_install_property (
+ object_class,
+ H264_PROP_INIT_QP,
+ g_param_spec_uint (
+ "init-qp",
+ "H264 init-qp",
+ "H264 init-qp",
+ 1,
+ 51,
+ H264_DEFAULT_INIT_QP,
+ G_PARAM_READWRITE));
+
+ g_object_class_install_property (
+ object_class,
+ H264_PROP_MIN_QP,
+ g_param_spec_uint (
+ "min-qp",
+ "H264 min-qp",
+ "H264 min-qp",
+ 1,
+ 51,
+ H264_DEFAULT_MIN_QP,
+ G_PARAM_READWRITE));
+
+ g_object_class_install_property (
+ object_class,
+ H264_PROP_SLICE_NUM,
+ g_param_spec_uint (
+ "slice-num",
+ "H264 slice num",
+ "H264 slice num",
+ 1,
+ 200,
+ 1,
+ G_PARAM_READWRITE));
+
+ g_object_class_install_property (
+ object_class,
+ H264_PROP_B_FRAME_NUM,
+ g_param_spec_uint (
+ "b-frame-num",
+ "B frams num",
+ "B frams num",
+ 0,
+ 10,
+ 0,
+ G_PARAM_READWRITE));
+}
* Boston, MA 02110-1301 USA
*/
-#ifndef GST_VAAPI_H264_ENCODE_H
-#define GST_VAAPI_H264_ENCODE_H
+#ifndef GST_VAAPI_ENCODE_H264_H
+#define GST_VAAPI_ENCODE_H264_H
#include <gst/gst.h>
#include "gstvaapiencode.h"
G_BEGIN_DECLS
-#define GST_TYPE_VAAPI_ENCODE_H264 (gst_vaapi_encode_h264_get_type())
-#define GST_IS_VAAPI_ENCODE_H264(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GST_TYPE_VAAPI_ENCODE_H264))
-#define GST_IS_VAAPI_ENCODE_H264_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GST_TYPE_VAAPI_ENCODE_H264))
-#define GST_VAAPI_ENCODE_H264_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GST_TYPE_VAAPI_ENCODE_H264, GstVaapiEncodeH264Class))
-#define GST_VAAPI_ENCODE_H264(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GST_TYPE_VAAPI_ENCODE_H264, GstVaapiEncodeH264))
-#define GST_VAAPI_ENCODE_H264_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GST_TYPE_VAAPI_ENCODE_H264, GstVaapiEncodeH264Class))
+#define GST_TYPE_VAAPI_ENCODE_H264 \
+ (gst_vaapi_encode_h264_get_type())
+
+#define GST_IS_VAAPI_ENCODE_H264(obj) \
+ (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GST_TYPE_VAAPI_ENCODE_H264))
+
+#define GST_IS_VAAPI_ENCODE_H264_CLASS(klass) \
+ (G_TYPE_CHECK_CLASS_TYPE ((klass), GST_TYPE_VAAPI_ENCODE_H264))
+
+#define GST_VAAPI_ENCODE_H264_GET_CLASS(obj) \
+ (G_TYPE_INSTANCE_GET_CLASS ((obj), \
+ GST_TYPE_VAAPI_ENCODE_H264, \
+ GstVaapiEncodeH264Class))
+
+#define GST_VAAPI_ENCODE_H264(obj) \
+ (G_TYPE_CHECK_INSTANCE_CAST ((obj), \
+ GST_TYPE_VAAPI_ENCODE_H264, \
+ GstVaapiEncodeH264))
+
+#define GST_VAAPI_ENCODE_H264_CLASS(klass) \
+ (G_TYPE_CHECK_CLASS_CAST ((klass), \
+ GST_TYPE_VAAPI_ENCODE_H264, \
+ GstVaapiEncodeH264Class))
typedef struct _GstVaapiEncodeH264 GstVaapiEncodeH264;
GType gst_vaapi_encode_h264_get_type(void);
-
G_END_DECLS
-#endif /* GST_VAAPI_H264_ENCODE_H */
-
+#endif /* GST_VAAPI_ENCODE_H264_H */
GST_PAD_ALWAYS,
GST_STATIC_CAPS(gst_vaapi_encode_mpeg4_src_caps_str));
-static void gst_vaapi_encode_mpeg4_finalize(GObject *object);
-static void gst_vaapi_encode_mpeg4_set_property(GObject *object, guint prop_id,
- const GValue *value, GParamSpec *pspec);
-static void gst_vaapi_encode_mpeg4_get_property (GObject * object, guint prop_id,
- GValue * value, GParamSpec * pspec);
-
/* mpeg4 encode */
GST_BOILERPLATE(
GstVaapiEncodeMpeg4,
gst_vaapi_encode_mpeg4,
GstVaapiEncode,
- GST_TYPE_VAAPI_ENCODE);
+ GST_TYPE_VAAPI_ENCODE)
enum {
MPEG4_PROP_0,
MPEG4_PROP_MIN_QP,
};
-
-static void
-gst_vaapi_encode_mpeg4_base_init(gpointer klass)
-{
- GstElementClass * const element_class = GST_ELEMENT_CLASS(klass);
-
- gst_element_class_set_details(element_class, &gst_vaapi_encode_mpeg4_details);
-
- /* sink pad */
- gst_element_class_add_pad_template(
- element_class,
- gst_static_pad_template_get(&gst_vaapi_encode_mpeg4_sink_factory)
- );
-
- /* src pad */
- gst_element_class_add_pad_template(
- element_class,
- gst_static_pad_template_get(&gst_vaapi_encode_mpeg4_src_factory)
- );
-}
-
-static void
-gst_vaapi_encode_mpeg4_class_init(GstVaapiEncodeMpeg4Class *klass)
-{
- GObjectClass * const object_class = G_OBJECT_CLASS(klass);
-
- GST_DEBUG_CATEGORY_INIT (gst_vaapi_encode_mpeg4_debug, "vaapimpeg4encode", 0,
- "vaapimpeg4encode element");
-
- object_class->finalize = gst_vaapi_encode_mpeg4_finalize;
- object_class->set_property = gst_vaapi_encode_mpeg4_set_property;
- object_class->get_property = gst_vaapi_encode_mpeg4_get_property;
-
-
- g_object_class_install_property (object_class, MPEG4_PROP_PROFILE,
- g_param_spec_uint ("profile",
- "MPEG4 Profile",
- "Profile supports: 2(Baseline), 3(ASP)",
- 2,
- 3,
- 2,
- G_PARAM_READWRITE));
- g_object_class_install_property (object_class, MPEG4_PROP_BITRATE,
- g_param_spec_uint ("bitrate",
- "MPEG4 encoding bitrate",
- "MPEG4 encoding bitrate, 10k~100M, (0, auto-calculate)",
- 0,
- 100*1000*1000,
- 0,
- G_PARAM_READWRITE));
- g_object_class_install_property (object_class, MPEG4_PROP_INTRA_PERIOD,
- g_param_spec_uint ("intra-period",
- "MPEG4 encoding intra-period",
- "MPEG4 encoding intra-period",
- 1,
- 300,
- MPEG4_DEFAULT_INTRA_PERIOD,
- G_PARAM_READWRITE));
- g_object_class_install_property (object_class, MPEG4_PROP_INIT_QP,
- g_param_spec_uint ("init-qp",
- "MPEG4 init-qp",
- "MPEG4 init-qp",
- 1,
- 51,
- MPEG4_DEFAULT_INIT_QP,
- G_PARAM_READWRITE));
- g_object_class_install_property (object_class, MPEG4_PROP_MIN_QP,
- g_param_spec_uint ("min-qp",
- "MPEG4 min-qp",
- "MPEG4 min-qp",
- 1,
- 51,
- MPEG4_DEFAULT_MIN_QP,
- G_PARAM_READWRITE));
-
-}
-
static void
-gst_vaapi_encode_mpeg4_init(GstVaapiEncodeMpeg4 *mpeg4_encode, GstVaapiEncodeMpeg4Class *klass)
+gst_vaapi_encode_mpeg4_init(
+ GstVaapiEncodeMpeg4 *mpeg4_encode,
+ GstVaapiEncodeMpeg4Class *klass)
{
GstVaapiEncode *encode = GST_VAAPI_ENCODE(mpeg4_encode);
encode->encoder = GST_VAAPI_ENCODER(gst_vaapi_encoder_mpeg4_new());
}
static void
-gst_vaapi_encode_mpeg4_set_property(GObject *object, guint prop_id,
- const GValue *value, GParamSpec *pspec)
+gst_vaapi_encode_mpeg4_set_property(
+ GObject *object,
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec
+)
{
GstVaapiEncode *encode = GST_VAAPI_ENCODE(object);
GstVaapiEncoderMpeg4 *mpeg4encoder = GST_VAAPI_ENCODER_MPEG4(encode->encoder);
}
static void
-gst_vaapi_encode_mpeg4_get_property (GObject * object, guint prop_id,
- GValue * value, GParamSpec * pspec)
+gst_vaapi_encode_mpeg4_get_property(
+ GObject * object,
+ guint prop_id,
+ GValue * value,
+ GParamSpec * pspec
+)
{
GstVaapiEncode *encode = GST_VAAPI_ENCODE(object);
GstVaapiEncoderMpeg4 *mpeg4encoder = GST_VAAPI_ENCODER_MPEG4(encode->encoder);
}
}
+static void
+gst_vaapi_encode_mpeg4_base_init(gpointer klass)
+{
+ GstElementClass * const element_class = GST_ELEMENT_CLASS(klass);
+
+ gst_element_class_set_details(element_class, &gst_vaapi_encode_mpeg4_details);
+
+ /* sink pad */
+ gst_element_class_add_pad_template(
+ element_class,
+ gst_static_pad_template_get(&gst_vaapi_encode_mpeg4_sink_factory)
+ );
+
+ /* src pad */
+ gst_element_class_add_pad_template(
+ element_class,
+ gst_static_pad_template_get(&gst_vaapi_encode_mpeg4_src_factory)
+ );
+}
+
+static void
+gst_vaapi_encode_mpeg4_class_init(GstVaapiEncodeMpeg4Class *klass)
+{
+ GObjectClass * const object_class = G_OBJECT_CLASS(klass);
+
+ GST_DEBUG_CATEGORY_INIT (gst_vaapi_encode_mpeg4_debug,
+ "vaapimpeg4encode",
+ 0,
+ "vaapimpeg4encode element");
+
+ object_class->finalize = gst_vaapi_encode_mpeg4_finalize;
+ object_class->set_property = gst_vaapi_encode_mpeg4_set_property;
+ object_class->get_property = gst_vaapi_encode_mpeg4_get_property;
+
+
+ g_object_class_install_property (
+ object_class,
+ MPEG4_PROP_PROFILE,
+ g_param_spec_uint (
+ "profile",
+ "MPEG4 Profile",
+ "Profile supports: 2(Baseline), 3(ASP)",
+ 2,
+ 3,
+ 2,
+ G_PARAM_READWRITE));
+
+ g_object_class_install_property (
+ object_class,
+ MPEG4_PROP_BITRATE,
+ g_param_spec_uint (
+ "bitrate",
+ "MPEG4 encoding bitrate",
+ "MPEG4 encoding bitrate, 10k~100M, (0, auto-calculate)",
+ 0,
+ 100*1000*1000,
+ 0,
+ G_PARAM_READWRITE));
+
+ g_object_class_install_property (
+ object_class,
+ MPEG4_PROP_INTRA_PERIOD,
+ g_param_spec_uint (
+ "intra-period",
+ "MPEG4 encoding intra-period",
+ "MPEG4 encoding intra-period",
+ 1,
+ 300,
+ MPEG4_DEFAULT_INTRA_PERIOD,
+ G_PARAM_READWRITE));
+
+ g_object_class_install_property (
+ object_class,
+ MPEG4_PROP_INIT_QP,
+ g_param_spec_uint (
+ "init-qp",
+ "MPEG4 init-qp",
+ "MPEG4 init-qp",
+ 1,
+ 51,
+ MPEG4_DEFAULT_INIT_QP,
+ G_PARAM_READWRITE));
+
+ g_object_class_install_property (
+ object_class,
+ MPEG4_PROP_MIN_QP,
+ g_param_spec_uint (
+ "min-qp",
+ "MPEG4 min-qp",
+ "MPEG4 min-qp",
+ 1,
+ 51,
+ MPEG4_DEFAULT_MIN_QP,
+ G_PARAM_READWRITE));
+}
* Boston, MA 02110-1301 USA
*/
-#ifndef GST_VAAPI_MPEG4_ENCODE_H
-#define GST_VAAPI_MPEG4_ENCODE_H
+#ifndef GST_VAAPI_ENCODE_MPEG4_H
+#define GST_VAAPI_ENCODE_MPEG4_H
#include <gst/gst.h>
#include "gstvaapiencode.h"
G_BEGIN_DECLS
-#define GST_TYPE_VAAPI_ENCODE_MPEG4 (gst_vaapi_encode_mpeg4_get_type())
-#define GST_IS_VAAPI_ENCODE_MPEG4(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GST_TYPE_VAAPI_ENCODE_MPEG4))
-#define GST_IS_VAAPI_ENCODE_MPEG4_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GST_TYPE_VAAPI_ENCODE_MPEG4))
-#define GST_VAAPI_ENCODE_MPEG4_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GST_TYPE_VAAPI_ENCODE_MPEG4, GstVaapiEncodeMpeg4Class))
-#define GST_VAAPI_ENCODE_MPEG4(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GST_TYPE_VAAPI_ENCODE_MPEG4, GstVaapiEncodeMpeg4))
-#define GST_VAAPI_ENCODE_MPEG4_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GST_TYPE_VAAPI_ENCODE_MPEG4, GstVaapiEncodeMpeg4Class))
+#define GST_TYPE_VAAPI_ENCODE_MPEG4 \
+ (gst_vaapi_encode_mpeg4_get_type())
+
+#define GST_IS_VAAPI_ENCODE_MPEG4(obj) \
+ (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GST_TYPE_VAAPI_ENCODE_MPEG4))
+
+#define GST_IS_VAAPI_ENCODE_MPEG4_CLASS(klass) \
+ (G_TYPE_CHECK_CLASS_TYPE ((klass), GST_TYPE_VAAPI_ENCODE_MPEG4))
+
+#define GST_VAAPI_ENCODE_MPEG4_GET_CLASS(obj) \
+ (G_TYPE_INSTANCE_GET_CLASS ((obj), \
+ GST_TYPE_VAAPI_ENCODE_MPEG4, \
+ GstVaapiEncodeMpeg4Class))
+
+#define GST_VAAPI_ENCODE_MPEG4(obj) \
+ (G_TYPE_CHECK_INSTANCE_CAST ((obj), \
+ GST_TYPE_VAAPI_ENCODE_MPEG4, \
+ GstVaapiEncodeMpeg4))
+
+#define GST_VAAPI_ENCODE_MPEG4_CLASS(klass) \
+ (G_TYPE_CHECK_CLASS_CAST ((klass), \
+ GST_TYPE_VAAPI_ENCODE_MPEG4, \
+ GstVaapiEncodeMpeg4Class))
typedef struct _GstVaapiEncodeMpeg4 GstVaapiEncodeMpeg4;
GType gst_vaapi_encode_mpeg4_get_type(void);
-
G_END_DECLS
-#endif /* GST_VAAPI_MPEG4_ENCODE_H */
-
+#endif /* GST_VAAPI_ENCODE_MPEG4_H */
projects / profile / ivi / gstreamer-vaapi.git / commitdiff