X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=src%2Fpicture_asset.h;h=cc99ddbcbe0ea592d89000fee51a7958c44114c5;hb=341bdc0e4f78fed5f231e741142e2e74415f56b7;hp=baea22c3098487c0c70acc68f6b0d95d2f1f3161;hpb=4bcd365d3dba8d640d79685209b7a306b508c3e3;p=libdcp.git diff --git a/src/picture_asset.h b/src/picture_asset.h index baea22c3..cc99ddbc 100644 --- a/src/picture_asset.h +++ b/src/picture_asset.h @@ -17,12 +17,17 @@ */ +#ifndef LIBDCP_PICTURE_ASSET_H +#define LIBDCP_PICTURE_ASSET_H + /** @file src/picture_asset.h * @brief An asset made up of JPEG2000 files */ #include #include "mxf_asset.h" +#include "util.h" +#include "metadata.h" namespace libdcp { @@ -34,102 +39,202 @@ class StereoPictureFrame; class PictureAsset : public MXFAsset { public: - PictureAsset (std::string directory, std::string mxf_name, sigc::signal1* progress, int fps, int entry_point, int length); - - /** Write details of this asset to a CPL stream. - * @param s Stream. + /** Construct a PictureAsset. + * This class will not write anything to disk in this constructor, but subclasses may. + * + * @param directory Directory where MXF file is. + * @param mxf_name Name of MXF file. */ - void write_to_cpl (std::ostream& s) const; - - std::list equals (boost::shared_ptr other, EqualityOptions opt) const; + PictureAsset (std::string directory, std::string mxf_name); + + /** Construct a PictureAsset. + * This class will not write anything to disk in this constructor, but subclasses may. + * + * @param directory Directory where MXF file is. + * @param mxf_name Name of MXF file. + * @param progress Signal to use to inform of progres, or 0. + * @param fps Video Frames per second. + * @param intrinsic_duration Duration of all the frames in the asset. + * @param size Size of video frame images in pixels. + */ + PictureAsset (std::string directory, std::string mxf_name, boost::signals2::signal* progress, int fps, int intrinsic_duration, bool encrypted, Size); + + bool equals (boost::shared_ptr other, EqualityOptions opt, boost::function note) const; - int width () const { - return _width; + Size size () const { + return _size; } - int height () const { - return _height; - } + void write_to_cpl (xmlpp::Node *) const; protected: - std::list frame_buffer_equals ( - int frame, EqualityOptions opt, uint8_t const * data_A, unsigned int size_A, uint8_t const * data_B, unsigned int size_B + bool frame_buffer_equals ( + int frame, EqualityOptions opt, boost::function note, + uint8_t const * data_A, unsigned int size_A, uint8_t const * data_B, unsigned int size_B ) const; + + /** picture size in pixels */ + Size _size; + +private: + std::string key_type () const; + std::string cpl_node_name () const; +}; + +class MonoPictureAsset; + +struct FrameInfo +{ + FrameInfo (uint64_t o, uint64_t s, std::string h) + : offset (o) + , size (s) + , hash (h) + {} + + FrameInfo (std::istream& s); + + void write (std::ostream& s); - /** picture width in pixels */ - int _width; - /** picture height in pixels */ - int _height; + uint64_t offset; + uint64_t size; + std::string hash; +}; + +/** A helper class for writing to MonoPictureAssets progressively (i.e. writing frame-by-frame, + * rather than giving libdcp all the frames in one go). + * + * Objects of this class can only be created with MonoPictureAsset::start_write(). + * + * Frames can be written to the MonoPictureAsset by calling write() with a JPEG2000 image + * (a verbatim .j2 file). finalize() must be called after the last frame has been written. + * The action of finalize() can't be done in MonoPictureAssetWriter's destructor as it may + * throw an exception. + */ +class MonoPictureAssetWriter +{ +public: + FrameInfo write (uint8_t* data, int size); + void fake_write (int size); + void finalize (); + +private: + friend class MonoPictureAsset; + + MonoPictureAssetWriter (MonoPictureAsset *, bool, MXFMetadata const &); + void start (uint8_t *, int); + + /* no copy construction */ + MonoPictureAssetWriter (MonoPictureAssetWriter const &); + MonoPictureAssetWriter& operator= (MonoPictureAssetWriter const &); + + /* do this with an opaque pointer so we don't have to include + ASDCP headers + */ + + struct ASDCPState; + boost::shared_ptr _state; + + MonoPictureAsset* _asset; + /** Number of picture frames written to the asset so far */ + int _frames_written; + bool _started; + /** true if finalize() has been called */ + bool _finalized; + bool _overwrite; + MXFMetadata _metadata; }; /** A 2D (monoscopic) picture asset */ class MonoPictureAsset : public PictureAsset { public: - /** Construct a PictureAsset, generating the MXF from the JPEG2000 files. + /** Construct a MonoPictureAsset, generating the MXF from the JPEG2000 files. * This may take some time; progress is indicated by emission of the Progress signal. + * * @param files Pathnames of JPEG2000 files, in frame order. * @param directory Directory in which to create MXF file. * @param mxf_name Name of MXF file to create. * @param progress Signal to inform of progress. - * @param fps Frames per second. - * @param length Length in frames. - * @param width Width of images in pixels. - * @param height Height of images in pixels. + * @param fps Video frames per second. + * @param intrinsic_duration Length of the whole asset in frames. + * @param size Size of images in pixels. + * @param encrypted true if asset should be encrypted. */ MonoPictureAsset ( std::vector const & files, std::string directory, std::string mxf_name, - sigc::signal1* progress, + boost::signals2::signal* progress, int fps, - int length, - int width, - int height + int intrinsic_duration, + bool encrypted, + Size size, + MXFMetadata const & metadata = MXFMetadata () ); - /** Construct a PictureAsset, generating the MXF from the JPEG2000 files. + /** Construct a MonoPictureAsset, generating the MXF from the JPEG2000 files. * This may take some time; progress is indicated by emission of the Progress signal. + * * @param get_path Functor which returns a JPEG2000 file path for a given frame (frames counted from 0). * @param directory Directory in which to create MXF file. * @param mxf_name Name of MXF file to create. * @param progress Signal to inform of progress. - * @param fps Frames per second. - * @param length Length in frames. - * @param width Width of images in pixels. - * @param height Height of images in pixels. + * @param fps Video frames per second. + * @param intrinsic_duration Length of the whole asset in frames. + * @param size Size of images in pixels. + * @param encrypted true if asset should be encrypted. */ MonoPictureAsset ( - sigc::slot get_path, + boost::function get_path, std::string directory, std::string mxf_name, - sigc::signal1* progress, + boost::signals2::signal* progress, int fps, - int length, - int width, - int height + int intrinsic_duration, + bool encrypted, + Size size, + MXFMetadata const & metadata = MXFMetadata () ); - MonoPictureAsset (std::string directory, std::string mxf_name, int fps, int entry_point, int length); - + /** Construct a MonoPictureAsset, reading the MXF from disk. + * @param directory Directory that the MXF is in. + * @param mxf_name The filename of the MXF within `directory'. + */ + MonoPictureAsset (std::string directory, std::string mxf_name); + + /** Construct a MonoPictureAsset for progressive writing using + * start_write() and a MonoPictureAssetWriter. + * + * @param directory Directory to put the MXF in. + * @param mxf_name Filename of the MXF within this directory. + * @param fps Video frames per second. + * @param size Size in pixels that the picture frames will be. + */ + MonoPictureAsset (std::string directory, std::string mxf_name, int fps, Size size); + + /** Start a progressive write to a MonoPictureAsset */ + boost::shared_ptr start_write (bool, MXFMetadata const & metadata = MXFMetadata ()); + boost::shared_ptr get_frame (int n) const; - std::list equals (boost::shared_ptr other, EqualityOptions opt) const; + bool equals (boost::shared_ptr other, EqualityOptions opt, boost::function note) const; private: std::string path_from_list (int f, std::vector const & files) const; - void construct (sigc::slot); + void construct (boost::function, MXFMetadata const &); }; /** A 3D (stereoscopic) picture asset */ class StereoPictureAsset : public PictureAsset { public: - StereoPictureAsset (std::string directory, std::string mxf_name, int fps, int entry_point, int length); + StereoPictureAsset (std::string directory, std::string mxf_name, int fps, int intrinsic_duration); boost::shared_ptr get_frame (int n) const; - std::list equals (boost::shared_ptr other, EqualityOptions opt) const; + bool equals (boost::shared_ptr other, EqualityOptions opt, boost::function note) const; }; } + +#endif