void check_dt(const char* dt);
private:
+ // disable copy and assignment
+ Base64Writer(const Base64Writer &);
+ Base64Writer & operator=(const Base64Writer &);
+
+ private:
Base64ContextEmitter * emitter;
std::string data_type_string;
beg = end;
icvYMLGetMultilineStringContent( fs, beg, indent, beg, end );
}
- if ( !base64::base64_valid(base64_buffer.data(), 0U, base64_buffer.size()) )
+ if ( base64_buffer.empty() ||
+ !base64::base64_valid(base64_buffer.data(), 0U, base64_buffer.size()) )
CV_PARSE_ERROR( "Invalid Base64 data." );
/* buffer for decoded data(exclude header) */
icvYMLParseValue( CvFileStorage* fs, char* ptr, CvFileNode* node,
int parent_flags, int min_indent )
{
- char buf[CV_FS_MAX_LEN + 1024];
+ char buf[CV_FS_MAX_LEN + 1024] = {0};
char* endptr = 0;
char c = ptr[0], d = ptr[1];
int is_parent_flow = CV_NODE_IS_FLOW(parent_flags);
{
int new_min_indent = min_indent + !is_parent_flow;
int struct_flags = CV_NODE_FLOW + (c == '{' ? CV_NODE_MAP : CV_NODE_SEQ);
- int is_simple = 1;
+ bool is_simple = true;
icvFSCreateCollection( fs, CV_NODE_TYPE(struct_flags) +
(node->info ? CV_NODE_USER : 0), node );
break;
elem = (CvFileNode*)cvSeqPush( node->data.seq, 0 );
}
+ CV_Assert(elem);
ptr = icvYMLParseValue( fs, ptr, elem, struct_flags, new_min_indent );
if( CV_NODE_IS_MAP(struct_flags) )
elem->tag |= CV_NODE_NAMED;
- is_simple &= !CV_NODE_IS_COLLECTION(elem->tag);
+ is_simple = is_simple && !CV_NODE_IS_COLLECTION(elem->tag);
}
node->data.seq->flags |= is_simple ? CV_NODE_SEQ_SIMPLE : 0;
}
else
{
- int indent, struct_flags, is_simple;
+ int indent, struct_flags;
+ bool is_simple;
if( is_parent_flow || c != '-' )
{
(node->info ? CV_NODE_USER : 0), node );
indent = (int)(ptr - fs->buffer_start);
- is_simple = 1;
+ is_simple = true;
for(;;)
{
elem = (CvFileNode*)cvSeqPush( node->data.seq, 0 );
}
-
+ CV_Assert(elem);
ptr = icvYMLSkipSpaces( fs, ptr, indent + 1, INT_MAX );
ptr = icvYMLParseValue( fs, ptr, elem, struct_flags, indent + 1 );
if( CV_NODE_IS_MAP(struct_flags) )
elem->tag |= CV_NODE_NAMED;
- is_simple &= !CV_NODE_IS_COLLECTION(elem->tag);
+ is_simple = is_simple && !CV_NODE_IS_COLLECTION(elem->tag);
ptr = icvYMLSkipSpaces( fs, ptr, 0, INT_MAX );
if( ptr - fs->buffer_start != indent )
beg = end;
icvXMLGetMultilineStringContent( fs, beg, beg, end );
}
- if ( !base64::base64_valid(base64_buffer.data(), 0U, base64_buffer.size()) )
+ if ( base64_buffer.empty() ||
+ !base64::base64_valid(base64_buffer.data(), 0U, base64_buffer.size()) )
CV_PARSE_ERROR( "Invalid Base64 data." );
/* alloc buffer for all decoded data(include header) */
int value_type CV_DEFAULT(CV_NODE_NONE))
{
CvFileNode *elem = node;
- int have_space = 1, is_simple = 1;
+ bool have_space = true, is_simple = true;
int is_user_type = CV_NODE_IS_USER(value_type);
memset( node, 0, sizeof(*node) );
if( cv_isspace(c) || c == '\0' || (c == '<' && ptr[1] == '!' && ptr[2] == '-') )
{
ptr = icvXMLSkipSpaces( fs, ptr, 0 );
- have_space = 1;
+ have_space = true;
c = *ptr;
}
elem = (CvFileNode*)cvSeqPush( node->data.seq, 0 );
else
elem = cvGetFileNode( fs, node, key, 1 );
-
+ CV_Assert(elem);
if (!is_binary_string)
ptr = icvXMLParseValue( fs, ptr, elem, elem_type);
else {
if( !is_noname )
elem->tag |= CV_NODE_NAMED;
- is_simple &= !CV_NODE_IS_COLLECTION(elem->tag);
+ is_simple = is_simple && !CV_NODE_IS_COLLECTION(elem->tag);
elem->info = info;
ptr = icvXMLParseTag( fs, ptr, &key2, &list, &tag_type );
if( tag_type != CV_XML_CLOSING_TAG || key2 != key )
CV_PARSE_ERROR( "Mismatched closing tag" );
- have_space = 1;
+ have_space = true;
}
else
{
else
{
// string
- char buf[CV_FS_MAX_LEN+16];
+ char buf[CV_FS_MAX_LEN+16] = {0};
int i = 0, len, is_quoted = 0;
elem->tag = CV_NODE_STRING;
if( c == '\"' )
if( !CV_NODE_IS_COLLECTION(value_type) && value_type != CV_NODE_NONE )
break;
- have_space = 0;
+ have_space = false;
}
}
while( cv_isalnum(c) || c == '_' || c == '-' );
attrname = cvGetHashedKey( fs, ptr, (int)(endptr - ptr), 1 );
+ CV_Assert(attrname);
ptr = endptr;
if( !tagname )
CvFileNode* root_node;
ptr = icvXMLParseTag( fs, ptr, &key, &list, &tag_type );
if( tag_type != CV_XML_OPENING_TAG ||
+ !key ||
strcmp(key->str.ptr,"opencv_storage") != 0 )
CV_PARSE_ERROR( "<opencv_storage> tag is missing" );
static char* icvJSONParseSeq( CvFileStorage* fs, char* ptr, CvFileNode* node )
{
+ if (!ptr)
+ CV_PARSE_ERROR( "ptr is NULL" );
+
if ( *ptr != '[' )
CV_PARSE_ERROR( "'[' - left-brace of seq is missing" );
else
CV_PARSE_ERROR( "Unexpected character" );
}
+ if (!ptr)
+ CV_PARSE_ERROR("ptr is NULL");
+
if ( *ptr != ']' )
CV_PARSE_ERROR( "']' - right-brace of seq is missing" );
else
static char* icvJSONParseMap( CvFileStorage* fs, char* ptr, CvFileNode* node )
{
+ if (!ptr)
+ CV_PARSE_ERROR("ptr is NULL");
+
if ( *ptr != '{' )
CV_PARSE_ERROR( "'{' - left-brace of map is missing" );
else
{
CvFileNode* child = 0;
ptr = icvJSONParseKey( fs, ptr, node, &child );
+ if ( ptr == 0 || fs->dummy_eof )
+ break;
ptr = icvJSONSkipSpaces( fs, ptr );
if ( ptr == 0 || fs->dummy_eof )
break;
CV_PARSE_ERROR( "Unexpected character" );
}
+ if (!ptr)
+ CV_PARSE_ERROR("ptr is NULL");
+
if ( *ptr != '}' )
CV_PARSE_ERROR( "'}' - right-brace of map is missing" );
else
CV_Error( CV_StsBadFlag, "CV_STORAGE_APPEND and CV_STORAGE_MEMORY are not currently compatible" );
fs = (CvFileStorage*)cvAlloc( sizeof(*fs) );
+ CV_Assert(fs);
memset( fs, 0, sizeof(*fs));
fs->memstorage = cvCreateMemStorage( default_block_size );
}
icvCloseFile( fs );
fs->file = fopen( fs->filename, "r+t" );
+ CV_Assert(fs->file);
fseek( fs->file, last_occurence, SEEK_SET );
// replace the last "</opencv_storage>" with " <!-- resumed -->", which has the same length
icvPuts( fs, " <!-- resumed -->" );
{
icvCloseFile( fs );
fs->file = fopen( fs->filename, "r+t" );
+ CV_Assert(fs->file);
fseek( fs->file, roffset, SEEK_END );
fputs( ",", fs->file );
}
const char* dt;
CvFileNode* data;
CvFileNode* sizes_node;
- int sizes[CV_MAX_DIM], dims, elem_type;
+ int sizes[CV_MAX_DIM] = {0}, dims, elem_type;
int i, total_size;
sizes_node = cvGetFileNodeByName( fs, node, "sizes" );
for( total_size = CV_MAT_CN(elem_type), i = 0; i < dims; i++ )
+ {
+ CV_Assert(sizes[i]);
total_size *= sizes[i];
+ }
int nelems = icvFileNodeSeqLen( data );
dims = CV_NODE_IS_SEQ(sizes_node->tag) ? sizes_node->data.seq->total :
CV_NODE_IS_INT(sizes_node->tag) ? 1 : -1;
- if( dims <= 0 || dims > CV_MAX_DIM_HEAP )
+ if( dims <= 0 || dims > CV_MAX_DIM)
CV_Error( CV_StsParseError, "Could not determine sparse matrix dimensionality" );
cvReadRawData( fs, sizes_node, sizes, "i" );
}
depth = IPL2CV_DEPTH(image->depth);
+ CV_Assert(depth < 9);
sprintf( dt_buf, "%d%c", image->nChannels, icvTypeSymbol[depth] );
dt = dt_buf + (dt_buf[2] == '\0' && dt_buf[0] == '1');
cvWriteString( fs, "dt", dt, 0 );
elem_type = icvDecodeSimpleFormat( dt );
data_order = cvReadStringByName( fs, node, "layout", "interleaved" );
- if( strcmp( data_order, "interleaved" ) != 0 )
+ if( !data_order || strcmp( data_order, "interleaved" ) != 0 )
CV_Error( CV_StsError, "Only interleaved images can be read" );
data = cvGetFileNodeByName( fs, node, "data" );
if( header_node )
{
+ CV_Assert(header_dt);
cvReadRawData( fs, header_node, (char*)seq + sizeof(CvSeq), header_dt );
}
else if( rect_node )
CvSeq* seq;
int level;
seq = (CvSeq*)cvRead( fs, elem );
+ CV_Assert(seq);
level = cvReadIntByName( fs, elem, "level", -1 );
if( level < 0 )
CV_Error( CV_StsParseError, "All the sequence tree nodes should contain \"level\" field" );
graph = cvCreateGraph( flags, header_size, vtx_size, edge_size, fs->dststorage );
if( header_node )
+ {
+ CV_Assert(header_dt);
cvReadRawData( fs, header_node, (char*)graph + sizeof(CvGraph), header_dt );
+ }
read_buf_size = MAX( src_vtx_size*3, 1 << 16 );
read_buf_size = MAX( src_edge_size*3, read_buf_size );
return cvRead( (CvFileStorage*)fs, (CvFileNode*)node );
}
+static const FileNodeIterator::SeqReader emptyReader = {0, 0, 0, 0, 0, 0, 0, 0};
+
FileNodeIterator::FileNodeIterator()
{
fs = 0;
container = 0;
- reader.ptr = 0;
+ reader = emptyReader;
remaining = 0;
}
FileNodeIterator::FileNodeIterator(const CvFileStorage* _fs,
const CvFileNode* _node, size_t _ofs)
{
+ reader = emptyReader;
if( _fs && _node && CV_NODE_TYPE(_node->tag) != CV_NODE_NONE )
{
int node_type = _node->tag & FileNode::TYPE_MASK;
{
fs = 0;
container = 0;
- reader.ptr = 0;
remaining = 0;
}
}
{
public:
- RawDataToBinaryConvertor(const void* src, int len, const char* dt)
+ RawDataToBinaryConvertor(const void* src, int len, const std::string & dt)
: beg(reinterpret_cast<const uchar *>(src))
, cur(0)
, end(0)
{
CV_Assert(src);
- CV_Assert(dt);
+ CV_Assert(!dt.empty());
CV_Assert(len > 0);
/* calc step and to_binary_funcs */
end = beg;
cur = beg;
- step = ::icvCalcStructSize(dt, 0);
+ step = ::icvCalcStructSize(dt.c_str(), 0);
end = beg + step * static_cast<size_t>(len);
}
};
private:
- void make_to_binary_funcs(const char* dt)
+ void make_to_binary_funcs(const std::string &dt)
{
size_t cnt = 0;
size_t offset = 0;
void base64::Base64Writer::write(const void* _data, size_t len, const char* dt)
{
check_dt(dt);
-
- RawDataToBinaryConvertor convertor(
- _data, static_cast<int>(len), data_type_string.c_str()
- );
+ RawDataToBinaryConvertor convertor(_data, static_cast<int>(len), data_type_string);
emitter->write(convertor);
}
}
};
+template <typename ST, typename DT>
+inline void addChannels(DT * dst, ST * buf, int cn)
+{
+ for (int i = 0; i < 4; ++i)
+ dst[i % cn] += buf[i];
+}
+
#if CV_SSE2
template <>
int CV_DECL_ALIGNED(16) ar[4];
_mm_store_si128((__m128i*)ar, v_sum);
- for (int i = 0; i < 4; i += cn)
- for (int j = 0; j < cn; ++j)
- dst[j] += ar[j + i];
+ addChannels(dst, ar, cn);
return x / cn;
}
_mm_store_pd(ar, v_sum0);
_mm_store_pd(ar + 2, v_sum1);
- for (int i = 0; i < 4; i += cn)
- for (int j = 0; j < cn; ++j)
- dst[j] += ar[j + i];
+ addChannels(dst, ar, cn);
return x / cn;
}
_mm_store_pd(ar, v_sum0);
_mm_store_pd(ar + 2, v_sum1);
- for (int i = 0; i < 4; i += cn)
- for (int j = 0; j < cn; ++j)
- dst[j] += ar[j + i];
+ addChannels(dst, ar, cn);
return x / cn;
}
unsigned int CV_DECL_ALIGNED(16) ar[4];
vst1q_u32(ar, v_sum);
- for (int i = 0; i < 4; i += cn)
- for (int j = 0; j < cn; ++j)
- dst[j] += ar[j + i];
+ addChannels(dst, ar, cn);
return x / cn;
}
int CV_DECL_ALIGNED(16) ar[4];
vst1q_s32(ar, v_sum);
- for (int i = 0; i < 4; i += cn)
- for (int j = 0; j < cn; ++j)
- dst[j] += ar[j + i];
+ addChannels(dst, ar, cn);
return x / cn;
}
unsigned int CV_DECL_ALIGNED(16) ar[4];
vst1q_u32(ar, v_sum);
- for (int i = 0; i < 4; i += cn)
- for (int j = 0; j < cn; ++j)
- dst[j] += ar[j + i];
+ addChannels(dst, ar, cn);
return x / cn;
}
int CV_DECL_ALIGNED(16) ar[4];
vst1q_s32(ar, v_sum);
- for (int i = 0; i < 4; i += cn)
- for (int j = 0; j < cn; ++j)
- dst[j] += ar[j + i];
+ addChannels(dst, ar, cn);
return x / cn;
}
}
};
+template <typename T>
+inline void addSqrChannels(T * sum, T * sqsum, T * buf, int cn)
+{
+ for (int i = 0; i < 4; ++i)
+ {
+ sum[i % cn] += buf[i];
+ sqsum[i % cn] += buf[4 + i];
+ }
+}
+
#if CV_SSE2
template <>
_mm_store_si128((__m128i*)ar, v_sum);
_mm_store_si128((__m128i*)(ar + 4), v_sqsum);
- for (int i = 0; i < 4; i += cn)
- for (int j = 0; j < cn; ++j)
- {
- sum[j] += ar[j + i];
- sqsum[j] += ar[4 + j + i];
- }
+ addSqrChannels(sum, sqsum, ar, cn);
return x / cn;
}
_mm_store_si128((__m128i*)ar, v_sum);
_mm_store_si128((__m128i*)(ar + 4), v_sqsum);
- for (int i = 0; i < 4; i += cn)
- for (int j = 0; j < cn; ++j)
- {
- sum[j] += ar[j + i];
- sqsum[j] += ar[4 + j + i];
- }
+ addSqrChannels(sum, sqsum, ar, cn);
return x / cn;
}
#if IPP_VERSION_X100 >= 700
int cn = src.channels();
+ if (cn > 4)
+ return false;
size_t total_size = src.total();
int rows = src.size[0], cols = rows ? (int)(total_size/rows) : 0;
if( src.dims == 2 || (src.isContinuous() && cols > 0 && (size_t)rows*cols == total_size) )
#if IPP_VERSION_X100 >= 700
size_t total_size = src.total();
+ int cn = src.channels();
+ if (cn > 4)
+ return false;
int rows = src.size[0], cols = rows ? (int)(total_size/rows) : 0;
if( src.dims == 2 || (src.isContinuous() && mask.isContinuous() && cols > 0 && (size_t)rows*cols == total_size) )
{
CV_INSTRUMENT_FUN_IPP(ippiMean, src.ptr(), (int)src.step[0], sz, res);
if( status >= 0 )
{
- for( int i = 0; i < src.channels(); i++ )
+ for( int i = 0; i < cn; i++ )
ret[i] = res[i];
return true;
}
bool haveMask = _mask.kind() != _InputArray::NONE;
int nz = haveMask ? -1 : (int)_src.total();
Scalar mean, stddev;
+ const int cn = _src.channels();
+ if (cn > 4)
+ return false;
{
- int type = _src.type(), depth = CV_MAT_DEPTH(type), cn = CV_MAT_CN(type);
+ int type = _src.type(), depth = CV_MAT_DEPTH(type);
bool doubleSupport = ocl::Device::getDefault().doubleFPConfig() > 0,
isContinuous = _src.isContinuous(),
isMaskContinuous = _mask.isContinuous();
wgs2_aligned <<= 1;
wgs2_aligned >>= 1;
- if ( (!doubleSupport && depth == CV_64F) || cn > 4 )
+ if ( (!doubleSupport && depth == CV_64F) )
return false;
char cvt[2][40];
}
double total = nz != 0 ? 1.0 / nz : 0;
- int k, j, cn = _src.channels();
+ int k, j;
for (int i = 0; i < cn; ++i)
{
mean[i] *= total;
if (d.isNVidia())
return false;
#endif
-
- int type = _src.type(), depth = CV_MAT_DEPTH(type), cn = CV_MAT_CN(type);
+ const int cn = _src.channels();
+ if (cn > 4)
+ return false;
+ int type = _src.type(), depth = CV_MAT_DEPTH(type);
bool doubleSupport = d.doubleFPConfig() > 0,
haveMask = _mask.kind() != _InputArray::NONE;
OCL_OP_SUM_SQR : (unstype ? OCL_OP_SUM : OCL_OP_SUM_ABS), _mask) )
return false;
- if (!haveMask)
- cn = 1;
-
double s = 0.0;
- for (int i = 0; i < cn; ++i)
+ for (int i = 0; i < (haveMask ? cn : 1); ++i)
s += sc[i];
result = normType == NORM_L1 || normType == NORM_L2SQR ? s : std::sqrt(s);
#endif
Scalar sc1, sc2;
- int type = _src1.type(), depth = CV_MAT_DEPTH(type), cn = CV_MAT_CN(type);
+ int cn = _src1.channels();
+ if (cn > 4)
+ return false;
+ int type = _src1.type(), depth = CV_MAT_DEPTH(type);
bool relative = (normType & NORM_RELATIVE) != 0;
normType &= ~NORM_RELATIVE;
bool normsum = normType == NORM_L1 || normType == NORM_L2 || normType == NORM_L2SQR;
projects / platform / upstream / opencv.git / commitdiff