src/chrome/renderer/media/cast_rtp_stream.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/renderer/media/cast_rtp_stream.h"
   6
   7 #include "base/bind.h"
   8 #include "base/debug/trace_event.h"
   9 #include "base/logging.h"
  10 #include "base/memory/weak_ptr.h"
  11 #include "base/strings/stringprintf.h"
  12 #include "base/sys_info.h"
  13 #include "chrome/renderer/media/cast_session.h"
  14 #include "chrome/renderer/media/cast_udp_transport.h"
  15 #include "content/public/renderer/media_stream_audio_sink.h"
  16 #include "content/public/renderer/media_stream_video_sink.h"
  17 #include "content/public/renderer/render_thread.h"
  18 #include "content/public/renderer/video_encode_accelerator.h"
  19 #include "media/audio/audio_parameters.h"
  20 #include "media/base/audio_bus.h"
  21 #include "media/base/audio_fifo.h"
  22 #include "media/base/bind_to_current_loop.h"
  23 #include "media/base/multi_channel_resampler.h"
  24 #include "media/base/video_frame.h"
  25 #include "media/cast/cast_config.h"
  26 #include "media/cast/cast_defines.h"
  27 #include "media/cast/cast_sender.h"
  28 #include "media/cast/net/cast_transport_config.h"
  29 #include "third_party/WebKit/public/platform/WebMediaStreamSource.h"
  30 #include "ui/gfx/geometry/size.h"
  31
  32 using media::cast::AudioSenderConfig;
  33 using media::cast::VideoSenderConfig;
  34
  35 namespace {
  36
  37 const char kCodecNameOpus[] = "OPUS";
  38 const char kCodecNameVp8[] = "VP8";
  39 const char kCodecNameH264[] = "H264";
  40
  41 // To convert from kilobits per second to bits to per second.
  42 const int kBitrateMultiplier = 1000;
  43
  44 // This constant defines the number of sets of audio data to buffer
  45 // in the FIFO. If input audio and output data have different resampling
  46 // rates then buffer is necessary to avoid audio glitches.
  47 // See CastAudioSink::ResampleData() and CastAudioSink::OnSetFormat()
  48 // for more defaults.
  49 const int kBufferAudioData = 2;
  50
  51 CastRtpPayloadParams DefaultOpusPayload() {
  52   CastRtpPayloadParams payload;
  53   payload.payload_type = 127;
  54   payload.max_latency_ms = media::cast::kDefaultRtpMaxDelayMs;
  55   payload.ssrc = 1;
  56   payload.feedback_ssrc = 2;
  57   payload.clock_rate = media::cast::kDefaultAudioSamplingRate;
  58   // The value is 0 which means VBR.
  59   payload.min_bitrate = payload.max_bitrate =
  60       media::cast::kDefaultAudioEncoderBitrate;
  61   payload.channels = 2;
  62   payload.max_frame_rate = 100;  // 10 ms audio frames
  63   payload.codec_name = kCodecNameOpus;
  64   return payload;
  65 }
  66
  67 CastRtpPayloadParams DefaultVp8Payload() {
  68   CastRtpPayloadParams payload;
  69   payload.payload_type = 96;
  70   payload.max_latency_ms = media::cast::kDefaultRtpMaxDelayMs;
  71   payload.ssrc = 11;
  72   payload.feedback_ssrc = 12;
  73   payload.clock_rate = media::cast::kVideoFrequency;
  74   payload.max_bitrate = 2000;
  75   payload.min_bitrate = 50;
  76   payload.channels = 1;
  77   payload.max_frame_rate = media::cast::kDefaultMaxFrameRate;
  78   payload.width = 1280;
  79   payload.height = 720;
  80   payload.codec_name = kCodecNameVp8;
  81   return payload;
  82 }
  83
  84 CastRtpPayloadParams DefaultH264Payload() {
  85   CastRtpPayloadParams payload;
  86   // TODO(hshi): set different ssrc/rtpPayloadType values for H264 and VP8
  87   // once b/13696137 is fixed.
  88   payload.payload_type = 96;
  89   payload.max_latency_ms = media::cast::kDefaultRtpMaxDelayMs;
  90   payload.ssrc = 11;
  91   payload.feedback_ssrc = 12;
  92   payload.clock_rate = media::cast::kVideoFrequency;
  93   payload.max_bitrate = 2000;
  94   payload.min_bitrate = 50;
  95   payload.channels = 1;
  96   payload.max_frame_rate = media::cast::kDefaultMaxFrameRate;
  97   payload.width = 1280;
  98   payload.height = 720;
  99   payload.codec_name = kCodecNameH264;
 100   return payload;
 101 }
 102
 103 bool IsHardwareVP8EncodingSupported() {
 104   // Query for hardware VP8 encoder support.
 105   std::vector<media::VideoEncodeAccelerator::SupportedProfile> vea_profiles =
 106       content::GetSupportedVideoEncodeAcceleratorProfiles();
 107   for (size_t i = 0; i < vea_profiles.size(); ++i) {
 108     if (vea_profiles[i].profile >= media::VP8PROFILE_MIN &&
 109         vea_profiles[i].profile <= media::VP8PROFILE_MAX) {
 110       return true;
 111     }
 112   }
 113   return false;
 114 }
 115
 116 bool IsHardwareH264EncodingSupported() {
 117   // Query for hardware H.264 encoder support.
 118   std::vector<media::VideoEncodeAccelerator::SupportedProfile> vea_profiles =
 119       content::GetSupportedVideoEncodeAcceleratorProfiles();
 120   for (size_t i = 0; i < vea_profiles.size(); ++i) {
 121     if (vea_profiles[i].profile >= media::H264PROFILE_MIN &&
 122         vea_profiles[i].profile <= media::H264PROFILE_MAX) {
 123       return true;
 124     }
 125   }
 126   return false;
 127 }
 128
 129 int NumberOfEncodeThreads() {
 130   // We want to give CPU cycles for capturing and not to saturate the system
 131   // just for encoding. So on a lower end system with only 1 or 2 cores we
 132   // use only one thread for encoding.
 133   if (base::SysInfo::NumberOfProcessors() <= 2)
 134     return 1;
 135
 136   // On higher end we want to use 2 threads for encoding to reduce latency.
 137   // In theory a physical CPU core has maximum 2 hyperthreads. Having 3 or
 138   // more logical processors means the system has at least 2 physical cores.
 139   return 2;
 140 }
 141
 142 std::vector<CastRtpParams> SupportedAudioParams() {
 143   // TODO(hclam): Fill in more codecs here.
 144   std::vector<CastRtpParams> supported_params;
 145   supported_params.push_back(CastRtpParams(DefaultOpusPayload()));
 146   return supported_params;
 147 }
 148
 149 std::vector<CastRtpParams> SupportedVideoParams() {
 150   std::vector<CastRtpParams> supported_params;
 151   if (IsHardwareH264EncodingSupported())
 152     supported_params.push_back(CastRtpParams(DefaultH264Payload()));
 153   supported_params.push_back(CastRtpParams(DefaultVp8Payload()));
 154   return supported_params;
 155 }
 156
 157 bool ToAudioSenderConfig(const CastRtpParams& params,
 158                          AudioSenderConfig* config) {
 159   config->ssrc = params.payload.ssrc;
 160   config->incoming_feedback_ssrc = params.payload.feedback_ssrc;
 161   if (config->ssrc == config->incoming_feedback_ssrc)
 162     return false;
 163   config->min_playout_delay =
 164       base::TimeDelta::FromMilliseconds(
 165           params.payload.min_latency_ms ?
 166           params.payload.min_latency_ms :
 167           params.payload.max_latency_ms);
 168   config->max_playout_delay =
 169       base::TimeDelta::FromMilliseconds(params.payload.max_latency_ms);
 170   if (config->min_playout_delay <= base::TimeDelta())
 171     return false;
 172   if (config->min_playout_delay > config->max_playout_delay)
 173     return false;
 174   config->rtp_payload_type = params.payload.payload_type;
 175   config->use_external_encoder = false;
 176   config->frequency = params.payload.clock_rate;
 177   if (config->frequency < 8000)
 178     return false;
 179   config->channels = params.payload.channels;
 180   if (config->channels < 1)
 181     return false;
 182   config->bitrate = params.payload.max_bitrate * kBitrateMultiplier;
 183   if (params.payload.codec_name == kCodecNameOpus)
 184     config->codec = media::cast::CODEC_AUDIO_OPUS;
 185   else
 186     return false;
 187   config->aes_key = params.payload.aes_key;
 188   config->aes_iv_mask = params.payload.aes_iv_mask;
 189   return true;
 190 }
 191
 192 bool ToVideoSenderConfig(const CastRtpParams& params,
 193                          VideoSenderConfig* config) {
 194   config->ssrc = params.payload.ssrc;
 195   config->incoming_feedback_ssrc = params.payload.feedback_ssrc;
 196   if (config->ssrc == config->incoming_feedback_ssrc)
 197     return false;
 198   config->min_playout_delay =
 199       base::TimeDelta::FromMilliseconds(
 200           params.payload.min_latency_ms ?
 201           params.payload.min_latency_ms :
 202           params.payload.max_latency_ms);
 203   config->max_playout_delay =
 204       base::TimeDelta::FromMilliseconds(params.payload.max_latency_ms);
 205   if (config->min_playout_delay <= base::TimeDelta())
 206     return false;
 207   if (config->min_playout_delay > config->max_playout_delay)
 208     return false;
 209   config->rtp_payload_type = params.payload.payload_type;
 210   config->width = params.payload.width;
 211   config->height = params.payload.height;
 212   if (config->width < 2 || config->height < 2)
 213     return false;
 214   config->min_bitrate = config->start_bitrate =
 215       params.payload.min_bitrate * kBitrateMultiplier;
 216   config->max_bitrate = params.payload.max_bitrate * kBitrateMultiplier;
 217   if (config->min_bitrate > config->max_bitrate)
 218     return false;
 219   config->start_bitrate = config->min_bitrate;
 220   config->max_frame_rate = static_cast<int>(
 221       std::max(1.0, params.payload.max_frame_rate) + 0.5);
 222   if (config->max_frame_rate > 120)
 223     return false;
 224   if (params.payload.codec_name == kCodecNameVp8) {
 225     config->use_external_encoder = IsHardwareVP8EncodingSupported();
 226     config->codec = media::cast::CODEC_VIDEO_VP8;
 227   } else if (params.payload.codec_name == kCodecNameH264) {
 228     config->use_external_encoder = IsHardwareH264EncodingSupported();
 229     config->codec = media::cast::CODEC_VIDEO_H264;
 230   } else {
 231     return false;
 232   }
 233   if (!config->use_external_encoder) {
 234     config->number_of_encode_threads = NumberOfEncodeThreads();
 235   }
 236   config->aes_key = params.payload.aes_key;
 237   config->aes_iv_mask = params.payload.aes_iv_mask;
 238   return true;
 239 }
 240
 241 }  // namespace
 242
 243 // This class receives MediaStreamTrack events and video frames from a
 244 // MediaStreamTrack.
 245 //
 246 // Threading: Video frames are received on the IO thread and then
 247 // forwarded to media::cast::VideoFrameInput through a static method.
 248 // Member variables of this class are only accessed on the render thread.
 249 class CastVideoSink : public base::SupportsWeakPtr<CastVideoSink>,
 250                       public content::MediaStreamVideoSink {
 251  public:
 252   // |track| provides data for this sink.
 253   // |expected_natural_size| is the expected dimension of the video frame.
 254   // |error_callback| is called if video formats don't match.
 255   CastVideoSink(const blink::WebMediaStreamTrack& track,
 256                 const gfx::Size& expected_natural_size,
 257                 const CastRtpStream::ErrorCallback& error_callback)
 258       : track_(track),
 259         sink_added_(false),
 260         expected_natural_size_(expected_natural_size),
 261         error_callback_(error_callback) {}
 262
 263   virtual ~CastVideoSink() {
 264     if (sink_added_)
 265       RemoveFromVideoTrack(this, track_);
 266   }
 267
 268   // This static method is used to forward video frames to |frame_input|.
 269   static void OnVideoFrame(
 270       // These parameters are already bound when callback is created.
 271       const gfx::Size& expected_natural_size,
 272       const CastRtpStream::ErrorCallback& error_callback,
 273       const scoped_refptr<media::cast::VideoFrameInput> frame_input,
 274       // These parameters are passed for each frame.
 275       const scoped_refptr<media::VideoFrame>& frame,
 276       const media::VideoCaptureFormat& format,
 277       const base::TimeTicks& estimated_capture_time) {
 278     if (frame->natural_size() != expected_natural_size) {
 279       error_callback.Run(
 280           base::StringPrintf("Video frame resolution does not match config."
 281                              " Expected %dx%d. Got %dx%d.",
 282                              expected_natural_size.width(),
 283                              expected_natural_size.height(),
 284                              frame->natural_size().width(),
 285                              frame->natural_size().height()));
 286       return;
 287     }
 288
 289     base::TimeTicks timestamp;
 290     if (estimated_capture_time.is_null())
 291       timestamp = base::TimeTicks::Now();
 292     else
 293       timestamp = estimated_capture_time;
 294
 295     // Used by chrome/browser/extension/api/cast_streaming/performance_test.cc
 296     TRACE_EVENT_INSTANT2(
 297         "cast_perf_test", "MediaStreamVideoSink::OnVideoFrame",
 298         TRACE_EVENT_SCOPE_THREAD,
 299         "timestamp",  timestamp.ToInternalValue(),
 300         "time_delta", frame->timestamp().ToInternalValue());
 301     frame_input->InsertRawVideoFrame(frame, timestamp);
 302   }
 303
 304   // Attach this sink to a video track represented by |track_|.
 305   // Data received from the track will be submitted to |frame_input|.
 306   void AddToTrack(
 307       const scoped_refptr<media::cast::VideoFrameInput>& frame_input) {
 308     DCHECK(!sink_added_);
 309     sink_added_ = true;
 310     AddToVideoTrack(
 311         this,
 312         base::Bind(
 313             &CastVideoSink::OnVideoFrame,
 314             expected_natural_size_,
 315             error_callback_,
 316             frame_input),
 317         track_);
 318   }
 319
 320  private:
 321   blink::WebMediaStreamTrack track_;
 322   bool sink_added_;
 323   gfx::Size expected_natural_size_;
 324   CastRtpStream::ErrorCallback error_callback_;
 325
 326   DISALLOW_COPY_AND_ASSIGN(CastVideoSink);
 327 };
 328
 329 // Receives audio data from a MediaStreamTrack. Data is submitted to
 330 // media::cast::FrameInput.
 331 //
 332 // Threading: Audio frames are received on the real-time audio thread.
 333 // Note that RemoveFromAudioTrack() is synchronous and we have
 334 // gurantee that there will be no more audio data after calling it.
 335 class CastAudioSink : public base::SupportsWeakPtr<CastAudioSink>,
 336                       public content::MediaStreamAudioSink {
 337  public:
 338   // |track| provides data for this sink.
 339   // |error_callback| is called if audio formats don't match.
 340   CastAudioSink(const blink::WebMediaStreamTrack& track,
 341                 const CastRtpStream::ErrorCallback& error_callback,
 342                 int output_channels,
 343                 int output_sample_rate)
 344       : track_(track),
 345         sink_added_(false),
 346         error_callback_(error_callback),
 347         weak_factory_(this),
 348         output_channels_(output_channels),
 349         output_sample_rate_(output_sample_rate),
 350         input_preroll_(0) {}
 351
 352   virtual ~CastAudioSink() {
 353     if (sink_added_)
 354       RemoveFromAudioTrack(this, track_);
 355   }
 356
 357   // Called on real-time audio thread.
 358   // content::MediaStreamAudioSink implementation.
 359   virtual void OnData(const int16* audio_data,
 360                       int sample_rate,
 361                       int number_of_channels,
 362                       int number_of_frames) OVERRIDE {
 363     scoped_ptr<media::AudioBus> input_bus;
 364     if (resampler_) {
 365       input_bus = ResampleData(
 366           audio_data, sample_rate, number_of_channels, number_of_frames);
 367       if (!input_bus)
 368         return;
 369     } else {
 370       input_bus = media::AudioBus::Create(
 371           number_of_channels, number_of_frames);
 372       input_bus->FromInterleaved(
 373           audio_data, number_of_frames, number_of_channels);
 374     }
 375
 376     // TODO(hclam): Pass in the accurate capture time to have good
 377     // audio / video sync.
 378     frame_input_->InsertAudio(input_bus.Pass(), base::TimeTicks::Now());
 379   }
 380
 381   // Return a resampled audio data from input. This is called when the
 382   // input sample rate doesn't match the output.
 383   // The flow of data is as follows:
 384   // |audio_data| ->
 385   //     AudioFifo |fifo_| ->
 386   //         MultiChannelResampler |resampler|.
 387   //
 388   // The resampler pulls data out of the FIFO and resample the data in
 389   // frequency domain. It might call |fifo_| for more than once. But no more
 390   // than |kBufferAudioData| times. We preroll audio data into the FIFO to
 391   // make sure there's enough data for resampling.
 392   scoped_ptr<media::AudioBus> ResampleData(
 393       const int16* audio_data,
 394       int sample_rate,
 395       int number_of_channels,
 396       int number_of_frames) {
 397     DCHECK_EQ(number_of_channels, output_channels_);
 398     fifo_input_bus_->FromInterleaved(
 399         audio_data, number_of_frames, number_of_channels);
 400     fifo_->Push(fifo_input_bus_.get());
 401
 402     if (input_preroll_ < kBufferAudioData - 1) {
 403       ++input_preroll_;
 404       return scoped_ptr<media::AudioBus>();
 405     }
 406
 407     scoped_ptr<media::AudioBus> output_bus(
 408         media::AudioBus::Create(
 409             output_channels_,
 410             output_sample_rate_ * fifo_input_bus_->frames() / sample_rate));
 411
 412     // Resampler will then call ProvideData() below to fetch data from
 413     // |input_data_|.
 414     resampler_->Resample(output_bus->frames(), output_bus.get());
 415     return output_bus.Pass();
 416   }
 417
 418   // Called on real-time audio thread.
 419   virtual void OnSetFormat(const media::AudioParameters& params) OVERRIDE {
 420     if (params.sample_rate() == output_sample_rate_)
 421       return;
 422     fifo_.reset(new media::AudioFifo(
 423         output_channels_,
 424         kBufferAudioData * params.frames_per_buffer()));
 425     fifo_input_bus_ = media::AudioBus::Create(
 426         params.channels(), params.frames_per_buffer());
 427     resampler_.reset(new media::MultiChannelResampler(
 428         output_channels_,
 429         static_cast<double>(params.sample_rate()) / output_sample_rate_,
 430         params.frames_per_buffer(),
 431         base::Bind(&CastAudioSink::ProvideData, base::Unretained(this))));
 432   }
 433
 434   // Add this sink to the track. Data received from the track will be
 435   // submitted to |frame_input|.
 436   void AddToTrack(
 437       const scoped_refptr<media::cast::AudioFrameInput>& frame_input) {
 438     DCHECK(!sink_added_);
 439     sink_added_ = true;
 440
 441     // This member is written here and then accessed on the IO thread
 442     // We will not get data until AddToAudioTrack is called so it is
 443     // safe to access this member now.
 444     frame_input_ = frame_input;
 445     AddToAudioTrack(this, track_);
 446   }
 447
 448   void ProvideData(int frame_delay, media::AudioBus* output_bus) {
 449     fifo_->Consume(output_bus, 0, output_bus->frames());
 450   }
 451
 452  private:
 453   blink::WebMediaStreamTrack track_;
 454   bool sink_added_;
 455   CastRtpStream::ErrorCallback error_callback_;
 456   base::WeakPtrFactory<CastAudioSink> weak_factory_;
 457
 458   const int output_channels_;
 459   const int output_sample_rate_;
 460
 461   // These member are accessed on the real-time audio time only.
 462   scoped_refptr<media::cast::AudioFrameInput> frame_input_;
 463   scoped_ptr<media::MultiChannelResampler> resampler_;
 464   scoped_ptr<media::AudioFifo> fifo_;
 465   scoped_ptr<media::AudioBus> fifo_input_bus_;
 466   int input_preroll_;
 467
 468   DISALLOW_COPY_AND_ASSIGN(CastAudioSink);
 469 };
 470
 471 CastRtpParams::CastRtpParams(const CastRtpPayloadParams& payload_params)
 472     : payload(payload_params) {}
 473
 474 CastCodecSpecificParams::CastCodecSpecificParams() {}
 475
 476 CastCodecSpecificParams::~CastCodecSpecificParams() {}
 477
 478 CastRtpPayloadParams::CastRtpPayloadParams()
 479     : payload_type(0),
 480       max_latency_ms(0),
 481       min_latency_ms(0),
 482       ssrc(0),
 483       feedback_ssrc(0),
 484       clock_rate(0),
 485       max_bitrate(0),
 486       min_bitrate(0),
 487       channels(0),
 488       max_frame_rate(0.0),
 489       width(0),
 490       height(0) {}
 491
 492 CastRtpPayloadParams::~CastRtpPayloadParams() {}
 493
 494 CastRtpParams::CastRtpParams() {}
 495
 496 CastRtpParams::~CastRtpParams() {}
 497
 498 CastRtpStream::CastRtpStream(const blink::WebMediaStreamTrack& track,
 499                              const scoped_refptr<CastSession>& session)
 500     : track_(track), cast_session_(session), weak_factory_(this) {}
 501
 502 CastRtpStream::~CastRtpStream() {}
 503
 504 std::vector<CastRtpParams> CastRtpStream::GetSupportedParams() {
 505   if (IsAudio())
 506     return SupportedAudioParams();
 507   else
 508     return SupportedVideoParams();
 509 }
 510
 511 CastRtpParams CastRtpStream::GetParams() { return params_; }
 512
 513 void CastRtpStream::Start(const CastRtpParams& params,
 514                           const base::Closure& start_callback,
 515                           const base::Closure& stop_callback,
 516                           const ErrorCallback& error_callback) {
 517   VLOG(1) << "CastRtpStream::Start = " << (IsAudio() ? "audio" : "video");
 518   stop_callback_ = stop_callback;
 519   error_callback_ = error_callback;
 520
 521   if (IsAudio()) {
 522     AudioSenderConfig config;
 523     if (!ToAudioSenderConfig(params, &config)) {
 524       DidEncounterError("Invalid parameters for audio.");
 525       return;
 526     }
 527
 528     // In case of error we have to go through DidEncounterError() to stop
 529     // the streaming after reporting the error.
 530     audio_sink_.reset(new CastAudioSink(
 531         track_,
 532         media::BindToCurrentLoop(base::Bind(&CastRtpStream::DidEncounterError,
 533                                             weak_factory_.GetWeakPtr())),
 534         params.payload.channels,
 535         params.payload.clock_rate));
 536     cast_session_->StartAudio(
 537         config,
 538         base::Bind(&CastAudioSink::AddToTrack, audio_sink_->AsWeakPtr()),
 539         base::Bind(&CastRtpStream::DidEncounterError,
 540                    weak_factory_.GetWeakPtr()));
 541     start_callback.Run();
 542   } else {
 543     VideoSenderConfig config;
 544     if (!ToVideoSenderConfig(params, &config)) {
 545       DidEncounterError("Invalid parameters for video.");
 546       return;
 547     }
 548     // See the code for audio above for explanation of callbacks.
 549     video_sink_.reset(new CastVideoSink(
 550         track_,
 551         gfx::Size(config.width, config.height),
 552         media::BindToCurrentLoop(base::Bind(&CastRtpStream::DidEncounterError,
 553                                             weak_factory_.GetWeakPtr()))));
 554     cast_session_->StartVideo(
 555         config,
 556         base::Bind(&CastVideoSink::AddToTrack, video_sink_->AsWeakPtr()),
 557         base::Bind(&CastRtpStream::DidEncounterError,
 558                    weak_factory_.GetWeakPtr()));
 559     start_callback.Run();
 560   }
 561 }
 562
 563 void CastRtpStream::Stop() {
 564   VLOG(1) << "CastRtpStream::Stop = " << (IsAudio() ? "audio" : "video");
 565   audio_sink_.reset();
 566   video_sink_.reset();
 567   if (!stop_callback_.is_null())
 568     stop_callback_.Run();
 569 }
 570
 571 void CastRtpStream::ToggleLogging(bool enable) {
 572   VLOG(1) << "CastRtpStream::ToggleLogging(" << enable << ") = "
 573           << (IsAudio() ? "audio" : "video");
 574   cast_session_->ToggleLogging(IsAudio(), enable);
 575 }
 576
 577 void CastRtpStream::GetRawEvents(
 578     const base::Callback<void(scoped_ptr<base::BinaryValue>)>& callback,
 579     const std::string& extra_data) {
 580   VLOG(1) << "CastRtpStream::GetRawEvents = "
 581           << (IsAudio() ? "audio" : "video");
 582   cast_session_->GetEventLogsAndReset(IsAudio(), extra_data, callback);
 583 }
 584
 585 void CastRtpStream::GetStats(
 586     const base::Callback<void(scoped_ptr<base::DictionaryValue>)>& callback) {
 587   VLOG(1) << "CastRtpStream::GetStats = "
 588           << (IsAudio() ? "audio" : "video");
 589   cast_session_->GetStatsAndReset(IsAudio(), callback);
 590 }
 591
 592 bool CastRtpStream::IsAudio() const {
 593   return track_.source().type() == blink::WebMediaStreamSource::TypeAudio;
 594 }
 595
 596 void CastRtpStream::DidEncounterError(const std::string& message) {
 597   VLOG(1) << "CastRtpStream::DidEncounterError(" << message << ") = "
 598           << (IsAudio() ? "audio" : "video");
 599   // Save the WeakPtr first because the error callback might delete this object.
 600   base::WeakPtr<CastRtpStream> ptr = weak_factory_.GetWeakPtr();
 601   error_callback_.Run(message);
 602   content::RenderThread::Get()->GetMessageLoop()->PostTask(
 603       FROM_HERE,
 604       base::Bind(&CastRtpStream::Stop, ptr));
 605 }