src/video_engine/test/auto_test/primitives/framedrop_primitives.cc - vendor/opensource/webrtc - Git at Google

 /*
  *  Copyright (c) 2011 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.
  */

 #include <cassert>
 #include <string>

 #include "framedrop_primitives.h"

 #include "general_primitives.h"
 #include "system_wrappers/interface/tick_util.h"
 #include "tb_interfaces.h"
 #include "testsupport/fileutils.h"
 #include "testsupport/frame_reader.h"
 #include "testsupport/frame_writer.h"
 #include "video_capture_factory.h"
 #include "vie_autotest.h"
 #include "vie_autotest_defines.h"
 #include "vie_to_file_renderer.h"

 // Tracks which frames are sent on the local side and reports them to the
 // FrameDropDetector class.
 class SendTimestampEffectFilter: public webrtc::ViEEffectFilter {
  public:
   explicit SendTimestampEffectFilter(FrameDropDetector* frame_drop_detector)
       : frame_drop_detector_(frame_drop_detector) {}
   virtual ~SendTimestampEffectFilter() {}
   virtual int Transform(int size, unsigned char* frameBuffer,
                         unsigned int timeStamp90KHz, unsigned int width,
                         unsigned int height) {
     frame_drop_detector_->ReportSent(timeStamp90KHz);
     return 0;
   }
  private:
   FrameDropDetector* frame_drop_detector_;
 };

 // Tracks when frames are decoded on the remote side (received from the
 // jitter buffer) and reports them to the FrameDropDetector class.
 class DecodeTimestampEffectFilter: public webrtc::ViEEffectFilter {
  public:
   explicit DecodeTimestampEffectFilter(FrameDropDetector* frame_drop_detector)
       : frame_drop_detector_(frame_drop_detector) {}
   virtual ~DecodeTimestampEffectFilter() {}
   virtual int Transform(int size, unsigned char* frameBuffer,
                         unsigned int timeStamp90KHz, unsigned int width,
                         unsigned int height) {
     frame_drop_detector_->ReportDecoded(timeStamp90KHz);
     return 0;
   }
  private:
   FrameDropDetector* frame_drop_detector_;
 };

 void TestFullStack(const TbInterfaces& interfaces,
                    int capture_id,
                    int video_channel,
                    int width,
                    int height,
                    int bit_rate_kbps,
                    FrameDropDetector* frame_drop_detector) {
   webrtc::VideoEngine *video_engine_interface = interfaces.video_engine;
   webrtc::ViEBase *base_interface = interfaces.base;
   webrtc::ViECapture *capture_interface = interfaces.capture;
   webrtc::ViERender *render_interface = interfaces.render;
   webrtc::ViECodec *codec_interface = interfaces.codec;
   webrtc::ViENetwork *network_interface = interfaces.network;

   // ***************************************************************
   // Engine ready. Begin testing class
   // ***************************************************************
   webrtc::VideoCodec video_codec;
   memset(&video_codec, 0, sizeof (webrtc::VideoCodec));

   // Set up all receive codecs. This basically setup the codec interface
   // to be able to recognize all receive codecs based on payload type.
   for (int idx = 0; idx < codec_interface->NumberOfCodecs(); idx++) {
     EXPECT_EQ(0, codec_interface->GetCodec(idx, video_codec));
     SetSuitableResolution(&video_codec, width, height);

     EXPECT_EQ(0, codec_interface->SetReceiveCodec(video_channel, video_codec));
   }
   const char *ip_address = "127.0.0.1";
   const unsigned short rtp_port = 6000;
   EXPECT_EQ(0, network_interface->SetLocalReceiver(video_channel, rtp_port));
   EXPECT_EQ(0, base_interface->StartReceive(video_channel));
   EXPECT_EQ(0, network_interface->SetSendDestination(video_channel, ip_address,
                                                      rtp_port));
   // Setup only the VP8 codec, which is what we'll use.
   webrtc::VideoCodec codec;
   EXPECT_TRUE(FindSpecificCodec(webrtc::kVideoCodecVP8, codec_interface,
                                 &codec));
   codec.startBitrate = bit_rate_kbps;
   codec.maxBitrate = bit_rate_kbps;
   codec.width = width;
   codec.height = height;
   EXPECT_EQ(0, codec_interface->SetSendCodec(video_channel, codec));

   webrtc::ViEImageProcess *image_process =
       webrtc::ViEImageProcess::GetInterface(video_engine_interface);
   EXPECT_TRUE(image_process);

   // Setup the effect filters
   DecodeTimestampEffectFilter decode_filter(frame_drop_detector);
   EXPECT_EQ(0, image_process->RegisterRenderEffectFilter(video_channel,
                                                          decode_filter));
   SendTimestampEffectFilter send_filter(frame_drop_detector);
   EXPECT_EQ(0, image_process->RegisterSendEffectFilter(video_channel,
                                                        send_filter));
   // Send video.
   EXPECT_EQ(0, base_interface->StartSend(video_channel));
   AutoTestSleep(KAutoTestSleepTimeMs);

   // Cleanup.
   EXPECT_EQ(0, image_process->DeregisterRenderEffectFilter(video_channel));
   EXPECT_EQ(0, image_process->DeregisterSendEffectFilter(video_channel));
   image_process->Release();
   ViETest::Log("Done!");

   // ***************************************************************
   // Testing finished. Tear down Video Engine
   // ***************************************************************
   EXPECT_EQ(0, base_interface->StopSend(video_channel));
   EXPECT_EQ(0, base_interface->StopReceive(video_channel));
   EXPECT_EQ(0, render_interface->StopRender(capture_id));
   EXPECT_EQ(0, render_interface->StopRender(video_channel));
   EXPECT_EQ(0, render_interface->RemoveRenderer(capture_id));
   EXPECT_EQ(0, render_interface->RemoveRenderer(video_channel));
   EXPECT_EQ(0, capture_interface->DisconnectCaptureDevice(video_channel));
   EXPECT_EQ(0, base_interface->DeleteChannel(video_channel));
 }

 void FixOutputFileForComparison(const std::string& output_file,
                                 int total_number_of_frames,
                                 int frame_length_in_bytes,
                                 std::list<Frame*> dropped_frames) {
   if (dropped_frames.size() == 0) {
     // No need to modify if no frames are dropped, since the file is already
     // frame-per-frame in sync in that case.
     return;
   }
   webrtc::test::FrameReaderImpl frame_reader(output_file,
                                              frame_length_in_bytes);
   const std::string temp_file = output_file + ".fixed";
   webrtc::test::FrameWriterImpl frame_writer(temp_file, frame_length_in_bytes);
   frame_reader.Init();
   frame_writer.Init();

   // Assume the dropped_frames list is sorted by frame number.
   int next_dropped_frame = dropped_frames.front()->number_;
   dropped_frames.pop_front();
   ASSERT_NE(0, next_dropped_frame) << "It should not be possible to drop the "
       "first frame. Both because we don't have anything useful to fill that "
       "gap with and it is impossible to detect it without any previous "
       "timestamps to compare with.";

   WebRtc_UWord8* last_read_frame_data =
       new WebRtc_UWord8[frame_length_in_bytes];

   // Write the first frame now since it will always be the same.
   EXPECT_TRUE(frame_reader.ReadFrame(last_read_frame_data));
   EXPECT_TRUE(frame_writer.WriteFrame(last_read_frame_data));

   // Process the file and write frame duplicates for all dropped frames.
   for (int i = 1; i < total_number_of_frames; ++i) {
     if (i == next_dropped_frame) {
       // Write the previous frame to the output file:
       EXPECT_TRUE(frame_writer.WriteFrame(last_read_frame_data));
       if (!dropped_frames.empty()) {
         next_dropped_frame = dropped_frames.front()->number_;
         dropped_frames.pop_front();
       }
     } else {
       // Read a new frame and write it to the output file.
       EXPECT_TRUE(frame_reader.ReadFrame(last_read_frame_data));
       EXPECT_TRUE(frame_writer.WriteFrame(last_read_frame_data));
     }
   }
   delete[] last_read_frame_data;
   frame_reader.Close();
   frame_writer.Close();
   ASSERT_EQ(0, std::remove(output_file.c_str()));
   ASSERT_EQ(0, std::rename(temp_file.c_str(), output_file.c_str()));
 }

 void FrameDropDetector::ReportSent(unsigned int timestamp) {
   int number = sent_frames_list_.size();
   Frame* frame = new Frame(number, timestamp);
   frame->sent_timestamp_in_us_ = webrtc::TickTime::MicrosecondTimestamp();
   sent_frames_list_.push_back(frame);
   sent_frames_[timestamp] = frame;
 }

 void FrameDropDetector::ReportDecoded(unsigned int timestamp) {
   // When the first sent frame arrives we calculate the fixed difference
   // between the timestamps of the sent frames and the decoded/rendered frames.
   // This diff is then used to identify the frames from the sent_frames_ map.
   if (frame_timestamp_diff_ == 0) {
     Frame* first_sent_frame = sent_frames_list_.front();
     frame_timestamp_diff_ = timestamp - first_sent_frame->frame_timestamp_;
   }
   // Calculate the sent timestamp required to identify the frame:
   unsigned int sent_timestamp = timestamp - frame_timestamp_diff_;

   // Find the right Frame object in the map of sent frames:
   Frame* frame = sent_frames_[sent_timestamp];
   frame->decoded_timestamp_in_us_ = webrtc::TickTime::MicrosecondTimestamp();
   decoded_frames_[sent_timestamp] = frame;
 }

 void FrameDropDetector::ReportRendered(unsigned int timestamp) {
   // Calculate the sent timestamp required to identify the frame:
   unsigned int sent_timestamp = timestamp - frame_timestamp_diff_;

   // Find this frame in the map of sent frames:
   Frame* frame = sent_frames_[sent_timestamp];
   frame->rendered_timestamp_in_us_ = webrtc::TickTime::MicrosecondTimestamp();
   rendered_frames_[sent_timestamp] = frame;
 }

 int FrameDropDetector::NumberSentFrames() {
   return static_cast<int>(sent_frames_.size());
 }

 void FrameDropDetector::PrintReport() {
   ViETest::Log("Frame Drop Detector report:");
   ViETest::Log("Sent     frames: %ld", sent_frames_.size());
   ViETest::Log("Decoded  frames: %ld", decoded_frames_.size());
   ViETest::Log("Rendered frames: %ld", rendered_frames_.size());

   // Display all frames and stats for them:
   long last_sent = 0;
   long last_decoded = 0;
   long last_rendered = 0;
   ViETest::Log("Sent frames summary:");
   ViETest::Log("Deltas are in microseconds and only cover existing frames.");
   ViETest::Log("Frame no  SentDelta  DecodedDelta  RenderedDelta  DecodedDrop? "
       "RenderedDrop?");
   for (std::list<Frame*>::iterator it = sent_frames_list_.begin();
        it != sent_frames_list_.end(); it++) {
     bool dropped_decode = (decoded_frames_.find((*it)->frame_timestamp_) ==
         decoded_frames_.end());
     bool dropped_render = (rendered_frames_.find((*it)->frame_timestamp_) ==
         rendered_frames_.end());
     int sent_delta = static_cast<int>((*it)->sent_timestamp_in_us_ - last_sent);
     int decoded_delta = dropped_decode ? 0 :
         static_cast<int>((*it)->decoded_timestamp_in_us_ - last_decoded);
     int rendered_delta = dropped_render ? 0 :
         static_cast<int>((*it)->rendered_timestamp_in_us_ - last_rendered);

     // Set values to 0 for the first frame:
     if ((*it)->number_ == 0) {
       sent_delta = 0;
       decoded_delta = 0;
       rendered_delta = 0;
     }
     ViETest::Log("%8d %10d    %10d     %10d    %s     %s", (*it)->number_,
            sent_delta, decoded_delta, rendered_delta,
            dropped_decode ? "DROPPED" : "      ",
            dropped_render ? "DROPPED" : "      ");
     last_sent = (*it)->sent_timestamp_in_us_;
     if (!dropped_render) {
       last_decoded = (*it)->decoded_timestamp_in_us_;
       last_rendered = (*it)->rendered_timestamp_in_us_;
     }
   }
   // Find and print the dropped frames. Work at a copy of the sent_frames_ map.
   std::list<Frame*> decode_dropped_frames = GetFramesDroppedAtDecodeStep();
   ViETest::Log("Number of dropped frames at the decode step: %d",
                static_cast<int>(decode_dropped_frames.size()));
   std::list<Frame*> render_dropped_frames = GetFramesDroppedAtRenderStep();
   ViETest::Log("Number of dropped frames at the render step: %d",
                static_cast<int>(render_dropped_frames.size()));
 }

 const std::list<Frame*> FrameDropDetector::GetFramesDroppedAtDecodeStep() {
   std::list<Frame*> dropped_frames;
   std::map<unsigned int, Frame*>::iterator it;
   for (it = sent_frames_.begin(); it != sent_frames_.end(); it++) {
     if (decoded_frames_.find(it->first) == decoded_frames_.end()) {
       dropped_frames.push_back(it->second);
     }
   }
   return dropped_frames;
 }

 const std::list<Frame*> FrameDropDetector::GetFramesDroppedAtRenderStep() {
   std::list<Frame*> dropped_frames;
   std::map<unsigned int, Frame*>::iterator it;
   for (it = sent_frames_.begin(); it != sent_frames_.end(); it++) {
     if (rendered_frames_.find(it->first) == rendered_frames_.end()) {
       dropped_frames.push_back(it->second);
     }
   }
   return dropped_frames;
 }

 int FrameDropMonitoringRemoteFileRenderer::DeliverFrame(
     unsigned char *buffer, int buffer_size, unsigned int time_stamp) {
   // Register that this frame has been rendered:
   frame_drop_detector_->ReportRendered(time_stamp);
   return ViEToFileRenderer::DeliverFrame(buffer, buffer_size, time_stamp);
 }

 int FrameDropMonitoringRemoteFileRenderer::FrameSizeChange(
     unsigned int width, unsigned int height, unsigned int number_of_streams) {
   return ViEToFileRenderer::FrameSizeChange(width, height, number_of_streams);
 }
	/*
	* Copyright (c) 2011 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.
	*/

	#include <cassert>
	#include <string>

	#include "framedrop_primitives.h"

	#include "general_primitives.h"
	#include "system_wrappers/interface/tick_util.h"
	#include "tb_interfaces.h"
	#include "testsupport/fileutils.h"
	#include "testsupport/frame_reader.h"
	#include "testsupport/frame_writer.h"
	#include "video_capture_factory.h"
	#include "vie_autotest.h"
	#include "vie_autotest_defines.h"
	#include "vie_to_file_renderer.h"

	// Tracks which frames are sent on the local side and reports them to the
	// FrameDropDetector class.
	class SendTimestampEffectFilter: public webrtc::ViEEffectFilter {
	public:
	explicit SendTimestampEffectFilter(FrameDropDetector* frame_drop_detector)
	: frame_drop_detector_(frame_drop_detector) {}
	virtual ~SendTimestampEffectFilter() {}
	virtual int Transform(int size, unsigned char* frameBuffer,
	unsigned int timeStamp90KHz, unsigned int width,
	unsigned int height) {
	frame_drop_detector_->ReportSent(timeStamp90KHz);
	return 0;
	}
	private:
	FrameDropDetector* frame_drop_detector_;
	};

	// Tracks when frames are decoded on the remote side (received from the
	// jitter buffer) and reports them to the FrameDropDetector class.
	class DecodeTimestampEffectFilter: public webrtc::ViEEffectFilter {
	public:
	explicit DecodeTimestampEffectFilter(FrameDropDetector* frame_drop_detector)
	: frame_drop_detector_(frame_drop_detector) {}
	virtual ~DecodeTimestampEffectFilter() {}
	virtual int Transform(int size, unsigned char* frameBuffer,
	unsigned int timeStamp90KHz, unsigned int width,
	unsigned int height) {
	frame_drop_detector_->ReportDecoded(timeStamp90KHz);
	return 0;
	}
	private:
	FrameDropDetector* frame_drop_detector_;
	};

	void TestFullStack(const TbInterfaces& interfaces,
	int capture_id,
	int video_channel,
	int width,
	int height,
	int bit_rate_kbps,
	FrameDropDetector* frame_drop_detector) {
	webrtc::VideoEngine *video_engine_interface = interfaces.video_engine;
	webrtc::ViEBase *base_interface = interfaces.base;
	webrtc::ViECapture *capture_interface = interfaces.capture;
	webrtc::ViERender *render_interface = interfaces.render;
	webrtc::ViECodec *codec_interface = interfaces.codec;
	webrtc::ViENetwork *network_interface = interfaces.network;

	// ***************************************************************
	// Engine ready. Begin testing class
	// ***************************************************************
	webrtc::VideoCodec video_codec;
	memset(&video_codec, 0, sizeof (webrtc::VideoCodec));

	// Set up all receive codecs. This basically setup the codec interface
	// to be able to recognize all receive codecs based on payload type.
	for (int idx = 0; idx < codec_interface->NumberOfCodecs(); idx++) {
	EXPECT_EQ(0, codec_interface->GetCodec(idx, video_codec));
	SetSuitableResolution(&video_codec, width, height);

	EXPECT_EQ(0, codec_interface->SetReceiveCodec(video_channel, video_codec));
	}
	const char *ip_address = "127.0.0.1";
	const unsigned short rtp_port = 6000;
	EXPECT_EQ(0, network_interface->SetLocalReceiver(video_channel, rtp_port));
	EXPECT_EQ(0, base_interface->StartReceive(video_channel));
	EXPECT_EQ(0, network_interface->SetSendDestination(video_channel, ip_address,
	rtp_port));
	// Setup only the VP8 codec, which is what we'll use.
	webrtc::VideoCodec codec;
	EXPECT_TRUE(FindSpecificCodec(webrtc::kVideoCodecVP8, codec_interface,
	&codec));
	codec.startBitrate = bit_rate_kbps;
	codec.maxBitrate = bit_rate_kbps;
	codec.width = width;
	codec.height = height;
	EXPECT_EQ(0, codec_interface->SetSendCodec(video_channel, codec));

	webrtc::ViEImageProcess *image_process =
	webrtc::ViEImageProcess::GetInterface(video_engine_interface);
	EXPECT_TRUE(image_process);

	// Setup the effect filters
	DecodeTimestampEffectFilter decode_filter(frame_drop_detector);
	EXPECT_EQ(0, image_process->RegisterRenderEffectFilter(video_channel,
	decode_filter));
	SendTimestampEffectFilter send_filter(frame_drop_detector);
	EXPECT_EQ(0, image_process->RegisterSendEffectFilter(video_channel,
	send_filter));
	// Send video.
	EXPECT_EQ(0, base_interface->StartSend(video_channel));
	AutoTestSleep(KAutoTestSleepTimeMs);

	// Cleanup.
	EXPECT_EQ(0, image_process->DeregisterRenderEffectFilter(video_channel));
	EXPECT_EQ(0, image_process->DeregisterSendEffectFilter(video_channel));
	image_process->Release();
	ViETest::Log("Done!");

	// ***************************************************************
	// Testing finished. Tear down Video Engine
	// ***************************************************************
	EXPECT_EQ(0, base_interface->StopSend(video_channel));
	EXPECT_EQ(0, base_interface->StopReceive(video_channel));
	EXPECT_EQ(0, render_interface->StopRender(capture_id));
	EXPECT_EQ(0, render_interface->StopRender(video_channel));
	EXPECT_EQ(0, render_interface->RemoveRenderer(capture_id));
	EXPECT_EQ(0, render_interface->RemoveRenderer(video_channel));
	EXPECT_EQ(0, capture_interface->DisconnectCaptureDevice(video_channel));
	EXPECT_EQ(0, base_interface->DeleteChannel(video_channel));
	}

	void FixOutputFileForComparison(const std::string& output_file,
	int total_number_of_frames,
	int frame_length_in_bytes,
	std::list<Frame*> dropped_frames) {
	if (dropped_frames.size() == 0) {
	// No need to modify if no frames are dropped, since the file is already
	// frame-per-frame in sync in that case.
	return;
	}
	webrtc::test::FrameReaderImpl frame_reader(output_file,
	frame_length_in_bytes);
	const std::string temp_file = output_file + ".fixed";
	webrtc::test::FrameWriterImpl frame_writer(temp_file, frame_length_in_bytes);
	frame_reader.Init();
	frame_writer.Init();

	// Assume the dropped_frames list is sorted by frame number.
	int next_dropped_frame = dropped_frames.front()->number_;
	dropped_frames.pop_front();
	ASSERT_NE(0, next_dropped_frame) << "It should not be possible to drop the "
	"first frame. Both because we don't have anything useful to fill that "
	"gap with and it is impossible to detect it without any previous "
	"timestamps to compare with.";

	WebRtc_UWord8* last_read_frame_data =
	new WebRtc_UWord8[frame_length_in_bytes];

	// Write the first frame now since it will always be the same.
	EXPECT_TRUE(frame_reader.ReadFrame(last_read_frame_data));
	EXPECT_TRUE(frame_writer.WriteFrame(last_read_frame_data));

	// Process the file and write frame duplicates for all dropped frames.
	for (int i = 1; i < total_number_of_frames; ++i) {
	if (i == next_dropped_frame) {
	// Write the previous frame to the output file:
	EXPECT_TRUE(frame_writer.WriteFrame(last_read_frame_data));
	if (!dropped_frames.empty()) {
	next_dropped_frame = dropped_frames.front()->number_;
	dropped_frames.pop_front();
	}
	} else {
	// Read a new frame and write it to the output file.
	EXPECT_TRUE(frame_reader.ReadFrame(last_read_frame_data));
	EXPECT_TRUE(frame_writer.WriteFrame(last_read_frame_data));
	}
	}
	delete[] last_read_frame_data;
	frame_reader.Close();
	frame_writer.Close();
	ASSERT_EQ(0, std::remove(output_file.c_str()));
	ASSERT_EQ(0, std::rename(temp_file.c_str(), output_file.c_str()));
	}

	void FrameDropDetector::ReportSent(unsigned int timestamp) {
	int number = sent_frames_list_.size();
	Frame* frame = new Frame(number, timestamp);
	frame->sent_timestamp_in_us_ = webrtc::TickTime::MicrosecondTimestamp();
	sent_frames_list_.push_back(frame);
	sent_frames_[timestamp] = frame;
	}

	void FrameDropDetector::ReportDecoded(unsigned int timestamp) {
	// When the first sent frame arrives we calculate the fixed difference
	// between the timestamps of the sent frames and the decoded/rendered frames.
	// This diff is then used to identify the frames from the sent_frames_ map.
	if (frame_timestamp_diff_ == 0) {
	Frame* first_sent_frame = sent_frames_list_.front();
	frame_timestamp_diff_ = timestamp - first_sent_frame->frame_timestamp_;
	}
	// Calculate the sent timestamp required to identify the frame:
	unsigned int sent_timestamp = timestamp - frame_timestamp_diff_;

	// Find the right Frame object in the map of sent frames:
	Frame* frame = sent_frames_[sent_timestamp];
	frame->decoded_timestamp_in_us_ = webrtc::TickTime::MicrosecondTimestamp();
	decoded_frames_[sent_timestamp] = frame;
	}

	void FrameDropDetector::ReportRendered(unsigned int timestamp) {
	// Calculate the sent timestamp required to identify the frame:
	unsigned int sent_timestamp = timestamp - frame_timestamp_diff_;

	// Find this frame in the map of sent frames:
	Frame* frame = sent_frames_[sent_timestamp];
	frame->rendered_timestamp_in_us_ = webrtc::TickTime::MicrosecondTimestamp();
	rendered_frames_[sent_timestamp] = frame;
	}

	int FrameDropDetector::NumberSentFrames() {
	return static_cast<int>(sent_frames_.size());
	}

	void FrameDropDetector::PrintReport() {
	ViETest::Log("Frame Drop Detector report:");
	ViETest::Log("Sent frames: %ld", sent_frames_.size());
	ViETest::Log("Decoded frames: %ld", decoded_frames_.size());
	ViETest::Log("Rendered frames: %ld", rendered_frames_.size());

	// Display all frames and stats for them:
	long last_sent = 0;
	long last_decoded = 0;
	long last_rendered = 0;
	ViETest::Log("Sent frames summary:");
	ViETest::Log("Deltas are in microseconds and only cover existing frames.");
	ViETest::Log("Frame no SentDelta DecodedDelta RenderedDelta DecodedDrop? "
	"RenderedDrop?");
	for (std::list<Frame*>::iterator it = sent_frames_list_.begin();
	it != sent_frames_list_.end(); it++) {
	bool dropped_decode = (decoded_frames_.find((*it)->frame_timestamp_) ==
	decoded_frames_.end());
	bool dropped_render = (rendered_frames_.find((*it)->frame_timestamp_) ==
	rendered_frames_.end());
	int sent_delta = static_cast<int>((*it)->sent_timestamp_in_us_ - last_sent);
	int decoded_delta = dropped_decode ? 0 :
	static_cast<int>((*it)->decoded_timestamp_in_us_ - last_decoded);
	int rendered_delta = dropped_render ? 0 :
	static_cast<int>((*it)->rendered_timestamp_in_us_ - last_rendered);

	// Set values to 0 for the first frame:
	if ((*it)->number_ == 0) {
	sent_delta = 0;
	decoded_delta = 0;
	rendered_delta = 0;
	}
	ViETest::Log("%8d %10d %10d %10d %s %s", (*it)->number_,
	sent_delta, decoded_delta, rendered_delta,
	dropped_decode ? "DROPPED" : " ",
	dropped_render ? "DROPPED" : " ");
	last_sent = (*it)->sent_timestamp_in_us_;
	if (!dropped_render) {
	last_decoded = (*it)->decoded_timestamp_in_us_;
	last_rendered = (*it)->rendered_timestamp_in_us_;
	}
	}
	// Find and print the dropped frames. Work at a copy of the sent_frames_ map.
	std::list<Frame*> decode_dropped_frames = GetFramesDroppedAtDecodeStep();
	ViETest::Log("Number of dropped frames at the decode step: %d",
	static_cast<int>(decode_dropped_frames.size()));
	std::list<Frame*> render_dropped_frames = GetFramesDroppedAtRenderStep();
	ViETest::Log("Number of dropped frames at the render step: %d",
	static_cast<int>(render_dropped_frames.size()));
	}

	const std::list<Frame*> FrameDropDetector::GetFramesDroppedAtDecodeStep() {
	std::list<Frame*> dropped_frames;
	std::map<unsigned int, Frame*>::iterator it;
	for (it = sent_frames_.begin(); it != sent_frames_.end(); it++) {
	if (decoded_frames_.find(it->first) == decoded_frames_.end()) {
	dropped_frames.push_back(it->second);
	}
	}
	return dropped_frames;
	}

	const std::list<Frame*> FrameDropDetector::GetFramesDroppedAtRenderStep() {
	std::list<Frame*> dropped_frames;
	std::map<unsigned int, Frame*>::iterator it;
	for (it = sent_frames_.begin(); it != sent_frames_.end(); it++) {
	if (rendered_frames_.find(it->first) == rendered_frames_.end()) {
	dropped_frames.push_back(it->second);
	}
	}
	return dropped_frames;
	}

	int FrameDropMonitoringRemoteFileRenderer::DeliverFrame(
	unsigned char *buffer, int buffer_size, unsigned int time_stamp) {
	// Register that this frame has been rendered:
	frame_drop_detector_->ReportRendered(time_stamp);
	return ViEToFileRenderer::DeliverFrame(buffer, buffer_size, time_stamp);
	}

	int FrameDropMonitoringRemoteFileRenderer::FrameSizeChange(
	unsigned int width, unsigned int height, unsigned int number_of_streams) {
	return ViEToFileRenderer::FrameSizeChange(width, height, number_of_streams);
	}