claunia/flac
1
0
Fork 0
mirror of https://github.com/claunia/flac.git synced 2025-12-16 18:54:26 +00:00
Code Issues Packages Projects Releases Wiki Activity

finish implementation

Browse Source
This commit is contained in:
Josh Coalson
2002-08-01 07:34:12 +00:00
parent 08a6282be2
commit 312438fc61
2 changed files with 45 additions and 197 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
include/FLAC/file_encoder.h
View File

@@ -453,6 +453,19 @@ FLAC__FileEncoderState FLAC__file_encoder_get_state(const FLAC__FileEncoder *enc
*/ */
FLAC__SeekableStreamEncoderState FLAC__file_encoder_get_seekable_stream_encoder_state(const FLAC__FileEncoder *encoder); FLAC__SeekableStreamEncoderState FLAC__file_encoder_get_seekable_stream_encoder_state(const FLAC__FileEncoder *encoder);
/** Get the state of the underlying stream encoder.
* Useful when the file encoder state is
* \c FLAC__FILE_ENCODER_SEEKABLE_STREAM_ENCODER_ERROR and the seekable stream
* encoder state is \c FLAC__SEEKABLE_STREAM_ENCODER_STREAM_ENCODER_ERROR.
*
* \param encoder An encoder instance to query.
* \assert
* \code encoder != NULL \endcode
* \retval FLAC__SeekableStreamEncoderState
* The seekable stream encoder state.
*/
FLAC__StreamEncoderState FLAC__file_encoder_get_stream_encoder_state(const FLAC__FileEncoder *encoder);
/** Get the "streamable subset" flag. /** Get the "streamable subset" flag.
* This is inherited from FLAC__SeekableStreamEncoder; see * This is inherited from FLAC__SeekableStreamEncoder; see
* FLAC__seekable_stream_encoder_get_streamable_subset(). * FLAC__seekable_stream_encoder_get_streamable_subset().

229
src/libFLAC/file_encoder.c
View File

@@ -31,8 +31,8 @@
***********************************************************************/ ***********************************************************************/
static void set_defaults_(FLAC__FileEncoder *encoder); static void set_defaults_(FLAC__FileEncoder *encoder);
static FLAC__StreamEncoderWriteStatus file_encoder_write_callback_(const FLAC__StreamEncoder *encoder, const FLAC__byte buffer[], unsigned bytes, unsigned samples, unsigned current_frame, void *client_data); static FLAC__SeekableStreamEncoderSeekStatus seek_callback_(const FLAC__SeekableStreamEncoder *encoder, FLAC__uint64 absolute_byte_offset, void *client_data);
static void file_encoder_metadata_callback_(const FLAC__StreamEncoder *encoder, const FLAC__StreamMetadata *metadata, void *client_data); static FLAC__StreamEncoderWriteStatus write_callback_(const FLAC__SeekableStreamEncoder *encoder, const FLAC__byte buffer[], unsigned bytes, unsigned samples, unsigned current_frame, void *client_data);
/*********************************************************************** /***********************************************************************
* *
@@ -69,6 +69,7 @@ const char * const FLAC__FileEncoderStateString[] = {
* Class constructor/destructor * Class constructor/destructor
* *
***********************************************************************/ ***********************************************************************/
FLAC__FileEncoder *FLAC__file_encoder_new() FLAC__FileEncoder *FLAC__file_encoder_new()
{ {
FLAC__FileEncoder *encoder; FLAC__FileEncoder *encoder;
@@ -141,19 +142,19 @@ FLAC__FileEncoderState FLAC__file_encoder_init(FLAC__FileEncoder *encoder)
if(0 == encoder->private_->filename) if(0 == encoder->private_->filename)
return encoder->protected_->state = FLAC__FILE_ENCODER_NO_FILENAME; return encoder->protected_->state = FLAC__FILE_ENCODER_NO_FILENAME;
encoder->private_->file = fopen(encoder->private_->filename, "wb"); encoder->private_->file = fopen(encoder->private_->filename, "w+b");
if(encoder->private_->file == 0) if(encoder->private_->file == 0)
return encoder->protected_->state = FLAC__FILE_ENCODER_ERROR_OPENING_FILE; return encoder->protected_->state = FLAC__FILE_ENCODER_ERROR_OPENING_FILE;
FLAC__seekable_stream_encoder_set_seek_callback(encoder->private_->seekable_stream_encoder, seek_callback_);
FLAC__seekable_stream_encoder_set_write_callback(encoder->private_->seekable_stream_encoder, write_callback_); FLAC__seekable_stream_encoder_set_write_callback(encoder->private_->seekable_stream_encoder, write_callback_);
FLAC__seekable_stream_encoder_set_metadata_callback(encoder->private_->seekable_stream_encoder, metadata_callback_);
FLAC__seekable_stream_encoder_set_client_data(encoder->private_->seekable_stream_encoder, encoder); FLAC__seekable_stream_encoder_set_client_data(encoder->private_->seekable_stream_encoder, encoder);
if(FLAC__seekable_seekable_stream_encoder_init(encoder->private_->seekable_stream_encoder) != FLAC__SEEKABLE_STREAM_ENCODER_OK) if(FLAC__seekable_stream_encoder_init(encoder->private_->seekable_stream_encoder) != FLAC__SEEKABLE_STREAM_ENCODER_OK)
return encoder->protected_->state = FLAC__FILE_ENCODER_SEEKABLE_STREAM_ENCODER_ERROR; return encoder->protected_->state = FLAC__FILE_ENCODER_SEEKABLE_STREAM_ENCODER_ERROR;
return decoder->protected_->state = FLAC__FILE_ENCODER_OK; return encoder->protected_->state = FLAC__FILE_ENCODER_OK;
} }
void FLAC__file_encoder_finish(FLAC__FileEncoder *encoder) void FLAC__file_encoder_finish(FLAC__FileEncoder *encoder)
@@ -366,7 +367,7 @@ FLAC__bool FLAC__file_encoder_set_metadata(FLAC__FileEncoder *encoder, FLAC__Str
FLAC__ASSERT(0 != encoder->private_->seekable_stream_encoder); FLAC__ASSERT(0 != encoder->private_->seekable_stream_encoder);
if(encoder->protected_->state != FLAC__FILE_ENCODER_UNINITIALIZED) if(encoder->protected_->state != FLAC__FILE_ENCODER_UNINITIALIZED)
return false; return false;
return FLAC__seekable_stream_encoder_set_metadata(encoder->private_->stream_encoder, value); return FLAC__seekable_stream_encoder_set_metadata(encoder->private_->seekable_stream_encoder, metadata, num_blocks);
} }
FLAC__bool FLAC__file_encoder_set_filename(FLAC__FileEncoder *encoder, const char *value) FLAC__bool FLAC__file_encoder_set_filename(FLAC__FileEncoder *encoder, const char *value)
@@ -396,13 +397,20 @@ FLAC__FileEncoderState FLAC__file_encoder_get_state(const FLAC__FileEncoder *enc
return encoder->protected_->state; return encoder->protected_->state;
} }
FLAC__FileEncoderState FLAC__file_encoder_get_seekable_stream_encoder_state(const FLAC__FileEncoder *encoder) FLAC__SeekableStreamEncoderState FLAC__file_encoder_get_seekable_stream_encoder_state(const FLAC__FileEncoder *encoder)
{ {
FLAC__ASSERT(0 != encoder); FLAC__ASSERT(0 != encoder);
FLAC__ASSERT(0 != encoder->private_); FLAC__ASSERT(0 != encoder->private_);
return FLAC__seekable_stream_encoder_get_state(encoder->private_->seekable_stream_encoder); return FLAC__seekable_stream_encoder_get_state(encoder->private_->seekable_stream_encoder);
} }
FLAC__StreamEncoderState FLAC__file_encoder_get_stream_encoder_state(const FLAC__FileEncoder *encoder)
{
FLAC__ASSERT(0 != encoder);
FLAC__ASSERT(0 != encoder->private_);
return FLAC__seekable_stream_encoder_get_stream_encoder_state(encoder->private_->seekable_stream_encoder);
}
FLAC__bool FLAC__file_encoder_get_streamable_subset(const FLAC__FileEncoder *encoder) FLAC__bool FLAC__file_encoder_get_streamable_subset(const FLAC__FileEncoder *encoder)
{ {
FLAC__ASSERT(0 != encoder); FLAC__ASSERT(0 != encoder);
@@ -523,6 +531,7 @@ FLAC__bool FLAC__file_encoder_process_interleaved(FLAC__FileEncoder *encoder, co
return FLAC__seekable_stream_encoder_process_interleaved(encoder->private_->seekable_stream_encoder, buffer, samples); return FLAC__seekable_stream_encoder_process_interleaved(encoder->private_->seekable_stream_encoder, buffer, samples);
} }
/*********************************************************************** /***********************************************************************
* *
* Private class methods * Private class methods
@@ -533,208 +542,34 @@ void set_defaults_(FLAC__FileEncoder *encoder)
{ {
FLAC__ASSERT(0 != encoder); FLAC__ASSERT(0 != encoder);
FLAC__ASSERT(0 != encoder->private_); FLAC__ASSERT(0 != encoder->private_);
FLAC__ASSERT(0 != encoder->protected_);
encoder->protected_->filename = 0; encoder->private_->filename = 0;
} }
FLAC__StreamEncoderWriteStatus file_encoder_write_callback_(const FLAC__StreamEncoder *encoder, const FLAC__byte buffer[], unsigned bytes, unsigned samples, unsigned current_frame, void *client_data) FLAC__SeekableStreamEncoderSeekStatus seek_callback_(const FLAC__SeekableStreamEncoder *encoder, FLAC__uint64 absolute_byte_offset, void *client_data)
{ {
FLAC__FileEncoder *file_encoder = (FLAC__FileEncoder*)client_data; FLAC__FileEncoder *file_encoder = (FLAC__FileEncoder*)client_data;
/* mark the current seek point if hit (if stream_offset == 0 that means we're still writing metadata and haven't hit the first frame yet) */ (void)encoder;
if(file_encoder->private_->stream_offset > 0 && file_encoder->private_->seek_table.num_points > 0) {
FLAC__uint64 current_sample = (FLAC__uint64)current_frame * (FLAC__uint64)FLAC__stream_encoder_get_blocksize(encoder), test_sample;
unsigned i;
for(i = file_encoder->private_->first_seek_point_to_check; i < file_encoder->private_->seek_table.num_points; i++) {
test_sample = file_encoder->private_->seek_table.points[i].sample_number;
if(test_sample > current_sample) {
break;
}
else if(test_sample == current_sample) {
file_encoder->private_->seek_table.points[i].stream_offset = file_encoder->private_->bytes_written - file_encoder->private_->stream_offset;
file_encoder->private_->seek_table.points[i].frame_samples = FLAC__stream_encoder_get_blocksize(encoder);
file_encoder->private_->first_seek_point_to_check++;
break;
}
else {
file_encoder->private_->first_seek_point_to_check++;
}
}
}
file_encoder->private_->bytes_written += bytes; FLAC__ASSERT(0 != file_encoder);
file_encoder->private_->samples_written += samples;
file_encoder->private_->current_frame = current_frame;
if(samples && file_encoder->private_->verbose && file_encoder->private_->total_samples_to_encode > 0 && !(current_frame & mask)) if(fseek(file_encoder->private_->file, absolute_byte_offset, SEEK_SET) < 0)
print_stats(file_encoder->private_); return FLAC__SEEKABLE_STREAM_ENCODER_SEEK_STATUS_ERROR;
if(file_encoder->private_->verify) {
file_encoder->private_->verify_fifo.encoded_signal = buffer;
file_encoder->private_->verify_fifo.encoded_bytes = bytes;
if(file_encoder->private_->verify_fifo.into_frames) {
if(!FLAC__stream_decoder_process_one_frame(file_encoder->private_->verify_fifo.decoder)) {
file_encoder->private_->verify_fifo.result = FLAC__VERIFY_FAILED_IN_FRAME;
return FLAC__STREAM_ENCODER_WRITE_FATAL_ERROR;
}
}
else {
if(!FLAC__stream_decoder_process_metadata(file_encoder->private_->verify_fifo.decoder)) {
file_encoder->private_->verify_fifo.result = FLAC__VERIFY_FAILED_IN_METADATA;
return FLAC__STREAM_ENCODER_WRITE_FATAL_ERROR;
}
}
}
#ifdef FLAC__HAS_OGG
if(file_encoder->private_->use_ogg) {
ogg_packet op;
memset(&op, 0, sizeof(op));
op.packet = (unsigned char *)buffer;
op.granulepos = file_encoder->private_->samples_written - 1;
/*@@@ WATCHOUT:
* this depends on the behavior of libFLAC that we will get one
* write_callback first with all the metadata (and 'samples'
* will be 0), then one write_callback for each frame.
*/
op.packetno = (samples == 0? -1 : (int)file_encoder->private_->current_frame);
op.bytes = bytes;
if (file_encoder->private_->bytes_written == bytes)
op.b_o_s = 1;
if (file_encoder->private_->total_samples_to_encode == file_encoder->private_->samples_written)
op.e_o_s = 1;
ogg_stream_packetin(&file_encoder->private_->ogg.os, &op);
while(ogg_stream_pageout(&file_encoder->private_->ogg.os, &file_encoder->private_->ogg.og) != 0) {
int written;
written = fwrite(file_encoder->private_->ogg.og.header, 1, file_encoder->private_->ogg.og.header_len, file_encoder->private_->fout);
if (written != file_encoder->private_->ogg.og.header_len)
return FLAC__STREAM_ENCODER_WRITE_FATAL_ERROR;
written = fwrite(file_encoder->private_->ogg.og.body, 1, file_encoder->private_->ogg.og.body_len, file_encoder->private_->fout);
if (written != file_encoder->private_->ogg.og.body_len)
return FLAC__STREAM_ENCODER_WRITE_FATAL_ERROR;
}
return FLAC__STREAM_ENCODER_WRITE_OK;
}
else else
#endif return FLAC__SEEKABLE_STREAM_ENCODER_SEEK_STATUS_OK;
{
if(fwrite(buffer, sizeof(FLAC__byte), bytes, file_encoder->private_->fout) == bytes)
return FLAC__STREAM_ENCODER_WRITE_OK;
else
return FLAC__STREAM_ENCODER_WRITE_FATAL_ERROR;
}
} }
void file_encoder_metadata_callback_(const FLAC__StreamEncoder *encoder, const FLAC__StreamMetadata *metadata, void *client_data) FLAC__StreamEncoderWriteStatus write_callback_(const FLAC__SeekableStreamEncoder *encoder, const FLAC__byte buffer[], unsigned bytes, unsigned samples, unsigned current_frame, void *client_data)
{ {
file_encoder->private_ *file_encoder->private_ = (file_encoder->private_ *)client_data; FLAC__FileEncoder *file_encoder = (FLAC__FileEncoder*)client_data;
FLAC__byte b;
FILE *f = file_encoder->private_->fout;
const FLAC__uint64 samples = metadata->data.stream_info.total_samples;
const unsigned min_framesize = metadata->data.stream_info.min_framesize;
const unsigned max_framesize = metadata->data.stream_info.max_framesize;
FLAC__ASSERT(metadata->type == FLAC__METADATA_TYPE_STREAMINFO); (void)encoder, (void)samples, (void)current_frame;
/* FLAC__ASSERT(0 != file_encoder);
* If we are writing to an ogg stream, there is no need to go back
* and update the STREAMINFO or SEEKTABLE blocks; the values we would
* update are not necessary with Ogg as the transport. We can't do
* it reliably anyway without knowing the Ogg structure.
*/
#ifdef FLAC__HAS_OGG
if(file_encoder->private_->use_ogg)
return;
#endif
/* if(fwrite(buffer, sizeof(FLAC__byte), bytes, file_encoder->private_->file) == bytes)
* we get called by the encoder when the encoding process has return FLAC__STREAM_ENCODER_WRITE_STATUS_OK;
* finished so that we can update the STREAMINFO and SEEKTABLE else
* blocks. return FLAC__STREAM_ENCODER_WRITE_STATUS_FATAL_ERROR;
*/
(void)encoder; /* silence compiler warning about unused parameter */
if(f != stdout) {
fclose(file_encoder->private_->fout);
if(0 == (f = fopen(file_encoder->private_->outfilename, "r+b")))
return;
}
/* all this is based on intimate knowledge of the stream header
* layout, but a change to the header format that would break this
* would also break all streams encoded in the previous format.
*/
if(-1 == fseek(f, 26, SEEK_SET)) goto end_;
fwrite(metadata->data.stream_info.md5sum, 1, 16, f);
/* if we get this far we know we can seek so no need to check the
* return value from fseek()
*/
fseek(f, 21, SEEK_SET);
if(fread(&b, 1, 1, f) != 1) goto framesize_;
fseek(f, 21, SEEK_SET);
b = (b & 0xf0) | (FLAC__byte)((samples >> 32) & 0x0F);
if(fwrite(&b, 1, 1, f) != 1) goto framesize_;
b = (FLAC__byte)((samples >> 24) & 0xFF);
if(fwrite(&b, 1, 1, f) != 1) goto framesize_;
b = (FLAC__byte)((samples >> 16) & 0xFF);
if(fwrite(&b, 1, 1, f) != 1) goto framesize_;
b = (FLAC__byte)((samples >> 8) & 0xFF);
if(fwrite(&b, 1, 1, f) != 1) goto framesize_;
b = (FLAC__byte)(samples & 0xFF);
if(fwrite(&b, 1, 1, f) != 1) goto framesize_;
framesize_:
fseek(f, 12, SEEK_SET);
b = (FLAC__byte)((min_framesize >> 16) & 0xFF);
if(fwrite(&b, 1, 1, f) != 1) goto seektable_;
b = (FLAC__byte)((min_framesize >> 8) & 0xFF);
if(fwrite(&b, 1, 1, f) != 1) goto seektable_;
b = (FLAC__byte)(min_framesize & 0xFF);
if(fwrite(&b, 1, 1, f) != 1) goto seektable_;
b = (FLAC__byte)((max_framesize >> 16) & 0xFF);
if(fwrite(&b, 1, 1, f) != 1) goto seektable_;
b = (FLAC__byte)((max_framesize >> 8) & 0xFF);
if(fwrite(&b, 1, 1, f) != 1) goto seektable_;
b = (FLAC__byte)(max_framesize & 0xFF);
if(fwrite(&b, 1, 1, f) != 1) goto seektable_;
seektable_:
if(file_encoder->private_->seek_table.num_points > 0) {
long pos;
unsigned i;
/* convert any unused seek points to placeholders */
for(i = 0; i < file_encoder->private_->seek_table.num_points; i++) {
if(file_encoder->private_->seek_table.points[i].sample_number == FLAC__STREAM_METADATA_SEEKPOINT_PLACEHOLDER)
break;
else if(file_encoder->private_->seek_table.points[i].frame_samples == 0)
file_encoder->private_->seek_table.points[i].sample_number = FLAC__STREAM_METADATA_SEEKPOINT_PLACEHOLDER;
}
/* the offset of the seek table data 'pos' should be after then stream sync and STREAMINFO block and SEEKTABLE header */
pos = (FLAC__STREAM_SYNC_LEN + FLAC__STREAM_METADATA_IS_LAST_LEN + FLAC__STREAM_METADATA_TYPE_LEN + FLAC__STREAM_METADATA_LENGTH_LEN) / 8;
pos += metadata->length;
pos += (FLAC__STREAM_METADATA_IS_LAST_LEN + FLAC__STREAM_METADATA_TYPE_LEN + FLAC__STREAM_METADATA_LENGTH_LEN) / 8;
fseek(f, pos, SEEK_SET);
for(i = 0; i < file_encoder->private_->seek_table.num_points; i++) {
if(!write_big_endian_uint64(f, file_encoder->private_->seek_table.points[i].sample_number)) goto end_;
if(!write_big_endian_uint64(f, file_encoder->private_->seek_table.points[i].stream_offset)) goto end_;
if(!write_big_endian_uint16(f, (FLAC__uint16)file_encoder->private_->seek_table.points[i].frame_samples)) goto end_;
}
}
end_:
fclose(f);
return;
} }