Add rotation to EncodedImage and make sure it is passed through encoders.

webrtc/api/java/jni/androidmediaencoder_jni.cc

 /*
  *  Copyright 2015 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.
  */
 
 // NOTICE: androidmediaencoder_jni.h must be included before
 // androidmediacodeccommon.h to avoid build errors.
 #include "webrtc/api/java/jni/androidmediaencoder_jni.h"
 
+#include <algorithm>

[pbos-webrtc, 2016/04/14 14:29:57]

Not needed, right?

[perkj_webrtc, 2016/04/15 12:37:39]

git cl lint say its needed.

+#include <list>
+
 #include "third_party/libyuv/include/libyuv/convert.h"
 #include "third_party/libyuv/include/libyuv/convert_from.h"
 #include "third_party/libyuv/include/libyuv/video_common.h"
 #include "webrtc/api/java/jni/androidmediacodeccommon.h"
 #include "webrtc/api/java/jni/classreferenceholder.h"
 #include "webrtc/api/java/jni/native_handle_impl.h"
 #include "webrtc/base/bind.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/thread.h"
@@ skipping 189 matching lines @@
   uint16_t picture_id_;
   enum libyuv::FourCC encoder_fourcc_;  // Encoder color space format.
   int last_set_bitrate_kbps_;  // Last-requested bitrate in kbps.
   int last_set_fps_;  // Last-requested frame rate.
   int64_t current_timestamp_us_;  // Current frame timestamps in us.
   int frames_received_;  // Number of frames received by encoder.
   int frames_encoded_;  // Number of frames encoded by encoder.
   int frames_dropped_media_encoder_;  // Number of frames dropped by encoder.
   // Number of dropped frames caused by full queue.
   int consecutive_full_queue_frame_drops_;
   int frames_in_queue_;  // Number of frames in encoder queue.

[magjed_webrtc, 2016/04/15 09:43:30]

This looks identical to input_frame_infos_.size(). Can you remove this variable?

[perkj_webrtc, 2016/04/15 12:37:39]

Done.

   int64_t stat_start_time_ms_;  // Start time for statistics.
   int current_frames_;  // Number of frames in the current statistics interval.
   int current_bytes_;  // Encoded bytes in the current statistics interval.
   int current_acc_qp_; // Accumulated QP in the current statistics interval.
   int current_encoding_time_ms_;  // Overall encoding time in the current second
   int64_t last_input_timestamp_ms_;  // Timestamp of last received yuv frame.
   int64_t last_output_timestamp_ms_;  // Timestamp of last encoded frame.
-  std::vector<int32_t> timestamps_;  // Video frames timestamp queue.
-  std::vector<int64_t> render_times_ms_;  // Video frames render time queue.
+
+  struct InputFrameInfo {
+    InputFrameInfo(int32_t timestamp,
+                   int64_t render_time_ms,
+                   webrtc::VideoRotation rotation)
+        : timestamp(timestamp),
+          render_time_ms(render_time_ms),
+          rotation(rotation) {}
+    const int32_t timestamp;
+    const int64_t render_time_ms;
+    const webrtc::VideoRotation rotation;
+  };
+  std::list<InputFrameInfo> input_frame_infos_;
   std::vector<int64_t> frame_rtc_times_ms_;  // Time when video frame is sent to

[magjed_webrtc, 2016/04/15 09:43:30]

Can you add a rtc_time member in InputFrameInfo and merge frame_rtc_times_ms_
with input_frame_infos_?

[perkj_webrtc, 2016/04/15 12:37:39]

Done.

                                              // encoder input.
-  int32_t output_timestamp_;  // Last output frame timestamp from timestamps_ Q.
+  int32_t output_timestamp_;                 // Last output frame timestamp from

[magjed_webrtc, 2016/04/15 09:43:30]

Can you replace |output_timestamp_|, |output_render_time_ms|, and
|output_render_time_ms_| with 'InputFrameInfo last_output_| instead? Down in
DeliverPendingOutputs(), you can write:
last_output_ = input_frame_infos_.front();
input_frame_infos_.pop_front();

[perkj_webrtc, 2016/04/15 12:37:39]

I could but that would mean a slight beaviour difference that I am not sure I am
comfortable with. ie- two callbacks for the same input frame. Separate cl? 

+                                             // |input_frame_infos_|.
   int64_t output_render_time_ms_; // Last output frame render time from
-                                  // render_times_ms_ queue.
+                                  // |input_frame_infos_|.
+  webrtc::VideoRotation output_rotation_;  // Last output frame rotation from
+                                           // |input_frame_infos_|.
   // Frame size in bytes fed to MediaCodec.
   int yuv_size_;
   // True only when between a callback_->Encoded() call return a positive value
   // and the next Encode() call being ignored.
   bool drop_next_input_frame_;
   // Global references; must be deleted in Release().
   std::vector<jobject> input_buffers_;
   QualityScaler quality_scaler_;
   // Dynamic resolution change, off by default.
   bool scale_;
@@ skipping 267 matching lines @@
   current_timestamp_us_ = 0;
   stat_start_time_ms_ = GetCurrentTimeMs();
   current_frames_ = 0;
   current_bytes_ = 0;
   current_acc_qp_ = 0;
   current_encoding_time_ms_ = 0;
   last_input_timestamp_ms_ = -1;
   last_output_timestamp_ms_ = -1;
   output_timestamp_ = 0;
   output_render_time_ms_ = 0;
-  timestamps_.clear();
-  render_times_ms_.clear();
+  input_frame_infos_.clear();
   frame_rtc_times_ms_.clear();
   drop_next_input_frame_ = false;
   use_surface_ = use_surface;
   picture_id_ = static_cast<uint16_t>(rand()) & 0x7FFF;
   gof_.SetGofInfoVP9(webrtc::TemporalStructureMode::kTemporalStructureMode1);
   tl0_pic_idx_ = static_cast<uint8_t>(rand());
   gof_idx_ = 0;
   last_frame_received_ms_ = -1;
   frames_received_since_last_key_ = kMinKeyFrameInterval;
 
@@ skipping 190 matching lines @@
     ALOGE << "Failed encode frame with timestamp: " << input_frame.timestamp();
     ResetCodecOnCodecThread();
     return WEBRTC_VIDEO_CODEC_ERROR;
   }
 
   last_input_timestamp_ms_ =
       current_timestamp_us_ / rtc::kNumMicrosecsPerMillisec;
   frames_in_queue_++;
 
   // Save input image timestamps for later output
-  timestamps_.push_back(input_frame.timestamp());
-  render_times_ms_.push_back(input_frame.render_time_ms());
+

[magjed_webrtc, 2016/04/15 09:43:30]

nit: remove empty line

[perkj_webrtc, 2016/04/15 12:37:39]

Done.

+  input_frame_infos_.push_back(InputFrameInfo(input_frame.timestamp(),

[magjed_webrtc, 2016/04/15 09:43:30]

emplace_back is allowed now according to http://chromium-cpp.appspot.com/, so I
think you should use that instead of push_back here.

[perkj_webrtc, 2016/04/15 12:37:39]

Done.

+                                              input_frame.render_time_ms(),
+                                              input_frame.rotation()));
   current_timestamp_us_ += rtc::kNumMicrosecsPerSec / last_set_fps_;
 
   if (!DeliverPendingOutputs(jni)) {
     ALOGE << "Failed deliver pending outputs.";
     ResetCodecOnCodecThread();
     return WEBRTC_VIDEO_CODEC_ERROR;
   }
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
@@ skipping 185 matching lines @@
     // Get key and config frame flags.
     jobject j_output_buffer =
         GetOutputBufferInfoBuffer(jni, j_output_buffer_info);
     bool key_frame = GetOutputBufferInfoIsKeyFrame(jni, j_output_buffer_info);
 
     // Get frame timestamps from a queue - for non config frames only.
     int64_t frame_encoding_time_ms = 0;
     last_output_timestamp_ms_ =
         GetOutputBufferInfoPresentationTimestampUs(jni, j_output_buffer_info) /
         1000;
     if (frames_in_queue_ > 0) {

[magjed_webrtc, 2016/04/15 09:43:30]

Can you CHECK_GT(frames_in_queue_, 0) here? It looks it should never happen that
we have no metadata for a frame.

[perkj_webrtc, 2016/04/15 12:37:39]

as discussed- I don't want to in this cl. The comment above make me think that
this might be something that may happen with H264 for the first frame when
configuration parameters are created. But this all look a bit weird.

-      output_timestamp_ = timestamps_.front();
-      timestamps_.erase(timestamps_.begin());
-      output_render_time_ms_ = render_times_ms_.front();
-      render_times_ms_.erase(render_times_ms_.begin());
+      const InputFrameInfo& frame_info = input_frame_infos_.front();
+      output_timestamp_ = frame_info.timestamp;
+      output_render_time_ms_ = frame_info.render_time_ms;
+      output_rotation_ = frame_info.rotation;
+      input_frame_infos_.pop_front();
       frame_encoding_time_ms = GetCurrentTimeMs() - frame_rtc_times_ms_.front();
       frame_rtc_times_ms_.erase(frame_rtc_times_ms_.begin());
       frames_in_queue_--;
     }
 
     // Extract payload.
     size_t payload_size = jni->GetDirectBufferCapacity(j_output_buffer);
     uint8_t* payload = reinterpret_cast<uint8_t*>(
         jni->GetDirectBufferAddress(j_output_buffer));
     CHECK_EXCEPTION(jni);
@@ skipping 11 matching lines @@
 
     // Callback - return encoded frame.
     int32_t callback_status = 0;
     if (callback_) {
       scoped_ptr<webrtc::EncodedImage> image(
           new webrtc::EncodedImage(payload, payload_size, payload_size));
       image->_encodedWidth = width_;
       image->_encodedHeight = height_;
       image->_timeStamp = output_timestamp_;
       image->capture_time_ms_ = output_render_time_ms_;
+      image->rotation_ = output_rotation_;
       image->_frameType =
           (key_frame ? webrtc::kVideoFrameKey : webrtc::kVideoFrameDelta);
       image->_completeFrame = true;
       image->adapt_reason_.quality_resolution_downscales =
           scale_ ? quality_scaler_.downscale_shift() : -1;
 
       webrtc::CodecSpecificInfo info;
       memset(&info, 0, sizeof(info));
       info.codecType = codecType_;
       if (codecType_ == kVideoCodecVP8) {
@@ skipping 269 matching lines @@
 }
 
 void MediaCodecVideoEncoderFactory::DestroyVideoEncoder(
     webrtc::VideoEncoder* encoder) {
   ALOGD << "Destroy video encoder.";
   delete encoder;
 }
 
 }  // namespace webrtc_jni