void PjsipCallFront::dump_info(pj_thread_t *thread) { Q_ASSERT(thread != NULL); qLogx()<<"pj_thread_is_registered:"<<pj_thread_is_registered(); qLogx()<<"pj_thread_get_prio:"<<pj_thread_get_prio(thread); qLogx()<<"pj_thread_get_prio_min:"<<pj_thread_get_prio_min(thread); qLogx()<<"pj_thread_get_prio_max:"<<pj_thread_get_prio_max(thread); qLogx()<<"pj_thread_get_name:"<<pj_thread_get_name(thread); qLogx()<<"pj_getpid:"<<pj_getpid(); }
/* * The thread's entry point. * * Each of the thread mainly will just execute the loop which * increments a variable. */ static void* thread_proc(pj_uint32_t *pcounter) { /* Test that pj_thread_register() works. */ pj_thread_desc desc; pj_thread_t *this_thread; unsigned id; pj_status_t rc; id = *pcounter; PJ_UNUSED_ARG(id); /* Warning about unused var if TRACE__ is disabled */ TRACE__((THIS_FILE, " thread %d running..", id)); pj_bzero(desc, sizeof(desc)); rc = pj_thread_register("thread", desc, &this_thread); if (rc != PJ_SUCCESS) { app_perror("...error in pj_thread_register", rc); return NULL; } /* Test that pj_thread_this() works */ this_thread = pj_thread_this(); if (this_thread == NULL) { PJ_LOG(3,(THIS_FILE, "...error: pj_thread_this() returns NULL!")); return NULL; } /* Test that pj_thread_get_name() works */ if (pj_thread_get_name(this_thread) == NULL) { PJ_LOG(3,(THIS_FILE, "...error: pj_thread_get_name() returns NULL!")); return NULL; } /* Main loop */ for (;!quit_flag;) { (*pcounter)++; //Must sleep if platform doesn't do time-slicing. //pj_thread_sleep(0); } TRACE__((THIS_FILE, " thread %d quitting..", id)); return NULL; }
PJ_DEF(void) pj_log( const char *sender, int level, const char *format, va_list marker) { pj_time_val now; pj_parsed_time ptime; char *pre; #if PJ_LOG_USE_STACK_BUFFER char log_buffer[PJ_LOG_MAX_SIZE]; #endif int saved_level, len, print_len; PJ_CHECK_STACK(); if (level > pj_log_max_level) return; if (is_logging_suspended()) return; /* Temporarily disable logging for this thread. Some of PJLIB APIs that * this function calls below will recursively call the logging function * back, hence it will cause infinite recursive calls if we allow that. */ suspend_logging(&saved_level); /* Get current date/time. */ pj_gettimeofday(&now); pj_time_decode(&now, &ptime); pre = log_buffer; if (log_decor & PJ_LOG_HAS_LEVEL_TEXT) { static const char *ltexts[] = { "FATAL:", "ERROR:", " WARN:", " INFO:", "DEBUG:", "TRACE:", "DETRC:"}; pj_ansi_strcpy(pre, ltexts[level]); pre += 6; } if (log_decor & PJ_LOG_HAS_DAY_NAME) { static const char *wdays[] = { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"}; pj_ansi_strcpy(pre, wdays[ptime.wday]); pre += 3; } if (log_decor & PJ_LOG_HAS_YEAR) { *pre++ = ' '; pre += pj_utoa(ptime.year, pre); } if (log_decor & PJ_LOG_HAS_MONTH) { *pre++ = '-'; pre += pj_utoa_pad(ptime.mon+1, pre, 2, '0'); } if (log_decor & PJ_LOG_HAS_DAY_OF_MON) { *pre++ = '-'; pre += pj_utoa_pad(ptime.day, pre, 2, '0'); } if (log_decor & PJ_LOG_HAS_TIME) { *pre++ = ' '; pre += pj_utoa_pad(ptime.hour, pre, 2, '0'); *pre++ = ':'; pre += pj_utoa_pad(ptime.min, pre, 2, '0'); *pre++ = ':'; pre += pj_utoa_pad(ptime.sec, pre, 2, '0'); } if (log_decor & PJ_LOG_HAS_MICRO_SEC) { *pre++ = '.'; pre += pj_utoa_pad(ptime.msec, pre, 3, '0'); } if (log_decor & PJ_LOG_HAS_SENDER) { enum { SENDER_WIDTH = 14 }; int sender_len = strlen(sender); *pre++ = ' '; if (sender_len <= SENDER_WIDTH) { while (sender_len < SENDER_WIDTH) *pre++ = ' ', ++sender_len; while (*sender) *pre++ = *sender++; } else { int i; for (i=0; i<SENDER_WIDTH; ++i) *pre++ = *sender++; } } if (log_decor & PJ_LOG_HAS_THREAD_ID) { enum { THREAD_WIDTH = 12 }; const char *thread_name = pj_thread_get_name(pj_thread_this()); int thread_len = strlen(thread_name); *pre++ = ' '; if (thread_len <= THREAD_WIDTH) { while (thread_len < THREAD_WIDTH) *pre++ = ' ', ++thread_len; while (*thread_name) *pre++ = *thread_name++; } else { int i; for (i=0; i<THREAD_WIDTH; ++i) *pre++ = *thread_name++; } } if (log_decor != 0 && log_decor != PJ_LOG_HAS_NEWLINE) *pre++ = ' '; if (log_decor & PJ_LOG_HAS_SPACE) { *pre++ = ' '; } len = pre - log_buffer; /* Print the whole message to the string log_buffer. */ print_len = pj_ansi_vsnprintf(pre, sizeof(log_buffer)-len, format, marker); if (print_len < 0) { level = 1; print_len = pj_ansi_snprintf(pre, sizeof(log_buffer)-len, "<logging error: msg too long>"); } len = len + print_len; if (len > 0 && len < (int)sizeof(log_buffer)-2) { if (log_decor & PJ_LOG_HAS_CR) { log_buffer[len++] = '\r'; } if (log_decor & PJ_LOG_HAS_NEWLINE) { log_buffer[len++] = '\n'; } log_buffer[len] = '\0'; } else { len = sizeof(log_buffer)-1; if (log_decor & PJ_LOG_HAS_CR) { log_buffer[sizeof(log_buffer)-3] = '\r'; } if (log_decor & PJ_LOG_HAS_NEWLINE) { log_buffer[sizeof(log_buffer)-2] = '\n'; } log_buffer[sizeof(log_buffer)-1] = '\0'; } /* It should be safe to resume logging at this point. Application can * recursively call the logging function inside the callback. */ resume_logging(&saved_level); if (log_writer) (*log_writer)(level, log_buffer, len); }
// // Get thread name. // static const char *get_name(pj_thread_t *thread) { return pj_thread_get_name(thread); }