|
|
#include "http_stream.h" |
|
|
|
|
|
#ifdef OPENCV |
|
|
// |
|
|
// a single-threaded, multi client(using select), debug webserver - streaming out mjpg. |
|
|
// on win, _WIN32 has to be defined, must link against ws2_32.lib (socks on linux are for free) |
|
|
// |
|
|
|
|
|
// |
|
|
// socket related abstractions: |
|
|
// |
|
|
#ifdef _WIN32 |
|
|
#pragma comment(lib, "ws2_32.lib") |
|
|
#include <winsock.h> |
|
|
#include <windows.h> |
|
|
#include <time.h> |
|
|
#define PORT unsigned long |
|
|
#define ADDRPOINTER int* |
|
|
struct _INIT_W32DATA |
|
|
{ |
|
|
WSADATA w; |
|
|
_INIT_W32DATA() { WSAStartup(MAKEWORD(2, 1), &w); } |
|
|
} _init_once; |
|
|
#else /* ! win32 */ |
|
|
#include <unistd.h> |
|
|
#include <sys/time.h> |
|
|
#include <sys/types.h> |
|
|
#include <sys/socket.h> |
|
|
#include <netdb.h> |
|
|
#include <netinet/in.h> |
|
|
#include <arpa/inet.h> |
|
|
#define PORT unsigned short |
|
|
#define SOCKET int |
|
|
#define HOSTENT struct hostent |
|
|
#define SOCKADDR struct sockaddr |
|
|
#define SOCKADDR_IN struct sockaddr_in |
|
|
#define ADDRPOINTER unsigned int* |
|
|
#define INVALID_SOCKET -1 |
|
|
#define SOCKET_ERROR -1 |
|
|
#endif /* _WIN32 */ |
|
|
|
|
|
#include <cstdio> |
|
|
#include <vector> |
|
|
#include <iostream> |
|
|
#include <algorithm> |
|
|
using std::cerr; |
|
|
using std::endl; |
|
|
|
|
|
#include "opencv2/opencv.hpp" |
|
|
#include "opencv2/highgui/highgui.hpp" |
|
|
#include "opencv2/highgui/highgui_c.h" |
|
|
#include "opencv2/imgproc/imgproc_c.h" |
|
|
#ifndef CV_VERSION_EPOCH |
|
|
#include "opencv2/videoio/videoio.hpp" |
|
|
#endif |
|
|
using namespace cv; |
|
|
|
|
|
#include "image.h" |
|
|
|
|
|
|
|
|
class MJPG_sender |
|
|
{ |
|
|
SOCKET sock; |
|
|
SOCKET maxfd; |
|
|
fd_set master; |
|
|
int timeout; // master sock timeout, shutdown after timeout millis. |
|
|
int quality; // jpeg compression [1..100] |
|
|
int close_all_sockets; |
|
|
|
|
|
int _write(int sock, char const*const s, int len) |
|
|
{ |
|
|
if (len < 1) { len = strlen(s); } |
|
|
return ::send(sock, s, len, 0); |
|
|
} |
|
|
|
|
|
public: |
|
|
|
|
|
MJPG_sender(int port = 0, int _timeout = 200000, int _quality = 30) |
|
|
: sock(INVALID_SOCKET) |
|
|
, timeout(_timeout) |
|
|
, quality(_quality) |
|
|
{ |
|
|
close_all_sockets = 0; |
|
|
FD_ZERO(&master); |
|
|
if (port) |
|
|
open(port); |
|
|
} |
|
|
|
|
|
~MJPG_sender() |
|
|
{ |
|
|
close_all(); |
|
|
release(); |
|
|
} |
|
|
|
|
|
bool release() |
|
|
{ |
|
|
if (sock != INVALID_SOCKET) |
|
|
::shutdown(sock, 2); |
|
|
sock = (INVALID_SOCKET); |
|
|
return false; |
|
|
} |
|
|
|
|
|
void close_all() |
|
|
{ |
|
|
close_all_sockets = 1; |
|
|
cv::Mat tmp(cv::Size(10, 10), CV_8UC3); |
|
|
write(tmp); |
|
|
} |
|
|
|
|
|
bool open(int port) |
|
|
{ |
|
|
sock = ::socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); |
|
|
|
|
|
SOCKADDR_IN address; |
|
|
address.sin_addr.s_addr = INADDR_ANY; |
|
|
address.sin_family = AF_INET; |
|
|
address.sin_port = htons(port); // ::htons(port); |
|
|
if (::bind(sock, (SOCKADDR*)&address, sizeof(SOCKADDR_IN)) == SOCKET_ERROR) |
|
|
{ |
|
|
cerr << "error MJPG_sender: couldn't bind sock " << sock << " to port " << port << "!" << endl; |
|
|
return release(); |
|
|
} |
|
|
if (::listen(sock, 10) == SOCKET_ERROR) |
|
|
{ |
|
|
cerr << "error MJPG_sender: couldn't listen on sock " << sock << " on port " << port << " !" << endl; |
|
|
return release(); |
|
|
} |
|
|
FD_ZERO(&master); |
|
|
FD_SET(sock, &master); |
|
|
maxfd = sock; |
|
|
return true; |
|
|
} |
|
|
|
|
|
bool isOpened() |
|
|
{ |
|
|
return sock != INVALID_SOCKET; |
|
|
} |
|
|
|
|
|
bool write(const Mat & frame) |
|
|
{ |
|
|
fd_set rread = master; |
|
|
struct timeval to = { 0,timeout }; |
|
|
if (::select(maxfd+1, &rread, NULL, NULL, &to) <= 0) |
|
|
return true; // nothing broken, there's just noone listening |
|
|
|
|
|
std::vector<uchar> outbuf; |
|
|
std::vector<int> params; |
|
|
params.push_back(IMWRITE_JPEG_QUALITY); |
|
|
params.push_back(quality); |
|
|
cv::imencode(".jpg", frame, outbuf, params); |
|
|
size_t outlen = outbuf.size(); |
|
|
|
|
|
#ifdef _WIN32 |
|
|
for (unsigned i = 0; i<rread.fd_count; i++) |
|
|
{ |
|
|
int addrlen = sizeof(SOCKADDR); |
|
|
SOCKET s = rread.fd_array[i]; // fd_set on win is an array, while ... |
|
|
#else |
|
|
for (int s = 0; s<=maxfd; s++) |
|
|
{ |
|
|
socklen_t addrlen = sizeof(SOCKADDR); |
|
|
if (!FD_ISSET(s, &rread)) // ... on linux it's a bitmask ;) |
|
|
continue; |
|
|
#endif |
|
|
if (s == sock) // request on master socket, accept and send main header. |
|
|
{ |
|
|
SOCKADDR_IN address = { 0 }; |
|
|
SOCKET client = ::accept(sock, (SOCKADDR*)&address, &addrlen); |
|
|
if (client == SOCKET_ERROR) |
|
|
{ |
|
|
cerr << "error MJPG_sender: couldn't accept connection on sock " << sock << " !" << endl; |
|
|
return false; |
|
|
} |
|
|
if (setsockopt(client, SOL_SOCKET, SO_RCVTIMEO, (char *)&to, sizeof(to)) < 0) { |
|
|
cerr << "error MJPG_sender: SO_RCVTIMEO setsockopt failed\n"; |
|
|
} |
|
|
if (setsockopt(client, SOL_SOCKET, SO_SNDTIMEO, (char *)&to, sizeof(to)) < 0) { |
|
|
cerr << "error MJPG_sender: SO_SNDTIMEO setsockopt failed\n"; |
|
|
} |
|
|
maxfd = (maxfd>client ? maxfd : client); |
|
|
FD_SET(client, &master); |
|
|
_write(client, "HTTP/1.0 200 OK\r\n", 0); |
|
|
_write(client, |
|
|
"Server: Mozarella/2.2\r\n" |
|
|
"Accept-Range: bytes\r\n" |
|
|
"Connection: close\r\n" |
|
|
"Max-Age: 0\r\n" |
|
|
"Expires: 0\r\n" |
|
|
"Cache-Control: no-cache, private\r\n" |
|
|
"Pragma: no-cache\r\n" |
|
|
"Content-Type: multipart/x-mixed-replace; boundary=mjpegstream\r\n" |
|
|
"\r\n", 0); |
|
|
cerr << "MJPG_sender: new client " << client << endl; |
|
|
} |
|
|
else // existing client, just stream pix |
|
|
{ |
|
|
if (close_all_sockets) { |
|
|
int result = ::shutdown(s, 1); // 0 close input, 1 close output, 2 close both |
|
|
char *buf = (char *)calloc(1024, sizeof(char)); |
|
|
::recv(s, buf, 1024, 0); |
|
|
free(buf); |
|
|
::closesocket(s); |
|
|
printf("MJPG_sender: close clinet: %d \n", result); |
|
|
continue; |
|
|
} |
|
|
|
|
|
char head[400]; |
|
|
sprintf(head, "--mjpegstream\r\nContent-Type: image/jpeg\r\nContent-Length: %zu\r\n\r\n", outlen); |
|
|
_write(s, head, 0); |
|
|
int n = _write(s, (char*)(&outbuf[0]), outlen); |
|
|
//cerr << "known client " << s << " " << n << endl; |
|
|
if (n < outlen) |
|
|
{ |
|
|
cerr << "MJPG_sender: kill client " << s << endl; |
|
|
::shutdown(s, 2); |
|
|
FD_CLR(s, &master); |
|
|
} |
|
|
} |
|
|
} |
|
|
return true; |
|
|
} |
|
|
}; |
|
|
// ---------------------------------------- |
|
|
|
|
|
void send_mjpeg(IplImage* ipl, int port, int timeout, int quality) |
|
|
{ |
|
|
static MJPG_sender wri(port, timeout, quality); |
|
|
cv::Mat mat = cv::cvarrToMat(ipl); |
|
|
wri.write(mat); |
|
|
std::cout << " MJPEG-stream sent. \n"; |
|
|
} |
|
|
// ---------------------------------------- |
|
|
|
|
|
class JSON_sender |
|
|
{ |
|
|
SOCKET sock; |
|
|
SOCKET maxfd; |
|
|
fd_set master; |
|
|
int timeout; // master sock timeout, shutdown after timeout millis. |
|
|
int close_all_sockets; |
|
|
|
|
|
int _write(int sock, char const*const s, int len) |
|
|
{ |
|
|
if (len < 1) { len = strlen(s); } |
|
|
return ::send(sock, s, len, 0); |
|
|
} |
|
|
|
|
|
public: |
|
|
|
|
|
JSON_sender(int port = 0, int _timeout = 200000) |
|
|
: sock(INVALID_SOCKET) |
|
|
, timeout(_timeout) |
|
|
{ |
|
|
close_all_sockets = 0; |
|
|
FD_ZERO(&master); |
|
|
if (port) |
|
|
open(port); |
|
|
} |
|
|
|
|
|
~JSON_sender() |
|
|
{ |
|
|
close_all(); |
|
|
release(); |
|
|
} |
|
|
|
|
|
bool release() |
|
|
{ |
|
|
if (sock != INVALID_SOCKET) |
|
|
::shutdown(sock, 2); |
|
|
sock = (INVALID_SOCKET); |
|
|
return false; |
|
|
} |
|
|
|
|
|
void close_all() |
|
|
{ |
|
|
close_all_sockets = 1; |
|
|
char tmp[1]; |
|
|
write(tmp); |
|
|
} |
|
|
|
|
|
bool open(int port) |
|
|
{ |
|
|
sock = ::socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); |
|
|
|
|
|
SOCKADDR_IN address; |
|
|
address.sin_addr.s_addr = INADDR_ANY; |
|
|
address.sin_family = AF_INET; |
|
|
address.sin_port = htons(port); // ::htons(port); |
|
|
if (::bind(sock, (SOCKADDR*)&address, sizeof(SOCKADDR_IN)) == SOCKET_ERROR) |
|
|
{ |
|
|
cerr << "error JSON_sender: couldn't bind sock " << sock << " to port " << port << "!" << endl; |
|
|
return release(); |
|
|
} |
|
|
if (::listen(sock, 10) == SOCKET_ERROR) |
|
|
{ |
|
|
cerr << "error JSON_sender: couldn't listen on sock " << sock << " on port " << port << " !" << endl; |
|
|
return release(); |
|
|
} |
|
|
FD_ZERO(&master); |
|
|
FD_SET(sock, &master); |
|
|
maxfd = sock; |
|
|
return true; |
|
|
} |
|
|
|
|
|
bool isOpened() |
|
|
{ |
|
|
return sock != INVALID_SOCKET; |
|
|
} |
|
|
|
|
|
bool write(char *outputbuf) |
|
|
{ |
|
|
fd_set rread = master; |
|
|
struct timeval to = { 0,timeout }; |
|
|
if (::select(maxfd + 1, &rread, NULL, NULL, &to) <= 0) |
|
|
return true; // nothing broken, there's just noone listening |
|
|
|
|
|
size_t outlen = strlen(outputbuf); |
|
|
|
|
|
#ifdef _WIN32 |
|
|
for (unsigned i = 0; i<rread.fd_count; i++) |
|
|
{ |
|
|
int addrlen = sizeof(SOCKADDR); |
|
|
SOCKET s = rread.fd_array[i]; // fd_set on win is an array, while ... |
|
|
#else |
|
|
for (int s = 0; s <= maxfd; s++) |
|
|
{ |
|
|
socklen_t addrlen = sizeof(SOCKADDR); |
|
|
if (!FD_ISSET(s, &rread)) // ... on linux it's a bitmask ;) |
|
|
continue; |
|
|
#endif |
|
|
if (s == sock) // request on master socket, accept and send main header. |
|
|
{ |
|
|
SOCKADDR_IN address = { 0 }; |
|
|
SOCKET client = ::accept(sock, (SOCKADDR*)&address, &addrlen); |
|
|
if (client == SOCKET_ERROR) |
|
|
{ |
|
|
cerr << "error JSON_sender: couldn't accept connection on sock " << sock << " !" << endl; |
|
|
return false; |
|
|
} |
|
|
if (setsockopt(client, SOL_SOCKET, SO_RCVTIMEO, (char *)&to, sizeof(to)) < 0) { |
|
|
cerr << "error JSON_sender: SO_RCVTIMEO setsockopt failed\n"; |
|
|
} |
|
|
if (setsockopt(client, SOL_SOCKET, SO_SNDTIMEO, (char *)&to, sizeof(to)) < 0) { |
|
|
cerr << "error JSON_sender: SO_SNDTIMEO setsockopt failed\n"; |
|
|
} |
|
|
maxfd = (maxfd>client ? maxfd : client); |
|
|
FD_SET(client, &master); |
|
|
_write(client, "HTTP/1.0 200 OK\r\n", 0); |
|
|
_write(client, |
|
|
"Server: Mozarella/2.2\r\n" |
|
|
"Accept-Range: bytes\r\n" |
|
|
"Connection: close\r\n" |
|
|
"Max-Age: 0\r\n" |
|
|
"Expires: 0\r\n" |
|
|
"Cache-Control: no-cache, private\r\n" |
|
|
"Pragma: no-cache\r\n" |
|
|
"Content-Type: application/json\r\n" |
|
|
//"Content-Type: multipart/x-mixed-replace; boundary=boundary\r\n" |
|
|
"\r\n", 0); |
|
|
cerr << "JSON_sender: new client " << client << endl; |
|
|
} |
|
|
else // existing client, just stream pix |
|
|
{ |
|
|
// Graceful closes will first close their output channels and then wait for the peer |
|
|
// on the other side of the connection to close its output channels. When both sides are done telling |
|
|
// each other they won<EFBFBD>t be sending any more data (i.e., closing output channels), |
|
|
// the connection can be closed fully, with no risk of reset. |
|
|
if (close_all_sockets) { |
|
|
int result = ::shutdown(s, 1); // 0 close input, 1 close output, 2 close both |
|
|
char *buf = (char *)calloc(1024, sizeof(char)); |
|
|
::recv(s, buf, 1024, 0); |
|
|
free(buf); |
|
|
::closesocket(s); |
|
|
printf("JSON_sender: close clinet: %d \n", result); |
|
|
continue; |
|
|
} |
|
|
|
|
|
//char head[400]; |
|
|
// application/json |
|
|
// application/x-resource+json or application/x-collection+json - when you are representing REST resources and collections |
|
|
// text/json or text/javascript or text/plain. |
|
|
// https://stackoverflow.com/questions/477816/what-is-the-correct-json-content-type |
|
|
//sprintf(head, "\r\nContent-Length: %zu\r\n\r\n", outlen); |
|
|
//sprintf(head, "--boundary\r\nContent-Type: application/json\r\nContent-Length: %zu\r\n\r\n", outlen); |
|
|
//_write(s, head, 0); |
|
|
int n = _write(s, outputbuf, outlen); |
|
|
//cerr << "known client " << s << " " << n << endl; |
|
|
if (n < outlen) |
|
|
{ |
|
|
cerr << "JSON_sender: kill client " << s << endl; |
|
|
::shutdown(s, 2); |
|
|
FD_CLR(s, &master); |
|
|
} |
|
|
} |
|
|
} |
|
|
return true; |
|
|
} |
|
|
}; |
|
|
// ---------------------------------------- |
|
|
|
|
|
void send_json(detection *dets, int nboxes, int classes, char **names, long long int frame_id, int port, int timeout) |
|
|
{ |
|
|
static JSON_sender js(port, timeout); |
|
|
char *send_buf = detection_to_json(dets, nboxes, classes, names, frame_id, NULL); |
|
|
|
|
|
js.write(send_buf); |
|
|
std::cout << " JSON-stream sent. \n"; |
|
|
free(send_buf); |
|
|
} |
|
|
|
|
|
// ---------------------------------------- |
|
|
|
|
|
CvCapture* get_capture_video_stream(char *path) { |
|
|
CvCapture* cap = NULL; |
|
|
try { |
|
|
cap = (CvCapture*)new cv::VideoCapture(path); |
|
|
} |
|
|
catch (...) { |
|
|
std::cout << " Error: video-stream " << path << " can't be opened! \n"; |
|
|
} |
|
|
return cap; |
|
|
} |
|
|
// ---------------------------------------- |
|
|
|
|
|
CvCapture* get_capture_webcam(int index) { |
|
|
CvCapture* cap = NULL; |
|
|
try { |
|
|
cap = (CvCapture*)new cv::VideoCapture(index); |
|
|
//((cv::VideoCapture*)cap)->set(CV_CAP_PROP_FRAME_WIDTH, 1280); |
|
|
//((cv::VideoCapture*)cap)->set(CV_CAP_PROP_FRAME_HEIGHT, 960); |
|
|
} |
|
|
catch (...) { |
|
|
std::cout << " Error: Web-camera " << index << " can't be opened! \n"; |
|
|
} |
|
|
return cap; |
|
|
} |
|
|
// ---------------------------------------- |
|
|
|
|
|
IplImage* get_webcam_frame(CvCapture *cap) { |
|
|
IplImage* src = NULL; |
|
|
try { |
|
|
cv::VideoCapture &cpp_cap = *(cv::VideoCapture *)cap; |
|
|
cv::Mat frame; |
|
|
if (cpp_cap.isOpened()) |
|
|
{ |
|
|
cpp_cap >> frame; |
|
|
IplImage tmp = frame; |
|
|
src = cvCloneImage(&tmp); |
|
|
} |
|
|
else { |
|
|
std::cout << " Video-stream stoped! \n"; |
|
|
} |
|
|
} |
|
|
catch (...) { |
|
|
std::cout << " Video-stream stoped! \n"; |
|
|
} |
|
|
return src; |
|
|
} |
|
|
|
|
|
int get_stream_fps_cpp(CvCapture *cap) { |
|
|
int fps = 25; |
|
|
try { |
|
|
cv::VideoCapture &cpp_cap = *(cv::VideoCapture *)cap; |
|
|
#ifndef CV_VERSION_EPOCH // OpenCV 3.x |
|
|
fps = cpp_cap.get(CAP_PROP_FPS); |
|
|
#else // OpenCV 2.x |
|
|
fps = cpp_cap.get(CV_CAP_PROP_FPS); |
|
|
#endif |
|
|
} |
|
|
catch (...) { |
|
|
std::cout << " Can't get FPS of source videofile. For output video FPS = 25 by default. \n"; |
|
|
} |
|
|
return fps; |
|
|
} |
|
|
// ---------------------------------------- |
|
|
extern "C" { |
|
|
image ipl_to_image(IplImage* src); // image.c |
|
|
} |
|
|
|
|
|
image image_data_augmentation(IplImage* ipl, int w, int h, |
|
|
int pleft, int ptop, int swidth, int sheight, int flip, |
|
|
float jitter, float dhue, float dsat, float dexp) |
|
|
{ |
|
|
cv::Mat img = cv::cvarrToMat(ipl); |
|
|
|
|
|
// crop |
|
|
cv::Rect src_rect(pleft, ptop, swidth, sheight); |
|
|
cv::Rect img_rect(cv::Point2i(0, 0), img.size()); |
|
|
cv::Rect new_src_rect = src_rect & img_rect; |
|
|
|
|
|
cv::Rect dst_rect(cv::Point2i(std::max<int>(0, -pleft), std::max<int>(0, -ptop)), new_src_rect.size()); |
|
|
|
|
|
cv::Mat cropped(cv::Size(src_rect.width, src_rect.height), img.type()); |
|
|
cropped.setTo(cv::Scalar::all(0)); |
|
|
|
|
|
img(new_src_rect).copyTo(cropped(dst_rect)); |
|
|
|
|
|
// resize |
|
|
cv::Mat sized; |
|
|
cv::resize(cropped, sized, cv::Size(w, h), 0, 0, INTER_LINEAR); |
|
|
|
|
|
// flip |
|
|
if (flip) { |
|
|
cv::flip(sized, cropped, 1); // 0 - x-axis, 1 - y-axis, -1 - both axes (x & y) |
|
|
sized = cropped.clone(); |
|
|
} |
|
|
|
|
|
// HSV augmentation |
|
|
// CV_BGR2HSV, CV_RGB2HSV, CV_HSV2BGR, CV_HSV2RGB |
|
|
if (ipl->nChannels >= 3) |
|
|
{ |
|
|
cv::Mat hsv_src; |
|
|
cvtColor(sized, hsv_src, CV_BGR2HSV); // also BGR -> RGB |
|
|
|
|
|
std::vector<cv::Mat> hsv; |
|
|
cv::split(hsv_src, hsv); |
|
|
|
|
|
hsv[1] *= dsat; |
|
|
hsv[2] *= dexp; |
|
|
hsv[0] += 179 * dhue; |
|
|
|
|
|
cv::merge(hsv, hsv_src); |
|
|
|
|
|
cvtColor(hsv_src, sized, CV_HSV2RGB); // now RGB instead of BGR |
|
|
} |
|
|
else |
|
|
{ |
|
|
sized *= dexp; |
|
|
} |
|
|
|
|
|
//std::stringstream window_name; |
|
|
//window_name << "augmentation - " << ipl; |
|
|
//cv::imshow(window_name.str(), sized); |
|
|
//cv::waitKey(0); |
|
|
|
|
|
// Mat -> IplImage -> image |
|
|
IplImage src = sized; |
|
|
image out = ipl_to_image(&src); |
|
|
|
|
|
return out; |
|
|
} |
|
|
|
|
|
|
|
|
#endif // OPENCV |
|
|
|
|
|
// ----------------------------------------------------- |
|
|
|
|
|
#if __cplusplus >= 201103L || _MSC_VER >= 1900 // C++11 |
|
|
|
|
|
#include <chrono> |
|
|
#include <iostream> |
|
|
|
|
|
static std::chrono::steady_clock::time_point steady_start, steady_end; |
|
|
static double total_time; |
|
|
|
|
|
double get_time_point() { |
|
|
std::chrono::steady_clock::time_point current_time = std::chrono::steady_clock::now(); |
|
|
//uint64_t now = std::chrono::duration_cast<std::chrono::milliseconds>(current_time.time_since_epoch()).count(); |
|
|
return std::chrono::duration_cast<std::chrono::microseconds>(current_time.time_since_epoch()).count(); |
|
|
} |
|
|
|
|
|
void start_timer() { |
|
|
steady_start = std::chrono::steady_clock::now(); |
|
|
} |
|
|
|
|
|
void stop_timer() { |
|
|
steady_end = std::chrono::steady_clock::now(); |
|
|
} |
|
|
|
|
|
double get_time() { |
|
|
double took_time = std::chrono::duration<double>(steady_end - steady_start).count(); |
|
|
total_time += took_time; |
|
|
return took_time; |
|
|
} |
|
|
|
|
|
void stop_timer_and_show() { |
|
|
stop_timer(); |
|
|
std::cout << " " << get_time()*1000 << " msec" << std::endl; |
|
|
} |
|
|
|
|
|
void stop_timer_and_show_name(char *name) { |
|
|
std::cout << " " << name; |
|
|
stop_timer_and_show(); |
|
|
} |
|
|
|
|
|
void show_total_time() { |
|
|
std::cout << " Total: " << total_time * 1000 << " msec" << std::endl; |
|
|
} |
|
|
|
|
|
#else // C++11 |
|
|
#include <iostream> |
|
|
|
|
|
double get_time_point() { return 0; } |
|
|
void start_timer() {} |
|
|
void stop_timer() {} |
|
|
double get_time() { return 0; } |
|
|
void stop_timer_and_show() { |
|
|
std::cout << " stop_timer_and_show() isn't implemented " << std::endl; |
|
|
} |
|
|
void stop_timer_and_show_name(char *name) { stop_timer_and_show(); } |
|
|
void total_time() {} |
|
|
#endif // C++11
|
