FLAC__bool flac__foreign_metadata_write_to_flac(foreign_metadata_t *fm, const char *infilename, const char *outfilename, const char **error)
{
FLAC__bool ok;
FILE *fin, *fout;
FLAC__Metadata_SimpleIterator *it = FLAC__metadata_simple_iterator_new();
if(!it) {
if(error) *error = "out of memory (000)";
return false;
}
if(!FLAC__metadata_simple_iterator_init(it, outfilename, /*read_only=*/true, /*preserve_file_stats=*/false)) {
if(error) *error = "can't initialize iterator (001)";
FLAC__metadata_simple_iterator_delete(it);
return false;
}
if(0 == (fin = flac_fopen(infilename, "rb"))) {
if(error) *error = "can't open WAVE/AIFF file for reading (002)";
FLAC__metadata_simple_iterator_delete(it);
return false;
}
if(0 == (fout = flac_fopen(outfilename, "r+b"))) {
if(error) *error = "can't open FLAC file for updating (003)";
FLAC__metadata_simple_iterator_delete(it);
fclose(fin);
return false;
}
ok = write_to_flac_(fm, fin, fout, it, error);
FLAC__metadata_simple_iterator_delete(it);
fclose(fin);
fclose(fout);
return ok;
}
FLAC__bool dump_stats(const subframe_stats_t *stats, const char *filename)
{
FILE *outfile;
unsigned i;
const double m = stats->mean;
const double s1 = stats->stddev, s2 = s1*2, s3 = s1*3, s4 = s1*4, s5 = s1*5, s6 = s1*6;
const double p = stats->buckets[stats->peak_index].count;
outfile = flac_fopen(filename, "w");
if(0 == outfile) {
fprintf(stderr, "ERROR opening %s: %s\n", filename, strerror(errno));
return false;
}
fprintf(outfile, "plot '-' title 'PDF', '-' title 'mean' with impulses, '-' title '1-stddev' with histeps, '-' title '2-stddev' with histeps, '-' title '3-stddev' with histeps, '-' title '4-stddev' with histeps, '-' title '5-stddev' with histeps, '-' title '6-stddev' with histeps\n");
for(i = 0; i < stats->nbuckets; i++) {
fprintf(outfile, "%d %u\n", stats->buckets[i].residual, stats->buckets[i].count);
}
fprintf(outfile, "e\n");
fprintf(outfile, "%f %f\ne\n", stats->mean, p);
fprintf(outfile, "%f %f\n%f %f\ne\n", m-s1, p*0.8, m+s1, p*0.8);
fprintf(outfile, "%f %f\n%f %f\ne\n", m-s2, p*0.7, m+s2, p*0.7);
fprintf(outfile, "%f %f\n%f %f\ne\n", m-s3, p*0.6, m+s3, p*0.6);
fprintf(outfile, "%f %f\n%f %f\ne\n", m-s4, p*0.5, m+s4, p*0.5);
fprintf(outfile, "%f %f\n%f %f\ne\n", m-s5, p*0.4, m+s5, p*0.4);
fprintf(outfile, "%f %f\n%f %f\ne\n", m-s6, p*0.3, m+s6, p*0.3);
fprintf(outfile, "pause -1 'waiting...'\n");
fclose(outfile);
return true;
}
FLAC__bool export_pic_to(const char *filename, const FLAC__StreamMetadata *picture, const char *pic_filename)
{
FILE *f;
const FLAC__uint32 len = picture->data.picture.data_length;
if(0 == pic_filename || strlen(pic_filename) == 0) {
flac_fprintf(stderr, "%s: ERROR: empty export file name\n", filename);
return false;
}
if(0 == strcmp(pic_filename, "-"))
f = grabbag__file_get_binary_stdout();
else
f = flac_fopen(pic_filename, "wb");
if(0 == f) {
flac_fprintf(stderr, "%s: ERROR: can't open export file %s: %s\n", filename, pic_filename, strerror(errno));
return false;
}
if(fwrite(picture->data.picture.data, 1, len, f) != len) {
flac_fprintf(stderr, "%s: ERROR: writing PICTURE data to file\n", filename);
if(f != stdout)
fclose(f);
return false;
}
if(f != stdout)
fclose(f);
return true;
}
FLAC__bool flac__foreign_metadata_write_to_iff(foreign_metadata_t *fm, const char *infilename, const char *outfilename, FLAC__off_t offset1, FLAC__off_t offset2, FLAC__off_t offset3, const char **error)
{
FLAC__bool ok;
FILE *fin, *fout;
if(0 == (fin = flac_fopen(infilename, "rb"))) {
if(error) *error = "can't open FLAC file for reading (000)";
return false;
}
if(0 == (fout = flac_fopen(outfilename, "r+b"))) {
if(error) *error = "can't open WAVE/AIFF file for updating (001)";
fclose(fin);
return false;
}
ok = write_to_iff_(fm, fin, fout, offset1, offset2, offset3, error);
fclose(fin);
fclose(fout);
return ok;
}
FLAC__bool flac__foreign_metadata_read_from_wave64(foreign_metadata_t *fm, const char *filename, const char **error)
{
FLAC__bool ok;
FILE *f = flac_fopen(filename, "rb");
if(!f) {
if(error) *error = "can't open Wave64 file for reading (000)";
return false;
}
ok = read_from_wave64_(fm, f, error);
fclose(f);
return ok;
}
FLAC__bool export_cs_to(const char *filename, const FLAC__StreamMetadata *cuesheet, const char *cs_filename)
{
FILE *f;
char *ref = 0;
size_t reflen;
if(0 == cs_filename || strlen(cs_filename) == 0) {
flac_fprintf(stderr, "%s: ERROR: empty export file name\n", filename);
return false;
}
if(0 == strcmp(cs_filename, "-"))
f = stdout;
else
f = flac_fopen(cs_filename, "w");
if(0 == f) {
flac_fprintf(stderr, "%s: ERROR: can't open export file %s: %s\n", filename, cs_filename, strerror(errno));
return false;
}
reflen = strlen(filename) + 7 + 1;
if(0 == (ref = malloc(reflen))) {
flac_fprintf(stderr, "%s: ERROR: allocating memory\n", filename);
if(f != stdout)
fclose(f);
return false;
}
flac_snprintf(ref, reflen, "\"%s\" FLAC", filename);
grabbag__cuesheet_emit(f, cuesheet, ref);
free(ref);
if(f != stdout)
fclose(f);
return true;
}
FLAC__bool flac__foreign_metadata_read_from_flac(foreign_metadata_t *fm, const char *filename, const char **error)
{
FLAC__bool ok;
FILE *f;
FLAC__Metadata_SimpleIterator *it = FLAC__metadata_simple_iterator_new();
if(!it) {
if(error) *error = "out of memory (000)";
return false;
}
if(!FLAC__metadata_simple_iterator_init(it, filename, /*read_only=*/true, /*preserve_file_stats=*/false)) {
if(error) *error = "can't initialize iterator (001)";
FLAC__metadata_simple_iterator_delete(it);
return false;
}
if(0 == (f = flac_fopen(filename, "rb"))) {
if(error) *error = "can't open FLAC file for reading (002)";
FLAC__metadata_simple_iterator_delete(it);
return false;
}
ok = read_from_flac_(fm, f, it, error);
FLAC__metadata_simple_iterator_delete(it);
fclose(f);
return ok;
}
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;
}
/* slight modification: no 'filename' arg, and errors are passed back in 'violation' instead of printed to stderr */
static FLAC__bool set_vc_field(FLAC__StreamMetadata *block, const Argument_VcField *field, FLAC__bool *needs_write, FLAC__bool raw, const char **violation)
{
FLAC__StreamMetadata_VorbisComment_Entry entry;
char *converted;
FLAC__ASSERT(0 != block);
FLAC__ASSERT(block->type == FLAC__METADATA_TYPE_VORBIS_COMMENT);
FLAC__ASSERT(0 != field);
FLAC__ASSERT(0 != needs_write);
if(field->field_value_from_file) {
/* read the file into 'data' */
FILE *f = 0;
char *data = 0;
const FLAC__off_t size = grabbag__file_get_filesize(field->field_value);
if(size < 0) {
*violation = "can't open file for tag value";
return false;
}
if(size >= 0x100000) { /* magic arbitrary limit, actual format limit is near 16MB */
*violation = "file for tag value is too large";
return false;
}
if(0 == (data = malloc(size+1)))
die("out of memory allocating tag value");
data[size] = '\0';
if(0 == (f = flac_fopen(field->field_value, "rb")) || fread(data, 1, size, f) != (size_t)size) {
free(data);
if(f)
fclose(f);
*violation = "error while reading file for tag value";
return false;
}
fclose(f);
if(strlen(data) != (size_t)size) {
free(data);
*violation = "file for tag value has embedded NULs";
return false;
}
/* move 'data' into 'converted', converting to UTF-8 if necessary */
if(raw) {
converted = data;
}
else if(utf8_encode(data, &converted) >= 0) {
free(data);
}
else {
free(data);
*violation = "error converting file contents to UTF-8 for tag value";
return false;
}
/* create and entry and append it */
if(!FLAC__metadata_object_vorbiscomment_entry_from_name_value_pair(&entry, field->field_name, converted)) {
free(converted);
*violation = "file for tag value is not valid UTF-8";
return false;
}
free(converted);
if(!FLAC__metadata_object_vorbiscomment_append_comment(block, entry, /*copy=*/false)) {
*violation = "memory allocation failure";
return false;
}
*needs_write = true;
return true;
}
else {
FLAC__bool needs_free = false;
#ifdef _WIN32 /* everything in UTF-8 already. Must not alter */
entry.entry = (FLAC__byte *)field->field;
#else
if(raw) {
entry.entry = (FLAC__byte *)field->field;
}
else if(utf8_encode(field->field, &converted) >= 0) {
entry.entry = (FLAC__byte *)converted;
needs_free = true;
}
else {
*violation = "error converting comment to UTF-8";
return false;
}
#endif
entry.length = strlen((const char *)entry.entry);
if(!FLAC__format_vorbiscomment_entry_is_legal(entry.entry, entry.length)) {
if(needs_free)
free(converted);
/*
* our previous parsing has already established that the field
* name is OK, so it must be the field value
*/
*violation = "tag value for is not valid UTF-8";
return false;
}
if(!FLAC__metadata_object_vorbiscomment_append_comment(block, entry, /*copy=*/true)) {
if(needs_free)
free(converted);
*violation = "memory allocation failure";
return false;
}
*needs_write = true;
if(needs_free)
free(converted);
return true;
}
}
FLAC__StreamMetadata *grabbag__picture_parse_specification(const char *spec, const char **error_message)
{
FLAC__StreamMetadata *obj;
int state = 0;
static const char *error_messages[] = {
"memory allocation error",
"invalid picture specification",
"invalid picture specification: can't parse resolution/color part",
"unable to extract resolution and color info from URL, user must set explicitly",
"unable to extract resolution and color info from file, user must set explicitly",
"error opening picture file",
"error reading picture file",
"invalid picture type",
"unable to guess MIME type from file, user must set explicitly",
"type 1 icon must be a 32x32 pixel PNG"
};
FLAC__ASSERT(0 != spec);
FLAC__ASSERT(0 != error_message);
/* double protection */
if(0 == spec)
return 0;
if(0 == error_message)
return 0;
*error_message = 0;
if(0 == (obj = FLAC__metadata_object_new(FLAC__METADATA_TYPE_PICTURE))) {
*error_message = error_messages[0];
return obj;
}
if(strchr(spec, '|')) { /* full format */
const char *p;
char *q;
for(p = spec; *error_message==0 && *p; ) {
if(*p == '|') {
switch(state) {
case 0: /* type */
if(!local__parse_type_(spec, p-spec, &obj->data.picture))
*error_message = error_messages[7];
break;
case 1: /* mime type */
if(p-spec) { /* if blank, we'll try to guess later from the picture data */
if(0 == (q = local__strndup_(spec, p-spec)))
*error_message = error_messages[0];
else if(!FLAC__metadata_object_picture_set_mime_type(obj, q, /*copy=*/false))
*error_message = error_messages[0];
}
break;
case 2: /* description */
if(0 == (q = local__strndup_(spec, p-spec)))
*error_message = error_messages[0];
else if(!FLAC__metadata_object_picture_set_description(obj, (FLAC__byte*)q, /*copy=*/false))
*error_message = error_messages[0];
break;
case 3: /* resolution/color (e.g. [300x300x16[/1234]] */
if(!local__parse_resolution_(spec, p-spec, &obj->data.picture))
*error_message = error_messages[2];
break;
default:
*error_message = error_messages[1];
break;
}
p++;
spec = p;
state++;
}
else
p++;
}
}
else { /* simple format, filename only, everything else guessed */
if(!local__parse_type_("", 0, &obj->data.picture)) /* use default picture type */
*error_message = error_messages[7];
/* leave MIME type to be filled in later */
/* leave description empty */
/* leave the rest to be filled in later: */
else if(!local__parse_resolution_("", 0, &obj->data.picture))
*error_message = error_messages[2];
else
state = 4;
}
/* parse filename, read file, try to extract resolution/color info if needed */
if(*error_message == 0) {
if(state != 4)
*error_message = error_messages[1];
else { /* 'spec' points to filename/URL */
if(0 == strcmp(obj->data.picture.mime_type, "-->")) { /* magic MIME type means URL */
if(!FLAC__metadata_object_picture_set_data(obj, (FLAC__byte*)spec, strlen(spec), /*copy=*/true))
*error_message = error_messages[0];
else if(obj->data.picture.width == 0 || obj->data.picture.height == 0 || obj->data.picture.depth == 0)
*error_message = error_messages[3];
}
else { /* regular picture file */
const FLAC__off_t size = grabbag__file_get_filesize(spec);
if(size < 0)
*error_message = error_messages[5];
else {
FLAC__byte *buffer = safe_malloc_(size);
if(0 == buffer)
*error_message = error_messages[0];
else {
FILE *f = flac_fopen(spec, "rb");
if(0 == f) {
*error_message = error_messages[5];
free(buffer);
}
else {
if(fread(buffer, 1, size, f) != (size_t)size)
*error_message = error_messages[6];
fclose(f);
if(0 == *error_message) {
if(!FLAC__metadata_object_picture_set_data(obj, buffer, size, /*copy=*/false))
*error_message = error_messages[6];
/* try to extract MIME type if user left it blank */
else if(*obj->data.picture.mime_type == '\0' && !local__extract_mime_type_(obj))
*error_message = error_messages[8];
/* try to extract resolution/color info if user left it blank */
else if((obj->data.picture.width == 0 || obj->data.picture.height == 0 || obj->data.picture.depth == 0) && !local__extract_resolution_color_info_(&obj->data.picture))
*error_message = error_messages[4];
}
else {
free(buffer);
}
}
}
}
}
}
}
if(*error_message == 0) {
if(
obj->data.picture.type == FLAC__STREAM_METADATA_PICTURE_TYPE_FILE_ICON_STANDARD &&
(
(strcmp(obj->data.picture.mime_type, "image/png") && strcmp(obj->data.picture.mime_type, "-->")) ||
obj->data.picture.width != 32 ||
obj->data.picture.height != 32
)
)
*error_message = error_messages[9];
}
if(*error_message && obj) {
FLAC__metadata_object_delete(obj);
obj = 0;
}
return obj;
}
static int do_cuesheet(const char *infilename, unsigned sample_rate, FLAC__bool is_cdda, FLAC__uint64 lead_out_offset)
{
FILE *fin, *fout;
const char *error_message, *tmpfilenamebase;
char tmpfilename[4096];
unsigned last_line_read;
FLAC__StreamMetadata *cuesheet;
FLAC__ASSERT(strlen(infilename) + 2 < sizeof(tmpfilename));
/*
* pass 1
*/
if(0 == strcmp(infilename, "-")) {
fin = stdin;
}
else if(0 == (fin = flac_fopen(infilename, "r"))) {
fprintf(stderr, "can't open file %s for reading: %s\n", infilename, strerror(errno));
return 255;
}
if(0 != (cuesheet = grabbag__cuesheet_parse(fin, &error_message, &last_line_read, sample_rate, is_cdda, lead_out_offset))) {
if(fin != stdin)
fclose(fin);
}
else {
printf("pass1: parse error, line %u: \"%s\"\n", last_line_read, error_message);
if(fin != stdin)
fclose(fin);
return 1;
}
if(!FLAC__metadata_object_cuesheet_is_legal(cuesheet, is_cdda, &error_message)) {
printf("pass1: illegal cuesheet: \"%s\"\n", error_message);
FLAC__metadata_object_delete(cuesheet);
return 1;
}
tmpfilenamebase = strstr(infilename, "cuesheets/");
tmpfilenamebase = tmpfilenamebase == NULL ? infilename : tmpfilenamebase;
flac_snprintf(tmpfilename, sizeof (tmpfilename), "%s.1", tmpfilenamebase);
if(0 == (fout = flac_fopen(tmpfilename, "w"))) {
fprintf(stderr, "can't open file %s for writing: %s\n", tmpfilename, strerror(errno));
FLAC__metadata_object_delete(cuesheet);
return 255;
}
grabbag__cuesheet_emit(fout, cuesheet, "\"dummy.wav\" WAVE");
FLAC__metadata_object_delete(cuesheet);
fclose(fout);
/*
* pass 2
*/
if(0 == (fin = flac_fopen(tmpfilename, "r"))) {
fprintf(stderr, "can't open file %s for reading: %s\n", tmpfilename, strerror(errno));
return 255;
}
if(0 != (cuesheet = grabbag__cuesheet_parse(fin, &error_message, &last_line_read, sample_rate, is_cdda, lead_out_offset))) {
if(fin != stdin)
fclose(fin);
}
else {
printf("pass2: parse error, line %u: \"%s\"\n", last_line_read, error_message);
if(fin != stdin)
fclose(fin);
return 1;
}
if(!FLAC__metadata_object_cuesheet_is_legal(cuesheet, is_cdda, &error_message)) {
printf("pass2: illegal cuesheet: \"%s\"\n", error_message);
FLAC__metadata_object_delete(cuesheet);
return 1;
}
flac_snprintf(tmpfilename, sizeof (tmpfilename), "%s.2", tmpfilenamebase);
if(0 == (fout = flac_fopen(tmpfilename, "w"))) {
fprintf(stderr, "can't open file %s for writing: %s\n", tmpfilename, strerror(errno));
FLAC__metadata_object_delete(cuesheet);
return 255;
}
grabbag__cuesheet_emit(fout, cuesheet, "\"dummy.wav\" WAVE");
FLAC__metadata_object_delete(cuesheet);
fclose(fout);
return 0;
}
FLAC__bool file_utils__generate_flacfile(FLAC__bool is_ogg, const char *output_filename, FLAC__off_t *output_filesize, unsigned length, const FLAC__StreamMetadata *streaminfo, FLAC__StreamMetadata **metadata, unsigned num_metadata)
{
FLAC__int32 samples[1024];
FLAC__StreamEncoder *encoder;
FLAC__StreamEncoderInitStatus init_status;
encoder_client_struct encoder_client_data;
unsigned i, n;
FLAC__ASSERT(0 != output_filename);
FLAC__ASSERT(0 != streaminfo);
FLAC__ASSERT(streaminfo->type == FLAC__METADATA_TYPE_STREAMINFO);
FLAC__ASSERT((streaminfo->is_last && num_metadata == 0) || (!streaminfo->is_last && num_metadata > 0));
if(0 == (encoder_client_data.file = flac_fopen(output_filename, "wb")))
return false;
encoder = FLAC__stream_encoder_new();
if(0 == encoder) {
fclose(encoder_client_data.file);
return false;
}
FLAC__stream_encoder_set_ogg_serial_number(encoder, file_utils__ogg_serial_number);
FLAC__stream_encoder_set_verify(encoder, true);
FLAC__stream_encoder_set_streamable_subset(encoder, true);
FLAC__stream_encoder_set_do_mid_side_stereo(encoder, false);
FLAC__stream_encoder_set_loose_mid_side_stereo(encoder, false);
FLAC__stream_encoder_set_channels(encoder, streaminfo->data.stream_info.channels);
FLAC__stream_encoder_set_bits_per_sample(encoder, streaminfo->data.stream_info.bits_per_sample);
FLAC__stream_encoder_set_sample_rate(encoder, streaminfo->data.stream_info.sample_rate);
FLAC__stream_encoder_set_blocksize(encoder, streaminfo->data.stream_info.min_blocksize);
FLAC__stream_encoder_set_max_lpc_order(encoder, 0);
FLAC__stream_encoder_set_qlp_coeff_precision(encoder, 0);
FLAC__stream_encoder_set_do_qlp_coeff_prec_search(encoder, false);
FLAC__stream_encoder_set_do_escape_coding(encoder, false);
FLAC__stream_encoder_set_do_exhaustive_model_search(encoder, false);
FLAC__stream_encoder_set_min_residual_partition_order(encoder, 0);
FLAC__stream_encoder_set_max_residual_partition_order(encoder, 0);
FLAC__stream_encoder_set_rice_parameter_search_dist(encoder, 0);
FLAC__stream_encoder_set_total_samples_estimate(encoder, streaminfo->data.stream_info.total_samples);
FLAC__stream_encoder_set_metadata(encoder, metadata, num_metadata);
if(is_ogg)
init_status = FLAC__stream_encoder_init_ogg_stream(encoder, /*read_callback=*/0, encoder_write_callback_, /*seek_callback=*/0, /*tell_callback=*/0, encoder_metadata_callback_, &encoder_client_data);
else
init_status = FLAC__stream_encoder_init_stream(encoder, encoder_write_callback_, /*seek_callback=*/0, /*tell_callback=*/0, encoder_metadata_callback_, &encoder_client_data);
if(init_status != FLAC__STREAM_ENCODER_INIT_STATUS_OK) {
fclose(encoder_client_data.file);
return false;
}
/* init the dummy sample buffer */
for(i = 0; i < sizeof(samples) / sizeof(FLAC__int32); i++)
samples[i] = i & 7;
while(length > 0) {
n = min(length, sizeof(samples) / sizeof(FLAC__int32));
if(!FLAC__stream_encoder_process_interleaved(encoder, samples, n)) {
fclose(encoder_client_data.file);
return false;
}
length -= n;
}
(void)FLAC__stream_encoder_finish(encoder);
fclose(encoder_client_data.file);
FLAC__stream_encoder_delete(encoder);
if(0 != output_filesize) {
struct flac_stat_s filestats;
if(flac_stat(output_filename, &filestats) != 0)
return false;
else
*output_filesize = filestats.st_size;
}
return true;
}
int main(int argc, char *argv[])
{
FILE *f;
char buf[36];
foreign_metadata_t *fm;
const char *fn, *error;
size_t i;
FLAC__uint32 size;
#ifdef _WIN32
if (get_utf8_argv(&argc, &argv) != 0) {
fprintf(stderr, "ERROR: failed to convert command line parameters to UTF-8\n");
return 1;
}
#endif
if(argc != 2) {
flac_fprintf(stderr, "usage: %s { file.wav | file.aif }\n", argv[0]);
return 1;
}
fn = argv[1];
if(0 == (f = flac_fopen(fn, "rb")) || fread(buf, 1, 4, f) != 4) {
flac_fprintf(stderr, "ERROR opening %s for reading\n", fn);
return 1;
}
fclose(f);
if(0 == (fm = flac__foreign_metadata_new(memcmp(buf, "RIFF", 4) && memcmp(buf, "RF64", 4)? FOREIGN_BLOCK_TYPE__AIFF : FOREIGN_BLOCK_TYPE__RIFF))) {
flac_fprintf(stderr, "ERROR: out of memory\n");
return 1;
}
if(fm->type == FOREIGN_BLOCK_TYPE__AIFF) {
if(!flac__foreign_metadata_read_from_aiff(fm, fn, &error)) {
flac_fprintf(stderr, "ERROR reading chunks from %s: %s\n", fn, error);
return 1;
}
}
else {
if(!flac__foreign_metadata_read_from_wave(fm, fn, &error)) {
flac_fprintf(stderr, "ERROR reading chunks from %s: %s\n", fn, error);
return 1;
}
}
if(0 == (f = flac_fopen(fn, "rb"))) {
flac_fprintf(stderr, "ERROR opening %s for reading\n", fn);
return 1;
}
for(i = 0; i < fm->num_blocks; i++) {
if(fseeko(f, fm->blocks[i].offset, SEEK_SET) < 0) {
flac_fprintf(stderr, "ERROR seeking in %s\n", fn);
return 1;
}
if(fread(buf, 1, i==0?12:8, f) != (i==0?12:8)) {
flac_fprintf(stderr, "ERROR reading %s\n", fn);
return 1;
}
size = unpack32_((FLAC__byte*)buf+4, fm->type);
printf("block:[%c%c%c%c] size=%08x=(%10u)", buf[0], buf[1], buf[2], buf[3], size, size);
if(i == 0)
printf(" type:[%c%c%c%c]", buf[8], buf[9], buf[10], buf[11]);
else if(fm->type == FOREIGN_BLOCK_TYPE__AIFF && i == fm->audio_block)
printf(" offset size=%08x=(%10u)", fm->ssnd_offset_size, fm->ssnd_offset_size);
else if(fm->type == FOREIGN_BLOCK_TYPE__RIFF && i == 1 && !memcmp(buf, "ds64", 4)) {
if(fread(buf+8, 1, 36-8, f) != 36-8) {
flac_fprintf(stderr, "ERROR reading %s\n", fn);
return 1;
}
printf("\n RIFF size=%016" PRIx64 "=(%20" PRIu64 ")", unpack64le_((FLAC__byte*)buf+8), unpack64le_((FLAC__byte*)buf+8));
printf("\n data size=%016" PRIx64 "=(%20" PRIu64 ")", unpack64le_((FLAC__byte*)buf+16), unpack64le_((FLAC__byte*)buf+16));
printf("\n sample count=%016" PRIx64 "=(%20" PRIu64 ")", unpack64le_((FLAC__byte*)buf+24), unpack64le_((FLAC__byte*)buf+24));
printf("\n table size=%08x=(%10u)", unpack32le_((FLAC__byte*)buf+32), unpack32le_((FLAC__byte*)buf+32));
}
printf("\n");
}
fclose(f);
flac__foreign_metadata_delete(fm);
return 0;
}
static void open_test_file(StreamDecoderClientData * pdcd, int is_ogg, const char * mode)
{
pdcd->file = flac_fopen(flacfilename(is_ogg), mode);
safe_strncpy(pdcd->filename, flacfilename(is_ogg), sizeof (pdcd->filename));
}