Simplify time representation; better in-tree DCP subtitle parser.

1 files changed, 342 insertions, 0 deletions

diff --git a/asdcplib/src/KM_fileio.h b/asdcplib/src/KM_fileio.h
new file mode 100755
index 0000000..cb00acc
--- /dev/null
+++ b/asdcplib/src/KM_fileio.h
@@ -0,0 +1,342 @@
+/*
+Copyright (c) 2004-2009, John Hurst
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+1. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+3. The name of the author may not be used to endorse or promote products
+   derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+  /*! \file    KM_fileio.h
+    \version $Id: KM_fileio.h,v 1.17 2009/06/22 05:49:02 jhurst Exp $
+    \brief   portable file i/o
+  */
+
+#ifndef _KM_FILEIO_H_
+#define _KM_FILEIO_H_
+
+#include <KM_util.h>
+#include <string>
+#include <boost/filesystem.hpp>
+#include <openssl/md5.h>
+
+#ifdef KM_WIN32
+# include <io.h>
+#else
+# include <dirent.h>
+# include <unistd.h>
+# include <time.h>
+# include <sys/types.h>
+#include <regex.h>
+#endif
+
+#include <sys/stat.h>
+
+
+
+namespace Kumu
+{
+  class DirScanner
+  {
+  public:
+	  DirScanner();
+	  Result_t Open(const char *);
+	  Result_t GetNext(char *);
+	  Result_t Close();
+  private:
+	  boost::filesystem::directory_iterator _iterator;
+  };
+
+#ifdef KM_WIN32
+  typedef __int64  fsize_t;
+  typedef __int64  fpos_t;
+  typedef HANDLE FileHandle;
+
+  enum SeekPos_t {
+    SP_BEGIN = FILE_BEGIN,
+    SP_POS   = FILE_CURRENT,
+    SP_END   = FILE_END
+  };
+#else
+  typedef off_t    fsize_t;
+  typedef off_t    fpos_t;
+  typedef int      FileHandle;
+  const FileHandle INVALID_HANDLE_VALUE = -1L;
+
+  enum SeekPos_t {
+    SP_BEGIN = SEEK_SET,
+    SP_POS   = SEEK_CUR,
+    SP_END   = SEEK_END
+  };
+#endif	
+	
+  //
+#ifndef KM_SMALL_FILES_OK
+  template <bool sizecheck>    void compile_time_size_checker();
+  template <> inline void compile_time_size_checker<false>() {}
+  //
+  // READ THIS if your compiler is complaining about a previously declared implementation of
+  // compile_time_size_checker(). For example, GCC 4.0.1 looks like this:
+  //
+  // error: 'void Kumu::compile_time_size_checker() [with bool sizecheck = false]' previously declared here
+  //
+  // This is happening because the equality being tested below is false. The reason for this 
+  // will depend on your OS, but on Linux it is probably because you have not used -D_FILE_OFFSET_BITS=64
+  // Adding this magic macro to your CFLAGS will get you going again. If you are on a system that
+  // does not support 64-bit files, you can disable this check by using -DKM_SMALL_FILES_OK. You
+  // will then of course be limited to file sizes < 4GB.
+  //
+  template <> inline void compile_time_size_checker<sizeof(Kumu::fsize_t)==sizeof(ui64_t)>() {}
+#endif
+  //
+
+  const ui32_t Kilobyte = 1024;
+  const ui32_t Megabyte = Kilobyte * Kilobyte;
+  const ui32_t Gigabyte = Megabyte * Kilobyte;
+
+  const ui32_t MaxFilePath = Kilobyte;
+
+
+  //------------------------------------------------------------------------------------------
+  // Path Manglers
+  //------------------------------------------------------------------------------------------
+
+  // types
+  typedef std::list<std::string> PathCompList_t; // a list of path components
+  typedef std::list<std::string> PathList_t; // a list of paths
+
+  // tests
+  bool        PathExists(const std::string& Path); // true if the path exists in the filesystem
+  bool        PathIsFile(const std::string& Path); // true if the path exists in the filesystem and is a file
+  bool        PathIsDirectory(const std::string& Path); // true if the path exists in the filesystem and is a directory
+  fsize_t     FileSize(const std::string& Path); // returns the size of a regular file, 0 for a directory or device
+  bool        PathsAreEquivalent(const std::string& lhs, const std::string& rhs); // true if paths point to the same filesystem entry
+
+  // Returns free space and total space available for the given path
+  Result_t    FreeSpaceForPath(const std::string& path, Kumu::fsize_t& free_space, Kumu::fsize_t& total_space);
+
+  // split and reassemble paths as lists of path components
+  PathCompList_t& PathToComponents(const std::string& Path, PathCompList_t& CList, char separator = '/'); // removes '//'
+  std::string ComponentsToPath(const PathCompList_t& CList, char separator = '/');
+  std::string ComponentsToAbsolutePath(const PathCompList_t& CList, char separator = '/'); // add separator to the front
+  bool        PathHasComponents(const std::string& Path, char separator = '/'); // true if paths starts with separator
+
+  bool        PathIsAbsolute(const std::string& Path, char separator = '/'); // true if path begins with separator
+  std::string PathMakeAbsolute(const std::string& Path, char separator = '/'); // compute position of relative path using getcwd()
+  std::string PathMakeLocal(const std::string& Path, const std::string& Parent); // remove Parent from front of Path, if it exists
+  std::string PathMakeCanonical(const std::string& Path, char separator = '/'); // remove '.' and '..'
+
+  // common operations
+  std::string PathBasename(const std::string& Path, char separator = '/'); // returns right-most path element (list back())
+  std::string PathDirname(const std::string& Path, char separator = '/'); // returns everything but the right-most element
+  std::string PathGetExtension(const std::string& Path); // returns everything in the right-most element following the right-most '.'
+  std::string PathSetExtension(const std::string& Path, const std::string& Extension); // empty extension removes '.' as well
+
+  std::string PathJoin(const std::string& Path1, const std::string& Path2, char separator = '/');
+  std::string PathJoin(const std::string& Path1, const std::string& Path2, const std::string& Path3, char separator = '/');
+  std::string PathJoin(const std::string& Path1, const std::string& Path2,
+		       const std::string& Path3, const std::string& Path4, char separator = '/');
+
+
+  //------------------------------------------------------------------------------------------
+  // Path Search
+  //------------------------------------------------------------------------------------------
+
+  // An interface for a path matching function, used by FindInPath() and FindInPaths() below
+  //
+  class IPathMatch
+  {
+  public:
+    virtual ~IPathMatch() {}
+    virtual bool Match(const std::string& s) const = 0;
+  };
+
+  // matches any pathname
+ class PathMatchAny : public IPathMatch
+  {
+  public:
+    virtual ~PathMatchAny() {}
+    inline bool Match(const std::string&) const { return true; }
+  };
+
+#ifndef KM_WIN32
+  // matches pathnames using a regular expression
+ class PathMatchRegex : public IPathMatch
+  {
+    regex_t m_regex;
+    PathMatchRegex();
+    const PathMatchRegex& operator=(const PathMatchRegex&);
+
+  public:
+    PathMatchRegex(const std::string& Pattern);
+    PathMatchRegex(const PathMatchRegex&);
+    virtual ~PathMatchRegex();
+    bool Match(const std::string& s) const;
+  };
+
+  // matches pathnames using a Bourne shell glob expression
+ class PathMatchGlob : public IPathMatch
+  {
+    regex_t m_regex;
+    PathMatchGlob();
+    const PathMatchGlob& operator=(const PathMatchGlob&);
+
+  public:
+    PathMatchGlob(const std::string& Pattern);
+    PathMatchGlob(const PathMatchGlob&);
+    virtual ~PathMatchGlob();
+    bool Match(const std::string& s) const;
+  };
+#endif /* !KM_WIN32 */
+
+  // Search all paths in SearchPaths for filenames matching Pattern (no directories are returned).
+  // Put results in FoundPaths. Returns after first find if one_shot is true.
+  PathList_t& FindInPath(const IPathMatch& Pattern, const std::string& SearchDir,
+			 PathList_t& FoundPaths, bool one_shot = false, char separator = '/');
+
+  PathList_t& FindInPaths(const IPathMatch& Pattern, const PathList_t& SearchPaths,
+			  PathList_t& FoundPaths, bool one_shot = false, char separator = '/');
+
+  //------------------------------------------------------------------------------------------
+  // Directory Manipulation
+  //------------------------------------------------------------------------------------------
+
+  // Create a directory, creates intermediate directories as necessary
+  Result_t CreateDirectoriesInPath(const std::string& Path);
+
+  // Delete a file (fails if the path points to a directory)
+  Result_t DeleteFile(const std::string& filename);
+
+  // Recursively remove a file or directory
+  Result_t DeletePath(const std::string& pathname);
+
+  //------------------------------------------------------------------------------------------
+  // File I/O Wrappers
+  //------------------------------------------------------------------------------------------
+
+  // Instant IO for strings
+  //
+  // Reads an entire file into a string.
+  Result_t ReadFileIntoString(const char* filename, std::string& outString, ui32_t max_size = 8 * Megabyte);
+
+  // Writes a string to a file, overwrites the existing file if present.
+  Result_t WriteStringIntoFile(const char* filename, const std::string& inString);
+
+  // Instant IO for archivable objects
+  //
+  // Unarchives a file into an object
+  Result_t ReadFileIntoObject(const std::string& Filename, IArchive& Object, ui32_t max_size = 8 * Kumu::Megabyte);
+
+  // Archives an object into a file
+  Result_t WriteObjectIntoFile(const IArchive& Object, const std::string& Filename);
+
+  // Instant IO for memory buffers
+  //
+  // Unarchives a file into a buffer
+  Result_t ReadFileIntoBuffer(const std::string& Filename, Kumu::ByteString& Buffer,
+			      ui32_t max_size = 8 * Kumu::Megabyte);
+
+  // Archives a buffer into a file
+  Result_t WriteBufferIntoFile(const Kumu::ByteString& Buffer, const std::string& Filename);
+
+
+  //------------------------------------------------------------------------------------------
+  // File I/O
+  //------------------------------------------------------------------------------------------
+
+  //
+  class FileReader
+    {
+      KM_NO_COPY_CONSTRUCT(FileReader);
+
+    protected:
+      std::string m_Filename;
+      FileHandle  m_Handle;
+
+    public:
+      FileReader() : m_Handle(INVALID_HANDLE_VALUE) {}
+      virtual ~FileReader() { Close(); }
+
+      Result_t OpenRead(const char*) const;                          // open the file for reading
+      Result_t Close() const;                                        // close the file
+      fsize_t  Size() const;                                         // returns the file's current size
+      Result_t Seek(Kumu::fpos_t = 0, SeekPos_t = SP_BEGIN) const;   // move the file pointer
+      Result_t Tell(Kumu::fpos_t* pos) const;                        // report the file pointer's location
+      Result_t Read(byte_t*, ui32_t, ui32_t* = 0) const;             // read a buffer of data
+
+      inline Kumu::fpos_t Tell() const                               // report the file pointer's location
+	{
+	  Kumu::fpos_t tmp_pos;
+	  Tell(&tmp_pos);
+	  return tmp_pos;
+	}
+
+      inline bool IsOpen() {                                         // returns true if the file is open
+	return (m_Handle != INVALID_HANDLE_VALUE);
+      }
+    };
+
+  //
+  class FileWriter : public FileReader
+    {
+      class h__iovec;
+      mem_ptr<h__iovec>  m_IOVec;
+      KM_NO_COPY_CONSTRUCT(FileWriter);
+      bool m_Hashing;
+      MD5_CTX m_MD5Context;
+
+    public:
+      FileWriter();
+      virtual ~FileWriter();
+
+      Result_t OpenWrite(const char*);                               // open a new file, overwrites existing
+      Result_t OpenModify(const char*);                              // open a file for read/write
+
+      // this part of the interface takes advantage of the iovec structure on
+      // platforms that support it. For each call to Writev(const byte_t*, ui32_t, ui32_t*),
+      // the given buffer is added to an internal iovec struct. All items on the list
+      // are written to disk by a call to Writev();
+      Result_t Writev(const byte_t*, ui32_t);                       // queue buffer for "gather" write
+      Result_t Writev(ui32_t* = 0);                                 // write all queued buffers
+
+      // if you call this while there are unwritten items on the iovec list,
+      // the iovec list will be written to disk before the given buffer,as though
+      // you had called Writev() first.
+      Result_t Write(const byte_t*, ui32_t, ui32_t* = 0);            // write buffer to disk
+
+      void StartHashing();
+      void MaybeHash(void const *, int);
+      std::string StopHashing();
+   };
+
+  Result_t CreateDirectoriesInPath(const std::string& Path);
+  Result_t FreeSpaceForPath(const std::string& path, Kumu::fsize_t& free_space, Kumu::fsize_t& total_space);
+  Result_t DeleteFile(const std::string& filename);
+  Result_t DeletePath(const std::string& pathname);
+
+} // namespace Kumu
+
+
+#endif // _KM_FILEIO_H_
+
+
+//
+// end KM_fileio.h
+//