src/Metadata.h

   1 /*
   2 Copyright (c) 2005-2006, John Hurst
   3 All rights reserved.
   4
   5 Redistribution and use in source and binary forms, with or without
   6 modification, are permitted provided that the following conditions
   7 are met:
   8 1. Redistributions of source code must retain the above copyright
   9    notice, this list of conditions and the following disclaimer.
  10 2. Redistributions in binary form must reproduce the above copyright
  11    notice, this list of conditions and the following disclaimer in the
  12    documentation and/or other materials provided with the distribution.
  13 3. The name of the author may not be used to endorse or promote products
  14    derived from this software without specific prior written permission.
  15
  16 THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  17 IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  18 OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  19 IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  20 INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  21 NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  22 DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  23 THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  24 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  25 THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26 */
  27 /*! \file    Metadata.h
  28     \version $Id$
  29     \brief   MXF metadata objects
  30 */
  31
  32 #ifndef _METADATA_H_
  33 #define _METADATA_H_
  34
  35 #include "MXF.h"
  36
  37 namespace ASDCP
  38 {
  39   namespace MXF
  40     {
  41       //
  42
  43       //
  44       class Identification : public InterchangeObject
  45         {
  46           ASDCP_NO_COPY_CONSTRUCT(Identification);
  47
  48         public:
  49           UUID ThisGenerationUID;
  50           UTF16String CompanyName;
  51           UTF16String ProductName;
  52           VersionType ProductVersion;
  53           UTF16String VersionString;
  54           UUID ProductUID;
  55           Timestamp ModificationDate;
  56           VersionType ToolkitVersion;
  57           UTF16String Platform;
  58
  59           Identification() {}
  60           virtual ~Identification() {}
  61           virtual const char* HasName() { return "Identification"; }
  62           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
  63           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
  64           virtual void     Dump(FILE* = 0);
  65           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
  66           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
  67         };
  68
  69       //
  70       class ContentStorage : public InterchangeObject
  71         {
  72           ASDCP_NO_COPY_CONSTRUCT(ContentStorage);
  73
  74         public:
  75           Batch<UUID> Packages;
  76           Batch<UUID> EssenceContainerData;
  77
  78           ContentStorage() {}
  79           virtual ~ContentStorage() {}
  80           virtual const char* HasName() { return "ContentStorage"; }
  81           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
  82           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
  83           virtual void     Dump(FILE* = 0);
  84           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
  85           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
  86         };
  87
  88       //
  89       class EssenceContainerData : public InterchangeObject
  90         {
  91           ASDCP_NO_COPY_CONSTRUCT(EssenceContainerData);
  92
  93         public:
  94           UMID LinkedPackageUID;
  95           ui32_t IndexSID;
  96           ui32_t BodySID;
  97
  98           EssenceContainerData() : IndexSID(0), BodySID(0) {}
  99           virtual ~EssenceContainerData() {}
 100           virtual const char* HasName() { return "EssenceContainerData"; }
 101           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 102           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 103           virtual void     Dump(FILE* = 0);
 104           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 105           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 106         };
 107
 108       //
 109       class GenericPackage : public InterchangeObject
 110         {
 111           ASDCP_NO_COPY_CONSTRUCT(GenericPackage);
 112
 113         public:
 114           UMID PackageUID;
 115           UTF16String Name;
 116           Timestamp PackageCreationDate;
 117           Timestamp PackageModifiedDate;
 118           Batch<UUID> Tracks;
 119
 120           GenericPackage() {}
 121           virtual ~GenericPackage() {}
 122           virtual const char* HasName() { return "GenericPackage"; }
 123           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 124           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 125           virtual void     Dump(FILE* = 0);
 126         };
 127
 128       //
 129       class MaterialPackage : public GenericPackage
 130         {
 131           ASDCP_NO_COPY_CONSTRUCT(MaterialPackage);
 132
 133         public:
 134
 135           MaterialPackage() {}
 136           virtual ~MaterialPackage() {}
 137           virtual const char* HasName() { return "MaterialPackage"; }
 138           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 139           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 140           virtual void     Dump(FILE* = 0);
 141           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 142           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 143         };
 144
 145       //
 146       class SourcePackage : public GenericPackage
 147         {
 148           ASDCP_NO_COPY_CONSTRUCT(SourcePackage);
 149
 150         public:
 151           UUID Descriptor;
 152
 153           SourcePackage() {}
 154           virtual ~SourcePackage() {}
 155           virtual const char* HasName() { return "SourcePackage"; }
 156           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 157           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 158           virtual void     Dump(FILE* = 0);
 159           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 160           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 161         };
 162
 163       //
 164       class GenericTrack : public InterchangeObject
 165         {
 166           ASDCP_NO_COPY_CONSTRUCT(GenericTrack);
 167
 168         public:
 169           ui32_t TrackID;
 170           ui32_t TrackNumber;
 171           UTF16String TrackName;
 172           UUID Sequence;
 173
 174           GenericTrack() : TrackID(0), TrackNumber(0) {}
 175           virtual ~GenericTrack() {}
 176           virtual const char* HasName() { return "GenericTrack"; }
 177           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 178           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 179           virtual void     Dump(FILE* = 0);
 180         };
 181
 182       //
 183       class StaticTrack : public GenericTrack
 184         {
 185           ASDCP_NO_COPY_CONSTRUCT(StaticTrack);
 186
 187         public:
 188
 189           StaticTrack() {}
 190           virtual ~StaticTrack() {}
 191           virtual const char* HasName() { return "StaticTrack"; }
 192           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 193           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 194           virtual void     Dump(FILE* = 0);
 195           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 196           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 197         };
 198
 199       //
 200       class Track : public GenericTrack
 201         {
 202           ASDCP_NO_COPY_CONSTRUCT(Track);
 203
 204         public:
 205           Rational EditRate;
 206           ui64_t Origin;
 207
 208           Track() : Origin(0) {}
 209           virtual ~Track() {}
 210           virtual const char* HasName() { return "Track"; }
 211           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 212           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 213           virtual void     Dump(FILE* = 0);
 214           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 215           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 216         };
 217
 218       //
 219       class StructuralComponent : public InterchangeObject
 220         {
 221           ASDCP_NO_COPY_CONSTRUCT(StructuralComponent);
 222
 223         public:
 224           UL DataDefinition;
 225           ui64_t Duration;
 226
 227           StructuralComponent() : Duration(0) {}
 228           virtual ~StructuralComponent() {}
 229           virtual const char* HasName() { return "StructuralComponent"; }
 230           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 231           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 232           virtual void     Dump(FILE* = 0);
 233         };
 234
 235       //
 236       class Sequence : public StructuralComponent
 237         {
 238           ASDCP_NO_COPY_CONSTRUCT(Sequence);
 239
 240         public:
 241           Batch<UUID> StructuralComponents;
 242
 243           Sequence() {}
 244           virtual ~Sequence() {}
 245           virtual const char* HasName() { return "Sequence"; }
 246           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 247           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 248           virtual void     Dump(FILE* = 0);
 249           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 250           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 251         };
 252
 253       //
 254       class SourceClip : public StructuralComponent
 255         {
 256           ASDCP_NO_COPY_CONSTRUCT(SourceClip);
 257
 258         public:
 259           ui64_t StartPosition;
 260           UMID SourcePackageID;
 261           ui32_t SourceTrackID;
 262
 263           SourceClip() : StartPosition(0), SourceTrackID(0) {}
 264           virtual ~SourceClip() {}
 265           virtual const char* HasName() { return "SourceClip"; }
 266           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 267           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 268           virtual void     Dump(FILE* = 0);
 269           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 270           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 271         };
 272
 273       //
 274       class TimecodeComponent : public StructuralComponent
 275         {
 276           ASDCP_NO_COPY_CONSTRUCT(TimecodeComponent);
 277
 278         public:
 279           ui16_t RoundedTimecodeBase;
 280           ui64_t StartTimecode;
 281           ui8_t DropFrame;
 282
 283           TimecodeComponent() : RoundedTimecodeBase(0), StartTimecode(0), DropFrame(0) {}
 284           virtual ~TimecodeComponent() {}
 285           virtual const char* HasName() { return "TimecodeComponent"; }
 286           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 287           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 288           virtual void     Dump(FILE* = 0);
 289           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 290           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 291         };
 292
 293       //
 294       class GenericDescriptor : public InterchangeObject
 295         {
 296           ASDCP_NO_COPY_CONSTRUCT(GenericDescriptor);
 297
 298         public:
 299           Batch<UUID> Locators;
 300           Batch<UUID> SubDescriptors;
 301
 302           GenericDescriptor() {}
 303           virtual ~GenericDescriptor() {}
 304           virtual const char* HasName() { return "GenericDescriptor"; }
 305           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 306           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 307           virtual void     Dump(FILE* = 0);
 308         };
 309
 310       //
 311       class FileDescriptor : public GenericDescriptor
 312         {
 313           ASDCP_NO_COPY_CONSTRUCT(FileDescriptor);
 314
 315         public:
 316           ui32_t LinkedTrackID;
 317           Rational SampleRate;
 318           ui64_t ContainerDuration;
 319           UL EssenceContainer;
 320           UL Codec;
 321
 322           FileDescriptor() : LinkedTrackID(0), ContainerDuration(0) {}
 323           virtual ~FileDescriptor() {}
 324           virtual const char* HasName() { return "FileDescriptor"; }
 325           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 326           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 327           virtual void     Dump(FILE* = 0);
 328           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 329           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 330         };
 331
 332       //
 333       class GenericSoundEssenceDescriptor : public FileDescriptor
 334         {
 335           ASDCP_NO_COPY_CONSTRUCT(GenericSoundEssenceDescriptor);
 336
 337         public:
 338           Rational AudioSamplingRate;
 339           ui8_t Locked;
 340           ui8_t AudioRefLevel;
 341           ui32_t ChannelCount;
 342           ui32_t QuantizationBits;
 343           ui8_t DialNorm;
 344
 345           GenericSoundEssenceDescriptor() : Locked(0), AudioRefLevel(0), ChannelCount(0), QuantizationBits(0), DialNorm(0) {}
 346           virtual ~GenericSoundEssenceDescriptor() {}
 347           virtual const char* HasName() { return "GenericSoundEssenceDescriptor"; }
 348           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 349           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 350           virtual void     Dump(FILE* = 0);
 351           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 352           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 353         };
 354
 355       //
 356       class WaveAudioDescriptor : public GenericSoundEssenceDescriptor
 357         {
 358           ASDCP_NO_COPY_CONSTRUCT(WaveAudioDescriptor);
 359
 360         public:
 361           ui16_t BlockAlign;
 362           ui8_t SequenceOffset;
 363           ui32_t AvgBps;
 364
 365           WaveAudioDescriptor() : BlockAlign(0), SequenceOffset(0), AvgBps(0) {}
 366           virtual ~WaveAudioDescriptor() {}
 367           virtual const char* HasName() { return "WaveAudioDescriptor"; }
 368           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 369           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 370           virtual void     Dump(FILE* = 0);
 371           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 372           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 373         };
 374
 375       //
 376       class GenericPictureEssenceDescriptor : public FileDescriptor
 377         {
 378           ASDCP_NO_COPY_CONSTRUCT(GenericPictureEssenceDescriptor);
 379
 380         public:
 381           ui8_t FrameLayout;
 382           ui32_t StoredWidth;
 383           ui32_t StoredHeight;
 384           Rational AspectRatio;
 385
 386           GenericPictureEssenceDescriptor() : FrameLayout(0), StoredWidth(0), StoredHeight(0) {}
 387           virtual ~GenericPictureEssenceDescriptor() {}
 388           virtual const char* HasName() { return "GenericPictureEssenceDescriptor"; }
 389           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 390           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 391           virtual void     Dump(FILE* = 0);
 392           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 393           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 394         };
 395
 396       //
 397       class RGBAEssenceDescriptor : public GenericPictureEssenceDescriptor
 398         {
 399           ASDCP_NO_COPY_CONSTRUCT(RGBAEssenceDescriptor);
 400
 401         public:
 402           ui32_t ComponentMaxRef;
 403           ui32_t ComponentMinRef;
 404           RGBLayout PixelLayout;
 405
 406           RGBAEssenceDescriptor() : ComponentMaxRef(0), ComponentMinRef(0) {}
 407           virtual ~RGBAEssenceDescriptor() {}
 408           virtual const char* HasName() { return "RGBAEssenceDescriptor"; }
 409           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 410           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 411           virtual void     Dump(FILE* = 0);
 412           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 413           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 414         };
 415
 416       //
 417       class JPEG2000PictureSubDescriptor : public InterchangeObject
 418         {
 419           ASDCP_NO_COPY_CONSTRUCT(JPEG2000PictureSubDescriptor);
 420
 421         public:
 422           ui16_t Rsize;
 423           ui32_t Xsize;
 424           ui32_t Ysize;
 425           ui32_t XOsize;
 426           ui32_t YOsize;
 427           ui32_t XTsize;
 428           ui32_t YTsize;
 429           ui32_t XTOsize;
 430           ui32_t YTOsize;
 431           ui16_t Csize;
 432           Raw PictureComponentSizing;
 433           Raw CodingStyleDefault;
 434           Raw QuantizationDefault;
 435
 436           JPEG2000PictureSubDescriptor() : Rsize(0), Xsize(0), Ysize(0), XOsize(0), YOsize(0), XTsize(0), YTsize(0), XTOsize(0), YTOsize(0), Csize(0) {}
 437           virtual ~JPEG2000PictureSubDescriptor() {}
 438           virtual const char* HasName() { return "JPEG2000PictureSubDescriptor"; }
 439           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 440           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 441           virtual void     Dump(FILE* = 0);
 442           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 443           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 444         };
 445
 446       //
 447       class CDCIEssenceDescriptor : public GenericPictureEssenceDescriptor
 448         {
 449           ASDCP_NO_COPY_CONSTRUCT(CDCIEssenceDescriptor);
 450
 451         public:
 452           ui32_t ComponentDepth;
 453           ui32_t HorizontalSubsampling;
 454           ui32_t VerticalSubsampling;
 455           ui8_t ColorSiting;
 456
 457           CDCIEssenceDescriptor() : ComponentDepth(0), HorizontalSubsampling(0), VerticalSubsampling(0), ColorSiting(0) {}
 458           virtual ~CDCIEssenceDescriptor() {}
 459           virtual const char* HasName() { return "CDCIEssenceDescriptor"; }
 460           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 461           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 462           virtual void     Dump(FILE* = 0);
 463           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 464           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 465         };
 466
 467       //
 468       class MPEG2VideoDescriptor : public CDCIEssenceDescriptor
 469         {
 470           ASDCP_NO_COPY_CONSTRUCT(MPEG2VideoDescriptor);
 471
 472         public:
 473           ui8_t CodedContentType;
 474           ui8_t LowDelay;
 475           ui32_t BitRate;
 476           ui8_t ProfileAndLevel;
 477
 478           MPEG2VideoDescriptor() : CodedContentType(0), LowDelay(0), BitRate(0), ProfileAndLevel(0) {}
 479           virtual ~MPEG2VideoDescriptor() {}
 480           virtual const char* HasName() { return "MPEG2VideoDescriptor"; }
 481           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 482           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 483           virtual void     Dump(FILE* = 0);
 484           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 485           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 486         };
 487
 488       //
 489       class DMSegment : public InterchangeObject
 490         {
 491           ASDCP_NO_COPY_CONSTRUCT(DMSegment);
 492
 493         public:
 494           ui64_t EventStartPosition;
 495           UTF16String EventComment;
 496           UUID DMFramework;
 497
 498           DMSegment() : EventStartPosition(0) {}
 499           virtual ~DMSegment() {}
 500           virtual const char* HasName() { return "DMSegment"; }
 501           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 502           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 503           virtual void     Dump(FILE* = 0);
 504           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 505           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 506         };
 507
 508       //
 509       class CryptographicFramework : public InterchangeObject
 510         {
 511           ASDCP_NO_COPY_CONSTRUCT(CryptographicFramework);
 512
 513         public:
 514           UUID ContextSR;
 515
 516           CryptographicFramework() {}
 517           virtual ~CryptographicFramework() {}
 518           virtual const char* HasName() { return "CryptographicFramework"; }
 519           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 520           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 521           virtual void     Dump(FILE* = 0);
 522           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 523           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 524         };
 525
 526       //
 527       class CryptographicContext : public InterchangeObject
 528         {
 529           ASDCP_NO_COPY_CONSTRUCT(CryptographicContext);
 530
 531         public:
 532           UUID ContextID;
 533           UL SourceEssenceContainer;
 534           UL CipherAlgorithm;
 535           UL MICAlgorithm;
 536           UUID CryptographicKeyID;
 537
 538           CryptographicContext() {}
 539           virtual ~CryptographicContext() {}
 540           virtual const char* HasName() { return "CryptographicContext"; }
 541           virtual Result_t InitFromTLVSet(TLVReader& TLVSet);
 542           virtual Result_t WriteToTLVSet(TLVWriter& TLVSet);
 543           virtual void     Dump(FILE* = 0);
 544           virtual Result_t InitFromBuffer(const byte_t* p, ui32_t l);
 545           virtual Result_t WriteToBuffer(ASDCP::FrameBuffer&);
 546         };
 547
 548     } // namespace MXF
 549 } // namespace ASDCP
 550
 551
 552 #endif // _METADATA_H_
 553
 554 //
 555 // end Metadata.h
 556 //