gcc_pure
bool IsAbsolute() const {
return Path(*this).IsAbsolute();
}
//---------------------------------------------------------------------------
bool __fastcall TFileZillaIntf::MakeDir(const wchar_t* APath)
{
DebugAssert(FFileZillaApi != NULL);
CServerPath Path(APath);
return Check(FFileZillaApi->MakeDir(Path), L"makedir");
}
//---------------------------------------------------------------------------
bool __fastcall TFileZillaIntf::ListFile(const wchar_t * FileName, const wchar_t * APath)
{
DebugAssert(FFileZillaApi != NULL);
CServerPath Path(APath);
return Check(FFileZillaApi->ListFile(FileName, Path), L"listfile");
}
Path System::GetUserDir()
{
struct passwd* pw = getpwuid(getuid());
return Path(pw->pw_dir);
}
void AnimationCache::_update_cache() {
cache_valid = false;
ERR_FAIL_COND(!root);
ERR_FAIL_COND(!root->is_inside_tree());
ERR_FAIL_COND(animation.is_null());
for (int i = 0; i < animation->get_track_count(); i++) {
NodePath np = animation->track_get_path(i);
Node *node = root->get_node(np);
if (!node) {
path_cache.push_back(Path());
ERR_EXPLAIN("Invalid Track Path in Animation: " + np);
ERR_CONTINUE(!node);
}
Path path;
Ref<Resource> res;
if (animation->track_get_type(i) == Animation::TYPE_TRANSFORM) {
if (np.get_subname_count() > 1) {
path_cache.push_back(Path());
ERR_EXPLAIN("Transform tracks can't have a subpath: " + np);
ERR_CONTINUE(animation->track_get_type(i) == Animation::TYPE_TRANSFORM);
}
Spatial *sp = Object::cast_to<Spatial>(node);
if (!sp) {
path_cache.push_back(Path());
ERR_EXPLAIN("Transform track not of type Spatial: " + np);
ERR_CONTINUE(!sp);
}
if (np.get_subname_count() == 1) {
StringName property = np.get_subname(0);
String ps = property;
Skeleton *sk = Object::cast_to<Skeleton>(node);
if (!sk) {
path_cache.push_back(Path());
ERR_EXPLAIN("Property defined in Transform track, but not a Skeleton!: " + np);
ERR_CONTINUE(!sk);
}
int idx = sk->find_bone(ps);
if (idx == -1) {
path_cache.push_back(Path());
ERR_EXPLAIN("Property defined in Transform track, but not a Skeleton Bone!: " + np);
ERR_CONTINUE(idx == -1);
}
path.bone_idx = idx;
path.skeleton = sk;
}
path.spatial = sp;
} else {
if (np.get_subname_count() > 0) {
RES res2;
Vector<StringName> leftover_subpath;
// We don't want to cache the last resource unless it is a method call
bool is_method = animation->track_get_type(i) == Animation::TYPE_METHOD;
root->get_node_and_resource(np, res2, leftover_subpath, is_method);
if (res2.is_valid()) {
path.resource = res2;
} else {
path.node = node;
}
path.object = res2.is_valid() ? res2.ptr() : (Object *)node;
path.subpath = leftover_subpath;
} else {
path.node = node;
path.object = node;
path.subpath = np.get_subnames();
}
}
if (animation->track_get_type(i) == Animation::TYPE_VALUE) {
if (np.get_subname_count() == 0) {
path_cache.push_back(Path());
ERR_EXPLAIN("Value Track lacks property: " + np);
ERR_CONTINUE(np.get_subname_count() == 0);
}
} else if (animation->track_get_type(i) == Animation::TYPE_METHOD) {
if (path.subpath.size() != 0) { // Trying to call a method of a non-resource
path_cache.push_back(Path());
ERR_EXPLAIN("Method Track has property: " + np);
ERR_CONTINUE(path.subpath.size() != 0);
}
}
path.valid = true;
path_cache.push_back(path);
if (!connected_nodes.has(path.node)) {
connected_nodes.insert(path.node);
path.node->connect("tree_exiting", this, "_node_exit_tree", Node::make_binds(path.node), CONNECT_ONESHOT);
}
}
cache_dirty = false;
cache_valid = true;
}
/**
* "Boots" up XCSoar
* @param hInstance Instance handle
* @param lpCmdLine Command line string
* @return True if bootup successful, False otherwise
*/
bool
Startup()
{
VerboseOperationEnvironment operation;
#ifdef HAVE_DOWNLOAD_MANAGER
Net::DownloadManager::Initialise();
#endif
LogFormat("Display dpi=%u,%u", Display::GetXDPI(), Display::GetYDPI());
// Creates the main window
TopWindowStyle style;
if (CommandLine::full_screen)
style.FullScreen();
style.Resizable();
MainWindow *const main_window = CommonInterface::main_window =
new MainWindow();
main_window->Create(SystemWindowSize(), style);
if (!main_window->IsDefined())
return false;
#ifdef ENABLE_OPENGL
LogFormat("OpenGL: "
#ifdef ANDROID
#ifdef USE_EGL
"egl=native "
#else
"egl=no "
#endif
#endif
#ifdef HAVE_OES_DRAW_TEXTURE
"oesdt=%d "
#endif
#ifdef HAVE_DYNAMIC_MULTI_DRAW_ARRAYS
"mda=%d "
#endif
"npot=%d vbo=%d fbo=%d stencil=%#x",
#ifdef HAVE_OES_DRAW_TEXTURE
OpenGL::oes_draw_texture,
#endif
#ifdef HAVE_DYNAMIC_MULTI_DRAW_ARRAYS
GLExt::HaveMultiDrawElements(),
#endif
OpenGL::texture_non_power_of_two,
OpenGL::vertex_buffer_object,
OpenGL::frame_buffer_object,
OpenGL::render_buffer_stencil);
#endif
CommonInterface::SetUISettings().SetDefaults();
main_window->Initialise();
#ifdef SIMULATOR_AVAILABLE
// prompt for simulator if not set by command line argument "-simulator" or "-fly"
if (!sim_set_in_cmd_line_flag) {
SimulatorPromptResult result = dlgSimulatorPromptShowModal();
switch (result) {
case SPR_QUIT:
return false;
case SPR_FLY:
global_simulator_flag = false;
break;
case SPR_SIMULATOR:
global_simulator_flag = true;
break;
}
}
#endif
CommonInterface::SetSystemSettings().SetDefaults();
CommonInterface::SetComputerSettings().SetDefaults();
CommonInterface::SetUIState().Clear();
const auto &computer_settings = CommonInterface::GetComputerSettings();
const auto &ui_settings = CommonInterface::GetUISettings();
auto &live_blackboard = CommonInterface::GetLiveBlackboard();
if (!LoadProfile())
return false;
operation.SetText(_("Initialising"));
/* create XCSoarData on the first start */
CreateDataPath();
Display::LoadOrientation(operation);
main_window->CheckResize();
main_window->InitialiseConfigured();
{
file_cache = new FileCache(LocalPath(_T("cache")));
}
ReadLanguageFile();
InputEvents::readFile();
// Initialize DeviceBlackboard
device_blackboard = new DeviceBlackboard();
devices = new MultipleDevices();
device_blackboard->SetDevices(*devices);
// Initialize main blackboard data
task_events = new GlideComputerTaskEvents();
task_manager = new TaskManager(computer_settings.task, way_points);
task_manager->SetTaskEvents(*task_events);
task_manager->Reset();
protected_task_manager =
new ProtectedTaskManager(*task_manager, computer_settings.task);
// Read the terrain file
operation.SetText(_("Loading Terrain File..."));
LogFormat("OpenTerrain");
terrain = RasterTerrain::OpenTerrain(file_cache, operation);
logger = new Logger();
glide_computer = new GlideComputer(way_points, airspace_database,
*protected_task_manager,
*task_events);
glide_computer->ReadComputerSettings(computer_settings);
glide_computer->SetTerrain(terrain);
glide_computer->SetLogger(logger);
glide_computer->Initialise();
replay = new Replay(logger, *protected_task_manager);
#ifdef HAVE_CMDLINE_REPLAY
if (CommandLine::replay_path != nullptr) {
Error error;
if (!replay->Start(Path(CommandLine::replay_path), error))
LogError(error);
}
#endif
GlidePolar &gp = CommonInterface::SetComputerSettings().polar.glide_polar_task;
gp = GlidePolar(fixed(0));
gp.SetMC(computer_settings.task.safety_mc);
gp.SetBugs(computer_settings.polar.degradation_factor);
PlaneGlue::FromProfile(CommonInterface::SetComputerSettings().plane,
Profile::map);
PlaneGlue::Synchronize(computer_settings.plane,
CommonInterface::SetComputerSettings(), gp);
task_manager->SetGlidePolar(gp);
// Read the topography file(s)
topography = new TopographyStore();
LoadConfiguredTopography(*topography, operation);
// Read the waypoint files
WaypointGlue::LoadWaypoints(way_points, terrain, operation);
// Read and parse the airfield info file
WaypointDetails::ReadFileFromProfile(way_points, operation);
// Set the home waypoint
WaypointGlue::SetHome(way_points, terrain,
CommonInterface::SetComputerSettings().poi,
CommonInterface::SetComputerSettings().team_code,
device_blackboard, false);
// ReSynchronise the blackboards here since SetHome touches them
device_blackboard->Merge();
CommonInterface::ReadBlackboardBasic(device_blackboard->Basic());
// Scan for weather forecast
LogFormat("RASP load");
rasp = new RaspStore();
rasp->ScanAll();
// Reads the airspace files
ReadAirspace(airspace_database, terrain, computer_settings.pressure,
operation);
{
const AircraftState aircraft_state =
ToAircraftState(device_blackboard->Basic(),
device_blackboard->Calculated());
ProtectedAirspaceWarningManager::ExclusiveLease lease(glide_computer->GetAirspaceWarnings());
lease->Reset(aircraft_state);
}
#ifdef HAVE_NOAA
noaa_store = new NOAAStore();
noaa_store->LoadFromProfile();
#endif
AudioVarioGlue::Initialise();
AudioVarioGlue::Configure(ui_settings.sound.vario);
// Start the device thread(s)
operation.SetText(_("Starting devices"));
devStartup();
/*
-- Reset polar in case devices need the data
GlidePolar::UpdatePolar(true, computer_settings);
This should be done inside devStartup if it is really required
*/
operation.SetText(_("Initialising display"));
GlueMapWindow *map_window = main_window->GetMap();
if (map_window != nullptr) {
map_window->SetWaypoints(&way_points);
map_window->SetTask(protected_task_manager);
map_window->SetRoutePlanner(&glide_computer->GetProtectedRoutePlanner());
map_window->SetGlideComputer(glide_computer);
map_window->SetAirspaces(&airspace_database);
map_window->SetTopography(topography);
map_window->SetTerrain(terrain);
map_window->SetWeather(rasp);
#ifdef HAVE_NOAA
map_window->SetNOAAStore(noaa_store);
#endif
/* show map at home waypoint until GPS fix becomes available */
if (computer_settings.poi.home_location_available)
map_window->SetLocation(computer_settings.poi.home_location);
}
// Finally ready to go.. all structures must be present before this.
// Create the drawing thread
#ifndef ENABLE_OPENGL
draw_thread = new DrawThread(*map_window);
draw_thread->Start(true);
#endif
// Show the infoboxes
InfoBoxManager::Show();
// Create the calculation thread
CreateCalculationThread();
// Find unique ID of this PDA
ReadAssetNumber();
glide_computer_events = new GlideComputerEvents();
glide_computer_events->Reset();
live_blackboard.AddListener(*glide_computer_events);
all_monitors = new AllMonitors();
if (!is_simulator() && computer_settings.logger.enable_flight_logger) {
flight_logger = new GlueFlightLogger(live_blackboard);
flight_logger->SetPath(LocalPath(_T("flights.log")));
}
if (computer_settings.logger.enable_nmea_logger)
NMEALogger::enabled = true;
LogFormat("ProgramStarted");
// Give focus to the map
main_window->SetDefaultFocus();
// Start calculation thread
merge_thread->Start();
calculation_thread->Start();
PageActions::Update();
#ifdef HAVE_TRACKING
tracking = new TrackingGlue();
tracking->SetSettings(computer_settings.tracking);
#ifdef HAVE_SKYLINES_TRACKING_HANDLER
if (map_window != nullptr)
map_window->SetSkyLinesData(&tracking->GetSkyLinesData());
#endif
#endif
assert(!global_running);
global_running = true;
AfterStartup();
operation.Hide();
main_window->FinishStartup();
return true;
}
HRESULT CHdmvClipInfo::ReadPlaylist(CString strPlaylistFile, REFERENCE_TIME& rtDuration, CAtlList<PlaylistItem>& Playlist)
{
CPath Path(strPlaylistFile);
rtDuration = 0;
// Get BDMV folder
Path.RemoveFileSpec();
Path.RemoveFileSpec();
m_hFile = CreateFile(strPlaylistFile, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, nullptr,
OPEN_EXISTING, FILE_ATTRIBUTE_READONLY | FILE_FLAG_SEQUENTIAL_SCAN, nullptr);
if (m_hFile != INVALID_HANDLE_VALUE) {
BYTE Buff[100];
bool bDuplicate = false;
ReadBuffer(Buff, 4);
if (memcmp(Buff, "MPLS", 4)) {
return CloseFile(VFW_E_INVALID_FILE_FORMAT);
}
ReadBuffer(Buff, 4);
if ((memcmp(Buff, "0200", 4) != 0) && (memcmp(Buff, "0100", 4) != 0)) {
return CloseFile(VFW_E_INVALID_FILE_FORMAT);
}
LARGE_INTEGER Pos;
unsigned short nPlaylistItems;
Pos.QuadPart = ReadDword(); // PlayList_start_address
ReadDword(); // PlayListMark_start_address
// PlayList()
SetFilePointerEx(m_hFile, Pos, nullptr, FILE_BEGIN);
ReadDword(); // length
ReadShort(); // reserved_for_future_use
nPlaylistItems = ReadShort(); // number_of_PlayItems
ReadShort(); // number_of_SubPaths
Pos.QuadPart += 10;
for (size_t i = 0; i < nPlaylistItems; i++) {
DWORD dwTemp;
PlaylistItem Item;
SetFilePointerEx(m_hFile, Pos, nullptr, FILE_BEGIN);
Pos.QuadPart += ReadShort() + 2;
ReadBuffer(Buff, 5);
Item.m_strFileName.Format(_T("%s\\STREAM\\%c%c%c%c%c.M2TS"), Path, Buff[0], Buff[1], Buff[2], Buff[3], Buff[4]);
ReadBuffer(Buff, 4);
if (memcmp(Buff, "M2TS", 4)) {
return CloseFile(VFW_E_INVALID_FILE_FORMAT);
}
ReadBuffer(Buff, 3);
dwTemp = ReadDword();
Item.m_rtIn = 20000i64 * dwTemp / 90; // Carefull : 32->33 bits!
dwTemp = ReadDword();
Item.m_rtOut = 20000i64 * dwTemp / 90; // Carefull : 32->33 bits!
rtDuration += (Item.m_rtOut - Item.m_rtIn);
if (Playlist.Find(Item) != nullptr) {
bDuplicate = true;
}
Playlist.AddTail(Item);
//TRACE(_T("File : %s, Duration : %s, Total duration : %s\n"), strTemp, ReftimeToString (rtOut - rtIn), ReftimeToString (rtDuration));
}
CloseFile(S_OK);
return bDuplicate ? S_FALSE : S_OK;
}
return AmHresultFromWin32(GetLastError());
}
gcc_pure
const_pointer GetExtension() const {
return Path(*this).GetExtension();
}
gcc_pure
AllocatedPath WithExtension(const_pointer new_extension) const {
return Path(*this).WithExtension(new_extension);
}
/**
* Check if this object is "inside" to the given path, and if yes,
* return the relative path.
*/
gcc_pure
Path RelativeTo(Path parent) const {
return Path(*this).RelativeTo(parent);
}
gcc_pure
bool MatchesExtension(const_pointer extension) const {
return Path(*this).MatchesExtension(extension);
}
gcc_pure
Path GetBase() const {
return Path(*this).GetBase();
}
AllocatedPath GetParent() const {
return Path(*this).GetParent();
}
gcc_pure
bool IsBase() const {
return Path(*this).IsBase();
}
Path DirectoryInfo::GetPath() const
{
return Path( m_path );
}
void Being::adjustCourse(int srcX, int srcY, int dstX, int dstY)
{
if (debug_movement)
printf("%p adjustCourse(%d, %d, %d, %d)\n",
(void*) this, srcX, srcY, dstX, dstY);
mDest.x = dstX;
mDest.y = dstY;
// Find a path to the destination when it is at least a tile away
if (mMap && fabsf((mDest - mPos).length()) > 32) {
setPath(mMap->findPath((int) mPos.x / 32, (int) mPos.y / 32,
dstX / 32, dstY / 32, getWalkMask()));
} else {
setPath(Path());
}
// TODO: Evaluate the implementation of this method
/*
if (mX / 32 == dstX / 32 && mY / 32 == dstY / 32)
{
// The being is already on the last tile of the path.
Path p;
p.push_back(Position(dstX, dstY));
setPath(p);
return;
}
Path p1;
int p1_size, p1_length;
Uint16 *p1_dist;
int onPath = -1;
if (srcX / 32 == dstX / 32 && srcY / 32 == dstY / 32)
{
p1_dist = new Uint16[1];
p1_size = 1;
p1_dist[0] = 0;
p1_length = 0;
}
else
{
p1 = mMap->findPath(srcX / 32, srcY / 32, dstX / 32, dstY / 32, getWalkMask());
if (p1.empty())
{
// No path, but don't teleport since it could be user input.
setPath(p1);
return;
}
p1_size = p1.size();
p1_dist = new Uint16[p1_size];
int j = 0;
// Remove last tile so that it can be replaced by the exact destination.
p1.pop_back();
for (Path::iterator i = p1.begin(), i_end = p1.end(); i != i_end; ++i)
{
// Get distance from source to tile i.
p1_dist[j] = mMap->getMetaTile(i->x, i->y)->Gcost;
// Check if the being is already walking on the path.
if (i->x == mX / 32 && i->y == mY / 32)
{
onPath = j;
}
// Do not set any offset for intermediate steps.
i->x = i->x * 32;
i->y = i->y * 32;
++j;
}
p1_length = mMap->getMetaTile(dstX / 32, dstY / 32)->Gcost;
p1_dist[p1_size - 1] = p1_length;
}
p1.push_back(Position(dstX, dstY));
if (mX / 32 == srcX / 32 && mY / 32 == srcY / 32)
{
// The being is at the start of the path.
setPath(p1);
delete[] p1_dist;
return;
}
if (onPath >= 0)
{
// The being is already on the path, but it needs to be slowed down.
for (int j = onPath; j >= 0; --j)
{
p1.pop_front();
}
int r = p1_length - p1_dist[onPath]; // remaining length
assert(r > 0);
setPath(p1, p1_length * 1024 / r);
delete[] p1_dist;
return;
}
Path bestPath;
int bestRating = -1, bestStart = 0, bestLength = 0;
int j = 0;
for (Path::iterator i = p1.begin(), i_end = p1.end(); i != i_end; ++i)
{
// Look if it is worth passing by tile i.
Path p2 = mMap->findPath(mX / 32, mY / 32, i->x / 32, i->y / 32, getWalkMask());
if (!p2.empty())
{
int l1 = mMap->getMetaTile(i->x / 32, i->y / 32)->Gcost;
int l2 = p1_length - p1_dist[j];
int r = l1 + l2 / 2; // TODO: tune rating formula
assert(r > 0);
if (bestRating < 0 || r < bestRating)
{
bestPath.swap(p2);
bestRating = r;
bestStart = j;
bestLength = l1 + l2;
}
}
++j;
}
if (bestRating < 0)
{
// Unable to reach the path? Still, don't teleport since it could be
// user input instead of server command.
setPath(p1);
delete[] p1_dist;
return;
}
bestPath.pop_back();
for (Path::iterator i = bestPath.begin(), i_end = bestPath.end(); i != i_end; ++i)
{
i->x = i->x * 32;
i->y = i->y * 32;
}
// Concatenate paths.
for (int j = bestStart; j > 0; --j)
{
p1.pop_front();
}
p1.splice(p1.begin(), bestPath);
assert(bestLength > 0);
setPath(p1, p1_length * 1024 / bestLength);
delete[] p1_dist;
*/
}
inline Path toPath() const { check(type_ & StringType, illegalConversion()); return Path(String(*this)); }
CmdEdit::editResult CmdEdit::editFile (Task& task)
{
// Check for file permissions.
Directory location (context.config.get ("data.location"));
if (! location.writable ())
throw std::string (STRING_EDIT_UNWRITABLE);
// Create a temp file name in data.location.
std::stringstream file;
file << "task." << task.get ("uuid").substr (0, 8) << ".task";
// Determine the output date format, which uses a hierarchy of definitions.
// rc.dateformat.edit
// rc.dateformat
std::string dateformat = context.config.get ("dateformat.edit");
if (dateformat == "")
dateformat = context.config.get ("dateformat");
// Change directory for the editor
std::string current_dir = Directory::cwd ();
int ignored = chdir (location._data.c_str ());
++ignored; // Keep compiler quiet.
// Check if the file already exists, if so, bail out
Path filepath = Path (file.str ());
if (filepath.exists ())
throw std::string (STRING_EDIT_IN_PROGRESS);
// Format the contents, T -> text, write to a file.
std::string before = formatTask (task, dateformat);
std::string before_orig = before;
File::write (file.str (), before);
// Determine correct editor: .taskrc:editor > $VISUAL > $EDITOR > vi
std::string editor = context.config.get ("editor");
char* peditor = getenv ("VISUAL");
if (editor == "" && peditor) editor = std::string (peditor);
peditor = getenv ("EDITOR");
if (editor == "" && peditor) editor = std::string (peditor);
if (editor == "") editor = "vi";
// Complete the command line.
editor += " ";
editor += "\"" + file.str () + "\"";
ARE_THESE_REALLY_HARMFUL:
bool changes = false; // No changes made.
// Launch the editor.
std::cout << format (STRING_EDIT_LAUNCHING, editor) << "\n";
int exitcode = system (editor.c_str ());
if (0 == exitcode)
std::cout << STRING_EDIT_COMPLETE << "\n";
else
{
std::cout << format (STRING_EDIT_FAILED, exitcode) << "\n";
if (-1 == exitcode)
std::cout << std::strerror (errno) << "\n";
return CmdEdit::editResult::error;
}
// Slurp file.
std::string after;
File::read (file.str (), after);
// Update task based on what can be parsed back out of the file, but only
// if changes were made.
if (before_orig != after)
{
std::cout << STRING_EDIT_CHANGES << "\n";
std::string problem = "";
bool oops = false;
try
{
parseTask (task, after, dateformat);
}
catch (const std::string& e)
{
problem = e;
oops = true;
}
if (oops)
{
std::cerr << STRING_ERROR_PREFIX << problem << "\n";
// Preserve the edits.
before = after;
File::write (file.str (), before);
if (confirm (STRING_EDIT_UNPARSEABLE))
goto ARE_THESE_REALLY_HARMFUL;
}
else
changes = true;
}
else
{
std::cout << STRING_EDIT_NO_CHANGES << "\n";
changes = false;
}
// Cleanup.
File::remove (file.str ());
ignored = chdir (current_dir.c_str ());
return changes
? CmdEdit::editResult::changes
: CmdEdit::editResult::nochanges;
}
Path MediaConvert::getOutputFilePath(){
return Path(destination.getPath(), (fileName + "." + getContainerName()));
}
Path FileInfo::GetPath() const
{
return Path( m_path );
}
HRESULT CHdmvClipInfo::ReadChapters(CString strPlaylistFile, CAtlList<CHdmvClipInfo::PlaylistItem>& PlaylistItems, CAtlList<PlaylistChapter>& Chapters)
{
CPath Path(strPlaylistFile);
// Get BDMV folder
Path.RemoveFileSpec();
Path.RemoveFileSpec();
m_hFile = CreateFile(strPlaylistFile, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, nullptr,
OPEN_EXISTING, FILE_ATTRIBUTE_READONLY | FILE_FLAG_SEQUENTIAL_SCAN, nullptr);
if (m_hFile != INVALID_HANDLE_VALUE) {
REFERENCE_TIME* rtOffset = DEBUG_NEW REFERENCE_TIME[PlaylistItems.GetCount()];
REFERENCE_TIME rtSum = 0;
int nIndex = 0;
BYTE Buff[100];
bool bDuplicate = false;
POSITION pos = PlaylistItems.GetHeadPosition();
while (pos) {
CHdmvClipInfo::PlaylistItem& PI = PlaylistItems.GetNext(pos);
rtOffset[nIndex] = rtSum - PI.m_rtIn;
rtSum = rtSum + PI.Duration();
nIndex++;
}
ReadBuffer(Buff, 4);
if (memcmp(Buff, "MPLS", 4)) {
SAFE_DELETE_ARRAY(rtOffset);
return CloseFile(VFW_E_INVALID_FILE_FORMAT);
}
ReadBuffer(Buff, 4);
if ((memcmp(Buff, "0200", 4) != 0) && (memcmp(Buff, "0100", 4) != 0)) {
SAFE_DELETE_ARRAY(rtOffset);
return CloseFile(VFW_E_INVALID_FILE_FORMAT);
}
LARGE_INTEGER Pos;
unsigned short nMarkCount;
ReadDword(); // PlayList_start_address
Pos.QuadPart = ReadDword(); // PlayListMark_start_address
// PlayListMark()
SetFilePointerEx(m_hFile, Pos, nullptr, FILE_BEGIN);
ReadDword(); // length
nMarkCount = ReadShort(); // number_of_PlayList_marks
for (size_t i = 0; i < nMarkCount; i++) {
PlaylistChapter Chapter;
ReadByte(); // reserved_for_future_use
Chapter.m_nMarkType = (PlaylistMarkType)ReadByte(); // mark_type
Chapter.m_nPlayItemId = ReadShort(); // ref_to_PlayItem_id
Chapter.m_rtTimestamp = 20000i64 * ReadDword() / 90 + rtOffset[Chapter.m_nPlayItemId]; // mark_time_stamp
Chapter.m_nEntryPID = ReadShort(); // entry_ES_PID
Chapter.m_rtDuration = 20000i64 * ReadDword() / 90; // duration
Chapters.AddTail(Chapter);
//TRACE(_T("Chapter %d : %s\n"), i, ReftimeToString(Chapter.m_rtTimestamp));
}
CloseFile(S_OK);
SAFE_DELETE_ARRAY(rtOffset);
return bDuplicate ? S_FALSE : S_OK;
}
return AmHresultFromWin32(GetLastError());
}
Path Path::Directory() const { return Path( std::make_shared< PathImpl >( m_impl->parent_path() )); }
Path System::GetTempDir()
{
return Path("/tmp");
}
Path Path::Filename() const { return Path( std::make_shared< PathImpl >( m_impl->filename() )); }
//XData implementations:
//->export:
FileStatus XData::xport( const std::string& filename, ExporterCommand cmd )
{
fs::path Path(filename);
fs::path parent = Path.parent_path();
// Ensure the parent path exists
fs::create_directories(parent);
if (os::fileOrDirExists(Path.string()))
{
switch (cmd)
{
case Merge:
{
//Check if definition already exists and return DefinitionExists. If it does not, append the definition to the file.
std::fstream file(Path.string(), std::ios_base::in | std::ios_base::out | std::ios_base::app);
if (!file.is_open())
return OpenFailed;
std::stringstream ss;
ss << file.rdbuf();
std::string String = ss.str();
std::size_t DefPos = String.find(_name);
while (DefPos != std::string::npos) //A name of a XData could be contained in another XData's name. Check that...
{
char before = String[DefPos > 0 ? DefPos-1 : 0];
char after = String[DefPos+_name.length() < String.size() ? DefPos+_name.length() : 0];
if ((DefPos == 0 || before == ' ' || before == '\t' || before == '\n') && (DefPos+_name.length() == String.size() || after == ' ' || after == '\t' || after == '\n')) //other delimiters necessary?
{
_definitionStart = 0;
//Definition found. But we want to have it clean, so let's see how many spaces are before the definition begin.
while (DefPos > 0)
{
if (String[--DefPos] != ' ' && String[DefPos] != '\t' && String[DefPos] != '\n')
{
_definitionStart = DefPos+1;
break;
}
}
file.close();
return DefinitionExists;
}
DefPos = String.find(_name,DefPos+_name.length());
}
file << "\n\n\n" << generateXDataDef();
file.close();
return AllOk;
}
case MergeOverwriteExisting:
{
//Find the old definition in the target file and delete it. Append the new definition.
//_definitionStart has been set in the first iteration of this method.
std::fstream file(Path.string(), std::ios_base::in);
if (!file.is_open())
return OpenFailed;
std::stringstream ss;
ss << file.rdbuf();
std::string OutString = ss.str();
file.close();
std::size_t DefLength = getDefLength(OutString.substr(_definitionStart));
if (DefLength == 0) //If the definitionlength can't be obtained, the merge fails.
return MergeFailed;
OutString.erase(_definitionStart, DefLength);
std::string insString = std::string( (_definitionStart != 0) ? "\n\n\n" : "" ) //No new lines in the first line
+ generateXDataDef()
+ std::string( (_definitionStart == OutString.size()) ? "" : "\n\n\n" ); //No new lines at the end of file
OutString.insert(_definitionStart, insString);
file.open(Path.string(), std::ios_base::out | std::ios_base::trunc);
if (!file.is_open())
return OpenFailed;
file << OutString;
file.close();
return AllOk;
}
case Overwrite:
{
//Warn if the target file contains multiple definitions: return MultipleDefinitions.
//Warn if the definition in the target file does not match the current definition: return DefinitionMisMatch
//else overwrite existing file.
std::string DefName;
std::ifstream file(Path.string(), std::ios_base::in);
if (!file.is_open())
return OpenFailed;
try { DefName = getDefinitionNameFromXD(file); }
catch (...)
{
rConsoleError() << "[XData::xport] Syntax error in file " << filename
<< ". Overwriting the file..." << std::endl;
break;
}
if (DefName == _name) //Definition will be overwritten...
break;
else if (DefName == "") //MultipleDefinitions exist
return MultipleDefinitions;
return DefinitionMismatch;
}
case OverwriteMultDef:
//Replace the file no matter what.
break;
default: return FileExists;
}
}
//Write the definition into the file.
std::ofstream file(Path.string(), std::ios_base::out | std::ios_base::trunc);
if (!file.is_open())
return OpenFailed;
file << generateXDataDef();
file.close();
return AllOk;
}
Path Path::Stem() const { return Path( std::make_shared< PathImpl >( m_impl->stem() )); }
//---------------------------------------------------------------------------
bool __fastcall TFileZillaIntf::RemoveDir(const wchar_t* FileName, const wchar_t* APath)
{
DebugAssert(FFileZillaApi != NULL);
CServerPath Path(APath);
return Check(FFileZillaApi->RemoveDir(FileName, Path), L"removedir");
}
Path Path::Extension() const { return Path( std::make_shared< PathImpl >( m_impl->extension() )); }
//---------------------------------------------------------------------------
bool __fastcall TFileZillaIntf::SetCurrentPath(const wchar_t * APath)
{
DebugAssert(FFileZillaApi != NULL);
CServerPath Path(APath);
return Check(FFileZillaApi->SetCurrentPath(Path), L"setcurrentpath");
}
operator Path() const {
return Path(c_str());
}
