analyze.c \
decode.c \
encode.c \
+ foreign_metadata.c \
main.c \
local_string_utils.c \
utils.c \
analyze.h \
decode.h \
encode.h \
+ foreign_metadata.h \
local_string_utils.h \
utils.h \
vorbiscomment.h
analyze.c \
decode.c \
encode.c \
+ foreign_metadata.c \
local_string_utils.c \
main.c \
utils.c \
typedef struct {
#if FLAC__HAS_OGG
FLAC__bool is_ogg;
+ FLAC__bool use_first_serial_number;
+ long serial_number;
#endif
FLAC__bool is_aiff_out;
FLAC__StreamDecoder *decoder;
FILE *fout;
+
+ foreign_metadata_t *foreign_metadata; /* NULL unless --keep-foreign-metadata requested */
} DecoderSession;
/*
* local routines
*/
-static FLAC__bool DecoderSession_construct(DecoderSession *d, FLAC__bool is_ogg, FLAC__bool is_aiff_out, FLAC__bool is_wave_out, FLAC__bool treat_warnings_as_errors, FLAC__bool continue_through_decode_errors, FLAC__bool channel_map_none, replaygain_synthesis_spec_t replaygain_synthesis_spec, FLAC__bool analysis_mode, analysis_options aopts, utils__SkipUntilSpecification *skip_specification, utils__SkipUntilSpecification *until_specification, utils__CueSpecification *cue_specification, const char *infilename, const char *outfilename);
+static FLAC__bool DecoderSession_construct(DecoderSession *d, FLAC__bool is_ogg, FLAC__bool use_first_serial_number, long serial_number, FLAC__bool is_aiff_out, FLAC__bool is_wave_out, FLAC__bool treat_warnings_as_errors, FLAC__bool continue_through_decode_errors, FLAC__bool channel_map_none, replaygain_synthesis_spec_t replaygain_synthesis_spec, FLAC__bool analysis_mode, analysis_options aopts, utils__SkipUntilSpecification *skip_specification, utils__SkipUntilSpecification *until_specification, utils__CueSpecification *cue_specification, foreign_metadata_t *foreign_metadata, const char *infilename, const char *outfilename);
static void DecoderSession_destroy(DecoderSession *d, FLAC__bool error_occurred);
-static FLAC__bool DecoderSession_init_decoder(DecoderSession *d, decode_options_t decode_options, const char *infilename);
+static FLAC__bool DecoderSession_init_decoder(DecoderSession *d, const char *infilename);
static FLAC__bool DecoderSession_process(DecoderSession *d);
static int DecoderSession_finish_ok(DecoderSession *d);
static int DecoderSession_finish_error(DecoderSession *d);
&decoder_session,
#if FLAC__HAS_OGG
options.common.is_ogg,
+ options.common.use_first_serial_number,
+ options.common.serial_number,
#else
/*is_ogg=*/false,
+ /*use_first_serial_number=*/false,
+ /*serial_number=*/0,
#endif
/*is_aiff_out=*/true,
/*is_wave_out=*/false,
&options.common.skip_specification,
&options.common.until_specification,
options.common.has_cue_specification? &options.common.cue_specification : 0,
+ options.foreign_metadata,
infilename,
outfilename
)
)
return 1;
- if(!DecoderSession_init_decoder(&decoder_session, options.common, infilename))
+ if(!DecoderSession_init_decoder(&decoder_session, infilename))
return DecoderSession_finish_error(&decoder_session);
if(!DecoderSession_process(&decoder_session))
&decoder_session,
#if FLAC__HAS_OGG
options.common.is_ogg,
+ options.common.use_first_serial_number,
+ options.common.serial_number,
#else
/*is_ogg=*/false,
+ /*use_first_serial_number=*/false,
+ /*serial_number=*/0,
#endif
/*is_aiff_out=*/false,
/*is_wave_out=*/true,
&options.common.skip_specification,
&options.common.until_specification,
options.common.has_cue_specification? &options.common.cue_specification : 0,
+ options.foreign_metadata,
infilename,
outfilename
)
)
return 1;
- if(!DecoderSession_init_decoder(&decoder_session, options.common, infilename))
+ if(!DecoderSession_init_decoder(&decoder_session, infilename))
return DecoderSession_finish_error(&decoder_session);
if(!DecoderSession_process(&decoder_session))
&decoder_session,
#if FLAC__HAS_OGG
options.common.is_ogg,
+ options.common.use_first_serial_number,
+ options.common.serial_number,
#else
/*is_ogg=*/false,
+ /*use_first_serial_number=*/false,
+ /*serial_number=*/0,
#endif
/*is_aiff_out=*/false,
/*is_wave_out=*/false,
&options.common.skip_specification,
&options.common.until_specification,
options.common.has_cue_specification? &options.common.cue_specification : 0,
+ /*foreign_metadata=*/NULL,
infilename,
outfilename
)
)
return 1;
- if(!DecoderSession_init_decoder(&decoder_session, options.common, infilename))
+ if(!DecoderSession_init_decoder(&decoder_session, infilename))
return DecoderSession_finish_error(&decoder_session);
if(!DecoderSession_process(&decoder_session))
return DecoderSession_finish_ok(&decoder_session);
}
-FLAC__bool DecoderSession_construct(DecoderSession *d, FLAC__bool is_ogg, FLAC__bool is_aiff_out, FLAC__bool is_wave_out, FLAC__bool treat_warnings_as_errors, FLAC__bool continue_through_decode_errors, FLAC__bool channel_map_none, replaygain_synthesis_spec_t replaygain_synthesis_spec, FLAC__bool analysis_mode, analysis_options aopts, utils__SkipUntilSpecification *skip_specification, utils__SkipUntilSpecification *until_specification, utils__CueSpecification *cue_specification, const char *infilename, const char *outfilename)
+FLAC__bool DecoderSession_construct(DecoderSession *d, FLAC__bool is_ogg, FLAC__bool use_first_serial_number, long serial_number, FLAC__bool is_aiff_out, FLAC__bool is_wave_out, FLAC__bool treat_warnings_as_errors, FLAC__bool continue_through_decode_errors, FLAC__bool channel_map_none, replaygain_synthesis_spec_t replaygain_synthesis_spec, FLAC__bool analysis_mode, analysis_options aopts, utils__SkipUntilSpecification *skip_specification, utils__SkipUntilSpecification *until_specification, utils__CueSpecification *cue_specification, foreign_metadata_t *foreign_metadata, const char *infilename, const char *outfilename)
{
#if FLAC__HAS_OGG
d->is_ogg = is_ogg;
+ d->use_first_serial_number = use_first_serial_number;
+ d->serial_number = serial_number;
#else
(void)is_ogg;
#endif
d->fout = 0; /* initialized with an open file later if necessary */
+ d->foreign_metadata = foreign_metadata;
+
FLAC__ASSERT(!(d->test_only && d->analysis_mode));
if(!d->test_only) {
}
}
-FLAC__bool DecoderSession_init_decoder(DecoderSession *decoder_session, decode_options_t decode_options, const char *infilename)
+FLAC__bool DecoderSession_init_decoder(DecoderSession *decoder_session, const char *infilename)
{
FLAC__StreamDecoderInitStatus init_status;
FLAC__uint32 test = 1;
is_big_endian_host_ = (*((FLAC__byte*)(&test)))? false : true;
+ if(decoder_session->foreign_metadata) {
+ const char *error;
+ if(!flac__foreign_metadata_read_from_flac(decoder_session->foreign_metadata, infilename, &error)) {
+ flac__utils_printf(stderr, 1, "%s: ERROR reading foreign metadata: %s\n", decoder_session->inbasefilename, error);
+ return false;
+ }
+ }
+
decoder_session->decoder = FLAC__stream_decoder_new();
if(0 == decoder_session->decoder) {
#if FLAC__HAS_OGG
if(decoder_session->is_ogg) {
- if(!decode_options.use_first_serial_number)
- FLAC__stream_decoder_set_ogg_serial_number(decoder_session->decoder, decode_options.serial_number);
+ if(!decoder_session->use_first_serial_number)
+ FLAC__stream_decoder_set_ogg_serial_number(decoder_session->decoder, decoder_session->serial_number);
init_status = FLAC__stream_decoder_init_ogg_file(decoder_session->decoder, strcmp(infilename, "-")? infilename : 0, write_callback, metadata_callback, error_callback, /*client_data=*/decoder_session);
}
else
#ifndef flac__decode_h
#define flac__decode_h
+#if HAVE_CONFIG_H
+# include <config.h>
+#endif
+
#include "analyze.h"
+#include "foreign_metadata.h"
#include "utils.h"
#include "share/replaygain_synthesis.h"
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
typedef struct {
FLAC__bool apply;
/* used for AIFF also */
typedef struct {
decode_options_t common;
+ foreign_metadata_t *foreign_metadata; /* NULL unless --keep-foreign-metadata requested */
} wav_decode_options_t;
typedef struct {
#include <math.h> /* for floor() */
#include <stdio.h> /* for FILE etc. */
#include <stdlib.h> /* for malloc */
-#include <string.h> /* for strcmp(), strerror( */
+#include <string.h> /* for strcmp(), strerror() */
#include "FLAC/all.h"
#include "share/grabbag.h"
#include "encode.h"
FLAC__bool is_stdout;
FLAC__bool outputfile_opened; /* true if we successfully opened the output file and we want it to be deleted if there is an error */
const char *inbasefilename;
+ const char *infilename;
const char *outfilename;
FLAC__uint64 skip;
*/
static FLAC__bool EncoderSession_construct(EncoderSession *e, FLAC__bool use_ogg, FLAC__bool verify, FLAC__bool treat_warnings_as_errors, FLAC__bool continue_through_decode_errors, FILE *infile, const char *infilename, const char *outfilename);
static void EncoderSession_destroy(EncoderSession *e);
-static int EncoderSession_finish_ok(EncoderSession *e, int info_align_carry, int info_align_zero);
+static int EncoderSession_finish_ok(EncoderSession *e, int info_align_carry, int info_align_zero, foreign_metadata_t *foreign_metadata);
static int EncoderSession_finish_error(EncoderSession *e);
-static FLAC__bool EncoderSession_init_encoder(EncoderSession *e, encode_options_t options, FLAC__uint32 channel_mask, unsigned channels, unsigned bps, unsigned sample_rate, FLACDecoderData *flac_decoder_data);
+static FLAC__bool EncoderSession_init_encoder(EncoderSession *e, encode_options_t options, FLAC__uint32 channel_mask, unsigned channels, unsigned bps, unsigned sample_rate, const foreign_metadata_t *foreign_metadata, FLACDecoderData *flac_decoder_data);
static FLAC__bool EncoderSession_process(EncoderSession *e, const FLAC__int32 * const buffer[], unsigned samples);
static FLAC__bool convert_to_seek_table_template(const char *requested_seek_points, int num_requested_seek_points, FLAC__StreamMetadata *cuesheet, EncoderSession *e);
static FLAC__bool canonicalize_until_specification(utils__SkipUntilSpecification *spec, const char *inbasefilename, unsigned sample_rate, FLAC__uint64 skip, FLAC__uint64 total_samples_in_input);
channel_map[i] = i;
}
+ if(options.foreign_metadata) {
+ const char *error;
+ if(!flac__foreign_metadata_read_from_aiff(options.foreign_metadata, infilename, &error)) {
+ flac__utils_printf(stderr, 1, "%s: ERROR reading foreign metadata: %s\n", encoder_session.inbasefilename, error);
+ return EncoderSession_finish_error(&encoder_session);
+ }
+ }
+
/* lookahead[] already has "FORMxxxxAIFF", do sub-chunks */
while(1) {
/* +54 for the size of the AIFF headers; this is just an estimate for the progress indicator and doesn't need to be exact */
encoder_session.unencoded_size= encoder_session.total_samples_to_encode*bytes_per_frame+54;
- if(!EncoderSession_init_encoder(&encoder_session, options.common, /*channel_mask=*/0, channels, bps-shift, sample_rate, /*flac_decoder_data=*/0))
+ if(!EncoderSession_init_encoder(&encoder_session, options.common, /*channel_mask=*/0, channels, bps-shift, sample_rate, options.foreign_metadata, /*flac_decoder_data=*/0))
return EncoderSession_finish_error(&encoder_session);
/* first do any samples in the reservoir */
if(encoder_session.treat_warnings_as_errors)
return EncoderSession_finish_error(&encoder_session);
}
- else {
+ else if(!options.foreign_metadata) {
flac__utils_printf(stderr, 1, "%s: WARNING: skipping unknown chunk '%s'\n", encoder_session.inbasefilename, chunk_id);
if(encoder_session.treat_warnings_as_errors)
return EncoderSession_finish_error(&encoder_session);
return EncoderSession_finish_error(&encoder_session);
}
- return EncoderSession_finish_ok(&encoder_session, info_align_carry, info_align_zero);
+ return EncoderSession_finish_ok(&encoder_session, info_align_carry, info_align_zero, options.foreign_metadata);
}
int flac__encode_wav(FILE *infile, off_t infilesize, const char *infilename, const char *outfilename, const FLAC__byte *lookahead, unsigned lookahead_length, wav_encode_options_t options)
channel_map[i] = i;
}
+ if(options.foreign_metadata) {
+ const char *error;
+ if(!flac__foreign_metadata_read_from_wave(options.foreign_metadata, infilename, &error)) {
+ flac__utils_printf(stderr, 1, "%s: ERROR reading foreign metadata: %s\n", encoder_session.inbasefilename, error);
+ return EncoderSession_finish_error(&encoder_session);
+ }
+ }
+
/*
* lookahead[] already has "RIFFxxxxWAVE", do sub-chunks
*/
* 4 byte: avg bytes per sec
* 2 byte: block align
* 2 byte: bits per sample (not necessarily all significant)
- * WAVEFORMAT adds
+ * WAVEFORMATEX adds
* 2 byte: extension size in bytes (usually 0 for WAVEFORMATEX and 22 for WAVEFORMATEXTENSIBLE with PCM)
* WAVEFORMATEXTENSIBLE adds
* 2 byte: valid bits per sample
/* +44 for the size of the WAV headers; this is just an estimate for the progress indicator and doesn't need to be exact */
encoder_session.unencoded_size = encoder_session.total_samples_to_encode * bytes_per_wide_sample + 44;
- if(!EncoderSession_init_encoder(&encoder_session, options.common, channel_mask, channels, bps-shift, sample_rate, /*flac_decoder_data=*/0))
+ if(!EncoderSession_init_encoder(&encoder_session, options.common, channel_mask, channels, bps-shift, sample_rate, options.foreign_metadata, /*flac_decoder_data=*/0))
return EncoderSession_finish_error(&encoder_session);
/*
FLAC__ASSERT(0);
}
}
- else {
+ else if(!options.foreign_metadata) {
flac__utils_printf(stderr, 1, "%s: WARNING: skipping unknown sub-chunk '%c%c%c%c'\n", encoder_session.inbasefilename, (char)(xx&255), (char)((xx>>8)&255), (char)((xx>>16)&255), (char)(xx>>24));
if(encoder_session.treat_warnings_as_errors)
return EncoderSession_finish_error(&encoder_session);
}
}
- return EncoderSession_finish_ok(&encoder_session, info_align_carry, info_align_zero);
+ return EncoderSession_finish_ok(&encoder_session, info_align_carry, info_align_zero, options.foreign_metadata);
}
int flac__encode_raw(FILE *infile, off_t infilesize, const char *infilename, const char *outfilename, const FLAC__byte *lookahead, unsigned lookahead_length, raw_encode_options_t options)
}
}
- if(!EncoderSession_init_encoder(&encoder_session, options.common, /*channel_mask=*/0, options.channels, options.bps, options.sample_rate, /*flac_decoder_data=*/0))
+ if(!EncoderSession_init_encoder(&encoder_session, options.common, /*channel_mask=*/0, options.channels, options.bps, options.sample_rate, /*foreign_metadata=*/0, /*flac_decoder_data=*/0))
return EncoderSession_finish_error(&encoder_session);
/*
}
}
- return EncoderSession_finish_ok(&encoder_session, info_align_carry, info_align_zero);
+ return EncoderSession_finish_ok(&encoder_session, info_align_carry, info_align_zero, /*foreign_metadata=*/0);
}
int flac__encode_flac(FILE *infile, off_t infilesize, const char *infilename, const char *outfilename, const FLAC__byte *lookahead, unsigned lookahead_length, flac_encode_options_t options, FLAC__bool input_is_ogg)
encoder_session.unencoded_size = decoder_data.filesize;
/* (channel mask will get copied over from the source VORBIS_COMMENT if it exists) */
- if(!EncoderSession_init_encoder(&encoder_session, options.common, /*channel_mask=*/0, decoder_data.metadata_blocks[0]->data.stream_info.channels, decoder_data.metadata_blocks[0]->data.stream_info.bits_per_sample, decoder_data.metadata_blocks[0]->data.stream_info.sample_rate, &decoder_data))
+ if(!EncoderSession_init_encoder(&encoder_session, options.common, /*channel_mask=*/0, decoder_data.metadata_blocks[0]->data.stream_info.channels, decoder_data.metadata_blocks[0]->data.stream_info.bits_per_sample, decoder_data.metadata_blocks[0]->data.stream_info.sample_rate, /*foreign_metadata=*/0, &decoder_data))
goto fubar2; /*@@@ yuck */
/*
}
FLAC__stream_decoder_delete(decoder);
- retval = EncoderSession_finish_ok(&encoder_session, -1, -1);
+ retval = EncoderSession_finish_ok(&encoder_session, -1, -1, /*foreign_metadata=*/0);
/* have to wail until encoder is completely finished before deleting because of the final step of writing the seekpoint offsets */
for(i = 0; i < decoder_data.num_metadata_blocks; i++)
FLAC__metadata_object_delete(decoder_data.metadata_blocks[i]);
e->outputfile_opened = false;
e->inbasefilename = grabbag__file_get_basename(infilename);
+ e->infilename = infilename;
e->outfilename = outfilename;
e->skip = 0; /* filled in later after the sample_rate is known */
}
}
-int EncoderSession_finish_ok(EncoderSession *e, int info_align_carry, int info_align_zero)
+int EncoderSession_finish_ok(EncoderSession *e, int info_align_carry, int info_align_zero, foreign_metadata_t *foreign_metadata)
{
FLAC__StreamEncoderState fse_state = FLAC__STREAM_ENCODER_OK;
int ret = 0;
}
}
+ /*@@@@@@ should this go here or somewhere else? */
+ if(ret == 0 && foreign_metadata) {
+ const char *error;
+ if(!flac__foreign_metadata_write_to_flac(foreign_metadata, e->infilename, e->outfilename, &error)) {
+ flac__utils_printf(stderr, 1, "%s: ERROR: updating foreign metadata in FLAC file: %s\n", e->inbasefilename, error);
+ ret = 1;
+ }
+ }
+
EncoderSession_destroy(e);
return ret;
return 1;
}
-FLAC__bool EncoderSession_init_encoder(EncoderSession *e, encode_options_t options, FLAC__uint32 channel_mask, unsigned channels, unsigned bps, unsigned sample_rate, FLACDecoderData *flac_decoder_data)
+typedef struct {
+ unsigned num_metadata;
+ FLAC__bool *needs_delete;
+ FLAC__StreamMetadata **metadata;
+ FLAC__StreamMetadata *cuesheet; /* always needs to be deleted */
+} static_metadata_t;
+
+static void static_metadata_init(static_metadata_t *m)
{
- unsigned num_metadata, i;
- FLAC__StreamMetadata padding, *cuesheet = 0;
- FLAC__StreamMetadata *static_metadata[4+64]; /* MAGIC +64 is for pictures metadata in options.pictures */
- FLAC__StreamMetadata **metadata = static_metadata;
+ m->num_metadata = 0;
+ m->needs_delete = 0;
+ m->metadata = 0;
+ m->cuesheet = 0;
+}
+
+static void static_metadata_clear(static_metadata_t *m)
+{
+ unsigned i;
+ for(i = 0; i < m->num_metadata; i++)
+ if(m->needs_delete[i])
+ FLAC__metadata_object_delete(m->metadata[i]);
+ if(m->metadata)
+ free(m->metadata);
+ if(m->needs_delete)
+ free(m->needs_delete);
+ if(m->cuesheet)
+ FLAC__metadata_object_delete(m->cuesheet);
+ static_metadata_init(m);
+}
+
+static FLAC__bool static_metadata_append(static_metadata_t *m, FLAC__StreamMetadata *d, FLAC__bool needs_delete)
+{
+ void *x;
+ if(0 == (x = realloc(m->metadata, sizeof(*m->metadata)*m->num_metadata+1)))
+ return false;
+ m->metadata = (FLAC__StreamMetadata**)x;
+ if(0 == (x = realloc(m->needs_delete, sizeof(*m->needs_delete)*m->num_metadata+1)))
+ return false;
+ m->needs_delete = (FLAC__bool*)x;
+ m->metadata[m->num_metadata] = d;
+ m->needs_delete[m->num_metadata] = needs_delete;
+ m->num_metadata++;
+ return true;
+}
+
+FLAC__bool EncoderSession_init_encoder(EncoderSession *e, encode_options_t options, FLAC__uint32 channel_mask, unsigned channels, unsigned bps, unsigned sample_rate, const foreign_metadata_t *foreign_metadata, FLACDecoderData *flac_decoder_data)
+{
+ FLAC__StreamMetadata padding;
+ FLAC__StreamMetadata **metadata = 0;
+ static_metadata_t static_metadata;
+ unsigned num_metadata = 0, i;
FLAC__StreamEncoderInitStatus init_status;
const FLAC__bool is_cdda = (channels == 1 || channels == 2) && (bps == 16) && (sample_rate == 44100);
char apodizations[2000];
FLAC__ASSERT(sizeof(options.pictures)/sizeof(options.pictures[0]) <= 64);
+ static_metadata_init(&static_metadata);
+
e->replay_gain = options.replay_gain;
e->channels = channels;
e->bits_per_sample = bps;
}
}
- if(!parse_cuesheet(&cuesheet, options.cuesheet_filename, e->inbasefilename, is_cdda, e->total_samples_to_encode, e->treat_warnings_as_errors))
+ if(!parse_cuesheet(&static_metadata.cuesheet, options.cuesheet_filename, e->inbasefilename, is_cdda, e->total_samples_to_encode, e->treat_warnings_as_errors))
return false;
- if(!convert_to_seek_table_template(options.requested_seek_points, options.num_requested_seek_points, options.cued_seekpoints? cuesheet : 0, e)) {
+ if(!convert_to_seek_table_template(options.requested_seek_points, options.num_requested_seek_points, options.cued_seekpoints? static_metadata.cuesheet : 0, e)) {
flac__utils_printf(stderr, 1, "%s: ERROR allocating memory for seek table\n", e->inbasefilename);
- if(0 != cuesheet)
- FLAC__metadata_object_delete(cuesheet);
+ static_metadata_clear(&static_metadata);
return false;
}
+ /* build metadata */
if(flac_decoder_data) {
/*
* we're encoding from FLAC so we will use the FLAC file's
FLAC__StreamMetadata *pic = FLAC__metadata_object_clone(options.pictures[i]);
if(0 == pic) {
flac__utils_printf(stderr, 1, "%s: ERROR allocating memory for PICTURE block\n", e->inbasefilename);
- if(0 != cuesheet)
- FLAC__metadata_object_delete(cuesheet);
+ static_metadata_clear(&static_metadata);
return false;
}
flac_decoder_data->metadata_blocks[flac_decoder_data->num_metadata_blocks++] = pic;
(void) flac__utils_get_channel_mask_tag(flac_decoder_data->metadata_blocks[i], &channel_mask);
flac__utils_printf(stderr, 1, "%s: WARNING, replacing tags from input FLAC file with those given on the command-line\n", e->inbasefilename);
if(e->treat_warnings_as_errors) {
- if(0 != cuesheet)
- FLAC__metadata_object_delete(cuesheet);
+ static_metadata_clear(&static_metadata);
return false;
}
FLAC__metadata_object_delete(flac_decoder_data->metadata_blocks[i]);
FLAC__StreamMetadata *vc = FLAC__metadata_object_clone(options.vorbis_comment);
if(0 == vc || (channel_mask && !flac__utils_set_channel_mask_tag(vc, channel_mask))) {
flac__utils_printf(stderr, 1, "%s: ERROR allocating memory for VORBIS_COMMENT block\n", e->inbasefilename);
- if(0 != cuesheet)
- FLAC__metadata_object_delete(cuesheet);
+ static_metadata_clear(&static_metadata);
return false;
}
for(i = flac_decoder_data->num_metadata_blocks; i > 1; i--)
for(i = 0, j = 0; i < flac_decoder_data->num_metadata_blocks; i++) {
FLAC__bool existing_cuesheet_is_bad = false;
/* check if existing cuesheet matches the input audio */
- if(flac_decoder_data->metadata_blocks[i]->type == FLAC__METADATA_TYPE_CUESHEET && 0 == cuesheet) {
+ if(flac_decoder_data->metadata_blocks[i]->type == FLAC__METADATA_TYPE_CUESHEET && 0 == static_metadata.cuesheet) {
const FLAC__StreamMetadata_CueSheet *cs = &flac_decoder_data->metadata_blocks[i]->data.cue_sheet;
if(e->total_samples_to_encode == 0) {
flac__utils_printf(stderr, 1, "%s: WARNING, cuesheet in input FLAC file cannot be kept if input size is not known, dropping it...\n", e->inbasefilename);
if(e->treat_warnings_as_errors) {
- if(0 != cuesheet)
- FLAC__metadata_object_delete(cuesheet);
+ static_metadata_clear(&static_metadata);
return false;
}
existing_cuesheet_is_bad = true;
else if(e->total_samples_to_encode != cs->tracks[cs->num_tracks-1].offset) {
flac__utils_printf(stderr, 1, "%s: WARNING, lead-out offset of cuesheet in input FLAC file does not match input length, dropping existing cuesheet...\n", e->inbasefilename);
if(e->treat_warnings_as_errors) {
- if(0 != cuesheet)
- FLAC__metadata_object_delete(cuesheet);
+ static_metadata_clear(&static_metadata);
return false;
}
existing_cuesheet_is_bad = true;
}
}
- if(flac_decoder_data->metadata_blocks[i]->type == FLAC__METADATA_TYPE_CUESHEET && (existing_cuesheet_is_bad || 0 != cuesheet)) {
- if(0 != cuesheet) {
+ if(flac_decoder_data->metadata_blocks[i]->type == FLAC__METADATA_TYPE_CUESHEET && (existing_cuesheet_is_bad || 0 != static_metadata.cuesheet)) {
+ if(0 != static_metadata.cuesheet) {
flac__utils_printf(stderr, 1, "%s: WARNING, replacing cuesheet in input FLAC file with the one given on the command-line\n", e->inbasefilename);
if(e->treat_warnings_as_errors) {
- FLAC__metadata_object_delete(cuesheet);
+ static_metadata_clear(&static_metadata);
return false;
}
}
flac_decoder_data->metadata_blocks[j++] = flac_decoder_data->metadata_blocks[i];
}
flac_decoder_data->num_metadata_blocks = j;
- if(0 != cuesheet && flac_decoder_data->num_metadata_blocks < sizeof(flac_decoder_data->metadata_blocks)/sizeof(flac_decoder_data->metadata_blocks[0])) {
+ if(0 != static_metadata.cuesheet && flac_decoder_data->num_metadata_blocks < sizeof(flac_decoder_data->metadata_blocks)/sizeof(flac_decoder_data->metadata_blocks[0])) {
/* prepend ours */
- FLAC__StreamMetadata *cs = FLAC__metadata_object_clone(cuesheet);
+ FLAC__StreamMetadata *cs = FLAC__metadata_object_clone(static_metadata.cuesheet);
if(0 == cs) {
flac__utils_printf(stderr, 1, "%s: ERROR allocating memory for CUESHEET block\n", e->inbasefilename);
- if(0 != cuesheet)
- FLAC__metadata_object_delete(cuesheet);
+ static_metadata_clear(&static_metadata);
return false;
}
for(i = flac_decoder_data->num_metadata_blocks; i > 1; i--)
if(options.num_requested_seek_points > 0) {
flac__utils_printf(stderr, 1, "%s: WARNING, replacing seektable in input FLAC file with the one given on the command-line\n", e->inbasefilename);
if(e->treat_warnings_as_errors) {
- if(0 != cuesheet)
- FLAC__metadata_object_delete(cuesheet);
+ static_metadata_clear(&static_metadata);
return false;
}
}
else {
flac__utils_printf(stderr, 1, "%s: WARNING, can't use existing seektable in input FLAC since the input size is changing or unknown, dropping existing SEEKTABLE block...\n", e->inbasefilename);
if(e->treat_warnings_as_errors) {
- if(0 != cuesheet)
- FLAC__metadata_object_delete(cuesheet);
+ static_metadata_clear(&static_metadata);
return false;
}
}
FLAC__StreamMetadata *st = FLAC__metadata_object_clone(e->seek_table_template);
if(0 == st) {
flac__utils_printf(stderr, 1, "%s: ERROR allocating memory for SEEKTABLE block\n", e->inbasefilename);
- if(0 != cuesheet)
- FLAC__metadata_object_delete(cuesheet);
+ static_metadata_clear(&static_metadata);
return false;
}
for(i = flac_decoder_data->num_metadata_blocks; i > 1; i--)
flac_decoder_data->metadata_blocks[flac_decoder_data->num_metadata_blocks] = FLAC__metadata_object_new(FLAC__METADATA_TYPE_PADDING);
if(0 == flac_decoder_data->metadata_blocks[flac_decoder_data->num_metadata_blocks]) {
flac__utils_printf(stderr, 1, "%s: ERROR allocating memory for PADDING block\n", e->inbasefilename);
- if(0 != cuesheet)
- FLAC__metadata_object_delete(cuesheet);
+ static_metadata_clear(&static_metadata);
return false;
}
flac_decoder_data->metadata_blocks[flac_decoder_data->num_metadata_blocks]->is_last = false; /* the encoder will set this for us */
* we're not encoding from FLAC so we will build the metadata
* from scratch
*/
- num_metadata = 0;
if(e->seek_table_template->data.seek_table.num_points > 0) {
e->seek_table_template->is_last = false; /* the encoder will set this for us */
- metadata[num_metadata++] = e->seek_table_template;
+ static_metadata_append(&static_metadata, e->seek_table_template, /*needs_delete=*/false);
}
- if(0 != cuesheet)
- metadata[num_metadata++] = cuesheet;
+ if(0 != static_metadata.cuesheet)
+ static_metadata_append(&static_metadata, static_metadata.cuesheet, /*needs_delete=*/false);
if(channel_mask) {
if(!flac__utils_set_channel_mask_tag(options.vorbis_comment, channel_mask)) {
flac__utils_printf(stderr, 1, "%s: ERROR adding channel mask tag\n", e->inbasefilename);
- if(0 != cuesheet)
- FLAC__metadata_object_delete(cuesheet);
+ static_metadata_clear(&static_metadata);
return false;
}
}
- metadata[num_metadata++] = options.vorbis_comment;
+ static_metadata_append(&static_metadata, options.vorbis_comment, /*needs_delete=*/false);
for(i = 0; i < options.num_pictures; i++)
- metadata[num_metadata++] = options.pictures[i];
+ static_metadata_append(&static_metadata, options.pictures[i], /*needs_delete=*/false);
+ if(foreign_metadata) {
+ for(i = 0; i < foreign_metadata->num_blocks; i++) {
+ FLAC__StreamMetadata *p = FLAC__metadata_object_new(FLAC__METADATA_TYPE_PADDING);
+ if(!p) {
+ flac__utils_printf(stderr, 1, "%s: ERROR: out of memory\n", e->inbasefilename);
+ static_metadata_clear(&static_metadata);
+ return false;
+ }
+ static_metadata_append(&static_metadata, p, /*needs_delete=*/true);
+ static_metadata.metadata[static_metadata.num_metadata-1]->length = FLAC__STREAM_METADATA_APPLICATION_ID_LEN/8 + foreign_metadata->blocks[i].size;
+fprintf(stderr,"@@@@@@ add PADDING=%u\n",static_metadata.metadata[static_metadata.num_metadata-1]->length);
+ }
+ }
if(options.padding != 0) {
padding.is_last = false; /* the encoder will set this for us */
padding.type = FLAC__METADATA_TYPE_PADDING;
padding.length = (unsigned)(options.padding>0? options.padding : (e->total_samples_to_encode / e->sample_rate < 20*60? FLAC_ENCODE__DEFAULT_PADDING : FLAC_ENCODE__DEFAULT_PADDING*8));
- metadata[num_metadata++] = &padding;
+ static_metadata_append(&static_metadata, &padding, /*needs_delete=*/false);
}
+ metadata = static_metadata.metadata;
+ num_metadata = static_metadata.num_metadata;
}
/* check for a few things that have not already been checked. the
* up front to give a better error message.
*/
if(!verify_metadata(e, metadata, num_metadata)) {
- if(0 != cuesheet)
- FLAC__metadata_object_delete(cuesheet);
+ static_metadata_clear(&static_metadata);
return false;
}
case CST_APODIZATION:
if(strlen(apodizations)+strlen(options.compression_settings[i].value.t_string)+2 >= sizeof(apodizations)) {
flac__utils_printf(stderr, 1, "%s: ERROR: too many apodization functions requested\n", e->inbasefilename);
- if(0 != cuesheet)
- FLAC__metadata_object_delete(cuesheet);
+ static_metadata_clear(&static_metadata);
return false;
}
else {
if(!options.debug.do_md5) {
flac__utils_printf(stderr, 1, "%s: WARNING, MD5 computation disabled, resulting file will not have MD5 sum\n", e->inbasefilename);
if(e->treat_warnings_as_errors) {
- if(0 != cuesheet)
- FLAC__metadata_object_delete(cuesheet);
+ static_metadata_clear(&static_metadata);
return false;
}
FLAC__stream_encoder_set_do_md5(e->encoder, false);
print_error_with_init_status(e, "ERROR initializing encoder", init_status);
if(FLAC__stream_encoder_get_state(e->encoder) != FLAC__STREAM_ENCODER_IO_ERROR)
e->outputfile_opened = true;
- if(0 != cuesheet)
- FLAC__metadata_object_delete(cuesheet);
+ static_metadata_clear(&static_metadata);
return false;
}
else
(FLAC__stream_encoder_get_do_exhaustive_model_search(e->encoder) || FLAC__stream_encoder_get_do_qlp_coeff_prec_search(e->encoder))? 0x0f :
0x3f;
- if(0 != cuesheet)
- FLAC__metadata_object_delete(cuesheet);
+ static_metadata_clear(&static_metadata);
return true;
}
#ifndef flac__encode_h
#define flac__encode_h
-/* needed because of off_t */
#if HAVE_CONFIG_H
# include <config.h>
#endif
#include "FLAC/metadata.h"
+#include "foreign_metadata.h"
#include "utils.h"
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
extern const int FLAC_ENCODE__DEFAULT_PADDING;
typedef enum {
typedef struct {
encode_options_t common;
+ foreign_metadata_t *foreign_metadata; /* NULL unless --keep-foreign-metadata requested */
} wav_encode_options_t;
typedef struct {
--- /dev/null
+/* flac - Command-line FLAC encoder/decoder
+ * Copyright (C) 2000,2001,2002,2003,2004,2005,2006,2007 Josh Coalson
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#if HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#if defined _MSC_VER || defined __MINGW32__
+#include <sys/types.h> /* for off_t */
+#if _MSC_VER <= 1600 /* @@@ [2G limit] */
+#define fseeko fseek
+#define ftello ftell
+#endif
+#endif
+#include <stdio.h> /* for FILE etc. */
+#include <stdlib.h> /* for calloc() etc. */
+#include <string.h> /* for memcmp() etc. */
+#include "FLAC/assert.h"
+#include "FLAC/metadata.h"
+#include "foreign_metadata.h"
+
+#ifdef min
+#undef min
+#endif
+#define min(x,y) ((x)<(y)?(x):(y))
+
+
+static const char *FLAC__FOREIGN_METADATA_APPLICATION_ID = "FFMB";/*@@@@@@ settle on an ID */
+
+static FLAC__uint32 unpack32be_(const FLAC__byte *b)
+{
+ return ((FLAC__uint32)b[0]<<24) + ((FLAC__uint32)b[1]<<16) + ((FLAC__uint32)b[2]<<8) + (FLAC__uint32)b[3];
+}
+
+static FLAC__uint32 unpack32le_(const FLAC__byte *b)
+{
+ return (FLAC__uint32)b[0] + ((FLAC__uint32)b[1]<<8) + ((FLAC__uint32)b[2]<<16) + ((FLAC__uint32)b[3]<<24);
+}
+
+static FLAC__bool append_block_(foreign_metadata_t *fm, off_t offset, FLAC__uint32 size, const char **error)
+{
+ foreign_block_t *fb = realloc(fm->blocks, sizeof(foreign_block_t) * (fm->num_blocks+1));
+ if(fb) {
+ fb[fm->num_blocks].offset = offset;
+ fb[fm->num_blocks].size = size;
+ fm->num_blocks++;
+ fm->blocks = fb;
+ return true;
+ }
+ if(error) *error = "out of memory";
+ return false;
+}
+
+static FLAC__bool read_from_aiff_(foreign_metadata_t *fm, FILE *f, const char **error)
+{
+ FLAC__byte buffer[12];
+ off_t offset, eof_offset;
+ if((offset = ftello(f)) < 0) {
+ if(error) *error = "ftello() error (001)";
+ return false;
+ }
+ if(fread(buffer, 1, 12, f) < 12 || memcmp(buffer, "FORM", 4) || (memcmp(buffer+8, "AIFF", 4) && memcmp(buffer+8, "AIFC", 4))) {
+ if(error) *error = "unsupported FORM layout (002)";
+ return false;
+ }
+ if(!append_block_(fm, offset, 12, error))
+ return false;
+ eof_offset = 8 + unpack32be_(buffer+4);
+ while(!feof(f)) {
+ FLAC__uint32 size, ssnd_offset_size = 0;
+ if((offset = ftello(f)) < 0) {
+ if(error) *error = "ftello() error (003)";
+ return false;
+ }
+ if((size = fread(buffer, 1, 8, f)) < 8) {
+ if(size == 0 && feof(f))
+ break;
+ if(error) *error = "invalid AIFF file (004)";
+ return false;
+ }
+ size = unpack32be_(buffer+4);
+ /* check if pad byte needed */
+ if(size & 1)
+ size++;
+ if(!memcmp(buffer, "COMM", 4)) {
+ if(fm->format_block) {
+ if(error) *error = "invalid AIFF file: multiple \"COMM\" chunks (005)";
+ return false;
+ }
+ fm->format_block = fm->num_blocks;
+ }
+ else if(!memcmp(buffer, "SSND", 4)) {
+ if(fm->audio_block) {
+ if(error) *error = "invalid AIFF file: multiple \"SSND\" chunks (006)";
+ return false;
+ }
+ fm->audio_block = fm->num_blocks;
+ /* read #offset bytes */
+ if(fread(buffer+8, 1, 4, f) < 4) {
+ if(error) *error = "invalid AIFF file (007)";
+ return false;
+ }
+ ssnd_offset_size = unpack32be_(buffer+8);
+ if(fseeko(f, -4, SEEK_CUR) < 0) {
+ if(error) *error = "invalid AIFF file: seek error (008)";
+ return false;
+ }
+ }
+ if(!append_block_(fm, offset, 8 + (memcmp(buffer, "SSND", 4)? size : 8 + ssnd_offset_size), error))
+ return false;
+fprintf(stderr,"@@@@@@ chunk=%c%c%c%c offset=%d size=%d\n",buffer[0],buffer[1],buffer[2],buffer[3],(int)offset,8+(int)size);
+ if(fseeko(f, size, SEEK_CUR) < 0) {
+ if(error) *error = "invalid AIFF file: seek error (009)";
+ return false;
+ }
+ }
+ if(eof_offset != ftello(f)) {
+ if(error) *error = "invalid AIFF file: unexpected EOF (010)";
+ return false;
+ }
+ if(!fm->format_block) {
+ if(error) *error = "invalid AIFF file: missing \"COMM\" chunk (011)";
+ return false;
+ }
+ if(!fm->audio_block) {
+ if(error) *error = "invalid AIFF file: missing \"SSND\" chunk (012)";
+ return false;
+ }
+ return true;
+}
+
+static FLAC__bool read_from_wave_(foreign_metadata_t *fm, FILE *f, const char **error)
+{
+ FLAC__byte buffer[12];
+ off_t offset, eof_offset;
+ if((offset = ftello(f)) < 0) {
+ if(error) *error = "ftello() error (001)";
+ return false;
+ }
+ if(fread(buffer, 1, 12, f) < 12 || memcmp(buffer, "RIFF", 4) || memcmp(buffer+8, "WAVE", 4)) {
+ if(error) *error = "unsupported RIFF layout (002)";
+ return false;
+ }
+ if(!append_block_(fm, offset, 12, error))
+ return false;
+ eof_offset = 8 + unpack32le_(buffer+4);
+fprintf(stderr,"@@@@@@ off=%d eof=%d\n",(int)offset,(int)eof_offset);
+ while(!feof(f)) {
+ FLAC__uint32 size;
+ if((offset = ftello(f)) < 0) {
+ if(error) *error = "ftello() error (003)";
+ return false;
+ }
+ if((size = fread(buffer, 1, 8, f)) < 8) {
+ if(size == 0 && feof(f))
+ break;
+ if(error) *error = "invalid WAVE file (004)";
+ return false;
+ }
+ size = unpack32le_(buffer+4);
+ /* check if pad byte needed */
+ if(size & 1)
+ size++;
+ if(!memcmp(buffer, "fmt ", 4)) {
+ if(fm->format_block) {
+ if(error) *error = "invalid WAVE file: multiple \"fmt \" chunks (005)";
+ return false;
+ }
+ fm->format_block = fm->num_blocks;
+ }
+ else if(!memcmp(buffer, "data", 4)) {
+ if(fm->audio_block) {
+ if(error) *error = "invalid WAVE file: multiple \"data\" chunks (006)";
+ return false;
+ }
+ fm->audio_block = fm->num_blocks;
+ }
+ if(!append_block_(fm, offset, 8 + (memcmp(buffer, "data", 4)? size : 0), error))
+ return false;
+fprintf(stderr,"@@@@@@ chunk=%c%c%c%c offset=%d size=%d\n",buffer[0],buffer[1],buffer[2],buffer[3],(int)offset,8+(int)size);
+ if(fseeko(f, size, SEEK_CUR) < 0) {
+ if(error) *error = "invalid WAVE file: seek error (007)";
+ return false;
+ }
+ }
+ if(eof_offset != ftello(f)) {
+ if(error) *error = "invalid WAVE file: unexpected EOF (008)";
+ return false;
+ }
+ if(!fm->format_block) {
+ if(error) *error = "invalid WAVE file: missing \"fmt \" chunk (009)";
+ return false;
+ }
+ if(!fm->audio_block) {
+ if(error) *error = "invalid WAVE file: missing \"data\" chunk (010)";
+ return false;
+ }
+ return true;
+}
+
+static FLAC__bool write_to_flac_(foreign_metadata_t *fm, FILE *fin, FILE *fout, FLAC__Metadata_SimpleIterator *it, const char **error)
+{
+ static FLAC__byte buffer[4096];
+ const unsigned ID_LEN = FLAC__STREAM_METADATA_APPLICATION_ID_LEN/8;
+ size_t left, block_num = 0;
+ FLAC__ASSERT(sizeof(buffer) >= ID_LEN);
+ while(block_num < fm->num_blocks) {
+ /* find next matching padding block */
+ do {
+ /* even on the first chunk's loop there will be a skippable STREAMINFO block, on subsequent loops we are first moving past the PADDING we just used */
+ if(!FLAC__metadata_simple_iterator_next(it)) {
+ if(error) *error = "no matching PADDING block found (004)";
+ return false;
+ }
+ } while(FLAC__metadata_simple_iterator_get_block_type(it) != FLAC__METADATA_TYPE_PADDING);
+ if(FLAC__metadata_simple_iterator_get_block_length(it) != ID_LEN+fm->blocks[block_num].size) {
+ if(error) *error = "PADDING block with wrong size found (005)";
+ return false;
+ }
+fprintf(stderr,"@@@@@@ flac offset = %d\n",(int)FLAC__metadata_simple_iterator_get_block_offset(it));
+ /* transfer chunk into APPLICATION block */
+ /* first set up the file pointers */
+ if(fseek(fin, fm->blocks[block_num].offset, SEEK_SET) < 0) {
+ if(error) *error = "seek failed in WAVE/AIFF file (006)";
+ return false;
+ }
+ if(fseek(fout, FLAC__metadata_simple_iterator_get_block_offset(it), SEEK_SET) < 0) {
+ if(error) *error = "seek failed in FLAC file (007)";
+ return false;
+ }
+ /* update the type */
+ buffer[0] = FLAC__METADATA_TYPE_APPLICATION;
+ if(FLAC__metadata_simple_iterator_is_last(it))
+ buffer[0] |= 0x80; /*MAGIC number*/
+ if(fwrite(buffer, 1, 1, fout) < 1) {
+ if(error) *error = "write failed in FLAC/AIFF file (008)";
+ return false;
+ }
+ /* length stays the same so skip over it */
+ if(fseek(fout, FLAC__STREAM_METADATA_LENGTH_LEN/8, SEEK_CUR) < 0) {
+ if(error) *error = "seek failed in FLAC file (009)";
+ return false;
+ }
+ /* write the APPLICATION ID */
+ memcpy(buffer, FLAC__FOREIGN_METADATA_APPLICATION_ID, ID_LEN);
+ if(fwrite(buffer, 1, ID_LEN, fout) < ID_LEN) {
+ if(error) *error = "write failed in FLAC/AIFF file (010)";
+ return false;
+ }
+ /* transfer the foreign metadata */
+ for(left = fm->blocks[block_num].size; left > 0; ) {
+ size_t need = min(sizeof(buffer), left);
+ if(fread(buffer, 1, need, fin) < need) {
+ if(error) *error = "read failed in WAVE/AIFF file (011)";
+ return false;
+ }
+ if(fwrite(buffer, 1, need, fout) < need) {
+ if(error) *error = "write failed in FLAC/AIFF file (012)";
+ return false;
+ }
+ left -= need;
+ }
+ block_num++;
+ }
+ return true;
+}
+
+foreign_metadata_t *flac__foreign_metadata_new(void)
+{
+ return (foreign_metadata_t*)calloc(sizeof(foreign_metadata_t), 1);
+}
+
+void flac__foreign_metadata_delete(foreign_metadata_t *fm)
+{
+ if(fm) {
+ if(fm->blocks)
+ free(fm->blocks);
+ free(fm);
+ }
+}
+
+FLAC__bool flac__foreign_metadata_read_from_aiff(foreign_metadata_t *fm, const char *filename, const char **error)
+{
+ FLAC__bool ok;
+ FILE *f = fopen(filename, "rb");
+ if(!f) {
+ if(error) *error = "can't open AIFF file for reading (000)";
+ return false;
+ }
+ ok = read_from_aiff_(fm, f, error);
+ fclose(f);
+ return ok;
+}
+
+FLAC__bool flac__foreign_metadata_read_from_wave(foreign_metadata_t *fm, const char *filename, const char **error)
+{
+ FLAC__bool ok;
+ FILE *f = fopen(filename, "rb");
+ if(!f) {
+ if(error) *error = "can't open WAVE file for reading (000)";
+ return false;
+ }
+ ok = read_from_wave_(fm, f, error);
+ fclose(f);
+ return ok;
+}
+
+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 = 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 = 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 flac__foreign_metadata_read_from_flac(foreign_metadata_t *fm, const char *filename, const char **error)
+{
+}
+
+FLAC__bool flac__foreign_metadata_write_to_aiff(foreign_metadata_t *fm, const char *infilename, const char *outfilename, const char **error)
+{
+}
+
+FLAC__bool flac__foreign_metadata_write_to_wave(foreign_metadata_t *fm, const char *infilename, const char *outfilename, const char **error)
+{
+}
--- /dev/null
+/* flac - Command-line FLAC encoder/decoder
+ * Copyright (C) 2000,2001,2002,2003,2004,2005,2006,2007 Josh Coalson
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#ifndef flac__foreign_metadata_h
+#define flac__foreign_metadata_h
+
+#if HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include "FLAC/metadata.h"
+#include "utils.h"
+
+typedef struct {
+ /* for encoding, this will be the offset in the WAVE/AIFF file of the chunk */
+ /* for decoding, this will be the offset in the FLAC file of the chunk data inside the APPLICATION block */
+ off_t offset;
+ FLAC__uint32 size;
+} foreign_block_t;
+
+typedef struct {
+ foreign_block_t *blocks;
+ size_t num_blocks;
+ size_t format_block; /* block number of 'fmt ' or 'COMM' chunk */
+ size_t audio_block; /* block number of 'data' or 'SSND' chunk */
+} foreign_metadata_t;
+
+foreign_metadata_t *flac__foreign_metadata_new(void);
+
+void flac__foreign_metadata_delete(foreign_metadata_t *fm);
+
+FLAC__bool flac__foreign_metadata_read_from_aiff(foreign_metadata_t *fm, const char *filename, const char **error);
+FLAC__bool flac__foreign_metadata_read_from_wave(foreign_metadata_t *fm, const char *filename, const char **error);
+FLAC__bool flac__foreign_metadata_write_to_flac(foreign_metadata_t *fm, const char *infilename, const char *outfilename, const char **error);
+
+FLAC__bool flac__foreign_metadata_read_from_flac(foreign_metadata_t *fm, const char *filename, const char **error);
+FLAC__bool flac__foreign_metadata_write_to_aiff(foreign_metadata_t *fm, const char *infilename, const char *outfilename, const char **error);
+FLAC__bool flac__foreign_metadata_write_to_wave(foreign_metadata_t *fm, const char *infilename, const char *outfilename, const char **error);
+
+#endif
/*
* general options
*/
- { "help" , share__no_argument, 0, 'h' },
- { "explain" , share__no_argument, 0, 'H' },
- { "version" , share__no_argument, 0, 'v' },
- { "decode" , share__no_argument, 0, 'd' },
- { "analyze" , share__no_argument, 0, 'a' },
- { "test" , share__no_argument, 0, 't' },
- { "stdout" , share__no_argument, 0, 'c' },
- { "silent" , share__no_argument, 0, 's' },
- { "totally-silent" , share__no_argument, 0, 0 },
- { "warnings-as-errors", share__no_argument, 0, 'w' },
- { "force" , share__no_argument, 0, 'f' },
- { "delete-input-file" , share__no_argument, 0, 0 },
- { "output-prefix" , share__required_argument, 0, 0 },
- { "output-name" , share__required_argument, 0, 'o' },
- { "skip" , share__required_argument, 0, 0 },
- { "until" , share__required_argument, 0, 0 },
- { "channel-map" , share__required_argument, 0, 0 }, /* undocumented */
+ { "help" , share__no_argument, 0, 'h' },
+ { "explain" , share__no_argument, 0, 'H' },
+ { "version" , share__no_argument, 0, 'v' },
+ { "decode" , share__no_argument, 0, 'd' },
+ { "analyze" , share__no_argument, 0, 'a' },
+ { "test" , share__no_argument, 0, 't' },
+ { "stdout" , share__no_argument, 0, 'c' },
+ { "silent" , share__no_argument, 0, 's' },
+ { "totally-silent" , share__no_argument, 0, 0 },
+ { "warnings-as-errors" , share__no_argument, 0, 'w' },
+ { "force" , share__no_argument, 0, 'f' },
+ { "delete-input-file" , share__no_argument, 0, 0 },
+ { "keep-foreign-metadata" , share__no_argument, 0, 0 },
+ { "output-prefix" , share__required_argument, 0, 0 },
+ { "output-name" , share__required_argument, 0, 'o' },
+ { "skip" , share__required_argument, 0, 0 },
+ { "until" , share__required_argument, 0, 0 },
+ { "channel-map" , share__required_argument, 0, 0 }, /* undocumented */
/*
* decoding options
{ "no-force" , share__no_argument, 0, 0 },
{ "no-seektable" , share__no_argument, 0, 0 },
{ "no-delete-input-file" , share__no_argument, 0, 0 },
+ { "no-keep-foreign-metadata" , share__no_argument, 0, 0 },
{ "no-replay-gain" , share__no_argument, 0, 0 },
{ "no-ignore-chunk-sizes" , share__no_argument, 0, 0 },
{ "no-sector-align" , share__no_argument, 0, 0 },
FLAC__bool force_aiff_format;
FLAC__bool force_raw_format;
FLAC__bool delete_input;
+ FLAC__bool keep_foreign_metadata;
FLAC__bool replay_gain;
FLAC__bool ignore_chunk_sizes;
FLAC__bool sector_align;
* whole file.
*/
if(
- (option_values.padding >= 0 && option_values.padding < GRABBAG__REPLAYGAIN_MAX_TAG_SPACE_REQUIRED) ||
- (option_values.padding < 0 && FLAC_ENCODE__DEFAULT_PADDING < GRABBAG__REPLAYGAIN_MAX_TAG_SPACE_REQUIRED)
+ (option_values.padding >= 0 && option_values.padding < (int)GRABBAG__REPLAYGAIN_MAX_TAG_SPACE_REQUIRED) ||
+ (option_values.padding < 0 && FLAC_ENCODE__DEFAULT_PADDING < (int)GRABBAG__REPLAYGAIN_MAX_TAG_SPACE_REQUIRED)
) {
flac__utils_printf(stderr, 1, "NOTE: --replay-gain may leave a small PADDING block even with --no-padding\n");
option_values.padding = GRABBAG__REPLAYGAIN_MAX_TAG_SPACE_REQUIRED;
if(!option_values.mode_decode && 0 != option_values.cuesheet_filename && option_values.num_files > 1) {
return usage_error("ERROR: --cuesheet cannot be used when encoding multiple files\n");
}
+ if(option_values.keep_foreign_metadata) {
+ /* we're not going to try and support the re-creation of broken WAVE files */
+ if(option_values.ignore_chunk_sizes)
+ return usage_error("ERROR: using --keep-foreign-metadata cannot be used with --ignore-chunk-sizes\n");
+ /*@@@@@@*/
+ if(option_values.delete_input)
+ return usage_error("ERROR: using --delete-input-file with --keep-foreign-metadata has been disabled until more testing has been done.\n");
+ flac__utils_printf(stderr, 1, "NOTE: --keep-foreign-metadata is a new feature; make sure to test the output file before deleting the original.\n");
+ }
}
flac__utils_printf(stderr, 2, "\n");
option_values.force_aiff_format = false;
option_values.force_raw_format = false;
option_values.delete_input = false;
+ option_values.keep_foreign_metadata = false;
option_values.replay_gain = false;
option_values.ignore_chunk_sizes = false;
option_values.sector_align = false;
else if(0 == strcmp(long_option, "delete-input-file")) {
option_values.delete_input = true;
}
+ else if(0 == strcmp(long_option, "keep-foreign-metadata")) {
+ option_values.keep_foreign_metadata = true;
+ }
else if(0 == strcmp(long_option, "output-prefix")) {
FLAC__ASSERT(0 != option_argument);
option_values.output_prefix = option_argument;
else if(0 == strcmp(long_option, "no-delete-input-file")) {
option_values.delete_input = false;
}
+ else if(0 == strcmp(long_option, "no-keep-foreign-metadata")) {
+ option_values.keep_foreign_metadata = false;
+ }
else if(0 == strcmp(long_option, "no-replay-gain")) {
option_values.replay_gain = false;
}
printf(" -o, --output-name=FILENAME Force the output file name\n");
printf(" --output-prefix=STRING Prepend STRING to output names\n");
printf(" --delete-input-file Deletes after a successful encode/decode\n");
+ printf(" --keep-foreign-metadata Save/restore WAVE or AIFF non-audio chunks\n");
printf(" --skip={#|mm:ss.ss} Skip the given initial samples for each input\n");
printf(" --until={#|[+|-]mm:ss.ss} Stop at the given sample for each input file\n");
#if FLAC__HAS_OGG
printf(" --no-adaptive-mid-side\n");
printf(" --no-decode-through-errors\n");
printf(" --no-delete-input-file\n");
+ printf(" --no-keep-foreign-metadata\n");
printf(" --no-exhaustive-model-search\n");
printf(" --no-lax\n");
printf(" --no-mid-side\n");
usage_header();
usage_summary();
printf("For encoding:\n");
- printf(" The input file(s) may be a PCM RIFF WAVE file, AIFF (or uncompressed AIFF-C)\n");
+ printf(" The input file(s) may be a PCM WAVE file, AIFF (or uncompressed AIFF-C)\n");
printf(" file, or raw samples.\n");
printf(" The output file(s) will be in native FLAC or Ogg FLAC format\n");
printf("For decoding, the reverse is true.\n");
printf(" successful encode or decode. If there was an\n");
printf(" error (including a verify error) the input file\n");
printf(" is left intact.\n");
+ printf(" --keep-foreign-metadata If encoding, save WAVE or AIFF non-audio chunks\n");
+ printf(" in FLAC metadata. If decoding, restore any saved\n");
+ printf(" non-audio chunks from FLAC metadata when writing\n");
+ printf(" the decoded file. Foreign metadata cannot be\n");
+ printf(" transcoded, e.g. WAVE chunks saved in a FLAC file\n");
+ printf(" cannot be restored when decoding to AIFF. Input\n");
+ printf(" and output must be regular files.\n");
printf(" --skip={#|mm:ss.ss} Skip the first # samples of each input file; can\n");
printf(" be used both for encoding and decoding. The\n");
printf(" alternative form mm:ss.ss can be used to specify\n");
printf(" --no-adaptive-mid-side\n");
printf(" --no-decode-through-errors\n");
printf(" --no-delete-input-file\n");
+ printf(" --no-keep-foreign-metadata\n");
printf(" --no-exhaustive-model-search\n");
printf(" --no-lax\n");
printf(" --no-mid-side\n");
FILE *encode_infile;
FLAC__byte lookahead[12];
unsigned lookahead_length = 0;
- FileFormat fmt = RAW;
+ FileFormat input_format = RAW;
FLAC__bool is_aifc = false;
int retval;
off_t infilesize;
if(!option_values.force_raw_format) {
/* first set format based on name */
if(strlen(infilename) >= 4 && 0 == FLAC__STRCASECMP(infilename+(strlen(infilename)-4), ".wav"))
- fmt= WAV;
+ input_format = WAV;
else if(strlen(infilename) >= 4 && 0 == FLAC__STRCASECMP(infilename+(strlen(infilename)-4), ".aif"))
- fmt= AIF;
+ input_format = AIF;
else if(strlen(infilename) >= 5 && 0 == FLAC__STRCASECMP(infilename+(strlen(infilename)-5), ".aiff"))
- fmt= AIF;
+ input_format = AIF;
else if(strlen(infilename) >= 5 && 0 == FLAC__STRCASECMP(infilename+(strlen(infilename)-5), ".flac"))
- fmt= FLAC;
+ input_format = FLAC;
else if(strlen(infilename) >= 4 && 0 == FLAC__STRCASECMP(infilename+(strlen(infilename)-4), ".oga"))
- fmt= OGGFLAC;
+ input_format = OGGFLAC;
else if(strlen(infilename) >= 4 && 0 == FLAC__STRCASECMP(infilename+(strlen(infilename)-4), ".ogg"))
- fmt= OGGFLAC;
+ input_format = OGGFLAC;
/* attempt to guess the file type based on the first 12 bytes */
if((lookahead_length = fread(lookahead, 1, 12, encode_infile)) < 12) {
- if(fmt != RAW) {
- format_mistake(infilename, fmt, RAW);
+ if(input_format != RAW) {
+ format_mistake(infilename, input_format, RAW);
if(option_values.treat_warnings_as_errors) {
conditional_fclose(encode_infile);
return 1;
}
}
- fmt= RAW;
+ input_format = RAW;
}
else {
if(!strncmp((const char *)lookahead, "ID3", 3)) {
return 1;
}
else if(!strncmp((const char *)lookahead, "RIFF", 4) && !strncmp((const char *)lookahead+8, "WAVE", 4))
- fmt= WAV;
+ input_format = WAV;
else if(!strncmp((const char *)lookahead, "FORM", 4) && !strncmp((const char *)lookahead+8, "AIFF", 4))
- fmt= AIF;
+ input_format = AIF;
else if(!strncmp((const char *)lookahead, "FORM", 4) && !strncmp((const char *)lookahead+8, "AIFC", 4)) {
- fmt= AIF;
+ input_format = AIF;
is_aifc = true;
}
else if(!memcmp(lookahead, FLAC__STREAM_SYNC_STRING, sizeof(FLAC__STREAM_SYNC_STRING)))
- fmt= FLAC;
+ input_format = FLAC;
/* this could be made more accurate by looking at the first packet */
else if(!memcmp(lookahead, "OggS", 4))
- fmt= OGGFLAC;
+ input_format = OGGFLAC;
else {
- if(fmt != RAW) {
- format_mistake(infilename, fmt, RAW);
+ if(input_format != RAW) {
+ format_mistake(infilename, input_format, RAW);
if(option_values.treat_warnings_as_errors) {
conditional_fclose(encode_infile);
return 1;
}
}
- fmt= RAW;
+ input_format = RAW;
}
}
}
+ if(option_values.keep_foreign_metadata) {
+ if(encode_infile == stdin || option_values.force_to_stdout) {
+ conditional_fclose(encode_infile);
+ return usage_error("ERROR: --keep-foreign-metadata cannot be used when encoding from stdin or to stdout\n");
+ }
+ if(input_format != WAV && input_format != AIF) {
+ conditional_fclose(encode_infile);
+ return usage_error("ERROR: --keep-foreign-metadata can only be used with WAVE or AIFF input\n");
+ }
+ }
+
/*
* Error if output file already exists (and -f not used).
* Use grabbag__file_get_filesize() as a cheap way to check.
*/
if(!option_values.test_only && !option_values.force_file_overwrite && strcmp(outfilename, "-") && grabbag__file_get_filesize(outfilename) != (off_t)(-1)) {
- if(fmt == FLAC) {
+ if(input_format == FLAC) {
/* need more detailed error message when re-flac'ing to avoid confusing the user */
flac__utils_printf(stderr, 1,
"ERROR: output file %s already exists.\n\n"
outfilename
);
}
- else if(fmt == OGGFLAC) {
+ else if(input_format == OGGFLAC) {
/* need more detailed error message when re-flac'ing to avoid confusing the user */
flac__utils_printf(stderr, 1,
"ERROR: output file %s already exists.\n\n"
}
if(option_values.format_input_size >= 0) {
- if (fmt != RAW || infilesize >= 0) {
+ if (input_format != RAW || infilesize >= 0) {
flac__utils_printf(stderr, 1, "ERROR: can only use --input-size when encoding raw samples from stdin\n");
conditional_fclose(encode_infile);
return 1;
}
}
- if(option_values.sector_align && (fmt == FLAC || fmt == OGGFLAC)) {
+ if(option_values.sector_align && (input_format == FLAC || input_format == OGGFLAC)) {
flac__utils_printf(stderr, 1, "ERROR: can't use --sector-align when the input file is FLAC or Ogg FLAC\n");
conditional_fclose(encode_infile);
return 1;
}
- if(option_values.sector_align && fmt == RAW && infilesize < 0) {
+ if(option_values.sector_align && input_format == RAW && infilesize < 0) {
flac__utils_printf(stderr, 1, "ERROR: can't use --sector-align when the input size is unknown\n");
conditional_fclose(encode_infile);
return 1;
}
- if(fmt == RAW) {
+ if(input_format == RAW) {
if(option_values.format_is_big_endian < 0 || option_values.format_is_unsigned_samples < 0 || option_values.format_channels < 0 || option_values.format_bps < 0 || option_values.format_sample_rate < 0) {
conditional_fclose(encode_infile);
return usage_error("ERROR: for encoding a raw file you must specify a value for --endian, --sign, --channels, --bps, and --sample-rate\n");
}
}
- if(encode_infile == stdin || option_values.force_to_stdout) {
+ if(/*@@@@@@why no stdin?*/encode_infile == stdin || option_values.force_to_stdout) {
if(option_values.replay_gain) {
conditional_fclose(encode_infile);
return usage_error("ERROR: --replay-gain cannot be used when encoding to stdout\n");
strcat(internal_outfilename, tmp_suffix);
}
- if(fmt == RAW) {
+ if(input_format == RAW) {
raw_encode_options_t options;
options.common = common_options;
retval = flac__encode_raw(encode_infile, infilesize, infilename, internal_outfilename? internal_outfilename : outfilename, lookahead, lookahead_length, options);
}
- else if(fmt == FLAC || fmt == OGGFLAC) {
+ else if(input_format == FLAC || input_format == OGGFLAC) {
flac_encode_options_t options;
options.common = common_options;
- retval = flac__encode_flac(encode_infile, infilesize, infilename, internal_outfilename? internal_outfilename : outfilename, lookahead, lookahead_length, options, fmt==OGGFLAC);
+ retval = flac__encode_flac(encode_infile, infilesize, infilename, internal_outfilename? internal_outfilename : outfilename, lookahead, lookahead_length, options, input_format==OGGFLAC);
}
else {
wav_encode_options_t options;
options.common = common_options;
- if(fmt == AIF)
+ /* read foreign metadata if requested */
+ if(option_values.keep_foreign_metadata) {
+ if(0 == (options.foreign_metadata = flac__foreign_metadata_new())) {
+ flac__utils_printf(stderr, 1, "ERROR: creating foreign metadata object\n");
+ conditional_fclose(encode_infile);
+ return 1;
+ }
+ }
+
+ if(input_format == AIF)
retval = flac__encode_aif(encode_infile, infilesize, infilename, internal_outfilename? internal_outfilename : outfilename, lookahead, lookahead_length, options, is_aifc);
else
retval = flac__encode_wav(encode_infile, infilesize, infilename, internal_outfilename? internal_outfilename : outfilename, lookahead, lookahead_length, options);
+
+ if(option_values.keep_foreign_metadata)
+ flac__foreign_metadata_delete(options.foreign_metadata);
}
if(retval == 0) {
0 != (error = grabbag__replaygain_store_to_file_title(internal_outfilename? internal_outfilename : outfilename, title_gain, title_peak, /*preserve_modtime=*/true))
) {
flac__utils_printf(stderr, 1, "%s: ERROR writing ReplayGain reference/title tags (%s)\n", outfilename, error);
+ retval = 1;
}
}
if(strcmp(infilename, "-"))
{
int retval;
FLAC__bool treat_as_ogg = false;
+ FileFormat output_format = WAV;
decode_options_t common_options;
const char *outfilename = get_decoded_outfilename(infilename);
return 1;
}
+ if(option_values.force_raw_format)
+ output_format = RAW;
+ else if(
+ option_values.force_aiff_format ||
+ (strlen(outfilename) >= 4 && 0 == FLAC__STRCASECMP(outfilename+(strlen(outfilename)-4), ".aif")) ||
+ (strlen(outfilename) >= 5 && 0 == FLAC__STRCASECMP(outfilename+(strlen(outfilename)-5), ".aiff"))
+ )
+ output_format = AIF;
+ else
+ output_format = WAV;
+
if(!option_values.test_only && !option_values.analyze) {
- if(option_values.force_raw_format && (option_values.format_is_big_endian < 0 || option_values.format_is_unsigned_samples < 0))
+ if(output_format == RAW && (option_values.format_is_big_endian < 0 || option_values.format_is_unsigned_samples < 0))
return usage_error("ERROR: for decoding to a raw file you must specify a value for --endian and --sign\n");
}
+ if(option_values.keep_foreign_metadata) {
+ if(0 == strcmp(infilename, "-") || 0 == strcmp(outfilename, "-"))
+ return usage_error("ERROR: --keep-foreign-metadata cannot be used when decoding from stdin or to stdout\n");
+ if(output_format != WAV && output_format != AIF)
+ return usage_error("ERROR: --keep-foreign-metadata can only be used with WAVE or AIFF output\n");
+ }
+
if(option_values.use_ogg)
treat_as_ogg = true;
else if(strlen(infilename) >= 4 && 0 == FLAC__STRCASECMP(infilename+(strlen(infilename)-4), ".oga"))
#endif
common_options.channel_map_none = option_values.channel_map_none;
- if(!option_values.force_raw_format) {
- wav_decode_options_t options;
+ if(output_format == RAW) {
+ raw_decode_options_t options;
options.common = common_options;
+ options.is_big_endian = option_values.format_is_big_endian;
+ options.is_unsigned_samples = option_values.format_is_unsigned_samples;
- if(
- option_values.force_aiff_format ||
- (strlen(outfilename) >= 4 && 0 == FLAC__STRCASECMP(outfilename+(strlen(outfilename)-4), ".aif")) ||
- (strlen(outfilename) >= 5 && 0 == FLAC__STRCASECMP(outfilename+(strlen(outfilename)-5), ".aiff"))
- )
- retval = flac__decode_aiff(infilename, option_values.test_only? 0 : outfilename, option_values.analyze, option_values.aopts, options);
- else
- retval = flac__decode_wav(infilename, option_values.test_only? 0 : outfilename, option_values.analyze, option_values.aopts, options);
+ retval = flac__decode_raw(infilename, option_values.test_only? 0 : outfilename, option_values.analyze, option_values.aopts, options);
}
else {
- raw_decode_options_t options;
+ wav_decode_options_t options;
options.common = common_options;
- options.is_big_endian = option_values.format_is_big_endian;
- options.is_unsigned_samples = option_values.format_is_unsigned_samples;
- retval = flac__decode_raw(infilename, option_values.test_only? 0 : outfilename, option_values.analyze, option_values.aopts, options);
+ /* read foreign metadata if requested */
+ if(option_values.keep_foreign_metadata) {
+ if(0 == (options.foreign_metadata = flac__foreign_metadata_new())) {
+ flac__utils_printf(stderr, 1, "ERROR: creating foreign metadata object\n");
+ return 1;
+ }
+ }
+
+ if(output_format == AIF)
+ retval = flac__decode_aiff(infilename, option_values.test_only? 0 : outfilename, option_values.analyze, option_values.aopts, options);
+ else
+ retval = flac__decode_wav(infilename, option_values.test_only? 0 : outfilename, option_values.analyze, option_values.aopts, options);
+
+ if(option_values.keep_foreign_metadata)
+ flac__foreign_metadata_delete(options.foreign_metadata);
}
if(retval == 0 && strcmp(infilename, "-")) {
projects / platform / upstream / flac.git / commitdiff