src/klvwalk.cpp

   1 /*
   2 Copyright (c) 2005-2018, 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    klvwalk.cpp
  28     \version $Id$
  29     \brief   KLV+MXF test
  30 */
  31
  32 #include "AS_DCP.h"
  33 #include "MXF.h"
  34 #include <KM_log.h>
  35 #include <stdlib.h>
  36 #include <string.h>
  37 #include <ctype.h>
  38 #include <assert.h>
  39 #include <sys/types.h>
  40 #include <sys/stat.h>
  41
  42 using namespace ASDCP;
  43 using Kumu::DefaultLogSink;
  44
  45
  46 //------------------------------------------------------------------------------------------
  47 //
  48 // command line option parser class
  49
  50 static const char* PROGRAM_NAME = "klvwalk";    // program name for messages
  51 typedef std::list<std::string> FileList_t;
  52
  53 // Increment the iterator, test for an additional non-option command line argument.
  54 // Causes the caller to return if there are no remaining arguments or if the next
  55 // argument begins with '-'.
  56 #define TEST_EXTRA_ARG(i,c)    if ( ++i >= argc || argv[(i)][0] == '-' ) \
  57                                  { \
  58                                    fprintf(stderr, "Argument not found for option -%c.\n", (c)); \
  59                                    return; \
  60                                  }
  61
  62 //
  63 void
  64 banner(FILE* stream = stdout)
  65 {
  66   fprintf(stream, "\n\
  67 %s (asdcplib %s)\n\n\
  68 Copyright (c) 2005-2013 John Hurst\n\
  69 %s is part of the asdcplib DCP tools package.\n\
  70 asdcplib may be copied only under the terms of the license found at\n\
  71 the top of every file in the asdcplib distribution kit.\n\n\
  72 Specify the -h (help) option for further information about %s\n\n",
  73           PROGRAM_NAME, ASDCP::Version(), PROGRAM_NAME, PROGRAM_NAME);
  74 }
  75
  76 //
  77 void
  78 usage(FILE* stream = stdout)
  79 {
  80   fprintf(stream, "\
  81 USAGE: %s [-r|-p] [-v] <input-file> [<input-file2> ...]\n\
  82 \n\
  83        %s [-h|-help] [-V]\n\
  84 \n\
  85   -h | -help   - Show help\n\
  86   -r           - When KLV data is an MXF OPAtom or OP 1a file, display headers\n\
  87   -p           - Display partition headers by walking the RIP\n\
  88   -v           - Verbose. Prints informative messages to stderr\n\
  89   -V           - Show version information\n\
  90 \n\
  91   NOTES: o There is no option grouping, all options must be distinct arguments.\n\
  92          o All option arguments must be separated from the option by whitespace.\n\
  93 \n", PROGRAM_NAME, PROGRAM_NAME);
  94 }
  95
  96 //
  97 //
  98  class CommandOptions
  99  {
 100    CommandOptions();
 101
 102  public:
 103    bool   error_flag;               // true if the given options are in error or not complete
 104    bool   version_flag;             // true if the version display option was selected
 105    bool   help_flag;                // true if the help display option was selected
 106    bool   verbose_flag;             // true if the informative messages option was selected
 107    bool   read_mxf_flag;            // true if the -r option was selected
 108    bool   walk_parts_flag;          // true if the -p option was selected
 109    FileList_t inFileList;           // File to operate on
 110
 111    CommandOptions(int argc, const char** argv) :
 112      error_flag(true), version_flag(false), help_flag(false),
 113      verbose_flag(false), read_mxf_flag(false), walk_parts_flag(false)
 114    {
 115      for ( int i = 1; i < argc; i++ )
 116        {
 117
 118          if ( (strcmp( argv[i], "-help") == 0) )
 119            {
 120              help_flag = true;
 121              continue;
 122            }
 123
 124          if ( argv[i][0] == '-' && isalpha(argv[i][1]) && argv[i][2] == 0 )
 125            {
 126              switch ( argv[i][1] )
 127                {
 128                case 'h': help_flag = true; break;
 129                case 'r': read_mxf_flag = true; break;
 130                case 'p': walk_parts_flag = true; break;
 131                case 'V': version_flag = true; break;
 132                case 'v': verbose_flag = true; break;
 133
 134                default:
 135                  fprintf(stderr, "Unrecognized option: %s\n", argv[i]);
 136                  return;
 137                }
 138            }
 139          else
 140            {
 141              if ( argv[i][0] != '-' )
 142                inFileList.push_back(argv[i]);
 143
 144              else
 145                {
 146                  fprintf(stderr, "Unrecognized option: %s\n", argv[i]);
 147                  return;
 148                }
 149            }
 150        }
 151
 152      if ( help_flag || version_flag )
 153        return;
 154
 155      if ( inFileList.empty() )
 156        {
 157          fputs("Input filename(s) required.\n", stderr);
 158          return;
 159        }
 160
 161      error_flag = false;
 162    }
 163  };
 164
 165
 166 //---------------------------------------------------------------------------------------------------
 167 //
 168
 169 int
 170 main(int argc, const char** argv)
 171 {
 172   CommandOptions Options(argc, argv);
 173
 174   if ( Options.version_flag )
 175     banner();
 176
 177   if ( Options.help_flag )
 178     usage();
 179
 180   if ( Options.version_flag || Options.help_flag )
 181     return 0;
 182
 183   if ( Options.error_flag )
 184     {
 185       fprintf(stderr, "There was a problem. Type %s -h for help.\n", PROGRAM_NAME);
 186       return 3;
 187     }
 188
 189   FileList_t::iterator fi;
 190   Result_t result = RESULT_OK;
 191
 192   for ( fi = Options.inFileList.begin(); ASDCP_SUCCESS(result) && fi != Options.inFileList.end(); fi++ )
 193     {
 194       if (Options.verbose_flag)
 195         fprintf(stderr, "Opening file %s\n", ((*fi).c_str()));
 196
 197       if ( Options.read_mxf_flag ) // dump MXF
 198         {
 199           Kumu::FileReader        Reader;
 200           const Dictionary* Dict = &DefaultCompositeDict();
 201           ASDCP::MXF::OP1aHeader Header(Dict);
 202           ASDCP::MXF::RIP RIP(Dict);
 203
 204           result = Reader.OpenRead(*fi);
 205
 206           if ( ASDCP_SUCCESS(result) )
 207             {
 208               result = MXF::SeekToRIP(Reader);
 209
 210               if ( ASDCP_SUCCESS(result) )
 211                 {
 212                   result = RIP.InitFromFile(Reader);
 213                   ui32_t test_s = RIP.PairArray.size();
 214
 215                   if ( ASDCP_FAILURE(result) )
 216                     {
 217                       DefaultLogSink().Error("File contains no RIP\n");
 218                       result = RESULT_OK;
 219                     }
 220                   else if ( RIP.PairArray.empty() )
 221                     {
 222                       DefaultLogSink().Error("RIP contains no Pairs.\n");
 223                     }
 224
 225                   Reader.Seek(0);
 226                 }
 227               else
 228                 {
 229                   DefaultLogSink().Error("read_mxf SeekToRIP failed: %s\n", result.Label());
 230                 }
 231             }
 232
 233           if ( ASDCP_SUCCESS(result) )
 234             result = Header.InitFromFile(Reader);
 235
 236           if ( ASDCP_SUCCESS(result) )
 237             Header.Dump(stdout);
 238
 239           if ( ASDCP_SUCCESS(result) && RIP.PairArray.size() > 2 )
 240             {
 241               MXF::RIP::const_pair_iterator pi = RIP.PairArray.begin();
 242
 243               for ( pi++; pi != RIP.PairArray.end() && ASDCP_SUCCESS(result); pi++ )
 244                 {
 245                   result = Reader.Seek((*pi).ByteOffset);
 246
 247                   if ( ASDCP_SUCCESS(result) )
 248                     {
 249                       MXF::Partition TmpPart(Dict);
 250                       result = TmpPart.InitFromFile(Reader);
 251
 252                       if ( ASDCP_SUCCESS(result) && TmpPart.BodySID > 0 )
 253                         TmpPart.Dump(stdout);
 254                     }
 255                 }
 256             }
 257
 258           if ( ASDCP_SUCCESS(result) )
 259             {
 260               ASDCP::MXF::OPAtomIndexFooter Index(Dict);
 261               result = Reader.Seek(Header.FooterPartition);
 262
 263               if ( ASDCP_SUCCESS(result) )
 264                 {
 265                   Index.m_Lookup = &Header.m_Primer;
 266                   result = Index.InitFromFile(Reader);
 267                 }
 268
 269               if ( ASDCP_SUCCESS(result) )
 270                 Index.Dump(stdout);
 271             }
 272
 273           if ( ASDCP_SUCCESS(result) )
 274             RIP.Dump(stdout);
 275         }
 276       else if ( Options.walk_parts_flag )
 277         {
 278           Kumu::FileReader        Reader;
 279           const Dictionary* Dict = &DefaultCompositeDict();
 280           ASDCP::MXF::OP1aHeader Header(Dict);
 281           ASDCP::MXF::RIP RIP(Dict);
 282
 283           result = Reader.OpenRead((*fi).c_str());
 284
 285           if ( ASDCP_SUCCESS(result) )
 286             result = MXF::SeekToRIP(Reader);
 287
 288           if ( ASDCP_SUCCESS(result) )
 289             {
 290               result = RIP.InitFromFile(Reader);
 291               ui32_t test_s = RIP.PairArray.size();
 292
 293               if ( ASDCP_FAILURE(result) )
 294                 {
 295                   DefaultLogSink().Error("File contains no RIP\n");
 296                   result = RESULT_OK;
 297                 }
 298               else if ( RIP.PairArray.empty() )
 299                 {
 300                   DefaultLogSink().Error("RIP contains no Pairs.\n");
 301                 }
 302
 303               Reader.Seek(0);
 304             }
 305           else
 306             {
 307               DefaultLogSink().Error("walk_parts SeekToRIP failed: %s\n", result.Label());
 308             }
 309
 310           if ( ASDCP_SUCCESS(result) )
 311             {
 312               RIP.Dump();
 313
 314               MXF::RIP::const_pair_iterator i;
 315               for ( i = RIP.PairArray.begin(); i != RIP.PairArray.end(); ++i )
 316                 {
 317                   Reader.Seek(i->ByteOffset);
 318                   MXF::Partition plain_part(Dict);
 319                   plain_part.InitFromFile(Reader);
 320
 321                   if ( plain_part.ThisPartition != i->ByteOffset )
 322                     {
 323                       DefaultLogSink().Error("ThisPartition value error: wanted=%qu, got=%qu\n",
 324                                              plain_part.ThisPartition, i->ByteOffset);
 325                     }
 326
 327                   plain_part.Dump();
 328                 }
 329             }
 330         }
 331       else // dump klv
 332         {
 333           Kumu::FileReader Reader;
 334           KLVFilePacket KP;
 335           ui64_t pos = 0;
 336
 337           result = Reader.OpenRead((*fi).c_str());
 338
 339           if ( ASDCP_SUCCESS(result) )
 340             result = KP.InitFromFile(Reader);
 341
 342           while ( ASDCP_SUCCESS(result) )
 343             {
 344               fprintf(stdout, "@0x%08llx: ", pos);
 345               KP.Dump(stdout, DefaultCompositeDict(), true);
 346               pos = Reader.Tell();
 347               result = KP.InitFromFile(Reader);
 348             }
 349
 350           if( result == RESULT_ENDOFFILE )
 351             result = RESULT_OK;
 352         }
 353     }
 354
 355   if ( ASDCP_FAILURE(result) )
 356     {
 357       fputs("Program stopped on error.\n", stderr);
 358
 359       if ( result != RESULT_FAIL )
 360         {
 361           fputs(result, stderr);
 362           fputc('\n', stderr);
 363         }
 364
 365       return 1;
 366     }
 367
 368   return 0;
 369 }
 370
 371
 372 //
 373 // end klvwalk.cpp
 374 //