src/media/cast/rtp_receiver/rtp_parser/rtp_parser.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 "media/cast/rtp_receiver/rtp_parser/rtp_parser.h"
   6
   7 #include "base/logging.h"
   8 #include "media/cast/cast_defines.h"
   9 #include "media/cast/rtp_receiver/rtp_receiver.h"
  10 #include "net/base/big_endian.h"
  11
  12 namespace media {
  13 namespace cast {
  14
  15 static const size_t kRtpCommonHeaderLength = 12;
  16 static const size_t kRtpCastHeaderLength = 7;
  17 static const uint8 kCastKeyFrameBitMask = 0x80;
  18 static const uint8 kCastReferenceFrameIdBitMask = 0x40;
  19
  20 RtpParser::RtpParser(RtpData* incoming_payload_callback,
  21                      const RtpParserConfig parser_config)
  22     : data_callback_(incoming_payload_callback),
  23       parser_config_(parser_config) {}
  24
  25 RtpParser::~RtpParser() {}
  26
  27 bool RtpParser::ParsePacket(const uint8* packet,
  28                             size_t length,
  29                             RtpCastHeader* rtp_header) {
  30   if (length == 0)
  31     return false;
  32   // Get RTP general header.
  33   if (!ParseCommon(packet, length, rtp_header))
  34     return false;
  35   if (rtp_header->webrtc.header.payloadType == parser_config_.payload_type &&
  36       rtp_header->webrtc.header.ssrc == parser_config_.ssrc) {
  37     return ParseCast(packet + kRtpCommonHeaderLength,
  38                      length - kRtpCommonHeaderLength,
  39                      rtp_header);
  40   }
  41   // Not a valid payload type / ssrc combination.
  42   return false;
  43 }
  44
  45 bool RtpParser::ParseCommon(const uint8* packet,
  46                             size_t length,
  47                             RtpCastHeader* rtp_header) {
  48   if (length < kRtpCommonHeaderLength)
  49     return false;
  50   uint8 version = packet[0] >> 6;
  51   if (version != 2)
  52     return false;
  53   uint8 cc = packet[0] & 0x0f;
  54   bool marker = ((packet[1] & 0x80) != 0);
  55   int payload_type = packet[1] & 0x7f;
  56
  57   uint16 sequence_number;
  58   uint32 rtp_timestamp, ssrc;
  59   net::BigEndianReader big_endian_reader(packet + 2, 10);
  60   big_endian_reader.ReadU16(&sequence_number);
  61   big_endian_reader.ReadU32(&rtp_timestamp);
  62   big_endian_reader.ReadU32(&ssrc);
  63
  64   if (ssrc != parser_config_.ssrc)
  65     return false;
  66
  67   rtp_header->webrtc.header.markerBit = marker;
  68   rtp_header->webrtc.header.payloadType = payload_type;
  69   rtp_header->webrtc.header.sequenceNumber = sequence_number;
  70   rtp_header->webrtc.header.timestamp = rtp_timestamp;
  71   rtp_header->webrtc.header.ssrc = ssrc;
  72   rtp_header->webrtc.header.numCSRCs = cc;
  73
  74   uint8 csrc_octs = cc * 4;
  75   rtp_header->webrtc.type.Audio.numEnergy = rtp_header->webrtc.header.numCSRCs;
  76   rtp_header->webrtc.header.headerLength = kRtpCommonHeaderLength + csrc_octs;
  77   rtp_header->webrtc.type.Audio.isCNG = false;
  78   rtp_header->webrtc.type.Audio.channel = parser_config_.audio_channels;
  79   // TODO(pwestin): look at x bit and skip data.
  80   return true;
  81 }
  82
  83 bool RtpParser::ParseCast(const uint8* packet,
  84                           size_t length,
  85                           RtpCastHeader* rtp_header) {
  86   if (length < kRtpCastHeaderLength)
  87     return false;
  88
  89   // Extract header.
  90   const uint8* data_ptr = packet;
  91   size_t data_length = length;
  92   rtp_header->is_key_frame = (data_ptr[0] & kCastKeyFrameBitMask);
  93   rtp_header->is_reference = (data_ptr[0] & kCastReferenceFrameIdBitMask);
  94   rtp_header->frame_id = frame_id_wrap_helper_.MapTo32bitsFrameId(data_ptr[1]);
  95
  96   net::BigEndianReader big_endian_reader(data_ptr + 2, 4);
  97   big_endian_reader.ReadU16(&rtp_header->packet_id);
  98   big_endian_reader.ReadU16(&rtp_header->max_packet_id);
  99
 100   if (rtp_header->is_reference) {
 101     rtp_header->reference_frame_id =
 102         reference_frame_id_wrap_helper_.MapTo32bitsFrameId(data_ptr[6]);
 103     data_ptr += kRtpCastHeaderLength;
 104     data_length -= kRtpCastHeaderLength;
 105   } else {
 106     data_ptr += kRtpCastHeaderLength - 1;
 107     data_length -= kRtpCastHeaderLength - 1;
 108   }
 109
 110   if (rtp_header->max_packet_id < rtp_header->packet_id)
 111     return false;
 112
 113   data_callback_->OnReceivedPayloadData(data_ptr, data_length, rtp_header);
 114   return true;
 115 }
 116
 117 }  // namespace cast
 118 }  // namespace media