Hi List,
I recently was assigned a task to port FLAC Encoder to our embedded
platform. Thanks to OO-like design of the libFLAC and throught
documentation, that porting went like a charm. I had some problems with
chmod/chown like routines while porting but I was able to safely remove that
piece of code without any trouble.
I have observed that the my application FLAC Encoder failes in
restartability test after about 1500 restarts. Narrowing down the problem
shows that I am having problem with multiple calls of
FLAC__metadata_object_vorbiscomment_entry_from_name_value_pair() and/or
FLAC__metadata_object_vorbiscomment_append_comment() routines, i.e. If I
have vorbis comment in my metadata with copy flag == true, my application's
restartability is affected. To test my observation, I took the simple
encoder example available with the FLAC package and added a couple of vorbis
comments in it as follows,
#if HAVE_CONFIG_H
> # include <config.h>
> #endif
>
> #include <stdio.h>
> #include <stdlib.h>
> #include <string.h>
> #include "FLAC_metadata.h"
> #include "FLAC_stream_encoder.h"
>
> static char outFileName[256] = {"encAudio.flac"};
> static unsigned char FLAC_tagTitle[] = {"Title"};
> static const unsigned char FLAC_tagArtist[] = {"Artist"};
> static const unsigned char FLAC_tagAlbum[] = {"Album"};
> static const unsigned char FLAC_tagYear[] = {"2008"};
> static const unsigned char FLAC_tagGenre[] = {"Audio Track"};
> static const unsigned char defFileName[16] = {"encAUDIO.flac"};
>
> static void progress_callback(const FLAC__StreamEncoder *encoder,
> FLAC__uint64 bytes_written, FLAC__uint64 samples_written, unsigned
> frames_written, unsigned total_frames_estimate, void *client_data);
>
> #define READSIZE 1024
>
> static unsigned total_samples = 0; /* can use a 32-bit number due to WAVE
> size limitations */
> static FLAC__byte buffer[READSIZE/*samples*/ * 2/*bytes_per_sample*/ *
> 2/*channels*/]; /* we read the WAVE data into here */
> static FLAC__int32 pcm[READSIZE/*samples*/ * 2/*channels*/];
>
> int main(int argc, char *argv[])
> {
> FLAC__bool ok = true;
> FLAC__StreamEncoder *encoder = 0;
> FLAC__StreamEncoderInitStatus init_status;
> FLAC__StreamMetadata *metadata[2];
> FLAC__StreamMetadata_VorbisComment_Entry entry;
> FILE *fin;
> unsigned sample_rate = 0;
> unsigned channels = 0;
> unsigned bps = 0;
>
> if(argc != 3) {
> fprintf(stderr, "usage: %s infile.wav outfile.flac\n", argv[0]);
> return 1;
> }
>
> if((fin = fopen(argv[1], "rb")) == NULL) {
> fprintf(stderr, "ERROR: opening %s for output\n", argv[1]);
> return 1;
> }
>
> /* read wav header and validate it */
> if(
> fread(buffer, 1, 44, fin) != 44 ||
> memcmp(buffer, "RIFF", 4) ||
> memcmp(buffer+8, "WAVEfmt \020\000\000\000\001\000\002\000", 16) ||
> memcmp(buffer+32, "\004\000\020\000data", 8)
> ) {
> fprintf(stderr, "ERROR: invalid/unsupported WAVE file, only 16bps
> stereo WAVE in canonical form allowed\n");
> fclose(fin);
> return 1;
> }
> sample_rate = ((((((unsigned)buffer[27] << 8) | buffer[26]) << 8) |
> buffer[25]) << 8) | buffer[24];
> printf("sampleRate:%d\n", sample_rate);
> channels = 2;
> bps = 16;
> total_samples = (((((((unsigned)buffer[43] << 8) | buffer[42]) << 8) |
> buffer[41]) << 8) | buffer[40]) / 4;
>
> /* allocate the encoder */
> if((encoder = FLAC__stream_encoder_new()) == NULL) {
> fprintf(stderr, "ERROR: allocating encoder\n");
> fclose(fin);
> return 1;
> }
>
> ok &= FLAC__stream_encoder_set_verify(encoder, true);
> ok &= FLAC__stream_encoder_set_compression_level(encoder, 5);
> ok &= FLAC__stream_encoder_set_channels(encoder, channels);
> ok &= FLAC__stream_encoder_set_bits_per_sample(encoder, bps);
> ok &= FLAC__stream_encoder_set_sample_rate(encoder, sample_rate);
> ok &= FLAC__stream_encoder_set_total_samples_estimate(encoder,
> total_samples);
>
> if( (metadata[0] =
> FLAC__metadata_object_new(FLAC__METADATA_TYPE_PADDING)) == NULL ||
> (metadata[1] =
> FLAC__metadata_object_new(FLAC__METADATA_TYPE_VORBIS_COMMENT)) == NULL)
> ok = false;
>
> metadata[0]->length = 512; /* set the padding length */
> #if BUGGY
> ok &=
> FLAC__metadata_object_vorbiscomment_entry_from_name_value_pair(&entry,
> "TITLE", FLAC_tagTitle);
> ok &= FLAC__metadata_object_vorbiscomment_append_comment(metadata[1],
> entry, /*copy=*/true);
> ok &=
> FLAC__metadata_object_vorbiscomment_entry_from_name_value_pair(&entry,
> "ARTIST", FLAC_tagArtist);
> ok &= FLAC__metadata_object_vorbiscomment_append_comment(metadata[1],
> entry, /*copy=*/true);
> ok &=
> FLAC__metadata_object_vorbiscomment_entry_from_name_value_pair(&entry,
> "ALBUM", FLAC_tagAlbum);
> ok &= FLAC__metadata_object_vorbiscomment_append_comment(metadata[1],
> entry, /*copy=*/true);
> ok &=
> FLAC__metadata_object_vorbiscomment_entry_from_name_value_pair(&entry,
> "GENRE", FLAC_tagGenre);
> ok &= FLAC__metadata_object_vorbiscomment_append_comment(metadata[1],
> entry, /*copy=*/true);
> ok &=
> FLAC__metadata_object_vorbiscomment_entry_from_name_value_pair(&entry,
> "DATE", FLAC_tagYear);
> ok &= FLAC__metadata_object_vorbiscomment_append_comment(metadata[1],
> entry, /*copy=*/true);
> #endif
> if (!FLAC__stream_encoder_set_metadata(encoder, metadata, 2))
> return FLAC__STREAM_ENCODER_CLIENT_ERROR;
>
> /* initialize encoder */
> if(ok) {
> init_status = FLAC__stream_encoder_init_file(encoder, argv[2],
> progress_callback, /*client_data=*/NULL);
> if(init_status != FLAC__STREAM_ENCODER_INIT_STATUS_OK) {
> fprintf(stderr, "ERROR: initializing encoder: %s\n",
> FLAC__StreamEncoderInitStatusString[init_status]);
> ok = false;
> }
> }
>
> /* read blocks of samples from WAVE file and feed to encoder */
> if(ok) {
> size_t left = (size_t)total_samples;
> while(ok && left) {
> size_t need = (left>READSIZE? (size_t)READSIZE : (size_t)left);
> if(fread(buffer, channels*(bps/8), need, fin) != need) {
> fprintf(stderr, "ERROR: reading from WAVE file\n");
> ok = false;
> }
> else {
> /* convert the packed little-endian 16-bit PCM samples from
> WAVE into an interleaved FLAC__int32 buffer for libFLAC */
> size_t i;
> for(i = 0; i < need*channels; i++) {
> /* inefficient but simple and works on big- or
> little-endian machines */
> pcm[i] =
> (FLAC__int32)(((FLAC__int16)(FLAC__int8)buffer[2*i+1] << 8) |
> (FLAC__int16)buffer[2*i]);
> }
> /* feed samples to encoder */
> ok = FLAC__stream_encoder_process_interleaved(encoder, pcm,
> need);
> }
> left -= need;
> }
> }
>
> ok &= FLAC__stream_encoder_finish(encoder);
>
> fprintf(stderr, "encoding: %s\n", ok? "succeeded" : "FAILED");
> fprintf(stderr, " state: %s\n",
> FLAC__StreamEncoderStateString[FLAC__stream_encoder_get_state(encoder)]);
>
> /* now that encoding is finished, the metadata can be freed */
> FLAC__metadata_object_delete(metadata[0]);
> FLAC__metadata_object_delete(metadata[1]);
> FLAC__stream_encoder_delete(encoder);
>
> fclose(fin);
>
> return 0;
> }
>
> void progress_callback(const FLAC__StreamEncoder *encoder, FLAC__uint64
> bytes_written, FLAC__uint64 samples_written, unsigned frames_written,
> unsigned total_frames_estimate, void *client_data)
> {
> (void)encoder, (void)client_data;
>
> #ifdef _MSC_VER
> fprintf(stderr, "wrote %I64u bytes, %I64u/%u samples, %u/%u frames\n",
> bytes_written, samples_written, total_samples, frames_written,
> total_frames_estimate);
> #else
> fprintf(stderr, "wrote %llu bytes, %llu/%u samples, %u/%u frames\n",
> bytes_written, samples_written, total_samples, frames_written,
> total_frames_estimate);
> #endif
> }
>
Then I compiled it with -g option and fed it to valgrind using
tool=memcheck. and here is the output of Valgrind,
... wrote 634814 bytes, 292570/292570 samples, 72/72 frames
> encoding: succeeded
> state: FLAC__STREAM_ENCODER_UNINITIALIZED
> ==21449==
> ==21449== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 13 from 1)
> ==21449== malloc/free: in use at exit: 97 bytes in 5 blocks.
> ==21449== malloc/free: *78 allocs*, *73 frees*, 477,278 bytes allocated.
> ==21449== For counts of detected errors, rerun with: -v
> ==21449== searching for pointers to 5 not-freed blocks.
> ==21449== checked 67,296 bytes.
> ==21449==
> ==21449== 97 bytes in 5 blocks are definitely lost in loss record 1 of 1
> ==21449== at 0x401A826: malloc (vg_replace_malloc.c:149)
> ==21449== by 0x804C66F:
> FLAC__metadata_object_vorbiscomment_entry_from_name_value_pair (in
> /home/XXX/workspace/FLACEnc/FLACEncoder)
> ==21449== by 0x80488AC: (within /home/XXX/workspace/FLACEnc/FLACEncoder)
> ==21449==
> ==21449== LEAK SUMMARY:
> ==21449== *definitely lost: 97 bytes in 5 blocks.*
> ==21449== possibly lost: 0 bytes in 0 blocks.
> ==21449== still reachable: 0 bytes in 0 blocks.
> ==21449== suppressed: 0 bytes in 0 blocks.
>
Above results are produced with libFLAC(vanilla) available with FLAC v1.2.1
on a linux distro.
I have observed that If I use VORBIS_COMMENT metadata with copy == true, I
get memory leaks, but with copy==false, I DONT get memory leaks.
I guess by asking the question, I have solved my problem of leak but the
question itself stands still.
I dont know if my question is right or not,
"is this behavior desired, should we get a memory leak if copy == true, when
should we set copy and when should we unset it"?
Just before pressing Send button, I also tested If this behavior is useful
for String pointers to the
FLAC__metadata_object_vorbiscomment_append_comment() routine but It didnt
help the leak.
Thanks all for your time.
Regards,
Nabsha
_______________________________________________
Flac-dev mailing list
Flac-dev@xiph.org
http://lists.xiph.org/mailman/listinfo/flac-dev
