1/* 2 * libjingle 3 * Copyright 2004 Google Inc. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions are met: 7 * 8 * 1. Redistributions of source code must retain the above copyright notice, 9 * this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright notice, 11 * this list of conditions and the following disclaimer in the documentation 12 * and/or other materials provided with the distribution. 13 * 3. The name of the author may not be used to endorse or promote products 14 * derived from this software without specific prior written permission. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED 17 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 18 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO 19 * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 20 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 21 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; 22 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 23 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 24 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 25 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 26 */ 27 28#ifndef TALK_MEDIA_BASE_TESTUTILS_H_ 29#define TALK_MEDIA_BASE_TESTUTILS_H_ 30 31#include <string> 32#include <vector> 33 34#if !defined(DISABLE_YUV) 35#include "libyuv/compare.h" 36#endif 37#include "talk/media/base/mediachannel.h" 38#include "talk/media/base/videocapturer.h" 39#include "talk/media/base/videocommon.h" 40#include "webrtc/base/basictypes.h" 41#include "webrtc/base/sigslot.h" 42#include "webrtc/base/window.h" 43 44namespace rtc { 45class ByteBuffer; 46class StreamInterface; 47} 48 49namespace cricket { 50 51// Returns size of 420 image with rounding on chroma for odd sizes. 52#define I420_SIZE(w, h) (w * h + (((w + 1) / 2) * ((h + 1) / 2)) * 2) 53// Returns size of ARGB image. 54#define ARGB_SIZE(w, h) (w * h * 4) 55 56template <class T> inline std::vector<T> MakeVector(const T a[], size_t s) { 57 return std::vector<T>(a, a + s); 58} 59#define MAKE_VECTOR(a) cricket::MakeVector(a, ARRAY_SIZE(a)) 60 61struct RtpDumpPacket; 62class RtpDumpWriter; 63class VideoFrame; 64 65struct RawRtpPacket { 66 void WriteToByteBuffer(uint32 in_ssrc, rtc::ByteBuffer* buf) const; 67 bool ReadFromByteBuffer(rtc::ByteBuffer* buf); 68 // Check if this packet is the same as the specified packet except the 69 // sequence number and timestamp, which should be the same as the specified 70 // parameters. 71 bool SameExceptSeqNumTimestampSsrc( 72 const RawRtpPacket& packet, uint16 seq, uint32 ts, uint32 ssc) const; 73 int size() const { return 28; } 74 75 uint8 ver_to_cc; 76 uint8 m_to_pt; 77 uint16 sequence_number; 78 uint32 timestamp; 79 uint32 ssrc; 80 char payload[16]; 81}; 82 83struct RawRtcpPacket { 84 void WriteToByteBuffer(rtc::ByteBuffer* buf) const; 85 bool ReadFromByteBuffer(rtc::ByteBuffer* buf); 86 bool EqualsTo(const RawRtcpPacket& packet) const; 87 88 uint8 ver_to_count; 89 uint8 type; 90 uint16 length; 91 char payload[16]; 92}; 93 94class RtpTestUtility { 95 public: 96 static size_t GetTestPacketCount(); 97 98 // Write the first count number of kTestRawRtcpPackets or kTestRawRtpPackets, 99 // depending on the flag rtcp. If it is RTP, use the specified SSRC. Return 100 // true if successful. 101 static bool WriteTestPackets( 102 size_t count, bool rtcp, uint32 rtp_ssrc, RtpDumpWriter* writer); 103 104 // Loop read the first count number of packets from the specified stream. 105 // Verify the elapsed time of the dump packets increase monotonically. If the 106 // stream is a RTP stream, verify the RTP sequence number, timestamp, and 107 // payload. If the stream is a RTCP stream, verify the RTCP header and 108 // payload. 109 static bool VerifyTestPacketsFromStream( 110 size_t count, rtc::StreamInterface* stream, uint32 ssrc); 111 112 // Verify the dump packet is the same as the raw RTP packet. 113 static bool VerifyPacket(const RtpDumpPacket* dump, 114 const RawRtpPacket* raw, 115 bool header_only); 116 117 static const uint32 kDefaultSsrc = 1; 118 static const uint32 kRtpTimestampIncrease = 90; 119 static const uint32 kDefaultTimeIncrease = 30; 120 static const uint32 kElapsedTimeInterval = 10; 121 static const RawRtpPacket kTestRawRtpPackets[]; 122 static const RawRtcpPacket kTestRawRtcpPackets[]; 123 124 private: 125 RtpTestUtility() {} 126}; 127 128// Test helper for testing VideoCapturer implementations. 129class VideoCapturerListener : public sigslot::has_slots<> { 130 public: 131 explicit VideoCapturerListener(VideoCapturer* cap); 132 133 CaptureState last_capture_state() const { return last_capture_state_; } 134 int frame_count() const { return frame_count_; } 135 uint32 frame_fourcc() const { return frame_fourcc_; } 136 int frame_width() const { return frame_width_; } 137 int frame_height() const { return frame_height_; } 138 uint32 frame_size() const { return frame_size_; } 139 bool resolution_changed() const { return resolution_changed_; } 140 141 void OnStateChange(VideoCapturer* capturer, CaptureState state); 142 void OnFrameCaptured(VideoCapturer* capturer, const CapturedFrame* frame); 143 144 private: 145 CaptureState last_capture_state_; 146 int frame_count_; 147 uint32 frame_fourcc_; 148 int frame_width_; 149 int frame_height_; 150 uint32 frame_size_; 151 bool resolution_changed_; 152}; 153 154class ScreencastEventCatcher : public sigslot::has_slots<> { 155 public: 156 ScreencastEventCatcher() : ssrc_(0), ev_(rtc::WE_RESIZE) { } 157 uint32 ssrc() const { return ssrc_; } 158 rtc::WindowEvent event() const { return ev_; } 159 void OnEvent(uint32 ssrc, rtc::WindowEvent ev) { 160 ssrc_ = ssrc; 161 ev_ = ev; 162 } 163 private: 164 uint32 ssrc_; 165 rtc::WindowEvent ev_; 166}; 167 168class VideoMediaErrorCatcher : public sigslot::has_slots<> { 169 public: 170 VideoMediaErrorCatcher() : ssrc_(0), error_(VideoMediaChannel::ERROR_NONE) { } 171 uint32 ssrc() const { return ssrc_; } 172 VideoMediaChannel::Error error() const { return error_; } 173 void OnError(uint32 ssrc, VideoMediaChannel::Error error) { 174 ssrc_ = ssrc; 175 error_ = error; 176 } 177 private: 178 uint32 ssrc_; 179 VideoMediaChannel::Error error_; 180}; 181 182// Returns the absolute path to a file in the testdata/ directory. 183std::string GetTestFilePath(const std::string& filename); 184 185// PSNR formula: psnr = 10 * log10 (Peak Signal^2 / mse) 186// sse is set to a small number for identical frames or sse == 0 187static inline double ComputePSNR(double sse, double count) { 188#if !defined(DISABLE_YUV) 189 return libyuv::SumSquareErrorToPsnr(static_cast<uint64>(sse), 190 static_cast<uint64>(count)); 191#else 192 if (sse <= 0.) 193 sse = 65025.0 * count / pow(10., 128./10.); // produces max PSNR of 128 194 return 10.0 * log10(65025.0 * count / sse); 195#endif 196} 197 198static inline double ComputeSumSquareError(const uint8 *org, const uint8 *rec, 199 int size) { 200#if !defined(DISABLE_YUV) 201 return static_cast<double>(libyuv::ComputeSumSquareError(org, rec, size)); 202#else 203 double sse = 0.; 204 for (int j = 0; j < size; ++j) { 205 const int diff = static_cast<int>(org[j]) - static_cast<int>(rec[j]); 206 sse += static_cast<double>(diff * diff); 207 } 208 return sse; 209#endif 210} 211 212// Loads the image with the specified prefix and size into |out|. 213bool LoadPlanarYuvTestImage(const std::string& prefix, 214 int width, int height, uint8* out); 215 216// Dumps the YUV image out to a file, for visual inspection. 217// PYUV tool can be used to view dump files. 218void DumpPlanarYuvTestImage(const std::string& prefix, const uint8* img, 219 int w, int h); 220 221// Dumps the ARGB image out to a file, for visual inspection. 222// ffplay tool can be used to view dump files. 223void DumpPlanarArgbTestImage(const std::string& prefix, const uint8* img, 224 int w, int h); 225 226// Compare two I420 frames. 227bool VideoFrameEqual(const VideoFrame* frame0, const VideoFrame* frame1); 228 229// Checks whether |codecs| contains |codec|; checks using Codec::Matches(). 230template <class C> 231bool ContainsMatchingCodec(const std::vector<C>& codecs, const C& codec) { 232 typename std::vector<C>::const_iterator it; 233 for (it = codecs.begin(); it != codecs.end(); ++it) { 234 if (it->Matches(codec)) { 235 return true; 236 } 237 } 238 return false; 239} 240 241// Create Simulcast StreamParams with given |ssrcs| and |cname|. 242cricket::StreamParams CreateSimStreamParams( 243 const std::string& cname, const std::vector<uint32>& ssrcs); 244// Create Simulcast stream with given |ssrcs| and |rtx_ssrcs|. 245// The number of |rtx_ssrcs| must match number of |ssrcs|. 246cricket::StreamParams CreateSimWithRtxStreamParams( 247 const std::string& cname, const std::vector<uint32>& ssrcs, 248 const std::vector<uint32>& rtx_ssrcs); 249 250} // namespace cricket 251 252#endif // TALK_MEDIA_BASE_TESTUTILS_H_ 253