Update video_replay tool to be able to dump .jpg files.

webrtc/video/replay.cc

 /*
  *  Copyright (c) 2014 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 13 matching lines @@
 #include "webrtc/system_wrappers/include/clock.h"
 #include "webrtc/system_wrappers/include/sleep.h"
 #include "webrtc/test/call_test.h"
 #include "webrtc/test/encoder_settings.h"
 #include "webrtc/test/fake_decoder.h"
 #include "webrtc/test/gtest.h"
 #include "webrtc/test/null_transport.h"
 #include "webrtc/test/rtp_file_reader.h"
 #include "webrtc/test/run_loop.h"
 #include "webrtc/test/run_test.h"
+#include "webrtc/test/testsupport/frame_writer.h"
 #include "webrtc/test/video_capturer.h"
 #include "webrtc/test/video_renderer.h"
 #include "webrtc/typedefs.h"
 
 namespace webrtc {
 namespace flags {
 
 // TODO(pbos): Multiple receivers.
 
 // Flag for payload type.
@@ skipping 85 matching lines @@
 
 DEFINE_string(input_file, "", "input file");
 static std::string InputFile() {
   return static_cast<std::string>(FLAGS_input_file);
 }
 static const bool input_file_dummy =
     google::RegisterFlagValidator(&FLAGS_input_file,
                                   &ValidateInputFilenameNotEmpty);
 
 // Flag for raw output files.
-DEFINE_string(out_base, "", "Basename (excluding .yuv) for raw output");
+DEFINE_string(out_base, "", "Basename (excluding .jpg) for raw output");
 static std::string OutBase() {
   return static_cast<std::string>(FLAGS_out_base);
 }
 
 DEFINE_string(decoder_bitstream_filename, "", "Decoder bitstream output file");
 static std::string DecoderBitstreamFilename() {
   return static_cast<std::string>(FLAGS_decoder_bitstream_filename);
 }
 
 // Flag for video codec.
 DEFINE_string(codec, "VP8", "Video codec");
 static std::string Codec() { return static_cast<std::string>(FLAGS_codec); }
 
 }  // namespace flags
 
 static const uint32_t kReceiverLocalSsrc = 0x123456;
 
 class FileRenderPassthrough : public rtc::VideoSinkInterface<VideoFrame> {
  public:
   FileRenderPassthrough(const std::string& basename,
                         rtc::VideoSinkInterface<VideoFrame>* renderer)
-      : basename_(basename),
-        renderer_(renderer),
-        file_(nullptr),
-        count_(0),
-        last_width_(0),
-        last_height_(0) {}
+      : basename_(basename), renderer_(renderer), file_(nullptr), count_(0) {}
 
   ~FileRenderPassthrough() {
     if (file_)
       fclose(file_);
   }
 
  private:
   void OnFrame(const VideoFrame& video_frame) override {
     if (renderer_)
       renderer_->OnFrame(video_frame);
+
     if (basename_.empty())
       return;
-    if (last_width_ != video_frame.width() ||
-        last_height_ != video_frame.height()) {
-      if (file_)
-        fclose(file_);
-      std::stringstream filename;
-      filename << basename_;
-      if (++count_ > 1)
-        filename << '-' << count_;
-      filename << '_' << video_frame.width() << 'x' << video_frame.height()
-               << ".yuv";
-      file_ = fopen(filename.str().c_str(), "wb");
-      if (!file_) {
-        fprintf(stderr,
-                "Couldn't open file for writing: %s\n",
-                filename.str().c_str());
-      }
-    }
-    last_width_ = video_frame.width();
-    last_height_ = video_frame.height();
-    if (!file_)
-      return;
-    PrintVideoFrame(video_frame, file_);
+
+    std::stringstream filename;
+    filename << basename_ << count_++ << "_" << video_frame.timestamp()
+             << ".jpg";
+
+#if !defined(WEBRTC_IOS)
+    test::JpegFrameWriter frame_writer(filename.str());
+    RTC_CHECK(frame_writer.WriteFrame(video_frame, 100));
+#endif
   }
 
   const std::string basename_;
   rtc::VideoSinkInterface<VideoFrame>* const renderer_;
   FILE* file_;
   size_t count_;
-  int last_width_;
-  int last_height_;
 };
 
 class DecoderBitstreamFileWriter : public EncodedFrameObserver {
  public:
   explicit DecoderBitstreamFileWriter(const char* filename)
       : file_(fopen(filename, "wb")) {
     RTC_DCHECK(file_);
   }
   ~DecoderBitstreamFileWriter() { fclose(file_); }
 
@@ skipping 129 matching lines @@
 }
 }  // namespace webrtc
 
 int main(int argc, char* argv[]) {
   ::testing::InitGoogleTest(&argc, argv);
   google::ParseCommandLineFlags(&argc, &argv, true);
 
   webrtc::test::RunTest(webrtc::RtpReplay);
   return 0;
 }