src/klvwalk.cpp

   1 /*
   2 Copyright (c) 2005-2015, 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: klvwalk.cpp,v 1.23 2015/10/09 23:41:11 jhurst Exp $
  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).c_str());
 205
 206           if ( ASDCP_SUCCESS(result) )
 207             result = MXF::SeekToRIP(Reader);
 208
 209           if ( ASDCP_SUCCESS(result) )
 210             {
 211               result = RIP.InitFromFile(Reader);
 212
 213               if ( ASDCP_FAILURE(result) )
 214                 {
 215                   DefaultLogSink().Error("File contains no RIP\n");
 216                   result = RESULT_OK;
 217                 }
 218               else if ( RIP.PairArray.empty() )
 219                 {
 220                   DefaultLogSink().Error("RIP contains no Pairs.\n");
 221                 }
 222
 223               Reader.Seek(0);
 224             }
 225           else
 226             {
 227               DefaultLogSink().Error("read_mxf SeekToRIP failed: %s\n", result.Label());
 228             }
 229
 230           if ( ASDCP_SUCCESS(result) )
 231             result = Header.InitFromFile(Reader);
 232
 233           if ( ASDCP_SUCCESS(result) )
 234             Header.Dump(stdout);
 235
 236           if ( ASDCP_SUCCESS(result) && RIP.PairArray.size() > 2 )
 237             {
 238               MXF::RIP::const_pair_iterator pi = RIP.PairArray.begin();
 239
 240               for ( pi++; pi != RIP.PairArray.end() && ASDCP_SUCCESS(result); pi++ )
 241                 {
 242                   result = Reader.Seek((*pi).ByteOffset);
 243
 244                   if ( ASDCP_SUCCESS(result) )
 245                     {
 246                       MXF::Partition TmpPart(Dict);
 247                       result = TmpPart.InitFromFile(Reader);
 248
 249                       if ( ASDCP_SUCCESS(result) && TmpPart.BodySID > 0 )
 250                         TmpPart.Dump(stdout);
 251                     }
 252                 }
 253             }
 254
 255           if ( ASDCP_SUCCESS(result) )
 256             {
 257               ASDCP::MXF::OPAtomIndexFooter Index(Dict);
 258               result = Reader.Seek(Header.FooterPartition);
 259
 260               if ( ASDCP_SUCCESS(result) )
 261                 {
 262                   Index.m_Lookup = &Header.m_Primer;
 263                   result = Index.InitFromFile(Reader);
 264                 }
 265
 266               if ( ASDCP_SUCCESS(result) )
 267                 Index.Dump(stdout);
 268             }
 269
 270           if ( ASDCP_SUCCESS(result) )
 271             RIP.Dump(stdout);
 272         }
 273       else if ( Options.walk_parts_flag )
 274         {
 275           Kumu::FileReader        Reader;
 276           const Dictionary* Dict = &DefaultCompositeDict();
 277           ASDCP::MXF::OP1aHeader Header(Dict);
 278           ASDCP::MXF::RIP RIP(Dict);
 279
 280           result = Reader.OpenRead((*fi).c_str());
 281
 282           if ( ASDCP_SUCCESS(result) )
 283             result = MXF::SeekToRIP(Reader);
 284
 285           if ( ASDCP_SUCCESS(result) )
 286             {
 287               result = RIP.InitFromFile(Reader);
 288
 289               if ( ASDCP_FAILURE(result) )
 290                 {
 291                   DefaultLogSink().Error("File contains no RIP\n");
 292                   result = RESULT_OK;
 293                 }
 294               else if ( RIP.PairArray.empty() )
 295                 {
 296                   DefaultLogSink().Error("RIP contains no Pairs.\n");
 297                 }
 298
 299               Reader.Seek(0);
 300             }
 301           else
 302             {
 303               DefaultLogSink().Error("walk_parts SeekToRIP failed: %s\n", result.Label());
 304             }
 305
 306           if ( ASDCP_SUCCESS(result) )
 307             {
 308               RIP.Dump();
 309
 310               MXF::RIP::const_pair_iterator i;
 311               for ( i = RIP.PairArray.begin(); i != RIP.PairArray.end(); ++i )
 312                 {
 313                   Reader.Seek(i->ByteOffset);
 314                   MXF::Partition plain_part(Dict);
 315                   plain_part.InitFromFile(Reader);
 316
 317                   if ( plain_part.ThisPartition != i->ByteOffset )
 318                     {
 319                       DefaultLogSink().Error("ThisPartition value error: wanted=%qu, got=%qu\n",
 320                                              plain_part.ThisPartition, i->ByteOffset);
 321                     }
 322
 323                   plain_part.Dump();
 324                 }
 325             }
 326         }
 327       else // dump klv
 328         {
 329           Kumu::FileReader Reader;
 330           KLVFilePacket KP;
 331           ui64_t pos = 0;
 332
 333           result = Reader.OpenRead((*fi).c_str());
 334
 335           if ( ASDCP_SUCCESS(result) )
 336             result = KP.InitFromFile(Reader);
 337
 338           while ( ASDCP_SUCCESS(result) )
 339             {
 340               fprintf(stdout, "@0x%08qx: ", pos);
 341               KP.Dump(stdout, DefaultCompositeDict(), true);
 342               pos = Reader.Tell();
 343               result = KP.InitFromFile(Reader);
 344             }
 345
 346           if( result == RESULT_ENDOFFILE )
 347             result = RESULT_OK;
 348         }
 349     }
 350
 351   if ( ASDCP_FAILURE(result) )
 352     {
 353       fputs("Program stopped on error.\n", stderr);
 354
 355       if ( result != RESULT_FAIL )
 356         {
 357           fputs(result, stderr);
 358           fputc('\n', stderr);
 359         }
 360
 361       return 1;
 362     }
 363
 364   return 0;
 365 }
 366
 367
 368 //
 369 // end klvwalk.cpp
 370 //