//timer needs to check if the return frame is NULL. NULL at end of frames.
CvMat* get_encoded(CvCapture *video, int scale){
// Obtain the next frame from the video file
IplImage *image;
CvMat *encoded;
if(scale > 1)
{
int j;
for(j = 0; j < scale - 1; j++)
{
cvQueryFrame(video);
}
}
image = cvQueryFrame(video);
if (!image) {
// Next frame doesn't exist or can't be obtained.
return NULL;
}
// Convert the frame to a smaller size (WIDTH x HEIGHT)
CvMat *thumb = cvCreateMat(360, 480, CV_8UC3);
cvResize(image, thumb, CV_INTER_AREA);
// Encode the frame in JPEG format with JPEG quality 100%.
const int encodeParams[] = { CV_IMWRITE_JPEG_QUALITY, 30 };
encoded = cvEncodeImage(".jpeg", image, encodeParams);
return encoded;
}
void Image_Handler(FCGIContext * context, char * params)
{
int num = 0, width = 800, height = 600;
FCGIValue val[] = {
{"num", &num, FCGI_INT_T},
{"width", &width, FCGI_INT_T},
{"height", &height, FCGI_INT_T}
};
if (!FCGI_ParseRequest(context, params, val, 3))
return;
else if (num < 0 || num > 1) {
FCGI_RejectJSON(context, "Invalid capture number");
return;
} else if (width <= 0 || height <= 0) {
FCGI_RejectJSON(context, "Invalid width/height");
return;
}
if (captureID != num) {
if (captureID >= 0) {
cvReleaseCapture(&capture);
}
capture = cvCreateCameraCapture(num);
captureID = num;
}
cvSetCaptureProperty(capture, CV_CAP_PROP_FRAME_WIDTH, width);
cvSetCaptureProperty(capture, CV_CAP_PROP_FRAME_HEIGHT, height);
static int p[] = {CV_IMWRITE_JPEG_QUALITY, 100, 0};
IplImage * frame = cvQueryFrame(capture);
assert(frame != NULL);
// CvMat stub;
// CvMat * background = cvGetMat(frame, &stub, 0, 0);
// CvMat *cv8u = cvCreateMat(frame->width, frame->height, CV_8U);
// double min, max;
// CvPoint a,b;
// cvMinMaxLoc(background, &min, &max, &a, &b, 0);
// double ccscale = 255.0/(max-min);
// double ccshift = -min;
//cvCvtScale(frame, cv8u, ccscale, ccshift);
CvMat * jpg = cvEncodeImage(".jpg", frame, p);
// Will this work?
Log(LOGNOTE, "Sending image!");
FCGI_PrintRaw("Content-type: image/jpg\r\n");
FCGI_PrintRaw("Cache-Control: no-cache, no-store, must-revalidate\r\n\r\n");
//FCGI_PrintRaw("Content-Length: %d", jpg->rows*jpg->cols);
FCGI_WriteBinary(jpg->data.ptr,1,jpg->rows*jpg->cols);
cvReleaseMat(&jpg);
cvReleaseImageHeader(&frame);
}
CvMat* img(IplImage *source) {
int width = 200;
int height = (width * (source->height)) / (source->width);
int param[3] = {CV_IMWRITE_PNG_COMPRESSION, 3, 0};
IplImage *destination = cvCreateImage(
cvSize( width, height ),
source->depth, source->nChannels );
cvResize( source, destination, CV_INTER_AREA );
return cvEncodeImage(".png", destination, param );
}
// function to compress 3 channel color IplImages
// returns CvMat that needs to be released by the calling function
CvMat* Image::compress_image(IplImage** dst_img, IplImage* src_img, int p[3])
{
// create a compressed matrix cvmat
CvMat *imgcmp = cvEncodeImage(".jpeg", src_img, p);
if(imgcmp == NULL)
return NULL;
// cvmat to IplImage
IplImage iplstub;
*dst_img = cvGetImage(imgcmp, &iplstub);
if (*dst_img == NULL)
return NULL;
return imgcmp;
}
// FIXME: error handling
static void opencv_exec(unsigned char* src, int src_size, unsigned char* path, int path_size, int w, int h, /*out*/ void** descriptor) {
char ext[256]; // NULL terminated cstr
int ext_pos = (sizeof(ext) < (path_size+1)) ? path_size+1 - sizeof(ext) : 0;
memcpy(ext, path, path_size - ext_pos);
ext[path_size - ext_pos] = 0;
CvMat tmp = cvMat(16384, 16384, CV_8UC4, (void*)src);
CvMat* src_img = cvDecodeImageM(&tmp, CV_LOAD_IMAGE_COLOR);
CvMat dst_img = cvMat(h, w, src_img->type, NULL);
cvCreateData(&dst_img);
cvResize(src_img, &dst_img, CV_INTER_AREA); // FIXME: using CV_INTER_AREA only if got scaled down
CvMat* enc_img = cvEncodeImage(ext, &dst_img, 0);
//out:
cvReleaseMat(&src_img);
cvReleaseData(&dst_img);
*descriptor = (void*)enc_img;
}
void* encode_image(void* m, int ext, int comp){
IplImage* img = (IplImage*)m;
int params[3];
char* type;
params[1] = comp;
params[2] = 0;
switch(ext) {
case 1:
params[0] = CV_IMWRITE_PNG_COMPRESSION;
type = ".png";
break;
case 2:
params[0] = CV_IMWRITE_JPEG_QUALITY;
type = ".jpeg";
break;
}
return (void*)cvEncodeImage(type, img, params);
}
void send_frame(union sigval sv_data) {
int i;
IplImage *image;
CvMat *encoded;
send_frame_data_t *data = sv_data.sival_ptr;
printf("speed: %d\n",data->speed);
printf("client_fd: %d\n",data->client_fd);
for(i=0; i < data->speed; i++) {
image = cvQueryFrame(data->video);
if (!image) {
printf("%s\n","Could not get image!");
}
}
if(!image) {
puts("could not get frame");
return;
}
// set the size of the thumb
printf("%s\n","Is thumb this the failure?");
CvMat* thumb = cvCreateMat(250, 250, CV_8UC3);
printf("%s\n","Is image this the failure?");
cvResize(image, thumb, CV_INTER_AREA);
printf("%s\n","Is encodeParams this the failure?");
// Encode the frame in JPEG format with JPEG quality 30%.
const static int encodeParams[] = { CV_IMWRITE_JPEG_QUALITY, 30 };
printf("%s\n","Is encoded this the failure?");
encoded = cvEncodeImage(".jpeg", thumb, encodeParams);
unsigned short int seq_num = data-> frame_num;
//unsigned int time_stamp = (data->speed *40) + data->time_stamp;
unsigned int time_stamp = 40 + data->time_stamp;
srandom((unsigned)time(NULL));
unsigned int ssrc = random();
unsigned short int payloadlength = encoded->cols;
unsigned short int packet_len = 12 + payloadlength; //12 byte header
// Create the rtp_packet
unsigned char *rtp_packet = malloc(packet_len+4); // need to add 4 to the prefix
if(rtp_packet == NULL) {
printf("%s\n", "Error allocating memory to rtp_packet");
return;
}
// prefix data
rtp_packet[0] = 0x24; // $ sign
rtp_packet[1] = 0x00;
rtp_packet[2] = (packet_len & 0xFF00) >> 8;
rtp_packet[3] = packet_len & 0x00FFF;
// header
rtp_packet[4] = head_first & 0xFF;
rtp_packet[5] = head_second & 0xFF;
rtp_packet[6] = (seq_num & 0xFF00) >> 8;
rtp_packet[7] = seq_num & 0x00FF;
rtp_packet[8] = time_stamp & 0xFF000000;
rtp_packet[9] = time_stamp & 0x00FF0000;
rtp_packet[10] = time_stamp & 0x0000FF00;
rtp_packet[11] = time_stamp & 0x000000FF;
rtp_packet[12] = ssrc & 0xFF000000;
rtp_packet[13] = ssrc & 0x00FF0000;
rtp_packet[14] = ssrc & 0x0000FF00;
rtp_packet[15] = ssrc & 0x000000FF;
//payload
printf("1\n");
printf("rtp_packet length: %d, payloadlength: %d, encoded length: %d\n",
(sizeof rtp_packet), payloadlength, encoded->cols);
memcpy(rtp_packet+16, encoded->data.ptr, payloadlength);
// return the packet
if(send(data->client_fd, rtp_packet, packet_len+4,0) == -1) {
puts("error sending packet");
perror("send");
}
free(rtp_packet);
printf("%d\n",data->frame_num);
printf("%d\n",data->time_stamp);
data->frame_num = data->frame_num + data->speed;
data->time_stamp = time_stamp;
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//show rectangle boxes(with object_tracking result)
void show_rects(IplImage *Image,RESULT *CUR,FLOAT ratio)
{
#if 0
//parameters
const int height = Image->height;
const int width = Image->width;
const int UpY = 0;
const int NEW_Y = Image->height;
for(int ii=0;ii<CUR->num;ii++)
{
//int *P = CUR->point+4*ii;
int *P = CUR->OR_point+4*ii;
CvScalar col = get_color(CUR->type[ii]);
CvPoint p1=cvPoint(P[0],P[1]);
CvPoint p2=cvPoint(P[2],P[3]);
cvRectangle(Image,p1,p2,col,3); //draw current-object rectangle
cvLine(Image,p1,p2,col,2);
p1 = cvPoint(P[0],P[3]);
p2 = cvPoint(P[2],P[1]);
cvLine(Image,p1,p2,col,2);
}
#else
//parameters
const int height = Image->height;
const int width = Image->width;
const int UpY = 0;
const int NEW_Y = Image->height;
// generate key
// key_t shm_key = ftok(OUTPUT_SHM_PATH, 1);
// if(shm_key == -1) {
// printf("key generation for output_SHM is failed\n");
// }
key_t shm_key_height = ftok(HEIGHT_SHM_PATH, 1);
if(shm_key_height == -1) {
printf("key generation for height_SHM is failed\n");
}
key_t shm_key_width = ftok(WIDTH_SHM_PATH, 1);
if(shm_key_width == -1) {
printf("key generation for width_SHM is failed\n");
}
// key_t shm_key_rbuf_dst = ftok(RBUF_DST_PATH, 1);
// if(shm_key_rbuf_dst == -1) {
// printf("key generation for rbuf_dst_SHM is failed\n");
// }
key_t shm_key_rbuf = ftok(RBUF_PATH, 1);
if(shm_key_rbuf == -1) {
printf("key generation for rbuf_SHM is failed\n");
}
key_t shm_key_rbuf_head = ftok(RBUF_HEAD_PATH, 1);
if(shm_key_rbuf_head == -1) {
printf("key generation for rbuf_head_SHM is failed\n");
}
key_t shm_key_rbuf_tail = ftok(RBUF_TAIL_PATH, 1);
if(shm_key_rbuf_tail == -1) {
printf("key generation for rbuf_tail_SHM is failed\n");
}
// generate key for semaphore
key_t sem_key = ftok(SEM_PATH, 1); // key for semaphore
if(sem_key == -1) { // error semantics
printf("key heneration for semaphore is failed\n");
}
/* generate key for fps keeper */
key_t shm_key_pds_fps = ftok(PDS_FPS_SHM_PATH, 1);
if(shm_key_pds_fps == -1) {
printf("key generation for pds_fps_SHM is failed\n");
}
// access to the shared memory
// int shrd_id = shmget(shm_key, IMAGE_SIZE, 0666);
// if(shrd_id < 0) {
// printf("Can't Access to the Shared Memory!! \n");
// }
int shrd_id_height = shmget(shm_key_height, sizeof(int), 0666);
if(shrd_id_height < 0) {
printf("Can't Access to the Shared Memory!! \n");
}
int shrd_id_width = shmget(shm_key_width, sizeof(int), 0666);
if(shrd_id_width < 0) {
printf("Can't Access to the Shared Memory!! \n");
}
// int shrd_id_rbuf_dst = shmget(shm_key_rbuf_dst, RBUF_ELEMENT_NUM*sizeof(int), 0666);
// if(shrd_id_rbuf_dst < 0) {
// printf("Can't Access to the Shared Memory!! \n");
// }
// int shrd_id_rbuf = shmget(shm_key_rbuf, MAX_OBJECT_NUM*sizeof(int*), 0666);
int shrd_id_rbuf = shmget(shm_key_rbuf, MAX_OBJECT_NUM*sizeof(obj_coordinate), 0666);
if(shrd_id_rbuf < 0) {
printf("Can't Access to the Shared Memory!! \n");
}
int shrd_id_rbuf_head = shmget(shm_key_rbuf_head, sizeof(int), 0666);
if(shrd_id_rbuf_head < 0) {
printf("Can't Access to the Shared Memory!! \n");
}
int shrd_id_rbuf_tail = shmget(shm_key_rbuf_tail, sizeof(int), 0666);
if(shrd_id_rbuf_tail < 0) {
printf("Can't Access to the Shared Memory!! \n");
}
// open semaphore
int semid = semget(sem_key, 1, 0666);
if(semid == -1) {
printf("Can't Access to the semaphore\n");
}
/* access to shared fps keeper */
int shrd_id_pds_fps = shmget(shm_key_pds_fps, sizeof(int), 0666);
if(shrd_id_pds_fps < 0) {
printf("Can't Access to the Shared Memory!! \n");
}
// unsigned char *shrd_ptr = (unsigned char *)shmat(shrd_id, NULL, 0);
int *shrd_ptr_height = (int *)shmat(shrd_id_height, NULL, 0);
int *shrd_ptr_width = (int *)shmat(shrd_id_width, NULL, 0);
// int *shrd_ptr_rbuf_dst = (int *)shmat(shrd_id_rbuf_dst, NULL, 0);
// int **shrd_ptr_rbuf = (int **)shmat(shrd_id_rbuf, NULL, 0);
obj_coordinate *shrd_ptr_rbuf = (obj_coordinate *)shmat(shrd_id_rbuf, NULL, 0);
int *shrd_ptr_rbuf_head = (int *)shmat(shrd_id_rbuf_head, NULL, 0);
int *shrd_ptr_rbuf_tail = (int *)shmat(shrd_id_rbuf_tail, NULL, 0);
int *shrd_ptr_pds_fps = (int *)shmat(shrd_id_pds_fps, NULL, 0);
// int *tmpptr = shrd_ptr_rbuf_dst;
// for(int i=0; i<MAX_OBJECT_NUM; i++) {
// shrd_ptr_rbuf[i] = tmpptr;
// tmpptr += CO_NUM;
// }
#if 0
// IplImage *output_image = cvCreateImage(cvSize(640, 480), IPL_DEPTH_8U, 3);
IplImage *output_image = cvCreateImage(cvSize(*shrd_ptr_width, *shrd_ptr_height), IPL_DEPTH_8U, 3);
// output_image->imageData = (char *)shrd_ptr;
/* for bitmap image, set the point of origin of image to left below */
output_image->origin = 1;
/* skip header information */
shrd_ptr += HEADER_SIZE;
/* To keep original data, use copied image data */
// memcpy(output_image->imageData, shrd_ptr, IMAGE_SIZE);
output_image->imageData = (char *)shrd_ptr;
#endif
#if 0
/* read image from buffer */
CvMat *buf = cvCreateMat(1, IMAGE_SIZE, CV_8UC3);
My_sem_operation(semid, LOCK); // lock semaphore
// buf->data.ptr = shrd_ptr;
memcpy(buf->data.ptr, shrd_ptr, IMAGE_SIZE);
My_sem_operation(semid, UNLOCK); // unlock semaphore
IplImage *output_image = cvDecodeImage(buf, CV_LOAD_IMAGE_COLOR); // absorb the difference of file format
#endif
for(int ii=0;ii<CUR->num;ii++)
{
//int *P = CUR->point+4*ii;
int *P = CUR->OR_point+4*ii;
CvScalar col = get_color(CUR->type[ii]);
CvPoint p1=cvPoint(P[0],P[1]);
CvPoint p2=cvPoint(P[2],P[3]);
// // draw rectangle to original image
// cvRectangle(Image,p1,p2,col,3); //draw current-object rectangle
// cvLine(Image,p1,p2,col,2);
// draw rectangle to shared memory image
// cvRectangle(output_image,p1,p2,col,3); //draw current-object rectangle
// cvLine(output_image,p1,p2,col,2);
p1 = cvPoint(P[0],P[3]);
p2 = cvPoint(P[2],P[1]);
// // draw rectangle to original image
// cvLine(Image,p1,p2,col,2);
// draw rectangle to shared memory image
// cvLine(output_image,p1,p2,col,2);
/* write coodinates to ring buffer*/
My_sem_operation(semid, LOCK); // lock semaphore
// apSetCoordinate(shrd_ptr_rbuf, P[0], shrd_ptr_rbuf_head, shrd_ptr_rbuf_tail, LEFT);
// apSetCoordinate(shrd_ptr_rbuf, P[1], shrd_ptr_rbuf_head, shrd_ptr_rbuf_tail, UPPER);
// apSetCoordinate(shrd_ptr_rbuf, P[2], shrd_ptr_rbuf_head, shrd_ptr_rbuf_tail, RIGHT);
// apSetCoordinate(shrd_ptr_rbuf, P[3], shrd_ptr_rbuf_head, shrd_ptr_rbuf_tail, BOTTOM);
apSetCoordinate(shrd_ptr_rbuf, // obj_coordinate *queue
shrd_ptr_rbuf_head, // int *head
shrd_ptr_rbuf_tail, // int *tail
P[0], // int left
P[1], // int upper
P[2], // int right
P[3], // int bottom
// CAR // int type
PEDESTRIAN // int type
);
My_sem_operation(semid, UNLOCK); // unlock semaphore
}
/* increment frame per second */
My_sem_operation(semid, LOCK); // lock semaphore
*shrd_ptr_pds_fps += 1;
My_sem_operation(semid, UNLOCK); // unlock semaphore
#if 0
/* copy back to the shared memory by png format*/
CvMat *buf_for_output = cvEncodeImage(".png", output_image);
//CvMat *buf_for_output = cvEncodeImage(".bmp", output_image);
//CvMat *buf_for_output = cvEncodeImage(".jpeg", output_image);
My_sem_operation(semid, LOCK); // lock semaphore
// memcpy(shrd_ptr, buf_for_output->data.ptr, IMAGE_SIZE); // サイズ違いでエラー？
memcpy(shrd_ptr, buf_for_output->data.ptr, (buf_for_output->rows)*(buf_for_output->cols)*sizeof(unsigned char)); // サイズ違いでエラー？
My_sem_operation(semid, UNLOCK); // unlock semaphore
cvShowImage("for debug", output_image);
cvWaitKey(10);
#endif
#if 0
FILE *testoutput = fopen("./testoutput", "wb");
if(testoutput == NULL){
printf("test output error\n");
}
unsigned char *tmpptr = (unsigned char *)buf_for_output->data.ptr;
for(int i=0; i<IMAGE_SIZE; i++) {
fprintf(testoutput, "%c",*tmpptr);
tmpptr++;
}
fclose(testoutput);
#endif
/* detouch(purge) shared memory */
// if(shmdt(shrd_ptr)==-1){
// printf("purge error! (shrd_ptr)\n");
// }
if(shmdt(shrd_ptr_height)==-1){
printf("purge error! (shrd_ptr_height)\n");
}
if(shmdt(shrd_ptr_width)==-1){
printf("purge error! (shrd_ptr_width)\n");
}
// if(shmdt(shrd_ptr_rbuf_dst)==-1) {
// printf("purge error! (shrd_ptr_rbuf_dst)\n");
// }
if(shmdt(shrd_ptr_rbuf)==-1) {
printf("purge error! (shrd_ptr_rbuf)\n");
}
if(shmdt(shrd_ptr_rbuf_head)==-1) {
printf("purge error! (shrd_ptr_rbuf_head)\n");
}
if(shmdt(shrd_ptr_rbuf_tail)==-1) {
printf("purge error! (shrd_ptr_rbuf_tail)\n");
}
if(shmdt(shrd_ptr_pds_fps)==-1){
printf("purge error! (shrd_ptr_pds_fps)\n");
}
#if 0
/* release image */
cvReleaseImage(&output_image);
cvReleaseMat(&buf);
cvReleaseMat(&buf_for_output);
#endif
#endif
}
void zoomImg(safeQueue *sq, struct bio_job *job)
{
/* Search tmp folder */
char *uri = job->name+strlen(SERVICE_ZOOM) + 1;
sds dstpath = zoomePathInTmpDir(uri);
//job->result = ufileMakeHttpReplyFromFile(dstpath);
job->result = ufileMmapHttpReply(dstpath);
printf("After Read File %.2lf \n", (double)(clock()));
if(job->result) {
sdsfree(dstpath);
safeQueuePush(sq,job); /* the current job will be freed by master */
return;
}
int width = 0, height = 0;
sds fn = NULL;
sds srcpath = NULL;
IplImage* src = NULL;
IplImage* dst = NULL;
IplImage* toencode = NULL;
CvMat* enImg = NULL;
int notpushed = 1;
int iscrop = 1;
int p[3];
p[0] = CV_IMWRITE_JPEG_QUALITY;
p[1] = IMG_DEFAULT_QUALITY;
p[2] = 0;
uchar *buf = NULL;
size_t len = 0;
uri_parse_state state = img_parse_uri(uri,&fn,&width,&height, &iscrop, &p[1]);
if(state == parse_error) goto clean;
// initializations
srcpath = bioPathInSrcDir(fn);
printf("Before Load Image %.2lf \n", (double)(clock()));
src = cvLoadImage(srcpath, CV_LOAD_IMAGE_COLOR);
printf("After Load Image %.2lf \n", (double)(clock()));
/* validate that everything initialized properly */
if(!src)
{
ulog(CCACHE_VERBOSE,"can't load image file: %s\n",srcpath);
goto clean;
}
int src_width = src->width;
int src_height = src->height;
int roi_src_width = src_width;
int roi_src_height = src_height;
if(width&&height) {
/* Preserve origial ratio */
/* NOTICE: dangerous type conversion */
roi_src_width = src_height*width/height;
roi_src_height = src_width*height/width;
if(roi_src_width>src_width) roi_src_width = src_width;
if(roi_src_height>src_height) roi_src_height = src_height;
}
else if(!width&&height) {
width = src_width;
}
else if(width&&!height) {
height = src_height;
}
else {
toencode = src;
}
if(!toencode) {
if(iscrop) {
int x = (src_width - roi_src_width)/2;
int y = (src_height - roi_src_height)/2;
// Say what the source region is
cvSetImageROI( src, cvRect(x,y,roi_src_width,roi_src_height));
}
dst = cvCreateImage(cvSize(width,height), src->depth, src->nChannels);
if(!dst) goto clean;
cvResize(src,dst,CV_INTER_CUBIC);
printf("After Resize Image %.2lf \n", (double)(clock()));
if(iscrop) {
cvResetImageROI( src );
}
toencode = dst;
}
enImg = cvEncodeImage(IMG_ENCODE_DEFAULT, toencode, p );
printf("After Encode Image %.2lf \n", (double)(clock()));
buf = enImg->data.ptr;
len = enImg->rows*enImg->cols;
job->result = ufilMakettpReplyFromBuffer(buf,len);
job->type |= BIO_WRITE_FILE; /* Remind master of new written file */
safeQueuePush(sq,job);
notpushed = 0;
/* clean up and release resources */
clean:
if(notpushed) {
job->result = NULL;
safeQueuePush(sq,job);
}
if(fn) sdsfree(fn);
if(srcpath) sdsfree(srcpath);
if(src) cvReleaseImage(&src);
if(enImg){
saveImage(dstpath, buf, len);
cvReleaseMat(&enImg);
}
sdsfree(dstpath);
if(dst) cvReleaseImage(&dst);
return;
}
int memcpy_picture(unsigned char *out, unsigned char *buf, int size)
{
// video 장치 공유 문제(opecv + mjpg)와 해상도에 따른 성능 문제로 인해
// opencv 해상도(800*600)와 stream(160*120) 해상도 변경
{
if(!g_fp)
{
g_fp = fopen("/dev/shm/picam.jpg", "wb");
if(!g_fp) exit(1);
}
int fd = fileno(g_fp);
while(1)
{
if(flock(fd, LOCK_EX) < 0)
{
if(errno == EINTR)
continue;
}
break;
}
fseek(g_fp, 0, SEEK_SET);
fwrite(buf, sizeof(unsigned char), size, g_fp);
fflush(g_fp);
while(1)
{
if(flock(fd, LOCK_UN) < 0)
{
if(errno == EINTR)
continue;
}
break;
}
/*
// 캡쳐된 원본은 object detection에 사용
FILE* fp = fopen("/dev/shm/picam.jpg", "wb");
if(fp)
{
fwrite(buf, sizeof(unsigned char), size, fp);
fclose(fp);
}
*/
// 스케일된 이미지는 스트리밍에 사용
// 이미지 스케일링은 output_http에서 하도록 변경
#if 0
CvMat cm = cvMat(1, size, CV_8UC1, buf);
IplImage* src = cvDecodeImage(&cm, CV_LOAD_IMAGE_COLOR);
if(!src) return 0;
IplImage* dst = cvCreateImage(cvSize(320, 240), src->depth, src->nChannels);
if(!dst) return 0;
cvResize(src, dst, CV_INTER_LINEAR);
//cvSaveImage("/dev/shm/small.jpg", dst, 0);
CvMat* enc = cvEncodeImage(".jpg", dst, 0);
if(!enc) return 0;
printf("#1 buf=%p, size=%d\n", buf, size);
printf("enc->data.ptr=%p, enc->rows=%d, enc->cols=%d\n", enc->data.ptr, enc->rows, enc->cols);
memcpy(buf, enc->data.ptr, enc->rows * enc->cols);
size = enc->rows * enc->cols;
printf("#2 buf=%p, size_%d\n", buf, size);
cvReleaseMat(&enc);
cvReleaseImage(&dst);
cvReleaseImage(&src);
#endif
}
unsigned char *ptdeb, *ptlimit, *ptcur = buf;
int sizein, pos = 0;
if(!is_huffman(buf)) {
ptdeb = ptcur = buf;
ptlimit = buf + size;
while((((ptcur[0] << 8) | ptcur[1]) != 0xffc0) && (ptcur < ptlimit))
ptcur++;
if(ptcur >= ptlimit)
return pos;
sizein = ptcur - ptdeb;
memcpy(out + pos, buf, sizein); pos += sizein;
memcpy(out + pos, dht_data, sizeof(dht_data)); pos += sizeof(dht_data);
memcpy(out + pos, ptcur, size - sizein); pos += size - sizein;
} else {
memcpy(out + pos, ptcur, size); pos += size;
}
return pos;
}
int UCS_run(SslHandle_t* ucs) {
IplImage* image;
CvCapture* capture;
CvMat* cvmat;
char imgseg[9];
char recvbuf[2];
size_t tsize, ssize, total_size;
int err, flag;
int is_stop_ucstream=0;
static const int jpeg_param[3] = {
CV_IMWRITE_JPEG_QUALITY, UCS_JPEG_QUALITY, 0 };
image = NULL;
capture = cvCaptureFromCAM(0);
flag = fcntl(ucs->ssl_fd, F_GETFL, 0);
fcntl(ucs->ssl_fd, F_SETFL, flag | O_NONBLOCK);
// 1280 x 800 tablet size
cvSetCaptureProperty(capture, CV_CAP_PROP_FRAME_WIDTH,
UCS_CAPTURE_SIZE_WIDTH);
cvSetCaptureProperty(capture, CV_CAP_PROP_FRAME_HEIGHT,
UCS_CAPTURE_SIZE_HIGHT);
//cvSetCaptureProperty(capture, CV_CAP_PROP_FPS, UCS_CAPTURE_FPS);
imgseg[0] = UCS_REQ_IMGSEG;
itobuf(UCS_SENDBUF_SIZE, imgseg + 1);
while (!is_stop_ucstream) {
while (!cvGrabFrame(capture)) {
perror("UCS_run > cvGrabFrame\n");
}
image = cvRetrieveFrame(capture, 0);
cvmat = cvEncodeImage(".jpg", image, jpeg_param);
total_size = cvmat->cols * cvmat->rows;
itobuf(total_size, imgseg + 5);
if (SSL_write(ucs->ssl, imgseg, 9) <= 0) {
perror("UCS_run > UCS_REQ_IMGSEG");
cvReleaseMat(&cvmat);
continue;
}
ssize = 0;
while (SSL_write(ucs->ssl, cvmat->data.ptr, total_size) <= 0);
cvReleaseMat(&cvmat);
usleep(100000);
if (SSL_read(ucs->ssl, recvbuf, 1) > 0) {
if (recvbuf[0] == UCS_REP_STOP) {
is_stop_ucstream = 1;
} else {
perror("UCS_run > UCS_REP_STOP");
break;
}
}
}
cvReleaseCapture(&capture);
return 0;
}
JNIEXPORT void JNICALL Java_com_seasbase_video_io_VideoReader_DiffProc(JNIEnv * env, jobject obj, jstring jo,jint thd,jint nframes)
{
jclass jovideo = env->GetObjectClass(obj);
jmethodID appendInfo = env->GetMethodID(jovideo,"appendInfo", "(Lcom/seasbase/video/io/Info;)V");//关键代码行
jclass jinfo = env->FindClass("com/seasbase/video/io/Info");
jmethodID initInfo = env->GetMethodID(jinfo, "<init>","(II[BIIIILjava/lang/String;Ljava/lang/String;Ljava/lang/String;)V");
//调用代码
HMODULE dlh = NULL;
char buf[256]={0};
//dlh=LoadLibrary("VehicleTypeRecognition_D.dll");
//dlh=LoadLibrary("HelloWorld.dll");
if (!(dlh=LoadLibrary("VehicleTypeRecognition_D.dll")))
{
printf("LoadLibrary() failed: %d\n", GetLastError());
}
ThreadInit threadInit;
threadInit = (ThreadInit)GetProcAddress(dlh, "ITS_ThreadInit");//ITS_ThreadInit(); 进程启动时调用
/*threadInit = (ThreadInit)GetProcAddress(dlh, "PrintHelloWord");*/
(*threadInit)();
VehicleRecInit vehicleRecInit;
int iInitFlag;
char* pathvar = getenv("ALG_DIR");
sprintf(buf,"%smodel",pathvar);
char* modePath = buf;// ..\\bin\\model
vehicleRecInit = (VehicleRecInit)GetProcAddress(dlh, "ITS_VehicleRecInit");
vehproc.pInstance = (*vehicleRecInit)(modePath, iInitFlag);//初始化操作
char* fpath =NULL;
fpath = jstringTostring(env,jo);
CvCapture * capture = cvCreateFileCapture(fpath);
long nbFrames = (long) cvGetCaptureProperty(capture, CV_CAP_PROP_FRAME_COUNT);
if( !capture )
{
fprintf(stderr,"Could not initialize capturing...\n");
}
IplImage* pSrcImg =NULL;
////////////////////////////////////////////////////
while (cvGrabFrame(capture) != 0 && (vehproc.pFrame = cvRetrieveFrame(capture)) != NULL)
{
nframes++;
vehproc.nfrnum++;
/*if(vehproc.nfrnum>40)
{
if(vehproc.nfrnum%5!=0)
continue;
}*/
if (NULL==pSrcImg)
{
pSrcImg =cvCreateImage(cvSize(vehproc.pFrame->width,vehproc.pFrame->height),IPL_DEPTH_8U,3);
}
cvCopyImage(vehproc.pFrame,pSrcImg);
vehproc.VehiclePreProc(pSrcImg);
jobject info;
jstring jnumber;jstring jtype;jstring jcolor;
for (int j = 0; j < vehproc.vehCnt; j++)//
{
/*threadInit = (ThreadInit)GetProcAddress(dlh, "PrintHelloWord");
(*threadInit)();*/
IplImage * pOutput = vehproc.vehinfo[j].vehicleImg;//cvCreateImage(cvSize(vehproc.pFrame->width,vehproc.pFrame->height),IPL_DEPTH_8U,3);
//cvCopyImage(vehproc.pFrame,pOutput);vehproc.vehinfo[j].plateImg;
sprintf(buf,"E:\\aaaa\\%d-%d.jpg",nframes,j);
cvSaveImage(buf,pOutput);
CvMat* mat = cvEncodeImage(".jpg",pOutput);
jbyteArray jarrRV =env->NewByteArray(mat->cols);
/*env->NewFloatArray()
env->NewFloatArray()
env->NewFloatArray()*/
env->SetByteArrayRegion(jarrRV,0,mat->cols,(const jbyte *)mat->data.ptr);
cvReleaseMat(&mat);
jnumber = WindowsTojstring(env,vehproc.vehinfo[j].platenumber);
jtype = WindowsTojstring(env,vehproc.vehinfo[j].tempVehicleType);
jcolor= WindowsTojstring(env,vehproc.vehinfo[j].eVehicleColor);
//jnumber = env->NewStringUTF(vehproc.vehinfo[j].platenumber);
//jtype = env->NewStringUTF(vehproc.vehinfo[j].tempVehicleType);
//jbyteArray jarrRV =env->NewByteArray(1);
/*jnumber = env->NewStringUTF("fde");
jtype = env->NewStringUTF("bbb");
jcolor = env->NewStringUTF("ccab");*/
//黑AU5881
if (strcmp(vehproc.vehinfo[j].platenumber,"黑AU5881")==0)
{
system("pause");
}
info = env->NewObject(jinfo,initInfo,vehproc.nfrnum,j,jarrRV,vehproc.vehinfo[j].pointLT.x,vehproc.vehinfo[j].pointLT.y,vehproc.vehinfo[j].width,vehproc.vehinfo[j].height,jnumber,jtype,jcolor);
//info = env->NewObject(jinfo,initInfo,vehproc.nfrnum,j,jarrRV,100,4,5,6,jnumber,jtype,jcolor);
env->CallObjectMethod(obj,appendInfo,info);
env->DeleteLocalRef(info);
env->DeleteLocalRef(jarrRV);
cvReleaseImage(&pOutput);
}
//#ifdef DEBUG_OUTPUT_IMAGE
//sprintf(buf,"E:\\aaaa\\%da.jpg",nframes);
cvSaveImage(buf,vehproc.pFrame);
//sprintf(buf,"E:\\aaaa\\%db.jpg",nframes);
cvSaveImage(buf,pSrcImg);
//#endif
}
jstring jnumber;
jstring jtype;
jstring jcolor;
jnumber = env->NewStringUTF("aaaaa");
jtype = env->NewStringUTF("bbbbb");
jcolor = env->NewStringUTF("ccccc");
jbyteArray jarrRV1 =env->NewByteArray(1);////
jobject info1 = env->NewObject(jinfo,initInfo,-1,-1,jarrRV1,-1,2,3,4,jnumber,jtype,jcolor);
env->CallObjectMethod(obj,appendInfo,info1);
env->DeleteLocalRef(info1);
env->DeleteLocalRef(jarrRV1);
env->DeleteLocalRef(jinfo);
cvReleaseImage(&pSrcImg);
cvReleaseCapture(&capture); //释放视频空间
VehicleRecRelease vehicleRecRelease;
vehicleRecRelease = (VehicleRecRelease)GetProcAddress(dlh, "ITS_VehicleRecRelease");
(*vehicleRecRelease)(vehproc.pInstance);
return;
}
int io_writeImage(sParameterStruct * sSO2Parameters, sConfigStruct * config)
{
FILE *fp;
short *stBuffer;
IplImage *img;
CvMat *png;
int l;
int writen_bytes;
char filename[512];
int filenamelength = 512;
int state;
char *buffer;
stBuffer = sSO2Parameters->stBuffer;
/* generate filenames */
state = createFilename(sSO2Parameters, config, filename, filenamelength, "png");
if (state) {
log_error("could not create txt filename");
return state;
}
log_debug("filename created: %s", filename);
/* convert the image buffer to an openCV image */
// TODO: check if this has already been done
// TODO: check return code
img = bufferToImage(stBuffer);
/*
* encode image as png to buffer
* playing with the compression is a huge waste of time with no benefit
*/
png = cvEncodeImage(".png", img, 0);
l = png->rows * png->cols;
cvReleaseImage(&img);
// pry the actual buffer pointer from png
buffer = (char *)malloc(l);
memcpy(buffer, png->data.s, l);
cvReleaseMat(&png);
/* add headers */
log_debug("insert headers %i", l);
l = insertHeaders(&buffer, sSO2Parameters, config, l);
/* save image to disk */
log_debug("open new png file %i", l);
fp = fopen(filename, "wb");
if (fp) {
writen_bytes = fwrite(buffer, 1, l, fp);
state = writen_bytes == l ? 0 : 1;
if (state) {
log_error("PNG image wasn't written correctly");
}
fclose(fp);
} else {
state = 1;
log_error("Couldn't open png file");
}
/* cleanup */
free(buffer);
if (!state) {
log_message("png image written");
}
return state;
}
