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;
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;
}
{
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));
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) {
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) {
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;
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)
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;
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;
}
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)
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) {
*/
#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"
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) {
*/
#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"
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) {
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) {
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) {
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) {
*/
#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"
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) {
* 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"
{
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) {
*/
#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"
{
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) {