int
id3tag_set_fieldvalue(lame_global_flags * gfp, const char *fieldvalue)
{
lame_internal_flags *gfc = gfp->internal_flags;
if (fieldvalue && *fieldvalue) {
uint32_t const frame_id = toID3v2TagId(fieldvalue);
char **p = NULL;
if (strlen(fieldvalue) < 5 || fieldvalue[4] != '=') {
return -1;
}
if (frame_id != 0) {
if (id3tag_set_textinfo_latin1(gfp, fieldvalue, &fieldvalue[5])) {
p = (char **) realloc(gfc->tag_spec.values,
sizeof(char *) * (gfc->tag_spec.num_values + 1));
if (!p) {
return -1;
}
gfc->tag_spec.values = (char **) p;
local_strdup(&gfc->tag_spec.values[gfc->tag_spec.num_values++], fieldvalue);
}
}
gfc->tag_spec.flags |= CHANGED_FLAG;
}
id3tag_add_v2(gfp);
return 0;
}
FLAC__bool parse_block_type(const char *in, Argument_BlockType *out)
{
char *p, *q, *r, *s;
unsigned entry;
if(*in == '\0')
return false;
s = local_strdup(in);
/* first count the entries */
for(out->num_entries = 1, p = strchr(s, ','); p; out->num_entries++, p = strchr(++p, ','))
;
/* make space */
FLAC__ASSERT(out->num_entries > 0);
if(0 == (out->entries = safe_malloc_mul_2op_(sizeof(Argument_BlockTypeEntry), /*times*/out->num_entries)))
die("out of memory allocating space for option list");
/* load 'em up */
entry = 0;
q = s;
while(q) {
FLAC__ASSERT(entry < out->num_entries);
if(0 != (p = strchr(q, ',')))
*p++ = 0;
r = strchr(q, ':');
if(r)
*r++ = '\0';
if(0 != r && 0 != strcmp(q, "APPLICATION")) {
free(s);
return false;
}
if(0 == strcmp(q, "STREAMINFO")) {
out->entries[entry++].type = FLAC__METADATA_TYPE_STREAMINFO;
}
else if(0 == strcmp(q, "PADDING")) {
out->entries[entry++].type = FLAC__METADATA_TYPE_PADDING;
}
else if(0 == strcmp(q, "APPLICATION")) {
out->entries[entry].type = FLAC__METADATA_TYPE_APPLICATION;
out->entries[entry].filter_application_by_id = (0 != r);
if(0 != r) {
if(strlen(r) == sizeof (out->entries[entry].application_id)) {
memcpy(out->entries[entry].application_id, r, sizeof (out->entries[entry].application_id));
}
else if(strlen(r) == 10 && strncmp(r, "0x", 2) == 0 && strspn(r+2, "0123456789ABCDEFabcdef") == 8) {
FLAC__uint32 x = strtoul(r+2, 0, 16);
out->entries[entry].application_id[3] = (FLAC__byte)(x & 0xff);
out->entries[entry].application_id[2] = (FLAC__byte)((x>>=8) & 0xff);
out->entries[entry].application_id[1] = (FLAC__byte)((x>>=8) & 0xff);
out->entries[entry].application_id[0] = (FLAC__byte)((x>>=8) & 0xff);
}
else {
free(s);
return false;
}
}
error *errorf(const char *format, ...)
{
va_list ap;
va_start(ap, format);
QString str = QString().vsprintf(format, ap);
va_end(ap);
QByteArray ba = str.toUtf8();
return local_strdup(ba.constData());
}
void panicf(const char *format, ...)
{
va_list ap;
va_start(ap, format);
QString str = QString().vsprintf(format, ap);
va_end(ap);
QByteArray ba = str.toUtf8();
hookPanic(local_strdup(ba.constData()));
}
void
id3tag_set_album(lame_global_flags * gfp, const char *album)
{
lame_internal_flags *gfc = gfp->internal_flags;
if (album && *album) {
local_strdup(&gfc->tag_spec.album, album);
gfc->tag_spec.flags |= CHANGED_FLAG;
copyV1ToV2(gfc, ID_ALBUM, album);
}
}
void
id3tag_set_artist(lame_global_flags * gfp, const char *artist)
{
lame_internal_flags *gfc = gfp->internal_flags;
if (artist && *artist) {
local_strdup(&gfc->tag_spec.artist, artist);
gfc->tag_spec.flags |= CHANGED_FLAG;
copyV1ToV2(gfc, ID_ARTIST, artist);
}
}
void
id3tag_set_title(lame_global_flags * gfp, const char *title)
{
lame_internal_flags *gfc = gfp->internal_flags;
if (title && *title) {
local_strdup(&gfc->tag_spec.title, title);
gfc->tag_spec.flags |= CHANGED_FLAG;
copyV1ToV2(gfc, ID_TITLE, title);
}
}
SWError SWSetPropertyString(SWPropertiesPtr properties, char *name, char *value)
{
struct SWProperty *p, *prev;
//fprintf(stderr, "SET %s=\"%s\"\n", name, value);
if (properties != NULL && name != NULL)
{
prev = NULL;
for (p = properties->head; p != NULL; p = p->next)
{
prev = p;
if (strcmp(name, p->key) == 0)
{
if (p->value != NULL)
free(p->value);
p->value = local_strdup(value);
return kNoError;
}
}
p = (struct SWProperty *) calloc(1, sizeof(struct SWProperty));
if (p == NULL)
return kMemoryAllocationError;
p->key = local_strdup(name);
p->value = local_strdup(value);
if (prev)
prev->next = p;
else
properties->head = p;
properties->numProperties++;
return kNoError;
}
else
return kUnknownError;
}
void
id3tag_set_comment(lame_global_flags * gfp, const char *comment)
{
lame_internal_flags *gfc = gfp->internal_flags;
if (comment && *comment) {
local_strdup(&gfc->tag_spec.comment, comment);
gfc->tag_spec.flags |= CHANGED_FLAG;
{
uint32_t const flags = gfc->tag_spec.flags;
id3v2_add_latin1(gfc, ID_COMMENT, "XXX", "", comment);
gfc->tag_spec.flags = flags;
}
}
}
FLAC__bool parse_vorbis_comment_field(const char *field_ref, char **field, char **name, char **value, unsigned *length, const char **violation)
{
static const char * const violations[] = {
"field name contains invalid character",
"field contains no '=' character"
};
char *p, *q, *s;
if(0 != field)
*field = local_strdup(field_ref);
s = local_strdup(field_ref);
if(0 == (p = strchr(s, '='))) {
free(s);
*violation = violations[1];
return false;
}
*p++ = '\0';
for(q = s; *q; q++) {
if(*q < 0x20 || *q > 0x7d || *q == 0x3d) {
free(s);
*violation = violations[0];
return false;
}
}
*name = local_strdup(s);
*value = local_strdup(p);
*length = strlen(p);
free(s);
return true;
}
FLAC__bool parse_add_seekpoint(const char *in, char **out, const char **violation)
{
static const char *garbled_ = "garbled specification";
const unsigned n = strlen(in);
FLAC__ASSERT(0 != in);
FLAC__ASSERT(0 != out);
if(n == 0) {
*violation = "specification is empty";
return false;
}
if(n > strspn(in, "0123456789.Xsx")) {
*violation = "specification contains invalid character";
return false;
}
if(in[n-1] == 'X') {
if(n > 1) {
*violation = garbled_;
return false;
}
}
else if(in[n-1] == 's') {
if(n-1 > strspn(in, "0123456789.")) {
*violation = garbled_;
return false;
}
}
else if(in[n-1] == 'x') {
if(n-1 > strspn(in, "0123456789")) {
*violation = garbled_;
return false;
}
}
else {
if(n > strspn(in, "0123456789")) {
*violation = garbled_;
return false;
}
}
*out = local_strdup(in);
return true;
}
static int
id3tag_set_userinfo_latin1(lame_internal_flags* gfc, char const *fieldvalue)
{
int rc;
char* dsc = 0, *val;
local_strdup(&dsc, fieldvalue);
val = dsc;
while (*val) {
if (*val == '=') {
*val++ = 0;
break;
}
++val;
}
rc = id3v2_add_latin1(gfc, ID_TXXX, "XXX", dsc, val);
free(dsc);
return rc;
}
FLAC__bool parse_block_number(const char *in, Argument_BlockNumber *out)
{
char *p, *q, *s, *end;
long i;
unsigned entry;
if(*in == '\0')
return false;
s = local_strdup(in);
/* first count the entries */
for(out->num_entries = 1, p = strchr(s, ','); p; out->num_entries++, p = strchr(++p, ','))
;
/* make space */
FLAC__ASSERT(out->num_entries > 0);
if(0 == (out->entries = safe_malloc_mul_2op_(sizeof(unsigned), /*times*/out->num_entries)))
die("out of memory allocating space for option list");
/* load 'em up */
entry = 0;
q = s;
while(q) {
FLAC__ASSERT(entry < out->num_entries);
if(0 != (p = strchr(q, ',')))
*p++ = '\0';
if(!isdigit((int)(*q)) || (i = strtol(q, &end, 10)) < 0 || *end) {
free(s);
return false;
}
out->entries[entry++] = (unsigned)i;
q = p;
}
FLAC__ASSERT(entry == out->num_entries);
free(s);
return true;
}
FLAC__bool parse_vorbis_comment_field_name(const char *field_ref, char **name, const char **violation)
{
static const char * const violations[] = {
"field name contains invalid character"
};
char *q, *s;
s = local_strdup(field_ref);
for(q = s; *q; q++) {
if(*q < 0x20 || *q > 0x7d || *q == 0x3d) {
free(s);
*violation = violations[0];
return false;
}
}
*name = s;
return true;
}
void packDataValue(QVariant_ *var, DataValue *value)
{
QVariant *qvar = reinterpret_cast<QVariant *>(var);
// Some assumptions are made below regarding the size of types.
// There's apparently no better way to handle this since that's
// how the types with well defined sizes (qint64) are mapped to
// meta-types (QMetaType::LongLong).
switch ((int)qvar->type()) {
case QVariant::Invalid:
value->dataType = DTInvalid;
break;
case QMetaType::QUrl:
*qvar = qvar->value<QUrl>().toString();
// fallthrough
case QMetaType::QString:
{
value->dataType = DTString;
QByteArray ba = qvar->toByteArray();
*(char**)(value->data) = local_strdup(ba.constData());
value->len = ba.size();
break;
}
case QMetaType::Bool:
value->dataType = DTBool;
*(qint8*)(value->data) = (qint8)qvar->toInt();
break;
case QMetaType::LongLong:
value->dataType = DTInt64;
*(qint64*)(value->data) = qvar->toLongLong();
break;
case QMetaType::Int:
value->dataType = DTInt32;
*(qint32*)(value->data) = qvar->toInt();
break;
case QMetaType::Double:
value->dataType = DTFloat64;
*(double*)(value->data) = qvar->toDouble();
break;
case QMetaType::Float:
value->dataType = DTFloat32;
*(float*)(value->data) = qvar->toFloat();
break;
case QMetaType::QColor:
value->dataType = DTColor;
*(unsigned int*)(value->data) = qvar->value<QColor>().rgba();
break;
case QMetaType::QVariantList:
{
QVariantList varlist = qvar->toList();
int len = varlist.size();
DataValue *dvlist = (DataValue *) malloc(sizeof(DataValue) * len);
for (int i = 0; i < len; i++) {
packDataValue((void*)&varlist.at(i), &dvlist[i]);
}
value->dataType = DTList;
value->len = len;
*(DataValue**)(value->data) = dvlist;
}
break;
default:
if (qvar->type() == (int)QMetaType::QObjectStar || qvar->canConvert<QObject *>()) {
QObject *qobject = qvar->value<QObject *>();
GoValue *govalue = dynamic_cast<GoValue *>(qobject);
if (govalue) {
value->dataType = DTGoAddr;
*(void **)(value->data) = govalue->addr;
} else {
value->dataType = DTObject;
*(void **)(value->data) = qobject;
}
break;
}
if (qstrncmp(qvar->typeName(), "QQmlListProperty<", 17) == 0) {
QQmlListProperty<QObject> *list = reinterpret_cast<QQmlListProperty<QObject>*>(qvar->data());
if (list->count && list->at) {
int len = list->count(list);
DataValue *dvlist = (DataValue *) malloc(sizeof(DataValue) * len);
QVariant elem;
for (int i = 0; i < len; i++) {
elem.setValue(list->at(list, i));
packDataValue(&elem, &dvlist[i]);
}
value->dataType = DTList;
value->len = len;
*(DataValue**)(value->data) = dvlist;
break;
}
}
panicf("unsupported variant type: %d (%s)", qvar->type(), qvar->typeName());
break;
}
}
FLAC__bool parse_option(int option_index, const char *option_argument, CommandLineOptions *options)
{
const char *opt = long_options_[option_index].name;
Operation *op;
Argument *arg;
FLAC__bool ok = true;
if(0 == strcmp(opt, "preserve-modtime")) {
options->preserve_modtime = true;
}
else if(0 == strcmp(opt, "with-filename")) {
options->prefix_with_filename = true;
}
else if(0 == strcmp(opt, "no-filename")) {
options->prefix_with_filename = false;
}
else if(0 == strcmp(opt, "no-utf8-convert")) {
options->utf8_convert = false;
}
else if(0 == strcmp(opt, "dont-use-padding")) {
options->use_padding = false;
}
else if(0 == strcmp(opt, "no-cued-seekpoints")) {
options->cued_seekpoints = false;
}
else if(0 == strcmp(opt, "show-md5sum")) {
(void) append_shorthand_operation(options, OP__SHOW_MD5SUM);
}
else if(0 == strcmp(opt, "show-min-blocksize")) {
(void) append_shorthand_operation(options, OP__SHOW_MIN_BLOCKSIZE);
}
else if(0 == strcmp(opt, "show-max-blocksize")) {
(void) append_shorthand_operation(options, OP__SHOW_MAX_BLOCKSIZE);
}
else if(0 == strcmp(opt, "show-min-framesize")) {
(void) append_shorthand_operation(options, OP__SHOW_MIN_FRAMESIZE);
}
else if(0 == strcmp(opt, "show-max-framesize")) {
(void) append_shorthand_operation(options, OP__SHOW_MAX_FRAMESIZE);
}
else if(0 == strcmp(opt, "show-sample-rate")) {
(void) append_shorthand_operation(options, OP__SHOW_SAMPLE_RATE);
}
else if(0 == strcmp(opt, "show-channels")) {
(void) append_shorthand_operation(options, OP__SHOW_CHANNELS);
}
else if(0 == strcmp(opt, "show-bps")) {
(void) append_shorthand_operation(options, OP__SHOW_BPS);
}
else if(0 == strcmp(opt, "show-total-samples")) {
(void) append_shorthand_operation(options, OP__SHOW_TOTAL_SAMPLES);
}
else if(0 == strcmp(opt, "set-md5sum")) {
op = append_shorthand_operation(options, OP__SET_MD5SUM);
FLAC__ASSERT(0 != option_argument);
if(!parse_md5(option_argument, op->argument.streaminfo_md5.value)) {
flac_fprintf(stderr, "ERROR (--%s): bad MD5 sum\n", opt);
ok = false;
}
else
undocumented_warning(opt);
}
else if(0 == strcmp(opt, "set-min-blocksize")) {
op = append_shorthand_operation(options, OP__SET_MIN_BLOCKSIZE);
if(!parse_uint32(option_argument, &(op->argument.streaminfo_uint32.value)) || op->argument.streaminfo_uint32.value < FLAC__MIN_BLOCK_SIZE || op->argument.streaminfo_uint32.value > FLAC__MAX_BLOCK_SIZE) {
flac_fprintf(stderr, "ERROR (--%s): value must be >= %u and <= %u\n", opt, FLAC__MIN_BLOCK_SIZE, FLAC__MAX_BLOCK_SIZE);
ok = false;
}
else
undocumented_warning(opt);
}
else if(0 == strcmp(opt, "set-max-blocksize")) {
op = append_shorthand_operation(options, OP__SET_MAX_BLOCKSIZE);
if(!parse_uint32(option_argument, &(op->argument.streaminfo_uint32.value)) || op->argument.streaminfo_uint32.value < FLAC__MIN_BLOCK_SIZE || op->argument.streaminfo_uint32.value > FLAC__MAX_BLOCK_SIZE) {
flac_fprintf(stderr, "ERROR (--%s): value must be >= %u and <= %u\n", opt, FLAC__MIN_BLOCK_SIZE, FLAC__MAX_BLOCK_SIZE);
ok = false;
}
else
undocumented_warning(opt);
}
else if(0 == strcmp(opt, "set-min-framesize")) {
op = append_shorthand_operation(options, OP__SET_MIN_FRAMESIZE);
if(!parse_uint32(option_argument, &(op->argument.streaminfo_uint32.value)) || op->argument.streaminfo_uint32.value >= (1u<<FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN)) {
flac_fprintf(stderr, "ERROR (--%s): value must be a %u-bit unsigned integer\n", opt, FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN);
ok = false;
}
else
undocumented_warning(opt);
}
else if(0 == strcmp(opt, "set-max-framesize")) {
op = append_shorthand_operation(options, OP__SET_MAX_FRAMESIZE);
if(!parse_uint32(option_argument, &(op->argument.streaminfo_uint32.value)) || op->argument.streaminfo_uint32.value >= (1u<<FLAC__STREAM_METADATA_STREAMINFO_MAX_FRAME_SIZE_LEN)) {
flac_fprintf(stderr, "ERROR (--%s): value must be a %u-bit unsigned integer\n", opt, FLAC__STREAM_METADATA_STREAMINFO_MAX_FRAME_SIZE_LEN);
ok = false;
}
else
undocumented_warning(opt);
}
else if(0 == strcmp(opt, "set-sample-rate")) {
op = append_shorthand_operation(options, OP__SET_SAMPLE_RATE);
if(!parse_uint32(option_argument, &(op->argument.streaminfo_uint32.value)) || !FLAC__format_sample_rate_is_valid(op->argument.streaminfo_uint32.value)) {
flac_fprintf(stderr, "ERROR (--%s): invalid sample rate\n", opt);
ok = false;
}
else
undocumented_warning(opt);
}
else if(0 == strcmp(opt, "set-channels")) {
op = append_shorthand_operation(options, OP__SET_CHANNELS);
if(!parse_uint32(option_argument, &(op->argument.streaminfo_uint32.value)) || op->argument.streaminfo_uint32.value > FLAC__MAX_CHANNELS) {
flac_fprintf(stderr, "ERROR (--%s): value must be > 0 and <= %u\n", opt, FLAC__MAX_CHANNELS);
ok = false;
}
else
undocumented_warning(opt);
}
else if(0 == strcmp(opt, "set-bps")) {
op = append_shorthand_operation(options, OP__SET_BPS);
if(!parse_uint32(option_argument, &(op->argument.streaminfo_uint32.value)) || op->argument.streaminfo_uint32.value < FLAC__MIN_BITS_PER_SAMPLE || op->argument.streaminfo_uint32.value > FLAC__MAX_BITS_PER_SAMPLE) {
flac_fprintf(stderr, "ERROR (--%s): value must be >= %u and <= %u\n", opt, FLAC__MIN_BITS_PER_SAMPLE, FLAC__MAX_BITS_PER_SAMPLE);
ok = false;
}
else
undocumented_warning(opt);
}
else if(0 == strcmp(opt, "set-total-samples")) {
op = append_shorthand_operation(options, OP__SET_TOTAL_SAMPLES);
if(!parse_uint64(option_argument, &(op->argument.streaminfo_uint64.value)) || op->argument.streaminfo_uint64.value >= (((FLAC__uint64)1)<<FLAC__STREAM_METADATA_STREAMINFO_TOTAL_SAMPLES_LEN)) {
flac_fprintf(stderr, "ERROR (--%s): value must be a %u-bit unsigned integer\n", opt, FLAC__STREAM_METADATA_STREAMINFO_TOTAL_SAMPLES_LEN);
ok = false;
}
else
undocumented_warning(opt);
}
else if(0 == strcmp(opt, "show-vendor-tag")) {
(void) append_shorthand_operation(options, OP__SHOW_VC_VENDOR);
}
else if(0 == strcmp(opt, "show-tag")) {
const char *violation;
op = append_shorthand_operation(options, OP__SHOW_VC_FIELD);
FLAC__ASSERT(0 != option_argument);
if(!parse_vorbis_comment_field_name(option_argument, &(op->argument.vc_field_name.value), &violation)) {
FLAC__ASSERT(0 != violation);
flac_fprintf(stderr, "ERROR (--%s): malformed vorbis comment field name \"%s\",\n %s\n", opt, option_argument, violation);
ok = false;
}
}
else if(0 == strcmp(opt, "remove-all-tags")) {
(void) append_shorthand_operation(options, OP__REMOVE_VC_ALL);
}
else if(0 == strcmp(opt, "remove-tag")) {
const char *violation;
op = append_shorthand_operation(options, OP__REMOVE_VC_FIELD);
FLAC__ASSERT(0 != option_argument);
if(!parse_vorbis_comment_field_name(option_argument, &(op->argument.vc_field_name.value), &violation)) {
FLAC__ASSERT(0 != violation);
flac_fprintf(stderr, "ERROR (--%s): malformed vorbis comment field name \"%s\",\n %s\n", opt, option_argument, violation);
ok = false;
}
}
else if(0 == strcmp(opt, "remove-first-tag")) {
const char *violation;
op = append_shorthand_operation(options, OP__REMOVE_VC_FIRSTFIELD);
FLAC__ASSERT(0 != option_argument);
if(!parse_vorbis_comment_field_name(option_argument, &(op->argument.vc_field_name.value), &violation)) {
FLAC__ASSERT(0 != violation);
flac_fprintf(stderr, "ERROR (--%s): malformed vorbis comment field name \"%s\",\n %s\n", opt, option_argument, violation);
ok = false;
}
}
else if(0 == strcmp(opt, "set-tag")) {
const char *violation;
op = append_shorthand_operation(options, OP__SET_VC_FIELD);
FLAC__ASSERT(0 != option_argument);
op->argument.vc_field.field_value_from_file = false;
if(!parse_vorbis_comment_field(option_argument, &(op->argument.vc_field.field), &(op->argument.vc_field.field_name), &(op->argument.vc_field.field_value), &(op->argument.vc_field.field_value_length), &violation)) {
FLAC__ASSERT(0 != violation);
flac_fprintf(stderr, "ERROR (--%s): malformed vorbis comment field \"%s\",\n %s\n", opt, option_argument, violation);
ok = false;
}
}
else if(0 == strcmp(opt, "set-tag-from-file")) {
const char *violation;
op = append_shorthand_operation(options, OP__SET_VC_FIELD);
FLAC__ASSERT(0 != option_argument);
op->argument.vc_field.field_value_from_file = true;
if(!parse_vorbis_comment_field(option_argument, &(op->argument.vc_field.field), &(op->argument.vc_field.field_name), &(op->argument.vc_field.field_value), &(op->argument.vc_field.field_value_length), &violation)) {
FLAC__ASSERT(0 != violation);
flac_fprintf(stderr, "ERROR (--%s): malformed vorbis comment field \"%s\",\n %s\n", opt, option_argument, violation);
ok = false;
}
}
else if(0 == strcmp(opt, "import-tags-from")) {
op = append_shorthand_operation(options, OP__IMPORT_VC_FROM);
FLAC__ASSERT(0 != option_argument);
if(!parse_string(option_argument, &(op->argument.filename.value))) {
flac_fprintf(stderr, "ERROR (--%s): missing filename\n", opt);
ok = false;
}
}
else if(0 == strcmp(opt, "export-tags-to")) {
op = append_shorthand_operation(options, OP__EXPORT_VC_TO);
FLAC__ASSERT(0 != option_argument);
if(!parse_string(option_argument, &(op->argument.filename.value))) {
flac_fprintf(stderr, "ERROR (--%s): missing filename\n", opt);
ok = false;
}
}
else if(0 == strcmp(opt, "import-cuesheet-from")) {
if(0 != find_shorthand_operation(options, OP__IMPORT_CUESHEET_FROM)) {
flac_fprintf(stderr, "ERROR (--%s): may be specified only once\n", opt);
ok = false;
}
op = append_shorthand_operation(options, OP__IMPORT_CUESHEET_FROM);
FLAC__ASSERT(0 != option_argument);
if(!parse_string(option_argument, &(op->argument.import_cuesheet_from.filename))) {
flac_fprintf(stderr, "ERROR (--%s): missing filename\n", opt);
ok = false;
}
}
else if(0 == strcmp(opt, "export-cuesheet-to")) {
op = append_shorthand_operation(options, OP__EXPORT_CUESHEET_TO);
FLAC__ASSERT(0 != option_argument);
if(!parse_string(option_argument, &(op->argument.filename.value))) {
flac_fprintf(stderr, "ERROR (--%s): missing filename\n", opt);
ok = false;
}
}
else if(0 == strcmp(opt, "import-picture-from")) {
op = append_shorthand_operation(options, OP__IMPORT_PICTURE_FROM);
FLAC__ASSERT(0 != option_argument);
if(!parse_string(option_argument, &(op->argument.specification.value))) {
flac_fprintf(stderr, "ERROR (--%s): missing specification\n", opt);
ok = false;
}
}
else if(0 == strcmp(opt, "export-picture-to")) {
arg = find_argument(options, ARG__BLOCK_NUMBER);
op = append_shorthand_operation(options, OP__EXPORT_PICTURE_TO);
FLAC__ASSERT(0 != option_argument);
if(!parse_string(option_argument, &(op->argument.export_picture_to.filename))) {
flac_fprintf(stderr, "ERROR (--%s): missing filename\n", opt);
ok = false;
}
op->argument.export_picture_to.block_number_link = arg? &(arg->value.block_number) : 0;
}
else if(0 == strcmp(opt, "add-seekpoint")) {
const char *violation;
char *spec;
FLAC__ASSERT(0 != option_argument);
if(!parse_add_seekpoint(option_argument, &spec, &violation)) {
FLAC__ASSERT(0 != violation);
flac_fprintf(stderr, "ERROR (--%s): malformed seekpoint specification \"%s\",\n %s\n", opt, option_argument, violation);
ok = false;
}
else {
op = find_shorthand_operation(options, OP__ADD_SEEKPOINT);
if(0 == op)
op = append_shorthand_operation(options, OP__ADD_SEEKPOINT);
local_strcat(&(op->argument.add_seekpoint.specification), spec);
local_strcat(&(op->argument.add_seekpoint.specification), ";");
free(spec);
}
}
else if(0 == strcmp(opt, "add-replay-gain")) {
(void) append_shorthand_operation(options, OP__ADD_REPLAY_GAIN);
}
else if(0 == strcmp(opt, "remove-replay-gain")) {
const FLAC__byte * const tags[5] = {
GRABBAG__REPLAYGAIN_TAG_REFERENCE_LOUDNESS,
GRABBAG__REPLAYGAIN_TAG_TITLE_GAIN,
GRABBAG__REPLAYGAIN_TAG_TITLE_PEAK,
GRABBAG__REPLAYGAIN_TAG_ALBUM_GAIN,
GRABBAG__REPLAYGAIN_TAG_ALBUM_PEAK
};
size_t i;
for(i = 0; i < sizeof(tags)/sizeof(tags[0]); i++) {
op = append_shorthand_operation(options, OP__REMOVE_VC_FIELD);
op->argument.vc_field_name.value = local_strdup((const char *)tags[i]);
}
}
else if(0 == strcmp(opt, "add-padding")) {
op = append_shorthand_operation(options, OP__ADD_PADDING);
FLAC__ASSERT(0 != option_argument);
if(!parse_add_padding(option_argument, &(op->argument.add_padding.length))) {
flac_fprintf(stderr, "ERROR (--%s): illegal length \"%s\", length must be >= 0 and < 2^%u\n", opt, option_argument, FLAC__STREAM_METADATA_LENGTH_LEN);
ok = false;
}
}
else if(0 == strcmp(opt, "help")) {
options->show_long_help = true;
}
else if(0 == strcmp(opt, "version")) {
options->show_version = true;
}
else if(0 == strcmp(opt, "list")) {
(void) append_major_operation(options, OP__LIST);
}
else if(0 == strcmp(opt, "append")) {
(void) append_major_operation(options, OP__APPEND);
}
else if(0 == strcmp(opt, "remove")) {
(void) append_major_operation(options, OP__REMOVE);
}
else if(0 == strcmp(opt, "remove-all")) {
(void) append_major_operation(options, OP__REMOVE_ALL);
}
else if(0 == strcmp(opt, "merge-padding")) {
(void) append_major_operation(options, OP__MERGE_PADDING);
}
else if(0 == strcmp(opt, "sort-padding")) {
(void) append_major_operation(options, OP__SORT_PADDING);
}
else if(0 == strcmp(opt, "block-number")) {
arg = append_argument(options, ARG__BLOCK_NUMBER);
FLAC__ASSERT(0 != option_argument);
if(!parse_block_number(option_argument, &(arg->value.block_number))) {
flac_fprintf(stderr, "ERROR: malformed block number specification \"%s\"\n", option_argument);
ok = false;
}
}
else if(0 == strcmp(opt, "block-type")) {
arg = append_argument(options, ARG__BLOCK_TYPE);
FLAC__ASSERT(0 != option_argument);
if(!parse_block_type(option_argument, &(arg->value.block_type))) {
flac_fprintf(stderr, "ERROR (--%s): malformed block type specification \"%s\"\n", opt, option_argument);
ok = false;
}
options->args.checks.has_block_type = true;
}
else if(0 == strcmp(opt, "except-block-type")) {
arg = append_argument(options, ARG__EXCEPT_BLOCK_TYPE);
FLAC__ASSERT(0 != option_argument);
if(!parse_block_type(option_argument, &(arg->value.block_type))) {
flac_fprintf(stderr, "ERROR (--%s): malformed block type specification \"%s\"\n", opt, option_argument);
ok = false;
}
options->args.checks.has_except_block_type = true;
}
else if(0 == strcmp(opt, "data-format")) {
arg = append_argument(options, ARG__DATA_FORMAT);
FLAC__ASSERT(0 != option_argument);
if(!parse_data_format(option_argument, &(arg->value.data_format))) {
flac_fprintf(stderr, "ERROR (--%s): illegal data format \"%s\"\n", opt, option_argument);
ok = false;
}
}
else if(0 == strcmp(opt, "application-data-format")) {
FLAC__ASSERT(0 != option_argument);
if(!parse_application_data_format(option_argument, &(options->application_data_format_is_hexdump))) {
flac_fprintf(stderr, "ERROR (--%s): illegal application data format \"%s\"\n", opt, option_argument);
ok = false;
}
}
else if(0 == strcmp(opt, "from-file")) {
arg = append_argument(options, ARG__FROM_FILE);
FLAC__ASSERT(0 != option_argument);
arg->value.from_file.file_name = local_strdup(option_argument);
}
else {
FLAC__ASSERT(0);
}
return ok;
}
FLAC__bool parse_options(int argc, char *argv[], CommandLineOptions *options)
{
int ret;
int option_index = 1;
FLAC__bool had_error = false;
while ((ret = share__getopt_long(argc, argv, "", long_options_, &option_index)) != -1) {
switch (ret) {
case 0:
had_error |= !parse_option(option_index, share__optarg, options);
break;
case '?':
case ':':
had_error = true;
break;
default:
FLAC__ASSERT(0);
break;
}
}
if(options->prefix_with_filename == 2)
options->prefix_with_filename = (argc - share__optind > 1);
if(share__optind >= argc && !options->show_long_help && !options->show_version) {
flac_fprintf(stderr,"ERROR: you must specify at least one FLAC file;\n");
flac_fprintf(stderr," metaflac cannot be used as a pipe\n");
had_error = true;
}
options->num_files = argc - share__optind;
if(options->num_files > 0) {
unsigned i = 0;
if(0 == (options->filenames = safe_malloc_mul_2op_(sizeof(char*), /*times*/options->num_files)))
die("out of memory allocating space for file names list");
while(share__optind < argc)
options->filenames[i++] = local_strdup(argv[share__optind++]);
}
if(options->args.checks.num_major_ops > 0) {
if(options->args.checks.num_major_ops > 1) {
flac_fprintf(stderr, "ERROR: you may only specify one major operation at a time\n");
had_error = true;
}
else if(options->args.checks.num_shorthand_ops > 0) {
flac_fprintf(stderr, "ERROR: you may not mix shorthand and major operations\n");
had_error = true;
}
}
/* check for only one FLAC file used with certain options */
if(options->num_files > 1) {
if(0 != find_shorthand_operation(options, OP__IMPORT_CUESHEET_FROM)) {
flac_fprintf(stderr, "ERROR: you may only specify one FLAC file when using '--import-cuesheet-from'\n");
had_error = true;
}
if(0 != find_shorthand_operation(options, OP__EXPORT_CUESHEET_TO)) {
flac_fprintf(stderr, "ERROR: you may only specify one FLAC file when using '--export-cuesheet-to'\n");
had_error = true;
}
if(0 != find_shorthand_operation(options, OP__EXPORT_PICTURE_TO)) {
flac_fprintf(stderr, "ERROR: you may only specify one FLAC file when using '--export-picture-to'\n");
had_error = true;
}
if(
0 != find_shorthand_operation(options, OP__IMPORT_VC_FROM) &&
0 == strcmp(find_shorthand_operation(options, OP__IMPORT_VC_FROM)->argument.filename.value, "-")
) {
flac_fprintf(stderr, "ERROR: you may only specify one FLAC file when using '--import-tags-from=-'\n");
had_error = true;
}
}
if(options->args.checks.has_block_type && options->args.checks.has_except_block_type) {
flac_fprintf(stderr, "ERROR: you may not specify both '--block-type' and '--except-block-type'\n");
had_error = true;
}
if(had_error)
short_usage(0);
/*
* We need to create an OP__ADD_SEEKPOINT operation if there is
* not one already, and --import-cuesheet-from was specified but
* --no-cued-seekpoints was not:
*/
if(options->cued_seekpoints) {
Operation *op = find_shorthand_operation(options, OP__IMPORT_CUESHEET_FROM);
if(0 != op) {
Operation *op2 = find_shorthand_operation(options, OP__ADD_SEEKPOINT);
if(0 == op2)
op2 = append_shorthand_operation(options, OP__ADD_SEEKPOINT);
op->argument.import_cuesheet_from.add_seekpoint_link = &(op2->argument.add_seekpoint);
}
}
return had_error;
}
FLAC__bool import_cs_from(const char *filename, FLAC__StreamMetadata **cuesheet, const char *cs_filename, FLAC__bool *needs_write, FLAC__uint64 lead_out_offset, unsigned sample_rate, FLAC__bool is_cdda, Argument_AddSeekpoint *add_seekpoint_link)
{
FILE *f;
const char *error_message;
char **seekpoint_specification = add_seekpoint_link? &(add_seekpoint_link->specification) : 0;
unsigned last_line_read;
if(0 == cs_filename || strlen(cs_filename) == 0) {
flac_fprintf(stderr, "%s: ERROR: empty import file name\n", filename);
return false;
}
if(0 == strcmp(cs_filename, "-"))
f = stdin;
else
f = flac_fopen(cs_filename, "r");
if(0 == f) {
flac_fprintf(stderr, "%s: ERROR: can't open import file %s: %s\n", filename, cs_filename, strerror(errno));
return false;
}
*cuesheet = grabbag__cuesheet_parse(f, &error_message, &last_line_read, sample_rate, is_cdda, lead_out_offset);
if(f != stdin)
fclose(f);
if(0 == *cuesheet) {
flac_fprintf(stderr, "%s: ERROR: while parsing cuesheet \"%s\" on line %u: %s\n", filename, cs_filename, last_line_read, error_message);
return false;
}
if(!FLAC__format_cuesheet_is_legal(&(*cuesheet)->data.cue_sheet, /*check_cd_da_subset=*/false, &error_message)) {
flac_fprintf(stderr, "%s: ERROR parsing cuesheet \"%s\": %s\n", filename, cs_filename, error_message);
return false;
}
/* if we're expecting CDDA, warn about non-compliance */
if(is_cdda && !FLAC__format_cuesheet_is_legal(&(*cuesheet)->data.cue_sheet, /*check_cd_da_subset=*/true, &error_message)) {
flac_fprintf(stderr, "%s: WARNING cuesheet \"%s\" is not audio CD compliant: %s\n", filename, cs_filename, error_message);
(*cuesheet)->data.cue_sheet.is_cd = false;
}
/* add seekpoints for each index point if required */
if(0 != seekpoint_specification) {
char spec[128];
unsigned track, indx;
const FLAC__StreamMetadata_CueSheet *cs = &(*cuesheet)->data.cue_sheet;
if(0 == *seekpoint_specification)
*seekpoint_specification = local_strdup("");
for(track = 0; track < cs->num_tracks; track++) {
const FLAC__StreamMetadata_CueSheet_Track *tr = cs->tracks+track;
for(indx = 0; indx < tr->num_indices; indx++) {
flac_snprintf(spec, sizeof (spec), "%" PRIu64 ";", (tr->offset + tr->indices[indx].offset));
local_strcat(seekpoint_specification, spec);
}
}
}
*needs_write = true;
return true;
}
SWError SWLoadProperties_RW(SWPropertiesPtr properties, SDL_RWops *ops)
{
char *key, *value, *semi, *s, *p;
char *section = NULL;
char line[80];
SWError err = kNoError;
if (properties != NULL && ops != NULL)
{
while(1)
{
key = SDL_RWgets(ops, line, sizeof(line));
if (key == NULL)
break;
if (key[0] == '#' || line[0] == '/')
continue; // comments
semi = strchr(key, ';');
if (semi != NULL)
*semi = '\0'; // comment
if (key[0] == '[') // sections
{
key++;
s = line + strlen(line) - 1;
while (isspace(*s) && s > key)
*s-- = '\0';
if (*s == ']')
{
*s-- = '\0';
// trim whitespace (section)
while (isspace(*key) && *key)
key++;
while (isspace(*s) && s > key)
*s-- = '\0';
if (section != NULL)
free(section);
section = local_strdup(key);
//fprintf(stderr, "SECTION: \"%s\"\n", section);
continue;
}
}
value = strchr(line, '=');
if (value != NULL)
{
*value++ = '\0';
// trim whitespace (key)
while (isspace(*key) && *key)
key++;
s = value - 2;
while (isspace(*s) && s > key)
*s-- = '\0';
if (s < key)
continue; // empty
// trim whitespace (value)
while (isspace(*value) && *value)
value++;
s = value + strlen(value) - 1;
while (isspace(*s) && s > value)
*s-- = '\0';
if (s < value)
continue;
if (section == NULL)
err = SWSetPropertyString(properties, key, value);
else
{
p = malloc(strlen(section) + 1 + strlen(key) + 1);
if (p != NULL)
{
s = p;
*s = '\0';
strcat(s, section); s += strlen(section);
*s++ = '/';
*s = '\0';
strcat(s, key); s += strlen(key);
*s = '\0';
err = SWSetPropertyString(properties, p, value);
free(p);
}
}
if (err)
return err;
}
}
if (section != NULL)
free(section);
SDL_RWclose(ops);
return kNoError;
}
else
return kUnknownError;
}
void packDataValue(QVariant_ *var, DataValue *value)
{
QVariant *qvar = reinterpret_cast<QVariant *>(var);
// Some assumptions are made below regarding the size of types.
// There's apparently no better way to handle this since that's
// how the types with well defined sizes (qint64) are mapped to
// meta-types (QMetaType::LongLong).
switch ((int)qvar->type()) {
case QVariant::Invalid:
value->dataType = DTInvalid;
break;
case QMetaType::QUrl:
*qvar = qvar->value<QUrl>().toString();
// fallthrough
case QMetaType::QString:
{
value->dataType = DTString;
QByteArray ba = qvar->toByteArray();
*(char**)(value->data) = local_strdup(ba.constData());
value->len = ba.size();
break;
}
case QMetaType::Bool:
value->dataType = DTBool;
*(qint8*)(value->data) = (qint8)qvar->toInt();
break;
case QMetaType::LongLong:
// Some of these entries will have to be fixed when handling platforms
// where sizeof(long long) != 8 or sizeof(int) != 4.
value->dataType = DTInt64;
*(qint64*)(value->data) = qvar->toLongLong();
break;
case QMetaType::ULongLong:
value->dataType = DTUint64;
*(quint64*)(value->data) = qvar->toLongLong();
break;
case QMetaType::Int:
value->dataType = DTInt32;
*(qint32*)(value->data) = qvar->toInt();
break;
case QMetaType::UInt:
value->dataType = DTUint32;
*(quint32*)(value->data) = qvar->toUInt();
break;
case QMetaType::VoidStar:
value->dataType = DTUintptr;
*(uintptr_t*)(value->data) = (uintptr_t)qvar->value<void *>();
break;
case QMetaType::Double:
value->dataType = DTFloat64;
*(double*)(value->data) = qvar->toDouble();
break;
case QMetaType::Float:
value->dataType = DTFloat32;
*(float*)(value->data) = qvar->toFloat();
break;
case QMetaType::QColor:
value->dataType = DTColor;
*(unsigned int*)(value->data) = qvar->value<QColor>().rgba();
break;
case QMetaType::QVariantList:
{
QVariantList varlist = qvar->toList();
int len = varlist.size();
DataValue *dvlist = (DataValue *) malloc(sizeof(DataValue) * len);
for (int i = 0; i < len; i++) {
packDataValue((void*)&varlist.at(i), &dvlist[i]);
}
value->dataType = DTValueList;
value->len = len;
*(DataValue**)(value->data) = dvlist;
}
break;
case QMetaType::QVariantMap:
{
QVariantMap varmap = qvar->toMap();
int len = varmap.size() * 2;
DataValue *dvlist = (DataValue *) malloc(sizeof(DataValue) * len);
QMapIterator<QString, QVariant> it(varmap);
for (int i = 0; i < len; i += 2) {
if (!it.hasNext()) {
panicf("QVariantMap mutated during iteration");
}
it.next();
QVariant key = it.key();
QVariant val = it.value();
packDataValue((void*)&key, &dvlist[i]);
packDataValue((void*)&val, &dvlist[i+1]);
}
value->dataType = DTValueMap;
value->len = len;
*(DataValue**)(value->data) = dvlist;
}
break;
default:
if (qvar->type() == (int)QMetaType::QObjectStar || qvar->canConvert<QObject *>()) {
QObject *qobject = qvar->value<QObject *>();
GoValue *goValue = dynamic_cast<GoValue *>(qobject);
if (goValue) {
value->dataType = DTGoAddr;
*(void **)(value->data) = goValue->addr;
break;
}
GoPaintedValue *goPaintedValue = dynamic_cast<GoPaintedValue *>(qobject);
if (goPaintedValue) {
value->dataType = DTGoAddr;
*(void **)(value->data) = goPaintedValue->addr;
break;
}
value->dataType = DTObject;
*(void **)(value->data) = qobject;
break;
}
{
QQmlListReference ref = qvar->value<QQmlListReference>();
if (ref.isValid() && ref.canCount() && ref.canAt()) {
int len = ref.count();
DataValue *dvlist = (DataValue *) malloc(sizeof(DataValue) * len);
QVariant elem;
for (int i = 0; i < len; i++) {
elem.setValue(ref.at(i));
packDataValue(&elem, &dvlist[i]);
}
value->dataType = DTValueList;
value->len = len;
*(DataValue**)(value->data) = dvlist;
break;
}
}
if (qstrncmp(qvar->typeName(), "QQmlListProperty<", 17) == 0) {
QQmlListProperty<QObject> *list = reinterpret_cast<QQmlListProperty<QObject>*>(qvar->data());
if (list->count && list->at) {
int len = list->count(list);
DataValue *dvlist = (DataValue *) malloc(sizeof(DataValue) * len);
QVariant elem;
for (int i = 0; i < len; i++) {
elem.setValue(list->at(list, i));
packDataValue(&elem, &dvlist[i]);
}
value->dataType = DTValueList;
value->len = len;
*(DataValue**)(value->data) = dvlist;
break;
}
}
panicf("unsupported variant type: %d (%s)", qvar->type(), qvar->typeName());
break;
}
}
