Use an enum class for Marker.

[libdcp.git] / src / decrypted_kdm.h

diff --git a/src/decrypted_kdm.h b/src/decrypted_kdm.h
index 954334202addb726b08d8a90f3ab9027abf7aa2a..867e97ff442e8b500d826baa146284b54835c5b0 100644 (file)
--- a/src/decrypted_kdm.h
+++ b/src/decrypted_kdm.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (C) 2013-2016 Carl Hetherington <cth@carlh.net>
+    Copyright (C) 2013-2018 Carl Hetherington <cth@carlh.net>
 
     This file is part of libdcp.
 
@@ -15,6 +15,20 @@
 
     You should have received a copy of the GNU General Public License
     along with libdcp.  If not, see <http://www.gnu.org/licenses/>.
+
+    In addition, as a special exception, the copyright holders give
+    permission to link the code of portions of this program with the
+    OpenSSL library under certain conditions as described in each
+    individual source file, and distribute linked combinations
+    including the two.
+
+    You must obey the GNU General Public License in all respects
+    for all of the code used other than OpenSSL.  If you modify
+    file(s) with this exception, you may extend this exception to your
+    version of the file(s), but you are not obligated to do so.  If you
+    do not wish to do so, delete this exception statement from your
+    version.  If you delete this exception statement from all source
+    files in the program, then also delete it here.
 */
 
 #ifndef LIBDCP_DECRYPTED_KDM_H
@@ -32,12 +46,15 @@
 #include <boost/filesystem.hpp>
 #include <boost/optional.hpp>
 
+class decrypted_kdm_test;
+
 namespace dcp {
 
 class DecryptedKDMKey;
 class EncryptedKDM;
 class CertificateChain;
 class CPL;
+class ReelMXF;
 
 /** @class DecryptedKDM
  *  @brief A decrypted KDM.
@@ -70,6 +87,19 @@ public:
                std::string issue_date
                );
 
+       /** Construct a DecryptedKDM containing a given set of keys.
+        *  @param keys Keys to be included in the DecryptedKDM.
+        */
+       DecryptedKDM (
+               std::string cpl_id,
+               std::map<std::shared_ptr<const ReelMXF>, Key> keys,
+               LocalTime not_valid_before,
+               LocalTime not_valid_after,
+               std::string annotation_text,
+               std::string content_title_text,
+               std::string issue_date
+               );
+
        /** Create a DecryptedKDM by taking a CPL and setting up to encrypt each of its
         *  assets with the same symmetric key.
         *
@@ -79,7 +109,7 @@ public:
         *  @param not_valid_after End time for the KDM.
         */
        DecryptedKDM (
-               boost::shared_ptr<const CPL> cpl,
+               std::shared_ptr<const CPL> cpl,
                Key key,
                LocalTime not_valid_before,
                LocalTime not_valid_after,
@@ -91,23 +121,28 @@ public:
        /** Encrypt this KDM's keys and sign the whole KDM.
         *  @param signer Chain to sign with.
         *  @param recipient Certificate of the projector/server which should receive this KDM's keys.
-        *  @param trusted_devices Extra trusted devices which should be written to the KDM (recipient will be written
+        *  @param trusted_devices Thumbprints of extra trusted devices which should be written to the KDM (recipient will be written
         *  as a trusted device automatically and does not need to be included in this list).
         *  @param formulation Formulation to use for the encrypted KDM.
+        *  @param disable_forensic_marking_picture true to disable forensic marking of picture.
+        *  @param disable_forensic_marking_audio if not set, don't disable forensic marking of audio.  If set to 0,
+        *  disable all forensic marking; if set above 0, disable forensic marking above that channel.
         *  @return Encrypted KDM.
         */
        EncryptedKDM encrypt (
-               boost::shared_ptr<const CertificateChain> signer,
+               std::shared_ptr<const CertificateChain> signer,
                Certificate recipient,
-               std::vector<Certificate> trusted_devices,
-               Formulation formulation
+               std::vector<std::string> trusted_devices,
+               Formulation formulation,
+               bool disable_forensic_marking_picture,
+               boost::optional<int> disable_forensic_marking_audio
                ) const;
 
-       void add_key (std::string type, std::string key_id, Key key, std::string cpl_id);
+       void add_key (boost::optional<std::string> type, std::string key_id, Key key, std::string cpl_id, Standard standard);
        void add_key (DecryptedKDMKey key);
 
        /** @return This KDM's (decrypted) keys, which could be used to decrypt assets. */
-       std::list<DecryptedKDMKey> keys () const {
+       std::vector<DecryptedKDMKey> keys () const {
                return _keys;
        }
 
@@ -124,12 +159,18 @@ public:
        }
 
 private:
+
+       friend class ::decrypted_kdm_test;
+
+       static void put_uuid (uint8_t ** d, std::string id);
+       static std::string get_uuid (unsigned char ** p);
+
        LocalTime _not_valid_before;
        LocalTime _not_valid_after;
        boost::optional<std::string> _annotation_text;
        std::string _content_title_text;
        std::string _issue_date;
-       std::list<DecryptedKDMKey> _keys;
+       std::vector<DecryptedKDMKey> _keys;
 };
 
 }