Add EncodedImageCallback::OnEncodedImage().

webrtc/modules/rtp_rtcp/source/rtp_sender_audio.cc

 /*
  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 127 matching lines @@
   // For G.723 G.729, AMR etc we can have inband VAD
   if (frame_type == kAudioFrameCN) {
     inband_vad_active_ = true;
   } else if (inband_vad_active_) {
     inband_vad_active_ = false;
     marker_bit = true;
   }
   return marker_bit;
 }
 
-int32_t RTPSenderAudio::SendAudio(FrameType frame_type,
+bool RTPSenderAudio::SendAudio(FrameType frame_type,
                                   int8_t payload_type,
                                   uint32_t capture_timestamp,
                                   const uint8_t* payload_data,
                                   size_t data_size,
                                   const RTPFragmentationHeader* fragmentation) {
   // TODO(pwestin) Breakup function in smaller functions.
   size_t payload_size = data_size;
   size_t max_payload_length = rtp_sender_->MaxPayloadLength();
   uint16_t dtmf_length_ms = 0;
   uint8_t key = 0;
@@ skipping 29 matching lines @@
   // A source MAY send events and coded audio packets for the same time
   // but we don't support it
   if (dtmf_event_is_on_) {
     if (frame_type == kEmptyFrame) {
       // kEmptyFrame is used to drive the DTMF when in CN mode
       // it can be triggered more frequently than we want to send the
       // DTMF packets.
       if (packet_size_samples >
           (capture_timestamp - dtmf_timestamp_last_sent_)) {
         // not time to send yet
-        return 0;
+        return true;
       }
     }
     dtmf_timestamp_last_sent_ = capture_timestamp;
     uint32_t dtmf_duration_samples = capture_timestamp - dtmf_timestamp_;
     bool ended = false;
     bool send = true;
 
     if (dtmf_length_samples_ > dtmf_duration_samples) {
       if (dtmf_duration_samples <= 0) {
         // Skip send packet at start, since we shouldn't use duration 0
@@ skipping 12 matching lines @@
 
         // set new timestap for this segment
         dtmf_timestamp_ = capture_timestamp;
         dtmf_duration_samples -= 0xffff;
         dtmf_length_samples_ -= 0xffff;
 
         return SendTelephoneEventPacket(
             ended, dtmf_payload_type, dtmf_timestamp_,
             static_cast<uint16_t>(dtmf_duration_samples), false);
       } else {
-        if (SendTelephoneEventPacket(ended, dtmf_payload_type, dtmf_timestamp_,
-                                     dtmf_duration_samples,
-                                     !dtmf_event_first_packet_sent_) != 0) {
-          return -1;
+        if (!SendTelephoneEventPacket(ended, dtmf_payload_type, dtmf_timestamp_,
+                                      dtmf_duration_samples,
+                                      !dtmf_event_first_packet_sent_)) {
+          return false;
         }
         dtmf_event_first_packet_sent_ = true;
-        return 0;
+        return true;
       }
     }
-    return 0;
+    return true;
   }
   if (payload_size == 0 || payload_data == NULL) {
     if (frame_type == kEmptyFrame) {
       // we don't send empty audio RTP packets
       // no error since we use it to drive DTMF when we use VAD
-      return 0;
+      return true;
     }
-    return -1;
+    return false;
   }
   uint8_t data_buffer[IP_PACKET_SIZE];
   bool marker_bit = MarkerBit(frame_type, payload_type);
 
   int32_t rtpHeaderLength = 0;
   uint16_t timestampOffset = 0;
 
   if (red_payload_type >= 0 && fragmentation && !marker_bit &&
       fragmentation->fragmentationVectorSize > 1) {
     // have we configured RED? use its payload type
     // we need to get the current timestamp to calc the diff
     uint32_t old_timestamp = rtp_sender_->Timestamp();
     rtpHeaderLength = rtp_sender_->BuildRtpHeader(data_buffer, red_payload_type,
                                                   marker_bit, capture_timestamp,
                                                   clock_->TimeInMilliseconds());
 
     timestampOffset = uint16_t(rtp_sender_->Timestamp() - old_timestamp);
   } else {
     rtpHeaderLength = rtp_sender_->BuildRtpHeader(data_buffer, payload_type,
                                                   marker_bit, capture_timestamp,
                                                   clock_->TimeInMilliseconds());
   }
   if (rtpHeaderLength <= 0) {
-    return -1;
+    return false;
   }
   if (max_payload_length < (rtpHeaderLength + payload_size)) {
     // Too large payload buffer.
-    return -1;
+    return false;
   }
   if (red_payload_type >= 0 &&  // Have we configured RED?
       fragmentation && fragmentation->fragmentationVectorSize > 1 &&
       !marker_bit) {
     if (timestampOffset <= 0x3fff) {
       if (fragmentation->fragmentationVectorSize != 2) {
         // we only support 2 codecs when using RED
-        return -1;
+        return false;
       }
       // only 0x80 if we have multiple blocks
       data_buffer[rtpHeaderLength++] =
           0x80 + fragmentation->fragmentationPlType[1];
       size_t blockLength = fragmentation->fragmentationLength[1];
 
       // sanity blockLength
       if (blockLength > 0x3ff) {  // block length 10 bits 1023 bytes
-        return -1;
+        return false;
       }
       uint32_t REDheader = (timestampOffset << 10) + blockLength;
       ByteWriter<uint32_t>::WriteBigEndian(data_buffer + rtpHeaderLength,
                                            REDheader);
       rtpHeaderLength += 3;
 
       data_buffer[rtpHeaderLength++] = fragmentation->fragmentationPlType[0];
       // copy the RED data
       memcpy(data_buffer + rtpHeaderLength,
              payload_data + fragmentation->fragmentationOffset[1],
@@ skipping 38 matching lines @@
   size_t packetSize = payload_size + rtpHeaderLength;
   RtpUtility::RtpHeaderParser rtp_parser(data_buffer, packetSize);
   RTPHeader rtp_header;
   rtp_parser.Parse(&rtp_header);
   rtp_sender_->UpdateAudioLevel(data_buffer, packetSize, rtp_header,
                                 (frame_type == kAudioFrameSpeech),
                                 audio_level_dbov);
   TRACE_EVENT_ASYNC_END2("webrtc", "Audio", capture_timestamp, "timestamp",
                          rtp_sender_->Timestamp(), "seqnum",
                          rtp_sender_->SequenceNumber());
-  int32_t send_result = rtp_sender_->SendToNetwork(
+  bool send_result = rtp_sender_->SendToNetwork(
       data_buffer, payload_size, rtpHeaderLength, rtc::TimeMillis(),
       kAllowRetransmission, RtpPacketSender::kHighPriority);
   if (first_packet_sent_()) {
     LOG(LS_INFO) << "First audio RTP packet sent to pacer";
   }
   return send_result;
 }
 
 // Audio level magnitude and voice activity flag are set for each RTP packet
 int32_t RTPSenderAudio::SetAudioLevel(uint8_t level_dbov) {
@@ skipping 33 matching lines @@
   {
     rtc::CritScope lock(&send_audio_critsect_);
     if (dtmf_payload_type_ < 0) {
       // TelephoneEvent payloadtype not configured
       return -1;
     }
   }
   return AddDTMF(key, time_ms, level);
 }
 
-int32_t RTPSenderAudio::SendTelephoneEventPacket(bool ended,
-                                                 int8_t dtmf_payload_type,
-                                                 uint32_t dtmf_timestamp,
-                                                 uint16_t duration,
-                                                 bool marker_bit) {
+bool RTPSenderAudio::SendTelephoneEventPacket(bool ended,
+                                              int8_t dtmf_payload_type,
+                                              uint32_t dtmf_timestamp,
+                                              uint16_t duration,
+                                              bool marker_bit) {
   uint8_t dtmfbuffer[IP_PACKET_SIZE];
-  uint8_t sendCount = 1;
-  int32_t retVal = 0;
+  uint8_t send_count = 1;
+  bool result = true;
 
   if (ended) {
     // resend last packet in an event 3 times
-    sendCount = 3;
+    send_count = 3;
   }
   do {
     // Send DTMF data
     int32_t header_length = rtp_sender_->BuildRtpHeader(
         dtmfbuffer, dtmf_payload_type, marker_bit, dtmf_timestamp,
         clock_->TimeInMilliseconds());
     if (header_length <= 0)
-      return -1;
+      return false;
 
     // reset CSRC and X bit
     dtmfbuffer[0] &= 0xe0;
 
     // Create DTMF data
     /*    From RFC 2833:
 
      0                   1                   2                   3
      0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
     |     event     |E|R| volume    |          duration             |
     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
     */
     // R bit always cleared
     uint8_t R = 0x00;
     uint8_t volume = dtmf_level_;
 
     // First packet un-ended
     uint8_t E = ended ? 0x80 : 0x00;
 
     // First byte is Event number, equals key number
     dtmfbuffer[12] = dtmf_key_;
     dtmfbuffer[13] = E | R | volume;
     ByteWriter<uint16_t>::WriteBigEndian(dtmfbuffer + 14, duration);
 
     TRACE_EVENT_INSTANT2(
         TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "Audio::SendTelephoneEvent",
         "timestamp", dtmf_timestamp, "seqnum", rtp_sender_->SequenceNumber());
-    retVal = rtp_sender_->SendToNetwork(dtmfbuffer, 4, 12, rtc::TimeMillis(),
+    result = rtp_sender_->SendToNetwork(dtmfbuffer, 4, 12, rtc::TimeMillis(),
                                         kAllowRetransmission,
                                         RtpPacketSender::kHighPriority);
-    sendCount--;
-  } while (sendCount > 0 && retVal == 0);
+    send_count--;
+  } while (send_count > 0 && result);
 
-  return retVal;
+  return result;
 }
 }  // namespace webrtc