I have posted a way to do that @ Getting current FPS of OpenCV. It is necessary to do a bit of averaging otherwise the fps will be too jumpy.

edit

I have put a Sleep inside process() and it gives correct fps and duration(+/- 1ms).

#include "opencv2/highgui/highgui.hpp"
#include "opencv2/imgproc/imgproc.hpp"
#include <opencv/cv.h>
#include <sys/timeb.h>
using namespace cv;

#if defined(_MSC_VER) || defined(WIN32)  || defined(_WIN32) || defined(__WIN32__) \
    || defined(WIN64)    || defined(_WIN64) || defined(__WIN64__) 

#include <windows.h>
bool _qpcInited=false;
double PCFreq = 0.0;
__int64 CounterStart = 0;
void InitCounter()
{
    LARGE_INTEGER li;
    if(!QueryPerformanceFrequency(&li))
    {
        std::cout << "QueryPerformanceFrequency failed!\n";
    }
    PCFreq = double(li.QuadPart)/1000.0f;
    _qpcInited=true;
}
double CLOCK()
{
    if(!_qpcInited) InitCounter();
    LARGE_INTEGER li;
    QueryPerformanceCounter(&li);
    return double(li.QuadPart)/PCFreq;
}

#endif

#if defined(unix)        || defined(__unix)      || defined(__unix__) \
    || defined(linux)       || defined(__linux)     || defined(__linux__) \
    || defined(sun)         || defined(__sun) \
    || defined(BSD)         || defined(__OpenBSD__) || defined(__NetBSD__) \
    || defined(__FreeBSD__) || defined __DragonFly__ \
    || defined(sgi)         || defined(__sgi) \
    || defined(__MACOSX__)  || defined(__APPLE__) \
    || defined(__CYGWIN__) 
double CLOCK()
{
    struct timespec t;
    clock_gettime(CLOCK_MONOTONIC,  &t);
    return (t.tv_sec * 1000)+(t.tv_nsec*1e-6);
}
#endif

double _avgdur=0;
double _fpsstart=0;
double _avgfps=0;
double _fps1sec=0;

double avgdur(double newdur)
{
    _avgdur=0.98*_avgdur+0.02*newdur;
    return _avgdur;
}

double avgfps()
{
    if(CLOCK()-_fpsstart>1000)      
    {
        _fpsstart=CLOCK();
        _avgfps=0.7*_avgfps+0.3*_fps1sec;
        _fps1sec=0;
    }
    _fps1sec++;
    return _avgfps;
}

void process(Mat& frame)
{
    Sleep(3);
}
int main(int argc, char** argv)
{
    int frameno=0;
    cv::Mat frame;
    cv::VideoCapture cap(0);
    for(;;)
    {
        //cap>>frame;
        double start=CLOCK();
        process(frame);
        double dur = CLOCK()-start;
        printf("avg time per frame %f ms. fps %f. frameno = %d\n",avgdur(dur),avgfps(),frameno++ );
        if(waitKey(1)==27)
            exit(0);
    }
    return 0;
}    

You got the method

VideoCapture::get(CV_CAP_PROP_FPS) Is it not working?

As far as I know a chrono approach would still use CPU Ticks. Supposing your loop is something like

cv::Mat frame; cv::VideoCapture cap(video_path);
while (cap.read(frame)) {
     /* .. */
}

You could try something like

#include <chrono>
using namespace std::chrono;

time_point<steady_clock> begin_time = steady_clock::now(), new_time;
cv::Mat frame; 
cv::VideoCapture cap(video_path);
size_t frame_counter = 0;

while (cap.read(frame)) {
    /* do stuff.. */ 
    frame_counter++;
    new_time = steady_clock::now();

    if (new_time - begin_time >= seconds{1}) {
        /* Do something with the fps in frame_counter */
        frame_counter = 0;
        begin_time = new_time;
    } 
}

I think you forgot to re-initialize the start time, here is modified code, this provides consistent fps value, I tested in my laptop and got around 33.2, I just count up to 100 frames and reinitialize everything, this seems to work

int n_frame = 0;
Mat previous;
auto start = std::chrono::high_resolution_clock::now();
VideoCapture m_cap(0);

while (m_cap.isOpened()) {
    n_frame++;
    if (n_frame == 100) {
        auto end = std::chrono::high_resolution_clock::now();
        auto time = std::chrono::duration_cast<chrono::seconds>(end - start);
        cout << "the fps is: " << (n_frame / static_cast<double>(time.count())) << endl;
        start = end;
        n_frame = 0;
    }
    //cout << "frame number: " << n_frame << endl;
    Mat frame, original;
    m_cap >> frame;
    if (frame.empty())
        break;
}

double fps=cvGetCaptureProperty(capture, CV_CAP_PROP_FPS);