int main(int argc, char **argv)
{
const char *guid_str;
const char *attr_str;
const char *varname;
const char *keyfilename;
const char *certfilename;
varsign_context *ctx;
bool include_attrs;
int c = 0;
unsigned char no_signing = 0;
unsigned char no_repack = 0;
ctx = talloc_zero(NULL, varsign_context);
keyfilename = NULL;
certfilename = NULL;
guid_str = NULL;
attr_str= NULL;
include_attrs = false;
for (;;) {
int idx;
c = getopt_long(argc, argv, "o:g:a:k:c:n:ivVh", options, &idx);
if (c == -1) {
break;
}
switch (c) {
case 'o':
ctx->outfilename = optarg;
break;
case 'g':
guid_str = optarg;
break;
case 'a':
attr_str = optarg;
break;
case 'k':
keyfilename = optarg;
break;
case 'c':
certfilename = optarg;
break;
case 'i':
include_attrs = true;
break;
case 'v':
ctx->verbose = 1;
break;
case 'V':
version();
return EXIT_SUCCESS;
case 'n':
no_signing = 1;
break;
case 'N':
no_signing = 1;
break;
case 'r':
no_repack = 1;
do_direct = 1;
break;
case 'R':
no_repack = 1;
do_direct = 1;
break;
case 'h':
usage();
return EXIT_SUCCESS;
}
}
if (argc != (optind + 2)) {
usage();
return EXIT_FAILURE;
}
if ((!keyfilename) && (!no_signing)) {
fprintf(stderr, "No signing key specified\n");
return EXIT_FAILURE;
}
if ((!certfilename) && (!no_signing)) {
fprintf(stderr, "No signing certificate specified\n");
return EXIT_FAILURE;
}
/* initialise openssl */
OpenSSL_add_all_digests();
OpenSSL_add_all_ciphers();
ERR_load_crypto_strings();
/* set up the variable signing context */
varname = argv[optind];
set_varname(ctx, varname);
ctx->infilename = argv[optind+1];
if (!ctx->outfilename) {
set_default_outfilename(ctx);
}
if (attr_str) {
ctx->var_attrs = parse_attrs(attr_str);
if (ctx->var_attrs == attr_invalid) {
return EXIT_FAILURE;
}
} else {
ctx->var_attrs = default_attrs;
}
if (guid_str) {
if (parse_guid(guid_str, &ctx->var_guid)) {
fprintf(stderr, "Invalid GUID '%s'\n", guid_str);
return EXIT_FAILURE;
}
} else {
set_default_guid(ctx, varname);
}
if (fileio_read_file(ctx, ctx->infilename, &ctx->data, &ctx->data_len)) {
return EXIT_FAILURE;
}
if (!no_signing)
{
ctx->key = fileio_read_pkey(keyfilename);
if (!ctx->key) {
return EXIT_FAILURE;
}
ctx->cert = fileio_read_cert(certfilename);
if (!ctx->cert) {
return EXIT_FAILURE;
}
}
/* do the signing */
if (add_auth_descriptor(ctx, no_signing)) {
return EXIT_FAILURE;
}
/* write the resulting image */
if (write_signed(ctx, include_attrs, no_repack)) {
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
static int
encode_audio(BitstreamWriter* bs,
pcmreader* pcmreader,
int signed_samples,
unsigned block_size)
{
unsigned left_shift = 0;
int sign_adjustment;
/*allocate some temporary buffers*/
array_ia* frame = array_ia_new();
array_ia* wrapped_samples = array_ia_new();
array_i* shifted = array_i_new();
array_ia* deltas = array_ia_new();
array_i* residuals = array_i_new();
unsigned c;
unsigned i;
for (i = 0; i < pcmreader->channels; i++)
wrapped_samples->append(wrapped_samples);
if (!signed_samples) {
sign_adjustment = 1 << (pcmreader->bits_per_sample - 1);
} else {
sign_adjustment = 0;
}
if (pcmreader->read(pcmreader, block_size, frame))
goto error;
while (frame->_[0]->len > 0) {
#ifndef STANDALONE
Py_BEGIN_ALLOW_THREADS
#endif
if (frame->_[0]->len != block_size) {
/*PCM frame count has changed, so issue BLOCKSIZE command*/
block_size = frame->_[0]->len;
write_unsigned(bs, COMMAND_SIZE, FN_BLOCKSIZE);
write_long(bs, block_size);
}
for (c = 0; c < frame->len; c++) {
array_i* channel = frame->_[c];
array_i* wrapped = wrapped_samples->_[c];
/*convert signed samples to unsigned, if necessary*/
if (sign_adjustment != 0)
for (i = 0; i < channel->len; i++)
channel->_[i] += sign_adjustment;
if (all_zero(channel)) {
/*write ZERO command and wrap channel for next set*/
write_unsigned(bs, COMMAND_SIZE, FN_ZERO);
wrapped->extend(wrapped, channel);
wrapped->tail(wrapped, SAMPLES_TO_WRAP, wrapped);
} else {
unsigned diff = 1;
unsigned energy = 0;
unsigned wasted_BPS = wasted_bits(channel);
if (wasted_BPS != left_shift) {
/*issue BITSHIFT comand*/
left_shift = wasted_BPS;
write_unsigned(bs, COMMAND_SIZE, FN_BITSHIFT);
write_unsigned(bs, BITSHIFT_SIZE, left_shift);
}
/*apply left shift to channel data*/
if (left_shift > 0) {
shifted->reset_for(shifted, channel->len);
for (i = 0; i < channel->len; i++)
a_append(shifted, channel->_[i] >> left_shift);
} else {
channel->copy(channel, shifted);
}
/*calculate best DIFF, energy and residuals for shifted data*/
calculate_best_diff(shifted, wrapped, deltas,
&diff, &energy, residuals);
/*issue DIFF command*/
write_unsigned(bs, COMMAND_SIZE, diff);
write_unsigned(bs, ENERGY_SIZE, energy);
for (i = 0; i < residuals->len; i++)
write_signed(bs, energy, residuals->_[i]);
/*wrap shifted channel data for next set*/
wrapped->extend(wrapped, shifted);
wrapped->tail(wrapped, SAMPLES_TO_WRAP, wrapped);
}
}
