src/picture_asset.cc

   1 /*
   2     Copyright (C) 2012-2021 Carl Hetherington <cth@carlh.net>
   3
   4     This file is part of libdcp.
   5
   6     libdcp is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 2 of the License, or
   9     (at your option) any later version.
  10
  11     libdcp is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with libdcp.  If not, see <http://www.gnu.org/licenses/>.
  18
  19     In addition, as a special exception, the copyright holders give
  20     permission to link the code of portions of this program with the
  21     OpenSSL library under certain conditions as described in each
  22     individual source file, and distribute linked combinations
  23     including the two.
  24
  25     You must obey the GNU General Public License in all respects
  26     for all of the code used other than OpenSSL.  If you modify
  27     file(s) with this exception, you may extend this exception to your
  28     version of the file(s), but you are not obligated to do so.  If you
  29     do not wish to do so, delete this exception statement from your
  30     version.  If you delete this exception statement from all source
  31     files in the program, then also delete it here.
  32 */
  33
  34
  35 /** @file  src/picture_asset.cc
  36  *  @brief PictureAsset class
  37  */
  38
  39
  40 #include "compose.hpp"
  41 #include "dcp_assert.h"
  42 #include "equality_options.h"
  43 #include "exceptions.h"
  44 #include "j2k_transcode.h"
  45 #include "openjpeg_image.h"
  46 #include "picture_asset.h"
  47 #include "picture_asset_writer.h"
  48 #include "util.h"
  49 #include <asdcp/AS_DCP.h>
  50 #include <asdcp/KM_fileio.h>
  51 #include <libxml++/nodes/element.h>
  52 #include <boost/filesystem.hpp>
  53 #include <list>
  54 #include <stdexcept>
  55
  56
  57 using std::string;
  58 using std::list;
  59 using std::vector;
  60 using std::max;
  61 using std::pair;
  62 using std::make_pair;
  63 using std::shared_ptr;
  64 using namespace dcp;
  65
  66
  67 PictureAsset::PictureAsset (boost::filesystem::path file)
  68         : Asset (file)
  69         , _intrinsic_duration (0)
  70 {
  71
  72 }
  73
  74
  75 PictureAsset::PictureAsset (Fraction edit_rate, Standard standard)
  76         : MXF (standard)
  77         , _edit_rate (edit_rate)
  78         , _intrinsic_duration (0)
  79 {
  80
  81 }
  82
  83
  84 void
  85 PictureAsset::read_picture_descriptor (ASDCP::JP2K::PictureDescriptor const & desc)
  86 {
  87         _size.width = desc.StoredWidth;
  88         _size.height = desc.StoredHeight;
  89         _edit_rate = Fraction (desc.EditRate.Numerator, desc.EditRate.Denominator);
  90         _intrinsic_duration = desc.ContainerDuration;
  91         _frame_rate = Fraction (desc.SampleRate.Numerator, desc.SampleRate.Denominator);
  92         _screen_aspect_ratio = Fraction (desc.AspectRatio.Numerator, desc.AspectRatio.Denominator);
  93 }
  94
  95
  96 bool
  97 PictureAsset::descriptor_equals (
  98         ASDCP::JP2K::PictureDescriptor const & a, ASDCP::JP2K::PictureDescriptor const & b, NoteHandler note
  99         ) const
 100 {
 101         if (
 102                 a.EditRate != b.EditRate ||
 103                 a.SampleRate != b.SampleRate ||
 104                 a.StoredWidth != b.StoredWidth ||
 105                 a.StoredHeight != b.StoredHeight ||
 106                 a.AspectRatio != b.AspectRatio ||
 107                 a.Rsize != b.Rsize ||
 108                 a.Xsize != b.Xsize ||
 109                 a.Ysize != b.Ysize ||
 110                 a.XOsize != b.XOsize ||
 111                 a.YOsize != b.YOsize ||
 112                 a.XTsize != b.XTsize ||
 113                 a.YTsize != b.YTsize ||
 114                 a.XTOsize != b.XTOsize ||
 115                 a.YTOsize != b.YTOsize ||
 116                 a.Csize != b.Csize
 117 //              a.CodingStyleDefault != b.CodingStyleDefault ||
 118 //              a.QuantizationDefault != b.QuantizationDefault
 119                 ) {
 120
 121                 note (NoteType::ERROR, "video MXF picture descriptors differ");
 122                 return false;
 123         }
 124
 125         if (a.ContainerDuration != b.ContainerDuration) {
 126                 note (NoteType::ERROR, "video container durations differ");
 127         }
 128
 129 //              for (unsigned int j = 0; j < ASDCP::JP2K::MaxComponents; ++j) {
 130 //                      if (a.ImageComponents[j] != b.ImageComponents[j]) {
 131 //                              notes.pack_start ("video MXF picture descriptors differ");
 132 //                      }
 133 //              }
 134
 135         return true;
 136 }
 137
 138
 139 bool
 140 PictureAsset::frame_buffer_equals (
 141         int frame, EqualityOptions const& opt, NoteHandler note,
 142         uint8_t const * data_A, unsigned int size_A, uint8_t const * data_B, unsigned int size_B
 143         ) const
 144 {
 145         if (size_A == size_B && memcmp (data_A, data_B, size_A) == 0) {
 146                 note (NoteType::NOTE, "J2K identical");
 147                 /* Easy result; the J2K data is identical */
 148                 return true;
 149         }
 150
 151         /* Decompress the images to bitmaps */
 152         auto image_A = decompress_j2k (const_cast<uint8_t*>(data_A), size_A, 0);
 153         auto image_B = decompress_j2k (const_cast<uint8_t*>(data_B), size_B, 0);
 154
 155         /* Compare them */
 156
 157         vector<int> abs_diffs (image_A->size().width * image_A->size().height * 3);
 158         int d = 0;
 159         int max_diff = 0;
 160
 161         for (int c = 0; c < 3; ++c) {
 162
 163                 if (image_A->size() != image_B->size()) {
 164                         note (NoteType::ERROR, String::compose ("image sizes for frame %1 differ", frame));
 165                         return false;
 166                 }
 167
 168                 int const pixels = image_A->size().width * image_A->size().height;
 169                 for (int j = 0; j < pixels; ++j) {
 170                         int const t = abs (image_A->data(c)[j] - image_B->data(c)[j]);
 171                         abs_diffs[d++] = t;
 172                         max_diff = max (max_diff, t);
 173                 }
 174         }
 175
 176         uint64_t total = 0;
 177         for (vector<int>::iterator j = abs_diffs.begin(); j != abs_diffs.end(); ++j) {
 178                 total += *j;
 179         }
 180
 181         double const mean = double (total) / abs_diffs.size ();
 182
 183         uint64_t total_squared_deviation = 0;
 184         for (auto j: abs_diffs) {
 185                 total_squared_deviation += pow (j - mean, 2);
 186         }
 187
 188         auto const std_dev = sqrt (double (total_squared_deviation) / abs_diffs.size());
 189
 190         note (NoteType::NOTE, String::compose("mean difference %1 deviation %2", mean, std_dev));
 191
 192         if (mean > opt.max_mean_pixel_error) {
 193                 note (
 194                         NoteType::ERROR,
 195                         String::compose ("mean %1 out of range %2 in frame %3", mean, opt.max_mean_pixel_error, frame)
 196                         );
 197
 198                 return false;
 199         }
 200
 201         if (std_dev > opt.max_std_dev_pixel_error) {
 202                 note (
 203                         NoteType::ERROR,
 204                         String::compose ("standard deviation %1 out of range %2 in frame %3", std_dev, opt.max_std_dev_pixel_error, frame)
 205                         );
 206
 207                 return false;
 208         }
 209
 210         return true;
 211 }
 212
 213
 214 string
 215 PictureAsset::static_pkl_type (Standard standard)
 216 {
 217         switch (standard) {
 218         case Standard::INTEROP:
 219                 return "application/x-smpte-mxf;asdcpKind=Picture";
 220         case Standard::SMPTE:
 221                 return "application/mxf";
 222         default:
 223                 DCP_ASSERT (false);
 224         }
 225 }
 226
 227
 228 string
 229 PictureAsset::pkl_type (Standard standard) const
 230 {
 231         return static_pkl_type (standard);
 232 }