media/cast/logging/logging_impl.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 "base/big_endian.h"
   6 #include "base/debug/trace_event.h"
   7 #include "media/cast/logging/logging_impl.h"
   8
   9 namespace media {
  10 namespace cast {
  11
  12 // TODO(imcheng): Collapse LoggingRaw onto LoggingImpl.
  13 LoggingImpl::LoggingImpl() {
  14   // LoggingImpl can be constructed on any thread, but its methods should all be
  15   // called on the same thread.
  16   thread_checker_.DetachFromThread();
  17 }
  18
  19 LoggingImpl::~LoggingImpl() {}
  20
  21 void LoggingImpl::InsertFrameEvent(const base::TimeTicks& time_of_event,
  22                                    CastLoggingEvent event, uint32 rtp_timestamp,
  23                                    uint32 frame_id) {
  24   DCHECK(thread_checker_.CalledOnValidThread());
  25   raw_.InsertFrameEvent(time_of_event, event, rtp_timestamp, frame_id);
  26 }
  27
  28 void LoggingImpl::InsertEncodedFrameEvent(const base::TimeTicks& time_of_event,
  29                                           CastLoggingEvent event,
  30                                           uint32 rtp_timestamp,
  31                                           uint32 frame_id, int frame_size,
  32                                           bool key_frame,
  33                                           int target_bitrate) {
  34   DCHECK(thread_checker_.CalledOnValidThread());
  35   raw_.InsertEncodedFrameEvent(time_of_event, event, rtp_timestamp, frame_id,
  36                                frame_size, key_frame, target_bitrate);
  37 }
  38
  39 void LoggingImpl::InsertFrameEventWithDelay(
  40     const base::TimeTicks& time_of_event, CastLoggingEvent event,
  41     uint32 rtp_timestamp, uint32 frame_id, base::TimeDelta delay) {
  42   DCHECK(thread_checker_.CalledOnValidThread());
  43   raw_.InsertFrameEventWithDelay(time_of_event, event, rtp_timestamp,
  44                                  frame_id, delay);
  45 }
  46
  47 void LoggingImpl::InsertSinglePacketEvent(const base::TimeTicks& time_of_event,
  48                                           CastLoggingEvent event,
  49                                           const Packet& packet) {
  50   DCHECK(thread_checker_.CalledOnValidThread());
  51
  52   // Parse basic properties.
  53   uint32 rtp_timestamp;
  54   uint16 packet_id, max_packet_id;
  55   const uint8* packet_data = &packet[0];
  56   base::BigEndianReader big_endian_reader(
  57       reinterpret_cast<const char*>(packet_data + 4), 4);
  58   big_endian_reader.ReadU32(&rtp_timestamp);
  59   base::BigEndianReader cast_big_endian_reader(
  60       reinterpret_cast<const char*>(packet_data + 12 + 2), 4);
  61   cast_big_endian_reader.ReadU16(&packet_id);
  62   cast_big_endian_reader.ReadU16(&max_packet_id);
  63
  64   // rtp_timestamp is enough - no need for frame_id as well.
  65   InsertPacketEvent(time_of_event,
  66                     event,
  67                     rtp_timestamp,
  68                     kFrameIdUnknown,
  69                     packet_id,
  70                     max_packet_id,
  71                     packet.size());
  72 }
  73
  74 void LoggingImpl::InsertPacketListEvent(const base::TimeTicks& time_of_event,
  75                                         CastLoggingEvent event,
  76                                         const PacketList& packets) {
  77   DCHECK(thread_checker_.CalledOnValidThread());
  78   for (PacketList::const_iterator it = packets.begin(); it != packets.end();
  79        ++it) {
  80     InsertSinglePacketEvent(time_of_event, event, (*it)->data);
  81   }
  82 }
  83
  84 void LoggingImpl::InsertPacketEvent(const base::TimeTicks& time_of_event,
  85                                     CastLoggingEvent event,
  86                                     uint32 rtp_timestamp, uint32 frame_id,
  87                                     uint16 packet_id, uint16 max_packet_id,
  88                                     size_t size) {
  89   DCHECK(thread_checker_.CalledOnValidThread());
  90   raw_.InsertPacketEvent(time_of_event, event, rtp_timestamp, frame_id,
  91                          packet_id, max_packet_id, size);
  92 }
  93
  94 void LoggingImpl::AddRawEventSubscriber(RawEventSubscriber* subscriber) {
  95   DCHECK(thread_checker_.CalledOnValidThread());
  96   raw_.AddSubscriber(subscriber);
  97 }
  98
  99 void LoggingImpl::RemoveRawEventSubscriber(RawEventSubscriber* subscriber) {
 100   DCHECK(thread_checker_.CalledOnValidThread());
 101   raw_.RemoveSubscriber(subscriber);
 102 }
 103
 104 }  // namespace cast
 105 }  // namespace media