sigrid/openh264

codec/api/svc/codec_app_def.h+6−1

   ENCODER_OPTION_CURRENT_PATH,
   ENCODER_OPTION_DUMP_FILE,
-  ENCODER_OPTION_TRACE_LEVEL
+  ENCODER_OPTION_TRACE_LEVEL,
+  ENCODER_OPTION_TRACE_CALLBACK, // a void (*)(void* context, int level, const char* message) function which receives log messages
+  ENCODER_OPTION_TRACE_CALLBACK_CONTEXT,
 } ENCODER_OPTION;
 /* Option types introduced in decoder application */
   DECODER_OPTION_LTR_MARKING_FLAG,	// feedback wether current frame mark a LTR
   DECODER_OPTION_LTR_MARKED_FRAME_NUM,	// feedback frame num marked by current Frame
   DECODER_OPTION_ERROR_CON_IDC, //not finished yet, indicate decoder error concealment status, in progress
+  DECODER_OPTION_TRACE_LEVEL,
+  DECODER_OPTION_TRACE_CALLBACK, // a void (*)(void* context, int level, const char* message) function which receives log messages
+  DECODER_OPTION_TRACE_CALLBACK_CONTEXT,
 } DECODER_OPTION;

codec/build/android/dec/jni/welsdecdemo.mk+0−1

@@ -26,7 +26,6 @@ LOCAL_SRC_FILES := \ · 25 unmodified lines
26	$(CONSOLE_DEC_PATH)/src/h264dec.cpp \	26	$(CONSOLE_DEC_PATH)/src/h264dec.cpp \
27	$(CONSOLE_DEC_PATH)/src/read_config.cpp \	27	$(CONSOLE_DEC_PATH)/src/read_config.cpp \
28	$(CONSOLE_DEC_PATH)/src/d3d9_utils.cpp \	28	$(CONSOLE_DEC_PATH)/src/d3d9_utils.cpp \
29	$(CODEC_PATH)/common/src/logging.cpp \
30	myjni.cpp	29	myjni.cpp
31	#	30	#
32	# Header Includes	31	# Header Includes

codec/build/android/enc/jni/welsencdemo.mk+0−1

@@ -25,7 +25,6 @@ CONSOLE_ENC_PATH := ../../../../console/enc · 24 unmodified lines
25	LOCAL_SRC_FILES := \	25	LOCAL_SRC_FILES := \
26	$(CONSOLE_ENC_PATH)/src/welsenc.cpp \	26	$(CONSOLE_ENC_PATH)/src/welsenc.cpp \
27	$(CONSOLE_ENC_PATH)/src/read_config.cpp \	27	$(CONSOLE_ENC_PATH)/src/read_config.cpp \
28	$(CODEC_PATH)/common/src/logging.cpp \
29	myjni.cpp	28	myjni.cpp
30		29
31	#	30	#

codec/build/iOS/common/common.xcodeproj/project.pbxproj+0−6

 		4C3406CD18D96EA600DFA14A /* cpu.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4C3406C418D96EA600DFA14A /* cpu.cpp */; };
 		4C3406CE18D96EA600DFA14A /* crt_util_safe_x.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4C3406C518D96EA600DFA14A /* crt_util_safe_x.cpp */; };
 		4C3406CF18D96EA600DFA14A /* deblocking_common.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4C3406C618D96EA600DFA14A /* deblocking_common.cpp */; };
-		4C3406D018D96EA600DFA14A /* logging.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4C3406C718D96EA600DFA14A /* logging.cpp */; };
 		4C3406D118D96EA600DFA14A /* WelsThreadLib.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4C3406C818D96EA600DFA14A /* WelsThreadLib.cpp */; };
 		4CC61F0918FF6B4B00E56EAB /* copy_mb_neon.S in Sources */ = {isa = PBXBuildFile; fileRef = 4CC61F0818FF6B4B00E56EAB /* copy_mb_neon.S */; };
 		4CE443D918B722CD0017DF25 /* Foundation.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 4CE443D818B722CD0017DF25 /* Foundation.framework */; };
 		4C3406B818D96EA600DFA14A /* cpu_core.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = cpu_core.h; sourceTree = "<group>"; };
 		4C3406B918D96EA600DFA14A /* crt_util_safe_x.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = crt_util_safe_x.h; sourceTree = "<group>"; };
 		4C3406BA18D96EA600DFA14A /* deblocking_common.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = deblocking_common.h; sourceTree = "<group>"; };
-		4C3406BC18D96EA600DFA14A /* logging.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = logging.h; sourceTree = "<group>"; };
 		4C3406BD18D96EA600DFA14A /* ls_defines.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ls_defines.h; sourceTree = "<group>"; };
 		4C3406BE18D96EA600DFA14A /* macros.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = macros.h; sourceTree = "<group>"; };
 		4C3406BF18D96EA600DFA14A /* mc_common.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = mc_common.h; sourceTree = "<group>"; };
 		4C3406C418D96EA600DFA14A /* cpu.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = cpu.cpp; sourceTree = "<group>"; };
 		4C3406C518D96EA600DFA14A /* crt_util_safe_x.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = crt_util_safe_x.cpp; sourceTree = "<group>"; };
 		4C3406C618D96EA600DFA14A /* deblocking_common.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = deblocking_common.cpp; sourceTree = "<group>"; };
-		4C3406C718D96EA600DFA14A /* logging.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = logging.cpp; sourceTree = "<group>"; };
 		4C3406C818D96EA600DFA14A /* WelsThreadLib.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = WelsThreadLib.cpp; sourceTree = "<group>"; };
 		4CC61F0818FF6B4B00E56EAB /* copy_mb_neon.S */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.asm; path = copy_mb_neon.S; sourceTree = "<group>"; };
 		4CE443D518B722CD0017DF25 /* libcommon.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = libcommon.a; sourceTree = BUILT_PRODUCTS_DIR; };
 				4C3406B918D96EA600DFA14A /* crt_util_safe_x.h */,
 				53C1C9BA193F0F9E00404D8F /* expand_pic.h */,
 				4C3406BA18D96EA600DFA14A /* deblocking_common.h */,
-				4C3406BC18D96EA600DFA14A /* logging.h */,
 				4C3406BD18D96EA600DFA14A /* ls_defines.h */,
 				4C3406BE18D96EA600DFA14A /* macros.h */,
 				4C3406BF18D96EA600DFA14A /* mc_common.h */,
 				4C3406C518D96EA600DFA14A /* crt_util_safe_x.cpp */,
 				53C1C9BB193F0FB000404D8F /* expand_pic.cpp */,
 				4C3406C618D96EA600DFA14A /* deblocking_common.cpp */,
-				4C3406C718D96EA600DFA14A /* logging.cpp */,
 				4C3406C818D96EA600DFA14A /* WelsThreadLib.cpp */,
 			);
 			path = src;
 				F556A8241906673900E156A8 /* arm_arch64_common_macro.S in Sources */,
 				4C3406CE18D96EA600DFA14A /* crt_util_safe_x.cpp in Sources */,
 				4C3406CF18D96EA600DFA14A /* deblocking_common.cpp in Sources */,
-				4C3406D018D96EA600DFA14A /* logging.cpp in Sources */,
 				4C3406D118D96EA600DFA14A /* WelsThreadLib.cpp in Sources */,
 				4C3406CC18D96EA600DFA14A /* mc_neon.S in Sources */,
 				4C3406CB18D96EA600DFA14A /* expand_picture_neon.S in Sources */,

codec/build/win32/dec/WelsDecCore.vcproj+0−4

 					RelativePath="..\..\..\decoder\core\src\get_intra_predictor.cpp"
 					>
 				</File>
-				<File
-					RelativePath="..\..\..\common\src\logging.cpp"
-					>
-				</File>
 				<File
 					RelativePath="..\..\..\decoder\core\src\manage_dec_ref.cpp"
 					>

codec/build/win32/dec/decConsole.vcproj+0−4

 				RelativePath="..\..\..\console\dec\src\h264dec.cpp"
 				>
 			</File>
-			<File
-				RelativePath="..\..\..\common\src\logging.cpp"
-				>
-			</File>
 			<File
 				RelativePath="..\..\..\console\dec\src\read_config.cpp"
 				>

codec/build/win32/enc/WelsEncCore.vcproj+0−4

 				RelativePath="..\..\..\encoder\core\src\get_intra_predictor.cpp"
 				>
 			</File>
-			<File
-				RelativePath="..\..\..\common\src\logging.cpp"
-				>
-			</File>
 			<File
 				RelativePath="..\..\..\encoder\core\src\mc.cpp"
 				>

codec/build/win32/enc/encConsole.vcproj+0−4

 			Name="Source Files"
 			Filter="cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
 			>
-			<File
-				RelativePath="..\..\..\common\src\logging.cpp"
-				>
-			</File>
 			<File
 				RelativePath="..\..\..\console\enc\src\read_config.cpp"
 				>

codec/common/inc/logging.h+0−54

@@ -1,54 +0,0 @@
1	/*!
2	* \copy
3	* Copyright (c) 2013, Cisco Systems
4	* Copyright (c) 2013, Mozilla
5	* All rights reserved.
6	*
7	* Redistribution and use in source and binary forms, with or without
8	* modification, are permitted provided that the following conditions
9	* are met:
10	*
11	* * Redistributions of source code must retain the above copyright
12	* notice, this list of conditions and the following disclaimer.
13	*
14	* * Redistributions in binary form must reproduce the above copyright
15	* notice, this list of conditions and the following disclaimer in
16	* the documentation and/or other materials provided with the
17	* distribution.
18	*
19	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20	* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21	* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
22	* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
23	* COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
24	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
25	* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
26	* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
27	* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
29	* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30	* POSSIBILITY OF SUCH DAMAGE.
31	*
32	*/
33
34
35	#ifndef WELS_LOGGING_H__
36	#define WELS_LOGGING_H__
37
38	// API surface.
39	void WelsStderrSetTraceLevel (int32_t level);
40
41
42	// Internal details.
43	int32_t welsStderrLevelTrace (int32_t level, const char* format, va_list ap);
44
45	template<int level> int32_t welsStderrTrace (
46	const char* format, ...) {
47	va_list ap;
48	va_start (ap, format);
49	welsStderrLevelTrace (level, format, ap);
50	va_end (ap);
51	return 0;
52	}
53
54	#endif

codec/common/inc/utils.h+5−23

  *	Log output routines
  */
-typedef int32_t	iWelsLogLevel;
 enum {
   WELS_LOG_QUIET		= 0x00,		// Quiet mode
   WELS_LOG_ERROR		= 1 << 0,	// Error log iLevel
   WELS_LOG_DEBUG		= 1 << 3,	// Debug log iLevel
   WELS_LOG_RESV		= 1 << 4,	// Resversed log iLevel
   WELS_LOG_LEVEL_COUNT = 5,
-  WELS_LOG_DEFAULT	= WELS_LOG_ERROR | WELS_LOG_WARNING | WELS_LOG_INFO | WELS_LOG_DEBUG	// Default log iLevel in Wels codec
+  WELS_LOG_DEFAULT	= WELS_LOG_DEBUG	// Default log iLevel in Wels codec
 };
 /*
 // wels log output
 typedef void (*PWelsLogCallbackFunc) (void* pCtx, const int32_t iLevel, const char* kpFmt, va_list argv);
-// wels psnr calc
+typedef struct TagLogContext {
-typedef float (*PWelsPsnrFunc) (const void* kpTarPic,
+  PWelsLogCallbackFunc pfLog;
-                                const int32_t kiTarStride,
+  void* pLogCtx;
-                                const void* kpRefPic,
+} SLogContext;
-                                const int32_t kiRefStride,
-                                const int32_t kiWidth,
-                                const int32_t kiHeight);
 #ifdef __GNUC__
 extern void WelsLog (void* pCtx, int32_t iLevel, const char* kpFmt, ...);
 #endif
-/*!
- *************************************************************************************
- * \brief	set log callback from external call
- *
- * \param	_log	log function routine
- *
- * \return	NONE
- *
- * \note	N/A
- *************************************************************************************
- */
-void WelsSetLogCallback (PWelsLogCallbackFunc _log);
 /*
  *	PSNR calculation routines
  */

codec/common/inc/welsCodecTrace.h+12−9

 #include <stdarg.h>
 #include "typedefs.h"
+#include "utils.h"
-typedef int32_t (*CM_WELS_TRACE) (const char* format, ...);
+typedef void (*CM_WELS_TRACE) (void* ctx, int level, const char* string);
 class welsCodecTrace {
  public:
   welsCodecTrace();
   ~welsCodecTrace();
-  static void TraceString (int32_t iLevel, const char* kpStrFormat);
-  static void CODEC_TRACE (void* pIgnore, const int32_t kiLevel, const char* kpStrFormat, va_list vl);
   void SetTraceLevel (const int32_t kiLevel);
+  void SetTraceCallback (CM_WELS_TRACE func);
+  void SetTraceCallbackContext (void* pCtx);
+ private:
+  static void StaticCodecTrace (void* pCtx, const int32_t kiLevel, const char* kpStrFormat, va_list vl);
+  void CodecTrace (const int32_t kiLevel, const char* kpStrFormat, va_list vl);
+  int32_t	m_iTraceLevel;
+  CM_WELS_TRACE m_fpTrace;
+  void*         m_pTraceCtx;
  public:
-  static int32_t	m_iTraceLevel;
-  static CM_WELS_TRACE m_fpDebugTrace;
-  static CM_WELS_TRACE m_fpInfoTrace;
-  static CM_WELS_TRACE m_fpWarnTrace;
-  static CM_WELS_TRACE m_fpErrorTrace;
+  SLogContext m_sLogCtx;
 };
 #endif //WELS_CODEC_TRACE

codec/common/src/logging.cpp+0−49

@@ -1,49 +0,0 @@
1	/*!
2	* \copy
3	* Copyright (c) 2013, Cisco Systems
4	* Copyright (c) 2013, Mozilla
5	* All rights reserved.
6	*
7	* Redistribution and use in source and binary forms, with or without
8	* modification, are permitted provided that the following conditions
9	* are met:
10	*
11	* * Redistributions of source code must retain the above copyright
12	* notice, this list of conditions and the following disclaimer.
13	*
14	* * Redistributions in binary form must reproduce the above copyright
15	* notice, this list of conditions and the following disclaimer in
16	* the documentation and/or other materials provided with the
17	* distribution.
18	*
19	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20	* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21	* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
22	* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
23	* COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
24	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
25	* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
26	* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
27	* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
29	* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30	* POSSIBILITY OF SUCH DAMAGE.
31	*
32	*/
33
34	#include <stdarg.h>
35	#include <stdio.h>
36	#include "typedefs.h"
37
38	static int32_t g_TraceLevel = 0;
39
40	void WelsStderrSetTraceLevel (int32_t level) {
41	g_TraceLevel = level;
42	}
43
44	int32_t welsStderrLevelTrace (int32_t level, const char* format, va_list ap) {
45	if (level < g_TraceLevel) {
46	vfprintf (stderr, format, ap);
47	}
48	return 0;
49	}

codec/common/src/utils.cpp+2−18

@@ -48,27 +48,11 @@ float WelsCalcPsnr (const void* kpTarPic, · 47 unmodified lines
48	const int32_t kiHeight);	48	const int32_t kiHeight);
49		49
50		50
51	static PWelsLogCallbackFunc wlog;
52
53	/*!
54	*************************************************************************************
55	* \brief set log callback from external call
56	*
57	* \param _log log function routine
58	*
59	* \return NONE
60	*
61	* \note N/A
62	*************************************************************************************
63	*/
64	void WelsSetLogCallback (PWelsLogCallbackFunc _log) {
65	wlog = _log;
66	}
67
68	void WelsLog (void* pCtx, int32_t iLevel, const char* kpFmt, ...) {	51	void WelsLog (void* pCtx, int32_t iLevel, const char* kpFmt, ...) {
		52	SLogContext* logCtx = (SLogContext*) pCtx;
69	va_list vl;	53	va_list vl;
70	va_start (vl, kpFmt);	54	va_start (vl, kpFmt);
71	wlog (pCtx, iLevel, kpFmt, vl);	55	logCtx->pfLog (logCtx->pLogCtx, iLevel, kpFmt, vl);
72	va_end (vl);	56	va_end (vl);
73	}	57	}
74		58

codec/common/src/welsCodecTrace.cpp+25−42

@@ -44,57 +44,34 @@ · 43 unmodified lines
44	#include "welsCodecTrace.h"	44	#include "welsCodecTrace.h"
45	#include "utils.h"	45	#include "utils.h"
46		46
47	#include "logging.h"
48		47
49	int32_t welsCodecTrace::m_iTraceLevel = WELS_LOG_DEFAULT;	48
50	CM_WELS_TRACE welsCodecTrace::m_fpDebugTrace = NULL;	49	static void welsStderrTrace (void* ctx, int level, const char* string) {
51	CM_WELS_TRACE welsCodecTrace::m_fpInfoTrace = NULL;	50	fprintf (stderr, "%s", string);
52	CM_WELS_TRACE welsCodecTrace::m_fpWarnTrace = NULL;	51	}
53	CM_WELS_TRACE welsCodecTrace::m_fpErrorTrace = NULL;
54		52
55	welsCodecTrace::welsCodecTrace() {	53	welsCodecTrace::welsCodecTrace() {
56		54
57	m_fpDebugTrace = welsStderrTrace<WELS_LOG_DEBUG>;	55	m_iTraceLevel = WELS_LOG_DEFAULT;
58	m_fpInfoTrace = welsStderrTrace<WELS_LOG_INFO>;	56	m_fpTrace = welsStderrTrace;
59	m_fpWarnTrace = welsStderrTrace<WELS_LOG_WARNING>;	57	m_pTraceCtx = NULL;
60	m_fpErrorTrace = welsStderrTrace<WELS_LOG_ERROR>;
61	}
62		58
63	welsCodecTrace::~welsCodecTrace() {	59	m_sLogCtx.pLogCtx = this;
64	m_fpDebugTrace = NULL;	60	m_sLogCtx.pfLog = StaticCodecTrace;
65	m_fpInfoTrace = NULL;
66	m_fpWarnTrace = NULL;
67	m_fpErrorTrace = NULL;
68	}	61	}
69		62
70	void welsCodecTrace::TraceString (int32_t iLevel, const char* str) {	63	welsCodecTrace::~welsCodecTrace() {
71	switch (iLevel) {	64	m_fpTrace = NULL;
72	case WELS_LOG_ERROR:
73	if (m_fpErrorTrace)
74	m_fpErrorTrace ("%s", str);
75	break;
76	case WELS_LOG_WARNING:
77	if (m_fpWarnTrace)
78	m_fpWarnTrace ("%s", str);
79	break;
80	case WELS_LOG_INFO:
81	if (m_fpInfoTrace)
82	m_fpInfoTrace ("%s", str);
83	break;
84	case WELS_LOG_DEBUG:
85	if (m_fpDebugTrace)
86	m_fpDebugTrace ("%s", str);
87	break;
88	default:
89	if (m_fpDebugTrace)
90	m_fpInfoTrace ("%s", str);
91	break;
92	}
93	}	65	}
94		66
95	#define MAX_LOG_SIZE 1024	67	#define MAX_LOG_SIZE 1024
96		68
97	void welsCodecTrace::CODEC_TRACE (void* ignore, const int32_t iLevel, const char* Str_Format, va_list vl) {	69	void welsCodecTrace::StaticCodecTrace (void* pCtx, const int32_t iLevel, const char* Str_Format, va_list vl) {
		70	welsCodecTrace* self = (welsCodecTrace*) pCtx;
		71	self->CodecTrace (iLevel, Str_Format, vl);
		72	}
		73
		74	void welsCodecTrace::CodecTrace (const int32_t iLevel, const char* Str_Format, va_list vl) {
98	if (m_iTraceLevel < iLevel) {	75	if (m_iTraceLevel < iLevel) {
99	return;	76	return;
100	}	77	}
@@ -102,13 +79,19 @@ void welsCodecTrace::CODEC_TRACE (void* ignore, const int32_t iLevel, const char · 1 unmodified line
102	char pBuf[MAX_LOG_SIZE] = {0};	79	char pBuf[MAX_LOG_SIZE] = {0};
103	WelsVsnprintf (pBuf, MAX_LOG_SIZE, Str_Format, vl); // confirmed_safe_unsafe_usage	80	WelsVsnprintf (pBuf, MAX_LOG_SIZE, Str_Format, vl); // confirmed_safe_unsafe_usage
104		81
105	welsCodecTrace::TraceString (iLevel, pBuf);	82	m_fpTrace (m_pTraceCtx, iLevel, pBuf);
106	}	83	}
107		84
108	void welsCodecTrace::SetTraceLevel (const int32_t iLevel) {	85	void welsCodecTrace::SetTraceLevel (const int32_t iLevel) {
109	if (iLevel >= 0)	86	if (iLevel >= 0)
110	m_iTraceLevel = iLevel;	87	m_iTraceLevel = iLevel;
111	WelsStderrSetTraceLevel (iLevel);
112	}	88	}
113		89
		90	void welsCodecTrace::SetTraceCallback (CM_WELS_TRACE func) {
		91	m_fpTrace = func;
		92	}
		93
		94	void welsCodecTrace::SetTraceCallbackContext (void* ctx) {
		95	m_pTraceCtx = ctx;
		96	}
114		97

codec/common/targets.mk+0−1

@@ -5,7 +5,6 @@ COMMON_CPP_SRCS=\ · 4 unmodified lines
5	$(COMMON_SRCDIR)/src/crt_util_safe_x.cpp\	5	$(COMMON_SRCDIR)/src/crt_util_safe_x.cpp\
6	$(COMMON_SRCDIR)/src/deblocking_common.cpp\	6	$(COMMON_SRCDIR)/src/deblocking_common.cpp\
7	$(COMMON_SRCDIR)/src/expand_pic.cpp\	7	$(COMMON_SRCDIR)/src/expand_pic.cpp\
8	$(COMMON_SRCDIR)/src/logging.cpp\
9	$(COMMON_SRCDIR)/src/sad_common.cpp\	8	$(COMMON_SRCDIR)/src/sad_common.cpp\
10	$(COMMON_SRCDIR)/src/utils.cpp\	9	$(COMMON_SRCDIR)/src/utils.cpp\
11	$(COMMON_SRCDIR)/src/welsCodecTrace.cpp\	10	$(COMMON_SRCDIR)/src/welsCodecTrace.cpp\

codec/console/dec/src/h264dec.cpp+6−3

 #include "typedefs.h"
 #include "measure_time.h"
 #include "d3d9_utils.h"
-#include "logging.h"
 using namespace std;
   SDecodingParam sDecParam = {0};
   string strInputFile (""), strOutputFile (""), strOptionFile ("");
+  int iLevelSetting = -1;
   sDecParam.sVideoProperty.size = sizeof (sDecParam.sVideoProperty);
         if (!strcmp (cmd, "-options")) {
           if (i + 1 < iArgC)
-            strOptionFile = pArgV[i++];
+            strOptionFile = pArgV[++i];
           else {
             printf ("options file not specified.\n");
             return 1;
           }
         } else if (!strcmp (cmd, "-trace")) {
           if (i + 1 < iArgC)
-            WelsStderrSetTraceLevel (atoi (pArgV[i++]));
+            iLevelSetting = atoi (pArgV[++i]);
           else {
             printf ("trace level not specified.\n");
             return 1;
     printf ("Create Decoder failed.\n");
     return 1;
   }
+  if (iLevelSetting >= 0) {
+    pDecoder->SetOption (DECODER_OPTION_TRACE_LEVEL, &iLevelSetting);
+  }
   if (pDecoder->Initialize (&sDecParam)) {
     printf ("Decoder initialization failed.\n");

codec/console/enc/src/welsenc.cpp+4−2

 #include "extern.h"
 #include "macros.h"
 #include "wels_const.h"
-#include "logging.h"
 #include "mt_defs.h"
 #include "WelsThreadLib.h"
 static void    SigIntHandler (int a) {
   g_iCtrlC = 1;
 }
-static int     g_LevelSetting = 0;
+static int     g_LevelSetting = -1;
 int ParseLayerConfig (CReadConfig& cRdLayerCfg, const int iLayer, SEncParamExt& pSvcParam, SFilesSet& sFileSet) {
   if (!cRdLayerCfg.ExistFile()) {
     iRet = 1;
     goto INSIDE_MEM_FREE;
   }
+  if (g_LevelSetting >= 0) {
+    pPtrEnc->SetOption (ENCODER_OPTION_TRACE_LEVEL, &g_LevelSetting);
+  }
   //finish reading the configurations
   iSourceWidth = pSrcPic->iPicWidth;
   iSourceHeight = pSrcPic->iPicHeight;

codec/decoder/core/inc/decoder.h+1−1

@@ -68,7 +68,7 @@ int32_t DecoderConfigParam (PWelsDecoderContext pCtx, const SDecodingParam* kpPa · 67 unmodified lines
68	* \note N/A	68	* \note N/A
69	*************************************************************************************	69	*************************************************************************************
70	*/	70	*/
71	int32_t WelsInitDecoder (PWelsDecoderContext pCtx);	71	int32_t WelsInitDecoder (PWelsDecoderContext pCtx, SLogContext* pLogCtx);
72		72
73	/*!	73	/*!
74	*************************************************************************************	74	*************************************************************************************

codec/decoder/core/inc/decoder_context.h+1−0

@@ -164,6 +164,7 @@ enum { · 163 unmodified lines
164	*/	164	*/
165		165
166	typedef struct TagWelsDecoderContext {	166	typedef struct TagWelsDecoderContext {
		167	SLogContext sLogCtx;
167	// Input	168	// Input
168	void* pArgDec; // structured arguments for decoder, reserved here for extension in the future	169	void* pArgDec; // structured arguments for decoder, reserved here for extension in the future
169		170

codec/decoder/core/src/decoder.cpp+4−3

 /*
  * fill data fields in default for decoder context
  */
-void WelsDecoderDefaults (PWelsDecoderContext pCtx) {
+void WelsDecoderDefaults (PWelsDecoderContext pCtx, SLogContext* pLogCtx) {
   int32_t iCpuCores               = 1;
   memset (pCtx, 0, sizeof (SWelsDecoderContext));	// fill zero first
+  pCtx->sLogCtx = *pLogCtx;
   pCtx->pArgDec                   = NULL;
  * \note	N/A
  *************************************************************************************
  */
-int32_t WelsInitDecoder (PWelsDecoderContext pCtx) {
+int32_t WelsInitDecoder (PWelsDecoderContext pCtx, SLogContext* pLogCtx) {
   if (pCtx == NULL) {
     return ERR_INFO_INVALID_PTR;
   }
   // default
-  WelsDecoderDefaults (pCtx);
+  WelsDecoderDefaults (pCtx, pLogCtx);
   // open decoder
   WelsOpenDecoder (pCtx);

codec/decoder/plus/src/welsDecoderExt.cpp+36−12

   m_pWelsTrace	= new welsCodecTrace();
   if (m_pWelsTrace != NULL) {
     m_pWelsTrace->SetTraceLevel (WELS_LOG_ERROR);
-    WelsSetLogCallback (welsCodecTrace::CODEC_TRACE);
-  }
-  WelsLog (NULL, WELS_LOG_INFO, "CWelsDecoder::CWelsDecoder() entry");
+    WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO, "CWelsDecoder::CWelsDecoder() entry");
+  }
 #ifdef OUTPUT_BIT_STREAM
   SWelsTime sCurTime;
 *	return: none
 ***************************************************************************/
 CWelsDecoder::~CWelsDecoder() {
-  WelsLog (NULL, WELS_LOG_INFO, "CWelsDecoder::~CWelsDecoder()");
+  if (m_pWelsTrace != NULL) {
+    WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO, "CWelsDecoder::~CWelsDecoder()");
+  }
   UninitDecoder();
 }
 long CWelsDecoder::Initialize (const SDecodingParam* pParam) {
+  if (m_pWelsTrace == NULL) {
+    return cmMallocMemeError;
+  }
   if (pParam == NULL) {
-    WelsLog (NULL, WELS_LOG_INFO, "CWelsDecoder::Initialize(), invalid input argument.");
+    WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO, "CWelsDecoder::Initialize(), invalid input argument.");
     return cmInitParaError;
   }
   if (NULL == m_pDecContext)
     return;
-  WelsLog (NULL, WELS_LOG_INFO, "into CWelsDecoder::uninit_decoder()..");
+  WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO, "into CWelsDecoder::uninit_decoder()..");
   WelsEndDecoder (m_pDecContext);
     m_pDecContext	= NULL;
   }
-  WelsLog (NULL , WELS_LOG_INFO, "left CWelsDecoder::uninit_decoder()..");
+  WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO, "left CWelsDecoder::uninit_decoder()..");
 }
 // the return value of this function is not suitable, it need report failure info to upper layer.
 void CWelsDecoder::InitDecoder (void) {
-  WelsLog (NULL, WELS_LOG_INFO, "CWelsDecoder::init_decoder()..");
+  WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO, "CWelsDecoder::init_decoder()..");
   m_pDecContext	= (PWelsDecoderContext)WelsMalloc (sizeof (SWelsDecoderContext), "m_pDecContext");
-  WelsInitDecoder (m_pDecContext);
+  WelsInitDecoder (m_pDecContext, &m_pWelsTrace->m_sLogCtx);
-  WelsLog (NULL, WELS_LOG_INFO, "CWelsDecoder::init_decoder().. left");
+  WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO, "CWelsDecoder::init_decoder().. left");
 }
 /*
 long CWelsDecoder::SetOption (DECODER_OPTION eOptID, void* pOption) {
   int iVal = 0;
-  if (m_pDecContext == NULL)
+  if (m_pDecContext == NULL && eOptID != DECODER_OPTION_TRACE_LEVEL &&
+      eOptID != DECODER_OPTION_TRACE_CALLBACK && eOptID != DECODER_OPTION_TRACE_CALLBACK_CONTEXT)
     return dsInitialOptExpected;
   if (eOptID == DECODER_OPTION_DATAFORMAT) { // Set color space of decoding output frame
       iVal = * ((int*)pOption); //EC method
     m_pDecContext->iErrorConMethod = iVal;
     return cmResultSuccess;
+  } else if (eOptID == DECODER_OPTION_TRACE_LEVEL) {
+    if (m_pWelsTrace) {
+      uint32_t level = * ((uint32_t*)pOption);
+      m_pWelsTrace->SetTraceLevel (level);
+    }
+    return cmResultSuccess;
+  } else if (eOptID == DECODER_OPTION_TRACE_CALLBACK) {
+    if (m_pWelsTrace) {
+      CM_WELS_TRACE callback = * ((CM_WELS_TRACE*)pOption);
+      m_pWelsTrace->SetTraceCallback (callback);
+    }
+    return cmResultSuccess;
+  } else if (eOptID == DECODER_OPTION_TRACE_CALLBACK_CONTEXT) {
+    if (m_pWelsTrace) {
+      void* ctx = * ((void**)pOption);
+      m_pWelsTrace->SetTraceCallbackContext (ctx);
+    }
+    return cmResultSuccess;
   }
   return cmInitParaError;
       }
     }
-    WelsLog (NULL, WELS_LOG_INFO, "decode failed, failure type:%d \n",
+    WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO, "decode failed, failure type:%d \n",
              m_pDecContext->iErrorCode);
     return (DECODING_STATE)m_pDecContext->iErrorCode;
   }

codec/encoder/core/inc/encoder_context.h+2−0

 #include "wels_preprocess.h"
 #include "wels_func_ptr_def.h"
 #include "crt_util_safe_x.h"
+#include "utils.h"
 #include "mt_defs.h"	// for multiple threadin,
 #include "WelsThreadLib.h"
 } SStrideTables;
 typedef struct TagWelsEncCtx {
+  SLogContext sLogCtx;
   // Input
   SWelsSvcCodingParam*		pSvcParam;	// SVC parameter, WelsSVCParamConfig in svc_param_settings.h
   SWelsSliceBs*		 	pSliceBs;		// bitstream buffering for various slices, [uiSliceIdx]

codec/encoder/core/inc/extern.h+3−3

codec/encoder/core/inc/slice_multi_threading.h+2−2

@@ -81,8 +81,8 @@ WELS_THREAD_ROUTINE_TYPE CodingSliceThreadProc (void* arg); · 80 unmodified lines
81		81
82	int32_t CreateSliceThreads (sWelsEncCtx* pCtx);	82	int32_t CreateSliceThreads (sWelsEncCtx* pCtx);
83		83
84	int32_t FiredSliceThreads (SSliceThreadPrivateData* pPriData, WELS_EVENT* pEventsList, WELS_EVENT* pMasterEventsList,	84	int32_t FiredSliceThreads (sWelsEncCtx* pCtx, SSliceThreadPrivateData* pPriData, WELS_EVENT* pEventsList,
85	SLayerBSInfo* pLayerBsInfo,	85	WELS_EVENT* pMasterEventsList, SLayerBSInfo* pLayerBsInfo,
86	const uint32_t kuiNumThreads/, int32_t iLayerNum/, SSliceCtx pSliceCtx, const bool kbIsDynamicSlicingMode);	86	const uint32_t kuiNumThreads/, int32_t iLayerNum/, SSliceCtx pSliceCtx, const bool kbIsDynamicSlicingMode);
87		87
88	int32_t DynamicDetectCpuCores();	88	int32_t DynamicDetectCpuCores();

codec/encoder/core/src/encoder_ext.cpp+36−28

  * \pParam	pParam		SWelsSvcCodingParam*
  * \return	successful - 0; otherwise none 0 for failed
  */
-int32_t ParamValidation (SWelsSvcCodingParam* pCfg) {
+int32_t ParamValidation (SLogContext* pLogCtx, SWelsSvcCodingParam* pCfg) {
   float fMaxFrameRate = 0.0f;
   const float fEpsn = 0.000001f;
   int32_t i = 0;
   assert (pCfg != NULL);
   if ((pCfg->iUsageType != CAMERA_VIDEO_REAL_TIME) && (pCfg->iUsageType != SCREEN_CONTENT_REAL_TIME)) {
-    WelsLog (NULL, WELS_LOG_ERROR, "ParamValidation(),Invalid usage type = %d\n", pCfg->iUsageType);
+    WelsLog (pLogCtx, WELS_LOG_ERROR, "ParamValidation(),Invalid usage type = %d\n", pCfg->iUsageType);
     return ENC_RETURN_UNSUPPORTED_PARA;
   }
   for (i = 0; i < pCfg->iSpatialLayerNum; ++ i) {
     if (fDlp->fOutputFrameRate > fDlp->fInputFrameRate || (fDlp->fInputFrameRate >= -fEpsn
         && fDlp->fInputFrameRate <= fEpsn)
         || (fDlp->fOutputFrameRate >= -fEpsn && fDlp->fOutputFrameRate <= fEpsn)) {
-      WelsLog (NULL, WELS_LOG_ERROR,
+      WelsLog (pLogCtx, WELS_LOG_ERROR,
                "Invalid settings in input frame rate(%.6f) or output frame rate(%.6f) of layer #%d config file..\n",
                fDlp->fInputFrameRate, fDlp->fOutputFrameRate, i);
       return ENC_RETURN_INVALIDINPUT;
     }
     if (UINT_MAX == GetLogFactor (fDlp->fOutputFrameRate, fDlp->fInputFrameRate)) {
-      WelsLog (NULL, WELS_LOG_ERROR,
+      WelsLog (pLogCtx, WELS_LOG_ERROR,
                "Invalid settings in input frame rate(%.6f) and output frame rate(%.6f) of layer #%d config file: iResult of output frame rate divided by input frame rate should be power of 2(i.e,in/pOut=2^n)..\n",
                fDlp->fInputFrameRate, fDlp->fOutputFrameRate, i);
       return ENC_RETURN_INVALIDINPUT;
       iTotalBitrate += fDlp->iSpatialBitrate;
     }
     if (iTotalBitrate > pCfg->iTargetBitrate) {
-      WelsLog (NULL, WELS_LOG_ERROR,
+      WelsLog (pLogCtx, WELS_LOG_ERROR,
                "Invalid settings in bitrate. the sum of each layer bitrate(%d) is larger than total bitrate setting(%d)\n",
                iTotalBitrate, pCfg->iTargetBitrate);
     }
 }
-int32_t ParamValidationExt (sWelsEncCtx* pCtx, SWelsSvcCodingParam* pCodingParam) {
+int32_t ParamValidationExt (SLogContext* pCtx, SWelsSvcCodingParam* pCodingParam) {
   int8_t i = 0;
   int32_t iIdx = 0;
     }
   }
-  return ParamValidation (pCodingParam);
+  return ParamValidation (pCtx, pCodingParam);
 }
 }
-void WelsEncoderApplyBitRate (SWelsSvcCodingParam* pParam, int iLayer) {
+void WelsEncoderApplyBitRate (SLogContext* pLogCtx, SWelsSvcCodingParam* pParam, int iLayer) {
   //TODO (Sijia):  this is a temporary solution which keep the ratio between layers
   //but it is also possible to fulfill the bitrate of lower layer first
   int32_t i, iOrigTotalBitrate = 0;
   if (iLayer == SPATIAL_LAYER_ALL) {
     if (pParam->iMaxBitrate < pParam->iTargetBitrate) {
-      WelsLog (NULL, WELS_LOG_WARNING,
+      WelsLog (pLogCtx, WELS_LOG_WARNING,
                "CWelsH264SVCEncoder::SetOption():ENCODER_OPTION_BITRATE,overall settting,TargetBitrate = %d,iMaxBitrate = %d\n",
                pParam->iTargetBitrate, pParam->iMaxBitrate);
       pParam->iMaxBitrate  = pParam->iTargetBitrate;
     }
   } else {
     if (pParam->sSpatialLayers[iLayer].iMaxSpatialBitrate < pParam->sSpatialLayers[iLayer].iSpatialBitrate) {
-      WelsLog (NULL, WELS_LOG_WARNING,
+      WelsLog (pLogCtx, WELS_LOG_WARNING,
                "CWelsH264SVCEncoder::SetOption():ENCODER_OPTION_BITRATE,iLayer = %d,iTargetBitrate = %d,iMaxBitrate = %d\n",
                iLayer, pParam->sSpatialLayers[iLayer].iSpatialBitrate, pParam->sSpatialLayers[iLayer].iMaxSpatialBitrate);
       pParam->sSpatialLayers[iLayer].iMaxSpatialBitrate = pParam->sSpatialLayers[iLayer].iSpatialBitrate;
 #endif//MEMORY_MONITOR
     if ((*ppCtx)->pMemAlign != NULL) {
-      WelsLog (NULL, WELS_LOG_INFO, "FreeMemorySvc(), verify memory usage (%d bytes) after free..\n",
+      WelsLog (*ppCtx, WELS_LOG_INFO, "FreeMemorySvc(), verify memory usage (%d bytes) after free..\n",
                (*ppCtx)->pMemAlign->WelsGetMemoryUsage());
       delete (*ppCtx)->pMemAlign;
       (*ppCtx)->pMemAlign = NULL;
   }
 }
-int32_t InitSliceSettings (SWelsSvcCodingParam* pCodingParam, const int32_t kiCpuCores, int16_t* pMaxSliceCount) {
+int32_t InitSliceSettings (SLogContext* pLogCtx, SWelsSvcCodingParam* pCodingParam, const int32_t kiCpuCores,
+                           int16_t* pMaxSliceCount) {
   int32_t iSpatialIdx = 0, iSpatialNum = pCodingParam->iSpatialLayerNum;
   uint16_t iMaxSliceCount = 0;
         pDlp->sSliceCfg.sSliceArgument.uiSliceNum = iMaxSliceCount;
       }
       if (pDlp->sSliceCfg.sSliceArgument.uiSliceNum == 1) {
-        WelsLog (NULL, WELS_LOG_DEBUG,
+        WelsLog (pLogCtx, WELS_LOG_DEBUG,
                  "InitSliceSettings(), uiSliceNum(%d) you set for SM_AUTO_SLICE, now turn to SM_SINGLE_SLICE type!\n",
                  pDlp->sSliceCfg.sSliceArgument.uiSliceNum);
         pDlp->sSliceCfg.uiSliceMode	= SM_SINGLE_SLICE;
       } else if (!CheckFixedSliceNumMultiSliceSetting (kiMbNumInFrame,
                  &pDlp->sSliceCfg.sSliceArgument)) {	// verify interleave mode settings
         //check uiSliceMbNum with current uiSliceNum
-        WelsLog (NULL, WELS_LOG_ERROR,
+        WelsLog (pLogCtx, WELS_LOG_ERROR,
                  "InitSliceSettings(), invalid uiSliceMbNum (%d) settings!,now turn to SM_SINGLE_SLICE type\n",
                  pDlp->sSliceCfg.sSliceArgument.uiSliceMbNum[0]);
         pDlp->sSliceCfg.uiSliceMode	= SM_SINGLE_SLICE;
 /*!
  * \brief	log output for cpu features/capabilities
  */
-void OutputCpuFeaturesLog (uint32_t uiCpuFeatureFlags, uint32_t uiCpuCores, int32_t iCacheLineSize) {
+void OutputCpuFeaturesLog (SLogContext* pLogCtx, uint32_t uiCpuFeatureFlags, uint32_t uiCpuCores,
+                           int32_t iCacheLineSize) {
   // welstracer output
-  WelsLog (NULL, WELS_LOG_INFO, "WELS CPU features/capacities (0x%x) detected: \t"	\
+  WelsLog (pLogCtx, WELS_LOG_INFO, "WELS CPU features/capacities (0x%x) detected: \t"	\
            "HTT:      %c, "	\
            "MMX:      %c, "	\
            "MMXEX:    %c, "	\
  * \pParam	pParam		SWelsSvcCodingParam*
  * \return	successful - 0; otherwise none 0 for failed
  */
-int32_t WelsInitEncoderExt (sWelsEncCtx** ppCtx, SWelsSvcCodingParam* pCodingParam) {
+int32_t WelsInitEncoderExt (sWelsEncCtx** ppCtx, SWelsSvcCodingParam* pCodingParam, SLogContext* pLogCtx) {
   sWelsEncCtx* pCtx		= NULL;
   int32_t	iRet					= 0;
   uint32_t uiCpuFeatureFlags		= 0;	// CPU features
   int16_t iSliceNum				= 1;	// number of slices used
   if (NULL == ppCtx || NULL == pCodingParam) {
-    WelsLog (NULL, WELS_LOG_ERROR, "WelsInitEncoderExt(), NULL == ppCtx(0x%p) or NULL == pCodingParam(0x%p).\n",
+    WelsLog (pLogCtx, WELS_LOG_ERROR, "WelsInitEncoderExt(), NULL == ppCtx(0x%p) or NULL == pCodingParam(0x%p).\n",
              (void*)ppCtx, (void*)pCodingParam);
     return 1;
   }
-  iRet	=	ParamValidationExt (*ppCtx, pCodingParam);
+  iRet	=	ParamValidationExt (pLogCtx, pCodingParam);
   if (iRet != 0) {
-    WelsLog (NULL, WELS_LOG_ERROR, "WelsInitEncoderExt(), ParamValidationExt failed return %d.\n", iRet);
+    WelsLog (pLogCtx, WELS_LOG_ERROR, "WelsInitEncoderExt(), ParamValidationExt failed return %d.\n", iRet);
     return iRet;
   }
     iCacheLineSize	= 32;
   else if (uiCpuFeatureFlags & WELS_CPU_CACHELINE_16)
     iCacheLineSize	= 16;
-  OutputCpuFeaturesLog (uiCpuFeatureFlags, uiCpuCores, iCacheLineSize);
+  OutputCpuFeaturesLog (pLogCtx, uiCpuFeatureFlags, uiCpuCores, iCacheLineSize);
 #else
   iCacheLineSize	= 16;	// 16 bytes aligned in default
 #endif//X86_ASM
   uiCpuCores	= WELS_CLIP3 (uiCpuCores, 1, MAX_THREADS_NUM);
-  if (InitSliceSettings (pCodingParam, uiCpuCores, &iSliceNum)) {
+  if (InitSliceSettings (pLogCtx, pCodingParam, uiCpuCores, &iSliceNum)) {
-    WelsLog (NULL, WELS_LOG_ERROR, "WelsInitEncoderExt(), InitSliceSettings failed.\n");
+    WelsLog (pLogCtx, WELS_LOG_ERROR, "WelsInitEncoderExt(), InitSliceSettings failed.\n");
     return 1;
   }
   WELS_VERIFY_RETURN_IF (1, (NULL == pCtx))
   memset (pCtx, 0, sizeof (sWelsEncCtx));
+  pCtx->sLogCtx = *pLogCtx;
   pCtx->pMemAlign = new CMemoryAlign (iCacheLineSize);
   WELS_VERIFY_RETURN_PROC_IF (1, (NULL == pCtx->pMemAlign), FreeMemorySvc (&pCtx))
           pCtx->iActiveThreadsNum	= iSliceCount;
           // to fire slice coding threads
-          iRet = FiredSliceThreads (&pCtx->pSliceThreading->pThreadPEncCtx[0], &pCtx->pSliceThreading->pReadySliceCodingEvent[0],
+          iRet = FiredSliceThreads (pCtx, &pCtx->pSliceThreading->pThreadPEncCtx[0],
+                                    &pCtx->pSliceThreading->pReadySliceCodingEvent[0],
                                     &pCtx->pSliceThreading->pThreadMasterEvent[0],
                                     pLayerBsInfo, iSliceCount, pCtx->pCurDqLayer->pSliceEncCtx, false);
           if (iRet) {
           iNumThreadsScheduled	= pCtx->iActiveThreadsNum;
           iNumThreadsRunning		= iNumThreadsScheduled;
           // to fire slice coding threads
-          iRet = FiredSliceThreads (&pCtx->pSliceThreading->pThreadPEncCtx[0], &pCtx->pSliceThreading->pReadySliceCodingEvent[0],
+          iRet = FiredSliceThreads (pCtx, &pCtx->pSliceThreading->pThreadPEncCtx[0],
+                                    &pCtx->pSliceThreading->pReadySliceCodingEvent[0],
                                     &pCtx->pSliceThreading->pThreadMasterEvent[0],
                                     pLayerBsInfo, iNumThreadsRunning, pCtx->pCurDqLayer->pSliceEncCtx, false);
           if (iRet) {
         const int32_t kiPartitionCnt	= pCtx->iActiveThreadsNum; //pSvcParam->iCountThreadsNum;
         // to fire slice coding threads
-        iRet = FiredSliceThreads (&pCtx->pSliceThreading->pThreadPEncCtx[0], &pCtx->pSliceThreading->pReadySliceCodingEvent[0],
+        iRet = FiredSliceThreads (pCtx, &pCtx->pSliceThreading->pThreadPEncCtx[0],
+                                  &pCtx->pSliceThreading->pReadySliceCodingEvent[0],
                                   &pCtx->pSliceThreading->pThreadMasterEvent[0],
                                   pLayerBsInfo, kiPartitionCnt, pCtx->pCurDqLayer->pSliceEncCtx, true);
         if (iRet) {
   if (NULL == ppCtx || NULL == *ppCtx || NULL == pNewParam)	return 1;
   /* Check validation in new parameters */
-  iReturn	= ParamValidationExt (*ppCtx, pNewParam);
+  iReturn	= ParamValidationExt (& (*ppCtx)->sLogCtx, pNewParam);
   if (iReturn != ENC_RETURN_SUCCESS)	return iReturn;
   pOldParam	= (*ppCtx)->pSvcParam;
   if (bNeedReset) {
     SParaSetOffsetVariable sTmpPsoVariable[PARA_SET_TYPE];
     uint16_t	          uiTmpIdrPicId;//this is for LTR!
+    SLogContext sLogCtx = (*ppCtx)->sLogCtx;
     memcpy (sTmpPsoVariable, (*ppCtx)->sPSOVector.sParaSetOffsetVariable,
             (PARA_SET_TYPE)*sizeof (SParaSetOffsetVariable)); // confirmed_safe_unsafe_usage
     uiTmpIdrPicId = (*ppCtx)->sPSOVector.uiIdrPicId;
     WelsUninitEncoderExt (ppCtx);
     /* Update new parameters */
-    if (WelsInitEncoderExt (ppCtx, pNewParam))
+    if (WelsInitEncoderExt (ppCtx, pNewParam, &sLogCtx))
       return 1;
     // reset the scaled spatial picture size

codec/encoder/core/src/slice_multi_threading.cpp+3−3

@@ -968,15 +968,15 @@ int32_t CreateSliceThreads (sWelsEncCtx* pCtx) { · 967 unmodified lines
968	return 0;	968	return 0;
969	}	969	}
970		970
971	int32_t FiredSliceThreads (SSliceThreadPrivateData* pPriData, WELS_EVENT* pEventsList, WELS_EVENT* pMasterEventsList,	971	int32_t FiredSliceThreads (sWelsEncCtx* pCtx, SSliceThreadPrivateData* pPriData, WELS_EVENT* pEventsList,
972	SLayerBSInfo* pLbi,	972	WELS_EVENT* pMasterEventsList, SLayerBSInfo* pLbi,
973	const uint32_t uiNumThreads, SSliceCtx* pSliceCtx, const bool bIsDynamicSlicingMode) {	973	const uint32_t uiNumThreads, SSliceCtx* pSliceCtx, const bool bIsDynamicSlicingMode) {
974	int32_t iEndMbIdx = 0;	974	int32_t iEndMbIdx = 0;
975	int32_t iIdx = 0;	975	int32_t iIdx = 0;
976	const int32_t kiEventCnt = uiNumThreads;	976	const int32_t kiEventCnt = uiNumThreads;
977		977
978	if (pPriData == NULL \|\| pLbi == NULL \|\| kiEventCnt <= 0 \|\| pEventsList == NULL) {	978	if (pPriData == NULL \|\| pLbi == NULL \|\| kiEventCnt <= 0 \|\| pEventsList == NULL) {
979	WelsLog (NULL, WELS_LOG_ERROR,	979	WelsLog (pCtx, WELS_LOG_ERROR,
980	"FiredSliceThreads(), fail due pPriData == %p \|\| pLbi == %p \|\| iEventCnt(%d) <= 0 \|\| pEventsList == %p!!\n",	980	"FiredSliceThreads(), fail due pPriData == %p \|\| pLbi == %p \|\| iEventCnt(%d) <= 0 \|\| pEventsList == %p!!\n",
981	(void)pPriData, (void)pLbi, uiNumThreads, (void*)pEventsList);	981	(void)pPriData, (void)pLbi, uiNumThreads, (void*)pEventsList);
982	return 1;	982	return 1;

codec/encoder/plus/src/welsEncoderExt.cpp+68−38

 }
 CWelsH264SVCEncoder::~CWelsH264SVCEncoder() {
-  WelsLog (NULL, WELS_LOG_INFO, "CWelsH264SVCEncoder::~CWelsH264SVCEncoder()\n");
+  if (m_pWelsTrace) {
+    WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO, "CWelsH264SVCEncoder::~CWelsH264SVCEncoder()\n");
-  if (m_pWelsTrace != NULL) {
-    delete m_pWelsTrace;
-    m_pWelsTrace = NULL;
-  }
 #ifdef REC_FRAME_COUNT
-  WelsLog (m_pEncContext, WELS_LOG_INFO,
+    WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO,
-           "CWelsH264SVCEncoder::~CWelsH264SVCEncoder(), m_uiCountFrameNum= %d, m_iCspInternal= 0x%x\n", m_uiCountFrameNum,
+             "CWelsH264SVCEncoder::~CWelsH264SVCEncoder(), m_uiCountFrameNum= %d, m_iCspInternal= 0x%x\n", m_uiCountFrameNum,
-           m_iCspInternal);
+             m_iCspInternal);
 #endif
+  }
 #ifdef REC_FRAME_COUNT
   m_uiCountFrameNum = 0;
 #endif//OUTPUT_BIT_STREAM
   Uninitialize();
+  if (m_pWelsTrace) {
+    delete m_pWelsTrace;
+    m_pWelsTrace = NULL;
+  }
 }
 void CWelsH264SVCEncoder::InitEncoder (void) {
+  m_pWelsTrace	= new welsCodecTrace();
+  if (m_pWelsTrace == NULL) {
+    return;
+  }
+  m_pWelsTrace->SetTraceLevel (WELS_LOG_ERROR);
 #ifdef REC_FRAME_COUNT
-  WelsLog (m_pEncContext, WELS_LOG_INFO,
+  WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO,
            "CWelsH264SVCEncoder::InitEncoder, m_uiCountFrameNum= %d, m_iCspInternal= 0x%x\n", m_uiCountFrameNum, m_iCspInternal);
 #endif
-  m_pWelsTrace	= new welsCodecTrace();
-  if (m_pWelsTrace != NULL) {
-    m_pWelsTrace->SetTraceLevel (WELS_LOG_ERROR);
-    WelsSetLogCallback (welsCodecTrace::CODEC_TRACE);
-  }
 }
 /* Interfaces override from ISVCEncoder */
  *	SVC Encoder Initialization
  */
 int CWelsH264SVCEncoder::Initialize (const SEncParamBase* argv) {
+  if (m_pWelsTrace == NULL) {
+    return cmMallocMemeError;
+  }
   if (NULL == argv) {
-    WelsLog (m_pEncContext, WELS_LOG_ERROR, "CWelsH264SVCEncoder::Initialize(), invalid argv= 0x%p\n",
+    WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_ERROR, "CWelsH264SVCEncoder::Initialize(), invalid argv= 0x%p\n",
              argv);
     return cmInitParaError;
   }
   SWelsSvcCodingParam	sConfig;
   // Convert SEncParamBase into WelsSVCParamConfig here..
   if (sConfig.ParamBaseTranscode (*argv)) {
-    WelsLog (m_pEncContext, WELS_LOG_ERROR, "CWelsH264SVCEncoder::Initialize(), parameter_translation failed.\n");
+    WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_ERROR,
+             "CWelsH264SVCEncoder::Initialize(), parameter_translation failed.\n");
     Uninitialize();
     return cmInitParaError;
   }
 }
 int CWelsH264SVCEncoder::InitializeExt (const SEncParamExt* argv) {
+  if (m_pWelsTrace == NULL) {
+    return cmMallocMemeError;
+  }
   if (NULL == argv) {
-    WelsLog (m_pEncContext, WELS_LOG_ERROR, "CWelsH264SVCEncoder::InitializeExt(), invalid argv= 0x%p\n",
+    WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_ERROR, "CWelsH264SVCEncoder::InitializeExt(), invalid argv= 0x%p\n",
              argv);
     return cmInitParaError;
   }
   SWelsSvcCodingParam	sConfig;
   // Convert SEncParamExt into WelsSVCParamConfig here..
   if (sConfig.ParamTranscode (*argv)) {
-    WelsLog (m_pEncContext, WELS_LOG_ERROR, "CWelsH264SVCEncoder::InitializeExt(), parameter_translation failed.\n");
+    WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_ERROR,
+             "CWelsH264SVCEncoder::InitializeExt(), parameter_translation failed.\n");
     Uninitialize();
     return cmInitParaError;
   }
 int CWelsH264SVCEncoder::InitializeInternal (SWelsSvcCodingParam* pCfg) {
   if (NULL == pCfg) {
-    WelsLog (m_pEncContext, WELS_LOG_ERROR, "CWelsH264SVCEncoder::Initialize(), invalid argv= 0x%p.\n",
+    WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_ERROR, "CWelsH264SVCEncoder::Initialize(), invalid argv= 0x%p.\n",
              pCfg);
     return cmInitParaError;
   }
   if (m_bInitialFlag) {
-    WelsLog (m_pEncContext, WELS_LOG_WARNING, "CWelsH264SVCEncoder::Initialize(), reinitialize, m_bInitialFlag= %d.\n",
+    WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_WARNING,
+             "CWelsH264SVCEncoder::Initialize(), reinitialize, m_bInitialFlag= %d.\n",
              m_bInitialFlag);
     Uninitialize();
   }
 #ifdef REC_FRAME_COUNT
   SWelsSvcCodingParam& sEncodingParam = *pCfg;
-  WelsLog (m_pEncContext, WELS_LOG_INFO, "CWelsH264SVCEncoder::Initialize, m_uiCountFrameNum= %d, m_iCspInternal= 0x%x\n",
+  WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO,
+           "CWelsH264SVCEncoder::Initialize, m_uiCountFrameNum= %d, m_iCspInternal= 0x%x\n",
            m_uiCountFrameNum, m_iCspInternal);
-  WelsLog (m_pEncContext, WELS_LOG_INFO,
+  WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO,
            "coding_param->iPicWidth= %d;coding_param->iPicHeight= %d;coding_param->iTargetBitrate= %d;coding_param->iRCMode= %d;coding_param->iTemporalLayerNum= %d;coding_param->iSpatialLayerNum= %d;coding_param->fFrameRate= %.6ff;coding_param->iInputCsp= %d;coding_param->uiIntraPeriod= %d;coding_param->bEnableSpsPpsIdAddition = %d;coding_param->bPrefixNalAddingCtrl = %d;coding_param->bEnableDenoise= %d;coding_param->bEnableBackgroundDetection= %d;coding_param->bEnableAdaptiveQuant= %d;coding_param->bEnableFrameSkip= %d;coding_param->bEnableCropPic= %d;coding_param->bEnableLongTermReference= %d;coding_param->iLtrMarkPeriod= %d;\n",
            sEncodingParam.iPicWidth,
            sEncodingParam.iPicHeight,
   int32_t i = 0;
   while (i < sEncodingParam.iSpatialLayerNum) {
     SSpatialLayerConfig* spatial_cfg = &sEncodingParam.sSpatialLayers[i];
-    WelsLog (m_pEncContext, WELS_LOG_INFO,
+    WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO,
              "coding_param->sSpatialLayers[%d]: .iVideoWidth= %d; .iVideoHeight= %d; .fFrameRate= %.6ff; .iSpatialBitrate= %d; .sSliceCfg.uiSliceMode= %d; .sSliceCfg.sSliceArgument.uiSliceNum= %d; .sSliceCfg.sSliceArgument.uiSliceSizeConstraint= %d;\n",
              i, spatial_cfg->iVideoWidth,
              spatial_cfg->iVideoHeight,
   const int32_t iColorspace = pCfg->iInputCsp;
   if (videoFormatI420 != iColorspace) {
-    WelsLog (m_pEncContext, WELS_LOG_ERROR, "CWelsH264SVCEncoder::Initialize(), invalid iInputCsp= %d.\n", iColorspace);
+    WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_ERROR, "CWelsH264SVCEncoder::Initialize(), invalid iInputCsp= %d.\n",
+             iColorspace);
     Uninitialize();
     return cmInitParaError;
   }
   // Check valid parameters
   const int32_t iNumOfLayers = pCfg->iSpatialLayerNum;
   if (iNumOfLayers < 1 || iNumOfLayers > MAX_DEPENDENCY_LAYER) {
-    WelsLog (m_pEncContext, WELS_LOG_ERROR,
+    WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_ERROR,
              "CWelsH264SVCEncoder::Initialize(), invalid iSpatialLayerNum= %d, valid at range of [1, %d].\n", iNumOfLayers,
              MAX_DEPENDENCY_LAYER);
     Uninitialize();
   if (pCfg->iTemporalLayerNum < 1)
     pCfg->iTemporalLayerNum	= 1;
   if (pCfg->iTemporalLayerNum > MAX_TEMPORAL_LEVEL) {
-    WelsLog (m_pEncContext, WELS_LOG_ERROR,
+    WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_ERROR,
              "CWelsH264SVCEncoder::Initialize(), invalid iTemporalLayerNum= %d, valid at range of [1, %d].\n",
              pCfg->iTemporalLayerNum, MAX_TEMPORAL_LEVEL);
     Uninitialize();
   //	assert( cfg.uiGopSize >= 1 && ( cfg.uiIntraPeriod && (cfg.uiIntraPeriod % cfg.uiGopSize) == 0) );
   if (pCfg->uiGopSize < 1 || pCfg->uiGopSize > MAX_GOP_SIZE) {
-    WelsLog (m_pEncContext, WELS_LOG_ERROR,
+    WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_ERROR,
              "CWelsH264SVCEncoder::Initialize(), invalid uiGopSize= %d, valid at range of [1, %d].\n", pCfg->uiGopSize,
              MAX_GOP_SIZE);
     Uninitialize();
   }
   if (!WELS_POWER2_IF (pCfg->uiGopSize)) {
-    WelsLog (m_pEncContext, WELS_LOG_ERROR,
+    WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_ERROR,
              "CWelsH264SVCEncoder::Initialize(), invalid uiGopSize= %d, valid at range of [1, %d] and yield to power of 2.\n",
              pCfg->uiGopSize, MAX_GOP_SIZE);
     Uninitialize();
   }
   if (pCfg->uiIntraPeriod && pCfg->uiIntraPeriod < pCfg->uiGopSize) {
-    WelsLog (m_pEncContext, WELS_LOG_ERROR,
+    WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_ERROR,
              "CWelsH264SVCEncoder::Initialize(), invalid uiIntraPeriod= %d, valid in case it equals to 0 for unlimited intra period or exceeds specified uiGopSize= %d.\n",
              pCfg->uiIntraPeriod, pCfg->uiGopSize);
     Uninitialize();
   }
   if ((pCfg->uiIntraPeriod && (pCfg->uiIntraPeriod & (pCfg->uiGopSize - 1)) != 0)) {
-    WelsLog (m_pEncContext, WELS_LOG_ERROR,
+    WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_ERROR,
              "CWelsH264SVCEncoder::Initialize(), invalid uiIntraPeriod= %d, valid in case it equals to 0 for unlimited intra period or exceeds specified uiGopSize= %d also multiple of it.\n",
              pCfg->uiIntraPeriod, pCfg->uiGopSize);
     Uninitialize();
   m_iMaxPicWidth	= pCfg->iPicWidth;
   m_iMaxPicHeight	= pCfg->iPicHeight;
-  if (WelsInitEncoderExt (&m_pEncContext, pCfg)) {
+  if (WelsInitEncoderExt (&m_pEncContext, pCfg, &m_pWelsTrace->m_sLogCtx)) {
-    WelsLog (m_pEncContext, WELS_LOG_ERROR, "CWelsH264SVCEncoder::Initialize(), WelsInitEncoderExt failed.\n");
+    WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_ERROR, "CWelsH264SVCEncoder::Initialize(), WelsInitEncoderExt failed.\n");
     Uninitialize();
     return cmInitParaError;
   }
     return 0;
   }
-  WelsLog (m_pEncContext, WELS_LOG_INFO, "CWelsH264SVCEncoder::Uninitialize()..\n");
+  WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO, "CWelsH264SVCEncoder::Uninitialize()..\n");
 #ifdef REC_FRAME_COUNT
-  WelsLog (m_pEncContext, WELS_LOG_INFO,
+  WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO,
            "CWelsH264SVCEncoder::Uninitialize, m_uiCountFrameNum= %d, m_iCspInternal= 0x%x\n", m_uiCountFrameNum, m_iCspInternal);
 #endif//REC_FRAME_COUNT
     return cmInitParaError;
   }
-  if (NULL == m_pEncContext || false == m_bInitialFlag) {
+  if ((NULL == m_pEncContext || false == m_bInitialFlag) && eOptionId != ENCODER_OPTION_TRACE_LEVEL
+      && eOptionId != ENCODER_OPTION_TRACE_CALLBACK && eOptionId != ENCODER_OPTION_TRACE_CALLBACK_CONTEXT) {
     return cmInitExpected;
   }
       break;
     }
     //adjust to valid range
-    WelsEncoderApplyBitRate (m_pEncContext->pSvcParam, pInfo->iLayer);
+    WelsEncoderApplyBitRate (&m_pWelsTrace->m_sLogCtx, m_pEncContext->pSvcParam, pInfo->iLayer);
   }
   break;
   case ENCODER_OPTION_MAX_BITRATE: {	// Target bit-rate
       break;
     }
     //adjust to valid range
-    WelsEncoderApplyBitRate (m_pEncContext->pSvcParam, pInfo->iLayer);
+    WelsEncoderApplyBitRate (&m_pWelsTrace->m_sLogCtx, m_pEncContext->pSvcParam, pInfo->iLayer);
   }
   break;
   case ENCODER_OPTION_RC_MODE: {	// 0:quality mode;1:bit-rate mode;2:bitrate limited mode
     }
   }
   break;
+  case ENCODER_OPTION_TRACE_CALLBACK: {
+    if (m_pWelsTrace) {
+      CM_WELS_TRACE callback = * ((CM_WELS_TRACE*)pOption);
+      m_pWelsTrace->SetTraceCallback (callback);
+    }
+  }
+  break;
+  case ENCODER_OPTION_TRACE_CALLBACK_CONTEXT: {
+    if (m_pWelsTrace) {
+      void* ctx = * ((void**)pOption);
+      m_pWelsTrace->SetTraceCallbackContext (ctx);
+    }
+  }
+  break;
   default:
     return cmInitParaError;
   }

Merge pull request #945 from mstorsjo/log-callback

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code

@@ -64,7 +64,7 @@ int32_t InitPic (const void* kpSrc, const int32_t kiCsp, const int32_t kiWidth, · 63 unmodified lines
64	* \pParam pParam SWelsSvcCodingParam*	64	* \pParam pParam SWelsSvcCodingParam*
65	* \return successful - 0; otherwise none 0 for failed	65	* \return successful - 0; otherwise none 0 for failed
66	*/	66	*/
67	int32_t ParamValidationExt (sWelsEncCtx* pCtx, SWelsSvcCodingParam* pParam);	67	int32_t ParamValidationExt (SLogContext* pCtx, SWelsSvcCodingParam* pParam);
68		68
69	// GOM based RC related for uiSliceNum decision	69	// GOM based RC related for uiSliceNum decision
70	void GomValidCheck (const int32_t kiMbWidth, const int32_t kiMbHeight, int32_t* pSliceNum);	70	void GomValidCheck (const int32_t kiMbWidth, const int32_t kiMbHeight, int32_t* pSliceNum);
@@ -75,7 +75,7 @@ void GomValidCheck (const int32_t kiMbWidth, const int32_t kiMbHeight, int32_t* · 4 unmodified lines
75	* \param para SWelsSvcCodingParam*	75	* \param para SWelsSvcCodingParam*
76	* \return successful - 0; otherwise none 0 for failed	76	* \return successful - 0; otherwise none 0 for failed
77	*/	77	*/
78	int32_t WelsInitEncoderExt (sWelsEncCtx** ppCtx, SWelsSvcCodingParam* pPara);	78	int32_t WelsInitEncoderExt (sWelsEncCtx** ppCtx, SWelsSvcCodingParam* pPara, SLogContext* pLogCtx);
79		79
80	/*!	80	/*!
81	* \brief uninitialize Wels encoder core library	81	* \brief uninitialize Wels encoder core library
@@ -107,7 +107,7 @@ int32_t ForceCodingIDR (sWelsEncCtx* pCtx); · 25 unmodified lines
107	*/	107	*/
108	int32_t WelsEncoderParamAdjust (sWelsEncCtx** ppCtx, SWelsSvcCodingParam* pNew);	108	int32_t WelsEncoderParamAdjust (sWelsEncCtx** ppCtx, SWelsSvcCodingParam* pNew);
109	void WelsEncoderApplyFrameRate (SWelsSvcCodingParam* pParam);	109	void WelsEncoderApplyFrameRate (SWelsSvcCodingParam* pParam);
110	void WelsEncoderApplyBitRate (SWelsSvcCodingParam* pParam, int32_t iLayer);	110	void WelsEncoderApplyBitRate (SLogContext* pLogCtx, SWelsSvcCodingParam* pParam, int32_t iLayer);
111		111
112	int32_t FilterLTRRecoveryRequest (sWelsEncCtx* pCtx, SLTRRecoverRequest* pLTRRecoverRequest);	112	int32_t FilterLTRRecoveryRequest (sWelsEncCtx* pCtx, SLTRRecoverRequest* pLTRRecoverRequest);
113		113