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

webrtc/test/fake_encoder.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 43 matching lines @@
                             const CodecSpecificInfo* codec_specific_info,
                             const std::vector<FrameType>* frame_types) {
   unsigned char max_framerate;
   unsigned char num_simulcast_streams;
   SimulcastStream simulcast_streams[kMaxSimulcastStreams];
   EncodedImageCallback* callback;
   uint32_t target_bitrate_sum_kbps;
   int max_target_bitrate_kbps;
   int64_t last_encode_time_ms;
   size_t num_encoded_bytes;
+  VideoCodecMode mode;
   {
     rtc::CritScope cs(&crit_sect_);
     max_framerate = config_.maxFramerate;
     num_simulcast_streams = config_.numberOfSimulcastStreams;
     for (int i = 0; i < num_simulcast_streams; ++i) {
       simulcast_streams[i] = config_.simulcastStream[i];
     }
     callback = callback_;
     target_bitrate_sum_kbps = target_bitrate_.get_sum_kbps();
     max_target_bitrate_kbps = max_target_bitrate_kbps_;
     last_encode_time_ms = last_encode_time_ms_;
     num_encoded_bytes = sizeof(encoded_buffer_);
+    mode = config_.mode;
   }
 
   int64_t time_now_ms = clock_->TimeInMilliseconds();
   const bool first_encode = (last_encode_time_ms == 0);
   RTC_DCHECK_GT(max_framerate, 0);
   int64_t time_since_last_encode_ms = 1000 / max_framerate;
   if (!first_encode) {
     // For all frames but the first we can estimate the display time by looking
     // at the display time of the previous frame.
     time_since_last_encode_ms = time_now_ms - last_encode_time_ms;
@@ skipping 49 matching lines @@
 
     std::unique_ptr<uint8_t[]> encoded_buffer(new uint8_t[num_encoded_bytes]);
     memcpy(encoded_buffer.get(), encoded_buffer_, num_encoded_bytes);
     EncodedImage encoded(encoded_buffer.get(), stream_bytes, num_encoded_bytes);
     encoded._timeStamp = input_image.timestamp();
     encoded.capture_time_ms_ = input_image.render_time_ms();
     encoded._frameType = (*frame_types)[i];
     encoded._encodedWidth = simulcast_streams[i].width;
     encoded._encodedHeight = simulcast_streams[i].height;
     encoded.rotation_ = input_image.rotation();
+    encoded.content_type_ = (mode == kScreensharing)
+                                ? VideoContentType::SCREENSHARE
+                                : VideoContentType::UNSPECIFIED;
     specifics.codec_name = ImplementationName();
     RTC_DCHECK(callback);
     if (callback->OnEncodedImage(encoded, &specifics, nullptr).error !=
         EncodedImageCallback::Result::OK) {
       return -1;
     }
     bits_available -= std::min(encoded._length * 8, bits_available);
   }
   return 0;
 }
@@ skipping 195 matching lines @@
   RTC_DCHECK_CALLED_SEQUENTIALLY(&sequence_checker_);
 
   queue1_.reset();
   queue2_.reset();
 
   return FakeH264Encoder::Release();
 }
 
 }  // namespace test
 }  // namespace webrtc