Revert of Add content type information to encoded images and corresponding rtp extension header

webrtc/modules/video_capture/video_capture_impl.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 14 matching lines @@
 namespace webrtc {
 namespace videocapturemodule {
 rtc::scoped_refptr<VideoCaptureModule> VideoCaptureImpl::Create(
     VideoCaptureExternal*& externalCapture) {
   rtc::scoped_refptr<VideoCaptureImpl> implementation(
       new rtc::RefCountedObject<VideoCaptureImpl>());
   externalCapture = implementation.get();
   return implementation;
 }
 
-const char* VideoCaptureImpl::CurrentDeviceName() const {
-  return _deviceUniqueId;
+const char* VideoCaptureImpl::CurrentDeviceName() const
+{
+    return _deviceUniqueId;
 }
 
 // static
 int32_t VideoCaptureImpl::RotationFromDegrees(int degrees,
                                               VideoRotation* rotation) {
   switch (degrees) {
     case 0:
       *rotation = kVideoRotation_0;
       return 0;
     case 90:
@@ skipping 81 matching lines @@
 {
     rtc::CritScope cs(&_apiCs);
 
     const int32_t width = frameInfo.width;
     const int32_t height = frameInfo.height;
 
     TRACE_EVENT1("webrtc", "VC::IncomingFrame", "capture_time", captureTime);
 
     // Not encoded, convert to I420.
     const VideoType commonVideoType =
-        RawVideoTypeToCommonVideoVideoType(frameInfo.rawType);
+              RawVideoTypeToCommonVideoVideoType(frameInfo.rawType);
 
     if (frameInfo.rawType != kVideoMJPEG &&
-        CalcBufferSize(commonVideoType, width, abs(height)) !=
-            videoFrameLength) {
-      LOG(LS_ERROR) << "Wrong incoming frame length.";
-      return -1;
+        CalcBufferSize(commonVideoType, width,
+                       abs(height)) != videoFrameLength)
+    {
+        LOG(LS_ERROR) << "Wrong incoming frame length.";
+        return -1;
     }
 
     int stride_y = width;
     int stride_uv = (width + 1) / 2;
     int target_width = width;
     int target_height = height;
 
     // SetApplyRotation doesn't take any lock. Make a local copy here.
     bool apply_rotation = apply_rotation_;
 
@@ skipping 10 matching lines @@
     // In Windows, the image starts bottom left, instead of top left.
     // Setting a negative source height, inverts the image (within LibYuv).
 
     // TODO(nisse): Use a pool?
     rtc::scoped_refptr<I420Buffer> buffer = I420Buffer::Create(
         target_width, abs(target_height), stride_y, stride_uv, stride_uv);
     const int conversionResult = ConvertToI420(
         commonVideoType, videoFrame, 0, 0,  // No cropping
         width, height, videoFrameLength,
         apply_rotation ? _rotateFrame : kVideoRotation_0, buffer.get());
-    if (conversionResult < 0) {
+    if (conversionResult < 0)
+    {
       LOG(LS_ERROR) << "Failed to convert capture frame from type "
                     << frameInfo.rawType << "to I420.";
-      return -1;
+        return -1;
     }
 
-    VideoFrame captureFrame(buffer, 0, rtc::TimeMillis(),
-                            !apply_rotation ? _rotateFrame : kVideoRotation_0);
+    VideoFrame captureFrame(
+        buffer, 0, rtc::TimeMillis(),
+        !apply_rotation ? _rotateFrame : kVideoRotation_0);
     captureFrame.set_ntp_time_ms(captureTime);
 
     DeliverCapturedFrame(captureFrame);
 
     return 0;
 }
 
 int32_t VideoCaptureImpl::SetCaptureRotation(VideoRotation rotation) {
   rtc::CritScope cs(&_apiCs);
   _rotateFrame = rotation;
   return 0;
 }
 
 bool VideoCaptureImpl::SetApplyRotation(bool enable) {
   // We can't take any lock here as it'll cause deadlock with IncomingFrame.
 
   // The effect of this is the last caller wins.
   apply_rotation_ = enable;
   return true;
 }
 
-void VideoCaptureImpl::UpdateFrameCount() {
-  if (_incomingFrameTimesNanos[0] / rtc::kNumNanosecsPerMicrosec == 0) {
-    // first no shift
-  } else {
-    // shift
-    for (int i = (kFrameRateCountHistorySize - 2); i >= 0; --i) {
-      _incomingFrameTimesNanos[i + 1] = _incomingFrameTimesNanos[i];
+void VideoCaptureImpl::UpdateFrameCount()
+{
+  if (_incomingFrameTimesNanos[0] / rtc::kNumNanosecsPerMicrosec == 0)
+    {
+        // first no shift
     }
-  }
-  _incomingFrameTimesNanos[0] = rtc::TimeNanos();
+    else
+    {
+        // shift
+        for (int i = (kFrameRateCountHistorySize - 2); i >= 0; i--)
+        {
+            _incomingFrameTimesNanos[i + 1] = _incomingFrameTimesNanos[i];
+        }
+    }
+    _incomingFrameTimesNanos[0] = rtc::TimeNanos();
 }
 
-uint32_t VideoCaptureImpl::CalculateFrameRate(int64_t now_ns) {
-  int32_t num = 0;
-  int32_t nrOfFrames = 0;
-  for (num = 1; num < (kFrameRateCountHistorySize - 1); ++num) {
-    if (_incomingFrameTimesNanos[num] <= 0 ||
-        (now_ns - _incomingFrameTimesNanos[num]) /
-                rtc::kNumNanosecsPerMillisec >
-            kFrameRateHistoryWindowMs) {  // don't use data older than 2sec
-      break;
-    } else {
-      nrOfFrames++;
+uint32_t VideoCaptureImpl::CalculateFrameRate(int64_t now_ns)
+{
+    int32_t num = 0;
+    int32_t nrOfFrames = 0;
+    for (num = 1; num < (kFrameRateCountHistorySize - 1); num++)
+    {
+        if (_incomingFrameTimesNanos[num] <= 0 ||
+            (now_ns - _incomingFrameTimesNanos[num]) /
+            rtc::kNumNanosecsPerMillisec >
+                kFrameRateHistoryWindowMs) // don't use data older than 2sec
+        {
+            break;
+        }
+        else
+        {
+            nrOfFrames++;
+        }
     }
-  }
-  if (num > 1) {
-    int64_t diff = (now_ns - _incomingFrameTimesNanos[num - 1]) /
-                   rtc::kNumNanosecsPerMillisec;
-    if (diff > 0) {
-      return uint32_t((nrOfFrames * 1000.0f / diff) + 0.5f);
+    if (num > 1)
+    {
+        int64_t diff = (now_ns - _incomingFrameTimesNanos[num - 1]) /
+                       rtc::kNumNanosecsPerMillisec;
+        if (diff > 0)
+        {
+            return uint32_t((nrOfFrames * 1000.0f / diff) + 0.5f);
+        }
     }
-  }
 
-  return nrOfFrames;
+    return nrOfFrames;
 }
 }  // namespace videocapturemodule
 }  // namespace webrtc