bcf_file::bcf_file(const parameters &p, bool diff)
{
if(!diff)
filename = p.vcf_filename;
else
filename = p.diff_file;
big_endian = is_big_endian();
is_BGZF = false; stream = p.stream_in;
N_entries = 0; N_kept_entries = 0;
meta_data = header();
if (stream)
{
is_BGZF = true;
open_gz();
}
else
open();
check_bcf();
read_header();
include_indv = vector<bool>(meta_data.N_indv,true);
}
void bcf_file::open()
{
int ret;
if (filename.substr(filename.size()-4) == ".vcf")
LOG.error("Filename ends in '.vcf'. Shouldn't you be using --vcf?\n");
if (filename.substr(filename.size()-7) == ".vcf.gz")
LOG.error("Filename ends in '.vcf.gz'. Shouldn't you be using --gzvcf?\n");
ret = bgzf_is_bgzf(filename.c_str());
if (ret == 1)
is_BGZF = true;
else
is_BGZF = false;
if (is_BGZF)
open_gz();
else
{
file_tmp.open(filename.c_str(), ios::in);
if (!file_tmp.is_open())
LOG.error("Could not open VCF file: " + filename, 0);
file_in = &file_tmp;
}
}
vcf_file::vcf_file(const parameters &p, bool diff)
{
if (!diff)
{
filename = p.vcf_filename;
compressed = p.vcf_compressed;
stream = p.stream_in;
}
else
{
filename = p.diff_file;
compressed = p.diff_file_compressed;
stream = false;
}
gzMAX_LINE_LEN = 0;
N_entries = 0; N_kept_entries = 0;
meta_data = header();
if (stream && compressed)
open_gz();
else if (stream)
{
char first = cin.peek();
if (first == 0x1f)
LOG.error("File starts with gzip magic string. Shouldn't you be using --gzvcf?\n");
file_in = &std::cin;
}
else
open();
read_header();
include_indv = vector<bool>(meta_data.N_indv,true);
}
void vcf_file::open()
{
struct stat buf;
int i = stat(filename.c_str(), &buf);
if (i != 0)
{
perror("stat error");
LOG.error("Can't determine file type of " + filename, 0);
}
if (!S_ISREG(buf.st_mode))
LOG.error("Does not appear to be a regular file: " + filename, 0);
if (filename.substr(filename.size()-4) == ".bcf")
LOG.error("Filename ends in '.bcf'. Shouldn't you be using --bcf?\n");
if (!compressed)
{
if (filename.substr(filename.size()-3) == ".gz")
LOG.error("Filename ends in '.gz'. Shouldn't you be using --gzvcf or --gzdiff?\n");
file_tmp.open(filename.c_str(), ios::in);
if (!file_tmp.is_open())
LOG.error("Could not open VCF file: " + filename, 0);
file_in = &file_tmp;
}
else
open_gz();
}
OIIO_PLUGIN_EXPORTS_END
bool
ZfileInput::valid_file(const std::string& filename) const
{
gzFile gz = open_gz(filename, "rb");
if (!gz)
return false;
ZfileHeader header;
gzread(gz, &header, sizeof(header));
bool ok = (header.magic == zfile_magic
|| header.magic == zfile_magic_endian);
gzclose(gz);
return ok;
}
bool
ZfileInput::open(const std::string& name, ImageSpec& newspec)
{
m_filename = name;
m_gz = open_gz(name, "rb");
if (!m_gz) {
error("Could not open file \"%s\"", name);
return false;
}
ZfileHeader header;
ASSERT(sizeof(header) == 136);
gzread(m_gz, &header, sizeof(header));
if (header.magic != zfile_magic && header.magic != zfile_magic_endian) {
error("Not a valid Zfile");
return false;
}
m_swab = (header.magic == zfile_magic_endian);
if (m_swab) {
swap_endian(&header.width);
swap_endian(&header.height);
swap_endian((float*)&header.worldtoscreen, 16);
swap_endian((float*)&header.worldtocamera, 16);
}
m_spec = ImageSpec(header.width, header.height, 1, TypeDesc::FLOAT);
if (m_spec.channelnames.size() == 0)
m_spec.channelnames.emplace_back("z");
else
m_spec.channelnames[0] = "z";
m_spec.z_channel = 0;
m_spec.attribute("worldtoscreen", TypeMatrix,
(float*)&header.worldtoscreen);
m_spec.attribute("worldtocamera", TypeMatrix,
(float*)&header.worldtocamera);
newspec = spec();
return true;
}
bool
ZfileOutput::open(const std::string& name, const ImageSpec& userspec,
OpenMode mode)
{
if (mode != Create) {
error("%s does not support subimages or MIP levels", format_name());
return false;
}
close(); // Close any already-opened file
m_gz = 0;
m_file = NULL;
m_spec = userspec; // Stash the spec
// Check for things this format doesn't support
if (m_spec.width < 1 || m_spec.height < 1) {
error("Image resolution must be at least 1x1, you asked for %d x %d",
m_spec.width, m_spec.height);
return false;
}
if (m_spec.depth < 1)
m_spec.depth = 1;
if (m_spec.depth > 1) {
error("%s does not support volume images (depth > 1)", format_name());
return false;
}
if (m_spec.nchannels != 1) {
error("Zfile only supports 1 channel, not %d", m_spec.nchannels);
return false;
}
// Force float
if (m_spec.format != TypeDesc::FLOAT)
m_spec.format = TypeDesc::FLOAT;
ZfileHeader header;
header.magic = zfile_magic;
header.width = (int)m_spec.width;
header.height = (int)m_spec.height;
ParamValue* p;
static float ident[16] = { 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1 };
if ((p = m_spec.find_attribute("worldtocamera", TypeMatrix)))
memcpy(header.worldtocamera, p->data(), 16 * sizeof(float));
else
memcpy(header.worldtocamera, ident, 16 * sizeof(float));
if ((p = m_spec.find_attribute("worldtoscreen", TypeMatrix)))
memcpy(header.worldtoscreen, p->data(), 16 * sizeof(float));
else
memcpy(header.worldtoscreen, ident, 16 * sizeof(float));
if (m_spec.get_string_attribute("compression", "none")
!= std::string("none")) {
m_gz = open_gz(name, "wb");
} else {
m_file = Filesystem::fopen(name, "wb");
}
if (!m_file && !m_gz) {
error("Could not open file \"%s\"", name);
return false;
}
bool b = 0;
if (m_gz) {
b = gzwrite(m_gz, &header, sizeof(header));
} else {
b = fwrite(&header, sizeof(header), 1, m_file);
}
if (!b) {
error("Failed write zfile::open (err: %d)", b);
return false;
}
// If user asked for tiles -- which this format doesn't support, emulate
// it by buffering the whole image.this form
if (m_spec.tile_width && m_spec.tile_height)
m_tilebuffer.resize(m_spec.image_bytes());
return true;
}