RELAND: [Cast] Software encoder support for varying video frame sizes.

media/cast/test/fake_media_source.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "media/cast/test/fake_media_source.h"
 
 #include "base/files/memory_mapped_file.h"
 #include "base/files/scoped_file.h"
 #include "base/logging.h"
+#include "base/rand_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "media/audio/audio_parameters.h"
 #include "media/base/audio_buffer.h"
 #include "media/base/audio_bus.h"
 #include "media/base/audio_fifo.h"
 #include "media/base/audio_timestamp_helper.h"
 #include "media/base/media.h"
 #include "media/base/multi_channel_resampler.h"
 #include "media/base/video_frame.h"
 #include "media/base/video_util.h"
 #include "media/cast/cast_sender.h"
 #include "media/cast/test/utility/audio_utility.h"
 #include "media/cast/test/utility/video_utility.h"
 #include "media/ffmpeg/ffmpeg_common.h"
 #include "media/ffmpeg/ffmpeg_deleters.h"
 #include "media/filters/audio_renderer_algorithm.h"
 #include "media/filters/ffmpeg_demuxer.h"
 #include "media/filters/ffmpeg_glue.h"
 #include "media/filters/in_memory_url_protocol.h"
 #include "ui/gfx/geometry/size.h"
 
 namespace {
 
 static const int kAudioChannels = 2;
 static const int kAudioSamplingFrequency = 48000;
-static const int kSoundFrequency = 1234;  // Frequency of sinusoid wave.
-static const float kSoundVolume = 0.5f;
+static const int kSoundFrequency = 440;  // Frequency of sinusoid wave.
+static const float kSoundVolume = 0.10f;
 static const int kAudioFrameMs = 10;  // Each audio frame is exactly 10ms.
 static const int kAudioPacketsPerSecond = 1000 / kAudioFrameMs;
 
+// Bounds for variable frame size mode.
+static const int kMinFakeFrameWidth = 60;
+static const int kMinFakeFrameHeight = 34;
+static const int kStartingFakeFrameWidth = 854;
+static const int kStartingFakeFrameHeight = 480;
+static const int kMaxFakeFrameWidth = 1280;
+static const int kMaxFakeFrameHeight = 720;
+static const int kMaxFrameSizeChangeMillis = 5000;
+
 void AVFreeFrame(AVFrame* frame) {
   av_frame_free(&frame);
 }
 
 base::TimeDelta PtsToTimeDelta(int64 pts, const AVRational& time_base) {
   return pts * base::TimeDelta::FromSeconds(1) * time_base.num / time_base.den;
 }
 
 int64 TimeDeltaToPts(base::TimeDelta delta, const AVRational& time_base) {
   return static_cast<int64>(
       delta.InSecondsF() * time_base.den / time_base.num +
       0.5 /* rounding */);
 }
 
 }  // namespace
 
 namespace media {
 namespace cast {
 
 FakeMediaSource::FakeMediaSource(
     scoped_refptr<base::SingleThreadTaskRunner> task_runner,
     base::TickClock* clock,
     const VideoSenderConfig& video_config,
     bool keep_frames)
     : task_runner_(task_runner),
       video_config_(video_config),
-     keep_frames_(keep_frames),
+      keep_frames_(keep_frames),
+      variable_frame_size_mode_(false),
       synthetic_count_(0),
       clock_(clock),
       audio_frame_count_(0),
       video_frame_count_(0),
       av_format_context_(NULL),
       audio_stream_index_(-1),
       playback_rate_(1.0),
       video_stream_index_(-1),
       video_frame_rate_numerator_(video_config.max_frame_rate),
       video_frame_rate_denominator_(1),
@@ skipping 105 matching lines @@
       }
       LOG(INFO) << "Source file has video.";
     } else {
       LOG(ERROR) << "Unknown stream type; ignore.";
     }
   }
 
   Rewind();
 }
 
+void FakeMediaSource::SetVariableFrameSizeMode(bool enabled) {
+  variable_frame_size_mode_ = enabled;
+}
+
 void FakeMediaSource::Start(scoped_refptr<AudioFrameInput> audio_frame_input,
                             scoped_refptr<VideoFrameInput> video_frame_input) {
   audio_frame_input_ = audio_frame_input;
   video_frame_input_ = video_frame_input;
 
   LOG(INFO) << "Max Frame rate: " << video_config_.max_frame_rate;
   LOG(INFO) << "Source Frame rate: "
             << video_frame_rate_numerator_ << "/"
             << video_frame_rate_denominator_ << " fps.";
   LOG(INFO) << "Audio playback rate: " << playback_rate_;
 
   if (start_time_.is_null())
     start_time_ = clock_->NowTicks();
 
   if (!is_transcoding_audio() && !is_transcoding_video()) {
     // Send fake patterns.
     task_runner_->PostTask(
         FROM_HERE,
-        base::Bind(
-            &FakeMediaSource::SendNextFakeFrame,
-            base::Unretained(this)));
+        base::Bind(&FakeMediaSource::SendNextFakeFrame,
+                   weak_factory_.GetWeakPtr()));
     return;
   }
 
   // Send transcoding streams.
   audio_algo_.Initialize(audio_params_);
   audio_algo_.FlushBuffers();
   audio_fifo_input_bus_ =
       AudioBus::Create(
           audio_params_.channels(), audio_params_.frames_per_buffer());
   // Audio FIFO can carry all data fron AudioRendererAlgorithm.
   audio_fifo_.reset(
       new AudioFifo(audio_params_.channels(),
                     audio_algo_.QueueCapacity()));
   audio_resampler_.reset(new media::MultiChannelResampler(
       audio_params_.channels(),
       static_cast<double>(audio_params_.sample_rate()) /
       kAudioSamplingFrequency,
       audio_params_.frames_per_buffer(),
-      base::Bind(&FakeMediaSource::ProvideData, base::Unretained(this))));
+      base::Bind(&FakeMediaSource::ProvideData, weak_factory_.GetWeakPtr())));
   task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(
-          &FakeMediaSource::SendNextFrame,
-          base::Unretained(this)));
+      base::Bind(&FakeMediaSource::SendNextFrame, weak_factory_.GetWeakPtr()));
 }
 
 void FakeMediaSource::SendNextFakeFrame() {
-  gfx::Size size(video_config_.width, video_config_.height);
+  UpdateNextFrameSize();
   scoped_refptr<VideoFrame> video_frame =
-      VideoFrame::CreateBlackFrame(size);
+      VideoFrame::CreateBlackFrame(current_frame_size_);
   PopulateVideoFrame(video_frame.get(), synthetic_count_);
   ++synthetic_count_;
 
   const base::TimeTicks now = clock_->NowTicks();
 
   base::TimeDelta video_time = VideoFrameTime(++video_frame_count_);
   video_frame->set_timestamp(video_time);
   if (keep_frames_)
     inserted_video_frame_queue_.push(video_frame);
   video_frame_input_->InsertRawVideoFrame(video_frame,
@@ skipping 28 matching lines @@
     video_time = VideoFrameTime(++video_frame_count_);
   }
 
   task_runner_->PostDelayedTask(
       FROM_HERE,
       base::Bind(&FakeMediaSource::SendNextFakeFrame,
                  weak_factory_.GetWeakPtr()),
       video_time - elapsed_time);
 }
 
+void FakeMediaSource::UpdateNextFrameSize() {
+  if (variable_frame_size_mode_) {
+    bool update_size_change_time = false;
+    if (current_frame_size_.IsEmpty()) {
+      current_frame_size_ = gfx::Size(kStartingFakeFrameWidth,
+                                      kStartingFakeFrameHeight);
+      update_size_change_time = true;
+    } else if (clock_->NowTicks() >= next_frame_size_change_time_) {
+      current_frame_size_ = gfx::Size(
+          base::RandInt(kMinFakeFrameWidth, kMaxFakeFrameWidth),
+          base::RandInt(kMinFakeFrameHeight, kMaxFakeFrameHeight));
+      update_size_change_time = true;
+    }
+
+    if (update_size_change_time) {
+      next_frame_size_change_time_ = clock_->NowTicks() +
+          base::TimeDelta::FromMillisecondsD(
+              base::RandDouble() * kMaxFrameSizeChangeMillis);
+    }
+  } else {
+    current_frame_size_ = gfx::Size(kStartingFakeFrameWidth,
+                                    kStartingFakeFrameHeight);
+    next_frame_size_change_time_ = base::TimeTicks();
+  }
+}
+
 bool FakeMediaSource::SendNextTranscodedVideo(base::TimeDelta elapsed_time) {
   if (!is_transcoding_video())
     return false;
 
   Decode(false);
   if (video_frame_queue_.empty())
     return false;
 
-  scoped_refptr<VideoFrame> decoded_frame =
-      video_frame_queue_.front();
-  if (elapsed_time < decoded_frame->timestamp())
+  const scoped_refptr<VideoFrame> video_frame = video_frame_queue_.front();
+  if (elapsed_time < video_frame->timestamp())
     return false;
-
-  gfx::Size size(video_config_.width, video_config_.height);
-  scoped_refptr<VideoFrame> video_frame =
-      VideoFrame::CreateBlackFrame(size);
   video_frame_queue_.pop();
-  media::CopyPlane(VideoFrame::kYPlane,
-                   decoded_frame->data(VideoFrame::kYPlane),
-                   decoded_frame->stride(VideoFrame::kYPlane),
-                   decoded_frame->rows(VideoFrame::kYPlane),
-                   video_frame.get());
-  media::CopyPlane(VideoFrame::kUPlane,
-                   decoded_frame->data(VideoFrame::kUPlane),
-                   decoded_frame->stride(VideoFrame::kUPlane),
-                   decoded_frame->rows(VideoFrame::kUPlane),
-                   video_frame.get());
-  media::CopyPlane(VideoFrame::kVPlane,
-                   decoded_frame->data(VideoFrame::kVPlane),
-                   decoded_frame->stride(VideoFrame::kVPlane),
-                   decoded_frame->rows(VideoFrame::kVPlane),
-                   video_frame.get());
 
   // Use the timestamp from the file if we're transcoding.
-  video_frame->set_timestamp(ScaleTimestamp(decoded_frame->timestamp()));
+  video_frame->set_timestamp(ScaleTimestamp(video_frame->timestamp()));
   if (keep_frames_)
     inserted_video_frame_queue_.push(video_frame);
   video_frame_input_->InsertRawVideoFrame(
       video_frame, start_time_ + video_frame->timestamp());
 
   // Make sure queue is not empty.
   Decode(false);
   return true;
 }
 
@@ skipping 30 matching lines @@
   if (audio_bus_queue_.empty() && video_frame_queue_.empty()) {
     // Both queues are empty can only mean that we have reached
     // the end of the stream.
     LOG(INFO) << "Rewind.";
     Rewind();
   }
 
   // Send next send.
   task_runner_->PostDelayedTask(
       FROM_HERE,
-      base::Bind(
-          &FakeMediaSource::SendNextFrame,
-          base::Unretained(this)),
+      base::Bind(&FakeMediaSource::SendNextFrame, weak_factory_.GetWeakPtr()),
       base::TimeDelta::FromMilliseconds(kAudioFrameMs));
 }
 
 base::TimeDelta FakeMediaSource::VideoFrameTime(int frame_number) {
   return frame_number * base::TimeDelta::FromSeconds(1) *
       video_frame_rate_denominator_ / video_frame_rate_numerator_;
 }
 
 base::TimeDelta FakeMediaSource::ScaleTimestamp(base::TimeDelta timestamp) {
   return base::TimeDelta::FromSecondsD(timestamp.InSecondsF() / playback_rate_);
@@ skipping 213 matching lines @@
 AVCodecContext* FakeMediaSource::av_audio_context() {
   return av_audio_stream()->codec;
 }
 
 AVCodecContext* FakeMediaSource::av_video_context() {
   return av_video_stream()->codec;
 }
 
 }  // namespace cast
 }  // namespace media