switch malloc+memset(0) to calloc()

src/libFLAC/bitbuffer.c

@@ -140,10 +140,9 @@ static FLAC__bool bitbuffer_resize_(FLAC__BitBuffer *bb, unsigned new_capacity)
 	if(bb->capacity == new_capacity)
 		return true;
 
-	new_buffer = (FLAC__blurb*)malloc(sizeof(FLAC__blurb) * new_capacity);
+	new_buffer = (FLAC__blurb*)calloc(new_capacity, sizeof(FLAC__blurb));
 	if(new_buffer == 0)
 		return false;
-	memset(new_buffer, 0, sizeof(FLAC__blurb) * new_capacity);
 	memcpy(new_buffer, bb->buffer, sizeof(FLAC__blurb)*min(bb->blurbs+(bb->bits?1:0), new_capacity));
 	if(new_capacity < bb->blurbs+(bb->bits?1:0)) {
 		bb->blurbs = new_capacity;
@@ -251,15 +250,15 @@ static FLAC__bool bitbuffer_read_from_client_(FLAC__BitBuffer *bb, FLAC__bool (*
 
 FLAC__BitBuffer *FLAC__bitbuffer_new()
 {
-	FLAC__BitBuffer *bb = (FLAC__BitBuffer*)malloc(sizeof(FLAC__BitBuffer));
+	FLAC__BitBuffer *bb = (FLAC__BitBuffer*)calloc(1, sizeof(FLAC__BitBuffer));
 
-	if(0 != bb) {
+	/* calloc() implies:
 		memset(bb, 0, sizeof(FLAC__BitBuffer));
 		bb->buffer = 0;
 		bb->capacity = 0;
 		bb->blurbs = bb->bits = bb->total_bits = 0;
 		bb->consumed_blurbs = bb->consumed_bits = bb->total_consumed_bits = 0;
-	}
+	*/
 	return bb;
 }
 
@@ -357,10 +356,9 @@ FLAC__bool FLAC__bitbuffer_clear(FLAC__BitBuffer *bb)
 {
 	if(bb->buffer == 0) {
 		bb->capacity = FLAC__BITBUFFER_DEFAULT_CAPACITY;
-		bb->buffer = (FLAC__blurb*)malloc(sizeof(FLAC__blurb) * bb->capacity);
+		bb->buffer = (FLAC__blurb*)calloc(bb->capacity, sizeof(FLAC__blurb));
 		if(bb->buffer == 0)
 			return false;
-		memset(bb->buffer, 0, bb->capacity);
 	}
 	else {
 		memset(bb->buffer, 0, bb->blurbs + (bb->bits?1:0));

src/libFLAC/file_decoder.c

@@ -96,26 +96,23 @@ FLAC_API FLAC__FileDecoder *FLAC__file_decoder_new()
 
 	FLAC__ASSERT(sizeof(int) >= 4); /* we want to die right away if this is not true */
 
-	decoder = (FLAC__FileDecoder*)malloc(sizeof(FLAC__FileDecoder));
+	decoder = (FLAC__FileDecoder*)calloc(1, sizeof(FLAC__FileDecoder));
 	if(decoder == 0) {
 		return 0;
 	}
-	memset(decoder, 0, sizeof(FLAC__FileDecoder));
 
-	decoder->protected_ = (FLAC__FileDecoderProtected*)malloc(sizeof(FLAC__FileDecoderProtected));
+	decoder->protected_ = (FLAC__FileDecoderProtected*)calloc(1, sizeof(FLAC__FileDecoderProtected));
 	if(decoder->protected_ == 0) {
 		free(decoder);
 		return 0;
 	}
-	memset(decoder->protected_, 0, sizeof(FLAC__FileDecoderProtected));
 
-	decoder->private_ = (FLAC__FileDecoderPrivate*)malloc(sizeof(FLAC__FileDecoderPrivate));
+	decoder->private_ = (FLAC__FileDecoderPrivate*)calloc(1, sizeof(FLAC__FileDecoderPrivate));
 	if(decoder->private_ == 0) {
 		free(decoder->protected_);
 		free(decoder);
 		return 0;
 	}
-	memset(decoder->private_, 0, sizeof(FLAC__FileDecoderPrivate));
 
 	decoder->private_->seekable_stream_decoder = FLAC__seekable_stream_decoder_new();
 	if(0 == decoder->private_->seekable_stream_decoder) {

src/libFLAC/file_encoder.c

@@ -86,26 +86,23 @@ FLAC_API FLAC__FileEncoder *FLAC__file_encoder_new()
 
 	FLAC__ASSERT(sizeof(int) >= 4); /* we want to die right away if this is not true */
 
-	encoder = (FLAC__FileEncoder*)malloc(sizeof(FLAC__FileEncoder));
+	encoder = (FLAC__FileEncoder*)calloc(1, sizeof(FLAC__FileEncoder));
 	if(encoder == 0) {
 		return 0;
 	}
-	memset(encoder, 0, sizeof(FLAC__FileEncoder));
 
-	encoder->protected_ = (FLAC__FileEncoderProtected*)malloc(sizeof(FLAC__FileEncoderProtected));
+	encoder->protected_ = (FLAC__FileEncoderProtected*)calloc(1, sizeof(FLAC__FileEncoderProtected));
 	if(encoder->protected_ == 0) {
 		free(encoder);
 		return 0;
 	}
-	memset(encoder->protected_, 0, sizeof(FLAC__FileEncoderProtected));
 
-	encoder->private_ = (FLAC__FileEncoderPrivate*)malloc(sizeof(FLAC__FileEncoderPrivate));
+	encoder->private_ = (FLAC__FileEncoderPrivate*)calloc(1, sizeof(FLAC__FileEncoderPrivate));
 	if(encoder->private_ == 0) {
 		free(encoder->protected_);
 		free(encoder);
 		return 0;
 	}
-	memset(encoder->private_, 0, sizeof(FLAC__FileEncoderPrivate));
 
 	encoder->private_->seekable_stream_encoder = FLAC__seekable_stream_encoder_new();
 	if(0 == encoder->private_->seekable_stream_encoder) {

src/libFLAC/metadata_iterators.c

@@ -242,7 +242,7 @@ FLAC_API const char * const FLAC__Metadata_SimpleIteratorStatusString[] = {
 
 FLAC_API FLAC__Metadata_SimpleIterator *FLAC__metadata_simple_iterator_new()
 {
-	FLAC__Metadata_SimpleIterator *iterator = malloc(sizeof(FLAC__Metadata_SimpleIterator));
+	FLAC__Metadata_SimpleIterator *iterator = calloc(1, sizeof(FLAC__Metadata_SimpleIterator));
 
 	if(0 != iterator) {
 		iterator->file = 0;
@@ -748,10 +748,7 @@ FLAC_API const char * const FLAC__Metadata_ChainStatusString[] = {
 
 static FLAC__Metadata_Node *node_new_()
 {
-	FLAC__Metadata_Node *node = (FLAC__Metadata_Node*)malloc(sizeof(FLAC__Metadata_Node));
-	if(0 != node)
-		memset(node, 0, sizeof(FLAC__Metadata_Node));
-	return node;
+	return (FLAC__Metadata_Node*)calloc(1, sizeof(FLAC__Metadata_Node));
 }
 
 static void node_delete_(FLAC__Metadata_Node *node)
@@ -888,7 +885,7 @@ static FLAC__bool chain_merge_adjacent_padding_(FLAC__Metadata_Chain *chain, FLA
 
 FLAC_API FLAC__Metadata_Chain *FLAC__metadata_chain_new()
 {
-	FLAC__Metadata_Chain *chain = malloc(sizeof(FLAC__Metadata_Chain));
+	FLAC__Metadata_Chain *chain = calloc(1, sizeof(FLAC__Metadata_Chain));
 
 	if(0 != chain) {
 		chain->filename = 0;
@@ -1102,12 +1099,12 @@ FLAC_API void FLAC__metadata_chain_sort_padding(FLAC__Metadata_Chain *chain)
 
 FLAC_API FLAC__Metadata_Iterator *FLAC__metadata_iterator_new()
 {
-	FLAC__Metadata_Iterator *iterator = malloc(sizeof(FLAC__Metadata_Iterator));
+	FLAC__Metadata_Iterator *iterator = calloc(1, sizeof(FLAC__Metadata_Iterator));
 
-	if(0 != iterator) {
+	/* calloc() implies:
 		iterator->current = 0;
 		iterator->chain = 0;
-	}
+	*/
 
 	return iterator;
 }

src/libFLAC/metadata_object.c

@@ -111,16 +111,9 @@ static void vorbiscomment_calculate_length_(FLAC__StreamMetadata *object)
 
 static FLAC__StreamMetadata_VorbisComment_Entry *vorbiscomment_entry_array_new_(unsigned num_comments)
 {
-	FLAC__StreamMetadata_VorbisComment_Entry *object_array;
-
 	FLAC__ASSERT(num_comments > 0);
 
-	object_array = malloc(num_comments * sizeof(FLAC__StreamMetadata_VorbisComment_Entry));
-
-	if(0 != object_array)
-		memset(object_array, 0, num_comments * sizeof(FLAC__StreamMetadata_VorbisComment_Entry));
-
-	return object_array;
+	return calloc(num_comments, sizeof(FLAC__StreamMetadata_VorbisComment_Entry));
 }
 
 static void vorbiscomment_entry_array_delete_(FLAC__StreamMetadata_VorbisComment_Entry *object_array, unsigned num_comments)
@@ -204,9 +197,8 @@ static FLAC__bool vorbiscomment_set_entry_(FLAC__StreamMetadata *object, FLAC__S
 
 FLAC_API FLAC__StreamMetadata *FLAC__metadata_object_new(FLAC__MetadataType type)
 {
-	FLAC__StreamMetadata *object = malloc(sizeof(FLAC__StreamMetadata));
+	FLAC__StreamMetadata *object = calloc(1, sizeof(FLAC__StreamMetadata));
 	if(0 != object) {
-		memset(object, 0, sizeof(FLAC__StreamMetadata));
 		object->is_last = false;
 		object->type = type;
 		switch(type) {

src/libFLAC/seekable_stream_decoder.c

@@ -18,7 +18,7 @@
  */
 
 #include <stdio.h>
-#include <stdlib.h> /* for malloc() */
+#include <stdlib.h> /* for calloc() */
 #include <string.h> /* for memcpy()/memcmp() */
 #include "FLAC/assert.h"
 #include "protected/seekable_stream_decoder.h"
@@ -121,26 +121,23 @@ FLAC_API FLAC__SeekableStreamDecoder *FLAC__seekable_stream_decoder_new()
 
 	FLAC__ASSERT(sizeof(int) >= 4); /* we want to die right away if this is not true */
 
-	decoder = (FLAC__SeekableStreamDecoder*)malloc(sizeof(FLAC__SeekableStreamDecoder));
+	decoder = (FLAC__SeekableStreamDecoder*)calloc(1, sizeof(FLAC__SeekableStreamDecoder));
 	if(decoder == 0) {
 		return 0;
 	}
-	memset(decoder, 0, sizeof(FLAC__SeekableStreamDecoder));
 
-	decoder->protected_ = (FLAC__SeekableStreamDecoderProtected*)malloc(sizeof(FLAC__SeekableStreamDecoderProtected));
+	decoder->protected_ = (FLAC__SeekableStreamDecoderProtected*)calloc(1, sizeof(FLAC__SeekableStreamDecoderProtected));
 	if(decoder->protected_ == 0) {
 		free(decoder);
 		return 0;
 	}
-	memset(decoder->protected_, 0, sizeof(FLAC__SeekableStreamDecoderProtected));
 
-	decoder->private_ = (FLAC__SeekableStreamDecoderPrivate*)malloc(sizeof(FLAC__SeekableStreamDecoderPrivate));
+	decoder->private_ = (FLAC__SeekableStreamDecoderPrivate*)calloc(1, sizeof(FLAC__SeekableStreamDecoderPrivate));
 	if(decoder->private_ == 0) {
 		free(decoder->protected_);
 		free(decoder);
 		return 0;
 	}
-	memset(decoder->private_, 0, sizeof(FLAC__SeekableStreamDecoderPrivate));
 
 	decoder->private_->stream_decoder = FLAC__stream_decoder_new();
 	if(0 == decoder->private_->stream_decoder) {

src/libFLAC/seekable_stream_encoder.c

@@ -18,7 +18,7 @@
  */
 
 #include <stdio.h>
-#include <stdlib.h> /* for malloc() */
+#include <stdlib.h> /* for calloc() */
 #include <string.h> /* for memcpy() */
 #include "FLAC/assert.h"
 #include "protected/seekable_stream_encoder.h"
@@ -99,26 +99,23 @@ FLAC_API FLAC__SeekableStreamEncoder *FLAC__seekable_stream_encoder_new()
 
 	FLAC__ASSERT(sizeof(int) >= 4); /* we want to die right away if this is not true */
 
-	encoder = (FLAC__SeekableStreamEncoder*)malloc(sizeof(FLAC__SeekableStreamEncoder));
+	encoder = (FLAC__SeekableStreamEncoder*)calloc(1, sizeof(FLAC__SeekableStreamEncoder));
 	if(encoder == 0) {
 		return 0;
 	}
-	memset(encoder, 0, sizeof(FLAC__SeekableStreamEncoder));
 
-	encoder->protected_ = (FLAC__SeekableStreamEncoderProtected*)malloc(sizeof(FLAC__SeekableStreamEncoderProtected));
+	encoder->protected_ = (FLAC__SeekableStreamEncoderProtected*)calloc(1, sizeof(FLAC__SeekableStreamEncoderProtected));
 	if(encoder->protected_ == 0) {
 		free(encoder);
 		return 0;
 	}
-	memset(encoder->protected_, 0, sizeof(FLAC__SeekableStreamEncoderProtected));
 
-	encoder->private_ = (FLAC__SeekableStreamEncoderPrivate*)malloc(sizeof(FLAC__SeekableStreamEncoderPrivate));
+	encoder->private_ = (FLAC__SeekableStreamEncoderPrivate*)calloc(1, sizeof(FLAC__SeekableStreamEncoderPrivate));
 	if(encoder->private_ == 0) {
 		free(encoder->protected_);
 		free(encoder);
 		return 0;
 	}
-	memset(encoder->private_, 0, sizeof(FLAC__SeekableStreamEncoderPrivate));
 
 	encoder->private_->stream_encoder = FLAC__stream_encoder_new();
 	if(0 == encoder->private_->stream_encoder) {

src/libFLAC/stream_decoder.c

@@ -150,26 +150,23 @@ FLAC_API FLAC__StreamDecoder *FLAC__stream_decoder_new()
 
 	FLAC__ASSERT(sizeof(int) >= 4); /* we want to die right away if this is not true */
 
-	decoder = (FLAC__StreamDecoder*)malloc(sizeof(FLAC__StreamDecoder));
+	decoder = (FLAC__StreamDecoder*)calloc(1, sizeof(FLAC__StreamDecoder));
 	if(decoder == 0) {
 		return 0;
 	}
-	memset(decoder, 0, sizeof(FLAC__StreamDecoder));
 
-	decoder->protected_ = (FLAC__StreamDecoderProtected*)malloc(sizeof(FLAC__StreamDecoderProtected));
+	decoder->protected_ = (FLAC__StreamDecoderProtected*)calloc(1, sizeof(FLAC__StreamDecoderProtected));
 	if(decoder->protected_ == 0) {
 		free(decoder);
 		return 0;
 	}
-	memset(decoder->protected_, 0, sizeof(FLAC__StreamDecoderProtected));
 
-	decoder->private_ = (FLAC__StreamDecoderPrivate*)malloc(sizeof(FLAC__StreamDecoderPrivate));
+	decoder->private_ = (FLAC__StreamDecoderPrivate*)calloc(1, sizeof(FLAC__StreamDecoderPrivate));
 	if(decoder->private_ == 0) {
 		free(decoder->protected_);
 		free(decoder);
 		return 0;
 	}
-	memset(decoder->private_, 0, sizeof(FLAC__StreamDecoderPrivate));
 
 	decoder->private_->input = FLAC__bitbuffer_new();
 	if(decoder->private_->input == 0) {

src/libFLAC/stream_encoder.c

@@ -430,26 +430,23 @@ FLAC_API FLAC__StreamEncoder *FLAC__stream_encoder_new()
 
 	FLAC__ASSERT(sizeof(int) >= 4); /* we want to die right away if this is not true */
 
-	encoder = (FLAC__StreamEncoder*)malloc(sizeof(FLAC__StreamEncoder));
+	encoder = (FLAC__StreamEncoder*)calloc(1, sizeof(FLAC__StreamEncoder));
 	if(encoder == 0) {
 		return 0;
 	}
-	memset(encoder, 0, sizeof(FLAC__StreamEncoder));
 
-	encoder->protected_ = (FLAC__StreamEncoderProtected*)malloc(sizeof(FLAC__StreamEncoderProtected));
+	encoder->protected_ = (FLAC__StreamEncoderProtected*)calloc(1, sizeof(FLAC__StreamEncoderProtected));
 	if(encoder->protected_ == 0) {
 		free(encoder);
 		return 0;
 	}
-	memset(encoder->protected_, 0, sizeof(FLAC__StreamEncoderProtected));
 
-	encoder->private_ = (FLAC__StreamEncoderPrivate*)malloc(sizeof(FLAC__StreamEncoderPrivate));
+	encoder->private_ = (FLAC__StreamEncoderPrivate*)calloc(1, sizeof(FLAC__StreamEncoderPrivate));
 	if(encoder->private_ == 0) {
 		free(encoder->protected_);
 		free(encoder);
 		return 0;
 	}
-	memset(encoder->private_, 0, sizeof(FLAC__StreamEncoderPrivate));
 
 	encoder->private_->frame = FLAC__bitbuffer_new();
 	if(encoder->private_->frame == 0) {

src/libOggFLAC/file_decoder.c

@@ -96,26 +96,23 @@ OggFLAC_API FLAC__FileDecoder *FLAC__file_decoder_new()
 
 	FLAC__ASSERT(sizeof(int) >= 4); /* we want to die right away if this is not true */
 
-	decoder = (FLAC__FileDecoder*)malloc(sizeof(FLAC__FileDecoder));
+	decoder = (FLAC__FileDecoder*)calloc(1, sizeof(FLAC__FileDecoder));
 	if(decoder == 0) {
 		return 0;
 	}
-	memset(decoder, 0, sizeof(FLAC__FileDecoder));
 
-	decoder->protected_ = (FLAC__FileDecoderProtected*)malloc(sizeof(FLAC__FileDecoderProtected));
+	decoder->protected_ = (FLAC__FileDecoderProtected*)calloc(1, sizeof(FLAC__FileDecoderProtected));
 	if(decoder->protected_ == 0) {
 		free(decoder);
 		return 0;
 	}
-	memset(decoder->protected_, 0, sizeof(FLAC__FileDecoderProtected));
 
-	decoder->private_ = (FLAC__FileDecoderPrivate*)malloc(sizeof(FLAC__FileDecoderPrivate));
+	decoder->private_ = (FLAC__FileDecoderPrivate*)calloc(1, sizeof(FLAC__FileDecoderPrivate));
 	if(decoder->private_ == 0) {
 		free(decoder->protected_);
 		free(decoder);
 		return 0;
 	}
-	memset(decoder->private_, 0, sizeof(FLAC__FileDecoderPrivate));
 
 	decoder->private_->seekable_stream_decoder = FLAC__seekable_stream_decoder_new();
 	if(0 == decoder->private_->seekable_stream_decoder) {

src/libOggFLAC/seekable_stream_decoder.c

@@ -18,7 +18,7 @@
  */
 
 #include <stdio.h>
-#include <stdlib.h> /* for malloc() */
+#include <stdlib.h> /* for calloc() */
 #include <string.h> /* for memcpy()/memcmp() */
 #include "FLAC/assert.h"
 #include "protected/seekable_stream_decoder.h"
@@ -121,26 +121,23 @@ OggFLAC_API FLAC__SeekableStreamDecoder *FLAC__seekable_stream_decoder_new()
 
 	FLAC__ASSERT(sizeof(int) >= 4); /* we want to die right away if this is not true */
 
-	decoder = (FLAC__SeekableStreamDecoder*)malloc(sizeof(FLAC__SeekableStreamDecoder));
+	decoder = (FLAC__SeekableStreamDecoder*)calloc(1, sizeof(FLAC__SeekableStreamDecoder));
 	if(decoder == 0) {
 		return 0;
 	}
-	memset(decoder, 0, sizeof(FLAC__SeekableStreamDecoder));
 
-	decoder->protected_ = (FLAC__SeekableStreamDecoderProtected*)malloc(sizeof(FLAC__SeekableStreamDecoderProtected));
+	decoder->protected_ = (FLAC__SeekableStreamDecoderProtected*)calloc(1, sizeof(FLAC__SeekableStreamDecoderProtected));
 	if(decoder->protected_ == 0) {
 		free(decoder);
 		return 0;
 	}
-	memset(decoder->protected_, 0, sizeof(FLAC__SeekableStreamDecoderProtected));
 
-	decoder->private_ = (FLAC__SeekableStreamDecoderPrivate*)malloc(sizeof(FLAC__SeekableStreamDecoderPrivate));
+	decoder->private_ = (FLAC__SeekableStreamDecoderPrivate*)calloc(1, sizeof(FLAC__SeekableStreamDecoderPrivate));
 	if(decoder->private_ == 0) {
 		free(decoder->protected_);
 		free(decoder);
 		return 0;
 	}
-	memset(decoder->private_, 0, sizeof(FLAC__SeekableStreamDecoderPrivate));
 
 	decoder->private_->stream_decoder = FLAC__stream_decoder_new();
 	if(0 == decoder->private_->stream_decoder) {

src/libOggFLAC/stream_decoder.c

@@ -17,7 +17,7 @@
  * Boston, MA  02111-1307, USA.
  */
 
-#include <stdlib.h>
+#include <stdlib.h> /* for calloc() */
 #include <string.h> /* for memset() */
 #include "ogg/ogg.h"
 #include "FLAC/assert.h"
@@ -88,26 +88,23 @@ OggFLAC_API OggFLAC__StreamDecoder *OggFLAC__stream_decoder_new()
 {
 	OggFLAC__StreamDecoder *decoder;
 
-	decoder = (OggFLAC__StreamDecoder*)malloc(sizeof(OggFLAC__StreamDecoder));
+	decoder = (OggFLAC__StreamDecoder*)calloc(1, sizeof(OggFLAC__StreamDecoder));
 	if(decoder == 0) {
 		return 0;
 	}
-	memset(decoder, 0, sizeof(OggFLAC__StreamDecoder));
 
-	decoder->protected_ = (OggFLAC__StreamDecoderProtected*)malloc(sizeof(OggFLAC__StreamDecoderProtected));
+	decoder->protected_ = (OggFLAC__StreamDecoderProtected*)calloc(1, sizeof(OggFLAC__StreamDecoderProtected));
 	if(decoder->protected_ == 0) {
 		free(decoder);
 		return 0;
 	}
-	memset(decoder->protected_, 0, sizeof(OggFLAC__StreamDecoderProtected));
 
-	decoder->private_ = (OggFLAC__StreamDecoderPrivate*)malloc(sizeof(OggFLAC__StreamDecoderPrivate));
+	decoder->private_ = (OggFLAC__StreamDecoderPrivate*)calloc(1, sizeof(OggFLAC__StreamDecoderPrivate));
 	if(decoder->private_ == 0) {
 		free(decoder->protected_);
 		free(decoder);
 		return 0;
 	}
-	memset(decoder->private_, 0, sizeof(OggFLAC__StreamDecoderPrivate));
 
 	decoder->private_->FLAC_stream_decoder = FLAC__stream_decoder_new();
 	if(0 == decoder->private_->FLAC_stream_decoder) {

src/libOggFLAC/stream_encoder.c

@@ -18,7 +18,7 @@
  */
 
 #include <stdio.h>
-#include <stdlib.h> /* for malloc() */
+#include <stdlib.h> /* for calloc() */
 #include <string.h> /* for memcpy() */
 #include "ogg/ogg.h"
 #include "FLAC/assert.h"
@@ -87,26 +87,23 @@ OggFLAC_API OggFLAC__StreamEncoder *OggFLAC__stream_encoder_new()
 {
 	OggFLAC__StreamEncoder *encoder;
 
-	encoder = (OggFLAC__StreamEncoder*)malloc(sizeof(OggFLAC__StreamEncoder));
+	encoder = (OggFLAC__StreamEncoder*)calloc(1, sizeof(OggFLAC__StreamEncoder));
 	if(encoder == 0) {
 		return 0;
 	}
-	memset(encoder, 0, sizeof(OggFLAC__StreamEncoder));
 
-	encoder->protected_ = (OggFLAC__StreamEncoderProtected*)malloc(sizeof(OggFLAC__StreamEncoderProtected));
+	encoder->protected_ = (OggFLAC__StreamEncoderProtected*)calloc(1, sizeof(OggFLAC__StreamEncoderProtected));
 	if(encoder->protected_ == 0) {
 		free(encoder);
 		return 0;
 	}
-	memset(encoder->protected_, 0, sizeof(OggFLAC__StreamEncoderProtected));
 
-	encoder->private_ = (OggFLAC__StreamEncoderPrivate*)malloc(sizeof(OggFLAC__StreamEncoderPrivate));
+	encoder->private_ = (OggFLAC__StreamEncoderPrivate*)calloc(1, sizeof(OggFLAC__StreamEncoderPrivate));
 	if(encoder->private_ == 0) {
 		free(encoder->protected_);
 		free(encoder);
 		return 0;
 	}
-	memset(encoder->private_, 0, sizeof(OggFLAC__StreamEncoderPrivate));
 
 	encoder->private_->FLAC_stream_encoder = FLAC__stream_encoder_new();
 	if(0 == encoder->private_->FLAC_stream_encoder) {