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#include "talk/media/base/testutils.h"
29
30#include <math.h>
31#include <algorithm>
32
33#include "talk/media/base/executablehelpers.h"
34#include "talk/media/base/rtpdump.h"
35#include "talk/media/base/videocapturer.h"
36#include "talk/media/base/videoframe.h"
37#include "webrtc/base/bytebuffer.h"
38#include "webrtc/base/fileutils.h"
39#include "webrtc/base/gunit.h"
40#include "webrtc/base/pathutils.h"
41#include "webrtc/base/stream.h"
42#include "webrtc/base/stringutils.h"
43#include "webrtc/base/testutils.h"
44
45namespace cricket {
46
47/////////////////////////////////////////////////////////////////////////
48// Implementation of RawRtpPacket
49/////////////////////////////////////////////////////////////////////////
50void RawRtpPacket::WriteToByteBuffer(uint32_t in_ssrc,
51                                     rtc::ByteBuffer* buf) const {
52  if (!buf) return;
53
54  buf->WriteUInt8(ver_to_cc);
55  buf->WriteUInt8(m_to_pt);
56  buf->WriteUInt16(sequence_number);
57  buf->WriteUInt32(timestamp);
58  buf->WriteUInt32(in_ssrc);
59  buf->WriteBytes(payload, sizeof(payload));
60}
61
62bool RawRtpPacket::ReadFromByteBuffer(rtc::ByteBuffer* buf) {
63  if (!buf) return false;
64
65  bool ret = true;
66  ret &= buf->ReadUInt8(&ver_to_cc);
67  ret &= buf->ReadUInt8(&m_to_pt);
68  ret &= buf->ReadUInt16(&sequence_number);
69  ret &= buf->ReadUInt32(&timestamp);
70  ret &= buf->ReadUInt32(&ssrc);
71  ret &= buf->ReadBytes(payload, sizeof(payload));
72  return ret;
73}
74
75bool RawRtpPacket::SameExceptSeqNumTimestampSsrc(const RawRtpPacket& packet,
76                                                 uint16_t seq,
77                                                 uint32_t ts,
78                                                 uint32_t ssc) const {
79  return sequence_number == seq &&
80      timestamp == ts &&
81      ver_to_cc == packet.ver_to_cc &&
82      m_to_pt == packet.m_to_pt &&
83      ssrc == ssc &&
84      0 == memcmp(payload, packet.payload, sizeof(payload));
85}
86
87/////////////////////////////////////////////////////////////////////////
88// Implementation of RawRtcpPacket
89/////////////////////////////////////////////////////////////////////////
90void RawRtcpPacket::WriteToByteBuffer(rtc::ByteBuffer *buf) const {
91  if (!buf) return;
92
93  buf->WriteUInt8(ver_to_count);
94  buf->WriteUInt8(type);
95  buf->WriteUInt16(length);
96  buf->WriteBytes(payload, sizeof(payload));
97}
98
99bool RawRtcpPacket::ReadFromByteBuffer(rtc::ByteBuffer* buf) {
100  if (!buf) return false;
101
102  bool ret = true;
103  ret &= buf->ReadUInt8(&ver_to_count);
104  ret &= buf->ReadUInt8(&type);
105  ret &= buf->ReadUInt16(&length);
106  ret &= buf->ReadBytes(payload, sizeof(payload));
107  return ret;
108}
109
110bool RawRtcpPacket::EqualsTo(const RawRtcpPacket& packet) const {
111  return ver_to_count == packet.ver_to_count &&
112      type == packet.type &&
113      length == packet.length &&
114      0 == memcmp(payload, packet.payload, sizeof(payload));
115}
116
117/////////////////////////////////////////////////////////////////////////
118// Implementation of class RtpTestUtility
119/////////////////////////////////////////////////////////////////////////
120const RawRtpPacket RtpTestUtility::kTestRawRtpPackets[] = {
121    {0x80, 0, 0, 0,  RtpTestUtility::kDefaultSsrc, "RTP frame 0"},
122    {0x80, 0, 1, 30, RtpTestUtility::kDefaultSsrc, "RTP frame 1"},
123    {0x80, 0, 2, 30, RtpTestUtility::kDefaultSsrc, "RTP frame 1"},
124    {0x80, 0, 3, 60, RtpTestUtility::kDefaultSsrc, "RTP frame 2"}
125};
126const RawRtcpPacket RtpTestUtility::kTestRawRtcpPackets[] = {
127    // The Version is 2, the Length is 2, and the payload has 8 bytes.
128    {0x80, 0, 2, "RTCP0000"},
129    {0x80, 0, 2, "RTCP0001"},
130    {0x80, 0, 2, "RTCP0002"},
131    {0x80, 0, 2, "RTCP0003"},
132};
133
134size_t RtpTestUtility::GetTestPacketCount() {
135  return std::min(arraysize(kTestRawRtpPackets),
136                  arraysize(kTestRawRtcpPackets));
137}
138
139bool RtpTestUtility::WriteTestPackets(size_t count,
140                                      bool rtcp,
141                                      uint32_t rtp_ssrc,
142                                      RtpDumpWriter* writer) {
143  if (!writer || count > GetTestPacketCount()) return false;
144
145  bool result = true;
146  uint32_t elapsed_time_ms = 0;
147  for (size_t i = 0; i < count && result; ++i) {
148    rtc::ByteBuffer buf;
149    if (rtcp) {
150      kTestRawRtcpPackets[i].WriteToByteBuffer(&buf);
151    } else {
152      kTestRawRtpPackets[i].WriteToByteBuffer(rtp_ssrc, &buf);
153    }
154
155    RtpDumpPacket dump_packet(buf.Data(), buf.Length(), elapsed_time_ms, rtcp);
156    elapsed_time_ms += kElapsedTimeInterval;
157    result &= (rtc::SR_SUCCESS == writer->WritePacket(dump_packet));
158  }
159  return result;
160}
161
162bool RtpTestUtility::VerifyTestPacketsFromStream(size_t count,
163                                                 rtc::StreamInterface* stream,
164                                                 uint32_t ssrc) {
165  if (!stream) return false;
166
167  uint32_t prev_elapsed_time = 0;
168  bool result = true;
169  stream->Rewind();
170  RtpDumpLoopReader reader(stream);
171  for (size_t i = 0; i < count && result; ++i) {
172    // Which loop and which index in the loop are we reading now.
173    size_t loop = i / GetTestPacketCount();
174    size_t index = i % GetTestPacketCount();
175
176    RtpDumpPacket packet;
177    result &= (rtc::SR_SUCCESS == reader.ReadPacket(&packet));
178    // Check the elapsed time of the dump packet.
179    result &= (packet.elapsed_time >= prev_elapsed_time);
180    prev_elapsed_time = packet.elapsed_time;
181
182    // Check the RTP or RTCP packet.
183    rtc::ByteBuffer buf(reinterpret_cast<const char*>(&packet.data[0]),
184                              packet.data.size());
185    if (packet.is_rtcp()) {
186      // RTCP packet.
187      RawRtcpPacket rtcp_packet;
188      result &= rtcp_packet.ReadFromByteBuffer(&buf);
189      result &= rtcp_packet.EqualsTo(kTestRawRtcpPackets[index]);
190    } else {
191      // RTP packet.
192      RawRtpPacket rtp_packet;
193      result &= rtp_packet.ReadFromByteBuffer(&buf);
194      result &= rtp_packet.SameExceptSeqNumTimestampSsrc(
195          kTestRawRtpPackets[index],
196          static_cast<uint16_t>(kTestRawRtpPackets[index].sequence_number +
197                                loop * GetTestPacketCount()),
198          static_cast<uint32_t>(kTestRawRtpPackets[index].timestamp +
199                                loop * kRtpTimestampIncrease),
200          ssrc);
201    }
202  }
203
204  stream->Rewind();
205  return result;
206}
207
208bool RtpTestUtility::VerifyPacket(const RtpDumpPacket* dump,
209                                  const RawRtpPacket* raw,
210                                  bool header_only) {
211  if (!dump || !raw) return false;
212
213  rtc::ByteBuffer buf;
214  raw->WriteToByteBuffer(RtpTestUtility::kDefaultSsrc, &buf);
215
216  if (header_only) {
217    size_t header_len = 0;
218    dump->GetRtpHeaderLen(&header_len);
219    return header_len == dump->data.size() &&
220        buf.Length() > dump->data.size() &&
221        0 == memcmp(buf.Data(), &dump->data[0], dump->data.size());
222  } else {
223    return buf.Length() == dump->data.size() &&
224        0 == memcmp(buf.Data(), &dump->data[0], dump->data.size());
225  }
226}
227
228// Implementation of VideoCaptureListener.
229VideoCapturerListener::VideoCapturerListener(VideoCapturer* capturer)
230    : last_capture_state_(CS_STARTING),
231      frame_count_(0),
232      frame_fourcc_(0),
233      frame_width_(0),
234      frame_height_(0),
235      frame_size_(0),
236      resolution_changed_(false) {
237  capturer->SignalStateChange.connect(this,
238      &VideoCapturerListener::OnStateChange);
239  capturer->SignalFrameCaptured.connect(this,
240      &VideoCapturerListener::OnFrameCaptured);
241}
242
243void VideoCapturerListener::OnStateChange(VideoCapturer* capturer,
244                                          CaptureState result) {
245  last_capture_state_ = result;
246}
247
248void VideoCapturerListener::OnFrameCaptured(VideoCapturer* capturer,
249                                            const CapturedFrame* frame) {
250  ++frame_count_;
251  if (1 == frame_count_) {
252    frame_fourcc_ = frame->fourcc;
253    frame_width_ = frame->width;
254    frame_height_ = frame->height;
255    frame_size_ = frame->data_size;
256  } else if (frame_width_ != frame->width || frame_height_ != frame->height) {
257    resolution_changed_ = true;
258  }
259}
260
261// Returns the absolute path to a file in the testdata/ directory.
262std::string GetTestFilePath(const std::string& filename) {
263  // Locate test data directory.
264#ifdef ENABLE_WEBRTC
265  rtc::Pathname path = rtc::GetExecutablePath();
266  EXPECT_FALSE(path.empty());
267  path.AppendPathname("../../talk/");
268#else
269  rtc::Pathname path = testing::GetTalkDirectory();
270  EXPECT_FALSE(path.empty());  // must be run from inside "talk"
271#endif
272  path.AppendFolder("media/testdata/");
273  path.SetFilename(filename);
274  return path.pathname();
275}
276
277// Loads the image with the specified prefix and size into |out|.
278bool LoadPlanarYuvTestImage(const std::string& prefix,
279                            int width,
280                            int height,
281                            uint8_t* out) {
282  std::stringstream ss;
283  ss << prefix << "." << width << "x" << height << "_P420.yuv";
284
285  rtc::scoped_ptr<rtc::FileStream> stream(
286      rtc::Filesystem::OpenFile(rtc::Pathname(
287          GetTestFilePath(ss.str())), "rb"));
288  if (!stream) {
289    return false;
290  }
291
292  rtc::StreamResult res =
293      stream->ReadAll(out, I420_SIZE(width, height), NULL, NULL);
294  return (res == rtc::SR_SUCCESS);
295}
296
297// Dumps the YUV image out to a file, for visual inspection.
298// PYUV tool can be used to view dump files.
299void DumpPlanarYuvTestImage(const std::string& prefix,
300                            const uint8_t* img,
301                            int w,
302                            int h) {
303  rtc::FileStream fs;
304  char filename[256];
305  rtc::sprintfn(filename, sizeof(filename), "%s.%dx%d_P420.yuv",
306                      prefix.c_str(), w, h);
307  fs.Open(filename, "wb", NULL);
308  fs.Write(img, I420_SIZE(w, h), NULL, NULL);
309}
310
311// Dumps the ARGB image out to a file, for visual inspection.
312// ffplay tool can be used to view dump files.
313void DumpPlanarArgbTestImage(const std::string& prefix,
314                             const uint8_t* img,
315                             int w,
316                             int h) {
317  rtc::FileStream fs;
318  char filename[256];
319  rtc::sprintfn(filename, sizeof(filename), "%s.%dx%d_ARGB.raw",
320                      prefix.c_str(), w, h);
321  fs.Open(filename, "wb", NULL);
322  fs.Write(img, ARGB_SIZE(w, h), NULL, NULL);
323}
324
325bool VideoFrameEqual(const VideoFrame* frame0, const VideoFrame* frame1) {
326  const uint8_t* y0 = frame0->GetYPlane();
327  const uint8_t* u0 = frame0->GetUPlane();
328  const uint8_t* v0 = frame0->GetVPlane();
329  const uint8_t* y1 = frame1->GetYPlane();
330  const uint8_t* u1 = frame1->GetUPlane();
331  const uint8_t* v1 = frame1->GetVPlane();
332
333  for (size_t i = 0; i < frame0->GetHeight(); ++i) {
334    if (0 != memcmp(y0, y1, frame0->GetWidth())) {
335      return false;
336    }
337    y0 += frame0->GetYPitch();
338    y1 += frame1->GetYPitch();
339  }
340
341  for (size_t i = 0; i < frame0->GetChromaHeight(); ++i) {
342    if (0 != memcmp(u0, u1, frame0->GetChromaWidth())) {
343      return false;
344    }
345    if (0 != memcmp(v0, v1, frame0->GetChromaWidth())) {
346      return false;
347    }
348    u0 += frame0->GetUPitch();
349    v0 += frame0->GetVPitch();
350    u1 += frame1->GetUPitch();
351    v1 += frame1->GetVPitch();
352  }
353
354  return true;
355}
356
357cricket::StreamParams CreateSimStreamParams(
358    const std::string& cname,
359    const std::vector<uint32_t>& ssrcs) {
360  cricket::StreamParams sp;
361  cricket::SsrcGroup sg(cricket::kSimSsrcGroupSemantics, ssrcs);
362  sp.ssrcs = ssrcs;
363  sp.ssrc_groups.push_back(sg);
364  sp.cname = cname;
365  return sp;
366}
367
368// There should be an rtx_ssrc per ssrc.
369cricket::StreamParams CreateSimWithRtxStreamParams(
370    const std::string& cname,
371    const std::vector<uint32_t>& ssrcs,
372    const std::vector<uint32_t>& rtx_ssrcs) {
373  cricket::StreamParams sp = CreateSimStreamParams(cname, ssrcs);
374  for (size_t i = 0; i < ssrcs.size(); ++i) {
375    sp.ssrcs.push_back(rtx_ssrcs[i]);
376    std::vector<uint32_t> fid_ssrcs;
377    fid_ssrcs.push_back(ssrcs[i]);
378    fid_ssrcs.push_back(rtx_ssrcs[i]);
379    cricket::SsrcGroup fid_group(cricket::kFidSsrcGroupSemantics, fid_ssrcs);
380    sp.ssrc_groups.push_back(fid_group);
381  }
382  return sp;
383}
384
385}  // namespace cricket
386