static void
vdebug_out(int prefix, enum debug_level level, enum debug_component comp,
const char * func_name, int line_no,
const char * fmt, va_list ap)
{
/* output to stderr even if haven't init */
if (fdebug_out == NULL)
fdebug_out = stderr;
if (debug_levels[comp] <= level) {
if (level >= WARNING) {
if (level == FORCE)
turn_blue();
else
turn_red();
}
if (prefix) {
fprintf (fdebug_out, "[%s %s@%s:%d]\t", get_comp_name(comp),
get_level_name(level), func_name, line_no);
}
vfprintf (fdebug_out, fmt, ap);
if (level >= WARNING)
turn_normal();
fflush(fdebug_out);
}
}
Mogu_Logger::Mogu_Logger()
{
if (LOG_OVERRIDE)
{
log_level = (int)Log_Level::all;
return;
}
Redis::Node_Editor log_config {Prefix::meta, "log"};
if (!log_config.node_exists())
{
log_level = (int) Log_Level::none;
}
else
{
std::string s = log_config.read();
log_level = (int) get_level_enum(s);
}
std::string cfg_level = log_config.read();
log_level = (int) get_level_enum(cfg_level);
std::cout << "Logger created with log level "
<< get_level_name((Log_Level)log_level)
<< std::endl;
}
int Logger::logv(int level, const char *fmt, va_list ap){
if(logger.level_ < level){
return 0;
}
char buf[LOG_BUF_LEN];
int len;
char *ptr = buf;
time_t time;
struct timeval tv;
struct tm *tm, tm_tmp;
gettimeofday(&tv, NULL);
time = tv.tv_sec;
tm = localtime_r(&time, &tm_tmp);
/* %3ld 在数值位数超过3位的时候不起作用, 所以这里转成int */
len = sprintf(ptr, "%04d-%02d-%02d %02d:%02d:%02d.%03d ",
tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
tm->tm_hour, tm->tm_min, tm->tm_sec, (int)(tv.tv_usec/1000));
if(len < 0){
return -1;
}
ptr += len;
memcpy(ptr, get_level_name(level), LEVEL_NAME_LEN);
ptr += LEVEL_NAME_LEN;
int space = sizeof(buf) - (ptr - buf) - 10;
len = vsnprintf(ptr, space, fmt, ap);
if(len < 0){
return -1;
}
ptr += len > space? space : len;
*ptr++ = '\n';
*ptr = '\0';
len = ptr - buf;
if(this->mutex){
pthread_mutex_lock(this->mutex);
}
write(this->fd, buf, len);
if(this->fd != STDOUT_FILENO && this->fd != STDERR_FILENO){
stats.w_curr += len;
stats.w_total += len;
if(rotate_size_ > 0 && stats.w_curr > rotate_size_){
this->rotate();
}
}
if(this->mutex){
pthread_mutex_unlock(this->mutex);
}
return len;
}
void LogHandler (const gchar* log_domain,
GLogLevelFlags log_level,
const gchar* message,
gpointer user_data)
{
if (log_level & levels_to_log)
{
std::string domain = log_domain ? log_domain : "default";
get_log_stream() << "[" << domain << "] " << get_level_name(log_level) << ": " << message << std::endl;
}
}
int Logger::logv(int level, const char *fmt, va_list ap){
Logger *logger = get_or_create_global_logger();
if(logger->level_ < level){
return 0;
}
char buf[LOG_BUF_LEN];
int len;
char *ptr = buf;
time_t time;
struct timeval tv;
struct tm *tm;
gettimeofday(&tv, NULL);
time = tv.tv_sec;
tm = localtime(&time);
len = sprintf(ptr, "%04d-%02d-%02d %02d:%02d:%02d.%03d ",
tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
tm->tm_hour, tm->tm_min, tm->tm_sec, static_cast<int>(tv.tv_usec/1000));
if(len < 0){
return -1;
}
ptr += len;
memcpy(ptr, get_level_name(level), LEVEL_NAME_LEN);
ptr += LEVEL_NAME_LEN;
int space = static_cast<int> (sizeof(buf) - (ptr - buf) - 10);
len = vsnprintf(ptr, space, fmt, ap);
if(len < 0){
return -1;
}
ptr += len > space? space : len;
*ptr++ = '\n';
*ptr = '\0';
len = static_cast<int>(ptr - buf);
{
base::MutexGuard<base::MutexLock> guard(mutex_);
fwrite(buf, len, 1, fp_);
fflush(fp_);
stats.w_curr += len;
stats.w_total += len;
if(rotate_size_ > 0 && stats.w_curr > rotate_size_){
this->rotate();
}
}
return len;
}
static void
vmessage_out(int prefix, enum debug_level l, enum debug_component c, char * fmt, va_list ap)
{
/* output to stdout if haven't init */
if (fdebug_out == NULL)
fdebug_out = stdout;
if (l >= WARNING)
turn_red();
if (prefix)
fprintf(fdebug_out, "%s: ", get_level_name(l));
vfprintf(fdebug_out, fmt, ap);
if (l >= WARNING)
turn_normal();
fflush(fdebug_out);
}
static GstFlowReturn
gst_dirac_parse_handle_frame (GstBaseParse * parse,
GstBaseParseFrame * frame, gint * skipsize)
{
int off;
guint32 next_header;
GstMapInfo map;
guint8 *data;
gsize size;
gboolean have_picture = FALSE;
int offset;
guint framesize = 0;
gst_buffer_map (frame->buffer, &map, GST_MAP_READ);
data = map.data;
size = map.size;
if (G_UNLIKELY (size < 13)) {
*skipsize = 1;
goto out;
}
GST_DEBUG ("%" G_GSIZE_FORMAT ": %02x %02x %02x %02x", size, data[0], data[1],
data[2], data[3]);
if (GST_READ_UINT32_BE (data) != 0x42424344) {
GstByteReader reader;
gst_byte_reader_init (&reader, data, size);
off = gst_byte_reader_masked_scan_uint32 (&reader, 0xffffffff,
0x42424344, 0, size);
if (off < 0) {
*skipsize = size - 3;
goto out;
}
GST_LOG_OBJECT (parse, "possible sync at buffer offset %d", off);
GST_DEBUG ("skipping %d", off);
*skipsize = off;
goto out;
}
/* have sync, parse chunks */
offset = 0;
while (!have_picture) {
GST_DEBUG ("offset %d:", offset);
if (offset + 13 >= size) {
framesize = offset + 13;
goto out;
}
GST_DEBUG ("chunk type %02x", data[offset + 4]);
if (GST_READ_UINT32_BE (data + offset) != 0x42424344) {
GST_DEBUG ("bad header");
*skipsize = 3;
goto out;
}
next_header = GST_READ_UINT32_BE (data + offset + 5);
GST_DEBUG ("next_header %d", next_header);
if (next_header == 0)
next_header = 13;
if (SCHRO_PARSE_CODE_IS_PICTURE (data[offset + 4])) {
have_picture = TRUE;
}
offset += next_header;
if (offset >= size) {
framesize = offset;
goto out;
}
}
gst_buffer_unmap (frame->buffer, &map);
framesize = offset;
GST_DEBUG ("framesize %d", framesize);
g_assert (framesize <= size);
if (data[4] == SCHRO_PARSE_CODE_SEQUENCE_HEADER) {
GstCaps *caps;
GstDiracParse *diracparse = GST_DIRAC_PARSE (parse);
DiracSequenceHeader sequence_header;
int ret;
ret = dirac_sequence_header_parse (&sequence_header, data + 13, size - 13);
if (ret) {
memcpy (&diracparse->sequence_header, &sequence_header,
sizeof (sequence_header));
caps = gst_caps_new_simple ("video/x-dirac",
"width", G_TYPE_INT, sequence_header.width,
"height", G_TYPE_INT, sequence_header.height,
"framerate", GST_TYPE_FRACTION,
sequence_header.frame_rate_numerator,
sequence_header.frame_rate_denominator,
"pixel-aspect-ratio", GST_TYPE_FRACTION,
sequence_header.aspect_ratio_numerator,
sequence_header.aspect_ratio_denominator,
"interlace-mode", G_TYPE_STRING,
sequence_header.interlaced ? "interleaved" : "progressive",
"profile", G_TYPE_STRING, get_profile_name (sequence_header.profile),
"level", G_TYPE_STRING, get_level_name (sequence_header.level), NULL);
gst_pad_set_caps (GST_BASE_PARSE_SRC_PAD (parse), caps);
gst_caps_unref (caps);
gst_base_parse_set_frame_rate (parse,
sequence_header.frame_rate_numerator,
sequence_header.frame_rate_denominator, 0, 0);
}
}
gst_base_parse_set_min_frame_size (parse, 13);
return gst_base_parse_finish_frame (parse, frame, framesize);
out:
gst_buffer_unmap (frame->buffer, &map);
if (framesize)
gst_base_parse_set_min_frame_size (parse, framesize);
return GST_FLOW_OK;
}
