+FLAC__bool canonicalize_until_specification(utils__SkipUntilSpecification *spec, const char *inbasefilename, unsigned sample_rate, FLAC__uint64 skip, FLAC__uint64 total_samples_in_input)
+{
+ /* convert from mm:ss.sss to sample number if necessary */
+ flac__utils_canonicalize_skip_until_specification(spec, sample_rate);
+
+ /* special case: if "--until=-0", use the special value '0' to mean "end-of-stream" */
+ if(spec->is_relative && spec->value.samples == 0) {
+ spec->is_relative = false;
+ return true;
+ }
+
+ /* in any other case the total samples in the input must be known */
+ if(total_samples_in_input == 0) {
+ flac__utils_printf(stderr, 1, "%s: ERROR, cannot use --until when FLAC metadata has total sample count of 0\n", inbasefilename);
+ return false;
+ }
+
+ FLAC__ASSERT(spec->value_is_samples);
+
+ /* convert relative specifications to absolute */
+ if(spec->is_relative) {
+ if(spec->value.samples <= 0)
+ spec->value.samples += (FLAC__int64)total_samples_in_input;
+ else
+ spec->value.samples += skip;
+ spec->is_relative = false;
+ }
+
+ /* error check */
+ if(spec->value.samples < 0) {
+ flac__utils_printf(stderr, 1, "%s: ERROR, --until value is before beginning of input\n", inbasefilename);
+ return false;
+ }
+ if((FLAC__uint64)spec->value.samples <= skip) {
+ flac__utils_printf(stderr, 1, "%s: ERROR, --until value is before --skip point\n", inbasefilename);
+ return false;
+ }
+ if((FLAC__uint64)spec->value.samples > total_samples_in_input) {
+ flac__utils_printf(stderr, 1, "%s: ERROR, --until value is after end of input\n", inbasefilename);
+ return false;
+ }
+
+ return true;
+}
+
+FLAC__bool write_iff_headers(FILE *f, DecoderSession *decoder_session, FLAC__uint64 samples)
+{
+ const FileFormat format = decoder_session->format;
+ const char *fmt_desc =
+ format==FORMAT_WAVE? "WAVE" :
+ format==FORMAT_WAVE64? "Wave64" :
+ format==FORMAT_RF64? "RF64" :
+ "AIFF";
+ const FLAC__bool is_waveformatextensible =
+ (format == FORMAT_WAVE || format == FORMAT_WAVE64 || format == FORMAT_RF64) &&
+ (
+ decoder_session->channel_mask == 2 ||
+ decoder_session->channel_mask > 3 ||
+ decoder_session->bps%8 ||
+ decoder_session->channels > 2
+ );
+ const FLAC__uint64 data_size = samples * decoder_session->channels * ((decoder_session->bps+7)/8);
+ const FLAC__uint64 aligned_data_size =
+ format == FORMAT_WAVE64?
+ (data_size+7) & (~(FLAC__uint64)7) :
+ (data_size+1) & (~(FLAC__uint64)1);
+
+ FLAC__uint64 iff_size;
+ unsigned foreign_metadata_size = 0; /* size of all non-audio non-fmt/COMM foreign metadata chunks */
+ foreign_metadata_t *fm = decoder_session->foreign_metadata;
+ size_t i;
+
+ FLAC__ASSERT(
+ format == FORMAT_WAVE ||
+ format == FORMAT_WAVE64 ||
+ format == FORMAT_RF64 ||
+ format == FORMAT_AIFF ||
+ format == FORMAT_AIFF_C
+ );
+
+ if(samples == 0) {
+ if(f == stdout) {
+ flac__utils_printf(stderr, 1, "%s: WARNING, don't have accurate sample count available for %s header.\n", decoder_session->inbasefilename, fmt_desc);
+ flac__utils_printf(stderr, 1, " Generated %s file will have a data chunk size of 0. Try\n", fmt_desc);
+ flac__utils_printf(stderr, 1, " decoding directly to a file instead.\n");
+ if(decoder_session->treat_warnings_as_errors)
+ return false;
+ }
+ else {
+ decoder_session->iff_headers_need_fixup = true;
+ }
+ }
+
+ if(fm) {
+ FLAC__ASSERT(fm->format_block);
+ FLAC__ASSERT(fm->audio_block);
+ FLAC__ASSERT(fm->format_block < fm->audio_block);
+ /* calc foreign metadata size; we always skip the first chunk, ds64 chunk, format chunk, and sound chunk since we write our own */
+ for(i = format==FORMAT_RF64?2:1; i < fm->num_blocks; i++) {
+ if(i != fm->format_block && i != fm->audio_block)
+ foreign_metadata_size += fm->blocks[i].size;
+ }
+ }
+
+ if(samples == 0)
+ iff_size = 0;
+ else if(format == FORMAT_WAVE || format == FORMAT_RF64)
+ /* 4 for WAVE form bytes */
+ /* +{36,0} for ds64 chunk */
+ /* +8+{40,16} for fmt chunk header and body */
+ /* +8 for data chunk header */
+ iff_size = 4 + (format==FORMAT_RF64?36:0) + 8+(is_waveformatextensible?40:16) + 8 + foreign_metadata_size + aligned_data_size;
+ else if(format == FORMAT_WAVE64)
+ /* 16+8 for RIFF GUID and size field */
+ /* +16 for WAVE GUID */
+ /* +16+8+{40,16} for fmt chunk header (GUID and size field) and body */
+ /* +16+8 for data chunk header (GUID and size field) */
+ iff_size = 16+8 + 16 + 16+8+(is_waveformatextensible?40:16) + 16+8 + foreign_metadata_size + aligned_data_size;
+ else /* AIFF */
+ iff_size = 46 + foreign_metadata_size + aligned_data_size;
+
+ if(format != FORMAT_WAVE64 && format != FORMAT_RF64 && iff_size >= 0xFFFFFFF4) {
+ flac__utils_printf(stderr, 1, "%s: ERROR: stream is too big to fit in a single %s file\n", decoder_session->inbasefilename, fmt_desc);
+ return false;
+ }
+
+ if(format == FORMAT_WAVE || format == FORMAT_WAVE64 || format == FORMAT_RF64) {
+ /* RIFF header */
+ switch(format) {
+ case FORMAT_WAVE:
+ if(flac__utils_fwrite("RIFF", 1, 4, f) != 4)
+ return false;
+ if(!write_little_endian_uint32(f, (FLAC__uint32)iff_size)) /* filesize-8 */
+ return false;
+ if(flac__utils_fwrite("WAVE", 1, 4, f) != 4)
+ return false;
+ break;
+ case FORMAT_WAVE64:
+ /* RIFF GUID 66666972-912E-11CF-A5D6-28DB04C10000 */
+ if(flac__utils_fwrite("\x72\x69\x66\x66\x2E\x91\xCF\x11\xD6\xA5\x28\xDB\x04\xC1\x00\x00", 1, 16, f) != 16)
+ return false;
+ if(!write_little_endian_uint64(f, iff_size))
+ return false;
+ /* WAVE GUID 65766177-ACF3-11D3-8CD1-00C04F8EDB8A */
+ if(flac__utils_fwrite("\x77\x61\x76\x65\xF3\xAC\xD3\x11\xD1\x8C\x00\xC0\x4F\x8E\xDB\x8A", 1, 16, f) != 16)
+ return false;
+ break;
+ case FORMAT_RF64:
+ if(flac__utils_fwrite("RF64", 1, 4, f) != 4)
+ return false;
+ if(!write_little_endian_uint32(f, 0xffffffff))
+ return false;
+ if(flac__utils_fwrite("WAVE", 1, 4, f) != 4)
+ return false;
+ break;
+ default:
+ return false;
+ }
+
+ /* ds64 chunk for RF64 */
+ if(format == FORMAT_RF64) {
+ if(flac__utils_fwrite("ds64", 1, 4, f) != 4)
+ return false;
+
+ if(!write_little_endian_uint32(f, 28)) /* chunk size */
+ return false;
+
+ if(!write_little_endian_uint64(f, iff_size))
+ return false;
+
+ if(!write_little_endian_uint64(f, data_size))
+ return false;
+
+ if(!write_little_endian_uint64(f, samples)) /*@@@@@@ correct? */
+ return false;
+
+ if(!write_little_endian_uint32(f, 0)) /* table size */
+ return false;
+ }
+
+ decoder_session->fm_offset1 = ftello(f);
+
+ if(fm) {
+ /* seek forward to {allocate} or {skip over already-written chunks} before "fmt " */
+ for(i = format==FORMAT_RF64?2:1; i < fm->format_block; i++) {
+ if(fseeko(f, fm->blocks[i].size, SEEK_CUR) < 0) {
+ flac__utils_printf(stderr, 1, "%s: ERROR: allocating/skipping foreign metadata before \"fmt \"\n", decoder_session->inbasefilename);
+ return false;
+ }
+ }
+ }
+
+ if(format != FORMAT_WAVE64) {
+ if(flac__utils_fwrite("fmt ", 1, 4, f) != 4)
+ return false;
+ if(!write_little_endian_uint32(f, is_waveformatextensible? 40 : 16)) /* chunk size */
+ return false;
+ }
+ else { /* Wave64 */
+ /* fmt GUID 20746D66-ACF3-11D3-8CD1-00C04F8EDB8A */
+ if(flac__utils_fwrite("\x66\x6D\x74\x20\xF3\xAC\xD3\x11\xD1\x8C\x00\xC0\x4F\x8E\xDB\x8A", 1, 16, f) != 16)
+ return false;
+ /* chunk size (+16+8 for GUID and size fields) */
+ if(!write_little_endian_uint64(f, 16+8+(is_waveformatextensible?40:16)))
+ return false;
+ }
+
+ if(!write_riff_wave_fmt_chunk_body(f, is_waveformatextensible, decoder_session->bps, decoder_session->channels, decoder_session->sample_rate, decoder_session->channel_mask))
+ return false;
+
+ decoder_session->fm_offset2 = ftello(f);
+
+ if(fm) {
+ /* seek forward to {allocate} or {skip over already-written chunks} after "fmt " but before "data" */
+ for(i = fm->format_block+1; i < fm->audio_block; i++) {
+ if(fseeko(f, fm->blocks[i].size, SEEK_CUR) < 0) {
+ flac__utils_printf(stderr, 1, "%s: ERROR: allocating/skipping foreign metadata after \"fmt \"\n", decoder_session->inbasefilename);
+ return false;
+ }
+ }
+ }
+
+ if(format != FORMAT_WAVE64) {
+ if(flac__utils_fwrite("data", 1, 4, f) != 4)
+ return false;
+ if(!write_little_endian_uint32(f, format==FORMAT_RF64? 0xffffffff : (FLAC__uint32)data_size))
+ return false;
+ }
+ else { /* Wave64 */
+ /* data GUID 61746164-ACF3-11D3-8CD1-00C04F8EDB8A */
+ if(flac__utils_fwrite("\x64\x61\x74\x61\xF3\xAC\xD3\x11\xD1\x8C\x00\xC0\x4F\x8E\xDB\x8A", 1, 16, f) != 16)
+ return false;
+ /* +16+8 for GUID and size fields */
+ if(!write_little_endian_uint64(f, 16+8 + data_size))
+ return false;
+ }
+
+ decoder_session->fm_offset3 = ftello(f) + aligned_data_size;
+ }
+ else {
+ if(flac__utils_fwrite("FORM", 1, 4, f) != 4)
+ return false;
+
+ if(!write_big_endian_uint32(f, (FLAC__uint32)iff_size)) /* filesize-8 */
+ return false;
+
+ if(flac__utils_fwrite("AIFF", 1, 4, f) != 4)
+ return false;
+
+ decoder_session->fm_offset1 = ftello(f);
+
+ if(fm) {
+ /* seek forward to {allocate} or {skip over already-written chunks} before "COMM" */
+ for(i = 1; i < fm->format_block; i++) {
+ if(fseeko(f, fm->blocks[i].size, SEEK_CUR) < 0) {
+ flac__utils_printf(stderr, 1, "%s: ERROR: allocating/skipping foreign metadata before \"COMM\"\n", decoder_session->inbasefilename);
+ return false;
+ }
+ }
+ }
+
+ if(!write_aiff_form_comm_chunk(f, samples, decoder_session->bps, decoder_session->channels, decoder_session->sample_rate))
+ return false;
+
+ decoder_session->fm_offset2 = ftello(f);
+
+ if(fm) {
+ /* seek forward to {allocate} or {skip over already-written chunks} after "COMM" but before "SSND" */
+ for(i = fm->format_block+1; i < fm->audio_block; i++) {
+ if(fseeko(f, fm->blocks[i].size, SEEK_CUR) < 0) {
+ flac__utils_printf(stderr, 1, "%s: ERROR: allocating/skipping foreign metadata after \"COMM\"\n", decoder_session->inbasefilename);
+ return false;
+ }
+ }
+ }
+
+ if(flac__utils_fwrite("SSND", 1, 4, f) != 4)
+ return false;
+
+ if(!write_big_endian_uint32(f, (FLAC__uint32)data_size + 8)) /* data size */
+ return false;
+
+ if(!write_big_endian_uint32(f, 0/*offset_size*/))
+ return false;
+
+ if(!write_big_endian_uint32(f, 0/*block_size*/))
+ return false;
+
+ decoder_session->fm_offset3 = ftello(f) + aligned_data_size;
+ }
+
+ return true;
+}
+
+FLAC__bool write_riff_wave_fmt_chunk_body(FILE *f, FLAC__bool is_waveformatextensible, unsigned bps, unsigned channels, unsigned sample_rate, FLAC__uint32 channel_mask)
+{
+ if(!write_little_endian_uint16(f, (FLAC__uint16)(is_waveformatextensible? 65534 : 1))) /* compression code */
+ return false;
+
+ if(!write_little_endian_uint16(f, (FLAC__uint16)channels))
+ return false;
+
+ if(!write_little_endian_uint32(f, sample_rate))
+ return false;
+
+ if(!write_little_endian_uint32(f, sample_rate * channels * ((bps+7) / 8)))
+ return false;
+
+ if(!write_little_endian_uint16(f, (FLAC__uint16)(channels * ((bps+7) / 8)))) /* block align */
+ return false;
+
+ if(!write_little_endian_uint16(f, (FLAC__uint16)(((bps+7)/8)*8))) /* bits per sample */
+ return false;
+
+ if(is_waveformatextensible) {
+ if(!write_little_endian_uint16(f, (FLAC__uint16)22)) /* cbSize */
+ return false;
+
+ if(!write_little_endian_uint16(f, (FLAC__uint16)bps)) /* validBitsPerSample */
+ return false;
+
+ if(!write_little_endian_uint32(f, channel_mask))
+ return false;
+
+ /* GUID = {0x00000001, 0x0000, 0x0010, {0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}} */
+ if(flac__utils_fwrite("\x01\x00\x00\x00\x00\x00\x10\x00\x80\x00\x00\xaa\x00\x38\x9b\x71", 1, 16, f) != 16)
+ return false;
+ }
+
+ return true;
+}
+
+FLAC__bool write_aiff_form_comm_chunk(FILE *f, FLAC__uint64 samples, unsigned bps, unsigned channels, unsigned sample_rate)
+{
+ FLAC__ASSERT(samples <= 0xffffffff);
+
+ if(flac__utils_fwrite("COMM", 1, 4, f) != 4)
+ return false;
+
+ if(!write_big_endian_uint32(f, 18)) /* chunk size = 18 */
+ return false;
+
+ if(!write_big_endian_uint16(f, (FLAC__uint16)channels))
+ return false;
+
+ if(!write_big_endian_uint32(f, (FLAC__uint32)samples))
+ return false;
+
+ if(!write_big_endian_uint16(f, (FLAC__uint16)bps))
+ return false;
+
+ if(!write_sane_extended(f, sample_rate))
+ return false;
+
+ return true;
+}
+