1/* 2 * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. 3 * 4 * Use of this source code is governed by a BSD-style license 5 * that can be found in the LICENSE file in the root of the source 6 * tree. An additional intellectual property rights grant can be found 7 * in the file PATENTS. All contributing project authors may 8 * be found in the AUTHORS file in the root of the source tree. 9 */ 10 11#include "webrtc/system_wrappers/source/trace_impl.h" 12 13#include <assert.h> 14#include <stdarg.h> 15#include <stdio.h> 16#include <string.h> 17 18#ifdef _WIN32 19#include "webrtc/system_wrappers/source/trace_win.h" 20#else 21#include "webrtc/system_wrappers/source/trace_posix.h" 22#endif // _WIN32 23 24#include "webrtc/system_wrappers/interface/sleep.h" 25 26#define KEY_LEN_CHARS 31 27 28#ifdef _WIN32 29#pragma warning(disable:4355) 30#endif // _WIN32 31 32namespace webrtc { 33 34const int Trace::kBoilerplateLength = 71; 35const int Trace::kTimestampPosition = 13; 36const int Trace::kTimestampLength = 12; 37uint32_t Trace::level_filter_ = kTraceDefault; 38 39// Construct On First Use idiom. Avoids "static initialization order fiasco". 40TraceImpl* TraceImpl::StaticInstance(CountOperation count_operation, 41 const TraceLevel level) { 42 // Sanities to avoid taking lock unless absolutely necessary (for 43 // performance reasons). count_operation == kAddRefNoCreate implies that a 44 // message will be written to file. 45 if ((level != kTraceAll) && (count_operation == kAddRefNoCreate)) { 46 if (!(level & level_filter())) { 47 return NULL; 48 } 49 } 50 TraceImpl* impl = 51 GetStaticInstance<TraceImpl>(count_operation); 52 return impl; 53} 54 55TraceImpl* TraceImpl::GetTrace(const TraceLevel level) { 56 return StaticInstance(kAddRefNoCreate, level); 57} 58 59TraceImpl* TraceImpl::CreateInstance() { 60#if defined(_WIN32) 61 return new TraceWindows(); 62#else 63 return new TracePosix(); 64#endif 65} 66 67TraceImpl::TraceImpl() 68 : critsect_interface_(CriticalSectionWrapper::CreateCriticalSection()), 69 callback_(NULL), 70 row_count_text_(0), 71 file_count_text_(0), 72 trace_file_(*FileWrapper::Create()), 73 thread_(*ThreadWrapper::CreateThread(TraceImpl::Run, this, 74 kHighestPriority, "Trace")), 75 event_(*EventWrapper::Create()), 76 critsect_array_(CriticalSectionWrapper::CreateCriticalSection()), 77 next_free_idx_(), 78 level_(), 79 length_(), 80 message_queue_(), 81 active_queue_(0) { 82 next_free_idx_[0] = 0; 83 next_free_idx_[1] = 0; 84 85 unsigned int tid = 0; 86 thread_.Start(tid); 87 88 for (int m = 0; m < WEBRTC_TRACE_NUM_ARRAY; ++m) { 89 for (int n = 0; n < WEBRTC_TRACE_MAX_QUEUE; ++n) { 90 message_queue_[m][n] = new 91 char[WEBRTC_TRACE_MAX_MESSAGE_SIZE]; 92 } 93 } 94} 95 96bool TraceImpl::StopThread() { 97 // Release the worker thread so that it can flush any lingering messages. 98 event_.Set(); 99 100 // Allow 10 ms for pending messages to be flushed out. 101 // TODO(hellner): why not use condition variables to do this? Or let the 102 // worker thread die and let this thread flush remaining 103 // messages? 104 SleepMs(10); 105 106 thread_.SetNotAlive(); 107 // Make sure the thread finishes as quickly as possible (instead of having 108 // to wait for the timeout). 109 event_.Set(); 110 bool stopped = thread_.Stop(); 111 112 CriticalSectionScoped lock(critsect_interface_); 113 trace_file_.Flush(); 114 trace_file_.CloseFile(); 115 return stopped; 116} 117 118TraceImpl::~TraceImpl() { 119 StopThread(); 120 delete &event_; 121 delete &trace_file_; 122 delete &thread_; 123 delete critsect_interface_; 124 delete critsect_array_; 125 126 for (int m = 0; m < WEBRTC_TRACE_NUM_ARRAY; ++m) { 127 for (int n = 0; n < WEBRTC_TRACE_MAX_QUEUE; ++n) { 128 delete [] message_queue_[m][n]; 129 } 130 } 131} 132 133int32_t TraceImpl::AddThreadId(char* trace_message) const { 134 uint32_t thread_id = ThreadWrapper::GetThreadId(); 135 // Messages is 12 characters. 136 return sprintf(trace_message, "%10u; ", thread_id); 137} 138 139int32_t TraceImpl::AddLevel(char* sz_message, const TraceLevel level) const { 140 const int kMessageLength = 12; 141 switch (level) { 142 case kTraceTerseInfo: 143 // Add the appropriate amount of whitespace. 144 memset(sz_message, ' ', kMessageLength); 145 sz_message[kMessageLength] = '\0'; 146 break; 147 case kTraceStateInfo: 148 sprintf(sz_message, "STATEINFO ; "); 149 break; 150 case kTraceWarning: 151 sprintf(sz_message, "WARNING ; "); 152 break; 153 case kTraceError: 154 sprintf(sz_message, "ERROR ; "); 155 break; 156 case kTraceCritical: 157 sprintf(sz_message, "CRITICAL ; "); 158 break; 159 case kTraceInfo: 160 sprintf(sz_message, "DEBUGINFO ; "); 161 break; 162 case kTraceModuleCall: 163 sprintf(sz_message, "MODULECALL; "); 164 break; 165 case kTraceMemory: 166 sprintf(sz_message, "MEMORY ; "); 167 break; 168 case kTraceTimer: 169 sprintf(sz_message, "TIMER ; "); 170 break; 171 case kTraceStream: 172 sprintf(sz_message, "STREAM ; "); 173 break; 174 case kTraceApiCall: 175 sprintf(sz_message, "APICALL ; "); 176 break; 177 case kTraceDebug: 178 sprintf(sz_message, "DEBUG ; "); 179 break; 180 default: 181 assert(false); 182 return 0; 183 } 184 // All messages are 12 characters. 185 return kMessageLength; 186} 187 188int32_t TraceImpl::AddModuleAndId(char* trace_message, 189 const TraceModule module, 190 const int32_t id) const { 191 // Use long int to prevent problems with different definitions of 192 // int32_t. 193 // TODO(hellner): is this actually a problem? If so, it should be better to 194 // clean up int32_t 195 const long int idl = id; 196 const int kMessageLength = 25; 197 if (idl != -1) { 198 const unsigned long int id_engine = id >> 16; 199 const unsigned long int id_channel = id & 0xffff; 200 201 switch (module) { 202 case kTraceUndefined: 203 // Add the appropriate amount of whitespace. 204 memset(trace_message, ' ', kMessageLength); 205 trace_message[kMessageLength] = '\0'; 206 break; 207 case kTraceVoice: 208 sprintf(trace_message, " VOICE:%5ld %5ld;", id_engine, 209 id_channel); 210 break; 211 case kTraceVideo: 212 sprintf(trace_message, " VIDEO:%5ld %5ld;", id_engine, 213 id_channel); 214 break; 215 case kTraceUtility: 216 sprintf(trace_message, " UTILITY:%5ld %5ld;", id_engine, 217 id_channel); 218 break; 219 case kTraceRtpRtcp: 220 sprintf(trace_message, " RTP/RTCP:%5ld %5ld;", id_engine, 221 id_channel); 222 break; 223 case kTraceTransport: 224 sprintf(trace_message, " TRANSPORT:%5ld %5ld;", id_engine, 225 id_channel); 226 break; 227 case kTraceAudioCoding: 228 sprintf(trace_message, "AUDIO CODING:%5ld %5ld;", id_engine, 229 id_channel); 230 break; 231 case kTraceSrtp: 232 sprintf(trace_message, " SRTP:%5ld %5ld;", id_engine, 233 id_channel); 234 break; 235 case kTraceAudioMixerServer: 236 sprintf(trace_message, " AUDIO MIX/S:%5ld %5ld;", id_engine, 237 id_channel); 238 break; 239 case kTraceAudioMixerClient: 240 sprintf(trace_message, " AUDIO MIX/C:%5ld %5ld;", id_engine, 241 id_channel); 242 break; 243 case kTraceVideoCoding: 244 sprintf(trace_message, "VIDEO CODING:%5ld %5ld;", id_engine, 245 id_channel); 246 break; 247 case kTraceVideoMixer: 248 // Print sleep time and API call 249 sprintf(trace_message, " VIDEO MIX:%5ld %5ld;", id_engine, 250 id_channel); 251 break; 252 case kTraceFile: 253 sprintf(trace_message, " FILE:%5ld %5ld;", id_engine, 254 id_channel); 255 break; 256 case kTraceAudioProcessing: 257 sprintf(trace_message, " AUDIO PROC:%5ld %5ld;", id_engine, 258 id_channel); 259 break; 260 case kTraceAudioDevice: 261 sprintf(trace_message, "AUDIO DEVICE:%5ld %5ld;", id_engine, 262 id_channel); 263 break; 264 case kTraceVideoRenderer: 265 sprintf(trace_message, "VIDEO RENDER:%5ld %5ld;", id_engine, 266 id_channel); 267 break; 268 case kTraceVideoCapture: 269 sprintf(trace_message, "VIDEO CAPTUR:%5ld %5ld;", id_engine, 270 id_channel); 271 break; 272 case kTraceRemoteBitrateEstimator: 273 sprintf(trace_message, " BWE RBE:%5ld %5ld;", id_engine, 274 id_channel); 275 break; 276 } 277 } else { 278 switch (module) { 279 case kTraceUndefined: 280 // Add the appropriate amount of whitespace. 281 memset(trace_message, ' ', kMessageLength); 282 trace_message[kMessageLength] = '\0'; 283 break; 284 case kTraceVoice: 285 sprintf(trace_message, " VOICE:%11ld;", idl); 286 break; 287 case kTraceVideo: 288 sprintf(trace_message, " VIDEO:%11ld;", idl); 289 break; 290 case kTraceUtility: 291 sprintf(trace_message, " UTILITY:%11ld;", idl); 292 break; 293 case kTraceRtpRtcp: 294 sprintf(trace_message, " RTP/RTCP:%11ld;", idl); 295 break; 296 case kTraceTransport: 297 sprintf(trace_message, " TRANSPORT:%11ld;", idl); 298 break; 299 case kTraceAudioCoding: 300 sprintf(trace_message, "AUDIO CODING:%11ld;", idl); 301 break; 302 case kTraceSrtp: 303 sprintf(trace_message, " SRTP:%11ld;", idl); 304 break; 305 case kTraceAudioMixerServer: 306 sprintf(trace_message, " AUDIO MIX/S:%11ld;", idl); 307 break; 308 case kTraceAudioMixerClient: 309 sprintf(trace_message, " AUDIO MIX/C:%11ld;", idl); 310 break; 311 case kTraceVideoCoding: 312 sprintf(trace_message, "VIDEO CODING:%11ld;", idl); 313 break; 314 case kTraceVideoMixer: 315 sprintf(trace_message, " VIDEO MIX:%11ld;", idl); 316 break; 317 case kTraceFile: 318 sprintf(trace_message, " FILE:%11ld;", idl); 319 break; 320 case kTraceAudioProcessing: 321 sprintf(trace_message, " AUDIO PROC:%11ld;", idl); 322 break; 323 case kTraceAudioDevice: 324 sprintf(trace_message, "AUDIO DEVICE:%11ld;", idl); 325 break; 326 case kTraceVideoRenderer: 327 sprintf(trace_message, "VIDEO RENDER:%11ld;", idl); 328 break; 329 case kTraceVideoCapture: 330 sprintf(trace_message, "VIDEO CAPTUR:%11ld;", idl); 331 break; 332 case kTraceRemoteBitrateEstimator: 333 sprintf(trace_message, " BWE RBE:%11ld;", idl); 334 break; 335 } 336 } 337 return kMessageLength; 338} 339 340int32_t TraceImpl::SetTraceFileImpl(const char* file_name_utf8, 341 const bool add_file_counter) { 342 CriticalSectionScoped lock(critsect_interface_); 343 344 trace_file_.Flush(); 345 trace_file_.CloseFile(); 346 347 if (file_name_utf8) { 348 if (add_file_counter) { 349 file_count_text_ = 1; 350 351 char file_name_with_counter_utf8[FileWrapper::kMaxFileNameSize]; 352 CreateFileName(file_name_utf8, file_name_with_counter_utf8, 353 file_count_text_); 354 if (trace_file_.OpenFile(file_name_with_counter_utf8, false, false, 355 true) == -1) { 356 return -1; 357 } 358 } else { 359 file_count_text_ = 0; 360 if (trace_file_.OpenFile(file_name_utf8, false, false, true) == -1) { 361 return -1; 362 } 363 } 364 } 365 row_count_text_ = 0; 366 return 0; 367} 368 369int32_t TraceImpl::TraceFileImpl( 370 char file_name_utf8[FileWrapper::kMaxFileNameSize]) { 371 CriticalSectionScoped lock(critsect_interface_); 372 return trace_file_.FileName(file_name_utf8, FileWrapper::kMaxFileNameSize); 373} 374 375int32_t TraceImpl::SetTraceCallbackImpl(TraceCallback* callback) { 376 CriticalSectionScoped lock(critsect_interface_); 377 callback_ = callback; 378 return 0; 379} 380 381int32_t TraceImpl::AddMessage( 382 char* trace_message, 383 const char msg[WEBRTC_TRACE_MAX_MESSAGE_SIZE], 384 const uint16_t written_so_far) const { 385 int length = 0; 386 if (written_so_far >= WEBRTC_TRACE_MAX_MESSAGE_SIZE) { 387 return -1; 388 } 389 // - 2 to leave room for newline and NULL termination. 390#ifdef _WIN32 391 length = _snprintf(trace_message, 392 WEBRTC_TRACE_MAX_MESSAGE_SIZE - written_so_far - 2, 393 "%s", msg); 394 if (length < 0) { 395 length = WEBRTC_TRACE_MAX_MESSAGE_SIZE - written_so_far - 2; 396 trace_message[length] = 0; 397 } 398#else 399 length = snprintf(trace_message, 400 WEBRTC_TRACE_MAX_MESSAGE_SIZE - written_so_far - 2, 401 "%s", msg); 402 if (length < 0 || 403 length > WEBRTC_TRACE_MAX_MESSAGE_SIZE - written_so_far - 2) { 404 length = WEBRTC_TRACE_MAX_MESSAGE_SIZE - written_so_far - 2; 405 trace_message[length] = 0; 406 } 407#endif 408 // Length with NULL termination. 409 return length + 1; 410} 411 412void TraceImpl::AddMessageToList( 413 const char trace_message[WEBRTC_TRACE_MAX_MESSAGE_SIZE], 414 const uint16_t length, 415 const TraceLevel level) { 416// NOTE(andresp): Enabled externally. 417#ifdef WEBRTC_DIRECT_TRACE 418 if (callback_) { 419 callback_->Print(level, trace_message, length); 420 } 421 return; 422#endif 423 424 CriticalSectionScoped lock(critsect_array_); 425 426 if (next_free_idx_[active_queue_] >= WEBRTC_TRACE_MAX_QUEUE) { 427 if (!trace_file_.Open() && !callback_) { 428 // Keep at least the last 1/4 of old messages when not logging. 429 // TODO(hellner): isn't this redundant. The user will make it known 430 // when to start logging. Why keep messages before 431 // that? 432 for (int n = 0; n < WEBRTC_TRACE_MAX_QUEUE / 4; ++n) { 433 const int last_quarter_offset = (3 * WEBRTC_TRACE_MAX_QUEUE / 4); 434 memcpy(message_queue_[active_queue_][n], 435 message_queue_[active_queue_][n + last_quarter_offset], 436 WEBRTC_TRACE_MAX_MESSAGE_SIZE); 437 } 438 next_free_idx_[active_queue_] = WEBRTC_TRACE_MAX_QUEUE / 4; 439 } else { 440 // More messages are being written than there is room for in the 441 // buffer. Drop any new messages. 442 // TODO(hellner): its probably better to drop old messages instead 443 // of new ones. One step further: if this happens 444 // it's due to writing faster than what can be 445 // processed. Maybe modify the filter at this point. 446 // E.g. turn of STREAM. 447 return; 448 } 449 } 450 451 uint16_t idx = next_free_idx_[active_queue_]; 452 next_free_idx_[active_queue_]++; 453 454 level_[active_queue_][idx] = level; 455 length_[active_queue_][idx] = length; 456 memcpy(message_queue_[active_queue_][idx], trace_message, length); 457 458 if (next_free_idx_[active_queue_] == WEBRTC_TRACE_MAX_QUEUE - 1) { 459 // Logging more messages than can be worked off. Log a warning. 460 const char warning_msg[] = "WARNING MISSING TRACE MESSAGES\n"; 461 level_[active_queue_][next_free_idx_[active_queue_]] = kTraceWarning; 462 length_[active_queue_][next_free_idx_[active_queue_]] = strlen(warning_msg); 463 memcpy(message_queue_[active_queue_][next_free_idx_[active_queue_]], 464 warning_msg, strlen(warning_msg)); 465 next_free_idx_[active_queue_]++; 466 } 467} 468 469bool TraceImpl::Run(void* obj) { 470 return static_cast<TraceImpl*>(obj)->Process(); 471} 472 473bool TraceImpl::Process() { 474 if (event_.Wait(1000) == kEventSignaled) { 475 // This slightly odd construction is to avoid locking |critsect_interface_| 476 // while calling WriteToFile() since it's locked inside the function. 477 critsect_interface_->Enter(); 478 bool write_to_file = trace_file_.Open() || callback_; 479 critsect_interface_->Leave(); 480 if (write_to_file) { 481 WriteToFile(); 482 } 483 } else { 484 CriticalSectionScoped lock(critsect_interface_); 485 trace_file_.Flush(); 486 } 487 return true; 488} 489 490void TraceImpl::WriteToFile() { 491 uint8_t local_queue_active = 0; 492 uint16_t local_next_free_idx = 0; 493 494 // There are two buffers. One for reading (for writing to file) and one for 495 // writing (for storing new messages). Let new messages be posted to the 496 // unused buffer so that the current buffer can be flushed safely. 497 { 498 CriticalSectionScoped lock(critsect_array_); 499 local_next_free_idx = next_free_idx_[active_queue_]; 500 next_free_idx_[active_queue_] = 0; 501 local_queue_active = active_queue_; 502 if (active_queue_ == 0) { 503 active_queue_ = 1; 504 } else { 505 active_queue_ = 0; 506 } 507 } 508 if (local_next_free_idx == 0) { 509 return; 510 } 511 512 CriticalSectionScoped lock(critsect_interface_); 513 514 for (uint16_t idx = 0; idx < local_next_free_idx; ++idx) { 515 TraceLevel local_level = level_[local_queue_active][idx]; 516 if (callback_) { 517 callback_->Print(local_level, message_queue_[local_queue_active][idx], 518 length_[local_queue_active][idx]); 519 } 520 if (trace_file_.Open()) { 521 if (row_count_text_ > WEBRTC_TRACE_MAX_FILE_SIZE) { 522 // wrap file 523 row_count_text_ = 0; 524 trace_file_.Flush(); 525 526 if (file_count_text_ == 0) { 527 trace_file_.Rewind(); 528 } else { 529 char old_file_name[FileWrapper::kMaxFileNameSize]; 530 char new_file_name[FileWrapper::kMaxFileNameSize]; 531 532 // get current name 533 trace_file_.FileName(old_file_name, 534 FileWrapper::kMaxFileNameSize); 535 trace_file_.CloseFile(); 536 537 file_count_text_++; 538 539 UpdateFileName(old_file_name, new_file_name, file_count_text_); 540 541 if (trace_file_.OpenFile(new_file_name, false, false, 542 true) == -1) { 543 return; 544 } 545 } 546 } 547 if (row_count_text_ == 0) { 548 char message[WEBRTC_TRACE_MAX_MESSAGE_SIZE + 1]; 549 int32_t length = AddDateTimeInfo(message); 550 if (length != -1) { 551 message[length] = 0; 552 message[length - 1] = '\n'; 553 trace_file_.Write(message, length); 554 row_count_text_++; 555 } 556 length = AddBuildInfo(message); 557 if (length != -1) { 558 message[length + 1] = 0; 559 message[length] = '\n'; 560 message[length - 1] = '\n'; 561 trace_file_.Write(message, length + 1); 562 row_count_text_++; 563 row_count_text_++; 564 } 565 } 566 uint16_t length = length_[local_queue_active][idx]; 567 message_queue_[local_queue_active][idx][length] = 0; 568 message_queue_[local_queue_active][idx][length - 1] = '\n'; 569 trace_file_.Write(message_queue_[local_queue_active][idx], length); 570 row_count_text_++; 571 } 572 } 573} 574 575void TraceImpl::AddImpl(const TraceLevel level, const TraceModule module, 576 const int32_t id, 577 const char msg[WEBRTC_TRACE_MAX_MESSAGE_SIZE]) { 578 if (TraceCheck(level)) { 579 char trace_message[WEBRTC_TRACE_MAX_MESSAGE_SIZE]; 580 char* message_ptr = trace_message; 581 582 int32_t len = 0; 583 int32_t ack_len = 0; 584 585 len = AddLevel(message_ptr, level); 586 if (len == -1) { 587 return; 588 } 589 message_ptr += len; 590 ack_len += len; 591 592 len = AddTime(message_ptr, level); 593 if (len == -1) { 594 return; 595 } 596 message_ptr += len; 597 ack_len += len; 598 599 len = AddModuleAndId(message_ptr, module, id); 600 if (len == -1) { 601 return; 602 } 603 message_ptr += len; 604 ack_len += len; 605 606 len = AddThreadId(message_ptr); 607 if (len < 0) { 608 return; 609 } 610 message_ptr += len; 611 ack_len += len; 612 613 len = AddMessage(message_ptr, msg, (uint16_t)ack_len); 614 if (len == -1) { 615 return; 616 } 617 ack_len += len; 618 AddMessageToList(trace_message, (uint16_t)ack_len, level); 619 620 // Make sure that messages are written as soon as possible. 621 event_.Set(); 622 } 623} 624 625bool TraceImpl::TraceCheck(const TraceLevel level) const { 626 return (level & level_filter()) ? true : false; 627} 628 629bool TraceImpl::UpdateFileName( 630 const char file_name_utf8[FileWrapper::kMaxFileNameSize], 631 char file_name_with_counter_utf8[FileWrapper::kMaxFileNameSize], 632 const uint32_t new_count) const { 633 int32_t length = (int32_t)strlen(file_name_utf8); 634 if (length < 0) { 635 return false; 636 } 637 638 int32_t length_without_file_ending = length - 1; 639 while (length_without_file_ending > 0) { 640 if (file_name_utf8[length_without_file_ending] == '.') { 641 break; 642 } else { 643 length_without_file_ending--; 644 } 645 } 646 if (length_without_file_ending == 0) { 647 length_without_file_ending = length; 648 } 649 int32_t length_to_ = length_without_file_ending - 1; 650 while (length_to_ > 0) { 651 if (file_name_utf8[length_to_] == '_') { 652 break; 653 } else { 654 length_to_--; 655 } 656 } 657 658 memcpy(file_name_with_counter_utf8, file_name_utf8, length_to_); 659 sprintf(file_name_with_counter_utf8 + length_to_, "_%lu%s", 660 static_cast<long unsigned int>(new_count), 661 file_name_utf8 + length_without_file_ending); 662 return true; 663} 664 665bool TraceImpl::CreateFileName( 666 const char file_name_utf8[FileWrapper::kMaxFileNameSize], 667 char file_name_with_counter_utf8[FileWrapper::kMaxFileNameSize], 668 const uint32_t new_count) const { 669 int32_t length = (int32_t)strlen(file_name_utf8); 670 if (length < 0) { 671 return false; 672 } 673 674 int32_t length_without_file_ending = length - 1; 675 while (length_without_file_ending > 0) { 676 if (file_name_utf8[length_without_file_ending] == '.') { 677 break; 678 } else { 679 length_without_file_ending--; 680 } 681 } 682 if (length_without_file_ending == 0) { 683 length_without_file_ending = length; 684 } 685 memcpy(file_name_with_counter_utf8, file_name_utf8, 686 length_without_file_ending); 687 sprintf(file_name_with_counter_utf8 + length_without_file_ending, "_%lu%s", 688 static_cast<long unsigned int>(new_count), 689 file_name_utf8 + length_without_file_ending); 690 return true; 691} 692 693void Trace::CreateTrace() { 694 TraceImpl::StaticInstance(kAddRef); 695} 696 697void Trace::ReturnTrace() { 698 TraceImpl::StaticInstance(kRelease); 699} 700 701int32_t Trace::TraceFile(char file_name[FileWrapper::kMaxFileNameSize]) { 702 TraceImpl* trace = TraceImpl::GetTrace(); 703 if (trace) { 704 int ret_val = trace->TraceFileImpl(file_name); 705 ReturnTrace(); 706 return ret_val; 707 } 708 return -1; 709} 710 711int32_t Trace::SetTraceFile(const char* file_name, 712 const bool add_file_counter) { 713 TraceImpl* trace = TraceImpl::GetTrace(); 714 if (trace) { 715 int ret_val = trace->SetTraceFileImpl(file_name, add_file_counter); 716 ReturnTrace(); 717 return ret_val; 718 } 719 return -1; 720} 721 722int32_t Trace::SetTraceCallback(TraceCallback* callback) { 723 TraceImpl* trace = TraceImpl::GetTrace(); 724 if (trace) { 725 int ret_val = trace->SetTraceCallbackImpl(callback); 726 ReturnTrace(); 727 return ret_val; 728 } 729 return -1; 730} 731 732void Trace::Add(const TraceLevel level, const TraceModule module, 733 const int32_t id, const char* msg, ...) { 734 TraceImpl* trace = TraceImpl::GetTrace(level); 735 if (trace) { 736 if (trace->TraceCheck(level)) { 737 char temp_buff[WEBRTC_TRACE_MAX_MESSAGE_SIZE]; 738 char* buff = 0; 739 if (msg) { 740 va_list args; 741 va_start(args, msg); 742#ifdef _WIN32 743 _vsnprintf(temp_buff, WEBRTC_TRACE_MAX_MESSAGE_SIZE - 1, msg, args); 744#else 745 vsnprintf(temp_buff, WEBRTC_TRACE_MAX_MESSAGE_SIZE - 1, msg, args); 746#endif 747 va_end(args); 748 buff = temp_buff; 749 } 750 trace->AddImpl(level, module, id, buff); 751 } 752 ReturnTrace(); 753 } 754} 755 756} // namespace webrtc 757