Initial commit: FunASR Speech Recognition Toolkit
Update API Documentation / build-api-docs (push) Has been cancelled
Update API Documentation / build-api-docs (push) Has been cancelled
Add complete FunASR codebase including models, runtime, and documentation.
This commit is contained in:
freedakgmail
@@ -0,0 +1,231 @@
|
||||
// base/kaldi-error.h
|
||||
|
||||
// Copyright 2019 LAIX (Yi Sun)
|
||||
// Copyright 2019 SmartAction LLC (kkm)
|
||||
// Copyright 2016 Brno University of Technology (author: Karel Vesely)
|
||||
// Copyright 2009-2011 Microsoft Corporation; Ondrej Glembek; Lukas Burget;
|
||||
// Saarland University
|
||||
|
||||
// See ../../COPYING for clarification regarding multiple authors
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// THIS CODE IS PROVIDED *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
||||
// KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
|
||||
// WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
|
||||
// MERCHANTABLITY OR NON-INFRINGEMENT.
|
||||
// See the Apache 2 License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
#ifndef KALDI_BASE_KALDI_ERROR_H_
|
||||
#define KALDI_BASE_KALDI_ERROR_H_ 1
|
||||
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <sstream>
|
||||
#include <stdexcept>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
#include "base/kaldi-types.h"
|
||||
#include "base/kaldi-utils.h"
|
||||
/* Important that this file does not depend on any other kaldi headers. */
|
||||
|
||||
#ifdef _MSC_VER
|
||||
#define __func__ __FUNCTION__
|
||||
#endif
|
||||
|
||||
namespace kaldi {
|
||||
|
||||
/// \addtogroup error_group
|
||||
/// @{
|
||||
|
||||
/***** PROGRAM NAME AND VERBOSITY LEVEL *****/
|
||||
|
||||
/// Called by ParseOptions to set base name (no directory) of the executing
|
||||
/// program. The name is printed in logging code along with every message,
|
||||
/// because in our scripts, we often mix together the stderr of many programs.
|
||||
/// This function is very thread-unsafe.
|
||||
void SetProgramName(const char *basename);
|
||||
|
||||
/// This is set by util/parse-options.{h,cc} if you set --verbose=? option.
|
||||
/// Do not use directly, prefer {Get,Set}VerboseLevel().
|
||||
extern int32 g_kaldi_verbose_level;
|
||||
|
||||
/// Get verbosity level, usually set via command line '--verbose=' switch.
|
||||
inline int32 GetVerboseLevel() { return g_kaldi_verbose_level; }
|
||||
|
||||
/// This should be rarely used, except by programs using Kaldi as library;
|
||||
/// command-line programs set the verbose level automatically from ParseOptions.
|
||||
inline void SetVerboseLevel(int32 i) { g_kaldi_verbose_level = i; }
|
||||
|
||||
/***** KALDI LOGGING *****/
|
||||
|
||||
/// Log message severity and source location info.
|
||||
struct LogMessageEnvelope {
|
||||
/// Message severity. In addition to these levels, positive values (1 to 6)
|
||||
/// specify verbose logging level. Verbose messages are produced only when
|
||||
/// SetVerboseLevel() has been called to set logging level to at least the
|
||||
/// corresponding value.
|
||||
enum Severity {
|
||||
kAssertFailed = -3, //!< Assertion failure. abort() will be called.
|
||||
kError = -2, //!< Fatal error. KaldiFatalError will be thrown.
|
||||
kWarning = -1, //!< Indicates a recoverable but abnormal condition.
|
||||
kInfo = 0, //!< Informational message.
|
||||
};
|
||||
int severity; //!< A Severity value, or positive verbosity level.
|
||||
const char *func; //!< Name of the function invoking the logging.
|
||||
const char *file; //!< Source file name with up to 1 leading directory.
|
||||
int32 line; //<! Line number in the source file.
|
||||
};
|
||||
|
||||
/// Kaldi fatal runtime error exception. This exception is thrown from any use
|
||||
/// of the KALDI_ERR logging macro after the logging function, either set by
|
||||
/// SetLogHandler(), or the Kaldi's internal one, has returned.
|
||||
class KaldiFatalError : public std::runtime_error {
|
||||
public:
|
||||
explicit KaldiFatalError(const std::string &message)
|
||||
: std::runtime_error(message) {}
|
||||
explicit KaldiFatalError(const char *message) : std::runtime_error(message) {}
|
||||
|
||||
/// Returns the exception name, "kaldi::KaldiFatalError".
|
||||
virtual const char *what() const noexcept override {
|
||||
return "kaldi::KaldiFatalError";
|
||||
}
|
||||
|
||||
/// Returns the Kaldi error message logged by KALDI_ERR.
|
||||
const char *KaldiMessage() const { return std::runtime_error::what(); }
|
||||
};
|
||||
|
||||
// Class MessageLogger is the workhorse behind the KALDI_ASSERT, KALDI_ERR,
|
||||
// KALDI_WARN, KALDI_LOG and KALDI_VLOG macros. It formats the message, then
|
||||
// either prints it to stderr or passes to the custom logging handler if
|
||||
// provided. Then, in case of the error, throws a KaldiFatalError exception, or
|
||||
// in case of failed KALDI_ASSERT, calls std::abort().
|
||||
class MessageLogger {
|
||||
public:
|
||||
/// The constructor stores the message's "envelope", a set of data which
|
||||
// identifies the location in source which is sending the message to log.
|
||||
// The pointers to strings are stored internally, and not owned or copied,
|
||||
// so that their storage must outlive this object.
|
||||
MessageLogger(LogMessageEnvelope::Severity severity, const char *func,
|
||||
const char *file, int32 line);
|
||||
|
||||
// The stream insertion operator, used in e.g. 'KALDI_LOG << "Message"'.
|
||||
template <typename T> MessageLogger &operator<<(const T &val) {
|
||||
ss_ << val;
|
||||
return *this;
|
||||
}
|
||||
|
||||
// When assigned a MessageLogger, log its contents.
|
||||
struct Log final {
|
||||
void operator=(const MessageLogger &logger) { logger.LogMessage(); }
|
||||
};
|
||||
|
||||
// When assigned a MessageLogger, log its contents and then throw
|
||||
// a KaldiFatalError.
|
||||
struct LogAndThrow final {
|
||||
[[noreturn]] void operator=(const MessageLogger &logger) {
|
||||
logger.LogMessage();
|
||||
throw KaldiFatalError(logger.GetMessage());
|
||||
}
|
||||
};
|
||||
|
||||
private:
|
||||
std::string GetMessage() const { return ss_.str(); }
|
||||
void LogMessage() const;
|
||||
|
||||
LogMessageEnvelope envelope_;
|
||||
std::ostringstream ss_;
|
||||
};
|
||||
|
||||
// Logging macros.
|
||||
#define KALDI_ERR \
|
||||
::kaldi::MessageLogger::LogAndThrow() = ::kaldi::MessageLogger( \
|
||||
::kaldi::LogMessageEnvelope::kError, __func__, __FILE__, __LINE__)
|
||||
#define KALDI_WARN \
|
||||
::kaldi::MessageLogger::Log() = ::kaldi::MessageLogger( \
|
||||
::kaldi::LogMessageEnvelope::kWarning, __func__, __FILE__, __LINE__)
|
||||
#define KALDI_LOG \
|
||||
::kaldi::MessageLogger::Log() = ::kaldi::MessageLogger( \
|
||||
::kaldi::LogMessageEnvelope::kInfo, __func__, __FILE__, __LINE__)
|
||||
#define KALDI_VLOG(v) \
|
||||
if ((v) <= ::kaldi::GetVerboseLevel()) \
|
||||
::kaldi::MessageLogger::Log() = \
|
||||
::kaldi::MessageLogger((::kaldi::LogMessageEnvelope::Severity)(v), \
|
||||
__func__, __FILE__, __LINE__)
|
||||
|
||||
/***** KALDI ASSERTS *****/
|
||||
|
||||
[[noreturn]] void KaldiAssertFailure_(const char *func, const char *file,
|
||||
int32 line, const char *cond_str);
|
||||
|
||||
// Note on KALDI_ASSERT and KALDI_PARANOID_ASSERT:
|
||||
//
|
||||
// A single block {} around if /else does not work, because it causes
|
||||
// syntax error (unmatched else block) in the following code:
|
||||
//
|
||||
// if (condition)
|
||||
// KALDI_ASSERT(condition2);
|
||||
// else
|
||||
// SomethingElse();
|
||||
//
|
||||
// do {} while(0) -- note there is no semicolon at the end! -- works nicely,
|
||||
// and compilers will be able to optimize the loop away (as the condition
|
||||
// is always false).
|
||||
//
|
||||
// Also see KALDI_COMPILE_TIME_ASSERT, defined in base/kaldi-utils.h, and
|
||||
// KALDI_ASSERT_IS_INTEGER_TYPE and KALDI_ASSERT_IS_FLOATING_TYPE, also defined
|
||||
// there.
|
||||
#ifndef NDEBUG
|
||||
#define KALDI_ASSERT(cond) \
|
||||
do { \
|
||||
if (cond) \
|
||||
(void)0; \
|
||||
else \
|
||||
::kaldi::KaldiAssertFailure_(__func__, __FILE__, __LINE__, #cond); \
|
||||
} while (0)
|
||||
#else
|
||||
#define KALDI_ASSERT(cond) (void)0
|
||||
#endif
|
||||
|
||||
// Some more expensive asserts only checked if this defined.
|
||||
#ifdef KALDI_PARANOID
|
||||
#define KALDI_PARANOID_ASSERT(cond) \
|
||||
do { \
|
||||
if (cond) \
|
||||
(void)0; \
|
||||
else \
|
||||
::kaldi::KaldiAssertFailure_(__func__, __FILE__, __LINE__, #cond); \
|
||||
} while (0)
|
||||
#else
|
||||
#define KALDI_PARANOID_ASSERT(cond) (void)0
|
||||
#endif
|
||||
|
||||
/***** THIRD-PARTY LOG-HANDLER *****/
|
||||
|
||||
/// Type of third-party logging function.
|
||||
typedef void (*LogHandler)(const LogMessageEnvelope &envelope,
|
||||
const char *message);
|
||||
|
||||
/// Set logging handler. If called with a non-NULL function pointer, the
|
||||
/// function pointed by it is called to send messages to a caller-provided log.
|
||||
/// If called with a NULL pointer, restores default Kaldi error logging to
|
||||
/// stderr. This function is obviously not thread safe; the log handler must be.
|
||||
/// Returns a previously set logging handler pointer, or NULL.
|
||||
LogHandler SetLogHandler(LogHandler);
|
||||
|
||||
/// @} end "addtogroup error_group"
|
||||
|
||||
//// Functions within internal is exported for testing only, do not use.
|
||||
//namespace internal {
|
||||
//bool LocateSymbolRange(const std::string &trace_name, size_t *begin,
|
||||
// size_t *end);
|
||||
//} // namespace internal
|
||||
} // namespace kaldi
|
||||
|
||||
#endif // KALDI_BASE_KALDI_ERROR_H_
|
||||
Reference in New Issue
Block a user