change encoder log output format, support GST log

diff --git a/gst/vaapiencode/gstvaapibaseencoder.c b/gst/vaapiencode/gstvaapibaseencoder.c
index 93ab55f..7a8a037 100644 (file)
--- a/gst/vaapiencode/gstvaapibaseencoder.c
+++ b/gst/vaapiencode/gstvaapibaseencoder.c
@@ -317,8 +317,8 @@ gst_vaapi_base_encoder_open_default(GstVaapiEncoder* encoder, GstVaapiDisplay *d
   } else {
     check_attri_ret = default_validate_encoder_parameters(base_encoder);
   }
-  ENCODER_CHECK_STATUS(check_attri_ret, ENCODER_PARAMETER_ERR, "vaapi encoder paramerter error.\n");
-  ENCODER_CHECK_STATUS(VA_INVALID_PROFILE != base_prv->profile, ENCODER_PROFILE_ERR, "vaapi encoder profile not set.\n");
+  ENCODER_CHECK_STATUS(check_attri_ret, ENCODER_PARAMETER_ERR, "vaapi encoder paramerter error.");
+  ENCODER_CHECK_STATUS(VA_INVALID_PROFILE != base_prv->profile, ENCODER_PROFILE_ERR, "vaapi encoder profile not set.");
 
   ENCODER_ASSERT(ENCODER_DISPLAY(encoder));
 
@@ -345,17 +345,17 @@ gst_vaapi_base_encoder_open_default(GstVaapiEncoder* encoder, GstVaapiDisplay *d
                         ENCODER_WIDTH(encoder),
                         ENCODER_HEIGHT(encoder));
 #endif
-  ENCODER_CHECK_STATUS(out_context, ENCODER_CONTEXT_ERR, "gst_vaapi_context_new failed.\n");
-  ENCODER_CHECK_STATUS(VA_INVALID_ID != GST_VAAPI_OBJECT_ID(out_context), ENCODER_CONTEXT_ERR, "gst_vaapi_context_new failed.\n");
+  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, display, out_context),
-                         ENCODER_MEM_ERR, "encoder <pre_alloc_resource> failed.\n");
+                         ENCODER_MEM_ERR, "encoder <pre_alloc_resource> failed.");
   }
   ENCODER_CHECK_STATUS(
     base_encoder_alloc_coded_buffers(base_encoder, display, out_context),
     ENCODER_MEM_ERR,
-    "encoder <base_encoder_alloc_coded_buffers> failed.\n"
+    "encoder <base_encoder_alloc_coded_buffers> failed."
   );
   *context = out_context;
 
@@ -426,7 +426,7 @@ base_encoder_alloc_coded_buffers(GstVaapiBaseEncoder *base_encoder, GstVaapiDisp
       break;
   }
   ENCODER_RELEASE_DISPLAY_LOCK(display);
-  ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS == va_status, FALSE, "create coded buffer failed.\n");
+  ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS == va_status, FALSE, "create coded buffer failed.");
 
   /* init queue available_code_buffers */
   g_mutex_lock(base_prv->code_buffer_lock);
@@ -512,11 +512,11 @@ gst_vaapi_base_encoder_encode_default(GstVaapiEncoder* encoder, GstVaapiDisplay
       ENCODER_CHECK_STATUS(base_prv->surfaces_pool, ENCODER_SURFACE_ERR, "surface pool could not be found in context");
       video_buffer = (GstVaapiVideoBuffer*)gst_vaapi_video_buffer_new_from_pool((GstVaapiVideoPool*)base_prv->surfaces_pool);
       new_surface = gst_vaapi_video_buffer_get_surface(video_buffer); //gst_vaapi_context_get_surface(context);
-      ENCODER_CHECK_STATUS(new_surface, ENCODER_SURFACE_ERR, "base_pop_free_surface failed.\n");
+      ENCODER_CHECK_STATUS(new_surface, ENCODER_SURFACE_ERR, "base_pop_free_surface failed.");
 
       /* put picture to new surface */
       va_status = base_put_raw_buffer_to_surface(base_encoder, display, raw_pic, new_surface);
-      ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS == va_status, ENCODER_PICTURE_ERR, "va put buffer to surface failed.\n");
+      ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS == va_status, ENCODER_PICTURE_ERR, "va put buffer to surface failed.");
 
       GST_BUFFER_TIMESTAMP(video_buffer) = GST_BUFFER_TIMESTAMP(raw_pic);
       GST_BUFFER_DURATION(video_buffer) = GST_BUFFER_DURATION(raw_pic);
@@ -541,18 +541,18 @@ again:
 
   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.\n");
+  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.\n");
+  ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS == va_status, ENCODER_PICTURE_ERR, "vaBeginPicture error.");
 
   /*get valid coded buffer*/
   coded_buf = pop_available_coded_buffer(base_prv);
-  ENCODER_CHECK_STATUS(coded_buf, ENCODER_ENC_RES_ERR, "dequeue_available_coded_buffer error.\n");
+  ENCODER_CHECK_STATUS(coded_buf, ENCODER_ENC_RES_ERR, "dequeue_available_coded_buffer error.");
 
   /* prepare frame*/
   ret = base_class->render_frame(base_encoder, display, context,
@@ -562,13 +562,13 @@ again:
   if (ENCODER_NO_ERROR != ret) {
     push_available_coded_buffer(base_prv, coded_buf);
   }
-  ENCODER_CHECK_STATUS(ENCODER_NO_ERROR == ret, ENCODER_PICTURE_ERR, "base_prepare_encoding failed.\n");
+  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.\n");
+  ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS == va_status, ENCODER_PICTURE_ERR, "vaEndPicture error.");
 
   /*query surface result*/
   ret = base_query_encoding_status(base_encoder, display, buffer_surface,
@@ -753,16 +753,16 @@ base_query_encoding_status(GstVaapiBaseEncoder *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.\n");
+  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.\n");
+  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 ".\n", GST_TIME_ARGS(GST_BUFFER_TIMESTAMP(surface_buffer)));
+    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.\n");
+  ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS ==va_status, ENCODER_QUERY_STATUS_ERR, "vaMapBuffer failed.");
 
   /*unlock display*/
   ENCODER_RELEASE_DISPLAY_LOCK(display);

diff --git a/gst/vaapiencode/gstvaapiencode.c b/gst/vaapiencode/gstvaapiencode.c
index d1ddf68..b1c27a2 100644 (file)
--- a/gst/vaapiencode/gstvaapiencode.c
+++ b/gst/vaapiencode/gstvaapiencode.c
@@ -293,7 +293,7 @@ gst_vaapi_encode_chain(GstPad *sink_pad, GstBuffer *buf)
     ENCODER_LOG_INFO("gst_vaapi_encode_chain 1st recv-buffer caps,\n%s", _encode_dump_caps(recv_caps));
 
     recv_struct = gst_caps_get_structure (recv_caps, 0);
-    ENCODER_CHECK_STATUS(NULL != recv_caps, GST_FLOW_ERROR, "gst_vaapi_encode_chain, 1st buffer didn't have detailed caps.\n");
+    ENCODER_CHECK_STATUS(NULL != recv_caps, GST_FLOW_ERROR, "gst_vaapi_encode_chain, 1st buffer didn't have detailed caps.");
     if (gst_structure_get_int (recv_struct, "width", &width)) {
       encode->encoder->width = width;
     }
@@ -309,7 +309,7 @@ gst_vaapi_encode_chain(GstPad *sink_pad, GstBuffer *buf)
     format_value = gst_structure_get_value (recv_struct, "format");
     if (format_value && GST_IS_H264ENCODE(encode)) {
       ENCODER_CHECK_STATUS(format_value && GST_TYPE_FOURCC == G_VALUE_TYPE(format_value),
-                                 GST_FLOW_ERROR, "1st buffer caps' format type is not fourcc.\n");
+                                 GST_FLOW_ERROR, "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);
@@ -338,18 +338,18 @@ gst_vaapi_encode_chain(GstPad *sink_pad, GstBuffer *buf)
       #endif
       if (display) {
         ENCODER_CHECK_STATUS(gst_vaapi_encoder_set_display(encode->encoder,display)
-                                    , GST_FLOW_ERROR, "set display failed in gst_vaapi_encode_chain.\n");
+                                    , GST_FLOW_ERROR, "set display failed in gst_vaapi_encode_chain.");
       }
     }
     encoder_ret = gst_vaapi_encoder_initialize(encode->encoder);
-    ENCODER_CHECK_STATUS (ENCODER_NO_ERROR == encoder_ret, GST_FLOW_ERROR, "gst_vaapi_encoder_initialize failed.\n");
+    ENCODER_CHECK_STATUS (ENCODER_NO_ERROR == encoder_ret, GST_FLOW_ERROR, "gst_vaapi_encoder_initialize failed.");
   #ifdef _MRST_
     encoder_ret = gst_vaapi_encoder_open(encode->encoder, surface_pool);
   #else
     VAAPI_UNUSED_ARG(surface_pool);
     encoder_ret = gst_vaapi_encoder_open(encode->encoder, NULL);
   #endif
-    ENCODER_CHECK_STATUS (ENCODER_NO_ERROR == encoder_ret, GST_FLOW_ERROR, "gst_vaapi_encoder_open failed.\n");
+    ENCODER_CHECK_STATUS (ENCODER_NO_ERROR == encoder_ret, GST_FLOW_ERROR, "gst_vaapi_encoder_open failed.");
 
     encode->first_sink_frame = FALSE;
   }
@@ -357,9 +357,9 @@ gst_vaapi_encode_chain(GstPad *sink_pad, GstBuffer *buf)
   /*encoding frames*/
   ENCODER_ASSERT(gst_vaapi_encoder_get_state(encode->encoder) >= VAAPI_ENC_OPENED);
   ++input_count;
-  ENCODER_LOG_INFO("input %d\n", input_count);
+  ENCODER_LOG_DEBUG("input %d", input_count);
   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.\n");
+  ENCODER_CHECK_STATUS (ENCODER_NO_ERROR == encoder_ret, GST_FLOW_ERROR, "gst_vaapi_encoder_encode failed.");
 
   /*check results*/
   while (out_buffers) {
@@ -382,7 +382,7 @@ gst_vaapi_encode_chain(GstPad *sink_pad, GstBuffer *buf)
       encode->first_src_frame = FALSE;
     }
     ++output_count;
-    ENCODER_LOG_INFO("output:%d, %" GST_TIME_FORMAT ", 0x%s\n",
+    ENCODER_LOG_DEBUG("output:%d, %" GST_TIME_FORMAT ", 0x%s",
                    output_count,
                    GST_TIME_ARGS(GST_BUFFER_TIMESTAMP(tmp_buffer)),
                    vaapi_encoder_dump_bytes(GST_BUFFER_DATA(tmp_buffer),
@@ -415,14 +415,14 @@ gst_vaapi_encode_buffer_alloc(GstPad * pad, guint64 offset, guint size,
     if (!display) {
       gst_vaapi_encoder_initialize(encode->encoder);
       display = gst_vaapi_encoder_get_display(encode->encoder);
-      ENCODER_CHECK_STATUS(display, GST_FLOW_ERROR, "gst_vaapi_encoder_get_display failed in gst_vaapi_encode_buffer_alloc.\n");
+      ENCODER_CHECK_STATUS(display, GST_FLOW_ERROR, "gst_vaapi_encoder_get_display failed in gst_vaapi_encode_buffer_alloc.");
     }
     buffer = 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.\n");
+  ENCODER_CHECK_STATUS(buffer, GST_FLOW_ERROR, "gst_vaapi_encode_buffer_alloc failed.");
 
   GST_BUFFER_OFFSET (buffer) = offset;
   if (caps) {

diff --git a/gst/vaapiencode/gstvaapiencoder.c b/gst/vaapiencode/gstvaapiencoder.c
index e93f61f..90651c2 100644 (file)
--- a/gst/vaapiencode/gstvaapiencoder.c
+++ b/gst/vaapiencode/gstvaapiencoder.c
@@ -132,12 +132,12 @@ gst_vaapi_encoder_initialize(GstVaapiEncoder* encoder)
   /* create va_dpy*/
   if (!encoder_prv->display) {
     encoder_prv->display = gst_vaapi_display_x11_new(NULL);
-    ENCODER_CHECK_STATUS(encoder_prv->display, ENCODER_DISPLAY_ERR, "gst_vaapi_display_x11_new failed.\n");
+    ENCODER_CHECK_STATUS(encoder_prv->display, ENCODER_DISPLAY_ERR, "gst_vaapi_display_x11_new failed.");
   }
 
   if (encoder_class->initialize) {
     ret = encoder_class->initialize(encoder, encoder_prv->display);
-    ENCODER_CHECK_STATUS (ENCODER_NO_ERROR == ret, ret, "encoder <initialize> failed.\n");
+    ENCODER_CHECK_STATUS (ENCODER_NO_ERROR == ret, ret, "encoder <initialize> failed.");
   }
   encoder_prv->state = VAAPI_ENC_INIT;
 
@@ -162,10 +162,10 @@ gst_vaapi_encoder_open(GstVaapiEncoder* encoder, void* private_data)
   }
   ENCODER_ASSERT(!encoder_prv->context);
 
-  ENCODER_CHECK_STATUS(encoder_class->open, ENCODER_FUNC_PTR_ERR, "encoder <open> function pointer empty.\n");
+  ENCODER_CHECK_STATUS(encoder_class->open, ENCODER_FUNC_PTR_ERR, "encoder <open> function pointer empty.");
   ret = encoder_class->open(encoder, encoder_prv->display, private_data, &encoder_prv->context);
-  ENCODER_CHECK_STATUS(ENCODER_NO_ERROR == ret, ret, "encoder <open> failed.\n");
-  ENCODER_CHECK_STATUS(encoder_prv->context, ENCODER_CONTEXT_ERR, "encoder <open> context failed.\n");
+  ENCODER_CHECK_STATUS(ENCODER_NO_ERROR == ret, ret, "encoder <open> failed.");
+  ENCODER_CHECK_STATUS(encoder_prv->context, ENCODER_CONTEXT_ERR, "encoder <open> context failed.");
 
   encoder_prv->state = VAAPI_ENC_OPENED;
 
@@ -180,10 +180,10 @@ gst_vaapi_encoder_encode(GstVaapiEncoder* encoder, GstBuffer *raw_pic, GList **c
   GstVaapiEncoderClass *encoder_class = GST_VAAPI_ENCODER_GET_CLASS(encoder);
   GstVaapiEncoderPrivate *encoder_prv = GST_VAAPI_ENCODER_GET_PRIVATE(encoder);
 
-  ENCODER_CHECK_STATUS(encoder_prv->state >= VAAPI_ENC_OPENED, ENCODER_STATE_ERR, "encoder was not opened before <encode>.\n");
-  ENCODER_CHECK_STATUS(encoder_class->encode, ENCODER_FUNC_PTR_ERR, "encoder <encode> function pointer empty.\n");
+  ENCODER_CHECK_STATUS(encoder_prv->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, encoder_prv->display, encoder_prv->context, raw_pic, coded_pics);
-  ENCODER_CHECK_STATUS(ENCODER_NO_ERROR == ret, ret, "encoder <encode> failed.\n");
+  ENCODER_CHECK_STATUS(ENCODER_NO_ERROR == ret, ret, "encoder <encode> failed.");
   if (encoder_prv->state < VAAPI_ENC_ENCODING) {
     encoder_prv->state = VAAPI_ENC_ENCODING;
   }
@@ -197,7 +197,7 @@ EncoderStatus gst_vaapi_encoder_get_codec_data(GstVaapiEncoder* encoder, GstBuff
   GstVaapiEncoderClass *encoder_class = GST_VAAPI_ENCODER_GET_CLASS(encoder);
   GstVaapiEncoderPrivate *encoder_prv = GST_VAAPI_ENCODER_GET_PRIVATE(encoder);
 
-  ENCODER_CHECK_STATUS(encoder_prv->state >= VAAPI_ENC_OPENED, ENCODER_STATE_ERR, "encoder was not opened before <get_codec_data>.\n");
+  ENCODER_CHECK_STATUS(encoder_prv->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");
@@ -219,9 +219,9 @@ gst_vaapi_encoder_flush(GstVaapiEncoder* encoder, GList **coded_pics)
   if (encoder_prv->state < VAAPI_ENC_OPENED) {
     return ENCODER_STATE_ERR;
   }
-  ENCODER_CHECK_STATUS(encoder_class->flush, ENCODER_FUNC_PTR_ERR, "encoder <flush> function pointer empty.\n");
+  ENCODER_CHECK_STATUS(encoder_class->flush, ENCODER_FUNC_PTR_ERR, "encoder <flush> function pointer empty.");
   ret = encoder_class->flush(encoder, encoder_prv->display, encoder_prv->context, coded_pics);
-  ENCODER_CHECK_STATUS(ENCODER_NO_ERROR == ret, ret, "encoder <flush> failed.\n");
+  ENCODER_CHECK_STATUS(ENCODER_NO_ERROR == ret, ret, "encoder <flush> failed.");
   if (encoder_prv->state > VAAPI_ENC_OPENED) {
     encoder_prv->state = VAAPI_ENC_OPENED;
   }
@@ -239,9 +239,9 @@ gst_vaapi_encoder_close(GstVaapiEncoder* encoder)
   if (VAAPI_ENC_INIT >= encoder_prv->state) {
     return ENCODER_NO_ERROR;
   }
-  ENCODER_CHECK_STATUS(encoder_class->close, ENCODER_FUNC_PTR_ERR, "encoder <close> function pointers empty.\n");
+  ENCODER_CHECK_STATUS(encoder_class->close, ENCODER_FUNC_PTR_ERR, "encoder <close> function pointers empty.");
   ret = encoder_class->close(encoder, encoder_prv->display, encoder_prv->context);
-  ENCODER_CHECK_STATUS(ENCODER_NO_ERROR == ret, ret, "encoder <close> failed.\n");
+  ENCODER_CHECK_STATUS(ENCODER_NO_ERROR == ret, ret, "encoder <close> failed.");
 end:
   if (encoder_prv->context) {
     g_object_unref(encoder_prv->context);
@@ -269,7 +269,7 @@ gst_vaapi_encoder_uninitialize(GstVaapiEncoder* encoder)
   ENCODER_ASSERT(VAAPI_ENC_INIT == encoder_prv->state);
   if (encoder_class->uninitialize) {
     ret = encoder_class->uninitialize(encoder, encoder_prv->display);
-    ENCODER_CHECK_STATUS(ENCODER_NO_ERROR == ret, ret, "encoder <uninitialize> failed.\n");
+    ENCODER_CHECK_STATUS(ENCODER_NO_ERROR == ret, ret, "encoder <uninitialize> failed.");
   }
 end:
   if (encoder_prv->display) {

diff --git a/gst/vaapiencode/gstvaapiencoder.h b/gst/vaapiencode/gstvaapiencoder.h
index b4b05e7..c546fdc 100644 (file)
--- a/gst/vaapiencode/gstvaapiencoder.h
+++ b/gst/vaapiencode/gstvaapiencoder.h
@@ -4,6 +4,7 @@
 #include <stdio.h>
 #include <stdint.h>
 
+#include "gst/gstinfo.h"
 #include "gst/gstbuffer.h"
 #include "gst/vaapi/gstvaapidisplay.h"
 #include "gst/vaapi/gstvaapicontext.h"
@@ -30,9 +31,17 @@ G_BEGIN_DECLS
 #define ENCODER_PARAMETER_ERR -12
 #define ENCODER_FUNC_PTR_ERR  -13
 
-#define ENCODER_LOG_ERROR(...) fprintf(stdout, ## __VA_ARGS__)
-#define ENCODER_LOG_DEBUG(...) fprintf(stdout, ## __VA_ARGS__)
-#define ENCODER_LOG_INFO(...)  fprintf(stdout, ## __VA_ARGS__)
+#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__)
+#else
+  #define ENCODER_LOG_ERROR(...)   GST_ERROR( __VA_ARGS__)
+  #define ENCODER_LOG_WARNING(...) GST_WARNING( __VA_ARGS__)
+  #define ENCODER_LOG_DEBUG(...)   GST_DEBUG( __VA_ARGS__)
+  #define ENCODER_LOG_INFO(...)    GST_INFO( __VA_ARGS__)
+#endif
 
 #define VAAPI_UNUSED_ARG(arg) (void)(arg)
 
@@ -40,7 +49,7 @@ G_BEGIN_DECLS
 #include <assert.h>
 #define ENCODER_ASSERT(exp) assert(exp)
 #else
-#define ENCODER_ASSERT(exp)
+#define ENCODER_ASSERT(exp) g_assert(exp)
 #endif
 
 #define ENCODER_CHECK_STATUS(exp, err_num, err_reason, ...)  \

diff --git a/gst/vaapiencode/gstvaapih263encoder.c b/gst/vaapiencode/gstvaapih263encoder.c
index 86d8f2c..4960900 100644 (file)
--- a/gst/vaapiencode/gstvaapih263encoder.c
+++ b/gst/vaapiencode/gstvaapih263encoder.c
@@ -223,19 +223,19 @@ gst_h263_encoder_rendering(GstVaapiBaseEncoder *encoder, GstVaapiDisplay *displa
     va_status = vaCreateBuffer(va_dpy, context_id,
                                VAEncSequenceParameterBufferType,
                                sizeof(seq_h263), 1, &seq_h263, &h263_prv->seq_parameter);
-    ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS == va_status, ENCODER_ENC_RES_ERR, "h263 alloc seq-buffer failed.\n");
+    ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS == va_status, ENCODER_ENC_RES_ERR, "h263 alloc seq-buffer failed.");
     va_status = vaRenderPicture(va_dpy, context_id, &h263_prv->seq_parameter, 1);
-    ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS == va_status, ENCODER_PICTURE_ERR, "h263 vaRenderPicture seq-parameters failed.\n");
+    ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS == va_status, ENCODER_PICTURE_ERR, "h263 vaRenderPicture seq-parameters failed.");
   }
 
   /* set reference and reconstructed surfaces */
   if (!h263_prv->ref_surface) {
     h263_prv->ref_surface = gst_vaapi_context_get_surface(context);
-    ENCODER_CHECK_STATUS(h263_prv->ref_surface, ENCODER_SURFACE_ERR, "h263 reference surface, h263_pop_free_surface failed.\n");
+    ENCODER_CHECK_STATUS(h263_prv->ref_surface, ENCODER_SURFACE_ERR, "h263 reference surface, h263_pop_free_surface failed.");
   }
   if (!h263_prv->recon_surface) {
     h263_prv->recon_surface = gst_vaapi_context_get_surface(context);
-    ENCODER_CHECK_STATUS(h263_prv->recon_surface, ENCODER_SURFACE_ERR, "h263 reconstructed surface, h263_pop_free_surface failed.\n");
+    ENCODER_CHECK_STATUS(h263_prv->recon_surface, ENCODER_SURFACE_ERR, "h263 reconstructed surface, h263_pop_free_surface failed.");
   }
 
   /* initialize picture, every time, every frame */
@@ -253,9 +253,11 @@ gst_h263_encoder_rendering(GstVaapiBaseEncoder *encoder, GstVaapiDisplay *displa
 
   va_status = vaCreateBuffer(va_dpy, context_id, VAEncPictureParameterBufferType,
                                sizeof(pic_h263), 1, &pic_h263, &h263_prv->pic_parameter);
-  ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS ==va_status, ENCODER_ENC_RES_ERR, "h263 creating pic-param buffer failed.\n");
+  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, &h263_prv->pic_parameter, 1);
-  ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS ==va_status, ENCODER_PICTURE_ERR, "h263 rendering pic-param buffer failed.\n");
+  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;
@@ -276,12 +278,12 @@ gst_h263_encoder_rendering(GstVaapiBaseEncoder *encoder, GstVaapiDisplay *displa
                              &h263_prv->slice_parameter);
   ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS ==va_status,
                        ENCODER_ENC_RES_ERR,
-                       "h263 creating slice-parameters buffer failed.\n");
+                       "h263 creating slice-parameters buffer failed.");
 
   va_status = vaRenderPicture(va_dpy, context_id, &h263_prv->slice_parameter, 1);
   ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS ==va_status,
                        ENCODER_PICTURE_ERR,
-                       "h263 rendering slice-parameters buffer failed.\n");
+                       "h263 rendering slice-parameters buffer failed.");
 
   /*swap ref_surface and recon_surface */
   GstVaapiSurface *swap = h263_prv->ref_surface;

diff --git a/gst/vaapiencode/gstvaapih264encode.c b/gst/vaapiencode/gstvaapih264encode.c
index d90e3c4..343cff6 100644 (file)
--- a/gst/vaapiencode/gstvaapih264encode.c
+++ b/gst/vaapiencode/gstvaapih264encode.c
@@ -196,7 +196,7 @@ gst_h264encode_set_property(GObject *object, guint prop_id,
       if (_h264_check_valid_profile(profile)) {
         h264encoder->profile = profile;
       } else {
-        ENCODER_LOG_ERROR("h264encode set property <profile> failed.\n");
+        ENCODER_LOG_ERROR("h264encode set property <profile> failed.");
       }
     }
       break;
@@ -206,7 +206,7 @@ gst_h264encode_set_property(GObject *object, guint prop_id,
       if (_h264_check_valid_level(level)) {
         h264encoder->level= level;
       } else {
-        ENCODER_LOG_ERROR("h264encode set property <level> failed.\n");
+        ENCODER_LOG_ERROR("h264encode set property <level> failed.");
       }
     }
       break;

diff --git a/gst/vaapiencode/gstvaapih264encoder.c b/gst/vaapiencode/gstvaapih264encoder.c
index c49d40a..a358aad 100644 (file)
--- a/gst/vaapiencode/gstvaapih264encoder.c
+++ b/gst/vaapiencode/gstvaapih264encoder.c
@@ -679,7 +679,6 @@ gst_h264_encoder_prepare_next_buffer(GstVaapiBaseEncoder* encoder,
   GstH264Encoder *h264_encoder = GST_H264_ENCODER(encoder);
   GstH264EncoderPrivate *h264_prv = GST_H264_ENCODER_GET_PRIVATE(h264_encoder);
   GstVaapiVideoBuffer  *return_buf = NULL;
-  GstVaapiVideoBuffer  *tmp_next_buf = NULL;
   //guint64 pts = 0;
 
   if (NULL == display_buf && g_queue_is_empty(h264_prv->queued_buffers)) {
@@ -802,19 +801,23 @@ gst_h264_encoder_rendering(GstVaapiBaseEncoder *encoder, GstVaapiDisplay *displa
     va_status = vaCreateBuffer(va_dpy, context_id,
                                VAEncSequenceParameterBufferType,
                                sizeof(seq_h264), 1, &seq_h264, &h264_prv->seq_parameter);
-    ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS == va_status, ENCODER_ENC_RES_ERR, "alloc seq-buffer failed.\n");
+    ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS == va_status,
+                         ENCODER_ENC_RES_ERR, "alloc seq-buffer failed.");
     va_status = vaRenderPicture(va_dpy, context_id, &h264_prv->seq_parameter, 1);
-    ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS == va_status, ENCODER_PICTURE_ERR, "vaRenderPicture seq-parameters failed.\n");
+    ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS == va_status,
+                         ENCODER_PICTURE_ERR, "vaRenderPicture seq-parameters failed.");
   }
 
   /* set pic_parameters*/
   if (!h264_prv->ref_surface1) {
     h264_prv->ref_surface1 = gst_vaapi_context_get_surface(context);
-    ENCODER_CHECK_STATUS(h264_prv->ref_surface1, ENCODER_SURFACE_ERR, "reference surface, h264_pop_free_surface failed.\n");
+    ENCODER_CHECK_STATUS(h264_prv->ref_surface1, ENCODER_SURFACE_ERR,
+                         "reference surface, h264_pop_free_surface failed.");
   }
   if (!h264_prv->recon_surface) {
     h264_prv->recon_surface = gst_vaapi_context_get_surface(context);
-    ENCODER_CHECK_STATUS(h264_prv->recon_surface, ENCODER_SURFACE_ERR, "reconstructed surface, h264_pop_free_surface failed.\n");
+    ENCODER_CHECK_STATUS(h264_prv->recon_surface, ENCODER_SURFACE_ERR,
+                         "reconstructed surface, h264_pop_free_surface failed.");
   }
 
   pic_h264.reference_picture = GST_VAAPI_OBJECT_ID(h264_prv->ref_surface1);
@@ -831,10 +834,12 @@ gst_h264_encoder_rendering(GstVaapiBaseEncoder *encoder, GstVaapiDisplay *displa
   va_status = vaCreateBuffer(va_dpy, context_id, VAEncPictureParameterBufferType,
                                sizeof(pic_h264), 1, &pic_h264, &h264_prv->pic_parameter);
 
-  ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS ==va_status, ENCODER_PICTURE_ERR, "creating pic-param buffer failed.\n");
+  ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS ==va_status,
+                       ENCODER_PICTURE_ERR, "creating pic-param buffer failed.");
 
   va_status = vaRenderPicture(va_dpy, context_id, &h264_prv->pic_parameter, 1);
-  ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS ==va_status, ENCODER_PICTURE_ERR, "rendering pic-param buffer failed.\n");
+  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;
@@ -868,10 +873,12 @@ gst_h264_encoder_rendering(GstVaapiBaseEncoder *encoder, GstVaapiDisplay *displa
                              h264_encoder->slice_num,
                              h264_prv->slice_param_buffers,
                              &h264_prv->slice_parameter);
-  ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS ==va_status, ENCODER_PICTURE_ERR, "creating slice-parameters buffer failed.\n");
+  ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS ==va_status,
+                       ENCODER_PICTURE_ERR, "creating slice-parameters buffer failed.");
 
   va_status = vaRenderPicture(va_dpy, context_id, &h264_prv->slice_parameter, 1);
-  ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS ==va_status, ENCODER_PICTURE_ERR, "rendering slice-parameters buffer failed.\n");
+  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 = h264_prv->ref_surface1;
@@ -928,7 +935,7 @@ h264_recreate_seq_param(GstH264Encoder *h264_encoder,
   else if (h264_encoder->init_qp == -2)
       seq_h264.rate_control_method = BR_VBR;
   else {
-      assert(h264_encoder->init_qp >= 0 && h264_encoder->init_qp <= 51);
+      ENCODER_ASSERT(h264_encoder->init_qp >= 0 && h264_encoder->init_qp <= 51);
       seq_h264.rate_control_method = BR_CQP;
   }
 
@@ -965,7 +972,7 @@ h264_recreate_seq_param(GstH264Encoder *h264_encoder,
                              sizeof(seq_h264), 1,
                              &seq_h264, &h264_prv->seq_parameter);
   ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS == va_status,
-                     FALSE, "alloc seq-buffer failed.\n");
+                     FALSE, "alloc seq-buffer failed.");
 
   /*pack sps header buffer/data */
   if (NULL == h264_prv->sps_data) {
@@ -1057,7 +1064,7 @@ h264_recreate_pic_param(GstH264Encoder *h264_encoder,
     frame_type = "P";
   if (h264_prv->cur_slice_type == SLICE_TYPE_B)
     frame_type = "B";
-  ENCODER_LOG_INFO("type:%s, frame_num:%d, display_num:%d\n",
+  ENCODER_LOG_INFO("type:%s, frame_num:%d, display_num:%d",
          frame_type, pic_h264.frame_num, pic_h264.CurrPic.TopFieldOrderCnt);
 
   if (VA_INVALID_ID != h264_prv->pic_parameter) { /* share the same pic_parameter*/
@@ -1067,7 +1074,8 @@ h264_recreate_pic_param(GstH264Encoder *h264_encoder,
   va_status = vaCreateBuffer(va_dpy, context_id, VAEncPictureParameterBufferType,
                                sizeof(pic_h264), 1, &pic_h264, &h264_prv->pic_parameter);
 
-  ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS ==va_status, FALSE, "creating pic-param buffer failed.\n");
+  ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS ==va_status,
+                       FALSE, "creating pic-param buffer failed.");
 
   //if (NULL == h264_prv->pps_data) {
   if (VA_INVALID_ID == h264_prv->packed_pps_data_buf) {
@@ -1178,7 +1186,8 @@ h264_recreate_slice_param(GstH264Encoder *h264_encoder,
                              h264_encoder->slice_num,
                              h264_prv->slice_param_buffers,
                              &h264_prv->slice_parameter);
-  ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS ==va_status, FALSE, "creating slice-parameters buffer failed.\n");
+  ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS ==va_status,
+                       FALSE, "creating slice-parameters buffer failed.");
 
 end:
   return ret;
@@ -1207,15 +1216,21 @@ gst_h264_encoder_rendering(GstVaapiBaseEncoder *encoder, GstVaapiDisplay *displa
 
   if (!h264_prv->ref_surface1) {
     h264_prv->ref_surface1 = gst_vaapi_context_get_surface(context);
-    ENCODER_CHECK_STATUS(h264_prv->ref_surface1, ENCODER_SURFACE_ERR, "reference surface, h264_pop_free_surface failed.\n");
+    ENCODER_CHECK_STATUS(h264_prv->ref_surface1,
+                         ENCODER_SURFACE_ERR,
+                         "reference surface, h264_pop_free_surface failed.");
   }
   if (!h264_prv->ref_surface2) {
     h264_prv->ref_surface2 = gst_vaapi_context_get_surface(context);
-    ENCODER_CHECK_STATUS(h264_prv->ref_surface2, ENCODER_SURFACE_ERR, "reference surface, h264_pop_free_surface failed.\n");
+    ENCODER_CHECK_STATUS(h264_prv->ref_surface2,
+                         ENCODER_SURFACE_ERR,
+                         "reference surface, h264_pop_free_surface failed.");
   }
   if (!h264_prv->recon_surface) {
     h264_prv->recon_surface = gst_vaapi_context_get_surface(context);
-    ENCODER_CHECK_STATUS(h264_prv->recon_surface, ENCODER_SURFACE_ERR, "reconstructed surface, h264_pop_free_surface failed.\n");
+    ENCODER_CHECK_STATUS(h264_prv->recon_surface,
+                         ENCODER_SURFACE_ERR,
+                         "reconstructed surface, h264_pop_free_surface failed.");
   }
 
   if (SLICE_TYPE_P == h264_prv->cur_slice_type) {
@@ -1265,7 +1280,7 @@ gst_h264_encoder_rendering(GstVaapiBaseEncoder *encoder, GstVaapiDisplay *displa
 
   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.\n");
+                       "vaRenderH264Picture failed.");
 
   /*after finished,  swap  recon and surface2*/
   if (SLICE_TYPE_P == h264_prv->cur_slice_type ||
@@ -1640,7 +1655,9 @@ h264_bitstream_write_uint(H264Bitstream *bitstream, guint32 value, guint32 bit_s
   }
 
   VAAPI_UNUSED_ARG(ret);
-  ENCODER_CHECK_STATUS(TRUE == h264_bitstream_auto_grow(bitstream, bit_size), FALSE, "h264_bitstream_auto_grow failed.\n");
+  ENCODER_CHECK_STATUS(TRUE == 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;
@@ -1684,7 +1701,9 @@ h264_bitstream_write_byte_array(H264Bitstream *bitstream, const guint8 *buf, gui
   }
 
   VAAPI_UNUSED_ARG(ret);
-  ENCODER_CHECK_STATUS(TRUE == h264_bitstream_auto_grow(bitstream, byte_size<<3), FALSE, "h264_bitstream_auto_grow failed.\n");
+  ENCODER_CHECK_STATUS(TRUE == h264_bitstream_auto_grow(bitstream, byte_size<<3),
+                       FALSE,
+                       "h264_bitstream_auto_grow failed.");
   if (0 == (bitstream->bit_size&0x07)) {
     memcpy(&bitstream->buffer[bitstream->bit_size>>3], buf, byte_size);
     bitstream->bit_size += (byte_size<<3);
@@ -1711,8 +1730,12 @@ h264_bitstream_write_ue(H264Bitstream *bitstream, guint32 value)
     ++size_in_bits;
     tmp_value >>= 1;
   }
-  ENCODER_CHECK_STATUS(h264_bitstream_write_uint(bitstream, 0, size_in_bits-1), FALSE, "h264_bitstream_write_ue failed.\n");
-  ENCODER_CHECK_STATUS(h264_bitstream_write_uint(bitstream, value, size_in_bits), FALSE, "h264_bitstream_write_ue failed.\n");
+  ENCODER_CHECK_STATUS(h264_bitstream_write_uint(bitstream, 0, size_in_bits-1),
+                       FALSE,
+                       "h264_bitstream_write_ue failed.");
+  ENCODER_CHECK_STATUS(h264_bitstream_write_uint(bitstream, value, size_in_bits),
+                       FALSE,
+                       "h264_bitstream_write_ue failed.");
 
 end:
   return ret;
@@ -1730,7 +1753,9 @@ h264_bitstream_write_se(H264Bitstream *bitstream, gint32 value)
     new_val = (value<<1) - 1;
   }
 
-  ENCODER_CHECK_STATUS(h264_bitstream_write_ue(bitstream, new_val), FALSE, "h264_bitstream_write_se failed.\n");
+  ENCODER_CHECK_STATUS(h264_bitstream_write_ue(bitstream, new_val),
+                       FALSE,
+                       "h264_bitstream_write_se failed.");
 
 end:
   return ret;

diff --git a/gst/vaapiencode/gstvaapimpeg4encoder.c b/gst/vaapiencode/gstvaapimpeg4encoder.c
index 3ac9284..da482cd 100644 (file)
--- a/gst/vaapiencode/gstvaapimpeg4encoder.c
+++ b/gst/vaapiencode/gstvaapimpeg4encoder.c
@@ -271,19 +271,26 @@ gst_mpeg4_encoder_rendering(GstVaapiBaseEncoder *encoder, GstVaapiDisplay *displ
     va_status = vaCreateBuffer(va_dpy, context_id,
                                VAEncSequenceParameterBufferType,
                                sizeof(seq_mpeg4), 1, &seq_mpeg4, &mpeg4_prv->seq_parameter);
-    ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS == va_status, ENCODER_ENC_RES_ERR, "mpeg4 alloc seq-buffer failed.\n");
+    ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS == va_status,
+                         ENCODER_ENC_RES_ERR, "mpeg4 alloc seq-buffer failed.");
     va_status = vaRenderPicture(va_dpy, context_id, &mpeg4_prv->seq_parameter, 1);
-    ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS == va_status, ENCODER_PICTURE_ERR, "mpeg4 vaRenderPicture seq-parameters failed.\n");
+    ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS == va_status,
+                         ENCODER_PICTURE_ERR,
+                         "mpeg4 vaRenderPicture seq-parameters failed.");
   }
 
   /* set reference and reconstructed surfaces */
   if (!mpeg4_prv->ref_surface) {
     mpeg4_prv->ref_surface = gst_vaapi_context_get_surface(context);
-    ENCODER_CHECK_STATUS(mpeg4_prv->ref_surface, ENCODER_SURFACE_ERR, "mpeg4 reference surface, mpeg4_pop_free_surface failed.\n");
+    ENCODER_CHECK_STATUS(mpeg4_prv->ref_surface,
+                         ENCODER_SURFACE_ERR,
+                         "mpeg4 reference surface, mpeg4_pop_free_surface failed.");
   }
   if (!mpeg4_prv->recon_surface) {
     mpeg4_prv->recon_surface = gst_vaapi_context_get_surface(context);
-    ENCODER_CHECK_STATUS(mpeg4_prv->recon_surface, ENCODER_SURFACE_ERR, "mpeg4 reconstructed surface, mpeg4_pop_free_surface failed.\n");
+    ENCODER_CHECK_STATUS(mpeg4_prv->recon_surface,
+                         ENCODER_SURFACE_ERR,
+                         "mpeg4 reconstructed surface, mpeg4_pop_free_surface failed.");
   }
 
   /* initialize picture, every time, every frame */
@@ -308,9 +315,13 @@ gst_mpeg4_encoder_rendering(GstVaapiBaseEncoder *encoder, GstVaapiDisplay *displ
 
   va_status = vaCreateBuffer(va_dpy, context_id, VAEncPictureParameterBufferType,
                                sizeof(pic_mpeg4), 1, &pic_mpeg4, &mpeg4_prv->pic_parameter);
-  ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS ==va_status, ENCODER_ENC_RES_ERR, "mpeg4 creating pic-param buffer failed.\n");
+  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, &mpeg4_prv->pic_parameter, 1);
-  ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS ==va_status, ENCODER_PICTURE_ERR, "mpeg4 rendering pic-param buffer failed.\n");
+  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;
@@ -329,10 +340,14 @@ gst_mpeg4_encoder_rendering(GstVaapiBaseEncoder *encoder, GstVaapiDisplay *displ
                              1,
                              &slice_mpeg4,
                              &mpeg4_prv->slice_parameter);
-  ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS ==va_status, ENCODER_ENC_RES_ERR, "mpeg4 creating slice-parameters buffer failed.\n");
+  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, &mpeg4_prv->slice_parameter, 1);
-  ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS ==va_status, ENCODER_PICTURE_ERR, "mpeg4 rendering slice-parameters buffer failed.\n");
+  ENCODER_CHECK_STATUS(VA_STATUS_SUCCESS ==va_status,
+                       ENCODER_PICTURE_ERR,
+                       "mpeg4 rendering slice-parameters buffer failed.");
 
   /*swap ref_surface and recon_surface */
   GstVaapiSurface *swap = mpeg4_prv->ref_surface;
@@ -375,7 +390,7 @@ gst_mpeg4_notify_frame(GstVaapiBaseEncoder *encoder, guint8 *buf, guint32 size)
   GstMPEG4EncoderPrivate *mpeg4_prv = GST_MPEG4_ENCODER_GET_PRIVATE(encoder);
   if (!mpeg4_prv->codec_data) {
     if (!mpeg4_encoder_generate_codec_data(buf, size, &mpeg4_prv->codec_data)) {
-      ENCODER_LOG_ERROR("mpeg4 encoder coded data error, please check <mpeg4_encoder_generate_codec_data>.\n");
+      ENCODER_LOG_ERROR("mpeg4 encoder coded data error, please check <mpeg4_encoder_generate_codec_data>.");
     }
   }
   if (mpeg4_prv->codec_data) {