/*
-Copyright (c) 2003-2007, John Hurst
+Copyright (c) 2003-2009, John Hurst
All rights reserved.
Redistribution and use in source and binary forms, with or without
these features.
*/
-#include <iostream>
-#include <assert.h>
-
#include <KM_fileio.h>
#include <KM_prng.h>
#include <PCMParserList.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, "%u.%u.%u", VERSION_MAJOR, VERSION_APIMINOR, VERSION_IMPMINOR);
- ProductVersion = s_buf;
+ ProductVersion = ASDCP::Version();
}
} s_MyInfo;
{
fprintf(stream, "\n\
%s (asdcplib %s)\n\n\
-Copyright (c) 2003-2006 John Hurst\n\n\
+Copyright (c) 2003-2009 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);
}
//
usage(FILE* stream = stdout)
{
fprintf(stream, "\
-USAGE: %s -c <output-file> [-3] [-b <buffer-size>] [-d <duration>] [-e|-E]\n\
- [-f <start-frame>] [-j <key-id-string>] [-k <key-string>] [-L] [-M]\n\
- [-p <frame-rate>] [-R] [-s <num>] [-v] [-W]\n\
- <input-file> [<input-file-2> ...]\n\
+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] <input-file> [<input-file-2> ...]\n\
\n\
%s [-h|-help] [-V]\n\
\n\
\n\
%s -t <input-file>\n\
\n\
- %s -x <file-prefix> [-b <buffer-size>] [-d <duration>]\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] <input-file>\n\
-\n", PACKAGE, PACKAGE, PACKAGE, PACKAGE, PACKAGE, PACKAGE, PACKAGE);
+ [-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\
- -3 - Create a stereoscopic image file. Expects two dir-\n\
- ectories of JP2K codestreams (directories must have\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\
fprintf(stream, "\
Read/Write Options:\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'. Default\n\
+ 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|48], 24 is default\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\
\n");
fprintf(stream, "\
MMT_GEN_ID,
MMT_GEN_KEY,
MMT_GOP_START,
- MMT_DIGEST
+ 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;
+
+ fprintf(stderr, "Error decoding channel format string: %s\n", label_name.c_str());
+ fprintf(stderr, "Expecting '5.1', '6.1', or '7.1'\n");
+ return PCM::CF_NONE;
+}
//
//
bool error_flag; // true if the given options are in error or not complete
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 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
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[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()
//
CommandOptions(int argc, const char** argv) :
- mode(MMT_NONE), error_flag(true), key_flag(false), key_id_flag(false), encrypt_header_flag(true),
- write_hmac(true), read_hmac(false), split_wav(false), mono_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), stereo_image_flag(false), start_frame(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),
- picture_rate(24), fb_size(FRAME_BUFFER_SIZE), file_count(0), file_root(0), out_file(0)
+ 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, UUIDlen);
case '1': mono_wav = true; break;
case '2': split_wav = true; break;
case '3': stereo_image_flag = true; break;
- case 'i': mode = MMT_INFO; break;
- case 'G': mode = MMT_GOP_START; 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': mode = MMT_GEN_KEY; break;
- case 'u': mode = MMT_GEN_ID; 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 'L': use_smpte_labels = true; break;
+
+ 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 'b':
+ TEST_EXTRA_ARG(i, 'b');
+ fb_size = abs(atoi(argv[i]));
+
+ if ( verbose_flag )
+ fprintf(stderr, "Frame Buffer size: %u bytes.\n", fb_size);
+
+ break;
case 'c':
TEST_EXTRA_ARG(i, 'c');
out_file = argv[i];
break;
- case 'x':
- TEST_EXTRA_ARG(i, 'x');
- mode = MMT_EXTRACT;
- file_root = argv[i];
+ case 'd':
+ TEST_EXTRA_ARG(i, 'd');
+ duration_flag = true;
+ duration = abs(atoi(argv[i]));
break;
- case 'k': key_flag = true;
- TEST_EXTRA_ARG(i, 'k');
- {
- ui32_t length;
- Kumu::hex2bin(argv[i], key_value, KeyLen, &length);
+ case 'E': encrypt_header_flag = false; break;
+ case 'e': encrypt_header_flag = true; break;
- if ( length != KeyLen )
- {
- fprintf(stderr, "Unexpected key length: %u, expecting %u characters.\n", length, KeyLen);
- return;
- }
- }
+ case 'f':
+ TEST_EXTRA_ARG(i, 'f');
+ start_frame = abs(atoi(argv[i]));
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');
{
}
break;
- case 'f':
- TEST_EXTRA_ARG(i, 'f');
- start_frame = abs(atoi(argv[i]));
+ case 'k': key_flag = true;
+ TEST_EXTRA_ARG(i, 'k');
+ {
+ ui32_t length;
+ Kumu::hex2bin(argv[i], key_value, KeyLen, &length);
+
+ if ( length != KeyLen )
+ {
+ fprintf(stderr, "Unexpected key length: %u, expecting %u characters.\n", length, KeyLen);
+ return;
+ }
+ }
break;
- case 'd':
- TEST_EXTRA_ARG(i, 'd');
- duration_flag = true;
- duration = abs(atoi(argv[i]));
+ case 'l':
+ TEST_EXTRA_ARG(i, 'l');
+ channel_fmt = decode_channel_fmt(argv[i]);
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 = abs(atoi(argv[i]));
break;
+ case 'R': do_repeat = true; break;
+ case 'S': split_wav = true; break;
+
case 's':
TEST_EXTRA_ARG(i, 's');
fb_dump_size = abs(atoi(argv[i]));
break;
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;
- case 'b':
- TEST_EXTRA_ARG(i, 'b');
- fb_size = abs(atoi(argv[i]));
-
- if ( verbose_flag )
- fprintf(stderr, "Frame Buffer size: %u bytes.\n", fb_size);
+ case 'w':
+ TEST_EXTRA_ARG(i, 'w');
+ number_width = abs(atoi(argv[i]));
+ break;
+ case 'x':
+ TEST_EXTRA_ARG(i, 'x');
+ mode = MMT_EXTRACT;
+ file_root = argv[i];
break;
default:
if ( ASDCP_SUCCESS(result) && ! Options.no_write_flag )
{
WriterInfo Info = s_MyInfo; // fill in your favorite identifiers here
- Kumu::GenRandomUUID(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 )
{
if ( ASDCP_SUCCESS(result) && ! Options.no_write_flag )
{
WriterInfo Info = s_MyInfo; // fill in your favorite identifiers here
- Kumu::GenRandomUUID(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 )
{
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, JP2K::SP_LEFT, FrameBuffer, Context, HMAC);
{
Kumu::FileWriter OutFile;
ui32_t write_count;
- snprintf(filename, filename_max, "%s%06uL.j2c", Options.file_root, i);
+ snprintf(filename, filename_max, left_format, Options.file_root, i);
result = OutFile.OpenWrite(filename);
if ( ASDCP_SUCCESS(result) )
{
Kumu::FileWriter OutFile;
ui32_t write_count;
- snprintf(filename, filename_max, "%s%06uR.j2c", Options.file_root, i);
+ snprintf(filename, filename_max, right_format, Options.file_root, i);
result = OutFile.OpenWrite(filename);
if ( ASDCP_SUCCESS(result) )
if ( ASDCP_SUCCESS(result) && ! Options.no_write_flag )
{
WriterInfo Info = s_MyInfo; // fill in your favorite identifiers here
- Kumu::GenRandomUUID(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 )
{
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);
Kumu::FileWriter OutFile;
char filename[256];
ui32_t write_count;
- snprintf(filename, 256, "%s%06u.j2c", Options.file_root, i);
+ snprintf(filename, 256, name_format, Options.file_root, i);
result = OutFile.OpenWrite(filename);
if ( ASDCP_SUCCESS(result) )
ADesc.SampleRate = 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, "48Khz PCM Audio, %s fps (%u spf)\n",
+ fprintf(stderr, "%.1fkHz PCM Audio, %s fps (%u spf)\n",
+ ADesc.AudioSamplingRate.Quotient() / 1000.0,
Options.szPictureRate(),
PCM::CalcSamplesPerFrame(ADesc));
fputs("AudioDescriptor:\n", stderr);
if ( ASDCP_SUCCESS(result) && ! Options.no_write_flag )
{
WriterInfo Info = s_MyInfo; // fill in your favorite identifiers here
- Kumu::GenRandomUUID(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 )
{
// set up MXF writer
if ( ASDCP_SUCCESS(result) )
{
- Parser.FillDescriptor(TDesc);
+ Parser.FillTimedTextDescriptor(TDesc);
FrameBuffer.Capacity(2*Kumu::Megabyte);
if ( Options.verbose_flag )
if ( ASDCP_SUCCESS(result) && ! Options.no_write_flag )
{
WriterInfo Info = s_MyInfo; // fill in your favorite identifiers here
- Kumu::GenRandomUUID(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 )
{
if ( ASDCP_SUCCESS(result) )
{
- Reader.FillDescriptor(TDesc);
+ Reader.FillTimedTextDescriptor(TDesc);
FrameBuffer.Capacity(2*Kumu::Megabyte);
if ( Options.verbose_flag )
{
public:
void FillDescriptor(TimedText::MXFReader& Reader) {
- Reader.FillDescriptor(*this);
+ Reader.FillTimedTextDescriptor(*this);
}
void Dump(FILE* stream) {
if ( EssenceType == ESS_MPEG2_VES )
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 )
result = FileInfoWrapper<ASDCP::PCM::MXFReader, MyAudioDescriptor>::file_info(Options, "PCM audio");
else if ( EssenceType == ESS_JPEG_2000 )
{
fprintf(stderr, "File is not AS-DCP: %s\n", Options.filenames[0]);
Kumu::FileReader Reader;
- MXF::OPAtomHeader TestHeader;
+ const Dictionary* Dict = &DefaultCompositeDict();
+ MXF::OPAtomHeader 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);
}
main(int argc, const char** argv)
{
Result_t result = RESULT_OK;
+ char str_buf[64];
CommandOptions Options(argc, argv);
if ( Options.version_flag )
if ( Options.error_flag )
{
- fprintf(stderr, "There was a problem. Type %s -h for help.\n", PACKAGE);
+ fprintf(stderr, "There was a problem. Type %s -h for help.\n", PROGRAM_NAME);
return 3;
}
{
Kumu::FortunaRNG RNG;
byte_t bin_buf[KeyLen];
- char str_buf[40];
RNG.FillRandom(bin_buf, KeyLen);
- printf("%s\n", Kumu::bin2hex(bin_buf, KeyLen, str_buf, 40));
+ printf("%s\n", Kumu::bin2hex(bin_buf, KeyLen, str_buf, 64));
}
else if ( Options.mode == MMT_GEN_ID )
{
UUID TmpID;
Kumu::GenRandomValue(TmpID);
- char str_buf[40];
- printf("%s\n", TmpID.EncodeHex(str_buf, 40));
+ 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]);
}
+ 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;
break;
case ESS_PCM_24b_48k:
+ case ESS_PCM_24b_96k:
result = read_PCM_file(Options);
break;
break;
case ESS_PCM_24b_48k:
+ case ESS_PCM_24b_96k:
result = write_PCM_file(Options);
break;
}
}
}
+ else
+ {
+ fprintf(stderr, "Unhandled mode: %d.\n", Options.mode);
+ return 6;
+ }
if ( ASDCP_FAILURE(result) )
{
projects / asdcplib.git / blobdiff