www.pudn.com > vcmatlab20060426WaterMark.zip > iofun_private_imftype.cpp
//
// MATLAB Compiler: 2.2
// Date: Tue May 10 11:47:30 2005
// Arguments: "-B" "macro_default" "-O" "all" "-O" "fold_scalar_mxarrays:on"
// "-O" "fold_non_scalar_mxarrays:on" "-O" "optimize_integer_for_loops:on" "-O"
// "array_indexing:on" "-O" "optimize_conditionals:on" "-B" "sglcpp" "-p" "-W"
// "main" "-L" "Cpp" "-t" "-T" "link:exe" "-h" "libmmfile.mlib" "-W" "mainhg"
// "libmwsglm.mlib" "huatu"
//
#include "iofun_private_imftype.hpp"
#include "libmatlbm.hpp"
#include "libmmfile.hpp"
static mxChar _array1_[160] = { 'R', 'u', 'n', '-', 't', 'i', 'm', 'e', ' ',
'E', 'r', 'r', 'o', 'r', ':', ' ', 'F', 'i',
'l', 'e', ':', ' ', 'i', 'o', 'f', 'u', 'n',
'/', 'p', 'r', 'i', 'v', 'a', 't', 'e', '/',
'i', 'm', 'f', 't', 'y', 'p', 'e', ' ', 'L',
'i', 'n', 'e', ':', ' ', '1', ' ', 'C', 'o',
'l', 'u', 'm', 'n', ':', ' ', '1', ' ', 'T',
'h', 'e', ' ', 'f', 'u', 'n', 'c', 't', 'i',
'o', 'n', ' ', '"', 'i', 'o', 'f', 'u', 'n',
'/', 'p', 'r', 'i', 'v', 'a', 't', 'e', '/',
'i', 'm', 'f', 't', 'y', 'p', 'e', '"', ' ',
'w', 'a', 's', ' ', 'c', 'a', 'l', 'l', 'e',
'd', ' ', 'w', 'i', 't', 'h', ' ', 'm', 'o',
'r', 'e', ' ', 't', 'h', 'a', 'n', ' ', 't',
'h', 'e', ' ', 'd', 'e', 'c', 'l', 'a', 'r',
'e', 'd', ' ', 'n', 'u', 'm', 'b', 'e', 'r',
' ', 'o', 'f', ' ', 'o', 'u', 't', 'p', 'u',
't', 's', ' ', '(', '1', ')', '.' };
static mwArray _mxarray0_ = mclInitializeString(160, _array1_);
static mxChar _array3_[159] = { 'R', 'u', 'n', '-', 't', 'i', 'm', 'e', ' ',
'E', 'r', 'r', 'o', 'r', ':', ' ', 'F', 'i',
'l', 'e', ':', ' ', 'i', 'o', 'f', 'u', 'n',
'/', 'p', 'r', 'i', 'v', 'a', 't', 'e', '/',
'i', 'm', 'f', 't', 'y', 'p', 'e', ' ', 'L',
'i', 'n', 'e', ':', ' ', '1', ' ', 'C', 'o',
'l', 'u', 'm', 'n', ':', ' ', '1', ' ', 'T',
'h', 'e', ' ', 'f', 'u', 'n', 'c', 't', 'i',
'o', 'n', ' ', '"', 'i', 'o', 'f', 'u', 'n',
'/', 'p', 'r', 'i', 'v', 'a', 't', 'e', '/',
'i', 'm', 'f', 't', 'y', 'p', 'e', '"', ' ',
'w', 'a', 's', ' ', 'c', 'a', 'l', 'l', 'e',
'd', ' ', 'w', 'i', 't', 'h', ' ', 'm', 'o',
'r', 'e', ' ', 't', 'h', 'a', 'n', ' ', 't',
'h', 'e', ' ', 'd', 'e', 'c', 'l', 'a', 'r',
'e', 'd', ' ', 'n', 'u', 'm', 'b', 'e', 'r',
' ', 'o', 'f', ' ', 'i', 'n', 'p', 'u', 't',
's', ' ', '(', '1', ')', '.' };
static mwArray _mxarray2_ = mclInitializeString(159, _array3_);
static mxChar _array5_[146] = { 'R', 'u', 'n', '-', 't', 'i', 'm', 'e', ' ',
'E', 'r', 'r', 'o', 'r', ':', ' ', 'F', 'i',
'l', 'e', ':', ' ', 'i', 'm', 'f', 't', 'y',
'p', 'e', '/', 'i', 's', 'b', 'm', 'p', ' ',
'L', 'i', 'n', 'e', ':', ' ', '1', '6', '9',
' ', 'C', 'o', 'l', 'u', 'm', 'n', ':', ' ',
'1', ' ', 'T', 'h', 'e', ' ', 'f', 'u', 'n',
'c', 't', 'i', 'o', 'n', ' ', '"', 'i', 'm',
'f', 't', 'y', 'p', 'e', '/', 'i', 's', 'b',
'm', 'p', '"', ' ', 'w', 'a', 's', ' ', 'c',
'a', 'l', 'l', 'e', 'd', ' ', 'w', 'i', 't',
'h', ' ', 'm', 'o', 'r', 'e', ' ', 't', 'h',
'a', 'n', ' ', 't', 'h', 'e', ' ', 'd', 'e',
'c', 'l', 'a', 'r', 'e', 'd', ' ', 'n', 'u',
'm', 'b', 'e', 'r', ' ', 'o', 'f', ' ', 'o',
'u', 't', 'p', 'u', 't', 's', ' ', '(', '1',
')', '.' };
static mwArray _mxarray4_ = mclInitializeString(146, _array5_);
static mxChar _array7_[145] = { 'R', 'u', 'n', '-', 't', 'i', 'm', 'e', ' ',
'E', 'r', 'r', 'o', 'r', ':', ' ', 'F', 'i',
'l', 'e', ':', ' ', 'i', 'm', 'f', 't', 'y',
'p', 'e', '/', 'i', 's', 'b', 'm', 'p', ' ',
'L', 'i', 'n', 'e', ':', ' ', '1', '6', '9',
' ', 'C', 'o', 'l', 'u', 'm', 'n', ':', ' ',
'1', ' ', 'T', 'h', 'e', ' ', 'f', 'u', 'n',
'c', 't', 'i', 'o', 'n', ' ', '"', 'i', 'm',
'f', 't', 'y', 'p', 'e', '/', 'i', 's', 'b',
'm', 'p', '"', ' ', 'w', 'a', 's', ' ', 'c',
'a', 'l', 'l', 'e', 'd', ' ', 'w', 'i', 't',
'h', ' ', 'm', 'o', 'r', 'e', ' ', 't', 'h',
'a', 'n', ' ', 't', 'h', 'e', ' ', 'd', 'e',
'c', 'l', 'a', 'r', 'e', 'd', ' ', 'n', 'u',
'm', 'b', 'e', 'r', ' ', 'o', 'f', ' ', 'i',
'n', 'p', 'u', 't', 's', ' ', '(', '1', ')',
'.' };
static mwArray _mxarray6_ = mclInitializeString(145, _array7_);
static mxChar _array9_[146] = { 'R', 'u', 'n', '-', 't', 'i', 'm', 'e', ' ',
'E', 'r', 'r', 'o', 'r', ':', ' ', 'F', 'i',
'l', 'e', ':', ' ', 'i', 'm', 'f', 't', 'y',
'p', 'e', '/', 'i', 's', 'x', 'w', 'd', ' ',
'L', 'i', 'n', 'e', ':', ' ', '1', '8', '2',
' ', 'C', 'o', 'l', 'u', 'm', 'n', ':', ' ',
'1', ' ', 'T', 'h', 'e', ' ', 'f', 'u', 'n',
'c', 't', 'i', 'o', 'n', ' ', '"', 'i', 'm',
'f', 't', 'y', 'p', 'e', '/', 'i', 's', 'x',
'w', 'd', '"', ' ', 'w', 'a', 's', ' ', 'c',
'a', 'l', 'l', 'e', 'd', ' ', 'w', 'i', 't',
'h', ' ', 'm', 'o', 'r', 'e', ' ', 't', 'h',
'a', 'n', ' ', 't', 'h', 'e', ' ', 'd', 'e',
'c', 'l', 'a', 'r', 'e', 'd', ' ', 'n', 'u',
'm', 'b', 'e', 'r', ' ', 'o', 'f', ' ', 'o',
'u', 't', 'p', 'u', 't', 's', ' ', '(', '1',
')', '.' };
static mwArray _mxarray8_ = mclInitializeString(146, _array9_);
static mxChar _array11_[145] = { 'R', 'u', 'n', '-', 't', 'i', 'm', 'e', ' ',
'E', 'r', 'r', 'o', 'r', ':', ' ', 'F', 'i',
'l', 'e', ':', ' ', 'i', 'm', 'f', 't', 'y',
'p', 'e', '/', 'i', 's', 'x', 'w', 'd', ' ',
'L', 'i', 'n', 'e', ':', ' ', '1', '8', '2',
' ', 'C', 'o', 'l', 'u', 'm', 'n', ':', ' ',
'1', ' ', 'T', 'h', 'e', ' ', 'f', 'u', 'n',
'c', 't', 'i', 'o', 'n', ' ', '"', 'i', 'm',
'f', 't', 'y', 'p', 'e', '/', 'i', 's', 'x',
'w', 'd', '"', ' ', 'w', 'a', 's', ' ', 'c',
'a', 'l', 'l', 'e', 'd', ' ', 'w', 'i', 't',
'h', ' ', 'm', 'o', 'r', 'e', ' ', 't', 'h',
'a', 'n', ' ', 't', 'h', 'e', ' ', 'd', 'e',
'c', 'l', 'a', 'r', 'e', 'd', ' ', 'n', 'u',
'm', 'b', 'e', 'r', ' ', 'o', 'f', ' ', 'i',
'n', 'p', 'u', 't', 's', ' ', '(', '1', ')',
'.' };
static mwArray _mxarray10_ = mclInitializeString(145, _array11_);
static mxChar _array13_[146] = { 'R', 'u', 'n', '-', 't', 'i', 'm', 'e', ' ',
'E', 'r', 'r', 'o', 'r', ':', ' ', 'F', 'i',
'l', 'e', ':', ' ', 'i', 'm', 'f', 't', 'y',
'p', 'e', '/', 'i', 's', 'p', 'n', 'g', ' ',
'L', 'i', 'n', 'e', ':', ' ', '2', '1', '2',
' ', 'C', 'o', 'l', 'u', 'm', 'n', ':', ' ',
'1', ' ', 'T', 'h', 'e', ' ', 'f', 'u', 'n',
'c', 't', 'i', 'o', 'n', ' ', '"', 'i', 'm',
'f', 't', 'y', 'p', 'e', '/', 'i', 's', 'p',
'n', 'g', '"', ' ', 'w', 'a', 's', ' ', 'c',
'a', 'l', 'l', 'e', 'd', ' ', 'w', 'i', 't',
'h', ' ', 'm', 'o', 'r', 'e', ' ', 't', 'h',
'a', 'n', ' ', 't', 'h', 'e', ' ', 'd', 'e',
'c', 'l', 'a', 'r', 'e', 'd', ' ', 'n', 'u',
'm', 'b', 'e', 'r', ' ', 'o', 'f', ' ', 'o',
'u', 't', 'p', 'u', 't', 's', ' ', '(', '1',
')', '.' };
static mwArray _mxarray12_ = mclInitializeString(146, _array13_);
static mxChar _array15_[145] = { 'R', 'u', 'n', '-', 't', 'i', 'm', 'e', ' ',
'E', 'r', 'r', 'o', 'r', ':', ' ', 'F', 'i',
'l', 'e', ':', ' ', 'i', 'm', 'f', 't', 'y',
'p', 'e', '/', 'i', 's', 'p', 'n', 'g', ' ',
'L', 'i', 'n', 'e', ':', ' ', '2', '1', '2',
' ', 'C', 'o', 'l', 'u', 'm', 'n', ':', ' ',
'1', ' ', 'T', 'h', 'e', ' ', 'f', 'u', 'n',
'c', 't', 'i', 'o', 'n', ' ', '"', 'i', 'm',
'f', 't', 'y', 'p', 'e', '/', 'i', 's', 'p',
'n', 'g', '"', ' ', 'w', 'a', 's', ' ', 'c',
'a', 'l', 'l', 'e', 'd', ' ', 'w', 'i', 't',
'h', ' ', 'm', 'o', 'r', 'e', ' ', 't', 'h',
'a', 'n', ' ', 't', 'h', 'e', ' ', 'd', 'e',
'c', 'l', 'a', 'r', 'e', 'd', ' ', 'n', 'u',
'm', 'b', 'e', 'r', ' ', 'o', 'f', ' ', 'i',
'n', 'p', 'u', 't', 's', ' ', '(', '1', ')',
'.' };
static mwArray _mxarray14_ = mclInitializeString(145, _array15_);
static mxChar _array17_[146] = { 'R', 'u', 'n', '-', 't', 'i', 'm', 'e', ' ',
'E', 'r', 'r', 'o', 'r', ':', ' ', 'F', 'i',
'l', 'e', ':', ' ', 'i', 'm', 'f', 't', 'y',
'p', 'e', '/', 'i', 's', 'p', 'c', 'x', ' ',
'L', 'i', 'n', 'e', ':', ' ', '2', '2', '5',
' ', 'C', 'o', 'l', 'u', 'm', 'n', ':', ' ',
'1', ' ', 'T', 'h', 'e', ' ', 'f', 'u', 'n',
'c', 't', 'i', 'o', 'n', ' ', '"', 'i', 'm',
'f', 't', 'y', 'p', 'e', '/', 'i', 's', 'p',
'c', 'x', '"', ' ', 'w', 'a', 's', ' ', 'c',
'a', 'l', 'l', 'e', 'd', ' ', 'w', 'i', 't',
'h', ' ', 'm', 'o', 'r', 'e', ' ', 't', 'h',
'a', 'n', ' ', 't', 'h', 'e', ' ', 'd', 'e',
'c', 'l', 'a', 'r', 'e', 'd', ' ', 'n', 'u',
'm', 'b', 'e', 'r', ' ', 'o', 'f', ' ', 'o',
'u', 't', 'p', 'u', 't', 's', ' ', '(', '1',
')', '.' };
static mwArray _mxarray16_ = mclInitializeString(146, _array17_);
static mxChar _array19_[145] = { 'R', 'u', 'n', '-', 't', 'i', 'm', 'e', ' ',
'E', 'r', 'r', 'o', 'r', ':', ' ', 'F', 'i',
'l', 'e', ':', ' ', 'i', 'm', 'f', 't', 'y',
'p', 'e', '/', 'i', 's', 'p', 'c', 'x', ' ',
'L', 'i', 'n', 'e', ':', ' ', '2', '2', '5',
' ', 'C', 'o', 'l', 'u', 'm', 'n', ':', ' ',
'1', ' ', 'T', 'h', 'e', ' ', 'f', 'u', 'n',
'c', 't', 'i', 'o', 'n', ' ', '"', 'i', 'm',
'f', 't', 'y', 'p', 'e', '/', 'i', 's', 'p',
'c', 'x', '"', ' ', 'w', 'a', 's', ' ', 'c',
'a', 'l', 'l', 'e', 'd', ' ', 'w', 'i', 't',
'h', ' ', 'm', 'o', 'r', 'e', ' ', 't', 'h',
'a', 'n', ' ', 't', 'h', 'e', ' ', 'd', 'e',
'c', 'l', 'a', 'r', 'e', 'd', ' ', 'n', 'u',
'm', 'b', 'e', 'r', ' ', 'o', 'f', ' ', 'i',
'n', 'p', 'u', 't', 's', ' ', '(', '1', ')',
'.' };
static mwArray _mxarray18_ = mclInitializeString(145, _array19_);
static mxChar _array21_[146] = { 'R', 'u', 'n', '-', 't', 'i', 'm', 'e', ' ',
'E', 'r', 'r', 'o', 'r', ':', ' ', 'F', 'i',
'l', 'e', ':', ' ', 'i', 'm', 'f', 't', 'y',
'p', 'e', '/', 'i', 's', 'j', 'p', 'g', ' ',
'L', 'i', 'n', 'e', ':', ' ', '2', '4', '2',
' ', 'C', 'o', 'l', 'u', 'm', 'n', ':', ' ',
'1', ' ', 'T', 'h', 'e', ' ', 'f', 'u', 'n',
'c', 't', 'i', 'o', 'n', ' ', '"', 'i', 'm',
'f', 't', 'y', 'p', 'e', '/', 'i', 's', 'j',
'p', 'g', '"', ' ', 'w', 'a', 's', ' ', 'c',
'a', 'l', 'l', 'e', 'd', ' ', 'w', 'i', 't',
'h', ' ', 'm', 'o', 'r', 'e', ' ', 't', 'h',
'a', 'n', ' ', 't', 'h', 'e', ' ', 'd', 'e',
'c', 'l', 'a', 'r', 'e', 'd', ' ', 'n', 'u',
'm', 'b', 'e', 'r', ' ', 'o', 'f', ' ', 'o',
'u', 't', 'p', 'u', 't', 's', ' ', '(', '1',
')', '.' };
static mwArray _mxarray20_ = mclInitializeString(146, _array21_);
static mxChar _array23_[145] = { 'R', 'u', 'n', '-', 't', 'i', 'm', 'e', ' ',
'E', 'r', 'r', 'o', 'r', ':', ' ', 'F', 'i',
'l', 'e', ':', ' ', 'i', 'm', 'f', 't', 'y',
'p', 'e', '/', 'i', 's', 'j', 'p', 'g', ' ',
'L', 'i', 'n', 'e', ':', ' ', '2', '4', '2',
' ', 'C', 'o', 'l', 'u', 'm', 'n', ':', ' ',
'1', ' ', 'T', 'h', 'e', ' ', 'f', 'u', 'n',
'c', 't', 'i', 'o', 'n', ' ', '"', 'i', 'm',
'f', 't', 'y', 'p', 'e', '/', 'i', 's', 'j',
'p', 'g', '"', ' ', 'w', 'a', 's', ' ', 'c',
'a', 'l', 'l', 'e', 'd', ' ', 'w', 'i', 't',
'h', ' ', 'm', 'o', 'r', 'e', ' ', 't', 'h',
'a', 'n', ' ', 't', 'h', 'e', ' ', 'd', 'e',
'c', 'l', 'a', 'r', 'e', 'd', ' ', 'n', 'u',
'm', 'b', 'e', 'r', ' ', 'o', 'f', ' ', 'i',
'n', 'p', 'u', 't', 's', ' ', '(', '1', ')',
'.' };
static mwArray _mxarray22_ = mclInitializeString(145, _array23_);
static mxChar _array25_[146] = { 'R', 'u', 'n', '-', 't', 'i', 'm', 'e', ' ',
'E', 'r', 'r', 'o', 'r', ':', ' ', 'F', 'i',
'l', 'e', ':', ' ', 'i', 'm', 'f', 't', 'y',
'p', 'e', '/', 'i', 's', 't', 'i', 'f', ' ',
'L', 'i', 'n', 'e', ':', ' ', '2', '5', '5',
' ', 'C', 'o', 'l', 'u', 'm', 'n', ':', ' ',
'1', ' ', 'T', 'h', 'e', ' ', 'f', 'u', 'n',
'c', 't', 'i', 'o', 'n', ' ', '"', 'i', 'm',
'f', 't', 'y', 'p', 'e', '/', 'i', 's', 't',
'i', 'f', '"', ' ', 'w', 'a', 's', ' ', 'c',
'a', 'l', 'l', 'e', 'd', ' ', 'w', 'i', 't',
'h', ' ', 'm', 'o', 'r', 'e', ' ', 't', 'h',
'a', 'n', ' ', 't', 'h', 'e', ' ', 'd', 'e',
'c', 'l', 'a', 'r', 'e', 'd', ' ', 'n', 'u',
'm', 'b', 'e', 'r', ' ', 'o', 'f', ' ', 'o',
'u', 't', 'p', 'u', 't', 's', ' ', '(', '1',
')', '.' };
static mwArray _mxarray24_ = mclInitializeString(146, _array25_);
static mxChar _array27_[145] = { 'R', 'u', 'n', '-', 't', 'i', 'm', 'e', ' ',
'E', 'r', 'r', 'o', 'r', ':', ' ', 'F', 'i',
'l', 'e', ':', ' ', 'i', 'm', 'f', 't', 'y',
'p', 'e', '/', 'i', 's', 't', 'i', 'f', ' ',
'L', 'i', 'n', 'e', ':', ' ', '2', '5', '5',
' ', 'C', 'o', 'l', 'u', 'm', 'n', ':', ' ',
'1', ' ', 'T', 'h', 'e', ' ', 'f', 'u', 'n',
'c', 't', 'i', 'o', 'n', ' ', '"', 'i', 'm',
'f', 't', 'y', 'p', 'e', '/', 'i', 's', 't',
'i', 'f', '"', ' ', 'w', 'a', 's', ' ', 'c',
'a', 'l', 'l', 'e', 'd', ' ', 'w', 'i', 't',
'h', ' ', 'm', 'o', 'r', 'e', ' ', 't', 'h',
'a', 'n', ' ', 't', 'h', 'e', ' ', 'd', 'e',
'c', 'l', 'a', 'r', 'e', 'd', ' ', 'n', 'u',
'm', 'b', 'e', 'r', ' ', 'o', 'f', ' ', 'i',
'n', 'p', 'u', 't', 's', ' ', '(', '1', ')',
'.' };
static mwArray _mxarray26_ = mclInitializeString(145, _array27_);
static mxChar _array29_[146] = { 'R', 'u', 'n', '-', 't', 'i', 'm', 'e', ' ',
'E', 'r', 'r', 'o', 'r', ':', ' ', 'F', 'i',
'l', 'e', ':', ' ', 'i', 'm', 'f', 't', 'y',
'p', 'e', '/', 'i', 's', 'h', 'd', 'f', ' ',
'L', 'i', 'n', 'e', ':', ' ', '2', '6', '8',
' ', 'C', 'o', 'l', 'u', 'm', 'n', ':', ' ',
'1', ' ', 'T', 'h', 'e', ' ', 'f', 'u', 'n',
'c', 't', 'i', 'o', 'n', ' ', '"', 'i', 'm',
'f', 't', 'y', 'p', 'e', '/', 'i', 's', 'h',
'd', 'f', '"', ' ', 'w', 'a', 's', ' ', 'c',
'a', 'l', 'l', 'e', 'd', ' ', 'w', 'i', 't',
'h', ' ', 'm', 'o', 'r', 'e', ' ', 't', 'h',
'a', 'n', ' ', 't', 'h', 'e', ' ', 'd', 'e',
'c', 'l', 'a', 'r', 'e', 'd', ' ', 'n', 'u',
'm', 'b', 'e', 'r', ' ', 'o', 'f', ' ', 'o',
'u', 't', 'p', 'u', 't', 's', ' ', '(', '1',
')', '.' };
static mwArray _mxarray28_ = mclInitializeString(146, _array29_);
static mxChar _array31_[145] = { 'R', 'u', 'n', '-', 't', 'i', 'm', 'e', ' ',
'E', 'r', 'r', 'o', 'r', ':', ' ', 'F', 'i',
'l', 'e', ':', ' ', 'i', 'm', 'f', 't', 'y',
'p', 'e', '/', 'i', 's', 'h', 'd', 'f', ' ',
'L', 'i', 'n', 'e', ':', ' ', '2', '6', '8',
' ', 'C', 'o', 'l', 'u', 'm', 'n', ':', ' ',
'1', ' ', 'T', 'h', 'e', ' ', 'f', 'u', 'n',
'c', 't', 'i', 'o', 'n', ' ', '"', 'i', 'm',
'f', 't', 'y', 'p', 'e', '/', 'i', 's', 'h',
'd', 'f', '"', ' ', 'w', 'a', 's', ' ', 'c',
'a', 'l', 'l', 'e', 'd', ' ', 'w', 'i', 't',
'h', ' ', 'm', 'o', 'r', 'e', ' ', 't', 'h',
'a', 'n', ' ', 't', 'h', 'e', ' ', 'd', 'e',
'c', 'l', 'a', 'r', 'e', 'd', ' ', 'n', 'u',
'm', 'b', 'e', 'r', ' ', 'o', 'f', ' ', 'i',
'n', 'p', 'u', 't', 's', ' ', '(', '1', ')',
'.' };
static mwArray _mxarray30_ = mclInitializeString(145, _array31_);
static mxChar _array33_[146] = { 'R', 'u', 'n', '-', 't', 'i', 'm', 'e', ' ',
'E', 'r', 'r', 'o', 'r', ':', ' ', 'F', 'i',
'l', 'e', ':', ' ', 'i', 'm', 'f', 't', 'y',
'p', 'e', '/', 'i', 's', 'g', 'i', 'f', ' ',
'L', 'i', 'n', 'e', ':', ' ', '2', '8', '1',
' ', 'C', 'o', 'l', 'u', 'm', 'n', ':', ' ',
'1', ' ', 'T', 'h', 'e', ' ', 'f', 'u', 'n',
'c', 't', 'i', 'o', 'n', ' ', '"', 'i', 'm',
'f', 't', 'y', 'p', 'e', '/', 'i', 's', 'g',
'i', 'f', '"', ' ', 'w', 'a', 's', ' ', 'c',
'a', 'l', 'l', 'e', 'd', ' ', 'w', 'i', 't',
'h', ' ', 'm', 'o', 'r', 'e', ' ', 't', 'h',
'a', 'n', ' ', 't', 'h', 'e', ' ', 'd', 'e',
'c', 'l', 'a', 'r', 'e', 'd', ' ', 'n', 'u',
'm', 'b', 'e', 'r', ' ', 'o', 'f', ' ', 'o',
'u', 't', 'p', 'u', 't', 's', ' ', '(', '1',
')', '.' };
static mwArray _mxarray32_ = mclInitializeString(146, _array33_);
static mxChar _array35_[145] = { 'R', 'u', 'n', '-', 't', 'i', 'm', 'e', ' ',
'E', 'r', 'r', 'o', 'r', ':', ' ', 'F', 'i',
'l', 'e', ':', ' ', 'i', 'm', 'f', 't', 'y',
'p', 'e', '/', 'i', 's', 'g', 'i', 'f', ' ',
'L', 'i', 'n', 'e', ':', ' ', '2', '8', '1',
' ', 'C', 'o', 'l', 'u', 'm', 'n', ':', ' ',
'1', ' ', 'T', 'h', 'e', ' ', 'f', 'u', 'n',
'c', 't', 'i', 'o', 'n', ' ', '"', 'i', 'm',
'f', 't', 'y', 'p', 'e', '/', 'i', 's', 'g',
'i', 'f', '"', ' ', 'w', 'a', 's', ' ', 'c',
'a', 'l', 'l', 'e', 'd', ' ', 'w', 'i', 't',
'h', ' ', 'm', 'o', 'r', 'e', ' ', 't', 'h',
'a', 'n', ' ', 't', 'h', 'e', ' ', 'd', 'e',
'c', 'l', 'a', 'r', 'e', 'd', ' ', 'n', 'u',
'm', 'b', 'e', 'r', ' ', 'o', 'f', ' ', 'i',
'n', 'p', 'u', 't', 's', ' ', '(', '1', ')',
'.' };
static mwArray _mxarray34_ = mclInitializeString(145, _array35_);
static mxChar _array37_[146] = { 'R', 'u', 'n', '-', 't', 'i', 'm', 'e', ' ',
'E', 'r', 'r', 'o', 'r', ':', ' ', 'F', 'i',
'l', 'e', ':', ' ', 'i', 'm', 'f', 't', 'y',
'p', 'e', '/', 'i', 's', 'c', 'u', 'r', ' ',
'L', 'i', 'n', 'e', ':', ' ', '2', '9', '4',
' ', 'C', 'o', 'l', 'u', 'm', 'n', ':', ' ',
'1', ' ', 'T', 'h', 'e', ' ', 'f', 'u', 'n',
'c', 't', 'i', 'o', 'n', ' ', '"', 'i', 'm',
'f', 't', 'y', 'p', 'e', '/', 'i', 's', 'c',
'u', 'r', '"', ' ', 'w', 'a', 's', ' ', 'c',
'a', 'l', 'l', 'e', 'd', ' ', 'w', 'i', 't',
'h', ' ', 'm', 'o', 'r', 'e', ' ', 't', 'h',
'a', 'n', ' ', 't', 'h', 'e', ' ', 'd', 'e',
'c', 'l', 'a', 'r', 'e', 'd', ' ', 'n', 'u',
'm', 'b', 'e', 'r', ' ', 'o', 'f', ' ', 'o',
'u', 't', 'p', 'u', 't', 's', ' ', '(', '1',
')', '.' };
static mwArray _mxarray36_ = mclInitializeString(146, _array37_);
static mxChar _array39_[145] = { 'R', 'u', 'n', '-', 't', 'i', 'm', 'e', ' ',
'E', 'r', 'r', 'o', 'r', ':', ' ', 'F', 'i',
'l', 'e', ':', ' ', 'i', 'm', 'f', 't', 'y',
'p', 'e', '/', 'i', 's', 'c', 'u', 'r', ' ',
'L', 'i', 'n', 'e', ':', ' ', '2', '9', '4',
' ', 'C', 'o', 'l', 'u', 'm', 'n', ':', ' ',
'1', ' ', 'T', 'h', 'e', ' ', 'f', 'u', 'n',
'c', 't', 'i', 'o', 'n', ' ', '"', 'i', 'm',
'f', 't', 'y', 'p', 'e', '/', 'i', 's', 'c',
'u', 'r', '"', ' ', 'w', 'a', 's', ' ', 'c',
'a', 'l', 'l', 'e', 'd', ' ', 'w', 'i', 't',
'h', ' ', 'm', 'o', 'r', 'e', ' ', 't', 'h',
'a', 'n', ' ', 't', 'h', 'e', ' ', 'd', 'e',
'c', 'l', 'a', 'r', 'e', 'd', ' ', 'n', 'u',
'm', 'b', 'e', 'r', ' ', 'o', 'f', ' ', 'i',
'n', 'p', 'u', 't', 's', ' ', '(', '1', ')',
'.' };
static mwArray _mxarray38_ = mclInitializeString(145, _array39_);
static mxChar _array41_[146] = { 'R', 'u', 'n', '-', 't', 'i', 'm', 'e', ' ',
'E', 'r', 'r', 'o', 'r', ':', ' ', 'F', 'i',
'l', 'e', ':', ' ', 'i', 'm', 'f', 't', 'y',
'p', 'e', '/', 'i', 's', 'i', 'c', 'o', ' ',
'L', 'i', 'n', 'e', ':', ' ', '3', '0', '7',
' ', 'C', 'o', 'l', 'u', 'm', 'n', ':', ' ',
'1', ' ', 'T', 'h', 'e', ' ', 'f', 'u', 'n',
'c', 't', 'i', 'o', 'n', ' ', '"', 'i', 'm',
'f', 't', 'y', 'p', 'e', '/', 'i', 's', 'i',
'c', 'o', '"', ' ', 'w', 'a', 's', ' ', 'c',
'a', 'l', 'l', 'e', 'd', ' ', 'w', 'i', 't',
'h', ' ', 'm', 'o', 'r', 'e', ' ', 't', 'h',
'a', 'n', ' ', 't', 'h', 'e', ' ', 'd', 'e',
'c', 'l', 'a', 'r', 'e', 'd', ' ', 'n', 'u',
'm', 'b', 'e', 'r', ' ', 'o', 'f', ' ', 'o',
'u', 't', 'p', 'u', 't', 's', ' ', '(', '1',
')', '.' };
static mwArray _mxarray40_ = mclInitializeString(146, _array41_);
static mxChar _array43_[145] = { 'R', 'u', 'n', '-', 't', 'i', 'm', 'e', ' ',
'E', 'r', 'r', 'o', 'r', ':', ' ', 'F', 'i',
'l', 'e', ':', ' ', 'i', 'm', 'f', 't', 'y',
'p', 'e', '/', 'i', 's', 'i', 'c', 'o', ' ',
'L', 'i', 'n', 'e', ':', ' ', '3', '0', '7',
' ', 'C', 'o', 'l', 'u', 'm', 'n', ':', ' ',
'1', ' ', 'T', 'h', 'e', ' ', 'f', 'u', 'n',
'c', 't', 'i', 'o', 'n', ' ', '"', 'i', 'm',
'f', 't', 'y', 'p', 'e', '/', 'i', 's', 'i',
'c', 'o', '"', ' ', 'w', 'a', 's', ' ', 'c',
'a', 'l', 'l', 'e', 'd', ' ', 'w', 'i', 't',
'h', ' ', 'm', 'o', 'r', 'e', ' ', 't', 'h',
'a', 'n', ' ', 't', 'h', 'e', ' ', 'd', 'e',
'c', 'l', 'a', 'r', 'e', 'd', ' ', 'n', 'u',
'm', 'b', 'e', 'r', ' ', 'o', 'f', ' ', 'i',
'n', 'p', 'u', 't', 's', ' ', '(', '1', ')',
'.' };
static mwArray _mxarray42_ = mclInitializeString(145, _array43_);
static mxChar _array45_[152] = { 'R', 'u', 'n', '-', 't', 'i', 'm', 'e', ' ',
'E', 'r', 'r', 'o', 'r', ':', ' ', 'F', 'i',
'l', 'e', ':', ' ', 'i', 'm', 'f', 't', 'y',
'p', 'e', '/', 'b', 'y', 't', 'e', 's', 'w',
'a', 'p', ' ', 'L', 'i', 'n', 'e', ':', ' ',
'3', '2', '0', ' ', 'C', 'o', 'l', 'u', 'm',
'n', ':', ' ', '1', ' ', 'T', 'h', 'e', ' ',
'f', 'u', 'n', 'c', 't', 'i', 'o', 'n', ' ',
'"', 'i', 'm', 'f', 't', 'y', 'p', 'e', '/',
'b', 'y', 't', 'e', 's', 'w', 'a', 'p', '"',
' ', 'w', 'a', 's', ' ', 'c', 'a', 'l', 'l',
'e', 'd', ' ', 'w', 'i', 't', 'h', ' ', 'm',
'o', 'r', 'e', ' ', 't', 'h', 'a', 'n', ' ',
't', 'h', 'e', ' ', 'd', 'e', 'c', 'l', 'a',
'r', 'e', 'd', ' ', 'n', 'u', 'm', 'b', 'e',
'r', ' ', 'o', 'f', ' ', 'o', 'u', 't', 'p',
'u', 't', 's', ' ', '(', '1', ')', '.' };
static mwArray _mxarray44_ = mclInitializeString(152, _array45_);
static mxChar _array47_[151] = { 'R', 'u', 'n', '-', 't', 'i', 'm', 'e', ' ',
'E', 'r', 'r', 'o', 'r', ':', ' ', 'F', 'i',
'l', 'e', ':', ' ', 'i', 'm', 'f', 't', 'y',
'p', 'e', '/', 'b', 'y', 't', 'e', 's', 'w',
'a', 'p', ' ', 'L', 'i', 'n', 'e', ':', ' ',
'3', '2', '0', ' ', 'C', 'o', 'l', 'u', 'm',
'n', ':', ' ', '1', ' ', 'T', 'h', 'e', ' ',
'f', 'u', 'n', 'c', 't', 'i', 'o', 'n', ' ',
'"', 'i', 'm', 'f', 't', 'y', 'p', 'e', '/',
'b', 'y', 't', 'e', 's', 'w', 'a', 'p', '"',
' ', 'w', 'a', 's', ' ', 'c', 'a', 'l', 'l',
'e', 'd', ' ', 'w', 'i', 't', 'h', ' ', 'm',
'o', 'r', 'e', ' ', 't', 'h', 'a', 'n', ' ',
't', 'h', 'e', ' ', 'd', 'e', 'c', 'l', 'a',
'r', 'e', 'd', ' ', 'n', 'u', 'm', 'b', 'e',
'r', ' ', 'o', 'f', ' ', 'i', 'n', 'p', 'u',
't', 's', ' ', '(', '1', ')', '.' };
static mwArray _mxarray46_ = mclInitializeString(151, _array47_);
static mwArray _mxarray48_ = mclInitializeDouble(1.0);
static mxChar _array50_[1] = { '.' };
static mwArray _mxarray49_ = mclInitializeString(1, _array50_);
static mwArray _mxarray51_ = mclInitializeCharVector(0, 0, (mxChar *)NULL);
static mwArray _mxarray52_ = mclInitializeDouble(0.0);
static mxChar _array54_[3] = { 'b', 'm', 'p' };
static mwArray _mxarray53_ = mclInitializeString(3, _array54_);
static mxChar _array56_[3] = { 'x', 'w', 'd' };
static mwArray _mxarray55_ = mclInitializeString(3, _array56_);
static mxChar _array58_[3] = { 'p', 'c', 'x' };
static mwArray _mxarray57_ = mclInitializeString(3, _array58_);
static mxChar _array62_[4] = { 'j', 'p', 'e', 'g' };
static mxArray * _mxarray61_ = mclInitializeString(4, _array62_);
static mxChar _array64_[3] = { 'j', 'p', 'g' };
static mxArray * _mxarray63_ = mclInitializeString(3, _array64_);
static mxArray * _array60_[2] = { _mxarray61_, _mxarray63_ };
static mwArray _mxarray59_ = mclInitializeCellVector(1, 2, _array60_);
static mwArray _mxarray65_ = mclInitializeString(3, _array64_);
static mxChar _array69_[4] = { 't', 'i', 'f', 'f' };
static mxArray * _mxarray68_ = mclInitializeString(4, _array69_);
static mxChar _array71_[3] = { 't', 'i', 'f' };
static mxArray * _mxarray70_ = mclInitializeString(3, _array71_);
static mxArray * _array67_[2] = { _mxarray68_, _mxarray70_ };
static mwArray _mxarray66_ = mclInitializeCellVector(1, 2, _array67_);
static mwArray _mxarray72_ = mclInitializeString(3, _array71_);
static mxChar _array74_[3] = { 'h', 'd', 'f' };
static mwArray _mxarray73_ = mclInitializeString(3, _array74_);
static mxChar _array76_[3] = { 'p', 'n', 'g' };
static mwArray _mxarray75_ = mclInitializeString(3, _array76_);
static mxChar _array78_[3] = { 'g', 'i', 'f' };
static mwArray _mxarray77_ = mclInitializeString(3, _array78_);
static mxChar _array80_[3] = { 'c', 'u', 'r' };
static mwArray _mxarray79_ = mclInitializeString(3, _array80_);
static mxChar _array82_[3] = { 'i', 'c', 'o' };
static mwArray _mxarray81_ = mclInitializeString(3, _array82_);
static mxChar _array84_[1] = { 'r' };
static mwArray _mxarray83_ = mclInitializeString(1, _array84_);
static mxChar _array86_[7] = { 'i', 'e', 'e', 'e', '-', 'l', 'e' };
static mwArray _mxarray85_ = mclInitializeString(7, _array86_);
static mwArray _mxarray87_ = mclInitializeDouble(2.0);
static mxChar _array89_[5] = { 'u', 'i', 'n', 't', '8' };
static mwArray _mxarray88_ = mclInitializeString(5, _array89_);
static mxChar _array91_[2] = { 'B', 'M' };
static mwArray _mxarray90_ = mclInitializeString(2, _array91_);
static mxChar _array93_[7] = { 'i', 'e', 'e', 'e', '-', 'b', 'e' };
static mwArray _mxarray92_ = mclInitializeString(7, _array93_);
static mwArray _mxarray94_ = mclInitializeDouble(3.0);
static mxChar _array96_[6] = { 'u', 'i', 'n', 't', '3', '2' };
static mwArray _mxarray95_ = mclInitializeString(6, _array96_);
static mwArray _mxarray97_ = mclInitializeDouble(7.0);
static mwArray _mxarray98_ = mclInitializeDouble(100.0);
static double _array100_[3] = { 0.0, 1.0, 2.0 };
static mwArray _mxarray99_ = mclInitializeDoubleVector(1, 3, _array100_);
static mwArray _mxarray101_ = mclInitializeDouble(8.0);
static double _array103_[8] = { 137.0, 80.0, 78.0, 71.0,
13.0, 10.0, 26.0, 10.0 };
static mwArray _mxarray102_ = mclInitializeDoubleVector(1, 8, _array103_);
static mwArray _mxarray104_ = mclInitializeDouble(128.0);
static mwArray _mxarray105_ = mclInitializeDouble(10.0);
static double _array107_[5] = { 0.0, 2.0, 3.0, 4.0, 5.0 };
static mwArray _mxarray106_ = mclInitializeDoubleVector(1, 5, _array107_);
static double _array109_[2] = { 255.0, 216.0 };
static mwArray _mxarray108_ = mclInitializeDoubleVector(2, 1, _array109_);
static mwArray _mxarray110_ = mclInitializeDouble(4.0);
static double _array112_[4] = { 73.0, 73.0, 42.0, 0.0 };
static mwArray _mxarray111_ = mclInitializeDoubleVector(4, 1, _array112_);
static double _array114_[4] = { 77.0, 77.0, 0.0, 42.0 };
static mwArray _mxarray113_ = mclInitializeDoubleVector(4, 1, _array114_);
static double _array116_[4] = { 14.0, 3.0, 19.0, 1.0 };
static mwArray _mxarray115_ = mclInitializeDoubleVector(4, 1, _array116_);
static double _array118_[3] = { 71.0, 73.0, 70.0 };
static mwArray _mxarray117_ = mclInitializeDoubleVector(3, 1, _array118_);
static mxChar _array120_[6] = { 'u', 'i', 'n', 't', '1', '6' };
static mwArray _mxarray119_ = mclInitializeString(6, _array120_);
static double _array122_[2] = { 0.0, 2.0 };
static mwArray _mxarray121_ = mclInitializeDoubleVector(2, 1, _array122_);
static double _array124_[2] = { 0.0, 1.0 };
static mwArray _mxarray123_ = mclInitializeDoubleVector(2, 1, _array124_);
static mwArray _mxarray125_ = mclInitializeDouble(255.0);
static mwArray _mxarray126_ = mclInitializeDouble(65280.0);
static mwArray _mxarray127_ = mclInitializeDouble(-8.0);
void InitializeModule_iofun_private_imftype() {
}
void TerminateModule_iofun_private_imftype() {
mxDestroyArray(_mxarray70_);
mxDestroyArray(_mxarray68_);
mxDestroyArray(_mxarray63_);
mxDestroyArray(_mxarray61_);
}
static mwArray imftype_isbmp(mwArray filename = mwArray::DIN);
#ifdef __cplusplus
extern "C"
#endif
void mlxImftype_isbmp(int nlhs, mxArray * plhs[], int nrhs, mxArray * prhs[]);
static mwArray imftype_isxwd(mwArray filename = mwArray::DIN);
#ifdef __cplusplus
extern "C"
#endif
void mlxImftype_isxwd(int nlhs, mxArray * plhs[], int nrhs, mxArray * prhs[]);
static mwArray imftype_ispng(mwArray filename = mwArray::DIN);
#ifdef __cplusplus
extern "C"
#endif
void mlxImftype_ispng(int nlhs, mxArray * plhs[], int nrhs, mxArray * prhs[]);
static mwArray imftype_ispcx(mwArray filename = mwArray::DIN);
#ifdef __cplusplus
extern "C"
#endif
void mlxImftype_ispcx(int nlhs, mxArray * plhs[], int nrhs, mxArray * prhs[]);
static mwArray imftype_isjpg(mwArray filename = mwArray::DIN);
#ifdef __cplusplus
extern "C"
#endif
void mlxImftype_isjpg(int nlhs, mxArray * plhs[], int nrhs, mxArray * prhs[]);
static mwArray imftype_istif(mwArray filename = mwArray::DIN);
#ifdef __cplusplus
extern "C"
#endif
void mlxImftype_istif(int nlhs, mxArray * plhs[], int nrhs, mxArray * prhs[]);
static mwArray imftype_ishdf(mwArray filename = mwArray::DIN);
#ifdef __cplusplus
extern "C"
#endif
void mlxImftype_ishdf(int nlhs, mxArray * plhs[], int nrhs, mxArray * prhs[]);
static mwArray imftype_isgif(mwArray filename = mwArray::DIN);
#ifdef __cplusplus
extern "C"
#endif
void mlxImftype_isgif(int nlhs, mxArray * plhs[], int nrhs, mxArray * prhs[]);
static mwArray imftype_iscur(mwArray filename = mwArray::DIN);
#ifdef __cplusplus
extern "C"
#endif
void mlxImftype_iscur(int nlhs, mxArray * plhs[], int nrhs, mxArray * prhs[]);
static mwArray imftype_isico(mwArray filename = mwArray::DIN);
#ifdef __cplusplus
extern "C"
#endif
void mlxImftype_isico(int nlhs, mxArray * plhs[], int nrhs, mxArray * prhs[]);
static mwArray imftype_byteswap(mwArray in = mwArray::DIN);
#ifdef __cplusplus
extern "C"
#endif
void mlxImftype_byteswap(int nlhs,
mxArray * plhs[],
int nrhs,
mxArray * prhs[]);
static mwArray Miofun_private_imftype(int nargout_, mwArray filename);
static mwArray Mimftype_isbmp(int nargout_, mwArray filename);
static mwArray Mimftype_isxwd(int nargout_, mwArray filename);
static mwArray Mimftype_ispng(int nargout_, mwArray filename);
static mwArray Mimftype_ispcx(int nargout_, mwArray filename);
static mwArray Mimftype_isjpg(int nargout_, mwArray filename);
static mwArray Mimftype_istif(int nargout_, mwArray filename);
static mwArray Mimftype_ishdf(int nargout_, mwArray filename);
static mwArray Mimftype_isgif(int nargout_, mwArray filename);
static mwArray Mimftype_iscur(int nargout_, mwArray filename);
static mwArray Mimftype_isico(int nargout_, mwArray filename);
static mwArray Mimftype_byteswap(int nargout_, mwArray in);
static mexFunctionTableEntry local_function_table_[11]
= { { "isbmp", mlxImftype_isbmp, 1, 1, NULL },
{ "isxwd", mlxImftype_isxwd, 1, 1, NULL },
{ "ispng", mlxImftype_ispng, 1, 1, NULL },
{ "ispcx", mlxImftype_ispcx, 1, 1, NULL },
{ "isjpg", mlxImftype_isjpg, 1, 1, NULL },
{ "istif", mlxImftype_istif, 1, 1, NULL },
{ "ishdf", mlxImftype_ishdf, 1, 1, NULL },
{ "isgif", mlxImftype_isgif, 1, 1, NULL },
{ "iscur", mlxImftype_iscur, 1, 1, NULL },
{ "isico", mlxImftype_isico, 1, 1, NULL },
{ "byteswap", mlxImftype_byteswap, 1, 1, NULL } };
_mexLocalFunctionTable _local_function_table_iofun_private_imftype
= { 11, local_function_table_ };
//
// The function "iofun_private_imftype" contains the normal interface for the
// "iofun/private/imftype" M-function from file
// "D:\matlab\matlab\toolbox\matlab\iofun\private\imftype.m" (lines 1-169).
// This function processes any input arguments and passes them to the
// implementation version of the function, appearing above.
//
mwArray iofun_private_imftype(mwArray filename) {
int nargout(1);
mwArray format(mclGetUninitializedArray());
format = Miofun_private_imftype(nargout, filename);
return format;
}
//
// The function "mlxIofun_private_imftype" contains the feval interface for the
// "iofun/private/imftype" M-function from file
// "D:\matlab\matlab\toolbox\matlab\iofun\private\imftype.m" (lines 1-169). The
// feval function calls the implementation version of iofun/private/imftype
// through this function. This function processes any input arguments and
// passes them to the implementation version of the function, appearing above.
//
void mlxIofun_private_imftype(int nlhs,
mxArray * plhs[],
int nrhs,
mxArray * prhs[]) {
MW_BEGIN_MLX();
{
mwArray mprhs[1];
mwArray mplhs[1];
int i;
mclCppUninitializeArrays(1, mplhs);
if (nlhs > 1) {
error(_mxarray0_);
}
if (nrhs > 1) {
error(_mxarray2_);
}
for (i = 0; i < 1 && i < nrhs; ++i) {
mprhs[i] = mwArray(prhs[i], 0);
}
for (; i < 1; ++i) {
mprhs[i].MakeDIN();
}
mplhs[0] = Miofun_private_imftype(nlhs, mprhs[0]);
plhs[0] = mplhs[0].FreezeData();
}
MW_END_MLX();
}
//
// The function "imftype_isbmp" contains the normal interface for the
// "imftype/isbmp" M-function from file
// "D:\matlab\matlab\toolbox\matlab\iofun\private\imftype.m" (lines 169-182).
// This function processes any input arguments and passes them to the
// implementation version of the function, appearing above.
//
static mwArray imftype_isbmp(mwArray filename) {
int nargout(1);
mwArray tf(mclGetUninitializedArray());
tf = Mimftype_isbmp(nargout, filename);
return tf;
}
//
// The function "mlxImftype_isbmp" contains the feval interface for the
// "imftype/isbmp" M-function from file
// "D:\matlab\matlab\toolbox\matlab\iofun\private\imftype.m" (lines 169-182).
// The feval function calls the implementation version of imftype/isbmp through
// this function. This function processes any input arguments and passes them
// to the implementation version of the function, appearing above.
//
void mlxImftype_isbmp(int nlhs, mxArray * plhs[], int nrhs, mxArray * prhs[]) {
MW_BEGIN_MLX();
{
mwArray mprhs[1];
mwArray mplhs[1];
int i;
mclCppUninitializeArrays(1, mplhs);
if (nlhs > 1) {
error(_mxarray4_);
}
if (nrhs > 1) {
error(_mxarray6_);
}
for (i = 0; i < 1 && i < nrhs; ++i) {
mprhs[i] = mwArray(prhs[i], 0);
}
for (; i < 1; ++i) {
mprhs[i].MakeDIN();
}
mplhs[0] = Mimftype_isbmp(nlhs, mprhs[0]);
plhs[0] = mplhs[0].FreezeData();
}
MW_END_MLX();
}
//
// The function "imftype_isxwd" contains the normal interface for the
// "imftype/isxwd" M-function from file
// "D:\matlab\matlab\toolbox\matlab\iofun\private\imftype.m" (lines 182-212).
// This function processes any input arguments and passes them to the
// implementation version of the function, appearing above.
//
static mwArray imftype_isxwd(mwArray filename) {
int nargout(1);
mwArray tf(mclGetUninitializedArray());
tf = Mimftype_isxwd(nargout, filename);
return tf;
}
//
// The function "mlxImftype_isxwd" contains the feval interface for the
// "imftype/isxwd" M-function from file
// "D:\matlab\matlab\toolbox\matlab\iofun\private\imftype.m" (lines 182-212).
// The feval function calls the implementation version of imftype/isxwd through
// this function. This function processes any input arguments and passes them
// to the implementation version of the function, appearing above.
//
void mlxImftype_isxwd(int nlhs, mxArray * plhs[], int nrhs, mxArray * prhs[]) {
MW_BEGIN_MLX();
{
mwArray mprhs[1];
mwArray mplhs[1];
int i;
mclCppUninitializeArrays(1, mplhs);
if (nlhs > 1) {
error(_mxarray8_);
}
if (nrhs > 1) {
error(_mxarray10_);
}
for (i = 0; i < 1 && i < nrhs; ++i) {
mprhs[i] = mwArray(prhs[i], 0);
}
for (; i < 1; ++i) {
mprhs[i].MakeDIN();
}
mplhs[0] = Mimftype_isxwd(nlhs, mprhs[0]);
plhs[0] = mplhs[0].FreezeData();
}
MW_END_MLX();
}
//
// The function "imftype_ispng" contains the normal interface for the
// "imftype/ispng" M-function from file
// "D:\matlab\matlab\toolbox\matlab\iofun\private\imftype.m" (lines 212-225).
// This function processes any input arguments and passes them to the
// implementation version of the function, appearing above.
//
static mwArray imftype_ispng(mwArray filename) {
int nargout(1);
mwArray tf(mclGetUninitializedArray());
tf = Mimftype_ispng(nargout, filename);
return tf;
}
//
// The function "mlxImftype_ispng" contains the feval interface for the
// "imftype/ispng" M-function from file
// "D:\matlab\matlab\toolbox\matlab\iofun\private\imftype.m" (lines 212-225).
// The feval function calls the implementation version of imftype/ispng through
// this function. This function processes any input arguments and passes them
// to the implementation version of the function, appearing above.
//
void mlxImftype_ispng(int nlhs, mxArray * plhs[], int nrhs, mxArray * prhs[]) {
MW_BEGIN_MLX();
{
mwArray mprhs[1];
mwArray mplhs[1];
int i;
mclCppUninitializeArrays(1, mplhs);
if (nlhs > 1) {
error(_mxarray12_);
}
if (nrhs > 1) {
error(_mxarray14_);
}
for (i = 0; i < 1 && i < nrhs; ++i) {
mprhs[i] = mwArray(prhs[i], 0);
}
for (; i < 1; ++i) {
mprhs[i].MakeDIN();
}
mplhs[0] = Mimftype_ispng(nlhs, mprhs[0]);
plhs[0] = mplhs[0].FreezeData();
}
MW_END_MLX();
}
//
// The function "imftype_ispcx" contains the normal interface for the
// "imftype/ispcx" M-function from file
// "D:\matlab\matlab\toolbox\matlab\iofun\private\imftype.m" (lines 225-242).
// This function processes any input arguments and passes them to the
// implementation version of the function, appearing above.
//
static mwArray imftype_ispcx(mwArray filename) {
int nargout(1);
mwArray tf(mclGetUninitializedArray());
tf = Mimftype_ispcx(nargout, filename);
return tf;
}
//
// The function "mlxImftype_ispcx" contains the feval interface for the
// "imftype/ispcx" M-function from file
// "D:\matlab\matlab\toolbox\matlab\iofun\private\imftype.m" (lines 225-242).
// The feval function calls the implementation version of imftype/ispcx through
// this function. This function processes any input arguments and passes them
// to the implementation version of the function, appearing above.
//
void mlxImftype_ispcx(int nlhs, mxArray * plhs[], int nrhs, mxArray * prhs[]) {
MW_BEGIN_MLX();
{
mwArray mprhs[1];
mwArray mplhs[1];
int i;
mclCppUninitializeArrays(1, mplhs);
if (nlhs > 1) {
error(_mxarray16_);
}
if (nrhs > 1) {
error(_mxarray18_);
}
for (i = 0; i < 1 && i < nrhs; ++i) {
mprhs[i] = mwArray(prhs[i], 0);
}
for (; i < 1; ++i) {
mprhs[i].MakeDIN();
}
mplhs[0] = Mimftype_ispcx(nlhs, mprhs[0]);
plhs[0] = mplhs[0].FreezeData();
}
MW_END_MLX();
}
//
// The function "imftype_isjpg" contains the normal interface for the
// "imftype/isjpg" M-function from file
// "D:\matlab\matlab\toolbox\matlab\iofun\private\imftype.m" (lines 242-255).
// This function processes any input arguments and passes them to the
// implementation version of the function, appearing above.
//
static mwArray imftype_isjpg(mwArray filename) {
int nargout(1);
mwArray tf(mclGetUninitializedArray());
tf = Mimftype_isjpg(nargout, filename);
return tf;
}
//
// The function "mlxImftype_isjpg" contains the feval interface for the
// "imftype/isjpg" M-function from file
// "D:\matlab\matlab\toolbox\matlab\iofun\private\imftype.m" (lines 242-255).
// The feval function calls the implementation version of imftype/isjpg through
// this function. This function processes any input arguments and passes them
// to the implementation version of the function, appearing above.
//
void mlxImftype_isjpg(int nlhs, mxArray * plhs[], int nrhs, mxArray * prhs[]) {
MW_BEGIN_MLX();
{
mwArray mprhs[1];
mwArray mplhs[1];
int i;
mclCppUninitializeArrays(1, mplhs);
if (nlhs > 1) {
error(_mxarray20_);
}
if (nrhs > 1) {
error(_mxarray22_);
}
for (i = 0; i < 1 && i < nrhs; ++i) {
mprhs[i] = mwArray(prhs[i], 0);
}
for (; i < 1; ++i) {
mprhs[i].MakeDIN();
}
mplhs[0] = Mimftype_isjpg(nlhs, mprhs[0]);
plhs[0] = mplhs[0].FreezeData();
}
MW_END_MLX();
}
//
// The function "imftype_istif" contains the normal interface for the
// "imftype/istif" M-function from file
// "D:\matlab\matlab\toolbox\matlab\iofun\private\imftype.m" (lines 255-268).
// This function processes any input arguments and passes them to the
// implementation version of the function, appearing above.
//
static mwArray imftype_istif(mwArray filename) {
int nargout(1);
mwArray tf(mclGetUninitializedArray());
tf = Mimftype_istif(nargout, filename);
return tf;
}
//
// The function "mlxImftype_istif" contains the feval interface for the
// "imftype/istif" M-function from file
// "D:\matlab\matlab\toolbox\matlab\iofun\private\imftype.m" (lines 255-268).
// The feval function calls the implementation version of imftype/istif through
// this function. This function processes any input arguments and passes them
// to the implementation version of the function, appearing above.
//
void mlxImftype_istif(int nlhs, mxArray * plhs[], int nrhs, mxArray * prhs[]) {
MW_BEGIN_MLX();
{
mwArray mprhs[1];
mwArray mplhs[1];
int i;
mclCppUninitializeArrays(1, mplhs);
if (nlhs > 1) {
error(_mxarray24_);
}
if (nrhs > 1) {
error(_mxarray26_);
}
for (i = 0; i < 1 && i < nrhs; ++i) {
mprhs[i] = mwArray(prhs[i], 0);
}
for (; i < 1; ++i) {
mprhs[i].MakeDIN();
}
mplhs[0] = Mimftype_istif(nlhs, mprhs[0]);
plhs[0] = mplhs[0].FreezeData();
}
MW_END_MLX();
}
//
// The function "imftype_ishdf" contains the normal interface for the
// "imftype/ishdf" M-function from file
// "D:\matlab\matlab\toolbox\matlab\iofun\private\imftype.m" (lines 268-281).
// This function processes any input arguments and passes them to the
// implementation version of the function, appearing above.
//
static mwArray imftype_ishdf(mwArray filename) {
int nargout(1);
mwArray tf(mclGetUninitializedArray());
tf = Mimftype_ishdf(nargout, filename);
return tf;
}
//
// The function "mlxImftype_ishdf" contains the feval interface for the
// "imftype/ishdf" M-function from file
// "D:\matlab\matlab\toolbox\matlab\iofun\private\imftype.m" (lines 268-281).
// The feval function calls the implementation version of imftype/ishdf through
// this function. This function processes any input arguments and passes them
// to the implementation version of the function, appearing above.
//
void mlxImftype_ishdf(int nlhs, mxArray * plhs[], int nrhs, mxArray * prhs[]) {
MW_BEGIN_MLX();
{
mwArray mprhs[1];
mwArray mplhs[1];
int i;
mclCppUninitializeArrays(1, mplhs);
if (nlhs > 1) {
error(_mxarray28_);
}
if (nrhs > 1) {
error(_mxarray30_);
}
for (i = 0; i < 1 && i < nrhs; ++i) {
mprhs[i] = mwArray(prhs[i], 0);
}
for (; i < 1; ++i) {
mprhs[i].MakeDIN();
}
mplhs[0] = Mimftype_ishdf(nlhs, mprhs[0]);
plhs[0] = mplhs[0].FreezeData();
}
MW_END_MLX();
}
//
// The function "imftype_isgif" contains the normal interface for the
// "imftype/isgif" M-function from file
// "D:\matlab\matlab\toolbox\matlab\iofun\private\imftype.m" (lines 281-294).
// This function processes any input arguments and passes them to the
// implementation version of the function, appearing above.
//
static mwArray imftype_isgif(mwArray filename) {
int nargout(1);
mwArray tf(mclGetUninitializedArray());
tf = Mimftype_isgif(nargout, filename);
return tf;
}
//
// The function "mlxImftype_isgif" contains the feval interface for the
// "imftype/isgif" M-function from file
// "D:\matlab\matlab\toolbox\matlab\iofun\private\imftype.m" (lines 281-294).
// The feval function calls the implementation version of imftype/isgif through
// this function. This function processes any input arguments and passes them
// to the implementation version of the function, appearing above.
//
void mlxImftype_isgif(int nlhs, mxArray * plhs[], int nrhs, mxArray * prhs[]) {
MW_BEGIN_MLX();
{
mwArray mprhs[1];
mwArray mplhs[1];
int i;
mclCppUninitializeArrays(1, mplhs);
if (nlhs > 1) {
error(_mxarray32_);
}
if (nrhs > 1) {
error(_mxarray34_);
}
for (i = 0; i < 1 && i < nrhs; ++i) {
mprhs[i] = mwArray(prhs[i], 0);
}
for (; i < 1; ++i) {
mprhs[i].MakeDIN();
}
mplhs[0] = Mimftype_isgif(nlhs, mprhs[0]);
plhs[0] = mplhs[0].FreezeData();
}
MW_END_MLX();
}
//
// The function "imftype_iscur" contains the normal interface for the
// "imftype/iscur" M-function from file
// "D:\matlab\matlab\toolbox\matlab\iofun\private\imftype.m" (lines 294-307).
// This function processes any input arguments and passes them to the
// implementation version of the function, appearing above.
//
static mwArray imftype_iscur(mwArray filename) {
int nargout(1);
mwArray tf(mclGetUninitializedArray());
tf = Mimftype_iscur(nargout, filename);
return tf;
}
//
// The function "mlxImftype_iscur" contains the feval interface for the
// "imftype/iscur" M-function from file
// "D:\matlab\matlab\toolbox\matlab\iofun\private\imftype.m" (lines 294-307).
// The feval function calls the implementation version of imftype/iscur through
// this function. This function processes any input arguments and passes them
// to the implementation version of the function, appearing above.
//
void mlxImftype_iscur(int nlhs, mxArray * plhs[], int nrhs, mxArray * prhs[]) {
MW_BEGIN_MLX();
{
mwArray mprhs[1];
mwArray mplhs[1];
int i;
mclCppUninitializeArrays(1, mplhs);
if (nlhs > 1) {
error(_mxarray36_);
}
if (nrhs > 1) {
error(_mxarray38_);
}
for (i = 0; i < 1 && i < nrhs; ++i) {
mprhs[i] = mwArray(prhs[i], 0);
}
for (; i < 1; ++i) {
mprhs[i].MakeDIN();
}
mplhs[0] = Mimftype_iscur(nlhs, mprhs[0]);
plhs[0] = mplhs[0].FreezeData();
}
MW_END_MLX();
}
//
// The function "imftype_isico" contains the normal interface for the
// "imftype/isico" M-function from file
// "D:\matlab\matlab\toolbox\matlab\iofun\private\imftype.m" (lines 307-320).
// This function processes any input arguments and passes them to the
// implementation version of the function, appearing above.
//
static mwArray imftype_isico(mwArray filename) {
int nargout(1);
mwArray tf(mclGetUninitializedArray());
tf = Mimftype_isico(nargout, filename);
return tf;
}
//
// The function "mlxImftype_isico" contains the feval interface for the
// "imftype/isico" M-function from file
// "D:\matlab\matlab\toolbox\matlab\iofun\private\imftype.m" (lines 307-320).
// The feval function calls the implementation version of imftype/isico through
// this function. This function processes any input arguments and passes them
// to the implementation version of the function, appearing above.
//
void mlxImftype_isico(int nlhs, mxArray * plhs[], int nrhs, mxArray * prhs[]) {
MW_BEGIN_MLX();
{
mwArray mprhs[1];
mwArray mplhs[1];
int i;
mclCppUninitializeArrays(1, mplhs);
if (nlhs > 1) {
error(_mxarray40_);
}
if (nrhs > 1) {
error(_mxarray42_);
}
for (i = 0; i < 1 && i < nrhs; ++i) {
mprhs[i] = mwArray(prhs[i], 0);
}
for (; i < 1; ++i) {
mprhs[i].MakeDIN();
}
mplhs[0] = Mimftype_isico(nlhs, mprhs[0]);
plhs[0] = mplhs[0].FreezeData();
}
MW_END_MLX();
}
//
// The function "imftype_byteswap" contains the normal interface for the
// "imftype/byteswap" M-function from file
// "D:\matlab\matlab\toolbox\matlab\iofun\private\imftype.m" (lines 320-329).
// This function processes any input arguments and passes them to the
// implementation version of the function, appearing above.
//
static mwArray imftype_byteswap(mwArray in) {
int nargout(1);
mwArray out(mclGetUninitializedArray());
out = Mimftype_byteswap(nargout, in);
return out;
}
//
// The function "mlxImftype_byteswap" contains the feval interface for the
// "imftype/byteswap" M-function from file
// "D:\matlab\matlab\toolbox\matlab\iofun\private\imftype.m" (lines 320-329).
// The feval function calls the implementation version of imftype/byteswap
// through this function. This function processes any input arguments and
// passes them to the implementation version of the function, appearing above.
//
void mlxImftype_byteswap(int nlhs,
mxArray * plhs[],
int nrhs,
mxArray * prhs[]) {
MW_BEGIN_MLX();
{
mwArray mprhs[1];
mwArray mplhs[1];
int i;
mclCppUninitializeArrays(1, mplhs);
if (nlhs > 1) {
error(_mxarray44_);
}
if (nrhs > 1) {
error(_mxarray46_);
}
for (i = 0; i < 1 && i < nrhs; ++i) {
mprhs[i] = mwArray(prhs[i], 0);
}
for (; i < 1; ++i) {
mprhs[i].MakeDIN();
}
mplhs[0] = Mimftype_byteswap(nlhs, mprhs[0]);
plhs[0] = mplhs[0].FreezeData();
}
MW_END_MLX();
}
//
// The function "Miofun_private_imftype" is the implementation version of the
// "iofun/private/imftype" M-function from file
// "D:\matlab\matlab\toolbox\matlab\iofun\private\imftype.m" (lines 1-169). It
// contains the actual compiled code for that M-function. It is a static
// function and must only be called from one of the interface functions,
// appearing below.
//
//
// function format = imftype(filename)
//
static mwArray Miofun_private_imftype(int nargout_, mwArray filename) {
mwLocalFunctionTable save_local_function_table_
(&_local_function_table_iofun_private_imftype);
int nargin_(nargin(1, mwVarargin(filename)));
mwArray format(mclGetUninitializedArray());
mwArray formatFound(mclGetUninitializedArray());
mwArray extension(mclGetUninitializedArray());
mwArray idx(mclGetUninitializedArray());
mwArray ans(mclGetUninitializedArray());
//
// %IMFTYPE Determine image file format.
// % FORMAT = IMFTYPE(FILENAME) attempts to determine the image
// % file format for the file FILENAME. If IMFTYPE is successful,
// % FORMAT will be returned as one of these strings:
// %
// % 'bmp' 'gif' 'hdf' 'jpg' 'pcx' 'tif' 'xwd' 'png'
// % 'cur' 'ico'
// %
// % FORMAT will be an empty string if IMFTYPE cannot determine
// % the file format.
// %
// % See also IMREAD, IMWRITE, IMFINFO.
//
// % Steven L. Eddins, June 1996
// % Copyright 1984-2001 The MathWorks, Inc.
// % $Revision: 1.11 $ $Date: 2001/04/15 12:02:00 $
//
// error(nargchk(1, 1, nargin));
//
error(mwVe(nargchk(_mxarray48_, _mxarray48_, nargin_)));
//
//
// % Optimization: look for a filename extension as a clue for the
// % first format to try.
//
// idx = find(filename == '.');
//
idx = find(mwVa(filename, "filename") == _mxarray49_);
//
// if (~isempty(idx))
//
if (mclNotBool(mwVe(isempty(mwVv(idx, "idx"))))) {
//
// extension = lower(filename(idx(end)+1:end));
//
extension
= lower(
mwVe(
mclArrayRef(
mwVsa(filename, "filename"),
colon(
mwVe(
mclArrayRef(
mwVsv(idx, "idx"),
end(mwVv(idx, "idx"), _mxarray48_, _mxarray48_)))
+ _mxarray48_,
end(
mwVa(filename, "filename"),
_mxarray48_,
_mxarray48_)))));
//
// else
//
} else {
//
// extension = '';
//
extension = _mxarray51_;
//
// end
//
}
//
//
// formatFound = 0;
//
formatFound = _mxarray52_;
//
//
// if (~isempty(extension))
//
if (mclNotBool(mwVe(isempty(mwVv(extension, "extension"))))) {
//
// switch extension
//
mwArray v_(mwVv(extension, "extension"));
if (switchcompare(v_, _mxarray53_)) {
//
// case 'bmp'
// formatFound = isbmp(filename);
//
formatFound = imftype_isbmp(mwVa(filename, "filename"));
//
// if (formatFound)
//
if (tobool(mwVv(formatFound, "formatFound"))) {
//
// format = 'bmp';
//
format = _mxarray53_;
//
// end
//
}
//
//
// case 'xwd'
//
} else if (switchcompare(v_, _mxarray55_)) {
//
// formatFound = isxwd(filename);
//
formatFound = imftype_isxwd(mwVa(filename, "filename"));
//
// if (formatFound)
//
if (tobool(mwVv(formatFound, "formatFound"))) {
//
// format = 'xwd';
//
format = _mxarray55_;
//
// end
//
}
//
//
// case 'pcx'
//
} else if (switchcompare(v_, _mxarray57_)) {
//
// formatFound = ispcx(filename);
//
formatFound = imftype_ispcx(mwVa(filename, "filename"));
//
// if (formatFound)
//
if (tobool(mwVv(formatFound, "formatFound"))) {
//
// format = 'pcx';
//
format = _mxarray57_;
//
// end
//
}
//
//
// case {'jpeg', 'jpg'}
//
} else if (switchcompare(v_, _mxarray59_)) {
//
// formatFound = isjpg(filename);
//
formatFound = imftype_isjpg(mwVa(filename, "filename"));
//
// if (formatFound)
//
if (tobool(mwVv(formatFound, "formatFound"))) {
//
// format = 'jpg';
//
format = _mxarray65_;
//
// end
//
}
//
//
// case {'tiff', 'tif'}
//
} else if (switchcompare(v_, _mxarray66_)) {
//
// formatFound = istif(filename);
//
formatFound = imftype_istif(mwVa(filename, "filename"));
//
// if (formatFound)
//
if (tobool(mwVv(formatFound, "formatFound"))) {
//
// format = 'tif';
//
format = _mxarray72_;
//
// end
//
}
//
//
// case 'hdf'
//
} else if (switchcompare(v_, _mxarray73_)) {
//
// formatFound = ishdf(filename);
//
formatFound = imftype_ishdf(mwVa(filename, "filename"));
//
// if (formatFound)
//
if (tobool(mwVv(formatFound, "formatFound"))) {
//
// format = 'hdf';
//
format = _mxarray73_;
//
// end
//
}
//
//
// case 'png'
//
} else if (switchcompare(v_, _mxarray75_)) {
//
// formatFound = ispng(filename);
//
formatFound = imftype_ispng(mwVa(filename, "filename"));
//
// if (formatFound)
//
if (tobool(mwVv(formatFound, "formatFound"))) {
//
// format = 'png';
//
format = _mxarray75_;
//
// end
//
}
//
//
// case 'gif'
//
} else if (switchcompare(v_, _mxarray77_)) {
//
// formatFound = isgif(filename);
//
formatFound = imftype_isgif(mwVa(filename, "filename"));
//
// if (formatFound)
//
if (tobool(mwVv(formatFound, "formatFound"))) {
//
// format = 'gif';
//
format = _mxarray77_;
//
// end
//
}
//
//
// case 'cur'
//
} else if (switchcompare(v_, _mxarray79_)) {
//
// formatFound = iscur(filename);
//
formatFound = imftype_iscur(mwVa(filename, "filename"));
//
// if (formatFound)
//
if (tobool(mwVv(formatFound, "formatFound"))) {
//
// format = 'cur';
//
format = _mxarray79_;
//
// end
//
}
//
//
// case 'ico'
//
} else if (switchcompare(v_, _mxarray81_)) {
//
// formatFound = isico(filename);
//
formatFound = imftype_isico(mwVa(filename, "filename"));
//
// if (formatFound)
//
if (tobool(mwVv(formatFound, "formatFound"))) {
//
// format = 'ico';
//
format = _mxarray81_;
//
// end
//
}
//
//
// end
//
}
//
// end
//
}
//
//
// % If the format hasn't been identified yet, try them all one at a
// % time.
//
// if (~formatFound)
//
if (mclNotBool(mwVv(formatFound, "formatFound"))) {
//
// formatFound = isbmp(filename);
//
formatFound = imftype_isbmp(mwVa(filename, "filename"));
//
// if (formatFound)
//
if (tobool(mwVv(formatFound, "formatFound"))) {
//
// format = 'bmp';
//
format = _mxarray53_;
//
// end
//
}
//
// end
//
}
//
//
// if (~formatFound)
//
if (mclNotBool(mwVv(formatFound, "formatFound"))) {
//
// formatFound = ispng(filename);
//
formatFound = imftype_ispng(mwVa(filename, "filename"));
//
// if (formatFound)
//
if (tobool(mwVv(formatFound, "formatFound"))) {
//
// format = 'png';
//
format = _mxarray75_;
//
// end
//
}
//
// end
//
}
//
//
// if (~formatFound)
//
if (mclNotBool(mwVv(formatFound, "formatFound"))) {
//
// formatFound = isxwd(filename);
//
formatFound = imftype_isxwd(mwVa(filename, "filename"));
//
// if (formatFound)
//
if (tobool(mwVv(formatFound, "formatFound"))) {
//
// format = 'xwd';
//
format = _mxarray55_;
//
// end
//
}
//
// end
//
}
//
//
// if (~formatFound)
//
if (mclNotBool(mwVv(formatFound, "formatFound"))) {
//
// formatFound = ispcx(filename);
//
formatFound = imftype_ispcx(mwVa(filename, "filename"));
//
// if (formatFound)
//
if (tobool(mwVv(formatFound, "formatFound"))) {
//
// format = 'pcx';
//
format = _mxarray57_;
//
// end
//
}
//
// end
//
}
//
//
// if (~formatFound)
//
if (mclNotBool(mwVv(formatFound, "formatFound"))) {
//
// formatFound = isjpg(filename);
//
formatFound = imftype_isjpg(mwVa(filename, "filename"));
//
// if (formatFound)
//
if (tobool(mwVv(formatFound, "formatFound"))) {
//
// format = 'jpg';
//
format = _mxarray65_;
//
// end
//
}
//
// end
//
}
//
//
// if (~formatFound)
//
if (mclNotBool(mwVv(formatFound, "formatFound"))) {
//
// formatFound = istif(filename);
//
formatFound = imftype_istif(mwVa(filename, "filename"));
//
// if (formatFound)
//
if (tobool(mwVv(formatFound, "formatFound"))) {
//
// format = 'tif';
//
format = _mxarray72_;
//
// end
//
}
//
// end
//
}
//
//
// if (~formatFound)
//
if (mclNotBool(mwVv(formatFound, "formatFound"))) {
//
// formatFound = ishdf(filename);
//
formatFound = imftype_ishdf(mwVa(filename, "filename"));
//
// if (formatFound)
//
if (tobool(mwVv(formatFound, "formatFound"))) {
//
// format = 'hdf';
//
format = _mxarray73_;
//
// end
//
}
//
// end
//
}
//
//
// if (~formatFound)
//
if (mclNotBool(mwVv(formatFound, "formatFound"))) {
//
// formatFound = iscur(filename);
//
formatFound = imftype_iscur(mwVa(filename, "filename"));
//
// if (formatFound)
//
if (tobool(mwVv(formatFound, "formatFound"))) {
//
// format = 'cur';
//
format = _mxarray79_;
//
// end
//
}
//
// end
//
}
//
//
// if (~formatFound)
//
if (mclNotBool(mwVv(formatFound, "formatFound"))) {
//
// formatFound = isico(filename);
//
formatFound = imftype_isico(mwVa(filename, "filename"));
//
// if (formatFound)
//
if (tobool(mwVv(formatFound, "formatFound"))) {
//
// format = 'ico';
//
format = _mxarray81_;
//
// end
//
}
//
// end
//
}
//
//
// if (~formatFound)
//
if (mclNotBool(mwVv(formatFound, "formatFound"))) {
//
// format = '';
//
format = _mxarray51_;
//
// end
//
}
mwValidateOutput(format, 1, nargout_, "format", "iofun/private/imftype");
return format;
//
//
//
//
}
//
// The function "Mimftype_isbmp" is the implementation version of the
// "imftype/isbmp" M-function from file
// "D:\matlab\matlab\toolbox\matlab\iofun\private\imftype.m" (lines 169-182).
// It contains the actual compiled code for that M-function. It is a static
// function and must only be called from one of the interface functions,
// appearing below.
//
//
// function tf = isbmp(filename)
//
static mwArray Mimftype_isbmp(int nargout_, mwArray filename) {
mwLocalFunctionTable save_local_function_table_
(&_local_function_table_iofun_private_imftype);
mwArray tf(mclGetUninitializedArray());
mwArray ans(mclGetUninitializedArray());
mwArray sig(mclGetUninitializedArray());
mwArray fid(mclGetUninitializedArray());
//
// %ISBMP Returns true for a BMP file.
// % TF = ISBMP(FILENAME)
//
// fid = fopen(filename, 'r', 'ieee-le');
//
fid = fopen(mwVa(filename, "filename"), _mxarray83_, _mxarray85_);
//
// if (fid < 0)
//
if (mclLtBool(mwVv(fid, "fid"), _mxarray52_)) {
//
// tf = logical(0);
//
tf = logical(_mxarray52_);
//
// else
//
} else {
//
// sig = fread(fid, 2, 'uint8');
//
sig = fread(mwVv(fid, "fid"), _mxarray87_, _mxarray88_);
//
// fclose(fid);
//
ans.EqAns(fclose(mwVv(fid, "fid")));
//
// tf = isequal(sig, double('BM')');
//
tf
= isequal(
mwVv(sig, "sig"),
mwVarargin(ctranspose(mwVe(double_func(_mxarray90_)))));
//
// end
//
}
mwValidateOutput(tf, 1, nargout_, "tf", "imftype/isbmp");
return tf;
//
//
//
}
//
// The function "Mimftype_isxwd" is the implementation version of the
// "imftype/isxwd" M-function from file
// "D:\matlab\matlab\toolbox\matlab\iofun\private\imftype.m" (lines 182-212).
// It contains the actual compiled code for that M-function. It is a static
// function and must only be called from one of the interface functions,
// appearing below.
//
//
// function tf = isxwd(filename)
//
static mwArray Mimftype_isxwd(int nargout_, mwArray filename) {
mwLocalFunctionTable save_local_function_table_
(&_local_function_table_iofun_private_imftype);
mwArray tf(mclGetUninitializedArray());
mwArray ans(mclGetUninitializedArray());
mwArray sig(mclGetUninitializedArray());
mwArray fid(mclGetUninitializedArray());
//
// %ISXWD Returns true for an XWD file.
// % TF = ISXWD(FILENAME)
//
// % XWD files can be big or little-endian. Try it big-endian
// % first.
// fid = fopen(filename, 'r', 'ieee-be'); % BMP files are little-endian
//
fid = fopen(mwVa(filename, "filename"), _mxarray83_, _mxarray92_);
//
// if (fid < 0)
//
if (mclLtBool(mwVv(fid, "fid"), _mxarray52_)) {
//
// tf = logical(0);
//
tf = logical(_mxarray52_);
//
// else
//
} else {
//
// sig = fread(fid, 3, 'uint32');
//
sig = fread(mwVv(fid, "fid"), _mxarray94_, _mxarray95_);
//
// fclose(fid);
//
ans.EqAns(fclose(mwVv(fid, "fid")));
//
// if (length(sig) < 3)
//
if (mclLengthInt(mwVv(sig, "sig")) < 3) {
//
// tf = logical(0);
//
tf = logical(_mxarray52_);
//
// else
//
} else {
//
// if (sig(2) == 7)
//
if (mclEqBool(
mwVe(mclIntArrayRef(mwVsv(sig, "sig"), 2)), _mxarray97_)) {
//
// tf = ((sig(1) >= 100) & (ismember(sig(3), [0 1 2])));
//
tf
= mwVe(mclIntArrayRef(mwVsv(sig, "sig"), 1)) >= _mxarray98_
& mwVe(
ismember(
mwVe(mclIntArrayRef(mwVsv(sig, "sig"), 3)),
_mxarray99_));
//
//
// elseif (sig(2) == byteswap(7))
//
} else if (mclEqBool(
mwVe(mclIntArrayRef(mwVsv(sig, "sig"), 2)),
mwVe(imftype_byteswap(_mxarray97_)))) {
//
// % 112 is 7 byte-reversed; maybe it's a little-endian XWD file.
// sig(1) = byteswap(sig(1));
//
mclIntArrayAssign(
&sig,
imftype_byteswap(mwVe(mclIntArrayRef(mwVsv(sig, "sig"), 1))),
1);
//
// sig(3) = byteswap(sig(3));
//
mclIntArrayAssign(
&sig,
imftype_byteswap(mwVe(mclIntArrayRef(mwVsv(sig, "sig"), 3))),
3);
//
// tf = ((sig(1) >= 100) & (ismember(sig(3), [0 1 2])));
//
tf
= mwVe(mclIntArrayRef(mwVsv(sig, "sig"), 1)) >= _mxarray98_
& mwVe(
ismember(
mwVe(mclIntArrayRef(mwVsv(sig, "sig"), 3)),
_mxarray99_));
//
//
// else
//
} else {
//
// tf = logical(0);
//
tf = logical(_mxarray52_);
//
// end
//
}
//
// end
//
}
//
// end
//
}
mwValidateOutput(tf, 1, nargout_, "tf", "imftype/isxwd");
return tf;
//
//
//
}
//
// The function "Mimftype_ispng" is the implementation version of the
// "imftype/ispng" M-function from file
// "D:\matlab\matlab\toolbox\matlab\iofun\private\imftype.m" (lines 212-225).
// It contains the actual compiled code for that M-function. It is a static
// function and must only be called from one of the interface functions,
// appearing below.
//
//
// function tf = ispng(filename)
//
static mwArray Mimftype_ispng(int nargout_, mwArray filename) {
mwLocalFunctionTable save_local_function_table_
(&_local_function_table_iofun_private_imftype);
mwArray tf(mclGetUninitializedArray());
mwArray ans(mclGetUninitializedArray());
mwArray sig(mclGetUninitializedArray());
mwArray fid(mclGetUninitializedArray());
//
// %ISPNG Returns true for a PNG file.
// % TF = ISPNG(FILENAME)
//
// fid = fopen(filename, 'r', 'ieee-be');
//
fid = fopen(mwVa(filename, "filename"), _mxarray83_, _mxarray92_);
//
// if (fid < 0)
//
if (mclLtBool(mwVv(fid, "fid"), _mxarray52_)) {
//
// tf = logical(0);
//
tf = logical(_mxarray52_);
//
// else
//
} else {
//
// sig = fread(fid, 8, 'uint8')';
//
sig
= ctranspose(
mwVe(fread(mwVv(fid, "fid"), _mxarray101_, _mxarray88_)));
//
// fclose(fid);
//
ans.EqAns(fclose(mwVv(fid, "fid")));
//
// tf = isequal(sig, [137 80 78 71 13 10 26 10]);
//
tf = isequal(mwVv(sig, "sig"), mwVarargin(_mxarray102_));
//
// end
//
}
mwValidateOutput(tf, 1, nargout_, "tf", "imftype/ispng");
return tf;
//
//
//
}
//
// The function "Mimftype_ispcx" is the implementation version of the
// "imftype/ispcx" M-function from file
// "D:\matlab\matlab\toolbox\matlab\iofun\private\imftype.m" (lines 225-242).
// It contains the actual compiled code for that M-function. It is a static
// function and must only be called from one of the interface functions,
// appearing below.
//
//
// function tf = ispcx(filename)
//
static mwArray Mimftype_ispcx(int nargout_, mwArray filename) {
mwLocalFunctionTable save_local_function_table_
(&_local_function_table_iofun_private_imftype);
mwArray tf(mclGetUninitializedArray());
mwArray ans(mclGetUninitializedArray());
mwArray header(mclGetUninitializedArray());
mwArray fid(mclGetUninitializedArray());
//
// %ISPCX Returns true for a PCX file.
// % TF = ISPCX(FILENAME)
//
// fid = fopen(filename, 'r', 'ieee-le');
//
fid = fopen(mwVa(filename, "filename"), _mxarray83_, _mxarray85_);
//
// if (fid < 0)
//
if (mclLtBool(mwVv(fid, "fid"), _mxarray52_)) {
//
// tf = logical(0);
//
tf = logical(_mxarray52_);
//
// else
//
} else {
//
// header = fread(fid, 128, 'uint8');
//
header = fread(mwVv(fid, "fid"), _mxarray104_, _mxarray88_);
//
// fclose(fid);
//
ans.EqAns(fclose(mwVv(fid, "fid")));
//
// if (length(header) < 128)
//
if (mclLengthInt(mwVv(header, "header")) < 128) {
//
// tf = logical(0);
//
tf = logical(_mxarray52_);
//
// else
//
} else {
//
// tf = (header(1) == 10) & ismember(header(2), [0 2 3 4 5]);
//
tf
= mwVe(mclIntArrayRef(mwVsv(header, "header"), 1))
== _mxarray105_
& mwVe(
ismember(
mwVe(mclIntArrayRef(mwVsv(header, "header"), 2)),
_mxarray106_));
//
// end
//
}
//
// end
//
}
mwValidateOutput(tf, 1, nargout_, "tf", "imftype/ispcx");
return tf;
//
//
//
}
//
// The function "Mimftype_isjpg" is the implementation version of the
// "imftype/isjpg" M-function from file
// "D:\matlab\matlab\toolbox\matlab\iofun\private\imftype.m" (lines 242-255).
// It contains the actual compiled code for that M-function. It is a static
// function and must only be called from one of the interface functions,
// appearing below.
//
//
// function tf = isjpg(filename)
//
static mwArray Mimftype_isjpg(int nargout_, mwArray filename) {
mwLocalFunctionTable save_local_function_table_
(&_local_function_table_iofun_private_imftype);
mwArray tf(mclGetUninitializedArray());
mwArray ans(mclGetUninitializedArray());
mwArray sig(mclGetUninitializedArray());
mwArray fid(mclGetUninitializedArray());
//
// %ISJPG Returns true for a JPG file.
// % TF = ISJPG(FILENAME)
//
// fid = fopen(filename, 'r', 'ieee-le');
//
fid = fopen(mwVa(filename, "filename"), _mxarray83_, _mxarray85_);
//
// if (fid < 0)
//
if (mclLtBool(mwVv(fid, "fid"), _mxarray52_)) {
//
// tf = logical(0);
//
tf = logical(_mxarray52_);
//
// else
//
} else {
//
// sig = fread(fid, 2, 'uint8');
//
sig = fread(mwVv(fid, "fid"), _mxarray87_, _mxarray88_);
//
// fclose(fid);
//
ans.EqAns(fclose(mwVv(fid, "fid")));
//
// tf = isequal(sig, [255; 216]);
//
tf = isequal(mwVv(sig, "sig"), mwVarargin(_mxarray108_));
//
// end
//
}
mwValidateOutput(tf, 1, nargout_, "tf", "imftype/isjpg");
return tf;
//
//
//
}
//
// The function "Mimftype_istif" is the implementation version of the
// "imftype/istif" M-function from file
// "D:\matlab\matlab\toolbox\matlab\iofun\private\imftype.m" (lines 255-268).
// It contains the actual compiled code for that M-function. It is a static
// function and must only be called from one of the interface functions,
// appearing below.
//
//
// function tf = istif(filename)
//
static mwArray Mimftype_istif(int nargout_, mwArray filename) {
mwLocalFunctionTable save_local_function_table_
(&_local_function_table_iofun_private_imftype);
mwArray tf(mclGetUninitializedArray());
mwArray ans(mclGetUninitializedArray());
mwArray sig(mclGetUninitializedArray());
mwArray fid(mclGetUninitializedArray());
//
// %ISTIF Returns true for a TIF file.
// % TF = ISTIF(FILENAME)
//
// fid = fopen(filename, 'r', 'ieee-le');
//
fid = fopen(mwVa(filename, "filename"), _mxarray83_, _mxarray85_);
//
// if (fid < 0)
//
if (mclLtBool(mwVv(fid, "fid"), _mxarray52_)) {
//
// tf = logical(0);
//
tf = logical(_mxarray52_);
//
// else
//
} else {
//
// sig = fread(fid, 4, 'uint8');
//
sig = fread(mwVv(fid, "fid"), _mxarray110_, _mxarray88_);
//
// fclose(fid);
//
ans.EqAns(fclose(mwVv(fid, "fid")));
//
// tf = isequal(sig, [73; 73; 42; 0]) | isequal(sig, [77; 77; 0; 42]);
//
tf
= mwVe(isequal(mwVv(sig, "sig"), mwVarargin(_mxarray111_)))
| mwVe(isequal(mwVv(sig, "sig"), mwVarargin(_mxarray113_)));
//
// end
//
}
mwValidateOutput(tf, 1, nargout_, "tf", "imftype/istif");
return tf;
//
//
//
}
//
// The function "Mimftype_ishdf" is the implementation version of the
// "imftype/ishdf" M-function from file
// "D:\matlab\matlab\toolbox\matlab\iofun\private\imftype.m" (lines 268-281).
// It contains the actual compiled code for that M-function. It is a static
// function and must only be called from one of the interface functions,
// appearing below.
//
//
// function tf = ishdf(filename)
//
static mwArray Mimftype_ishdf(int nargout_, mwArray filename) {
mwLocalFunctionTable save_local_function_table_
(&_local_function_table_iofun_private_imftype);
mwArray tf(mclGetUninitializedArray());
mwArray ans(mclGetUninitializedArray());
mwArray sig(mclGetUninitializedArray());
mwArray fid(mclGetUninitializedArray());
//
// %ISHDF Returns true for an HDF file.
// % TF = ISHDF(FILENAME)
//
// fid = fopen(filename, 'r', 'ieee-le');
//
fid = fopen(mwVa(filename, "filename"), _mxarray83_, _mxarray85_);
//
// if (fid < 0)
//
if (mclLtBool(mwVv(fid, "fid"), _mxarray52_)) {
//
// tf = logical(0);
//
tf = logical(_mxarray52_);
//
// else
//
} else {
//
// sig = fread(fid, 4, 'uint8');
//
sig = fread(mwVv(fid, "fid"), _mxarray110_, _mxarray88_);
//
// fclose(fid);
//
ans.EqAns(fclose(mwVv(fid, "fid")));
//
// tf = isequal(sig, [14; 3; 19; 1]);
//
tf = isequal(mwVv(sig, "sig"), mwVarargin(_mxarray115_));
//
// end
//
}
mwValidateOutput(tf, 1, nargout_, "tf", "imftype/ishdf");
return tf;
//
//
//
}
//
// The function "Mimftype_isgif" is the implementation version of the
// "imftype/isgif" M-function from file
// "D:\matlab\matlab\toolbox\matlab\iofun\private\imftype.m" (lines 281-294).
// It contains the actual compiled code for that M-function. It is a static
// function and must only be called from one of the interface functions,
// appearing below.
//
//
// function tf = isgif(filename)
//
static mwArray Mimftype_isgif(int nargout_, mwArray filename) {
mwLocalFunctionTable save_local_function_table_
(&_local_function_table_iofun_private_imftype);
mwArray tf(mclGetUninitializedArray());
mwArray ans(mclGetUninitializedArray());
mwArray sig(mclGetUninitializedArray());
mwArray fid(mclGetUninitializedArray());
//
// %ISGIF Returns true for a GIF file.
// % TF = ISGIF(FILENAME)
//
// fid = fopen(filename, 'r', 'ieee-le');
//
fid = fopen(mwVa(filename, "filename"), _mxarray83_, _mxarray85_);
//
// if (fid < 0)
//
if (mclLtBool(mwVv(fid, "fid"), _mxarray52_)) {
//
// tf = logical(0);
//
tf = logical(_mxarray52_);
//
// else
//
} else {
//
// sig = fread(fid, 3, 'uint8');
//
sig = fread(mwVv(fid, "fid"), _mxarray94_, _mxarray88_);
//
// fclose(fid);
//
ans.EqAns(fclose(mwVv(fid, "fid")));
//
// tf = isequal(sig, [71; 73; 70]);
//
tf = isequal(mwVv(sig, "sig"), mwVarargin(_mxarray117_));
//
// end
//
}
mwValidateOutput(tf, 1, nargout_, "tf", "imftype/isgif");
return tf;
//
//
//
}
//
// The function "Mimftype_iscur" is the implementation version of the
// "imftype/iscur" M-function from file
// "D:\matlab\matlab\toolbox\matlab\iofun\private\imftype.m" (lines 294-307).
// It contains the actual compiled code for that M-function. It is a static
// function and must only be called from one of the interface functions,
// appearing below.
//
//
// function tf = iscur(filename)
//
static mwArray Mimftype_iscur(int nargout_, mwArray filename) {
mwLocalFunctionTable save_local_function_table_
(&_local_function_table_iofun_private_imftype);
mwArray tf(mclGetUninitializedArray());
mwArray ans(mclGetUninitializedArray());
mwArray sig(mclGetUninitializedArray());
mwArray fid(mclGetUninitializedArray());
//
// %ISCUR Returns true for a CUR file.
// % TF = ISCUR(FILENAME)
//
// fid = fopen(filename, 'r', 'ieee-le');
//
fid = fopen(mwVa(filename, "filename"), _mxarray83_, _mxarray85_);
//
// if (fid < 0)
//
if (mclLtBool(mwVv(fid, "fid"), _mxarray52_)) {
//
// tf = logical(0);
//
tf = logical(_mxarray52_);
//
// else
//
} else {
//
// sig = fread(fid, 2, 'uint16');
//
sig = fread(mwVv(fid, "fid"), _mxarray87_, _mxarray119_);
//
// fclose(fid);
//
ans.EqAns(fclose(mwVv(fid, "fid")));
//
// tf = isequal(sig, [0; 2]);
//
tf = isequal(mwVv(sig, "sig"), mwVarargin(_mxarray121_));
//
// end
//
}
mwValidateOutput(tf, 1, nargout_, "tf", "imftype/iscur");
return tf;
//
//
//
}
//
// The function "Mimftype_isico" is the implementation version of the
// "imftype/isico" M-function from file
// "D:\matlab\matlab\toolbox\matlab\iofun\private\imftype.m" (lines 307-320).
// It contains the actual compiled code for that M-function. It is a static
// function and must only be called from one of the interface functions,
// appearing below.
//
//
// function tf = isico(filename)
//
static mwArray Mimftype_isico(int nargout_, mwArray filename) {
mwLocalFunctionTable save_local_function_table_
(&_local_function_table_iofun_private_imftype);
mwArray tf(mclGetUninitializedArray());
mwArray ans(mclGetUninitializedArray());
mwArray sig(mclGetUninitializedArray());
mwArray fid(mclGetUninitializedArray());
//
// %ISICO Returns true for an ICO file.
// % TF = ISICO(FILENAME)
//
// fid = fopen(filename, 'r', 'ieee-le');
//
fid = fopen(mwVa(filename, "filename"), _mxarray83_, _mxarray85_);
//
// if (fid < 0)
//
if (mclLtBool(mwVv(fid, "fid"), _mxarray52_)) {
//
// tf = logical(0);
//
tf = logical(_mxarray52_);
//
// else
//
} else {
//
// sig = fread(fid, 2, 'uint16');
//
sig = fread(mwVv(fid, "fid"), _mxarray87_, _mxarray119_);
//
// fclose(fid);
//
ans.EqAns(fclose(mwVv(fid, "fid")));
//
// tf = isequal(sig, [0; 1]);
//
tf = isequal(mwVv(sig, "sig"), mwVarargin(_mxarray123_));
//
// end
//
}
mwValidateOutput(tf, 1, nargout_, "tf", "imftype/isico");
return tf;
//
//
//
}
//
// The function "Mimftype_byteswap" is the implementation version of the
// "imftype/byteswap" M-function from file
// "D:\matlab\matlab\toolbox\matlab\iofun\private\imftype.m" (lines 320-329).
// It contains the actual compiled code for that M-function. It is a static
// function and must only be called from one of the interface functions,
// appearing below.
//
//
// function out = byteswap(in)
//
static mwArray Mimftype_byteswap(int nargout_, mwArray in) {
mwLocalFunctionTable save_local_function_table_
(&_local_function_table_iofun_private_imftype);
mwArray out(mclGetUninitializedArray());
mwArray highByte(mclGetUninitializedArray());
mwArray lowByte(mclGetUninitializedArray());
//
// %BYTESWAP Swap byte order for a number between 0 and 65535.
// % OUT = BYTESWAP(IN)
//
// lowByte = bitand(in, 255);
//
lowByte = bitand_func(mwVa(in, "in"), _mxarray125_);
//
// highByte = bitshift(bitand(in, 65280), -8);
//
highByte
= bitshift(
mwVe(bitand_func(mwVa(in, "in"), _mxarray126_)), _mxarray127_);
//
// out = bitor(bitshift(lowByte, 8), highByte);
//
out
= bitor_func(
mwVe(bitshift(mwVv(lowByte, "lowByte"), _mxarray101_)),
mwVv(highByte, "highByte"));
mwValidateOutput(out, 1, nargout_, "out", "imftype/byteswap");
return out;
//
//
//
//
}