/*-----------------------------------------------------------Escaper::process-+
| Main routine |
+----------------------------------------------------------------------------*/
void Escaper::process(char const * pBeg, int len)
{
int k;
char const * pCur = (char const *)memchr(pBeg, ESCAPE_CHAR, len);
char const * pEnd = pBeg + len;
if (m_wait.size >= 0) {
k = sizeof m_wait.buf - m_wait.size;
if (pCur) {
if ((pCur - pBeg) < k) k = pCur - pBeg;
}else {
if (len < k) k = len;
}
memcpy(m_wait.buf + m_wait.size, pBeg, k);
switch (findDecoder(m_wait.buf, k+m_wait.size)) {
case Decoder::NOT_ME:
output(&m_wait.esc, m_wait.size+1);
m_wait.size = -1;
break;
case Decoder::ME_DUNNO:
m_wait.size += k;
return;
default: // valid escape sequence
m_decoder->action();
k = strlen(m_decoder->getCode()) - m_wait.size;
assert (k > 0);
m_wait.size = -1;
pBeg += k;
len -= k;
break;
}
}
for (;;) {
if (pCur) {
len = pEnd - ++pCur;
switch (findDecoder(pCur, len)) {
case Decoder::NOT_ME:
break;
case Decoder::ME_DUNNO:
assert (len <= sizeof m_wait.buf);
memcpy(m_wait.buf, pCur, len);
if (pCur > pBeg) output(pBeg, pCur-pBeg-1);
m_wait.size = len;
return;
default: // valid escape sequence
if (pCur > pBeg) output(pBeg, pCur-pBeg-1);
k = strlen(m_decoder->getCode());
pCur += k;
len -= k;
pBeg = pCur;
m_decoder->action();
break;
}
pCur = (char const *)memchr(pCur, ESCAPE_CHAR, len);
}else {
if (pEnd > pBeg) output(pBeg, pEnd - pBeg);
return;
}
}
}
int sceAudiocodecDecode(u32 ctxPtr, int codec) {
if (!ctxPtr){
ERROR_LOG_REPORT(ME, "sceAudiocodecDecode(%08x, %i (%s)) got NULL pointer", ctxPtr, codec, GetCodecName(codec));
return -1;
}
if (IsValidCodec(codec)){
// Use SimpleAudioDec to decode audio
auto ctx = PSPPointer<AudioCodecContext>::Create(ctxPtr); // On stack, no need to allocate.
int outbytes = 0;
// find a decoder in audioList
auto decoder = findDecoder(ctxPtr);
if (!decoder && oldStateLoaded) {
// We must have loaded an old state that did not have sceAudiocodec information.
// Fake it by creating the desired context.
decoder = new SimpleAudio(codec);
decoder->SetCtxPtr(ctxPtr);
audioList[ctxPtr] = decoder;
}
if (decoder != NULL) {
// Decode audio
decoder->Decode(Memory::GetPointer(ctx->inDataPtr), ctx->inDataSize, Memory::GetPointer(ctx->outDataPtr), &outbytes);
}
DEBUG_LOG(ME, "sceAudiocodecDec(%08x, %i (%s))", ctxPtr, codec, GetCodecName(codec));
return 0;
}
ERROR_LOG_REPORT(ME, "UNIMPL sceAudiocodecDecode(%08x, %i (%s))", ctxPtr, codec, GetCodecName(codec));
return 0;
}
static void*
imdecode_( const Mat& buf, int flags, int hdrtype, Mat* mat=0 )
{
CV_Assert(buf.data && buf.isContinuous());
IplImage* image = 0;
CvMat *matrix = 0;
Mat temp, *data = &temp;
string filename;
ImageDecoder decoder = findDecoder(buf);
if( decoder.empty() )
return 0;
if( !decoder->setSource(buf) )
{
filename = tempfile();
FILE* f = fopen( filename.c_str(), "wb" );
if( !f )
return 0;
size_t bufSize = buf.cols*buf.rows*buf.elemSize();
fwrite( &buf.data[0], 1, bufSize, f );
fclose(f);
decoder->setSource(filename);
}
if( !decoder->readHeader() )
{
if( !filename.empty() )
remove(filename.c_str());
return 0;
}
CvSize size;
size.width = decoder->width();
size.height = decoder->height();
int type = decoder->type();
if( flags != -1 )
{
if( (flags & CV_LOAD_IMAGE_ANYDEPTH) == 0 )
type = CV_MAKETYPE(CV_8U, CV_MAT_CN(type));
if( (flags & CV_LOAD_IMAGE_COLOR) != 0 ||
((flags & CV_LOAD_IMAGE_ANYCOLOR) != 0 && CV_MAT_CN(type) > 1) )
type = CV_MAKETYPE(CV_MAT_DEPTH(type), 3);
else
type = CV_MAKETYPE(CV_MAT_DEPTH(type), 1);
}
if( hdrtype == LOAD_CVMAT || hdrtype == LOAD_MAT )
{
if( hdrtype == LOAD_CVMAT )
{
matrix = cvCreateMat( size.height, size.width, type );
temp = cvarrToMat(matrix);
}
else
{
mat->create( size.height, size.width, type );
data = mat;
}
}
else
{
image = cvCreateImage( size, cvIplDepth(type), CV_MAT_CN(type) );
temp = cvarrToMat(image);
}
bool code = decoder->readData( *data );
if( !filename.empty() )
remove(filename.c_str());
if( !code )
{
cvReleaseImage( &image );
cvReleaseMat( &matrix );
if( mat )
mat->release();
return 0;
}
return hdrtype == LOAD_CVMAT ? (void*)matrix :
hdrtype == LOAD_IMAGE ? (void*)image : (void*)mat;
}
static void*
imread_( const string& filename, int flags, int hdrtype, Mat* mat=0 )
{
IplImage* image = 0;
CvMat *matrix = 0;
Mat temp, *data = &temp;
ImageDecoder decoder = findDecoder(filename);
if( decoder.empty() )
return 0;
decoder->setSource(filename);
if( !decoder->readHeader() )
return 0;
CvSize size;
size.width = decoder->width();
size.height = decoder->height();
int type = decoder->type();
if( flags != -1 )
{
if( (flags & CV_LOAD_IMAGE_ANYDEPTH) == 0 )
type = CV_MAKETYPE(CV_8U, CV_MAT_CN(type));
if( (flags & CV_LOAD_IMAGE_COLOR) != 0 ||
((flags & CV_LOAD_IMAGE_ANYCOLOR) != 0 && CV_MAT_CN(type) > 1) )
type = CV_MAKETYPE(CV_MAT_DEPTH(type), 3);
else
type = CV_MAKETYPE(CV_MAT_DEPTH(type), 1);
}
if( hdrtype == LOAD_CVMAT || hdrtype == LOAD_MAT )
{
if( hdrtype == LOAD_CVMAT )
{
matrix = cvCreateMat( size.height, size.width, type );
temp = cvarrToMat(matrix);
}
else
{
mat->create( size.height, size.width, type );
data = mat;
}
}
else
{
image = cvCreateImage( size, cvIplDepth(type), CV_MAT_CN(type) );
temp = cvarrToMat(image);
}
if( !decoder->readData( *data ))
{
cvReleaseImage( &image );
cvReleaseMat( &matrix );
if( mat )
mat->release();
return 0;
}
return hdrtype == LOAD_CVMAT ? (void*)matrix :
hdrtype == LOAD_IMAGE ? (void*)image : (void*)mat;
}
/**
* Read an image into memory and return the information
*
* @param[in] filename File to load
* @param[in] flags Flags
* @param[in] mats Reference to C++ vector<Mat> object to hold the images
*
*/
static bool
imreadmulti_(const String& filename, int flags, std::vector<Mat>& mats)
{
/// Search for the relevant decoder to handle the imagery
ImageDecoder decoder;
#ifdef HAVE_GDAL
if (flags != IMREAD_UNCHANGED && (flags & IMREAD_LOAD_GDAL) == IMREAD_LOAD_GDAL){
decoder = GdalDecoder().newDecoder();
}
else{
#endif
decoder = findDecoder(filename);
#ifdef HAVE_GDAL
}
#endif
/// if no decoder was found, return nothing.
if (!decoder){
return 0;
}
/// set the filename in the driver
decoder->setSource(filename);
// read the header to make sure it succeeds
if (!decoder->readHeader())
return 0;
for (;;)
{
// grab the decoded type
int type = decoder->type();
if( (flags & IMREAD_LOAD_GDAL) != IMREAD_LOAD_GDAL && flags != IMREAD_UNCHANGED )
{
if ((flags & CV_LOAD_IMAGE_ANYDEPTH) == 0)
type = CV_MAKETYPE(CV_8U, CV_MAT_CN(type));
if ((flags & CV_LOAD_IMAGE_COLOR) != 0 ||
((flags & CV_LOAD_IMAGE_ANYCOLOR) != 0 && CV_MAT_CN(type) > 1))
type = CV_MAKETYPE(CV_MAT_DEPTH(type), 3);
else
type = CV_MAKETYPE(CV_MAT_DEPTH(type), 1);
}
// read the image data
Mat mat(decoder->height(), decoder->width(), type);
if (!decoder->readData(mat))
{
// optionally rotate the data if EXIF' orientation flag says so
if( (flags & IMREAD_IGNORE_ORIENTATION) == 0 && flags != IMREAD_UNCHANGED )
{
ApplyExifOrientation(filename, mat);
}
break;
}
mats.push_back(mat);
if (!decoder->nextPage())
{
break;
}
}
return !mats.empty();
}
/**
* Read an image into memory and return the information
*
* @param[in] filename File to load
* @param[in] flags Flags
* @param[in] hdrtype { LOAD_CVMAT=0,
* LOAD_IMAGE=1,
* LOAD_MAT=2
* }
* @param[in] mat Reference to C++ Mat object (If LOAD_MAT)
* @param[in] scale_denom Scale value
*
*/
static void*
imread_( const String& filename, int flags, int hdrtype, Mat* mat=0 )
{
IplImage* image = 0;
CvMat *matrix = 0;
Mat temp, *data = &temp;
/// Search for the relevant decoder to handle the imagery
ImageDecoder decoder;
#ifdef HAVE_GDAL
if(flags != IMREAD_UNCHANGED && (flags & IMREAD_LOAD_GDAL) == IMREAD_LOAD_GDAL ){
decoder = GdalDecoder().newDecoder();
}else{
#endif
decoder = findDecoder( filename );
#ifdef HAVE_GDAL
}
#endif
/// if no decoder was found, return nothing.
if( !decoder ){
return 0;
}
int scale_denom = 1;
if( flags > IMREAD_LOAD_GDAL )
{
if( flags & IMREAD_REDUCED_GRAYSCALE_2 )
scale_denom = 2;
else if( flags & IMREAD_REDUCED_GRAYSCALE_4 )
scale_denom = 4;
else if( flags & IMREAD_REDUCED_GRAYSCALE_8 )
scale_denom = 8;
}
/// set the scale_denom in the driver
decoder->setScale( scale_denom );
/// set the filename in the driver
decoder->setSource( filename );
// read the header to make sure it succeeds
if( !decoder->readHeader() )
return 0;
// established the required input image size
CvSize size;
size.width = decoder->width();
size.height = decoder->height();
// grab the decoded type
int type = decoder->type();
if( (flags & IMREAD_LOAD_GDAL) != IMREAD_LOAD_GDAL && flags != IMREAD_UNCHANGED )
{
if( (flags & CV_LOAD_IMAGE_ANYDEPTH) == 0 )
type = CV_MAKETYPE(CV_8U, CV_MAT_CN(type));
if( (flags & CV_LOAD_IMAGE_COLOR) != 0 ||
((flags & CV_LOAD_IMAGE_ANYCOLOR) != 0 && CV_MAT_CN(type) > 1) )
type = CV_MAKETYPE(CV_MAT_DEPTH(type), 3);
else
type = CV_MAKETYPE(CV_MAT_DEPTH(type), 1);
}
if( hdrtype == LOAD_CVMAT || hdrtype == LOAD_MAT )
{
if( hdrtype == LOAD_CVMAT )
{
matrix = cvCreateMat( size.height, size.width, type );
temp = cvarrToMat( matrix );
}
else
{
mat->create( size.height, size.width, type );
data = mat;
}
}
else
{
image = cvCreateImage( size, cvIplDepth(type), CV_MAT_CN(type) );
temp = cvarrToMat( image );
}
// read the image data
if( !decoder->readData( *data ))
{
cvReleaseImage( &image );
cvReleaseMat( &matrix );
if( mat )
mat->release();
return 0;
}
if( decoder->setScale( scale_denom ) > 1 ) // if decoder is JpegDecoder then decoder->setScale always returns 1
{
resize( *mat, *mat, Size( size.width / scale_denom, size.height / scale_denom ) );
}
return hdrtype == LOAD_CVMAT ? (void*)matrix :
hdrtype == LOAD_IMAGE ? (void*)image : (void*)mat;
}
int ffplay(const char *filename, const char *force_format) {
char errbuf[256];
int r = 0;
int frameFinished;
AVPacket packet;
int audio_buf_size = AVCODEC_MAX_AUDIO_FRAME_SIZE;
int16_t *audio_buf = (int16_t *) malloc((AVCODEC_MAX_AUDIO_FRAME_SIZE * 3) / 2);
if(!audio_buf) {
ds_printf("DS_ERROR: No free memory\n");
return -1;
}
memset(audio_buf, 0, (AVCODEC_MAX_AUDIO_FRAME_SIZE * 3) / 2);
AVFormatContext *pFormatCtx = NULL;
AVFrame *pFrame = NULL;
AVCodecContext *pVideoCodecCtx = NULL, *pAudioCodecCtx = NULL;
AVInputFormat *file_iformat = NULL;
video_txr_t movie_txr;
int videoStream = -1, audioStream = -1;
maple_device_t *cont = NULL;
cont_state_t *state = NULL;
int pause = 0, done = 0;
char fn[MAX_FN_LEN];
sprintf(fn, "ds:%s", filename);
memset(&movie_txr, 0, sizeof(movie_txr));
if(!codecs_inited) {
avcodec_register_all();
avcodec_register(&mp1_decoder);
avcodec_register(&mp2_decoder);
avcodec_register(&mp3_decoder);
avcodec_register(&vorbis_decoder);
//avcodec_register(&mpeg4_decoder);
codecs_inited = 1;
}
if(force_format)
file_iformat = av_find_input_format(force_format);
else
file_iformat = NULL;
// Open video file
ds_printf("DS_PROCESS_FFMPEG: Opening file: %s\n", filename);
if((r = av_open_input_file((AVFormatContext**)(&pFormatCtx), fn, file_iformat, /*FFM_PACKET_SIZE*/0, NULL)) != 0) {
av_strerror(r, errbuf, 256);
ds_printf("DS_ERROR_FFMPEG: %s\n", errbuf);
free(audio_buf);
return -1; // Couldn't open file
}
// Retrieve stream information
ds_printf("DS_PROCESS_FFMPEG: Retrieve stream information...\n");
if((r = av_find_stream_info(pFormatCtx)) < 0) {
av_strerror(r, errbuf, 256);
ds_printf("DS_ERROR_FFMPEG: %s\n", errbuf);
av_close_input_file(pFormatCtx);
free(audio_buf);
return -1; // Couldn't find stream information
}
// Dump information about file onto standard error
dump_format(pFormatCtx, 0, filename, 0);
//thd_sleep(5000);
pVideoCodecCtx = findDecoder(pFormatCtx, AVMEDIA_TYPE_VIDEO, &videoStream);
pAudioCodecCtx = findDecoder(pFormatCtx, AVMEDIA_TYPE_AUDIO, &audioStream);
//LockInput();
if(pVideoCodecCtx) {
//LockVideo();
ShutdownVideoThread();
SDL_DS_FreeScreenTexture(0);
int format = 0;
switch(pVideoCodecCtx->pix_fmt) {
case PIX_FMT_YUV420P:
case PIX_FMT_YUVJ420P:
format = PVR_TXRFMT_YUV422;
#ifdef USE_HW_YUV
yuv_conv_init();
#endif
break;
case PIX_FMT_UYVY422:
case PIX_FMT_YUVJ422P:
format = PVR_TXRFMT_YUV422;
break;
default:
format = PVR_TXRFMT_RGB565;
break;
}
MakeVideoTexture(&movie_txr, pVideoCodecCtx->width, pVideoCodecCtx->height, format | PVR_TXRFMT_NONTWIDDLED, PVR_FILTER_BILINEAR);
#ifdef USE_HW_YUV
yuv_conv_setup(movie_txr.addr, PVR_YUV_MODE_MULTI, PVR_YUV_FORMAT_YUV420, movie_txr.width, movie_txr.height);
pvr_dma_init();
#endif
} else {
ds_printf("DS_ERROR: Didn't find a video stream.\n");
}
if(pAudioCodecCtx) {
#ifdef USE_DIRECT_AUDIO
audioinit(pAudioCodecCtx);
#else
sprintf(fn, "%s/firmware/aica/ds_stream.drv", getenv("PATH"));
if(snd_init_fw(fn) < 0) {
goto exit_free;
}
if(aica_audio_open(pAudioCodecCtx->sample_rate, pAudioCodecCtx->channels, 8192) < 0) {
goto exit_free;
}
//snd_cpu_clock(0x19);
//snd_init_decoder(8192);
#endif
} else {
ds_printf("DS_ERROR: Didn't find a audio stream.\n");
}
//ds_printf("FORMAT: %d\n", pVideoCodecCtx->pix_fmt);
// Allocate video frame
pFrame = avcodec_alloc_frame();
if(pFrame == NULL) {
ds_printf("DS_ERROR: Can't alloc memory\n");
goto exit_free;
}
int pressed = 0, framecnt = 0;
uint32 fa = 0;
fa = GET_EXPORT_ADDR("ffplay_format_handler");
if(fa > 0 && fa != 0xffffffff) {
EXPT_GUARD_BEGIN;
void (*ff_format_func)(AVFormatContext *, AVCodecContext *, AVCodecContext *) =
(void (*)(AVFormatContext *, AVCodecContext *, AVCodecContext *))fa;
ff_format_func(pFormatCtx, pVideoCodecCtx, pAudioCodecCtx);
EXPT_GUARD_CATCH;
EXPT_GUARD_END;
}
fa = GET_EXPORT_ADDR("ffplay_frame_handler");
void (*ff_frame_func)(AVFrame *) = NULL;
if(fa > 0 && fa != 0xffffffff) {
EXPT_GUARD_BEGIN;
ff_frame_func = (void (*)(AVFrame *))fa;
// Test call
ff_frame_func(NULL);
EXPT_GUARD_CATCH;
ff_frame_func = NULL;
EXPT_GUARD_END;
}
fa = GET_EXPORT_ADDR("ffplay_render_handler");
if(fa > 0 && fa != 0xffffffff) {
EXPT_GUARD_BEGIN;
movie_txr.render_cb = (void (*)(void *))fa;
// Test call
movie_txr.render_cb(NULL);
EXPT_GUARD_CATCH;
movie_txr.render_cb = NULL;
EXPT_GUARD_END;
}
while(av_read_frame(pFormatCtx, &packet) >= 0 && !done) {
do {
if(ff_frame_func)
ff_frame_func(pFrame);
cont = maple_enum_type(0, MAPLE_FUNC_CONTROLLER);
framecnt++;
if(cont) {
state = (cont_state_t *)maple_dev_status(cont);
if (!state) {
break;
}
if (state->buttons & CONT_START || state->buttons & CONT_B) {
av_free_packet(&packet);
done = 1;
}
if (state->buttons & CONT_A) {
if((framecnt - pressed) > 10) {
pause = pause ? 0 : 1;
if(pause) {
#ifdef USE_DIRECT_AUDIO
audio_end();
#else
stop_audio();
#endif
} else {
#ifndef USE_DIRECT_AUDIO
start_audio();
#endif
}
}
pressed = framecnt;
}
if(state->buttons & CONT_DPAD_LEFT) {
//av_seek_frame(pFormatCtx, -1, timestamp * ( AV_TIME_BASE / 1000 ), AVSEEK_FLAG_BACKWARD);
}
if(state->buttons & CONT_DPAD_RIGHT) {
//av_seek_frame(pFormatCtx, -1, timestamp * ( AV_TIME_BASE / 1000 ), AVSEEK_FLAG_BACKWARD);
}
}
if(pause) thd_sleep(100);
} while(pause);
//printf("Packet: size: %d data: %02x%02x%02x pst: %d\n", packet.size, packet.data[0], packet.data[1], packet.data[2], pFrame->pts);
// Is this a packet from the video stream?
if(packet.stream_index == videoStream) {
//printf("video\n");
// Decode video frame
if((r = avcodec_decode_video2(pVideoCodecCtx, pFrame, &frameFinished, &packet)) < 0) {
//av_strerror(r, errbuf, 256);
//printf("DS_ERROR_FFMPEG: %s\n", errbuf);
} else {
// Did we get a video frame?
if(frameFinished && !pVideoCodecCtx->hurry_up) {
RenderVideo(&movie_txr, pFrame, pVideoCodecCtx);
}
}
} else if(packet.stream_index == audioStream) {
//printf("audio\n");
//snd_decode((uint8*)audio_buf, audio_buf_size, AICA_CODEC_MP3);
audio_buf_size = AVCODEC_MAX_AUDIO_FRAME_SIZE;
if((r = avcodec_decode_audio3(pAudioCodecCtx, audio_buf, &audio_buf_size, &packet)) < 0) {
//av_strerror(r, errbuf, 256);
//printf("DS_ERROR_FFMPEG: %s\n", errbuf);
//continue;
} else {
if(audio_buf_size > 0 && !pAudioCodecCtx->hurry_up) {
#ifdef USE_DIRECT_AUDIO
audio_write(pAudioCodecCtx, audio_buf, audio_buf_size);
#else
aica_audio_write((char*)audio_buf, audio_buf_size);
#endif
}
}
}
// Free the packet that was allocated by av_read_frame
av_free_packet(&packet);
}
goto exit_free;
exit_free:
if(pFrame)
av_free(pFrame);
if(pFormatCtx)
av_close_input_file(pFormatCtx);
if(audioStream > -1) {
if(pAudioCodecCtx)
avcodec_close(pAudioCodecCtx);
#ifdef USE_DIRECT_AUDIO
audio_end();
#else
aica_audio_close();
sprintf(fn, "%s/firmware/aica/kos_stream.drv", getenv("PATH"));
snd_init_fw(fn);
#endif
}
if(audio_buf) {
free(audio_buf);
}
if(videoStream > -1) {
if(pVideoCodecCtx)
avcodec_close(pVideoCodecCtx);
FreeVideoTexture(&movie_txr);
SDL_DS_AllocScreenTexture(GetScreen());
InitVideoThread();
//UnlockVideo();
}
//UnlockInput();
ProcessVideoEventsUpdate(NULL);
return 0;
}
static void*
imdecode_( const Vector<uchar>& buf, int flags, int hdrtype, Mat* mat=0 )
{
IplImage* image = 0;
CvMat *matrix = 0;
Mat temp, *data = &temp;
char fnamebuf[L_tmpnam];
const char* filename = 0;
ImageDecoder decoder = findDecoder(buf);
if( !decoder.obj )
return 0;
if( !decoder->setSource(buf) )
{
filename = tmpnam(fnamebuf);
FILE* f = fopen( filename, "wb" );
if( !f )
return 0;
fwrite( &buf[0], 1, buf.size(), f );
fclose(f);
decoder->setSource(filename);
}
if( !decoder->readHeader() )
{
if( filename )
unlink(filename);
return 0;
}
CvSize size;
size.width = decoder->width();
size.height = decoder->height();
int type = decoder->type();
if( flags != -1 )
{
if( (flags & CV_LOAD_IMAGE_ANYDEPTH) == 0 )
type = CV_MAKETYPE(CV_8U, CV_MAT_CN(type));
if( (flags & CV_LOAD_IMAGE_COLOR) != 0 ||
((flags & CV_LOAD_IMAGE_ANYCOLOR) != 0 && CV_MAT_CN(type) > 1) )
type = CV_MAKETYPE(CV_MAT_DEPTH(type), 3);
else
type = CV_MAKETYPE(CV_MAT_DEPTH(type), 1);
}
if( hdrtype == LOAD_CVMAT || hdrtype == LOAD_MAT )
{
if( hdrtype == LOAD_CVMAT )
{
matrix = cvCreateMat( size.height, size.width, type );
temp = cvarrToMat(matrix);
}
else
{
mat->create( size.height, size.width, type );
data = mat;
}
}
else
{
image = cvCreateImage( size, cvIplDepth(type), CV_MAT_CN(type) );
temp = cvarrToMat(image);
}
bool code = decoder->readData( *data );
if( filename )
unlink(filename);
if( !code )
{
cvReleaseImage( &image );
cvReleaseMat( &matrix );
if( mat )
mat->release();
return 0;
}
return hdrtype == LOAD_CVMAT ? (void*)matrix :
hdrtype == LOAD_IMAGE ? (void*)image : (void*)mat;
}
