/*
-Copyright (c) 2003-2005, John Hurst
+Copyright (c) 2003-2014, John Hurst
All rights reserved.
Redistribution and use in source and binary forms, with or without
these features.
*/
-#include <iostream>
-#include <assert.h>
-
-#include <FileIO.h>
+#include <KM_fileio.h>
+#include <KM_prng.h>
#include <PCMParserList.h>
#include <WavFileWriter.h>
-#include <hex_utils.h>
-#include <AS_DCP_UUID.h>
#include <MXF.h>
#include <Metadata.h>
+#include <openssl/sha.h>
+
+#include <iostream>
+#include <assert.h>
using namespace ASDCP;
-const ui32_t FRAME_BUFFER_SIZE = 4*1024*1024;
+const ui32_t FRAME_BUFFER_SIZE = 4 * Kumu::Megabyte;
//------------------------------------------------------------------------------------------
//
// command line option parser class
-static const char* PACKAGE = "asdcp-test"; // program name for messages
+static const char* PROGRAM_NAME = "asdcp-test"; // program name for messages
const ui32_t MAX_IN_FILES = 16; // maximum number of input files handled by
// the command option parser
memcpy(ProductUUID, default_ProductUUID_Data, UUIDlen);
CompanyName = "WidgetCo";
ProductName = "asdcp-test";
-
- char s_buf[128];
- snprintf(s_buf, 128, "%lu.%lu.%lu", VERSION_MAJOR, VERSION_APIMINOR, VERSION_IMPMINOR);
- ProductVersion = s_buf;
+ ProductVersion = ASDCP::Version();
}
} s_MyInfo;
-// Macros used to test command option data state.
-
-// True if a major mode has already been selected.
-#define TEST_MAJOR_MODE() ( info_flag||create_flag||extract_flag||genkey_flag||genid_flag||gop_start_flag )
-
-// Causes the caller to return if a major mode has already been selected,
-// otherwise sets the given flag.
-#define TEST_SET_MAJOR_MODE(f) if ( TEST_MAJOR_MODE() ) \
- { \
- fputs("Conflicting major mode, choose one of -(gcixG)).\n", stderr); \
- return; \
- } \
- (f) = true;
// Increment the iterator, test for an additional non-option command line argument.
// Causes the caller to return if there are no remaining arguments or if the next
// argument begins with '-'.
#define TEST_EXTRA_ARG(i,c) if ( ++i >= argc || argv[(i)][0] == '-' ) \
{ \
- fprintf(stderr, "Argument not found for option %c.\n", (c)); \
+ fprintf(stderr, "Argument not found for option -%c.\n", (c)); \
return; \
}
//
void
-banner(FILE* stream = stderr)
+banner(FILE* stream = stdout)
{
fprintf(stream, "\n\
%s (asdcplib %s)\n\n\
-Copyright (c) 2003-2005 John Hurst\n\n\
+Copyright (c) 2003-2015 John Hurst\n\n\
asdcplib may be copied only under the terms of the license found at\n\
the top of every file in the asdcplib distribution kit.\n\n\
Specify the -h (help) option for further information about %s\n\n",
- PACKAGE, ASDCP::Version(), PACKAGE);
+ PROGRAM_NAME, ASDCP::Version(), PROGRAM_NAME);
}
//
void
-usage(FILE* stream = stderr)
+usage(FILE* stream = stdout)
{
fprintf(stream, "\
-USAGE: %s [-i [-H, -n]|-c <filename> [-p <rate>, -e, -M, -R]|-x <root-name> [-m][-S]|-g|-u|-G|-V|-h]\n\
- [-k <key-string>] [-j <key-id-string>] [-f <start-frame-num>] [-d <duration>]\n\
- [-b <buf-size>] [-W] [-v [-s]] [<filename>, ...]\n\
-\n", PACKAGE);
+USAGE: %s -c <output-file> [-3] [-a <uuid>] [-b <buffer-size>]\n\
+ [-d <duration>] [-e|-E] [-f <start-frame>] [-j <key-id-string>]\n\
+ [-k <key-string>] [-l <label>] [-L] [-M] [-p <frame-rate>] [-R]\n\
+ [-s <num>] [-v] [-W] [-z|-Z] <input-file> [<input-file-2> ...]\n\
+\n\
+ %s [-h|-help] [-V]\n\
+\n\
+ %s -i [-H] [-n] [-v] <input-file>\n\
+\n\
+ %s -g | -u\n\
+\n\
+ %s -G [-v] <input-file>\n\
+\n\
+ %s -t <input-file>\n\
+\n\
+ %s -x <file-prefix> [-3] [-b <buffer-size>] [-d <duration>]\n\
+ [-f <starting-frame>] [-m] [-p <frame-rate>] [-R] [-s <num>] [-S|-1]\n\
+ [-v] [-W] [-w] <input-file>\n\n",
+ PROGRAM_NAME, PROGRAM_NAME, PROGRAM_NAME, PROGRAM_NAME,
+ PROGRAM_NAME, PROGRAM_NAME, PROGRAM_NAME);
fprintf(stream, "\
Major modes:\n\
- -i - show file info\n\
- -c <filename> - create AS-DCP file from input(s)\n\
- -x <root-name> - extract essence from AS-DCP file to named file(s)\n\
- -g - generate a random 16 byte value to stdout\n\
- -u - generate a random UUID value to stdout\n\
- -G - Perform GOP start lookup test on MPEG file\n\
- -V - show version\n\
- -h - show help\n\
+ -3 - With -c, create a stereoscopic image file. Expects two\n\
+ directories of JP2K codestreams (directories must have\n\
+ an equal number of frames; left eye is first).\n\
+ - With -x, force stereoscopic interpretation of a JP2K\n\
+ track file.\n\
+ -c <output-file> - Create an AS-DCP track file from input(s)\n\
+ -g - Generate a random 16 byte value to stdout\n\
+ -G - Perform GOP start lookup test on MXF+Interop MPEG file\n\
+ -h | -help - Show help\n\
+ -i - Show file info\n\
+ -t - Calculate message digest of input file\n\
+ -U - Dump UL catalog to stdout\n\
+ -u - Generate a random UUID value to stdout\n\
+ -V - Show version information\n\
+ -x <root-name> - Extract essence from AS-DCP file to named file(s)\n\
\n");
fprintf(stream, "\
Security Options:\n\
- -j <key-id-str> - write key ID instead of creating a random value\n\
- -k <key-string> - use key for ciphertext operations\n\
- -e - encrypt MPEG or JP2K headers (default)\n\
- -E - do not encrypt MPEG or JP2K headers\n\
- -M - do not create HMAC values when writing\n\
- -m - verify HMAC values when reading\n\
+ -e - Encrypt MPEG or JP2K headers (default)\n\
+ -E - Do not encrypt MPEG or JP2K headers\n\
+ -j <key-id-str> - Write key ID instead of creating a random value\n\
+ -k <key-string> - Use key for ciphertext operations\n\
+ -m - verify HMAC values when reading\n\
+ -M - Do not create HMAC values when writing\n\
\n");
fprintf(stream, "\
Read/Write Options:\n\
- -b <buf-size> - Size (in bytes) of the picture frame buffer, default: 2097152 (2MB)\n\
- -f <frame-num> - starting frame number, default 0\n\
- -d <duration> - number of frames to process, default all\n\
- -p <rate> - fps of picture when wrapping PCM or JP2K:, use one of [23|24|48], 24 is default\n\
- -R - Repeat the first frame over the entire file (picture essence only, requires -c, -d)\n\
- -S - Split Wave essence to stereo WAV files during extract (default = multichannel WAV)\n\
- -W - read input file only, do not write source file\n\
+ -a <UUID> - Specify the Asset ID of a file (with -c)\n\
+ -b <buffer-size> - Specify size in bytes of picture frame buffer.\n\
+ Defaults to 4,194,304 (4MB)\n\
+ -d <duration> - Number of frames to process, default all\n\
+ -f <start-frame> - Starting frame number, default 0\n\
+ -l <label> - Use given channel format label when writing MXF sound\n\
+ files. SMPTE 429-2 labels: '5.1', '6.1', '7.1', '7.1DS', 'WTF'.\n\
+ Default is no label (valid for Interop only).\n\
+ -L - Write SMPTE UL values instead of MXF Interop\n\
+ -p <rate> - fps of picture when wrapping PCM or JP2K:\n\
+ Use one of [23|24|25|30|48|50|60], 24 is default\n\
+ -R - Repeat the first frame over the entire file (picture\n\
+ essence only, requires -c, -d)\n\
+ -S - Split Wave essence to stereo WAV files during extract.\n\
+ Default is multichannel WAV\n\
+ -1 - Split Wave essence to mono WAV files during extract.\n\
+ Default is multichannel WAV\n\
+ -W - Read input file only, do not write source file\n\
+ -w <width> - Width of numeric element in a series of frame file names\n\
+ (use with -x, default 6).\n\
+ -z - Fail if j2c inputs have unequal parameters (default)\n\
+ -Z - Ignore unequal parameters in j2c inputs\n\
\n");
fprintf(stream, "\
Info Options:\n\
- -H - show MXF header metadata, used with option -i\n\
- -n - show index, used with option -i\n\
+ -H - Show MXF header metadata, used with option -i\n\
+ -n - Show index, used with option -i\n\
\n\
Other Options:\n\
- -s <number> - number of bytes of frame buffer to be dumped as hex to stderr (use with -v)\n\
- -v - verbose, show extra detail during run\n\
+ -s <num> - Number of bytes of frame buffer to be dumped as hex to\n\
+ stderr, used with option -v\n\
+ -v - Verbose, prints informative messages to stderr\n\
\n\
NOTES: o There is no option grouping, all options must be distinct arguments.\n\
o All option arguments must be separated from the option by whitespace.\n\
- o An argument of \"23\" to the -p option will be interpreted as 23000/1001 fps.\n\
+ o An argument of \"23\" to the -p option will be interpreted\n\
+ as 24000/1001 fps.\n\
\n");
}
+//
+enum MajorMode_t
+{
+ MMT_NONE,
+ MMT_INFO,
+ MMT_CREATE,
+ MMT_EXTRACT,
+ MMT_GEN_ID,
+ MMT_GEN_KEY,
+ MMT_GOP_START,
+ MMT_DIGEST,
+ MMT_UL_LIST,
+};
+
+//
+PCM::ChannelFormat_t
+decode_channel_fmt(const std::string& label_name)
+{
+ if ( label_name == "5.1" )
+ return PCM::CF_CFG_1;
+
+ else if ( label_name == "6.1" )
+ return PCM::CF_CFG_2;
+
+ else if ( label_name == "7.1" )
+ return PCM::CF_CFG_3;
+
+ else if ( label_name == "WTF" )
+ return PCM::CF_CFG_4;
+
+ else if ( label_name == "7.1DS" )
+ return PCM::CF_CFG_5;
+
+ fprintf(stderr, "Error decoding channel format string: %s\n", label_name.c_str());
+ fprintf(stderr, "Expecting '5.1', '6.1', '7.1', '7.1DS' or 'WTF'\n");
+ return PCM::CF_NONE;
+}
+
//
//
class CommandOptions
CommandOptions();
public:
+ MajorMode_t mode;
bool error_flag; // true if the given options are in error or not complete
- bool info_flag; // true if the file info mode was selected
- bool create_flag; // true if the file create mode was selected
- bool extract_flag; // true if the file extract mode was selected
- bool genkey_flag; // true if we are to generate a new key value
- bool genid_flag; // true if we are to generate a new UUID value
- bool gop_start_flag; // true if we are to perform a GOP start lookup test
bool key_flag; // true if an encryption key was given
bool key_id_flag; // true if a key ID was given
+ bool asset_id_flag; // true if an asset ID was given
bool encrypt_header_flag; // true if mpeg headers are to be encrypted
bool write_hmac; // true if HMAC values are to be generated and written
bool read_hmac; // true if HMAC values are to be validated
bool split_wav; // true if PCM is to be extracted to stereo WAV files
+ bool mono_wav; // true if PCM is to be extracted to mono WAV files
bool verbose_flag; // true if the verbose option was selected
ui32_t fb_dump_size; // number of bytes of frame buffer to dump
bool showindex_flag; // true if index is to be displayed
bool no_write_flag; // true if no output files are to be written
bool version_flag; // true if the version display option was selected
bool help_flag; // true if the help display option was selected
+ bool stereo_image_flag; // if true, expect stereoscopic JP2K input (left eye first)
+ ui32_t number_width; // number of digits in a serialized filename (for JPEG extract)
ui32_t start_frame; // frame number to begin processing
ui32_t duration; // number of frames to be processed
bool duration_flag; // true if duration argument given
bool do_repeat; // if true and -c -d, repeat first input frame
+ bool use_smpte_labels; // if true, SMPTE UL values will be written instead of MXF Interop values
+ bool j2c_pedantic; // passed to JP2K::SequenceParser::OpenRead
ui32_t picture_rate; // fps of picture when wrapping PCM
ui32_t fb_size; // size of picture frame buffer
ui32_t file_count; // number of elements in filenames[]
const char* file_root; // filename pre for files written by the extract mode
const char* out_file; // name of mxf file created by create mode
byte_t key_value[KeyLen]; // value of given encryption key (when key_flag is true)
- byte_t key_id_value[KeyIDlen];// value of given key ID (when key_id_flag is true)
+ byte_t key_id_value[UUIDlen];// value of given key ID (when key_id_flag is true)
+ byte_t asset_id_value[UUIDlen];// value of asset ID (when asset_id_flag is true)
const char* filenames[MAX_IN_FILES]; // list of filenames to be processed
+ PCM::ChannelFormat_t channel_fmt; // audio channel arrangement
//
Rational PictureRate()
{
+ if ( picture_rate == 16 ) return EditRate_16;
+ if ( picture_rate == 18 ) return EditRate_18;
+ if ( picture_rate == 20 ) return EditRate_20;
+ if ( picture_rate == 22 ) return EditRate_22;
if ( picture_rate == 23 ) return EditRate_23_98;
+ if ( picture_rate == 24 ) return EditRate_24;
+ if ( picture_rate == 25 ) return EditRate_25;
+ if ( picture_rate == 30 ) return EditRate_30;
if ( picture_rate == 48 ) return EditRate_48;
+ if ( picture_rate == 50 ) return EditRate_50;
+ if ( picture_rate == 60 ) return EditRate_60;
+ if ( picture_rate == 96 ) return EditRate_96;
+ if ( picture_rate == 100 ) return EditRate_100;
+ if ( picture_rate == 120 ) return EditRate_120;
+ if ( picture_rate == 192 ) return EditRate_192;
+ if ( picture_rate == 200 ) return EditRate_200;
+ if ( picture_rate == 240 ) return EditRate_240;
return EditRate_24;
}
//
const char* szPictureRate()
{
+ if ( picture_rate == 16 ) return "16";
+ if ( picture_rate == 18 ) return "18.182";
+ if ( picture_rate == 20 ) return "20";
+ if ( picture_rate == 22 ) return "21.818";
if ( picture_rate == 23 ) return "23.976";
+ if ( picture_rate == 24 ) return "24";
+ if ( picture_rate == 25 ) return "25";
+ if ( picture_rate == 30 ) return "30";
if ( picture_rate == 48 ) return "48";
+ if ( picture_rate == 50 ) return "50";
+ if ( picture_rate == 60 ) return "60";
+ if ( picture_rate == 96 ) return "96";
+ if ( picture_rate == 100 ) return "100";
+ if ( picture_rate == 120 ) return "120";
+ if ( picture_rate == 192 ) return "192";
+ if ( picture_rate == 200 ) return "200";
+ if ( picture_rate == 240 ) return "240";
return "24";
}
//
CommandOptions(int argc, const char** argv) :
- error_flag(true), info_flag(false), create_flag(false),
- extract_flag(false), genkey_flag(false), genid_flag(false), gop_start_flag(false),
- key_flag(false), encrypt_header_flag(true), write_hmac(true), read_hmac(false), split_wav(false),
+ mode(MMT_NONE), error_flag(true), key_flag(false), key_id_flag(false), asset_id_flag(false),
+ encrypt_header_flag(true), write_hmac(true), read_hmac(false), split_wav(false), mono_wav(false),
verbose_flag(false), fb_dump_size(0), showindex_flag(false), showheader_flag(false),
- no_write_flag(false), version_flag(false), help_flag(false), start_frame(0),
- duration(0xffffffff), duration_flag(false), do_repeat(false), picture_rate(24),
- fb_size(FRAME_BUFFER_SIZE), file_count(0), file_root(0), out_file(0)
+ no_write_flag(false), version_flag(false), help_flag(false), stereo_image_flag(false),
+ number_width(6), start_frame(0),
+ duration(0xffffffff), duration_flag(false), do_repeat(false), use_smpte_labels(false), j2c_pedantic(true),
+ picture_rate(24), fb_size(FRAME_BUFFER_SIZE), file_count(0), file_root(0), out_file(0),
+ channel_fmt(PCM::CF_NONE)
{
memset(key_value, 0, KeyLen);
- memset(key_id_value, 0, KeyIDlen);
+ memset(key_id_value, 0, UUIDlen);
for ( int i = 1; i < argc; i++ )
{
- if ( argv[i][0] == '-' && isalpha(argv[i][1]) && argv[i][2] == 0 )
+
+ if ( (strcmp( argv[i], "-help") == 0) )
+ {
+ help_flag = true;
+ continue;
+ }
+
+ if ( argv[i][0] == '-'
+ && ( isalpha(argv[i][1]) || isdigit(argv[i][1]) )
+ && argv[i][2] == 0 )
{
switch ( argv[i][1] )
{
- case 'i': TEST_SET_MAJOR_MODE(info_flag); break;
- case 'G': TEST_SET_MAJOR_MODE(gop_start_flag); break;
- case 'W': no_write_flag = true; break;
- case 'n': showindex_flag = true; break;
- case 'H': showheader_flag = true; break;
- case 'R': do_repeat = true; break;
- case 'S': split_wav = true; break;
- case 'V': version_flag = true; break;
- case 'h': help_flag = true; break;
- case 'v': verbose_flag = true; break;
- case 'g':
-#ifdef ASDCP_WITHOUT_OPENSSL
- fputs("Program compiled without encryption support.\n", stderr);
- return;
-#else
- genkey_flag = true;
-#endif
- break;
+ case '1': mono_wav = true; break;
+ case '2': split_wav = true; break;
+ case '3': stereo_image_flag = true; break;
- case 'u':
-#ifdef ASDCP_WITHOUT_OPENSSL
- fputs("Program compiled without encryption support.\n", stderr);
- return;
-#else
- genid_flag = true;
-#endif
+ case 'a':
+ asset_id_flag = true;
+ TEST_EXTRA_ARG(i, 'a');
+ {
+ ui32_t length;
+ Kumu::hex2bin(argv[i], asset_id_value, UUIDlen, &length);
+
+ if ( length != UUIDlen )
+ {
+ fprintf(stderr, "Unexpected asset ID length: %u, expecting %u characters.\n", length, UUIDlen);
+ return;
+ }
+ }
break;
- case 'e': encrypt_header_flag = true; break;
- case 'E': encrypt_header_flag = false; break;
- case 'M': write_hmac = false; break;
- case 'm': read_hmac = true; break;
+ case 'b':
+ TEST_EXTRA_ARG(i, 'b');
+ fb_size = Kumu::xabs(strtol(argv[i], 0, 10));
+
+ if ( verbose_flag )
+ fprintf(stderr, "Frame Buffer size: %u bytes.\n", fb_size);
+
+ break;
case 'c':
- TEST_SET_MAJOR_MODE(create_flag);
TEST_EXTRA_ARG(i, 'c');
+ mode = MMT_CREATE;
out_file = argv[i];
break;
- case 'x':
- TEST_SET_MAJOR_MODE(extract_flag);
- TEST_EXTRA_ARG(i, 'x');
- file_root = argv[i];
+ case 'd':
+ TEST_EXTRA_ARG(i, 'd');
+ duration_flag = true;
+ duration = Kumu::xabs(strtol(argv[i], 0, 10));
break;
- case 'k': key_flag = true;
-#ifdef ASDCP_WITHOUT_OPENSSL
- fputs("Program compiled without encryption support.\n", stderr);
- return;
-#else
- TEST_EXTRA_ARG(i, 'k');
+ case 'E': encrypt_header_flag = false; break;
+ case 'e': encrypt_header_flag = true; break;
+
+ case 'f':
+ TEST_EXTRA_ARG(i, 'f');
+ start_frame = Kumu::xabs(strtol(argv[i], 0, 10));
+ break;
+
+ case 'G': mode = MMT_GOP_START; break;
+ case 'g': mode = MMT_GEN_KEY; break;
+ case 'H': showheader_flag = true; break;
+ case 'h': help_flag = true; break;
+ case 'i': mode = MMT_INFO; break;
+
+ case 'j': key_id_flag = true;
+ TEST_EXTRA_ARG(i, 'j');
{
ui32_t length;
- hex2bin(argv[i], key_value, KeyLen, &length);
+ Kumu::hex2bin(argv[i], key_id_value, UUIDlen, &length);
- if ( length != KeyLen )
+ if ( length != UUIDlen )
{
- fprintf(stderr, "Unexpected key length: %lu, expecting %lu characters.\n", KeyLen, length);
+ fprintf(stderr, "Unexpected key ID length: %u, expecting %u characters.\n", length, UUIDlen);
return;
}
}
-#endif
break;
- case 'j': key_id_flag = true;
-#ifdef ASDCP_WITHOUT_OPENSSL
- fputs("Program compiled without encryption support.\n", stderr);
- return;
-#else
- TEST_EXTRA_ARG(i, 'j');
+ case 'k': key_flag = true;
+ TEST_EXTRA_ARG(i, 'k');
{
ui32_t length;
- hex2bin(argv[i], key_id_value, KeyIDlen, &length);
+ Kumu::hex2bin(argv[i], key_value, KeyLen, &length);
- if ( length != KeyIDlen )
+ if ( length != KeyLen )
{
- fprintf(stderr, "Unexpected key ID length: %lu, expecting %lu characters.\n", KeyIDlen, length);
+ fprintf(stderr, "Unexpected key length: %u, expecting %u characters.\n", length, KeyLen);
return;
}
}
-#endif
break;
- case 'f':
- TEST_EXTRA_ARG(i, 'f');
- start_frame = atoi(argv[i]); // TODO: test for negative value, should use strtol()
+ case 'l':
+ TEST_EXTRA_ARG(i, 'l');
+ channel_fmt = decode_channel_fmt(argv[i]);
break;
- case 'd':
- TEST_EXTRA_ARG(i, 'd');
- duration_flag = true;
- duration = atoi(argv[i]); // TODO: test for negative value, should use strtol()
- break;
+ case 'L': use_smpte_labels = true; break;
+ case 'M': write_hmac = false; break;
+ case 'm': read_hmac = true; break;
+ case 'n': showindex_flag = true; break;
case 'p':
TEST_EXTRA_ARG(i, 'p');
- picture_rate = atoi(argv[i]);
+ picture_rate = Kumu::xabs(strtol(argv[i], 0, 10));
break;
+ case 'R': do_repeat = true; break;
+ case 'S': split_wav = true; break;
+
case 's':
TEST_EXTRA_ARG(i, 's');
- fb_dump_size = atoi(argv[i]);
+ fb_dump_size = Kumu::xabs(strtol(argv[i], 0, 10));
break;
- case 'b':
- TEST_EXTRA_ARG(i, 'b');
- fb_size = atoi(argv[i]);
+ case 't': mode = MMT_DIGEST; break;
+ case 'U': mode = MMT_UL_LIST; break;
+ case 'u': mode = MMT_GEN_ID; break;
+ case 'V': version_flag = true; break;
+ case 'v': verbose_flag = true; break;
+ case 'W': no_write_flag = true; break;
- if ( verbose_flag )
- fprintf(stderr, "Frame Buffer size: %lu bytes.\n", fb_size);
+ case 'w':
+ TEST_EXTRA_ARG(i, 'w');
+ number_width = Kumu::xabs(strtol(argv[i], 0, 10));
+ break;
+ case 'x':
+ TEST_EXTRA_ARG(i, 'x');
+ mode = MMT_EXTRACT;
+ file_root = argv[i];
break;
+ case 'Z': j2c_pedantic = false; break;
+ case 'z': j2c_pedantic = true; break;
+
default:
- fprintf(stderr, "Unrecognized option: %c\n", argv[i][1]);
+ fprintf(stderr, "Unrecognized option: %s\n", argv[i]);
return;
}
}
else
{
- filenames[file_count++] = argv[i];
+
+ if ( argv[i][0] != '-' )
+ {
+ filenames[file_count++] = argv[i];
+ }
+ else
+ {
+ fprintf(stderr, "Unrecognized argument: %s\n", argv[i]);
+ return;
+ }
if ( file_count >= MAX_IN_FILES )
{
- fprintf(stderr, "Filename lists exceeds maximum list size: %lu\n", MAX_IN_FILES);
+ fprintf(stderr, "Filename lists exceeds maximum list size: %u\n", MAX_IN_FILES);
return;
}
}
}
- if ( TEST_MAJOR_MODE() )
+ if ( help_flag || version_flag )
+ return;
+
+ if ( ( mode == MMT_INFO
+ || mode == MMT_CREATE
+ || mode == MMT_EXTRACT
+ || mode == MMT_GOP_START
+ || mode == MMT_DIGEST ) && file_count == 0 )
{
- if ( ! genkey_flag && ! genid_flag && file_count == 0 )
- {
- fputs("Option requires at least one filename argument.\n", stderr);
- return;
- }
+ fputs("Option requires at least one filename argument.\n", stderr);
+ return;
}
- if ( ! TEST_MAJOR_MODE() && ! help_flag && ! version_flag )
+ if ( mode == MMT_NONE && ! help_flag && ! version_flag )
{
- fputs("No operation selected (use one of -(gcixG) or -h for help).\n", stderr);
+ fputs("No operation selected (use one of -[gGcitux] or -h for help).\n", stderr);
return;
}
//------------------------------------------------------------------------------------------
// MPEG2 essence
-#if 0
+
// Write a plaintext MPEG2 Video Elementary Stream to a plaintext ASDCP file
// Write a plaintext MPEG2 Video Elementary Stream to a ciphertext ASDCP file
//
MPEG2::Parser Parser;
MPEG2::MXFWriter Writer;
MPEG2::VideoDescriptor VDesc;
-
-#ifndef ASDCP_WITHOUT_OPENSSL
byte_t IV_buf[CBC_BLOCK_SIZE];
- FortunaRNG RNG;
-#endif
+ Kumu::FortunaRNG RNG;
// set up essence parser
Result_t result = Parser.OpenRead(Options.filenames[0]);
{
fputs("MPEG-2 Pictures\n", stderr);
fputs("VideoDescriptor:\n", stderr);
- fprintf(stderr, "Frame Buffer size: %lu\n", Options.fb_size);
+ fprintf(stderr, "Frame Buffer size: %u\n", Options.fb_size);
MPEG2::VideoDescriptorDump(VDesc);
}
}
if ( ASDCP_SUCCESS(result) && ! Options.no_write_flag )
{
WriterInfo Info = s_MyInfo; // fill in your favorite identifiers here
-#ifndef ASDCP_WITHOUT_OPENSSL
- GenRandomUUID(RNG, Info.AssetUUID);
+ if ( Options.asset_id_flag )
+ memcpy(Info.AssetUUID, Options.asset_id_value, UUIDlen);
+ else
+ Kumu::GenRandomUUID(Info.AssetUUID);
+
+ if ( Options.use_smpte_labels )
+ {
+ Info.LabelSetType = LS_MXF_SMPTE;
+ fprintf(stderr, "ATTENTION! Writing SMPTE Universal Labels\n");
+ }
// configure encryption
if( Options.key_flag )
{
- GenRandomUUID(RNG, Info.ContextID);
+ Kumu::GenRandomUUID(Info.ContextID);
Info.EncryptedEssence = true;
if ( Options.key_id_flag )
- memcpy(Info.CryptographicKeyID, Options.key_id_value, KeyIDlen);
+ memcpy(Info.CryptographicKeyID, Options.key_id_value, UUIDlen);
else
- RNG.FillRandom(Info.CryptographicKeyID, KeyIDlen);
+ RNG.FillRandom(Info.CryptographicKeyID, UUIDlen);
Context = new AESEncContext;
result = Context->InitKey(Options.key_value);
{
Info.UsesHMAC = true;
HMAC = new HMACContext;
- result = HMAC->InitKey(Options.key_value);
+ result = HMAC->InitKey(Options.key_value, Info.LabelSetType);
}
}
-#endif // ASDCP_WITHOUT_OPENSSL
if ( ASDCP_SUCCESS(result) )
result = Writer.OpenWrite(Options.out_file, Info, VDesc);
{
result = Writer.WriteFrame(FrameBuffer, Context, HMAC);
-#ifndef ASDCP_WITHOUT_OPENSSL
// The Writer class will forward the last block of ciphertext
// to the encryption context for use as the IV for the next
// frame. If you want to use non-sequitur IV values, un-comment
// the following line of code.
// if ( ASDCP_SUCCESS(result) && Options.key_flag )
// Context->SetIVec(RNG.FillRandom(IV_buf, CBC_BLOCK_SIZE));
-#endif
}
}
return result;
}
-#endif
// Read a plaintext MPEG2 Video Elementary Stream from a plaintext ASDCP file
// Read a plaintext MPEG2 Video Elementary Stream from a ciphertext ASDCP file
HMACContext* HMAC = 0;
MPEG2::MXFReader Reader;
MPEG2::FrameBuffer FrameBuffer(Options.fb_size);
- FileWriter OutFile;
+ Kumu::FileWriter OutFile;
ui32_t frame_count = 0;
Result_t result = Reader.OpenRead(Options.filenames[0]);
if ( Options.verbose_flag )
{
- fprintf(stderr, "Frame Buffer size: %lu\n", Options.fb_size);
+ fprintf(stderr, "Frame Buffer size: %u\n", Options.fb_size);
MPEG2::VideoDescriptorDump(VDesc);
}
}
if ( Info.UsesHMAC )
{
HMAC = new HMACContext;
- result = HMAC->InitKey(Options.key_value);
+ result = HMAC->InitKey(Options.key_value, Info.LabelSetType);
}
else
{
if ( Options.verbose_flag )
{
- fprintf(stderr, "Frame Buffer size: %lu\n", Options.fb_size);
+ fprintf(stderr, "Frame Buffer size: %u\n", Options.fb_size);
MPEG2::VideoDescriptorDump(VDesc);
}
}
if ( FrameBuffer.FrameType() != FRAME_I )
fprintf(stderr, "Expecting an I frame, got %c\n", FrameTypeChar(FrameBuffer.FrameType()));
- fprintf(stderr, "Requested frame %lu, got %lu\n", i, FrameBuffer.FrameNumber());
+ fprintf(stderr, "Requested frame %u, got %u\n", i, FrameBuffer.FrameNumber());
}
}
return result;
}
-#if 0
//------------------------------------------------------------------------------------------
// JPEG 2000 essence
-// Write one or more plaintext JPEG 2000 codestreams to a plaintext ASDCP file
-// Write one or more plaintext JPEG 2000 codestreams to a ciphertext ASDCP file
+// Write one or more plaintext JPEG 2000 stereoscopic codestream pairs to a plaintext ASDCP file
+// Write one or more plaintext JPEG 2000 stereoscopic codestream pairs to a ciphertext ASDCP file
//
Result_t
-write_JP2K_file(CommandOptions& Options)
+write_JP2K_S_file(CommandOptions& Options)
{
AESEncContext* Context = 0;
HMACContext* HMAC = 0;
- JP2K::MXFWriter Writer;
+ JP2K::MXFSWriter Writer;
JP2K::FrameBuffer FrameBuffer(Options.fb_size);
JP2K::PictureDescriptor PDesc;
- JP2K::SequenceParser Parser;
+ JP2K::SequenceParser ParserLeft, ParserRight;
+ byte_t IV_buf[CBC_BLOCK_SIZE];
+ Kumu::FortunaRNG RNG;
-#ifndef ASDCP_WITHOUT_OPENSSL
- byte_t IV_buf[CBC_BLOCK_SIZE];
- FortunaRNG RNG;
-#endif
+ if ( Options.file_count != 2 )
+ {
+ fprintf(stderr, "Two inputs are required for stereoscopic option.\n");
+ return RESULT_FAIL;
+ }
// set up essence parser
- Result_t result = Parser.OpenRead(Options.filenames[0]);
+ Result_t result = ParserLeft.OpenRead(Options.filenames[0], Options.j2c_pedantic);
+
+ if ( ASDCP_SUCCESS(result) )
+ result = ParserRight.OpenRead(Options.filenames[1], Options.j2c_pedantic);
// set up MXF writer
if ( ASDCP_SUCCESS(result) )
{
- Parser.FillPictureDescriptor(PDesc);
+ ParserLeft.FillPictureDescriptor(PDesc);
PDesc.EditRate = Options.PictureRate();
if ( Options.verbose_flag )
{
- fprintf(stderr, "JPEG 2000 pictures\n");
- fputs("PictureDescriptor:\n", stderr);
- fprintf(stderr, "Frame Buffer size: %lu\n", Options.fb_size);
+ fputs("JPEG 2000 stereoscopic pictures\nPictureDescriptor:\n", stderr);
+ fprintf(stderr, "Frame Buffer size: %u\n", Options.fb_size);
JP2K::PictureDescriptorDump(PDesc);
}
}
if ( ASDCP_SUCCESS(result) && ! Options.no_write_flag )
{
WriterInfo Info = s_MyInfo; // fill in your favorite identifiers here
-#ifndef ASDCP_WITHOUT_OPENSSL
- GenRandomUUID(RNG, Info.AssetUUID);
+ if ( Options.asset_id_flag )
+ memcpy(Info.AssetUUID, Options.asset_id_value, UUIDlen);
+ else
+ Kumu::GenRandomUUID(Info.AssetUUID);
+
+ if ( Options.use_smpte_labels )
+ {
+ Info.LabelSetType = LS_MXF_SMPTE;
+ fprintf(stderr, "ATTENTION! Writing SMPTE Universal Labels\n");
+ }
// configure encryption
if( Options.key_flag )
{
- GenRandomUUID(RNG, Info.ContextID);
+ Kumu::GenRandomUUID(Info.ContextID);
Info.EncryptedEssence = true;
if ( Options.key_id_flag )
- memcpy(Info.CryptographicKeyID, Options.key_id_value, KeyIDlen);
+ memcpy(Info.CryptographicKeyID, Options.key_id_value, UUIDlen);
else
- RNG.FillRandom(Info.CryptographicKeyID, KeyIDlen);
+ RNG.FillRandom(Info.CryptographicKeyID, UUIDlen);
Context = new AESEncContext;
result = Context->InitKey(Options.key_value);
{
Info.UsesHMAC = true;
HMAC = new HMACContext;
- result = HMAC->InitKey(Options.key_value);
+ result = HMAC->InitKey(Options.key_value, Info.LabelSetType);
}
}
-#endif // ASDCP_WITHOUT_OPENSSL
if ( ASDCP_SUCCESS(result) )
result = Writer.OpenWrite(Options.out_file, Info, PDesc);
if ( ASDCP_SUCCESS(result) )
{
ui32_t duration = 0;
- result = Parser.Reset();
+ result = ParserLeft.Reset();
+ if ( ASDCP_SUCCESS(result) ) result = ParserRight.Reset();
while ( ASDCP_SUCCESS(result) && duration++ < Options.duration )
{
- if ( ! Options.do_repeat || duration == 1 )
- {
- result = Parser.ReadFrame(FrameBuffer);
+ result = ParserLeft.ReadFrame(FrameBuffer);
- if ( ASDCP_SUCCESS(result) )
- {
- if ( Options.verbose_flag )
- FrameBuffer.Dump(stderr, Options.fb_dump_size);
+ if ( ASDCP_SUCCESS(result) )
+ {
+ if ( Options.verbose_flag )
+ FrameBuffer.Dump(stderr, Options.fb_dump_size);
- if ( Options.encrypt_header_flag )
- FrameBuffer.PlaintextOffset(0);
- }
+ if ( Options.encrypt_header_flag )
+ FrameBuffer.PlaintextOffset(0);
}
if ( ASDCP_SUCCESS(result) && ! Options.no_write_flag )
+ result = Writer.WriteFrame(FrameBuffer, JP2K::SP_LEFT, Context, HMAC);
+
+ if ( ASDCP_SUCCESS(result) )
+ result = ParserRight.ReadFrame(FrameBuffer);
+
+ if ( ASDCP_SUCCESS(result) )
{
- result = Writer.WriteFrame(FrameBuffer, Context, HMAC);
-#ifndef ASDCP_WITHOUT_OPENSSL
- // The Writer class will forward the last block of ciphertext
- // to the encryption context for use as the IV for the next
- // frame. If you want to use non-sequitur IV values, un-comment
- // the following line of code.
- // if ( ASDCP_SUCCESS(result) && Options.key_flag )
- // Context->SetIVec(RNG.FillRandom(IV_buf, CBC_BLOCK_SIZE));
-#endif
+ if ( Options.verbose_flag )
+ FrameBuffer.Dump(stderr, Options.fb_dump_size);
+
+ if ( Options.encrypt_header_flag )
+ FrameBuffer.PlaintextOffset(0);
}
+
+ if ( ASDCP_SUCCESS(result) && ! Options.no_write_flag )
+ result = Writer.WriteFrame(FrameBuffer, JP2K::SP_RIGHT, Context, HMAC);
}
if ( result == RESULT_ENDOFFILE )
return result;
}
-#endif
-// Read one or more plaintext JPEG 2000 codestreams from a plaintext ASDCP file
-// Read one or more plaintext JPEG 2000 codestreams from a ciphertext ASDCP file
-// Read one or more ciphertext JPEG 2000 codestreams from a ciphertext ASDCP file
-//
+// Read one or more plaintext JPEG 2000 stereoscopic codestream pairs from a plaintext ASDCP file
+// Read one or more plaintext JPEG 2000 stereoscopic codestream pairs from a ciphertext ASDCP file
+// Read one or more ciphertext JPEG 2000 stereoscopic codestream pairs from a ciphertext ASDCP file
Result_t
-read_JP2K_file(CommandOptions& Options)
+read_JP2K_S_file(CommandOptions& Options)
{
AESDecContext* Context = 0;
HMACContext* HMAC = 0;
- JP2K::MXFReader Reader;
+ JP2K::MXFSReader Reader;
JP2K::FrameBuffer FrameBuffer(Options.fb_size);
ui32_t frame_count = 0;
if ( Options.verbose_flag )
{
- fprintf(stderr, "Frame Buffer size: %lu\n", Options.fb_size);
+ fprintf(stderr, "Frame Buffer size: %u\n", Options.fb_size);
JP2K::PictureDescriptorDump(PDesc);
}
}
if ( Info.UsesHMAC )
{
HMAC = new HMACContext;
- result = HMAC->InitKey(Options.key_value);
+ result = HMAC->InitKey(Options.key_value, Info.LabelSetType);
}
else
{
}
}
+ const int filename_max = 1024;
+ char filename[filename_max];
ui32_t last_frame = Options.start_frame + ( Options.duration ? Options.duration : frame_count);
if ( last_frame > frame_count )
last_frame = frame_count;
+ char left_format[64]; char right_format[64];
+ snprintf(left_format, 64, "%%s%%0%duL.j2c", Options.number_width);
+ snprintf(right_format, 64, "%%s%%0%duR.j2c", Options.number_width);
+
for ( ui32_t i = Options.start_frame; ASDCP_SUCCESS(result) && i < last_frame; i++ )
{
- result = Reader.ReadFrame(i, FrameBuffer, Context, HMAC);
+ result = Reader.ReadFrame(i, JP2K::SP_LEFT, FrameBuffer, Context, HMAC);
if ( ASDCP_SUCCESS(result) )
{
- FileWriter OutFile;
- char filename[256];
+ Kumu::FileWriter OutFile;
ui32_t write_count;
- snprintf(filename, 256, "%s%06lu.j2c", Options.file_root, i);
+ snprintf(filename, filename_max, left_format, Options.file_root, i);
result = OutFile.OpenWrite(filename);
if ( ASDCP_SUCCESS(result) )
if ( Options.verbose_flag )
FrameBuffer.Dump(stderr, Options.fb_dump_size);
}
+
+ if ( ASDCP_SUCCESS(result) )
+ result = Reader.ReadFrame(i, JP2K::SP_RIGHT, FrameBuffer, Context, HMAC);
+
+ if ( ASDCP_SUCCESS(result) )
+ {
+ Kumu::FileWriter OutFile;
+ ui32_t write_count;
+ snprintf(filename, filename_max, right_format, Options.file_root, i);
+ result = OutFile.OpenWrite(filename);
+
+ if ( ASDCP_SUCCESS(result) )
+ result = OutFile.Write(FrameBuffer.Data(), FrameBuffer.Size(), &write_count);
+ }
}
return result;
}
-#if 0
-//------------------------------------------------------------------------------------------
-// PCM essence
-// Write one or more plaintext PCM audio streams to a plaintext ASDCP file
-// Write one or more plaintext PCM audio streams to a ciphertext ASDCP file
+// Write one or more plaintext JPEG 2000 codestreams to a plaintext ASDCP file
+// Write one or more plaintext JPEG 2000 codestreams to a ciphertext ASDCP file
//
Result_t
-write_PCM_file(CommandOptions& Options)
+write_JP2K_file(CommandOptions& Options)
{
- AESEncContext* Context = 0;
- HMACContext* HMAC = 0;
- PCMParserList Parser;
- PCM::MXFWriter Writer;
- PCM::FrameBuffer FrameBuffer;
- PCM::AudioDescriptor ADesc;
- Rational PictureRate = Options.PictureRate();
-
-#ifndef ASDCP_WITHOUT_OPENSSL
- byte_t IV_buf[CBC_BLOCK_SIZE];
- FortunaRNG RNG;
-#endif
+ AESEncContext* Context = 0;
+ HMACContext* HMAC = 0;
+ JP2K::MXFWriter Writer;
+ JP2K::FrameBuffer FrameBuffer(Options.fb_size);
+ JP2K::PictureDescriptor PDesc;
+ JP2K::SequenceParser Parser;
+ byte_t IV_buf[CBC_BLOCK_SIZE];
+ Kumu::FortunaRNG RNG;
// set up essence parser
- Result_t result = Parser.OpenRead(Options.file_count, Options.filenames, PictureRate);
+ Result_t result = Parser.OpenRead(Options.filenames[0], Options.j2c_pedantic);
// set up MXF writer
if ( ASDCP_SUCCESS(result) )
{
- Parser.FillAudioDescriptor(ADesc);
-
- ADesc.SampleRate = PictureRate;
- FrameBuffer.Capacity(PCM::CalcFrameBufferSize(ADesc));
+ Parser.FillPictureDescriptor(PDesc);
+ PDesc.EditRate = Options.PictureRate();
if ( Options.verbose_flag )
{
- fprintf(stderr, "48Khz PCM Audio, %s fps (%lu spf)\n",
- Options.szPictureRate(),
- PCM::CalcSamplesPerFrame(ADesc));
- fputs("AudioDescriptor:\n", stderr);
- PCM::AudioDescriptorDump(ADesc);
+ fprintf(stderr, "JPEG 2000 pictures\n");
+ fputs("PictureDescriptor:\n", stderr);
+ fprintf(stderr, "Frame Buffer size: %u\n", Options.fb_size);
+ JP2K::PictureDescriptorDump(PDesc);
}
}
if ( ASDCP_SUCCESS(result) && ! Options.no_write_flag )
{
WriterInfo Info = s_MyInfo; // fill in your favorite identifiers here
-#ifndef ASDCP_WITHOUT_OPENSSL
- GenRandomUUID(RNG, Info.AssetUUID);
+ if ( Options.asset_id_flag )
+ memcpy(Info.AssetUUID, Options.asset_id_value, UUIDlen);
+ else
+ Kumu::GenRandomUUID(Info.AssetUUID);
+
+ if ( Options.use_smpte_labels )
+ {
+ Info.LabelSetType = LS_MXF_SMPTE;
+ fprintf(stderr, "ATTENTION! Writing SMPTE Universal Labels\n");
+ }
// configure encryption
if( Options.key_flag )
{
- GenRandomUUID(RNG, Info.ContextID);
+ Kumu::GenRandomUUID(Info.ContextID);
Info.EncryptedEssence = true;
if ( Options.key_id_flag )
- memcpy(Info.CryptographicKeyID, Options.key_id_value, KeyIDlen);
+ memcpy(Info.CryptographicKeyID, Options.key_id_value, UUIDlen);
else
- RNG.FillRandom(Info.CryptographicKeyID, KeyIDlen);
+ RNG.FillRandom(Info.CryptographicKeyID, UUIDlen);
Context = new AESEncContext;
result = Context->InitKey(Options.key_value);
{
Info.UsesHMAC = true;
HMAC = new HMACContext;
- result = HMAC->InitKey(Options.key_value);
+ result = HMAC->InitKey(Options.key_value, Info.LabelSetType);
}
}
-#endif // ASDCP_WITHOUT_OPENSSL
if ( ASDCP_SUCCESS(result) )
- result = Writer.OpenWrite(Options.out_file, Info, ADesc);
+ result = Writer.OpenWrite(Options.out_file, Info, PDesc);
}
if ( ASDCP_SUCCESS(result) )
{
- result = Parser.Reset();
ui32_t duration = 0;
+ result = Parser.Reset();
while ( ASDCP_SUCCESS(result) && duration++ < Options.duration )
{
- result = Parser.ReadFrame(FrameBuffer);
-
- if ( ASDCP_SUCCESS(result) )
+ if ( ! Options.do_repeat || duration == 1 )
{
- if ( FrameBuffer.Size() != FrameBuffer.Capacity() )
+ result = Parser.ReadFrame(FrameBuffer);
+
+ if ( ASDCP_SUCCESS(result) )
{
- fprintf(stderr, "WARNING: Last frame read was short, PCM input is possibly not frame aligned.\n");
- fprintf(stderr, "Expecting %lu bytes, got %lu.\n", FrameBuffer.Capacity(), FrameBuffer.Size());
- result = RESULT_ENDOFFILE;
- continue;
+ if ( Options.verbose_flag )
+ FrameBuffer.Dump(stderr, Options.fb_dump_size);
+
+ if ( Options.encrypt_header_flag )
+ FrameBuffer.PlaintextOffset(0);
}
+ }
- if ( Options.verbose_flag )
- FrameBuffer.Dump(stderr, Options.fb_dump_size);
+ if ( ASDCP_SUCCESS(result) && ! Options.no_write_flag )
+ {
+ result = Writer.WriteFrame(FrameBuffer, Context, HMAC);
- if ( ! Options.no_write_flag )
- {
- result = Writer.WriteFrame(FrameBuffer, Context, HMAC);
+ // The Writer class will forward the last block of ciphertext
+ // to the encryption context for use as the IV for the next
+ // frame. If you want to use non-sequitur IV values, un-comment
+ // the following line of code.
+ // if ( ASDCP_SUCCESS(result) && Options.key_flag )
+ // Context->SetIVec(RNG.FillRandom(IV_buf, CBC_BLOCK_SIZE));
+ }
+ }
+
+ if ( result == RESULT_ENDOFFILE )
+ result = RESULT_OK;
+ }
+
+ if ( ASDCP_SUCCESS(result) && ! Options.no_write_flag )
+ result = Writer.Finalize();
+
+ return result;
+}
+
+// Read one or more plaintext JPEG 2000 codestreams from a plaintext ASDCP file
+// Read one or more plaintext JPEG 2000 codestreams from a ciphertext ASDCP file
+// Read one or more ciphertext JPEG 2000 codestreams from a ciphertext ASDCP file
+//
+Result_t
+read_JP2K_file(CommandOptions& Options)
+{
+ AESDecContext* Context = 0;
+ HMACContext* HMAC = 0;
+ JP2K::MXFReader Reader;
+ JP2K::FrameBuffer FrameBuffer(Options.fb_size);
+ ui32_t frame_count = 0;
+
+ Result_t result = Reader.OpenRead(Options.filenames[0]);
+
+ if ( ASDCP_SUCCESS(result) )
+ {
+ JP2K::PictureDescriptor PDesc;
+ Reader.FillPictureDescriptor(PDesc);
+
+ frame_count = PDesc.ContainerDuration;
+
+ if ( Options.verbose_flag )
+ {
+ fprintf(stderr, "Frame Buffer size: %u\n", Options.fb_size);
+ JP2K::PictureDescriptorDump(PDesc);
+ }
+ }
+
+ if ( ASDCP_SUCCESS(result) && Options.key_flag )
+ {
+ Context = new AESDecContext;
+ result = Context->InitKey(Options.key_value);
+
+ if ( ASDCP_SUCCESS(result) && Options.read_hmac )
+ {
+ WriterInfo Info;
+ Reader.FillWriterInfo(Info);
+
+ if ( Info.UsesHMAC )
+ {
+ HMAC = new HMACContext;
+ result = HMAC->InitKey(Options.key_value, Info.LabelSetType);
+ }
+ else
+ {
+ fputs("File does not contain HMAC values, ignoring -m option.\n", stderr);
+ }
+ }
+ }
+
+ ui32_t last_frame = Options.start_frame + ( Options.duration ? Options.duration : frame_count);
+ if ( last_frame > frame_count )
+ last_frame = frame_count;
+
+ char name_format[64];
+ snprintf(name_format, 64, "%%s%%0%du.j2c", Options.number_width);
+
+ for ( ui32_t i = Options.start_frame; ASDCP_SUCCESS(result) && i < last_frame; i++ )
+ {
+ result = Reader.ReadFrame(i, FrameBuffer, Context, HMAC);
+
+ if ( ASDCP_SUCCESS(result) )
+ {
+ Kumu::FileWriter OutFile;
+ char filename[256];
+ ui32_t write_count;
+ snprintf(filename, 256, name_format, Options.file_root, i);
+ result = OutFile.OpenWrite(filename);
+
+ if ( ASDCP_SUCCESS(result) )
+ result = OutFile.Write(FrameBuffer.Data(), FrameBuffer.Size(), &write_count);
+
+ if ( Options.verbose_flag )
+ FrameBuffer.Dump(stderr, Options.fb_dump_size);
+ }
+ }
+
+ return result;
+}
+
+//------------------------------------------------------------------------------------------
+// PCM essence
+
+
+// Write one or more plaintext PCM audio streams to a plaintext ASDCP file
+// Write one or more plaintext PCM audio streams to a ciphertext ASDCP file
+//
+Result_t
+write_PCM_file(CommandOptions& Options)
+{
+ AESEncContext* Context = 0;
+ HMACContext* HMAC = 0;
+ PCMParserList Parser;
+ PCM::MXFWriter Writer;
+ PCM::FrameBuffer FrameBuffer;
+ PCM::AudioDescriptor ADesc;
+ Rational PictureRate = Options.PictureRate();
+ byte_t IV_buf[CBC_BLOCK_SIZE];
+ Kumu::FortunaRNG RNG;
+
+ // set up essence parser
+ Result_t result = Parser.OpenRead(Options.file_count, Options.filenames, PictureRate);
+
+ // set up MXF writer
+ if ( ASDCP_SUCCESS(result) )
+ {
+ Parser.FillAudioDescriptor(ADesc);
+
+ ADesc.EditRate = PictureRate;
+ FrameBuffer.Capacity(PCM::CalcFrameBufferSize(ADesc));
+ ADesc.ChannelFormat = Options.channel_fmt;
+
+ if ( Options.use_smpte_labels && ADesc.ChannelFormat == PCM::CF_NONE)
+ {
+ fprintf(stderr, "ATTENTION! Writing SMPTE audio without ChannelAssignment property (see option -l)\n");
+ }
+
+ if ( Options.verbose_flag )
+ {
+ fprintf(stderr, "%.1fkHz PCM Audio, %s fps (%u spf)\n",
+ ADesc.AudioSamplingRate.Quotient() / 1000.0,
+ Options.szPictureRate(),
+ PCM::CalcSamplesPerFrame(ADesc));
+ fputs("AudioDescriptor:\n", stderr);
+ PCM::AudioDescriptorDump(ADesc);
+ }
+ }
+
+ if ( ASDCP_SUCCESS(result) && ! Options.no_write_flag )
+ {
+ WriterInfo Info = s_MyInfo; // fill in your favorite identifiers here
+ if ( Options.asset_id_flag )
+ memcpy(Info.AssetUUID, Options.asset_id_value, UUIDlen);
+ else
+ Kumu::GenRandomUUID(Info.AssetUUID);
+
+ if ( Options.use_smpte_labels )
+ {
+ Info.LabelSetType = LS_MXF_SMPTE;
+ fprintf(stderr, "ATTENTION! Writing SMPTE Universal Labels\n");
+ }
+
+ // configure encryption
+ if( Options.key_flag )
+ {
+ Kumu::GenRandomUUID(Info.ContextID);
+ Info.EncryptedEssence = true;
+
+ if ( Options.key_id_flag )
+ memcpy(Info.CryptographicKeyID, Options.key_id_value, UUIDlen);
+ else
+ RNG.FillRandom(Info.CryptographicKeyID, UUIDlen);
+
+ Context = new AESEncContext;
+ result = Context->InitKey(Options.key_value);
+
+ if ( ASDCP_SUCCESS(result) )
+ result = Context->SetIVec(RNG.FillRandom(IV_buf, CBC_BLOCK_SIZE));
+
+ if ( ASDCP_SUCCESS(result) && Options.write_hmac )
+ {
+ Info.UsesHMAC = true;
+ HMAC = new HMACContext;
+ result = HMAC->InitKey(Options.key_value, Info.LabelSetType);
+ }
+ }
+
+ if ( ASDCP_SUCCESS(result) )
+ result = Writer.OpenWrite(Options.out_file, Info, ADesc);
+ }
+
+ if ( ASDCP_SUCCESS(result) )
+ {
+ result = Parser.Reset();
+ ui32_t duration = 0;
+
+ while ( ASDCP_SUCCESS(result) && duration++ < Options.duration )
+ {
+ result = Parser.ReadFrame(FrameBuffer);
+
+ if ( ASDCP_SUCCESS(result) )
+ {
+ if ( FrameBuffer.Size() != FrameBuffer.Capacity() )
+ {
+ fprintf(stderr, "WARNING: Last frame read was short, PCM input is possibly not frame aligned.\n");
+ fprintf(stderr, "Expecting %u bytes, got %u.\n", FrameBuffer.Capacity(), FrameBuffer.Size());
+ result = RESULT_ENDOFFILE;
+ continue;
+ }
+
+ if ( Options.verbose_flag )
+ FrameBuffer.Dump(stderr, Options.fb_dump_size);
+
+ if ( ! Options.no_write_flag )
+ {
+ result = Writer.WriteFrame(FrameBuffer, Context, HMAC);
-#ifndef ASDCP_WITHOUT_OPENSSL
// The Writer class will forward the last block of ciphertext
// to the encryption context for use as the IV for the next
// frame. If you want to use non-sequitur IV values, un-comment
// the following line of code.
// if ( ASDCP_SUCCESS(result) && Options.key_flag )
// Context->SetIVec(RNG.FillRandom(IV_buf, CBC_BLOCK_SIZE));
-#endif
}
}
}
return result;
}
-#endif
// Read one or more plaintext PCM audio streams from a plaintext ASDCP file
// Read one or more plaintext PCM audio streams from a ciphertext ASDCP file
{
Reader.FillAudioDescriptor(ADesc);
- if ( ADesc.SampleRate != EditRate_23_98
- && ADesc.SampleRate != EditRate_24
- && ADesc.SampleRate != EditRate_48 )
- ADesc.SampleRate = Options.PictureRate();
+ if ( ADesc.EditRate != EditRate_23_98
+ && ADesc.EditRate != EditRate_24
+ && ADesc.EditRate != EditRate_25
+ && ADesc.EditRate != EditRate_30
+ && ADesc.EditRate != EditRate_48
+ && ADesc.EditRate != EditRate_50
+ && ADesc.EditRate != EditRate_60 )
+ ADesc.EditRate = Options.PictureRate();
FrameBuffer.Capacity(PCM::CalcFrameBufferSize(ADesc));
return RESULT_FAIL;
}
- last_frame = xmin(Options.start_frame + last_frame, ADesc.ContainerDuration);
+ last_frame = Kumu::xmin(Options.start_frame + last_frame, ADesc.ContainerDuration);
}
ADesc.ContainerDuration = last_frame - Options.start_frame;
- OutWave.OpenWrite(ADesc, Options.file_root, Options.split_wav);
+ OutWave.OpenWrite(ADesc, Options.file_root,
+ ( Options.split_wav ? WavFileWriter::ST_STEREO :
+ ( Options.mono_wav ? WavFileWriter::ST_MONO : WavFileWriter::ST_NONE ) ));
}
if ( ASDCP_SUCCESS(result) && Options.key_flag )
if ( Info.UsesHMAC )
{
HMAC = new HMACContext;
- result = HMAC->InitKey(Options.key_value);
+ result = HMAC->InitKey(Options.key_value, Info.LabelSetType);
}
else
{
}
+//------------------------------------------------------------------------------------------
+// TimedText essence
+
+
+// Write one or more plaintext timed text streams to a plaintext ASDCP file
+// Write one or more plaintext timed text streams to a ciphertext ASDCP file
+//
+Result_t
+write_timed_text_file(CommandOptions& Options)
+{
+ AESEncContext* Context = 0;
+ HMACContext* HMAC = 0;
+ TimedText::DCSubtitleParser Parser;
+ TimedText::MXFWriter Writer;
+ TimedText::FrameBuffer FrameBuffer;
+ TimedText::TimedTextDescriptor TDesc;
+ byte_t IV_buf[CBC_BLOCK_SIZE];
+ Kumu::FortunaRNG RNG;
+
+ // set up essence parser
+ Result_t result = Parser.OpenRead(Options.filenames[0]);
+
+ // set up MXF writer
+ if ( ASDCP_SUCCESS(result) )
+ {
+ Parser.FillTimedTextDescriptor(TDesc);
+ FrameBuffer.Capacity(Options.fb_size);
+
+ if ( Options.verbose_flag )
+ {
+ fputs("D-Cinema Timed-Text Descriptor:\n", stderr);
+ TimedText::DescriptorDump(TDesc);
+ }
+ }
+
+ if ( ASDCP_SUCCESS(result) && ! Options.no_write_flag )
+ {
+ WriterInfo Info = s_MyInfo; // fill in your favorite identifiers here
+ if ( Options.asset_id_flag )
+ memcpy(Info.AssetUUID, Options.asset_id_value, UUIDlen);
+ else
+ Kumu::GenRandomUUID(Info.AssetUUID);
+
+ if ( Options.use_smpte_labels )
+ {
+ Info.LabelSetType = LS_MXF_SMPTE;
+ fprintf(stderr, "ATTENTION! Writing SMPTE Universal Labels\n");
+ }
+
+ // configure encryption
+ if( Options.key_flag )
+ {
+ Kumu::GenRandomUUID(Info.ContextID);
+ Info.EncryptedEssence = true;
+
+ if ( Options.key_id_flag )
+ memcpy(Info.CryptographicKeyID, Options.key_id_value, UUIDlen);
+ else
+ RNG.FillRandom(Info.CryptographicKeyID, UUIDlen);
+
+ Context = new AESEncContext;
+ result = Context->InitKey(Options.key_value);
+
+ if ( ASDCP_SUCCESS(result) )
+ result = Context->SetIVec(RNG.FillRandom(IV_buf, CBC_BLOCK_SIZE));
+
+ if ( ASDCP_SUCCESS(result) && Options.write_hmac )
+ {
+ Info.UsesHMAC = true;
+ HMAC = new HMACContext;
+ result = HMAC->InitKey(Options.key_value, Info.LabelSetType);
+ }
+ }
+
+ if ( ASDCP_SUCCESS(result) )
+ result = Writer.OpenWrite(Options.out_file, Info, TDesc);
+ }
+
+ if ( ASDCP_FAILURE(result) )
+ return result;
+
+ std::string XMLDoc;
+ TimedText::ResourceList_t::const_iterator ri;
+
+ result = Parser.ReadTimedTextResource(XMLDoc);
+
+ if ( ASDCP_SUCCESS(result) )
+ result = Writer.WriteTimedTextResource(XMLDoc, Context, HMAC);
+
+ for ( ri = TDesc.ResourceList.begin() ; ri != TDesc.ResourceList.end() && ASDCP_SUCCESS(result); ri++ )
+ {
+ result = Parser.ReadAncillaryResource((*ri).ResourceID, FrameBuffer);
+
+ if ( ASDCP_SUCCESS(result) )
+ {
+ if ( Options.verbose_flag )
+ FrameBuffer.Dump(stderr, Options.fb_dump_size);
+
+ if ( ! Options.no_write_flag )
+ {
+ result = Writer.WriteAncillaryResource(FrameBuffer, Context, HMAC);
+
+ // The Writer class will forward the last block of ciphertext
+ // to the encryption context for use as the IV for the next
+ // frame. If you want to use non-sequitur IV values, un-comment
+ // the following line of code.
+ // if ( ASDCP_SUCCESS(result) && Options.key_flag )
+ // Context->SetIVec(RNG.FillRandom(IV_buf, CBC_BLOCK_SIZE));
+ }
+ }
+
+ if ( result == RESULT_ENDOFFILE )
+ result = RESULT_OK;
+ }
+
+ if ( ASDCP_SUCCESS(result) && ! Options.no_write_flag )
+ result = Writer.Finalize();
+
+ return result;
+}
+
+
+// Read one or more timed text streams from a plaintext ASDCP file
+// Read one or more timed text streams from a ciphertext ASDCP file
+// Read one or more timed text streams from a ciphertext ASDCP file
+//
+Result_t
+read_timed_text_file(CommandOptions& Options)
+{
+ AESDecContext* Context = 0;
+ HMACContext* HMAC = 0;
+ TimedText::MXFReader Reader;
+ TimedText::FrameBuffer FrameBuffer;
+ TimedText::TimedTextDescriptor TDesc;
+
+ Result_t result = Reader.OpenRead(Options.filenames[0]);
+
+ if ( ASDCP_SUCCESS(result) )
+ {
+ Reader.FillTimedTextDescriptor(TDesc);
+ FrameBuffer.Capacity(Options.fb_size);
+
+ if ( Options.verbose_flag )
+ TimedText::DescriptorDump(TDesc);
+ }
+
+ if ( ASDCP_SUCCESS(result) && Options.key_flag )
+ {
+ Context = new AESDecContext;
+ result = Context->InitKey(Options.key_value);
+
+ if ( ASDCP_SUCCESS(result) && Options.read_hmac )
+ {
+ WriterInfo Info;
+ Reader.FillWriterInfo(Info);
+
+ if ( Info.UsesHMAC )
+ {
+ HMAC = new HMACContext;
+ result = HMAC->InitKey(Options.key_value, Info.LabelSetType);
+ }
+ else
+ {
+ fputs("File does not contain HMAC values, ignoring -m option.\n", stderr);
+ }
+ }
+ }
+
+ if ( ASDCP_FAILURE(result) )
+ return result;
+
+ std::string XMLDoc;
+ std::string out_path = Kumu::PathDirname(Options.file_root);
+ ui32_t write_count;
+ char buf[64];
+ TimedText::ResourceList_t::const_iterator ri;
+
+ result = Reader.ReadTimedTextResource(XMLDoc, Context, HMAC);
+
+ if ( ASDCP_SUCCESS(result) )
+ {
+ Kumu::FileWriter Writer;
+ result = Writer.OpenWrite(Options.file_root);
+
+ if ( ASDCP_SUCCESS(result) )
+ result = Writer.Write(reinterpret_cast<const byte_t*>(XMLDoc.c_str()), XMLDoc.size(), &write_count);
+ }
+
+ for ( ri = TDesc.ResourceList.begin() ; ri != TDesc.ResourceList.end() && ASDCP_SUCCESS(result); ri++ )
+ {
+ result = Reader.ReadAncillaryResource(ri->ResourceID, FrameBuffer, Context, HMAC);
+
+ if ( ASDCP_SUCCESS(result) )
+ {
+ Kumu::FileWriter Writer;
+ result = Writer.OpenWrite(Kumu::PathJoin(out_path, Kumu::UUID(ri->ResourceID).EncodeHex(buf, 64)).c_str());
+
+ if ( ASDCP_SUCCESS(result) )
+ {
+ if ( Options.verbose_flag )
+ FrameBuffer.Dump(stderr, Options.fb_dump_size);
+
+ result = Writer.Write(FrameBuffer.RoData(), FrameBuffer.Size(), &write_count);
+ }
+ }
+ }
+
+ return result;
+}
+
//------------------------------------------------------------------------------------------
//
}
};
+class MyStereoPictureDescriptor : public JP2K::PictureDescriptor
+{
+ public:
+ void FillDescriptor(JP2K::MXFSReader& Reader) {
+ Reader.FillPictureDescriptor(*this);
+ }
+
+ void Dump(FILE* stream) {
+ JP2K::PictureDescriptorDump(*this, stream);
+ }
+};
+
class MyAudioDescriptor : public PCM::AudioDescriptor
{
public:
}
};
+class MyTextDescriptor : public TimedText::TimedTextDescriptor
+{
+ public:
+ void FillDescriptor(TimedText::MXFReader& Reader) {
+ Reader.FillTimedTextDescriptor(*this);
+ }
+
+ void Dump(FILE* stream) {
+ TimedText::DescriptorDump(*this, stream);
+ }
+};
// MSVC didn't like the function template, so now it's a static class method
template<class ReaderT, class DescriptorT>
class FileInfoWrapper
{
public:
- static void file_info(CommandOptions& Options, FILE* stream = 0)
+ static Result_t
+ file_info(CommandOptions& Options, const char* type_string, FILE* stream = 0)
{
+ assert(type_string);
if ( stream == 0 )
stream = stdout;
+ Result_t result = RESULT_OK;
+
if ( Options.verbose_flag || Options.showheader_flag )
{
ReaderT Reader;
- Result_t result = Reader.OpenRead(Options.filenames[0]);
+ result = Reader.OpenRead(Options.filenames[0]);
if ( ASDCP_SUCCESS(result) )
{
+ fprintf(stdout, "File essence type is %s.\n", type_string);
+
if ( Options.showheader_flag )
Reader.DumpHeaderMetadata(stream);
Reader.DumpHeaderMetadata(stream);
}
}
+
+ return result;
}
};
if ( EssenceType == ESS_MPEG2_VES )
{
- fputs("File essence type is MPEG2 video.\n", stdout);
- FileInfoWrapper<ASDCP::MPEG2::MXFReader, MyVideoDescriptor>::file_info(Options);
+ result = FileInfoWrapper<ASDCP::MPEG2::MXFReader, MyVideoDescriptor>::file_info(Options, "MPEG2 video");
}
- else if ( EssenceType == ESS_PCM_24b_48k )
+ else if ( EssenceType == ESS_PCM_24b_48k || EssenceType == ESS_PCM_24b_96k )
{
- fputs("File essence type is PCM audio.\n", stdout);
- FileInfoWrapper<ASDCP::PCM::MXFReader, MyAudioDescriptor>::file_info(Options);
+ result = FileInfoWrapper<ASDCP::PCM::MXFReader, MyAudioDescriptor>::file_info(Options, "PCM audio");
+
+ if ( ASDCP_SUCCESS(result) )
+ {
+ const Dictionary* Dict = &DefaultCompositeDict();
+ PCM::MXFReader Reader;
+ MXF::OP1aHeader Header(Dict);
+ MXF::WaveAudioDescriptor *descriptor = 0;
+
+ result = Reader.OpenRead(Options.filenames[0]);
+
+ if ( ASDCP_SUCCESS(result) )
+ result = Reader.OP1aHeader().GetMDObjectByType(Dict->ul(MDD_WaveAudioDescriptor), reinterpret_cast<MXF::InterchangeObject**>(&descriptor));
+
+ if ( ASDCP_SUCCESS(result) )
+ {
+ char buf[64];
+ fprintf(stdout, " ChannelAssignment: %s\n", descriptor->ChannelAssignment.const_get().EncodeString(buf, 64));
+ }
+ }
}
else if ( EssenceType == ESS_JPEG_2000 )
{
- fputs("File essence type is JPEG 2000 pictures.\n", stdout);
- FileInfoWrapper<ASDCP::JP2K::MXFReader, MyPictureDescriptor>::file_info(Options);
+ if ( Options.stereo_image_flag )
+ {
+ result = FileInfoWrapper<ASDCP::JP2K::MXFSReader,
+ MyStereoPictureDescriptor>::file_info(Options, "JPEG 2000 stereoscopic pictures");
+ }
+ else
+ {
+ result = FileInfoWrapper<ASDCP::JP2K::MXFReader,
+ MyPictureDescriptor>::file_info(Options, "JPEG 2000 pictures");
+ }
+ }
+ else if ( EssenceType == ESS_JPEG_2000_S )
+ {
+ result = FileInfoWrapper<ASDCP::JP2K::MXFSReader,
+ MyStereoPictureDescriptor>::file_info(Options, "JPEG 2000 stereoscopic pictures");
+ }
+ else if ( EssenceType == ESS_TIMED_TEXT )
+ {
+ result = FileInfoWrapper<ASDCP::TimedText::MXFReader, MyTextDescriptor>::file_info(Options, "Timed Text");
}
else
{
fprintf(stderr, "File is not AS-DCP: %s\n", Options.filenames[0]);
- FileReader Reader;
- MXF::OPAtomHeader TestHeader;
+ Kumu::FileReader Reader;
+ const Dictionary* Dict = &DefaultCompositeDict();
+ MXF::OP1aHeader TestHeader(Dict);
result = Reader.OpenRead(Options.filenames[0]);
if ( ASDCP_SUCCESS(result) )
{
- TestHeader.Partition::Dump();
+ TestHeader.Partition::Dump(stdout);
if ( MXF::Identification* ID = TestHeader.GetIdentification() )
- ID->Dump();
+ ID->Dump(stdout);
else
fputs("File contains no Identification object.\n", stdout);
if ( MXF::SourcePackage* SP = TestHeader.GetSourcePackage() )
- SP->Dump();
+ SP->Dump(stdout);
else
fputs("File contains no SourcePackage object.\n", stdout);
}
}
+//
+Result_t
+digest_file(const char* filename)
+{
+ using namespace Kumu;
+
+ ASDCP_TEST_NULL_STR(filename);
+ FileReader Reader;
+ SHA_CTX Ctx;
+ SHA1_Init(&Ctx);
+ ByteString Buf(8192);
+
+ Result_t result = Reader.OpenRead(filename);
+
+ while ( ASDCP_SUCCESS(result) )
+ {
+ ui32_t read_count = 0;
+ result = Reader.Read(Buf.Data(), Buf.Capacity(), &read_count);
+
+ if ( result == RESULT_ENDOFFILE )
+ {
+ result = RESULT_OK;
+ break;
+ }
+
+ if ( ASDCP_SUCCESS(result) )
+ SHA1_Update(&Ctx, Buf.Data(), read_count);
+ }
+
+ if ( ASDCP_SUCCESS(result) )
+ {
+ const ui32_t sha_len = 20;
+ byte_t bin_buf[sha_len];
+ char sha_buf[64];
+ SHA1_Final(bin_buf, &Ctx);
+
+ fprintf(stdout, "%s %s\n", base64encode(bin_buf, sha_len, sha_buf, 64), filename);
+ }
+
+ return result;
+}
+
//
int
main(int argc, const char** argv)
{
Result_t result = RESULT_OK;
+ char str_buf[64];
CommandOptions Options(argc, argv);
+ if ( Options.version_flag )
+ banner();
+
if ( Options.help_flag )
- {
- usage();
- return 0;
- }
+ usage();
- if ( Options.error_flag )
- return 3;
+ if ( Options.version_flag || Options.help_flag )
+ return 0;
- if ( Options.version_flag )
- banner();
+ if ( Options.error_flag )
+ {
+ fprintf(stderr, "There was a problem. Type %s -h for help.\n", PROGRAM_NAME);
+ return 3;
+ }
- if ( Options.info_flag )
+ if ( Options.mode == MMT_INFO )
{
result = show_file_info(Options);
+
+ for ( int i = 1; ASDCP_SUCCESS(result) && i < Options.file_count; ++i )
+ {
+ Options.filenames[0] = Options.filenames[i]; // oh-so hackish
+ result = show_file_info(Options);
+ }
}
- else if ( Options.gop_start_flag )
+ else if ( Options.mode == MMT_GOP_START )
{
result = gop_start_test(Options);
}
-#ifndef ASDCP_WITHOUT_OPENSSL
- else if ( Options.genkey_flag )
+ else if ( Options.mode == MMT_GEN_KEY )
{
- FortunaRNG RNG;
+ Kumu::FortunaRNG RNG;
byte_t bin_buf[KeyLen];
- char str_buf[40];
RNG.FillRandom(bin_buf, KeyLen);
- printf("%s\n", bin2hex(bin_buf, KeyLen, str_buf, 40));
+ printf("%s\n", Kumu::bin2hex(bin_buf, KeyLen, str_buf, 64));
}
- else if ( Options.genid_flag )
+ else if ( Options.mode == MMT_GEN_ID )
{
- FortunaRNG RNG;
- byte_t bin_buf[KeyLen];
- char str_buf[40];
-
- GenRandomUUID(RNG, bin_buf);
- bin2hex(bin_buf, KeyLen, str_buf, 40);
- printf("%s\n", hyphenate_UUID(str_buf, 40));
+ UUID TmpID;
+ Kumu::GenRandomValue(TmpID);
+ printf("%s\n", TmpID.EncodeHex(str_buf, 64));
+ }
+ else if ( Options.mode == MMT_DIGEST )
+ {
+ for ( ui32_t i = 0; i < Options.file_count && ASDCP_SUCCESS(result); i++ )
+ result = digest_file(Options.filenames[i]);
}
-#endif // ASDCP_WITHOUT_OPENSSL
- else if ( Options.extract_flag )
+ else if ( Options.mode == MMT_UL_LIST )
+ {
+ if ( Options.use_smpte_labels )
+ DefaultSMPTEDict().Dump(stdout);
+ else
+ DefaultInteropDict().Dump(stdout);
+ }
+ else if ( Options.mode == MMT_EXTRACT )
{
EssenceType_t EssenceType;
result = ASDCP::EssenceType(Options.filenames[0], EssenceType);
-#ifdef SMPTE_LABELS
- fprintf(stderr, "ATTENTION! Expecting SMPTE Universal Labels\n");
-#endif
+
if ( ASDCP_SUCCESS(result) )
{
switch ( EssenceType )
break;
case ESS_JPEG_2000:
- result = read_JP2K_file(Options);
+ if ( Options.stereo_image_flag )
+ result = read_JP2K_S_file(Options);
+ else
+ result = read_JP2K_file(Options);
+ break;
+
+ case ESS_JPEG_2000_S:
+ result = read_JP2K_S_file(Options);
break;
case ESS_PCM_24b_48k:
+ case ESS_PCM_24b_96k:
result = read_PCM_file(Options);
break;
+ case ESS_TIMED_TEXT:
+ result = read_timed_text_file(Options);
+ break;
+
default:
fprintf(stderr, "%s: Unknown file type, not ASDCP essence.\n", Options.filenames[0]);
return 5;
}
}
}
- else if ( Options.create_flag )
+ else if ( Options.mode == MMT_CREATE )
{
- fprintf(stderr, "ATTENTION! This version of asdcplib does not support writing MXF files.\n");
-
-#if 0
if ( Options.do_repeat && ! Options.duration_flag )
{
fputs("Option -R requires -d <duration>\n", stderr);
EssenceType_t EssenceType;
result = ASDCP::RawEssenceType(Options.filenames[0], EssenceType);
-#ifdef SMPTE_LABELS
- fprintf(stderr, "ATTENTION! Writing SMPTE Universal Labels\n");
-#endif
+
if ( ASDCP_SUCCESS(result) )
{
switch ( EssenceType )
break;
case ESS_JPEG_2000:
- result = write_JP2K_file(Options);
+ if ( Options.stereo_image_flag )
+ result = write_JP2K_S_file(Options);
+
+ else
+ result = write_JP2K_file(Options);
+
break;
case ESS_PCM_24b_48k:
+ case ESS_PCM_24b_96k:
result = write_PCM_file(Options);
break;
+ case ESS_TIMED_TEXT:
+ result = write_timed_text_file(Options);
+ break;
+
default:
fprintf(stderr, "%s: Unknown file type, not ASDCP-compatible essence.\n",
Options.filenames[0]);
return 5;
}
}
-#endif
+ }
+ else
+ {
+ fprintf(stderr, "Unhandled mode: %d.\n", Options.mode);
+ return 6;
}
- if ( result != RESULT_OK )
+ if ( ASDCP_FAILURE(result) )
{
fputs("Program stopped on error.\n", stderr);
- if ( result != RESULT_FAIL )
+ if ( result == RESULT_SFORMAT )
+ {
+ fputs("Use option '-3' to force stereoscopic mode.\n", stderr);
+ }
+ else if ( result != RESULT_FAIL )
{
- fputs(GetResultString(result), stderr);
+ fputs(result, stderr);
fputc('\n', stderr);
}
projects / asdcplib.git / blobdiff