C++ (Cpp) output_file_init Examples

Example #1

File: output-oss.c Project: runeswagger/soundplayer-redux

int output_oss_init(void *arg){
	//start up the oss
	if(arg == NULL){
		//default to /dev/dsp
		arg = (void*)"/dev/dsp";
	}
	output_file_init(arg);
	output_oss_configure(44100, 2, NULL);
	return 0;
}

Example #2

File: output_file.c Project: 4Fwolf/mt6572_x201

struct output_file *output_file_open_fd(int fd, unsigned int block_size, int64_t len,
		int gz, int sparse, int chunks, int crc)
{
	int ret;
	struct output_file *out;

	if (gz) {
		out = output_file_new_gz();
	} else {
		out = output_file_new_normal();
	}

	out->ops->open(out, fd);

	ret = output_file_init(out, block_size, len, sparse, chunks, crc);
	if (ret < 0) {
		free(out);
		return NULL;
	}

	return out;
}

Example #3

File: output_file.c Project: 4Fwolf/mt6572_x201

static int output_file_init(struct output_file *out, int block_size,
		int64_t len, bool sparse, int chunks, bool crc)
{
	int ret;

	out->len = len;
	out->block_size = block_size;
	out->cur_out_ptr = 0ll;
	out->chunk_cnt = 0;
	out->crc32 = 0;
	out->use_crc = crc;

	out->zero_buf = calloc(block_size, 1);
	if (!out->zero_buf) {
		error_errno("malloc zero_buf");
		return -ENOMEM;
	}

	out->fill_buf = calloc(block_size, 1);
	if (!out->fill_buf) {
		error_errno("malloc fill_buf");
		ret = -ENOMEM;
		goto err_fill_buf;
	}

	if (sparse) {
		out->sparse_ops = &sparse_file_ops;
	} else {
		out->sparse_ops = &normal_file_ops;
	}

	if (sparse) {
		sparse_header_t sparse_header = {
				.magic = SPARSE_HEADER_MAGIC,
				.major_version = SPARSE_HEADER_MAJOR_VER,
				.minor_version = SPARSE_HEADER_MINOR_VER,
				.file_hdr_sz = SPARSE_HEADER_LEN,
				.chunk_hdr_sz = CHUNK_HEADER_LEN,
				.blk_sz = out->block_size,
				.total_blks = out->len / out->block_size,
				.total_chunks = chunks,
				.image_checksum = 0
		};

		if (out->use_crc) {
			sparse_header.total_chunks++;
		}

		ret = out->ops->write(out, &sparse_header, sizeof(sparse_header));
		if (ret < 0) {
			goto err_write;
		}
	}

	return 0;

err_write:
	free(out->fill_buf);
err_fill_buf:
	free(out->zero_buf);
	return ret;
}

static struct output_file *output_file_new_gz(void)
{
	struct output_file_gz *outgz = calloc(1, sizeof(struct output_file_gz));
	if (!outgz) {
		error_errno("malloc struct outgz");
		return NULL;
	}

	outgz->out.ops = &gz_file_ops;

	return &outgz->out;
}

static struct output_file *output_file_new_normal(void)
{
	struct output_file_normal *outn = calloc(1, sizeof(struct output_file_normal));
	if (!outn) {
		error_errno("malloc struct outn");
		return NULL;
	}

	outn->out.ops = &file_ops;

	return &outn->out;
}

struct output_file *output_file_open_callback(int (*write)(void *, const void *, int),
		void *priv, unsigned int block_size, int64_t len, int gz, int sparse,
		int chunks, int crc)
{
	int ret;
	struct output_file_callback *outc;

	outc = calloc(1, sizeof(struct output_file_callback));
	if (!outc) {
		error_errno("malloc struct outc");
		return NULL;
	}

	outc->out.ops = &callback_file_ops;
	outc->priv = priv;
	outc->write = write;

	ret = output_file_init(&outc->out, block_size, len, sparse, chunks, crc);
	if (ret < 0) {
		free(outc);
		return NULL;
	}

	return &outc->out;
}