// ***************************************************************** -*- C++ -*-

/*

 * Copyright (C) 2004-2021 Exiv2 authors

 * This program is part of the Exiv2 distribution.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, 5th Floor, Boston, MA 02110-1301 USA.

 */

// *****************************************************************************

// included header files

#include "quicktimevideo.hpp"

#include "basicio.hpp"

#include "config.h"

#include "enforce.hpp"

#include "error.hpp"

#include "futils.hpp"

#include "helper_functions.hpp"

#include "image_int.hpp"

#include "properties.hpp"

#include "safe_op.hpp"

#include "tags.hpp"

#include "tags_int.hpp"

// + standard includes

#include <array>

#include <cmath>

#include <string>

// *****************************************************************************

// class member definitions

namespace Exiv2::Internal {

static constexpr TagVocabulary qTimeFileType[] = {

    {"3g2a", "3GPP2 Media (.3G2) compliant with 3GPP2 C.S0050-0 V1.0"},

    {"3g2b", "3GPP2 Media (.3G2) compliant with 3GPP2 C.S0050-A V1.0.0"},

    {"3g2c", "3GPP2 Media (.3G2) compliant with 3GPP2 C.S0050-B v1.0"},

    {"3ge6", "3GPP (.3GP) Release 6 MBMS Extended Presentations"},

    {"3ge7", "3GPP (.3GP) Release 7 MBMS Extended Presentations"},

    {"3gg6", "3GPP Release 6 General Profile"},

    {"3gp1", "3GPP Media (.3GP) Release 1 (probably non-existent)"},

    {"3gp2", "3GPP Media (.3GP) Release 2 (probably non-existent)"},

    {"3gp3", "3GPP Media (.3GP) Release 3 (probably non-existent)"},

    {"3gp4", "3GPP Media (.3GP) Release 4"},

    {"3gp5", "3GPP Media (.3GP) Release 5"},

    {"3gp6", "3GPP Media (.3GP) Release 6 Streaming Servers"},

    {"3gs7", "3GPP Media (.3GP) Release 7 Streaming Servers"},

    {"CAEP", "Canon Digital Camera"},

    {"CDes", "Convergent Design"},

    {"F4A ", "Audio for Adobe Flash Player 9+ (.F4A)"},

    {"F4B ", "Audio Book for Adobe Flash Player 9+ (.F4B)"},

    {"F4P ", "Protected Video for Adobe Flash Player 9+ (.F4P)"},

    {"F4V ", "Video for Adobe Flash Player 9+ (.F4V)"},

    {"JP2 ", "JPEG 2000 Image (.JP2) [ISO 15444-1 ?]"},

    {"JP20", "Unknown, from GPAC samples (prob non-existent)"},

    {"KDDI", "3GPP2 EZmovie for KDDI 3G cellphones"},

    {"M4A ", "Apple iTunes AAC-LC (.M4A) Audio"},

    {"M4B ", "Apple iTunes AAC-LC (.M4B) Audio Book"},

    {"M4P ", "Apple iTunes AAC-LC (.M4P) AES Protected Audio"},

    {"M4V ", "Apple iTunes Video (.M4V) Video"},

    {"M4VH", "Apple TV (.M4V)"},

    {"M4VP", "Apple iPhone (.M4V)"},

    {"MPPI", "Photo Player, MAF [ISO/IEC 23000-3]"},

    {"MSNV", "MPEG-4 (.MP4) for SonyPSP"},

    {"NDAS", "MP4 v2 [ISO 14496-14] Nero Digital AAC Audio"},

    {"NDSC", "MPEG-4 (.MP4) Nero Cinema Profile"},

    {"NDSH", "MPEG-4 (.MP4) Nero HDTV Profile"},

    {"NDSM", "MPEG-4 (.MP4) Nero Mobile Profile"},

    {"NDSP", "MPEG-4 (.MP4) Nero Portable Profile"},

    {"NDSS", "MPEG-4 (.MP4) Nero Standard Profile"},

    {"NDXC", "H.264/MPEG-4 AVC (.MP4) Nero Cinema Profile"},

    {"NDXH", "H.264/MPEG-4 AVC (.MP4) Nero HDTV Profile"},

    {"NDXM", "H.264/MPEG-4 AVC (.MP4) Nero Mobile Profile"},

    {"NDXP", "H.264/MPEG-4 AVC (.MP4) Nero Portable Profile"},

    {"NDXS", "H.264/MPEG-4 AVC (.MP4) Nero Standard Profile"},

    {"NIKO", "Nikon"},

    {"ROSS", "Ross Video"},

    {"avc1", "MP4 Base w/ AVC ext [ISO 14496-12:2005]"},

    {"caqv", "Casio Digital Camera"},

    {"da0a", "DMB MAF w/ MPEG Layer II aud, MOT slides, DLS, JPG/PNG/MNG images"},

    {"da0b", "DMB MAF, extending DA0A, with 3GPP timed text, DID, TVA, REL, IPMP"},

    {"da1a", "DMB MAF audio with ER-BSAC audio, JPG/PNG/MNG images"},

    {"da1b", "DMB MAF, extending da1a, with 3GPP timed text, DID, TVA, REL, IPMP"},

    {"da2a", "DMB MAF aud w/ HE-AAC v2 aud, MOT slides, DLS, JPG/PNG/MNG images"},

    {"da2b", "DMB MAF, extending da2a, with 3GPP timed text, DID, TVA, REL, IPMP"},

    {"da3a", "DMB MAF aud with HE-AAC aud, JPG/PNG/MNG images"},

    {"da3b", "DMB MAF, extending da3a w/ BIFS, 3GPP timed text, DID, TVA, REL, IPMP"},

    {"dmb1", "DMB MAF supporting all the components defined in the specification"},

    {"dmpf", "Digital Media Project"},

    {"drc1", "Dirac (wavelet compression), encapsulated in ISO base media (MP4)"},

    {"dv1a", "DMB MAF vid w/ AVC vid, ER-BSAC aud, BIFS, JPG/PNG/MNG images, TS"},

    {"dv1b", "DMB MAF, extending dv1a, with 3GPP timed text, DID, TVA, REL, IPMP"},

    {"dv2a", "DMB MAF vid w/ AVC vid, HE-AAC v2 aud, BIFS, JPG/PNG/MNG images, TS"},

    {"dv2b", "DMB MAF, extending dv2a, with 3GPP timed text, DID, TVA, REL, IPMP"},

    {"dv3a", "DMB MAF vid w/ AVC vid, HE-AAC aud, BIFS, JPG/PNG/MNG images, TS"},

    {"dv3b", "DMB MAF, extending dv3a, with 3GPP timed text, DID, TVA, REL, IPMP"},

    {"dvr1", "DVB (.DVB) over RTP"},

    {"dvt1", "DVB (.DVB) over MPEG-2 Transport Stream"},

    {"isc2", "ISMACryp 2.0 Encrypted File"},

    {"iso2", "MP4 Base Media v2 [ISO 14496-12:2005]"},

    {"isom", "MP4 Base Media v1 [IS0 14496-12:2003]"},

    {"jpm ", "JPEG 2000 Compound Image (.JPM) [ISO 15444-6]"},

    {"jpx ", "JPEG 2000 with extensions (.JPX) [ISO 15444-2]"},

    {"mj2s", "Motion JPEG 2000 [ISO 15444-3] Simple Profile"},

    {"mjp2", "Motion JPEG 2000 [ISO 15444-3] General Profile"},

    {"mmp4", "MPEG-4/3GPP Mobile Profile (.MP4/3GP) (for NTT)"},

    {"mp21", "MPEG-21 [ISO/IEC 21000-9]"},

    {"mp41", "MP4 v1 [ISO 14496-1:ch13]"},

    {"mp42", "MP4 v2 [ISO 14496-14]"},

    {"mp71", "MP4 w/ MPEG-7 Metadata [per ISO 14496-12]"},

    {"mqt ", "Sony / Mobile QuickTime (.MQV) US Patent 7,477,830 (Sony Corp)"},

    {"niko", "Nikon"},

    {"odcf", "OMA DCF DRM Format 2.0 (OMA-TS-DRM-DCF-V2_0-20060303-A)"},

    {"opf2", "OMA PDCF DRM Format 2.1 (OMA-TS-DRM-DCF-V2_1-20070724-C)"},

    {"opx2", "OMA PDCF DRM + XBS extensions (OMA-TS-DRM_XBS-V1_0-20070529-C)"},

    {"pana", "Panasonic Digital Camera"},

    {"qt  ", "Apple QuickTime (.MOV/QT)"},

    {"sdv ", "SD Memory Card Video"},

    {"ssc1", "Samsung stereoscopic, single stream"},

    {"ssc2", "Samsung stereoscopic, dual stream"},

};

static constexpr TagVocabulary handlerClassTags[] = {

    {"dhlr", "Data Handler"},

    {"mhlr", "Media Handler"},

};

static constexpr TagVocabulary handlerTypeTags[] = {

    {"alis", "Alias Data"},

    {"crsm", "Clock Reference"},

    {"hint", "Hint Track"},

    {"ipsm", "IPMP"},

    {"m7sm", "MPEG-7 Stream"},

    {"mdir", "Metadata"},

    {"mdta", "Metadata Tags"},

    {"mjsm", "MPEG-J"},

    {"ocsm", "Object Content"},

    {"odsm", "Object Descriptor"},

    {"sdsm", "Scene Description"},

    {"soun", "Audio Track"},

    {"text", "Text"},

    {"tmcd", "Time Code"},

    {"url ", "URL"},

    {"vide", "Video Track"},

};

static constexpr TagVocabulary vendorIDTags[] = {

    {"FFMP", "FFmpeg"},

    {"appl", "Apple"},

    {"olym", "Olympus"},

    {"GIC ", "General Imaging Co."},

    {"fe20", "Olympus (fe20)"},

    {"pana", "Panasonic"},

    {"KMPI", "Konica-Minolta"},

    {"kdak", "Kodak"},

    {"pent", "Pentax"},

    {"NIKO", "Nikon"},

    {"leic", "Leica"},

    {"pr01", "Olympus (pr01)"},

    {"SMI ", "Sorenson Media Inc."},

    {"mino", "Minolta"},

    {"sany", "Sanyo"},

    {"ZORA", "Zoran Corporation"},

    {"niko", "Nikon"},

};

static constexpr TagVocabulary cameraByteOrderTags[] = {

    {"II", "Little-endian (Intel, II)"},

    {"MM", "Big-endian (Motorola, MM)"},

};

static constexpr TagDetails graphicsModetags[] = {

    {0x0, "srcCopy"},

    {0x1, "srcOr"},

    {0x2, "srcXor"},

    {0x3, "srcBic"},

    {0x4, "notSrcCopy"},

    {0x5, "notSrcOr"},

    {0x6, "notSrcXor"},

    {0x7, "notSrcBic"},

    {0x8, "patCopy"},

    {0x9, "patOr"},

    {0xa, "patXor"},

    {0xb, "patBic"},

    {0xc, "notPatCopy"},

    {0xd, "notPatOr"},

    {0xe, "notPatXor"},

    {0xf, "notPatBic"},

    {0x20, "blend"},

    {0x21, "addPin"},

    {0x22, "addOver"},

    {0x23, "subPin"},

    {0x24, "transparent"},

    {0x25, "addMax"},

    {0x26, "subOver"},

    {0x27, "addMin"},

    {0x31, "grayishTextOr"},

    {0x32, "hilite"},

    {0x40, "ditherCopy"},

    {0x100, "Alpha"},

    {0x101, "White Alpha"},

    {0x102, "Pre-multiplied Black Alpha"},

    {0x110, "Component Alpha"},

};

static constexpr TagVocabulary userDatatags[] = {

    {"AllF", "PlayAllFrames"},

    {"CNCV", "CompressorVersion"},

    {"CNFV", "FirmwareVersion"},

    {"CNMN", "Model"},

    {"CNTH", "CanonCNTH"},

    {"DcMD", "DcMD"},

    {"FFMV", "FujiFilmFFMV"},

    {"INFO", "SamsungINFO"},

    {"LOOP", "LoopStyle"},

    {"MMA0", "MinoltaMMA0"},

    {"MMA1", "MinoltaMMA1"},

    {"MVTG", "FujiFilmMVTG"},

    {"NCDT", "NikonNCDT"},

    {"PANA", "PanasonicPANA"},

    {"PENT", "PentaxPENT"},

    {"PXMN", "MakerNotePentax5b"},

    {"PXTH", "PentaxPreview"},

    {"QVMI", "CasioQVMI"},

    {"SDLN", "PlayMode"},

    {"SelO", "PlaySelection"},

    {"TAGS", "KodakTags/KonicaMinoltaTags/MinoltaTags/NikonTags/OlympusTags/PentaxTags/SamsungTags/SanyoMOV/SanyoMP4"},

    {"WLOC", "WindowLocation"},

    {"XMP_", "XMP"},

    {"Xtra", "Xtra"},

    {"hinf", "HintTrackInfo"},

    {"hinv", "HintVersion"},

    {"hnti", "Hint"},

    {"meta", "Meta"},

    {"name", "Name"},

    {"ptv ", "PrintToVideo"},

    {"scrn", "OlympusPreview"},

    {"thmb", "MakerNotePentax5a/OlympusThumbnail"},

};

static constexpr TagVocabulary userDataReferencetags[] = {

    {"CNCV", "Xmp.video.CompressorVersion"},

    {"CNFV", "Xmp.video.FirmwareVersion"},

    {"CNMN", "Xmp.video.Model"},

    {"NCHD", "Xmp.video.MakerNoteType"},

    {"WLOC", "Xmp.video.WindowLocation"},

    {"SDLN", "Xmp.video.PlayMode"},

    {"FFMV", "Xmp.video.StreamName"},

    {"SelO", "Xmp.video.PlaySelection"},

    {"name", "Xmp.video.Name"},

    {"vndr", "Xmp.video.Vendor"},

    {" ART", "Xmp.video.Artist"},

    {" alb", "Xmp.video.Album"},

    {" arg", "Xmp.video.Arranger"},

    {" ark", "Xmp.video.ArrangerKeywords"},

    {" cmt", "Xmp.video.Comment"},

    {" cok", "Xmp.video.ComposerKeywords"},

    {" com", "Xmp.video.Composer"},

    {" cpy", "Xmp.video.Copyright"},

    {" day", "Xmp.video.CreateDate"},

    {" dir", "Xmp.video.Director"},

    {" ed1", "Xmp.video.Edit1"},

    {" ed2", "Xmp.video.Edit2"},

    {" ed3", "Xmp.video.Edit3"},

    {" ed4", "Xmp.video.Edit4"},

    {" ed5", "Xmp.video.Edit5"},

    {" ed6", "Xmp.video.Edit6"},

    {" ed7", "Xmp.video.Edit7"},

    {" ed8", "Xmp.video.Edit8"},

    {" ed9", "Xmp.video.Edit9"},

    {" enc", "Xmp.video.Encoder"},

    {" fmt", "Xmp.video.Format"},

    {" gen", "Xmp.video.Genre"},

    {" grp", "Xmp.video.Grouping"},

    {" inf", "Xmp.video.Information"},

    {" isr", "Xmp.video.ISRCCode"},

    {" lab", "Xmp.video.RecordLabelName"},

    {" lal", "Xmp.video.RecordLabelURL"},

    {" lyr", "Xmp.video.Lyrics"},

    {" mak", "Xmp.video.Make"},

    {" mal", "Xmp.video.MakerURL"},

    {" mod", "Xmp.video.Model"},

    {" nam", "Xmp.video.Title"},

    {" pdk", "Xmp.video.ProducerKeywords"},

    {" phg", "Xmp.video.RecordingCopyright"},

    {" prd", "Xmp.video.Producer"},

    {" prf", "Xmp.video.Performers"},

    {" prk", "Xmp.video.PerformerKeywords"},

    {" prl", "Xmp.video.PerformerURL"},

    {" req", "Xmp.video.Requirements"},

    {" snk", "Xmp.video.SubtitleKeywords"},

    {" snm", "Xmp.video.Subtitle"},

    {" src", "Xmp.video.SourceCredits"},

    {" swf", "Xmp.video.SongWriter"},

    {" swk", "Xmp.video.SongWriterKeywords"},

    {" swr", "Xmp.video.SoftwareVersion"},

    {" too", "Xmp.video.Encoder"},

    {" trk", "Xmp.video.Track"},

    {" wrt", "Xmp.video.Composer"},

    {" xyz", "Xmp.video.GPSCoordinates"},

    {"CMbo", "Xmp.video.CameraByteOrder"},

    {"Cmbo", "Xmp.video.CameraByteOrder"},

};

static constexpr TagDetails NikonNCTGTags[] = {

    {0x0001, "Xmp.video.Make"},

    {0x0002, "Xmp.video.Model"},

    {0x0003, "Xmp.video.Software"},

    {0x0011, "Xmp.video.CreationDate"},

    {0x0012, "Xmp.video.DateTimeOriginal"},

    {0x0013, "Xmp.video.FrameCount"},

    {0x0016, "Xmp.video.FrameRate"},

    {0x0022, "Xmp.video.FrameWidth"},

    {0x0023, "Xmp.video.FrameHeight"},

    {0x0032, "Xmp.audio.channelType"},

    {0x0033, "Xmp.audio.BitsPerSample"},

    {0x0034, "Xmp.audio.sampleRate"},

    {0x1108822, "Xmp.video.ExposureProgram"},

    {0x1109204, "Xmp.video.ExposureCompensation"},

    {0x1109207, "Xmp.video.MeteringMode"},

    {0x110a434, "Xmp.video.LensModel"},

    {0x1200000, "Xmp.video.GPSVersionID"},

    {0x1200001, "Xmp.video.GPSLatitudeRef"},

    {0x1200002, "Xmp.video.GPSLatitude"},

    {0x1200003, "Xmp.video.GPSLongitudeRef"},

    {0x1200004, "Xmp.video.GPSLongitude"},

    {0x1200005, "Xmp.video.GPSAltitudeRef"},

    {0x1200006, "Xmp.video.GPSAltitude"},

    {0x1200007, "Xmp.video.GPSTimeStamp"},

    {0x1200008, "Xmp.video.GPSSatellites"},

    {0x1200010, "Xmp.video.GPSImgDirectionRef"},

    {0x1200011, "Xmp.video.GPSImgDirection"},

    {0x1200012, "Xmp.video.GPSMapDatum"},

    {0x120001d, "Xmp.video.GPSDateStamp"},

    {0x2000001, "Xmp.video.MakerNoteVersion"},

    {0x2000005, "Xmp.video.WhiteBalance"},

    {0x200000b, "Xmp.video.WhiteBalanceFineTune"},

    {0x200001e, "Xmp.video.ColorSpace"},

    {0x2000023, "Xmp.video.PictureControlData"},

    {0x2000024, "Xmp.video.WorldTime"},

    {0x200002c, "Xmp.video.UnknownInfo"},

    {0x2000032, "Xmp.video.UnknownInfo2"},

    {0x2000039, "Xmp.video.LocationInfo"},

    {0x2000083, "Xmp.video.LensType"},

    {0x2000084, "Xmp.video.LensModel"},

    {0x20000ab, "Xmp.video.VariProgram"},

};

[[maybe_unused]] static constexpr TagDetails NikonColorSpace[] = {

    {1, "sRGB"},

    {2, "Adobe RGB"},

};

[[maybe_unused]] static constexpr TagVocabulary NikonGPS_Latitude_Longitude_ImgDirection_Reference[] = {

    {"N", "North"}, {"S", "South"}, {"E", "East"}, {"W", "West"}, {"M", "Magnetic North"}, {"T", "True North"},

};

[[maybe_unused]] static constexpr TagDetails NikonGPSAltitudeRef[] = {

    {0, "Above Sea Level"},

    {1, "Below Sea Level"},

};

[[maybe_unused]] static constexpr TagDetails NikonExposureProgram[] = {

    {0, "Not Defined"},

    {1, "Manual"},

    {2, "Program AE"},

    {3, "Aperture-priority AE"},

    {4, "Shutter speed priority AE"},

    {5, "Creative (Slow speed)"},

    {6, "Action (High speed)"},

    {7, "Portrait"},

    {8, "Landscape"},

};

[[maybe_unused]] static constexpr TagDetails NikonMeteringMode[] = {

    {0, "Unknown"}, {1, "Average"},    {2, "Center-weighted average"},

    {3, "Spot"},    {4, "Multi-spot"}, {5, "Multi-segment"},

    {6, "Partial"}, {255, "Other"},

};

static constexpr TagDetails PictureControlAdjust[] = {

    {0, "Default Settings"},

    {1, "Quick Adjust"},

    {2, "Full Control"},

};

//! Contrast and Sharpness

static constexpr TagDetails NormalSoftHard[] = {

    {0, "Normal"},

    {1, "Soft"},

    {2, "Hard"},

};

//! Saturation

static constexpr TagDetails Saturation[] = {

    {0, "Normal"},

    {1, "Low"},

    {2, "High"},

};

//! YesNo, used for DaylightSavings

static constexpr TagDetails YesNo[] = {

    {0, "No"},

    {1, "Yes"},

};

//! DateDisplayFormat

static constexpr TagDetails DateDisplayFormat[] = {

    {0, "Y/M/D"},

    {1, "M/D/Y"},

    {2, "D/M/Y"},

};

static constexpr TagDetails FilterEffect[] = {

    {0x80, "Off"}, {0x81, "Yellow"}, {0x82, "Orange"}, {0x83, "Red"}, {0x84, "Green"}, {0xff, "n/a"},

};

static constexpr TagDetails ToningEffect[] = {

    {0x80, "B&W"},         {0x81, "Sepia"},      {0x82, "Cyanotype"},  {0x83, "Red"},

    {0x84, "Yellow"},      {0x85, "Green"},      {0x86, "Blue-green"}, {0x87, "Blue"},

    {0x88, "Purple-blue"}, {0x89, "Red-purple"}, {0xff, "n/a"},

};

static constexpr TagDetails whiteBalance[] = {

    {0, "Auto"}, {1, "Daylight"}, {2, "Shade"}, {3, "Fluorescent"}, {4, "Tungsten"}, {5, "Manual"},

};

enum movieHeaderTags {

  MovieHeaderVersion,

  CreateDate,

  ModifyDate,

  TimeScale,

  Duration,

  PreferredRate,

  PreferredVolume,

  PreviewTime = 18,

  PreviewDuration,

  PosterTime,

  SelectionTime,

  SelectionDuration,

  CurrentTime,

  NextTrackID

};

enum trackHeaderTags {

  TrackHeaderVersion,

  TrackCreateDate,

  TrackModifyDate,

  TrackID,

  TrackDuration = 5,

  TrackLayer = 8,

  TrackVolume,

  ImageWidth = 19,

  ImageHeight

};

enum mediaHeaderTags {

  MediaHeaderVersion,

  MediaCreateDate,

  MediaModifyDate,

  MediaTimeScale,

  MediaDuration,

  MediaLanguageCode

};

enum handlerTags { HandlerClass = 1, HandlerType, HandlerVendorID };

enum videoHeaderTags { GraphicsMode = 2, OpColor };

enum stream { Video, Audio, Hint, Null, GenMediaHeader };

enum imageDescTags {

  codec,

  VendorID = 4,

  SourceImageWidth_Height = 7,

  XResolution,

  YResolution,

  CompressorName = 10,

  BitDepth

};

enum audioDescTags { AudioFormat, AudioVendorID = 4, AudioChannels, AudioSampleRate = 7, MOV_AudioFormat = 13 };

/*!

  @brief Function used to check equality of a Tags with a

      particular string (ignores case while comparing).

  @param buf Data buffer that will contain Tag to compare

  @param str char* Pointer to string

  @return Returns true if the buffer value is equal to string.

 */

static bool equalsQTimeTag(Exiv2::DataBuf& buf, const char str[5]) {

  return std::equal(buf.begin(), buf.begin() + 4, str,

                    [](auto b, auto s) { return std::tolower(b) == std::tolower(s); });

}

/*!

  @brief Function used to ignore Tags and values stored in them,

      since they are not necessary as metadata information

  @param buf Data buffer that will contain Tag to compare

  @return Returns true, if Tag is found in the ignoreList[]

 */

static bool ignoreList(Exiv2::DataBuf& buf) {

  const char ignoreList[13][5] = {

      "mdat", "edts", "junk", "iods", "alis", "stsc", "stsz", "stco", "ctts", "stss", "skip", "wide", "cmvd",

  };

  for (auto i : ignoreList)

    if (equalsQTimeTag(buf, i))

      return true;

  return false;

}

/*!

  @brief Function used to ignore Tags, basically Tags which

      contain other tags inside them, since they are not necessary

      as metadata information

  @param buf Data buffer that will contain Tag to compare

  @return Returns true, if Tag is found in the ignoreList[]

 */

static bool dataIgnoreList(Exiv2::DataBuf& buf) {

  const char ignoreList[8][5] = {

      "moov", "mdia", "minf", "dinf", "alis", "stbl", "cmov", "meta",

  };

  for (auto i : ignoreList)

    if (equalsQTimeTag(buf, i))

      return true;

  return false;

}

}  // namespace Exiv2::Internal

namespace Exiv2 {

using namespace Exiv2::Internal;

QuickTimeVideo::QuickTimeVideo(BasicIo::UniquePtr io, size_t max_recursion_depth) :

    Image(ImageType::qtime, mdNone, std::move(io)),

    mvhdTimeScale_(1),

    mdhdTimeScale_(1),

    currentStream_(Null),

    max_recursion_depth_(max_recursion_depth) {

}  // QuickTimeVideo::QuickTimeVideo

std::string QuickTimeVideo::mimeType() const {

  return "video/quicktime";

}

void QuickTimeVideo::writeMetadata() {

}

void QuickTimeVideo::readMetadata() {

  if (io_->open() != 0)

    throw Error(ErrorCode::kerDataSourceOpenFailed, io_->path(), strError());

  // Ensure that this is the correct image type

  if (!isQTimeType(*io_, false)) {

    if (io_->error() || io_->eof())

      throw Error(ErrorCode::kerFailedToReadImageData);

    throw Error(ErrorCode::kerNotAnImage, "QuickTime");

  }

  IoCloser closer(*io_);

  clearMetadata();

  continueTraversing_ = true;

  height_ = width_ = 1;

  xmpData_["Xmp.video.FileSize"] = static_cast<double>(io_->size()) / 1048576.0;

  xmpData_["Xmp.video.MimeType"] = mimeType();

  while (continueTraversing_)

    decodeBlock(0);

  xmpData_["Xmp.video.AspectRatio"] = getAspectRatio(width_, height_);

}  // QuickTimeVideo::readMetadata

void QuickTimeVideo::decodeBlock(size_t recursion_depth, std::string const& entered_from) {

  enforce(recursion_depth < max_recursion_depth_, Exiv2::ErrorCode::kerCorruptedMetadata);

  const long bufMinSize = 4;

  DataBuf buf(bufMinSize + 1);

  uint64_t size = 0;

  buf.data()[4] = '\0';

  io_->read(buf.data(), 4);

  if (io_->eof()) {

    continueTraversing_ = false;

    return;

  }

  size = buf.read_uint32(0, bigEndian);

  io_->readOrThrow(buf.data(), 4);

  // we have read 2x 4 bytes

  size_t hdrsize = 8;

  if (size == 1) {

    // The box size is encoded as a uint64_t, so we need to read another 8 bytes.

    DataBuf data(8);

    hdrsize += 8;

    io_->readOrThrow(data.data(), data.size());

    size = data.read_uint64(0, bigEndian);

  } else if (size == 0 && entered_from == "meta") {

    size = buf.read_uint32(0, bigEndian);

    io_->readOrThrow(buf.data(), 4, Exiv2::ErrorCode::kerCorruptedMetadata);

  }

  enforce(size >= hdrsize, Exiv2::ErrorCode::kerCorruptedMetadata);

  enforce(size - hdrsize <= io_->size() - io_->tell(), Exiv2::ErrorCode::kerCorruptedMetadata);

  enforce(size - hdrsize <= std::numeric_limits<size_t>::max(), Exiv2::ErrorCode::kerCorruptedMetadata);

  // std::cerr<<"Tag=>"<<buf.data()<<"     size=>"<<size-hdrsize << '\n';

  const auto newsize = static_cast<size_t>(size - hdrsize);

  if (ignoreList(buf)) {

    discard(newsize);

    return;

  }

  if (newsize > buf.size()) {

    buf.resize(newsize);

  }

  tagDecoder(buf, newsize, recursion_depth + 1);

}  // QuickTimeVideo::decodeBlock

static std::string readString(BasicIo& io, size_t size) {

  enforce(size <= io.size() - io.tell(), Exiv2::ErrorCode::kerCorruptedMetadata);

  Exiv2::DataBuf str(size + 1);

  io.readOrThrow(str.data(), size);

  str.write_uint8(size, 0);  // nul-terminate string

  return Exiv2::toString(str.data());

}

void QuickTimeVideo::tagDecoder(Exiv2::DataBuf& buf, size_t size, size_t recursion_depth) {

  enforce(recursion_depth < max_recursion_depth_, Exiv2::ErrorCode::kerCorruptedMetadata);

  assert(buf.size() > 4);

  if (ignoreList(buf))

    discard(size);

  else if (dataIgnoreList(buf)) {

    decodeBlock(recursion_depth + 1, Exiv2::toString(buf.data()));

  } else if (equalsQTimeTag(buf, "ftyp"))

    fileTypeDecoder(size);

  else if (equalsQTimeTag(buf, "trak"))

    setMediaStream(size);

  else if (equalsQTimeTag(buf, "mvhd"))

    movieHeaderDecoder(size);

  else if (equalsQTimeTag(buf, "tkhd"))

    trackHeaderDecoder(size);

  else if (equalsQTimeTag(buf, "mdhd"))

    mediaHeaderDecoder(size);

  else if (equalsQTimeTag(buf, "hdlr"))

    handlerDecoder(size);

  else if (equalsQTimeTag(buf, "vmhd"))

    videoHeaderDecoder(size);

  else if (equalsQTimeTag(buf, "udta"))

    userDataDecoder(size, recursion_depth + 1);

  else if (equalsQTimeTag(buf, "dref"))

    multipleEntriesDecoder(recursion_depth + 1);

  else if (equalsQTimeTag(buf, "stsd"))

    sampleDesc(size);

  else if (equalsQTimeTag(buf, "stts"))

    timeToSampleDecoder();

  else if (equalsQTimeTag(buf, "pnot"))

    previewTagDecoder(size);

  else if (equalsQTimeTag(buf, "tapt"))

    trackApertureTagDecoder(size);

  else if (equalsQTimeTag(buf, "keys"))

    keysTagDecoder(size);

  else if (equalsQTimeTag(buf, "url ")) {

    if (currentStream_ == Video)

      xmpData_["Xmp.video.URL"] = readString(*io_, size);

    else if (currentStream_ == Audio)

      xmpData_["Xmp.audio.URL"] = readString(*io_, size);

    else

      discard(size);

  }

  else if (equalsQTimeTag(buf, "urn ")) {

    if (currentStream_ == Video)

      xmpData_["Xmp.video.URN"] = readString(*io_, size);

    else if (currentStream_ == Audio)

      xmpData_["Xmp.audio.URN"] = readString(*io_, size);

    else

      discard(size);

  }

  else if (equalsQTimeTag(buf, "dcom")) {

    xmpData_["Xmp.video.Compressor"] = readString(*io_, size);

  }

  else if (equalsQTimeTag(buf, "smhd")) {

    io_->readOrThrow(buf.data(), 4);

    io_->readOrThrow(buf.data(), 4);

    xmpData_["Xmp.audio.Balance"] = buf.read_uint16(0, bigEndian);

  }

  else {

    discard(size);

  }

}  // QuickTimeVideo::tagDecoder

void QuickTimeVideo::discard(size_t size) {

  size_t cur_pos = io_->tell();

  io_->seek(cur_pos + size, BasicIo::beg);

}  // QuickTimeVideo::discard

void QuickTimeVideo::previewTagDecoder(size_t size) {

  DataBuf buf(4);

  size_t cur_pos = io_->tell();

  io_->readOrThrow(buf.data(), 4);

  xmpData_["Xmp.video.PreviewDate"] = buf.read_uint32(0, bigEndian);

  io_->readOrThrow(buf.data(), 2);

  xmpData_["Xmp.video.PreviewVersion"] = getShort(buf.data(), bigEndian);

  io_->readOrThrow(buf.data(), 4);

  if (equalsQTimeTag(buf, "PICT"))

    xmpData_["Xmp.video.PreviewAtomType"] = "QuickDraw Picture";

  else

    xmpData_["Xmp.video.PreviewAtomType"] = std::string{buf.c_str(), 4};

  io_->seek(cur_pos + size, BasicIo::beg);

}  // QuickTimeVideo::previewTagDecoder

void QuickTimeVideo::keysTagDecoder(size_t size) {

  DataBuf buf(4);

  size_t cur_pos = io_->tell();

  io_->readOrThrow(buf.data(), 4);

  xmpData_["Xmp.video.PreviewDate"] = buf.read_uint32(0, bigEndian);

  io_->readOrThrow(buf.data(), 2);

  xmpData_["Xmp.video.PreviewVersion"] = getShort(buf.data(), bigEndian);

  io_->readOrThrow(buf.data(), 4);

  if (equalsQTimeTag(buf, "PICT"))

    xmpData_["Xmp.video.PreviewAtomType"] = "QuickDraw Picture";

  else

    xmpData_["Xmp.video.PreviewAtomType"] = std::string{buf.c_str(), 4};

  io_->seek(cur_pos + size, BasicIo::beg);

}  // QuickTimeVideo::keysTagDecoder

void QuickTimeVideo::trackApertureTagDecoder(size_t size) {

  DataBuf buf(4);

  DataBuf buf2(2);

  size_t cur_pos = io_->tell();

  byte n = 3;

  while (n--) {

    io_->seek(4L, BasicIo::cur);

    io_->readOrThrow(buf.data(), 4);

    if (equalsQTimeTag(buf, "clef")) {

      io_->seek(4L, BasicIo::cur);

      io_->readOrThrow(buf.data(), 2);

      io_->readOrThrow(buf2.data(), 2);

      xmpData_["Xmp.video.CleanApertureWidth"] =

          stringFormat("{}.{}", buf.read_uint16(0, bigEndian), buf2.read_uint16(0, bigEndian));

      io_->readOrThrow(buf.data(), 2);

      io_->readOrThrow(buf2.data(), 2);

      xmpData_["Xmp.video.CleanApertureHeight"] =

          stringFormat("{}.{}", buf.read_uint16(0, bigEndian), buf2.read_uint16(0, bigEndian));

    }

    else if (equalsQTimeTag(buf, "prof")) {

      io_->seek(4L, BasicIo::cur);

      io_->readOrThrow(buf.data(), 2);

      io_->readOrThrow(buf2.data(), 2);

      xmpData_["Xmp.video.ProductionApertureWidth"] =

          stringFormat("{}.{}", buf.read_uint16(0, bigEndian), buf2.read_uint16(0, bigEndian));

      io_->readOrThrow(buf.data(), 2);

      io_->readOrThrow(buf2.data(), 2);

      xmpData_["Xmp.video.ProductionApertureHeight"] =

          stringFormat("{}.{}", buf.read_uint16(0, bigEndian), buf2.read_uint16(0, bigEndian));

    }

    else if (equalsQTimeTag(buf, "enof")) {

      io_->seek(4L, BasicIo::cur);

      io_->readOrThrow(buf.data(), 2);

      io_->readOrThrow(buf2.data(), 2);

      xmpData_["Xmp.video.EncodedPixelsWidth"] =

          stringFormat("{}.{}", buf.read_uint16(0, bigEndian), buf2.read_uint16(0, bigEndian));

      io_->readOrThrow(buf.data(), 2);

      io_->readOrThrow(buf2.data(), 2);

      xmpData_["Xmp.video.EncodedPixelsHeight"] =

          stringFormat("{}.{}", buf.read_uint16(0, bigEndian), buf2.read_uint16(0, bigEndian));

    }

  }

  io_->seek(cur_pos + size, BasicIo::beg);

}  // QuickTimeVideo::trackApertureTagDecoder

void QuickTimeVideo::CameraTagsDecoder(size_t size) {

  size_t cur_pos = io_->tell();

  DataBuf buf(50);

  DataBuf buf2(4);

  io_->readOrThrow(buf.data(), 4);

  if (equalsQTimeTag(buf, "NIKO")) {

    io_->seek(cur_pos, BasicIo::beg);

    io_->readOrThrow(buf.data(), 24);

    xmpData_["Xmp.video.Make"] = buf.data();

    io_->readOrThrow(buf.data(), 14);

    xmpData_["Xmp.video.Model"] = buf.data();

    io_->readOrThrow(buf.data(), 4);

    xmpData_["Xmp.video.ExposureTime"] = stringFormat("1/{}", std::ceil(buf.read_uint32(0, littleEndian) / 10.0));

    io_->readOrThrow(buf.data(), 4);

    io_->readOrThrow(buf2.data(), 4);

    xmpData_["Xmp.video.FNumber"] =

        buf.read_uint32(0, littleEndian) / static_cast<double>(buf2.read_uint32(0, littleEndian));

    io_->readOrThrow(buf.data(), 4);

    io_->readOrThrow(buf2.data(), 4);

    xmpData_["Xmp.video.ExposureCompensation"] =

        buf.read_uint32(0, littleEndian) / static_cast<double>(buf2.read_uint32(0, littleEndian));

    io_->readOrThrow(buf.data(), 10);

    io_->readOrThrow(buf.data(), 4);

    if (auto td = Exiv2::find(whiteBalance, buf.read_uint32(0, littleEndian)))

      xmpData_["Xmp.video.WhiteBalance"] = _(td->label_);

    io_->readOrThrow(buf.data(), 4);

    io_->readOrThrow(buf2.data(), 4);

    xmpData_["Xmp.video.FocalLength"] =

        buf.read_uint32(0, littleEndian) / static_cast<double>(buf2.read_uint32(0, littleEndian));

    io_->seek(95L, BasicIo::cur);

    io_->readOrThrow(buf.data(), 48);

    buf.write_uint8(48, 0);

    xmpData_["Xmp.video.Software"] = buf.data();

    io_->readOrThrow(buf.data(), 4);

    xmpData_["Xmp.video.ISO"] = buf.read_uint32(0, littleEndian);

  }

  io_->seek(cur_pos + size, BasicIo::beg);

}  // QuickTimeVideo::CameraTagsDecoder

void QuickTimeVideo::userDataDecoder(size_t outer_size, size_t recursion_depth) {

  enforce(recursion_depth < max_recursion_depth_, Exiv2::ErrorCode::kerCorruptedMetadata);

  size_t cur_pos = io_->tell();

  const TagVocabulary* td;

  const TagVocabulary* tv;

  const TagVocabulary* tv_internal;

  const long bufMinSize = 100;

  DataBuf buf(bufMinSize);

  size_t size_internal = outer_size;

  std::memset(buf.data(), 0x0, buf.size());

  while ((size_internal / 4 != 0) && (size_internal > 0)) {

    buf.data()[4] = '\0';

    io_->readOrThrow(buf.data(), 4);

    const size_t size = buf.read_uint32(0, bigEndian);

    if (size > size_internal)

      break;

    size_internal -= size;

    io_->readOrThrow(buf.data(), 4);

    if (buf.data()[0] == 169)

      buf.data()[0] = ' ';

    td = Exiv2::find(userDatatags, Exiv2::toString(buf.data()));

    tv = Exiv2::find(userDataReferencetags, Exiv2::toString(buf.data()));

    if (size <= 12)

      break;

    if (equalsQTimeTag(buf, "DcMD") || equalsQTimeTag(buf, "NCDT"))

      userDataDecoder(size - 8, recursion_depth + 1);

    else if (equalsQTimeTag(buf, "NCTG"))

      NikonTagsDecoder(size - 8);

    else if (equalsQTimeTag(buf, "TAGS"))

      CameraTagsDecoder(size - 8);

    else if (equalsQTimeTag(buf, "CNCV") || equalsQTimeTag(buf, "CNFV") || equalsQTimeTag(buf, "CNMN") ||

             equalsQTimeTag(buf, "NCHD") || equalsQTimeTag(buf, "FFMV")) {

      enforce(tv, Exiv2::ErrorCode::kerCorruptedMetadata);

      xmpData_[_(tv->label_)] = readString(*io_, size - 8);

    }

    else if (equalsQTimeTag(buf, "CMbo") || equalsQTimeTag(buf, "Cmbo")) {

      enforce(tv, Exiv2::ErrorCode::kerCorruptedMetadata);

      io_->readOrThrow(buf.data(), 2);

      buf.data()[2] = '\0';

      tv_internal = Exiv2::find(cameraByteOrderTags, Exiv2::toString(buf.data()));

      if (tv_internal)

        xmpData_[_(tv->label_)] = _(tv_internal->label_);

      else

        xmpData_[_(tv->label_)] = buf.data();

    }

    else if (tv) {

      io_->readOrThrow(buf.data(), 4);

      xmpData_[_(tv->label_)] = readString(*io_, size - 12);

    }

    else if (td)

      tagDecoder(buf, size - 8, recursion_depth + 1);

  }

  io_->seek(cur_pos + outer_size, BasicIo::beg);

}  // QuickTimeVideo::userDataDecoder

void QuickTimeVideo::NikonTagsDecoder(size_t size) {

  size_t cur_pos = io_->tell();

  DataBuf buf(201);

  DataBuf buf2(4 + 1);

  uint32_t TagID = 0;

  uint16_t dataLength = 0;

  uint16_t dataType = 2;

  const TagDetails* td;

  const TagDetails* td2;

  for (int i = 0; i < 100; i++) {

    io_->readOrThrow(buf.data(), 4);

    TagID = buf.read_uint32(0, bigEndian);

    td = Exiv2::find(NikonNCTGTags, TagID);

    io_->readOrThrow(buf.data(), 2);

    dataType = buf.read_uint16(0, bigEndian);

    std::memset(buf.data(), 0x0, buf.size());

    io_->readOrThrow(buf.data(), 2);

    if (TagID == 0x2000023) {

      size_t local_pos = io_->tell();

      dataLength = buf.read_uint16(0, bigEndian);

      std::memset(buf.data(), 0x0, buf.size());

      io_->readOrThrow(buf.data(), 4);

      xmpData_["Xmp.video.PictureControlVersion"] = buf.data();

      io_->readOrThrow(buf.data(), 20);

      xmpData_["Xmp.video.PictureControlName"] = buf.data();

      io_->readOrThrow(buf.data(), 20);

      xmpData_["Xmp.video.PictureControlBase"] = buf.data();

      io_->readOrThrow(buf.data(), 4);

      std::memset(buf.data(), 0x0, buf.size());

      io_->readOrThrow(buf.data(), 1);

      td2 = Exiv2::find(PictureControlAdjust, static_cast<int>(buf.data()[0]) & 7);

      if (td2)

        xmpData_["Xmp.video.PictureControlAdjust"] = _(td2->label_);

      else

        xmpData_["Xmp.video.PictureControlAdjust"] = static_cast<int>(buf.data()[0]) & 7;

      io_->readOrThrow(buf.data(), 1);

      td2 = Exiv2::find(NormalSoftHard, static_cast<int>(buf.data()[0]) & 7);

      if (td2)

        xmpData_["Xmp.video.PictureControlQuickAdjust"] = _(td2->label_);

      io_->readOrThrow(buf.data(), 1);

      td2 = Exiv2::find(NormalSoftHard, static_cast<int>(buf.data()[0]) & 7);

      if (td2)

        xmpData_["Xmp.video.Sharpness"] = _(td2->label_);

      else

        xmpData_["Xmp.video.Sharpness"] = static_cast<int>(buf.data()[0]) & 7;

      io_->readOrThrow(buf.data(), 1);

      td2 = Exiv2::find(NormalSoftHard, static_cast<int>(buf.data()[0]) & 7);

      if (td2)

        xmpData_["Xmp.video.Contrast"] = _(td2->label_);

      else

        xmpData_["Xmp.video.Contrast"] = static_cast<int>(buf.data()[0]) & 7;

      io_->readOrThrow(buf.data(), 1);

      td2 = Exiv2::find(NormalSoftHard, static_cast<int>(buf.data()[0]) & 7);

      if (td2)

        xmpData_["Xmp.video.Brightness"] = _(td2->label_);

      else

        xmpData_["Xmp.video.Brightness"] = static_cast<int>(buf.data()[0]) & 7;

      io_->readOrThrow(buf.data(), 1);

      td2 = Exiv2::find(Saturation, static_cast<int>(buf.data()[0]) & 7);

      if (td2)

        xmpData_["Xmp.video.Saturation"] = _(td2->label_);

      else

        xmpData_["Xmp.video.Saturation"] = static_cast<int>(buf.data()[0]) & 7;

      io_->readOrThrow(buf.data(), 1);

      xmpData_["Xmp.video.HueAdjustment"] = static_cast<int>(buf.data()[0]) & 7;

      io_->readOrThrow(buf.data(), 1);

      td2 = Exiv2::find(FilterEffect, static_cast<int>(buf.data()[0]));

      if (td2)

        xmpData_["Xmp.video.FilterEffect"] = _(td2->label_);

      else

        xmpData_["Xmp.video.FilterEffect"] = static_cast<int>(buf.data()[0]);

      io_->readOrThrow(buf.data(), 1);

      td2 = Exiv2::find(ToningEffect, static_cast<int>(buf.data()[0]));

      if (td2)

        xmpData_["Xmp.video.ToningEffect"] = _(td2->label_);

      else

        xmpData_["Xmp.video.ToningEffect"] = static_cast<int>(buf.data()[0]);

      io_->readOrThrow(buf.data(), 1);

      xmpData_["Xmp.video.ToningSaturation"] = static_cast<int>(buf.data()[0]);

      io_->seek(local_pos + dataLength, BasicIo::beg);

    }

    else if (TagID == 0x2000024) {

      size_t local_pos = io_->tell();

      dataLength = buf.read_uint16(0, bigEndian);

      std::memset(buf.data(), 0x0, buf.size());

      io_->readOrThrow(buf.data(), 2);

      xmpData_["Xmp.video.TimeZone"] = Exiv2::getShort(buf.data(), bigEndian);

      io_->readOrThrow(buf.data(), 1);

      td2 = Exiv2::find(YesNo, static_cast<int>(buf.data()[0]));

      if (td2)

        xmpData_["Xmp.video.DayLightSavings"] = _(td2->label_);

      io_->readOrThrow(buf.data(), 1);

      td2 = Exiv2::find(DateDisplayFormat, static_cast<int>(buf.data()[0]));

      if (td2)

        xmpData_["Xmp.video.DateDisplayFormat"] = _(td2->label_);

      io_->seek(local_pos + dataLength, BasicIo::beg);

    }

    else if (dataType == 2 || dataType == 7) {

      dataLength = buf.read_uint16(0, bigEndian);

      std::memset(buf.data(), 0x0, buf.size());

      // Sanity check with an "unreasonably" large number

      if (dataLength >= buf.size()) {

#ifndef SUPPRESS_WARNINGS

        EXV_ERROR << "Xmp.video Nikon Tags, dataLength was found to be larger than 200."

                  << " Entries considered invalid. Not Processed.\n";

#endif

        io_->seek(io_->tell() + dataLength, BasicIo::beg);

        buf.data()[0] = '\0';

      } else {

        io_->readOrThrow(buf.data(), dataLength);

        buf.data()[dataLength] = '\0';

      }

      if (td) {

        xmpData_[_(td->label_)] = buf.data();

      }

    } else if (dataType == 4) {

      dataLength = buf.read_uint16(0, bigEndian) * 4;

      std::memset(buf.data(), 0x0, buf.size());

      io_->readOrThrow(buf.data(), 4);

      if (td)

        xmpData_[_(td->label_)] = buf.read_uint32(0, bigEndian);

      // Sanity check with an "unreasonably" large number

      if (dataLength > 200 || dataLength < 4) {

#ifndef SUPPRESS_WARNINGS

        EXV_ERROR << "Xmp.video Nikon Tags, dataLength was found to be of inappropriate size."

                  << " Entries considered invalid. Not Processed.\n";

#endif

        io_->seek(io_->tell() + dataLength - 4, BasicIo::beg);

      } else

        io_->readOrThrow(buf.data(), dataLength - 4);

    } else if (dataType == 3) {