139 lines
4.3 KiB
C++
139 lines
4.3 KiB
C++
// Copyright 2014 Google Inc. All rights reserved.
|
|
//
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file or at
|
|
// https://developers.google.com/open-source/licenses/bsd
|
|
|
|
#include "packager/app/mpd_generator_flags.h"
|
|
#include "packager/app/vlog_flags.h"
|
|
#include "packager/base/at_exit.h"
|
|
#include "packager/base/command_line.h"
|
|
#include "packager/base/logging.h"
|
|
#include "packager/base/strings/string_split.h"
|
|
#include "packager/base/strings/stringprintf.h"
|
|
#include "packager/mpd/util/mpd_writer.h"
|
|
#include "packager/version/version.h"
|
|
|
|
#if defined(OS_WIN)
|
|
#include <codecvt>
|
|
#include <functional>
|
|
#include <locale>
|
|
#endif // defined(OS_WIN)
|
|
|
|
namespace shaka {
|
|
namespace {
|
|
const char kUsage[] =
|
|
"MPD generation driver program.\n"
|
|
"This program accepts MediaInfo files in human readable text "
|
|
"format and outputs an MPD.\n"
|
|
"The main use case for this is to output MPD for VOD.\n"
|
|
"Limitations:\n"
|
|
" Each MediaInfo can only have one of VideoInfo, AudioInfo, or TextInfo.\n"
|
|
" There will be at most 3 AdaptationSets in the MPD, i.e. 1 video, 1 "
|
|
"audio, and 1 text.\n"
|
|
"Sample Usage:\n"
|
|
"%s --input=\"video1.media_info,video2.media_info,audio1.media_info\" "
|
|
"--output=\"video_audio.mpd\"";
|
|
|
|
enum ExitStatus {
|
|
kSuccess = 0,
|
|
kEmptyInputError,
|
|
kEmptyOutputError,
|
|
kFailedToWriteMpdToFileError
|
|
};
|
|
|
|
ExitStatus CheckRequiredFlags() {
|
|
if (FLAGS_input.empty()) {
|
|
LOG(ERROR) << "--input is required.";
|
|
return kEmptyInputError;
|
|
}
|
|
|
|
if (FLAGS_output.empty()) {
|
|
LOG(ERROR) << "--output is required.";
|
|
return kEmptyOutputError;
|
|
}
|
|
|
|
return kSuccess;
|
|
}
|
|
|
|
ExitStatus RunMpdGenerator() {
|
|
DCHECK_EQ(CheckRequiredFlags(), kSuccess);
|
|
std::vector<std::string> base_urls;
|
|
typedef std::vector<std::string>::const_iterator Iterator;
|
|
|
|
std::vector<std::string> input_files = base::SplitString(
|
|
FLAGS_input, ",", base::KEEP_WHITESPACE, base::SPLIT_WANT_ALL);
|
|
|
|
if (!FLAGS_base_urls.empty()) {
|
|
base_urls = base::SplitString(FLAGS_base_urls, ",", base::KEEP_WHITESPACE,
|
|
base::SPLIT_WANT_ALL);
|
|
}
|
|
|
|
MpdWriter mpd_writer;
|
|
for (Iterator it = base_urls.begin(); it != base_urls.end(); ++it)
|
|
mpd_writer.AddBaseUrl(*it);
|
|
|
|
for (Iterator it = input_files.begin(); it != input_files.end(); ++it) {
|
|
if (!mpd_writer.AddFile(it->c_str(), FLAGS_output)) {
|
|
LOG(WARNING) << "MpdWriter failed to read " << *it << ", skipping.";
|
|
}
|
|
}
|
|
|
|
if (!mpd_writer.WriteMpdToFile(FLAGS_output.c_str())) {
|
|
LOG(ERROR) << "Failed to write MPD to " << FLAGS_output;
|
|
return kFailedToWriteMpdToFileError;
|
|
}
|
|
|
|
return kSuccess;
|
|
}
|
|
|
|
int MpdMain(int argc, char** argv) {
|
|
base::AtExitManager exit;
|
|
// Needed to enable VLOG/DVLOG through --vmodule or --v.
|
|
base::CommandLine::Init(argc, argv);
|
|
CHECK(logging::InitLogging(logging::LoggingSettings()));
|
|
|
|
google::SetUsageMessage(base::StringPrintf(kUsage, argv[0]));
|
|
google::ParseCommandLineFlags(&argc, &argv, true);
|
|
|
|
ExitStatus status = CheckRequiredFlags();
|
|
if (status != kSuccess) {
|
|
const std::string version_string = base::StringPrintf(
|
|
"mpd_generator version %s", GetPackagerVersion().c_str());
|
|
google::ShowUsageWithFlags(version_string.c_str());
|
|
return status;
|
|
}
|
|
|
|
return RunMpdGenerator();
|
|
}
|
|
|
|
} // namespace
|
|
} // namespace shaka
|
|
|
|
#if defined(OS_WIN)
|
|
// Windows wmain, which converts wide character arguments to UTF-8.
|
|
int wmain(int argc, wchar_t* argv[], wchar_t* envp[]) {
|
|
std::unique_ptr<char* [], std::function<void(char**)>> utf8_argv(
|
|
new char*[argc], [argc](char** utf8_args) {
|
|
// TODO(tinskip): This leaks, but if this code is enabled, it crashes.
|
|
// Figure out why. I suspect gflags does something funny with the
|
|
// argument array.
|
|
// for (int idx = 0; idx < argc; ++idx)
|
|
// delete[] utf8_args[idx];
|
|
delete[] utf8_args;
|
|
});
|
|
std::wstring_convert<std::codecvt_utf8<wchar_t>> converter;
|
|
for (int idx = 0; idx < argc; ++idx) {
|
|
std::string utf8_arg(converter.to_bytes(argv[idx]));
|
|
utf8_arg += '\0';
|
|
utf8_argv[idx] = new char[utf8_arg.size()];
|
|
memcpy(utf8_argv[idx], &utf8_arg[0], utf8_arg.size());
|
|
}
|
|
return shaka::MpdMain(argc, utf8_argv.get());
|
|
}
|
|
#else
|
|
int main(int argc, char** argv) {
|
|
return shaka::MpdMain(argc, argv);
|
|
}
|
|
#endif // !defined(OS_WIN)
|