(61d00a474) v0.9.7.1

2020-03-04 13:04:10 +01:00
parent 3c50efa5c9
commit 3c09ebe02f
5086 changed files with 786063 additions and 295871 deletions
@@ -0,0 +1,391 @@
+// Copyright (c) 2012 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.
+//
+// This sample application demonstrates how to use the matroska parser
+// library, which allows clients to handle a matroska format file.
+
+#include "sample_muxer_metadata.h"
+
+#include <cstdio>
+#include <string>
+
+#include "mkvmuxer/mkvmuxer.h"
+#include "webvtt/vttreader.h"
+
+SampleMuxerMetadata::SampleMuxerMetadata() : segment_(NULL) {}
+
+bool SampleMuxerMetadata::Init(mkvmuxer::Segment* segment) {
+  if (segment == NULL || segment_ != NULL)
+    return false;
+
+  segment_ = segment;
+  return true;
+}
+
+bool SampleMuxerMetadata::Load(const char* file, Kind kind) {
+  if (kind == kChapters)
+    return LoadChapters(file);
+
+  uint64_t track_num;
+
+  if (!AddTrack(kind, &track_num)) {
+    printf("Unable to add track for WebVTT file \"%s\"\n", file);
+    return false;
+  }
+
+  return Parse(file, kind, track_num);
+}
+
+bool SampleMuxerMetadata::AddChapters() {
+  typedef cue_list_t::const_iterator iter_t;
+  iter_t i = chapter_cues_.begin();
+  const iter_t j = chapter_cues_.end();
+
+  while (i != j) {
+    const cue_t& chapter = *i++;
+
+    if (!AddChapter(chapter))
+      return false;
+  }
+
+  return true;
+}
+
+bool SampleMuxerMetadata::Write(int64_t time_ns) {
+  typedef cues_set_t::iterator iter_t;
+
+  iter_t i = cues_set_.begin();
+  const iter_t j = cues_set_.end();
+
+  while (i != j) {
+    const cues_set_t::value_type& v = *i;
+
+    if (time_ns >= 0 && v > time_ns)
+      return true;  // nothing else to do just yet
+
+    if (!v.Write(segment_)) {
+      printf("\nCould not add metadata.\n");
+      return false;  // error
+    }
+
+    cues_set_.erase(i++);
+  }
+
+  return true;
+}
+
+bool SampleMuxerMetadata::LoadChapters(const char* file) {
+  if (!chapter_cues_.empty()) {
+    printf("Support for more than one chapters file is not yet implemented\n");
+    return false;
+  }
+
+  cue_list_t cues;
+
+  if (!ParseChapters(file, &cues))
+    return false;
+
+  // TODO(matthewjheaney): support more than one chapters file
+  chapter_cues_.swap(cues);
+
+  return true;
+}
+
+bool SampleMuxerMetadata::ParseChapters(const char* file,
+                                        cue_list_t* cues_ptr) {
+  cue_list_t& cues = *cues_ptr;
+  cues.clear();
+
+  libwebvtt::VttReader r;
+  int e = r.Open(file);
+
+  if (e) {
+    printf("Unable to open WebVTT file: \"%s\"\n", file);
+    return false;
+  }
+
+  libwebvtt::Parser p(&r);
+  e = p.Init();
+
+  if (e < 0) {  // error
+    printf("Error parsing WebVTT file: \"%s\"\n", file);
+    return false;
+  }
+
+  libwebvtt::Time t;
+  t.hours = -1;
+
+  for (;;) {
+    cue_t c;
+    e = p.Parse(&c);
+
+    if (e < 0) {  // error
+      printf("Error parsing WebVTT file: \"%s\"\n", file);
+      return false;
+    }
+
+    if (e > 0)  // EOF
+      return true;
+
+    if (c.start_time < t) {
+      printf("bad WebVTT cue timestamp (out-of-order)\n");
+      return false;
+    }
+
+    if (c.stop_time < c.start_time) {
+      printf("bad WebVTT cue timestamp (stop < start)\n");
+      return false;
+    }
+
+    t = c.start_time;
+    cues.push_back(c);
+  }
+}
+
+bool SampleMuxerMetadata::AddChapter(const cue_t& cue) {
+  // TODO(matthewjheaney): support language and country
+
+  mkvmuxer::Chapter* const chapter = segment_->AddChapter();
+
+  if (chapter == NULL) {
+    printf("Unable to add chapter\n");
+    return false;
+  }
+
+  if (cue.identifier.empty()) {
+    chapter->set_id(NULL);
+  } else {
+    const char* const id = cue.identifier.c_str();
+    if (!chapter->set_id(id)) {
+      printf("Unable to set chapter id\n");
+      return false;
+    }
+  }
+
+  typedef libwebvtt::presentation_t time_ms_t;
+  const time_ms_t start_time_ms = cue.start_time.presentation();
+  const time_ms_t stop_time_ms = cue.stop_time.presentation();
+
+  enum { kNsPerMs = 1000000 };
+  const uint64_t start_time_ns = start_time_ms * kNsPerMs;
+  const uint64_t stop_time_ns = stop_time_ms * kNsPerMs;
+
+  chapter->set_time(*segment_, start_time_ns, stop_time_ns);
+
+  typedef libwebvtt::Cue::payload_t::const_iterator iter_t;
+  iter_t i = cue.payload.begin();
+  const iter_t j = cue.payload.end();
+
+  std::string title;
+
+  for (;;) {
+    title += *i++;
+
+    if (i == j)
+      break;
+
+    enum { kLF = '\x0A' };
+    title += kLF;
+  }
+
+  if (!chapter->add_string(title.c_str(), NULL, NULL)) {
+    printf("Unable to set chapter title\n");
+    return false;
+  }
+
+  return true;
+}
+
+bool SampleMuxerMetadata::AddTrack(Kind kind, uint64_t* track_num) {
+  *track_num = 0;
+
+  // Track number value 0 means "let muxer choose track number"
+  mkvmuxer::Track* const track = segment_->AddTrack(0);
+
+  if (track == NULL)  // error
+    return false;
+
+  // Return the track number value chosen by the muxer
+  *track_num = track->number();
+
+  int type;
+  const char* codec_id;
+
+  switch (kind) {
+    case kSubtitles:
+      type = 0x11;
+      codec_id = "D_WEBVTT/SUBTITLES";
+      break;
+
+    case kCaptions:
+      type = 0x11;
+      codec_id = "D_WEBVTT/CAPTIONS";
+      break;
+
+    case kDescriptions:
+      type = 0x21;
+      codec_id = "D_WEBVTT/DESCRIPTIONS";
+      break;
+
+    case kMetadata:
+      type = 0x21;
+      codec_id = "D_WEBVTT/METADATA";
+      break;
+
+    default:
+      return false;
+  }
+
+  track->set_type(type);
+  track->set_codec_id(codec_id);
+
+  // TODO(matthewjheaney): set name and language
+
+  return true;
+}
+
+bool SampleMuxerMetadata::Parse(const char* file, Kind /* kind */,
+                                uint64_t track_num) {
+  libwebvtt::VttReader r;
+  int e = r.Open(file);
+
+  if (e) {
+    printf("Unable to open WebVTT file: \"%s\"\n", file);
+    return false;
+  }
+
+  libwebvtt::Parser p(&r);
+
+  e = p.Init();
+
+  if (e < 0) {  // error
+    printf("Error parsing WebVTT file: \"%s\"\n", file);
+    return false;
+  }
+
+  SortableCue cue;
+  cue.track_num = track_num;
+
+  libwebvtt::Time t;
+  t.hours = -1;
+
+  for (;;) {
+    cue_t& c = cue.cue;
+    e = p.Parse(&c);
+
+    if (e < 0) {  // error
+      printf("Error parsing WebVTT file: \"%s\"\n", file);
+      return false;
+    }
+
+    if (e > 0)  // EOF
+      return true;
+
+    if (c.start_time >= t) {
+      t = c.start_time;
+    } else {
+      printf("bad WebVTT cue timestamp (out-of-order)\n");
+      return false;
+    }
+
+    if (c.stop_time < c.start_time) {
+      printf("bad WebVTT cue timestamp (stop < start)\n");
+      return false;
+    }
+
+    cues_set_.insert(cue);
+  }
+}
+
+void SampleMuxerMetadata::MakeFrame(const cue_t& c, std::string* pf) {
+  pf->clear();
+  WriteCueIdentifier(c.identifier, pf);
+  WriteCueSettings(c.settings, pf);
+  WriteCuePayload(c.payload, pf);
+}
+
+void SampleMuxerMetadata::WriteCueIdentifier(const std::string& identifier,
+                                             std::string* pf) {
+  pf->append(identifier);
+  pf->push_back('\x0A');  // LF
+}
+
+void SampleMuxerMetadata::WriteCueSettings(const cue_t::settings_t& settings,
+                                           std::string* pf) {
+  if (settings.empty()) {
+    pf->push_back('\x0A');  // LF
+    return;
+  }
+
+  typedef cue_t::settings_t::const_iterator iter_t;
+
+  iter_t i = settings.begin();
+  const iter_t j = settings.end();
+
+  for (;;) {
+    const libwebvtt::Setting& setting = *i++;
+
+    pf->append(setting.name);
+    pf->push_back(':');
+    pf->append(setting.value);
+
+    if (i == j)
+      break;
+
+    pf->push_back(' ');  // separate settings with whitespace
+  }
+
+  pf->push_back('\x0A');  // LF
+}
+
+void SampleMuxerMetadata::WriteCuePayload(const cue_t::payload_t& payload,
+                                          std::string* pf) {
+  typedef cue_t::payload_t::const_iterator iter_t;
+
+  iter_t i = payload.begin();
+  const iter_t j = payload.end();
+
+  while (i != j) {
+    const std::string& line = *i++;
+    pf->append(line);
+    pf->push_back('\x0A');  // LF
+  }
+}
+
+bool SampleMuxerMetadata::SortableCue::Write(mkvmuxer::Segment* segment) const {
+  // Cue start time expressed in milliseconds
+  const int64_t start_ms = cue.start_time.presentation();
+
+  // Cue start time expressed in nanoseconds (MKV time)
+  const int64_t start_ns = start_ms * 1000000;
+
+  // Cue stop time expressed in milliseconds
+  const int64_t stop_ms = cue.stop_time.presentation();
+
+  // Cue stop time expressed in nanonseconds
+  const int64_t stop_ns = stop_ms * 1000000;
+
+  // Metadata blocks always specify the block duration.
+  const int64_t duration_ns = stop_ns - start_ns;
+
+  std::string frame;
+  MakeFrame(cue, &frame);
+
+  typedef const uint8_t* data_t;
+  const data_t buf = reinterpret_cast<data_t>(frame.data());
+  const uint64_t len = frame.length();
+
+  mkvmuxer::Frame muxer_frame;
+  if (!muxer_frame.Init(buf, len))
+    return 0;
+  muxer_frame.set_track_number(track_num);
+  muxer_frame.set_timestamp(start_ns);
+  muxer_frame.set_duration(duration_ns);
+  muxer_frame.set_is_key(true);  // All metadata frames are keyframes.
+  return segment->AddGenericFrame(&muxer_frame);
+}