From 19db239537b2c93e383051ca795259ea59be09aa Mon Sep 17 00:00:00 2001 From: Jonathan Thomas Date: Thu, 8 Sep 2016 17:03:42 -0500 Subject: [PATCH] More changes looking for build server breakage --- include/CacheBase.h | 17 +++-- include/CacheMemory.h | 23 +++++-- src/CacheBase.cpp | 24 ++++++- src/CacheMemory.cpp | 151 ++++++++++++++++++++++++++++++++++++++++-- 4 files changed, 197 insertions(+), 18 deletions(-) diff --git a/include/CacheBase.h b/include/CacheBase.h index 2721ba85..729a057d 100644 --- a/include/CacheBase.h +++ b/include/CacheBase.h @@ -31,6 +31,7 @@ #include #include "Frame.h" #include "Exceptions.h" +#include "Json.h" namespace openshot { @@ -44,7 +45,8 @@ namespace openshot { class CacheBase { protected: - int64 max_bytes; ///< This is the max number of bytes to cache (0 = no limit) + string cache_type; ///< This is a friendly type name of the derived cache instance + long long int max_bytes; ///< This is the max number of bytes to cache (0 = no limit) /// Section lock for multiple threads CriticalSection *cacheCriticalSection; @@ -56,7 +58,7 @@ namespace openshot { /// @brief Constructor that sets the max bytes to cache /// @param max_bytes The maximum bytes to allow in the cache. Once exceeded, the cache will purge the oldest frames. - CacheBase(int64 max_bytes); + CacheBase(long long int max_bytes); /// @brief Add a Frame to the cache /// @param frame The openshot::Frame object needing to be cached. @@ -73,7 +75,7 @@ namespace openshot { virtual tr1::shared_ptr GetFrame(long int frame_number) = 0; /// Gets the maximum bytes value - virtual int64 GetBytes() = 0; + virtual long long int GetBytes() = 0; /// Get the smallest frame number virtual tr1::shared_ptr GetSmallestFrame() = 0; @@ -83,11 +85,11 @@ namespace openshot { virtual void Remove(long int frame_number) = 0; /// Gets the maximum bytes value - int64 GetMaxBytes() { return max_bytes; }; + long long int GetMaxBytes() { return max_bytes; }; /// @brief Set maximum bytes to a different amount /// @param number_of_bytes The maximum bytes to allow in the cache. Once exceeded, the cache will purge the oldest frames. - void SetMaxBytes(int64 number_of_bytes) { max_bytes = number_of_bytes; }; + void SetMaxBytes(long long int number_of_bytes) { max_bytes = number_of_bytes; }; /// @brief Set maximum bytes to a different amount based on a ReaderInfo struct /// @param number_of_frames The maximum number of frames to hold in cache @@ -97,6 +99,11 @@ namespace openshot { /// @param channels The number of audio channels in the frame void SetMaxBytesFromInfo(long int number_of_frames, int width, int height, int sample_rate, int channels); + /// Get and Set JSON methods + virtual string Json() = 0; ///< Generate JSON string of this object + virtual void SetJson(string value) throw(InvalidJSON) = 0; ///< Load JSON string into this object + virtual Json::Value JsonValue() = 0; ///< Generate Json::JsonValue for this object + virtual void SetJsonValue(Json::Value root) = 0; ///< Load Json::JsonValue into this object }; diff --git a/include/CacheMemory.h b/include/CacheMemory.h index b0753e21..2f55ad0d 100644 --- a/include/CacheMemory.h +++ b/include/CacheMemory.h @@ -25,8 +25,8 @@ * along with OpenShot Library. If not, see . */ -#ifndef OPENSHOT_CACHE_H -#define OPENSHOT_CACHE_H +#ifndef OPENSHOT_CACHE_MEMORY_H +#define OPENSHOT_CACHE_MEMORY_H #include #include @@ -38,7 +38,7 @@ namespace openshot { /** - * @brief This class is a cache manager for Frame objects. + * @brief This class is a memory-based cache manager for Frame objects. * * It is used by FileReaders (such as FFmpegReader) to cache recently accessed frames. Due to the * high cost of decoding streams, once a frame is decoded, converted to RGB, and a Frame object is created, @@ -50,9 +50,17 @@ namespace openshot { map > frames; ///< This map holds the frame number and Frame objects deque frame_numbers; ///< This queue holds a sequential list of cached Frame numbers + bool needs_range_processing; ///< Something has changed, and the range data needs to be re-calculated + Json::Value ranges; ///< JSON ranges of frame numbers + vector ordered_frame_numbers; ///< Ordered list of frame numbers used by cache + map frame_ranges; ///< This map holds the ranges of frames, useful for quickly displaying the contents of the cache + long int range_version; ///< The version of the JSON range data (incremented with each change) + /// Clean up cached frames that exceed the max number of bytes void CleanUp(); + /// Calculate ranges of frames + void CalculateRanges(); public: /// Default constructor, no max bytes @@ -60,7 +68,7 @@ namespace openshot { /// @brief Constructor that sets the max bytes to cache /// @param max_bytes The maximum bytes to allow in the cache. Once exceeded, the cache will purge the oldest frames. - CacheMemory(int64 max_bytes); + CacheMemory(long long int max_bytes); // Default destructor ~CacheMemory(); @@ -80,7 +88,7 @@ namespace openshot { tr1::shared_ptr GetFrame(long int frame_number); /// Gets the maximum bytes value - int64 GetBytes(); + long long int GetBytes(); /// Get the smallest frame number tr1::shared_ptr GetSmallestFrame(); @@ -93,6 +101,11 @@ namespace openshot { /// @param frame_number The frame number of the cached frame void Remove(long int frame_number); + /// Get and Set JSON methods + string Json(); ///< Generate JSON string of this object + void SetJson(string value) throw(InvalidJSON); ///< Load JSON string into this object + Json::Value JsonValue(); ///< Generate Json::JsonValue for this object + void SetJsonValue(Json::Value root) throw(InvalidFile, ReaderClosed); ///< Load Json::JsonValue into this object }; } diff --git a/src/CacheBase.cpp b/src/CacheBase.cpp index 9ab1956a..c7218105 100644 --- a/src/CacheBase.cpp +++ b/src/CacheBase.cpp @@ -37,7 +37,7 @@ CacheBase::CacheBase() : max_bytes(0) { }; // Constructor that sets the max frames to cache -CacheBase::CacheBase(int64 max_bytes) : max_bytes(max_bytes) { +CacheBase::CacheBase(long long int max_bytes) : max_bytes(max_bytes) { // Init the critical section cacheCriticalSection = new CriticalSection(); }; @@ -46,7 +46,27 @@ CacheBase::CacheBase(int64 max_bytes) : max_bytes(max_bytes) { void CacheBase::SetMaxBytesFromInfo(long int number_of_frames, int width, int height, int sample_rate, int channels) { // n frames X height X width X 4 colors of chars X audio channels X 4 byte floats - int64 bytes = number_of_frames * (height * width * 4 + (sample_rate * channels * 4)); + long long int bytes = number_of_frames * (height * width * 4 + (sample_rate * channels * 4)); SetMaxBytes(bytes); } +// Generate Json::JsonValue for this object +Json::Value CacheBase::JsonValue() { + + // Create root json object + Json::Value root; + stringstream max_bytes_stream; + max_bytes_stream << max_bytes; + root["max_bytes"] = max_bytes_stream.str(); + + // return JsonValue + return root; +} + +// Load Json::JsonValue into this object +void CacheBase::SetJsonValue(Json::Value root) { + + // Set data from Json (if key is found) + if (!root["max_bytes"].isNull()) + max_bytes = atoll(root["max_bytes"].asString().c_str()); +} \ No newline at end of file diff --git a/src/CacheMemory.cpp b/src/CacheMemory.cpp index 54123819..f772ce01 100644 --- a/src/CacheMemory.cpp +++ b/src/CacheMemory.cpp @@ -32,12 +32,18 @@ using namespace openshot; // Default constructor, no max bytes CacheMemory::CacheMemory() : CacheBase(0) { - + // Set cache type name + cache_type = "CacheMemory"; + range_version = 0; + needs_range_processing = false; }; // Constructor that sets the max bytes to cache -CacheMemory::CacheMemory(int64 max_bytes) : CacheBase(max_bytes) { - +CacheMemory::CacheMemory(long long int max_bytes) : CacheBase(max_bytes) { + // Set cache type name + cache_type = "CacheMemory"; + range_version = 0; + needs_range_processing = false; }; // Default destructor @@ -45,12 +51,78 @@ CacheMemory::~CacheMemory() { frames.clear(); frame_numbers.clear(); + ordered_frame_numbers.clear(); // remove critical section delete cacheCriticalSection; cacheCriticalSection = NULL; } +// Calculate ranges of frames +void CacheMemory::CalculateRanges() { + // Only calculate when something has changed + if (needs_range_processing) { + + // Create a scoped lock, to protect the cache from multiple threads + const GenericScopedLock lock(*cacheCriticalSection); + + // Sort ordered frame #s, and calculate JSON ranges + std::sort(ordered_frame_numbers.begin(), ordered_frame_numbers.end()); + + // Clear existing JSON variable + ranges.clear(); + ranges = Json::Value(Json::arrayValue); + + // Increment range version + range_version++; + + vector::iterator itr_ordered; + long int starting_frame = *ordered_frame_numbers.begin(); + long int ending_frame = *ordered_frame_numbers.begin(); + + // Loop through all known frames (in sequential order) + for (itr_ordered = ordered_frame_numbers.begin(); itr_ordered != ordered_frame_numbers.end(); ++itr_ordered) { + long int frame_number = *itr_ordered; + if (frame_number - ending_frame > 1) { + // End of range detected + Json::Value range; + + // Add JSON object with start/end attributes + // Use strings, since long ints are supported in JSON + stringstream start_str; + start_str << starting_frame; + stringstream end_str; + end_str << ending_frame; + range["start"] = start_str.str(); + range["end"] = end_str.str(); + ranges.append(range); + + // Set new starting range + starting_frame = frame_number; + } + + // Set current frame as end of range, and keep looping + ending_frame = frame_number; + } + + // APPEND FINAL VALUE + Json::Value range; + + // Add JSON object with start/end attributes + // Use strings, since long ints are supported in JSON + stringstream start_str; + start_str << starting_frame; + stringstream end_str; + end_str << ending_frame; + range["start"] = start_str.str(); + range["end"] = end_str.str(); + ranges.append(range); + + // Reset needs_range_processing + needs_range_processing = false; + } +} + // Add a Frame to the cache void CacheMemory::Add(tr1::shared_ptr frame) { @@ -68,6 +140,8 @@ void CacheMemory::Add(tr1::shared_ptr frame) // Add frame to queue and map frames[frame_number] = frame; frame_numbers.push_front(frame_number); + ordered_frame_numbers.push_back(frame_number); + needs_range_processing = true; // Clean up old frames CleanUp(); @@ -113,12 +187,12 @@ tr1::shared_ptr CacheMemory::GetSmallestFrame() } // Gets the maximum bytes value -int64 CacheMemory::GetBytes() +long long int CacheMemory::GetBytes() { // Create a scoped lock, to protect the cache from multiple threads const GenericScopedLock lock(*cacheCriticalSection); - int64 total_bytes = 0; + long long int total_bytes = 0; // Loop through frames, and calculate total bytes deque::reverse_iterator itr; @@ -161,7 +235,7 @@ void CacheMemory::MoveToFront(long int frame_number) // Does frame exists in cache? /* FIXME if the frame number isn't present, the loop will do nothing, so why protect it? * Is it to save time by avoiding a loop? - * Do we really need to optmize the case where we've been given a nonexisting frame_number? */ + * Do we really need to optimize the case where we've been given a nonexisting frame_number? */ if (frames.count(frame_number)) { // Loop through frame numbers @@ -189,6 +263,7 @@ void CacheMemory::Clear() frames.clear(); frame_numbers.clear(); + ordered_frame_numbers.clear(); } // Count the frames in the queue @@ -220,3 +295,67 @@ void CacheMemory::CleanUp() } } } + + +// Generate JSON string of this object +string CacheMemory::Json() { + + // Return formatted string + return JsonValue().toStyledString(); +} + +// Generate Json::JsonValue for this object +Json::Value CacheMemory::JsonValue() { + + // Proccess range data (if anything has changed) + CalculateRanges(); + + // Create root json object + Json::Value root = CacheBase::JsonValue(); // get parent properties + root["type"] = cache_type; + root["ranges"] = ranges; + + Json::Value version; + stringstream range_version_str; + range_version_str << range_version; + root["version"] = range_version_str.str(); + + // return JsonValue + return root; +} + +// Load JSON string into this object +void CacheMemory::SetJson(string value) throw(InvalidJSON) { + + // Parse JSON string into JSON objects + Json::Value root; + Json::Reader reader; + bool success = reader.parse( value, root ); + if (!success) + // Raise exception + throw InvalidJSON("JSON could not be parsed (or is invalid)", ""); + + try + { + // Set all values that match + SetJsonValue(root); + } + catch (exception e) + { + // Error parsing JSON (or missing keys) + throw InvalidJSON("JSON is invalid (missing keys or invalid data types)", ""); + } +} + +// Load Json::JsonValue into this object +void CacheMemory::SetJsonValue(Json::Value root) throw(InvalidFile, ReaderClosed) { + + // Close timeline before we do anything (this also removes all open and closing clips) + Clear(); + + // Set parent data + CacheBase::SetJsonValue(root); + + if (!root["type"].isNull()) + cache_type = root["type"].asString(); +} \ No newline at end of file