Sort method declarations/definitions in VideoReceiveStream.

webrtc/video/video_receive_stream.cc

 /*
  *  Copyright (c) 2013 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 267 matching lines @@
                                     size_t length,
                                     const PacketTime& packet_time) {
   return rtp_stream_receiver_.DeliverRtp(packet, length, packet_time);
 }
 
 bool VideoReceiveStream::OnRecoveredPacket(const uint8_t* packet,
                                            size_t length) {
   return rtp_stream_receiver_.OnRecoveredPacket(packet, length);
 }
 
+void VideoReceiveStream::SetSyncChannel(VoiceEngine* voice_engine,
+                                        int audio_channel_id) {
+  if (voice_engine && audio_channel_id != -1) {
+    VoEVideoSync* voe_sync_interface = VoEVideoSync::GetInterface(voice_engine);
+    rtp_stream_sync_.ConfigureSync(audio_channel_id, voe_sync_interface);
+    voe_sync_interface->Release();
+  } else {
+    rtp_stream_sync_.ConfigureSync(-1, nullptr);
+  }
+}
+
 void VideoReceiveStream::Start() {
   if (decode_thread_.IsRunning())
     return;
   if (jitter_buffer_experiment_) {
     frame_buffer_->Start();
     call_stats_->RegisterStatsObserver(&rtp_stream_receiver_);
 
     if (rtp_stream_receiver_.IsRetransmissionsEnabled() &&
         rtp_stream_receiver_.IsUlpfecEnabled()) {
       frame_buffer_->SetProtectionMode(kProtectionNackFEC);
@@ skipping 57 matching lines @@
     for (const Decoder& decoder : config_.decoders)
       video_receiver_.RegisterExternalDecoder(nullptr, decoder.payload_type);
   }
 
   call_stats_->DeregisterStatsObserver(video_stream_decoder_.get());
   video_stream_decoder_.reset();
   incoming_video_stream_.reset();
   transport_adapter_.Disable();
 }
 
-void VideoReceiveStream::SetSyncChannel(VoiceEngine* voice_engine,
-                                        int audio_channel_id) {
-  if (voice_engine && audio_channel_id != -1) {
-    VoEVideoSync* voe_sync_interface = VoEVideoSync::GetInterface(voice_engine);
-    rtp_stream_sync_.ConfigureSync(audio_channel_id, voe_sync_interface);
-    voe_sync_interface->Release();
-  } else {
-    rtp_stream_sync_.ConfigureSync(-1, nullptr);
-  }
-}
-
 VideoReceiveStream::Stats VideoReceiveStream::GetStats() const {
   return stats_proxy_.GetStats();
 }
 
+void VideoReceiveStream::EnableEncodedFrameRecording(rtc::PlatformFile file,
+                                                     size_t byte_limit) {
+  {
+    rtc::CritScope lock(&ivf_writer_lock_);
+    if (file == rtc::kInvalidPlatformFileValue) {
+      ivf_writer_.reset();
+    } else {
+      ivf_writer_ = IvfFileWriter::Wrap(rtc::File(file), byte_limit);
+    }
+  }
+
+  if (file != rtc::kInvalidPlatformFileValue) {
+    // Make a keyframe appear as early as possible in the logs, to give actually
+    // decodable output.
+    RequestKeyFrame();
+  }
+}
+
 // TODO(tommi): This method grabs a lock 6 times.
 void VideoReceiveStream::OnFrame(const VideoFrame& video_frame) {
   // TODO(tommi): OnDecodedFrame grabs a lock, incidentally the same lock
   // that OnSyncOffsetUpdated() and OnRenderedFrame() below grab.
   stats_proxy_.OnDecodedFrame();
 
   int64_t sync_offset_ms;
   double estimated_freq_khz;
   // TODO(tommi): GetStreamSyncOffsetInMs grabs three locks.  One inside the
   // function itself, another in GetChannel() and a third in
   // GetPlayoutTimestamp.  Seems excessive.  Anyhow, I'm assuming the function
   // succeeds most of the time, which leads to grabbing a fourth lock.
   if (rtp_stream_sync_.GetStreamSyncOffsetInMs(video_frame, &sync_offset_ms,
                                                &estimated_freq_khz)) {
     // TODO(tommi): OnSyncOffsetUpdated grabs a lock.
     stats_proxy_.OnSyncOffsetUpdated(sync_offset_ms, estimated_freq_khz);
   }
 
   // config_.renderer must never be null if we're getting this callback.
   config_.renderer->OnFrame(video_frame);
 
   // TODO(tommi): OnRenderFrame grabs a lock too.
   stats_proxy_.OnRenderedFrame(video_frame);
 }
 
-void VideoReceiveStream::OnCompleteFrame(
-    std::unique_ptr<video_coding::FrameObject> frame) {
-  int last_continuous_pid = frame_buffer_->InsertFrame(std::move(frame));
-  if (last_continuous_pid != -1)
-    rtp_stream_receiver_.FrameContinuous(last_continuous_pid);
-}
-
 // TODO(asapersson): Consider moving callback from video_encoder.h or
 // creating a different callback.
 EncodedImageCallback::Result VideoReceiveStream::OnEncodedImage(
     const EncodedImage& encoded_image,
     const CodecSpecificInfo* codec_specific_info,
     const RTPFragmentationHeader* fragmentation) {
   stats_proxy_.OnPreDecode(encoded_image, codec_specific_info);
   if (config_.pre_decode_callback) {
     config_.pre_decode_callback->EncodedFrameCallback(
         EncodedFrame(encoded_image._buffer, encoded_image._length,
                      encoded_image._frameType));
   }
   {
     rtc::CritScope lock(&ivf_writer_lock_);
     if (ivf_writer_.get()) {
       RTC_DCHECK(codec_specific_info);
       bool ok = ivf_writer_->WriteFrame(encoded_image,
                                         codec_specific_info->codecType);
       RTC_DCHECK(ok);
     }
   }
 
   return Result(Result::OK, encoded_image._timeStamp);
 }
 
+void VideoReceiveStream::SendNack(
+    const std::vector<uint16_t>& sequence_numbers) {
+  rtp_stream_receiver_.RequestPacketRetransmit(sequence_numbers);
+}
+
+void VideoReceiveStream::RequestKeyFrame() {
+  rtp_stream_receiver_.RequestKeyFrame();
+}
+
+void VideoReceiveStream::OnCompleteFrame(
+    std::unique_ptr<video_coding::FrameObject> frame) {
+  int last_continuous_pid = frame_buffer_->InsertFrame(std::move(frame));
+  if (last_continuous_pid != -1)
+    rtp_stream_receiver_.FrameContinuous(last_continuous_pid);
+}
+
 bool VideoReceiveStream::DecodeThreadFunction(void* ptr) {
   static_cast<VideoReceiveStream*>(ptr)->Decode();
   return true;
 }
 
 void VideoReceiveStream::Decode() {
   static const int kMaxDecodeWaitTimeMs = 50;
   if (jitter_buffer_experiment_) {
     static const int kMaxWaitForFrameMs = 3000;
     std::unique_ptr<video_coding::FrameObject> frame;
     video_coding::FrameBuffer::ReturnReason res =
         frame_buffer_->NextFrame(kMaxWaitForFrameMs, &frame);
 
     if (res == video_coding::FrameBuffer::ReturnReason::kStopped)
       return;
 
     if (frame) {
       if (video_receiver_.Decode(frame.get()) == VCM_OK)
         rtp_stream_receiver_.FrameDecoded(frame->picture_id);
     } else {
       LOG(LS_WARNING) << "No decodable frame in " << kMaxWaitForFrameMs
                       << " ms, requesting keyframe.";
       RequestKeyFrame();
     }
   } else {
     video_receiver_.Decode(kMaxDecodeWaitTimeMs);
   }
 }
 
-void VideoReceiveStream::SendNack(
-    const std::vector<uint16_t>& sequence_numbers) {
-  rtp_stream_receiver_.RequestPacketRetransmit(sequence_numbers);
-}
-
-void VideoReceiveStream::EnableEncodedFrameRecording(rtc::PlatformFile file,
-                                                     size_t byte_limit) {
-  {
-    rtc::CritScope lock(&ivf_writer_lock_);
-    if (file == rtc::kInvalidPlatformFileValue) {
-      ivf_writer_.reset();
-    } else {
-      ivf_writer_ = IvfFileWriter::Wrap(rtc::File(file), byte_limit);
-    }
-  }
-
-  if (file != rtc::kInvalidPlatformFileValue) {
-    // Make a keyframe appear as early as possible in the logs, to give actually
-    // decodable output.
-    RequestKeyFrame();
-  }
-}
-
-void VideoReceiveStream::RequestKeyFrame() {
-  rtp_stream_receiver_.RequestKeyFrame();
-}
-
 }  // namespace internal
 }  // namespace webrtc