(61d00a474) v0.9.7.1

Libraries/webm_mem_playback/libwebm/testing/test_util.cc

@@ -0,0 +1,215 @@
+// Copyright (c) 2016 The WebM 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 "testing/test_util.h"
+
+#include <cstdint>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <ios>
+#include <string>
+
+#include "common/libwebm_util.h"
+#include "common/webmids.h"
+
+#include "mkvparser/mkvparser.h"
+#include "mkvparser/mkvreader.h"
+
+namespace test {
+
+std::string GetTestDataDir() {
+  const char* test_data_path = std::getenv("LIBWEBM_TEST_DATA_PATH");
+  return test_data_path ? std::string(test_data_path) : std::string();
+}
+
+std::string GetTestFilePath(const std::string& name) {
+  const std::string libwebm_testdata_dir = GetTestDataDir();
+  return libwebm_testdata_dir + "/" + name;
+}
+
+bool CompareFiles(const std::string& file1, const std::string& file2) {
+  const std::size_t kBlockSize = 4096;
+  std::uint8_t buf1[kBlockSize] = {0};
+  std::uint8_t buf2[kBlockSize] = {0};
+
+  libwebm::FilePtr f1 =
+      libwebm::FilePtr(std::fopen(file1.c_str(), "rb"), libwebm::FILEDeleter());
+  libwebm::FilePtr f2 =
+      libwebm::FilePtr(std::fopen(file2.c_str(), "rb"), libwebm::FILEDeleter());
+
+  if (!f1.get() || !f2.get()) {
+    // Files cannot match if one or both couldn't be opened.
+    return false;
+  }
+
+  do {
+    const std::size_t r1 = std::fread(buf1, 1, kBlockSize, f1.get());
+    const std::size_t r2 = std::fread(buf2, 1, kBlockSize, f2.get());
+
+    // TODO(fgalligan): Add output of which byte differs.
+    if (r1 != r2 || std::memcmp(buf1, buf2, r1)) {
+      return 0;  // Files are not equal
+    }
+  } while (!std::feof(f1.get()) && !std::feof(f2.get()));
+
+  return std::feof(f1.get()) && std::feof(f2.get());
+}
+
+bool HasCuePoints(const mkvparser::Segment* segment,
+                  std::int64_t* cues_offset) {
+  if (!segment || !cues_offset) {
+    return false;
+  }
+  using mkvparser::SeekHead;
+  const SeekHead* const seek_head = segment->GetSeekHead();
+  if (!seek_head) {
+    return false;
+  }
+
+  std::int64_t offset = 0;
+  for (int i = 0; i < seek_head->GetCount(); ++i) {
+    const SeekHead::Entry* const entry = seek_head->GetEntry(i);
+    if (entry->id == libwebm::kMkvCues) {
+      offset = entry->pos;
+    }
+  }
+
+  if (offset <= 0) {
+    // No Cues found.
+    return false;
+  }
+
+  *cues_offset = offset;
+  return true;
+}
+
+bool ValidateCues(mkvparser::Segment* segment, mkvparser::IMkvReader* reader) {
+  if (!segment) {
+    return false;
+  }
+
+  std::int64_t cues_offset = 0;
+  if (!HasCuePoints(segment, &cues_offset)) {
+    // No cues to validate, everything is OK.
+    return true;
+  }
+
+  // Parse Cues.
+  long long cues_pos = 0;  // NOLINT
+  long cues_len = 0;  // NOLINT
+  if (segment->ParseCues(cues_offset, cues_pos, cues_len)) {
+    return false;
+  }
+
+  // Get a pointer to the video track if it exists. Otherwise, we assume
+  // that Cues are based on the first track (which is true for all our test
+  // files).
+  const mkvparser::Tracks* const tracks = segment->GetTracks();
+  const mkvparser::Track* cues_track = tracks->GetTrackByIndex(0);
+  for (int i = 1; i < static_cast<int>(tracks->GetTracksCount()); ++i) {
+    const mkvparser::Track* const track = tracks->GetTrackByIndex(i);
+    if (track->GetType() == mkvparser::Track::kVideo) {
+      cues_track = track;
+      break;
+    }
+  }
+
+  // Iterate through Cues and verify if they are pointing to the correct
+  // Cluster position.
+  const mkvparser::Cues* const cues = segment->GetCues();
+  const mkvparser::CuePoint* cue_point = NULL;
+  while (cues->LoadCuePoint()) {
+    if (!cue_point) {
+      cue_point = cues->GetFirst();
+    } else {
+      cue_point = cues->GetNext(cue_point);
+    }
+    const mkvparser::CuePoint::TrackPosition* const track_position =
+        cue_point->Find(cues_track);
+    const long long cluster_pos = track_position->m_pos +  // NOLINT
+                                  segment->m_start;
+
+    // If a cluster does not begin at |cluster_pos|, then the file is
+    // incorrect.
+    long length;  // NOLINT
+    const std::int64_t id = mkvparser::ReadID(reader, cluster_pos, length);
+    if (id != libwebm::kMkvCluster) {
+      return false;
+    }
+  }
+  return true;
+}
+
+MkvParser::~MkvParser() {
+  delete segment;
+  delete reader;
+}
+
+bool ParseMkvFileReleaseParser(const std::string& webm_file,
+                               MkvParser* parser_out) {
+  parser_out->reader = new (std::nothrow) mkvparser::MkvReader;
+  mkvparser::MkvReader& reader = *parser_out->reader;
+  if (!parser_out->reader || reader.Open(webm_file.c_str()) < 0) {
+    return false;
+  }
+
+  long long pos = 0;  // NOLINT
+  mkvparser::EBMLHeader ebml_header;
+  if (ebml_header.Parse(&reader, pos)) {
+    return false;
+  }
+
+  using mkvparser::Segment;
+  Segment* segment_ptr = nullptr;
+  if (Segment::CreateInstance(&reader, pos, segment_ptr)) {
+    return false;
+  }
+
+  std::unique_ptr<Segment> segment(segment_ptr);
+  long result;
+  if ((result = segment->Load()) < 0) {
+    return false;
+  }
+
+  const mkvparser::Cluster* cluster = segment->GetFirst();
+  if (!cluster || cluster->EOS()) {
+    return false;
+  }
+
+  while (cluster && cluster->EOS() == false) {
+    if (cluster->GetTimeCode() < 0) {
+      return false;
+    }
+
+    const mkvparser::BlockEntry* block = nullptr;
+    if (cluster->GetFirst(block) < 0) {
+      return false;
+    }
+
+    while (block != NULL && block->EOS() == false) {
+      if (cluster->GetNext(block, block) < 0) {
+        return false;
+      }
+    }
+
+    cluster = segment->GetNext(cluster);
+  }
+
+  parser_out->segment = segment.release();
+  return true;
+}
+
+bool ParseMkvFile(const std::string& webm_file) {
+  MkvParser parser;
+  const bool result = ParseMkvFileReleaseParser(webm_file, &parser);
+  delete parser.segment;
+  delete parser.reader;
+  return result;
+}
+
+}  // namespace test