| OLD | NEW |
|---|
| (Empty) |
| 1 /* | |
| 2 * Copyright (c) 2015 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/modules/audio_coding/main/acm2/acm_dump.h" | |
| 12 | |
| 13 #include <deque> | |
| 14 | |
| 15 #include "webrtc/base/checks.h" | |
| 16 #include "webrtc/base/thread_annotations.h" | |
| 17 #include "webrtc/system_wrappers/interface/clock.h" | |
| 18 #include "webrtc/system_wrappers/interface/critical_section_wrapper.h" | |
| 19 #include "webrtc/system_wrappers/interface/file_wrapper.h" | |
| 20 | |
| 21 #ifdef RTC_AUDIOCODING_DEBUG_DUMP | |
| 22 // Files generated at build-time by the protobuf compiler. | |
| 23 #ifdef WEBRTC_ANDROID_PLATFORM_BUILD | |
| 24 #include "external/webrtc/webrtc/modules/audio_coding/dump.pb.h" | |
| 25 #else | |
| 26 #include "webrtc/audio_coding/dump.pb.h" | |
| 27 #endif | |
| 28 #endif | |
| 29 | |
| 30 namespace webrtc { | |
| 31 | |
| 32 // Noop implementation if flag is not set | |
| 33 #ifndef RTC_AUDIOCODING_DEBUG_DUMP | |
| 34 class AcmDumpImpl final : public AcmDump { | |
| 35 public: | |
| 36 void StartLogging(const std::string& file_name, int duration_ms) override{}; | |
| 37 void LogRtpPacket(bool incoming, | |
| 38 const uint8_t* packet, | |
| 39 size_t length) override{}; | |
| 40 void LogDebugEvent(DebugEvent event_type, | |
| 41 const std::string& event_message) override{}; | |
| 42 void LogDebugEvent(DebugEvent event_type) override{}; | |
| 43 }; | |
| 44 #else | |
| 45 | |
| 46 class AcmDumpImpl final : public AcmDump { | |
| 47 public: | |
| 48 AcmDumpImpl(); | |
| 49 | |
| 50 void StartLogging(const std::string& file_name, int duration_ms) override; | |
| 51 void LogRtpPacket(bool incoming, | |
| 52 const uint8_t* packet, | |
| 53 size_t length) override; | |
| 54 void LogDebugEvent(DebugEvent event_type, | |
| 55 const std::string& event_message) override; | |
| 56 void LogDebugEvent(DebugEvent event_type) override; | |
| 57 | |
| 58 private: | |
| 59 // This function is identical to LogDebugEvent, but requires holding the lock. | |
| 60 void LogDebugEventLocked(DebugEvent event_type, | |
| 61 const std::string& event_message) | |
| 62 EXCLUSIVE_LOCKS_REQUIRED(crit_); | |
| 63 // Stops logging and clears the stored data and buffers. | |
| 64 void Clear() EXCLUSIVE_LOCKS_REQUIRED(crit_); | |
| 65 // Adds a new event to the logfile if logging is active, or adds it to the | |
| 66 // list of recent log events otherwise. | |
| 67 void HandleEvent(ACMDumpEvent* event) EXCLUSIVE_LOCKS_REQUIRED(crit_); | |
| 68 // Writes the event to the file. Note that this will destroy the state of the | |
| 69 // input argument. | |
| 70 void StoreToFile(ACMDumpEvent* event) EXCLUSIVE_LOCKS_REQUIRED(crit_); | |
| 71 // Adds the event to the list of recent events, and removes any events that | |
| 72 // are too old and no longer fall in the time window. | |
| 73 void AddRecentEvent(const ACMDumpEvent& event) | |
| 74 EXCLUSIVE_LOCKS_REQUIRED(crit_); | |
| 75 | |
| 76 // Amount of time in microseconds to record log events, before starting the | |
| 77 // actual log. | |
| 78 const int recent_log_duration_us = 10000000; | |
| 79 | |
| 80 rtc::scoped_ptr<webrtc::CriticalSectionWrapper> crit_; | |
| 81 rtc::scoped_ptr<webrtc::FileWrapper> file_ GUARDED_BY(crit_); | |
| 82 rtc::scoped_ptr<ACMDumpEventStream> stream_ GUARDED_BY(crit_); | |
| 83 std::deque<ACMDumpEvent> recent_log_events_ GUARDED_BY(crit_); | |
| 84 bool currently_logging_ GUARDED_BY(crit_); | |
| 85 int64_t start_time_us_ GUARDED_BY(crit_); | |
| 86 int64_t duration_us_ GUARDED_BY(crit_); | |
| 87 const webrtc::Clock* const clock_; | |
| 88 }; | |
| 89 | |
| 90 namespace { | |
| 91 | |
| 92 // Convert from AcmDump's debug event enum (runtime format) to the corresponding | |
| 93 // protobuf enum (serialized format). | |
| 94 ACMDumpDebugEvent_EventType convertDebugEvent(AcmDump::DebugEvent event_type) { | |
| 95 switch (event_type) { | |
| 96 case AcmDump::DebugEvent::kLogStart: | |
| 97 return ACMDumpDebugEvent::LOG_START; | |
| 98 case AcmDump::DebugEvent::kLogEnd: | |
| 99 return ACMDumpDebugEvent::LOG_END; | |
| 100 case AcmDump::DebugEvent::kAudioPlayout: | |
| 101 return ACMDumpDebugEvent::AUDIO_PLAYOUT; | |
| 102 } | |
| 103 return ACMDumpDebugEvent::UNKNOWN_EVENT; | |
| 104 } | |
| 105 | |
| 106 } // Anonymous namespace. | |
| 107 | |
| 108 // AcmDumpImpl member functions. | |
| 109 AcmDumpImpl::AcmDumpImpl() | |
| 110 : crit_(webrtc::CriticalSectionWrapper::CreateCriticalSection()), | |
| 111 file_(webrtc::FileWrapper::Create()), | |
| 112 stream_(new webrtc::ACMDumpEventStream()), | |
| 113 currently_logging_(false), | |
| 114 start_time_us_(0), | |
| 115 duration_us_(0), | |
| 116 clock_(webrtc::Clock::GetRealTimeClock()) { | |
| 117 } | |
| 118 | |
| 119 void AcmDumpImpl::StartLogging(const std::string& file_name, int duration_ms) { | |
| 120 CriticalSectionScoped lock(crit_.get()); | |
| 121 Clear(); | |
| 122 if (file_->OpenFile(file_name.c_str(), false) != 0) { | |
| 123 return; | |
| 124 } | |
| 125 // Add LOG_START event to the recent event list. This call will also remove | |
| 126 // any events that are too old from the recent event list. | |
| 127 LogDebugEventLocked(DebugEvent::kLogStart, ""); | |
| 128 currently_logging_ = true; | |
| 129 start_time_us_ = clock_->TimeInMicroseconds(); | |
| 130 duration_us_ = static_cast<int64_t>(duration_ms) * 1000; | |
| 131 // Write all the recent events to the log file. | |
| 132 for (auto&& event : recent_log_events_) { | |
| 133 StoreToFile(&event); | |
| 134 } | |
| 135 recent_log_events_.clear(); | |
| 136 } | |
| 137 | |
| 138 void AcmDumpImpl::LogRtpPacket(bool incoming, | |
| 139 const uint8_t* packet, | |
| 140 size_t length) { | |
| 141 CriticalSectionScoped lock(crit_.get()); | |
| 142 ACMDumpEvent rtp_event; | |
| 143 const int64_t timestamp = clock_->TimeInMicroseconds(); | |
| 144 rtp_event.set_timestamp_us(timestamp); | |
| 145 rtp_event.set_type(webrtc::ACMDumpEvent::RTP_EVENT); | |
| 146 rtp_event.mutable_packet()->set_direction( | |
| 147 incoming ? ACMDumpRTPPacket::INCOMING : ACMDumpRTPPacket::OUTGOING); | |
| 148 rtp_event.mutable_packet()->set_rtp_data(packet, length); | |
| 149 HandleEvent(&rtp_event); | |
| 150 } | |
| 151 | |
| 152 void AcmDumpImpl::LogDebugEvent(DebugEvent event_type, | |
| 153 const std::string& event_message) { | |
| 154 CriticalSectionScoped lock(crit_.get()); | |
| 155 LogDebugEventLocked(event_type, event_message); | |
| 156 } | |
| 157 | |
| 158 void AcmDumpImpl::LogDebugEvent(DebugEvent event_type) { | |
| 159 CriticalSectionScoped lock(crit_.get()); | |
| 160 LogDebugEventLocked(event_type, ""); | |
| 161 } | |
| 162 | |
| 163 void AcmDumpImpl::LogDebugEventLocked(DebugEvent event_type, | |
| 164 const std::string& event_message) { | |
| 165 ACMDumpEvent event; | |
| 166 int64_t timestamp = clock_->TimeInMicroseconds(); | |
| 167 event.set_timestamp_us(timestamp); | |
| 168 event.set_type(webrtc::ACMDumpEvent::DEBUG_EVENT); | |
| 169 auto debug_event = event.mutable_debug_event(); | |
| 170 debug_event->set_type(convertDebugEvent(event_type)); | |
| 171 debug_event->set_message(event_message); | |
| 172 HandleEvent(&event); | |
| 173 } | |
| 174 | |
| 175 void AcmDumpImpl::Clear() { | |
| 176 if (file_->Open()) { | |
| 177 file_->CloseFile(); | |
| 178 } | |
| 179 currently_logging_ = false; | |
| 180 stream_->Clear(); | |
| 181 } | |
| 182 | |
| 183 void AcmDumpImpl::HandleEvent(ACMDumpEvent* event) { | |
| 184 if (currently_logging_) { | |
| 185 if (clock_->TimeInMicroseconds() < start_time_us_ + duration_us_) { | |
| 186 StoreToFile(event); | |
| 187 } else { | |
| 188 LogDebugEventLocked(DebugEvent::kLogEnd, ""); | |
| 189 Clear(); | |
| 190 AddRecentEvent(*event); | |
| 191 } | |
| 192 } else { | |
| 193 AddRecentEvent(*event); | |
| 194 } | |
| 195 } | |
| 196 | |
| 197 void AcmDumpImpl::StoreToFile(ACMDumpEvent* event) { | |
| 198 // Reuse the same object at every log event. | |
| 199 if (stream_->stream_size() < 1) { | |
| 200 stream_->add_stream(); | |
| 201 } | |
| 202 DCHECK_EQ(stream_->stream_size(), 1); | |
| 203 stream_->mutable_stream(0)->Swap(event); | |
| 204 | |
| 205 std::string dump_buffer; | |
| 206 stream_->SerializeToString(&dump_buffer); | |
| 207 file_->Write(dump_buffer.data(), dump_buffer.size()); | |
| 208 } | |
| 209 | |
| 210 void AcmDumpImpl::AddRecentEvent(const ACMDumpEvent& event) { | |
| 211 recent_log_events_.push_back(event); | |
| 212 while (recent_log_events_.front().timestamp_us() < | |
| 213 event.timestamp_us() - recent_log_duration_us) { | |
| 214 recent_log_events_.pop_front(); | |
| 215 } | |
| 216 } | |
| 217 | |
| 218 bool AcmDump::ParseAcmDump(const std::string& file_name, | |
| 219 ACMDumpEventStream* result) { | |
| 220 char tmp_buffer[1024]; | |
| 221 int bytes_read = 0; | |
| 222 rtc::scoped_ptr<FileWrapper> dump_file(FileWrapper::Create()); | |
| 223 if (dump_file->OpenFile(file_name.c_str(), true) != 0) { | |
| 224 return false; | |
| 225 } | |
| 226 std::string dump_buffer; | |
| 227 while ((bytes_read = dump_file->Read(tmp_buffer, sizeof(tmp_buffer))) > 0) { | |
| 228 dump_buffer.append(tmp_buffer, bytes_read); | |
| 229 } | |
| 230 dump_file->CloseFile(); | |
| 231 return result->ParseFromString(dump_buffer); | |
| 232 } | |
| 233 | |
| 234 #endif // RTC_AUDIOCODING_DEBUG_DUMP | |
| 235 | |
| 236 // AcmDump member functions. | |
| 237 rtc::scoped_ptr<AcmDump> AcmDump::Create() { | |
| 238 return rtc::scoped_ptr<AcmDump>(new AcmDumpImpl()); | |
| 239 } | |
| 240 } // namespace webrtc | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1230973005:
Adds logging of configuration information for VideoReceiveStream (Closed)
Base URL: https://chromium.googlesource.com/external/webrtc.git@master