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;
}    

• Here is a very simple way to print your program's frame rate at each frame (no counter needed) :

  import time
  
  while True:
      start_time = time.time() # start time of the loop
  
      ########################
      # your fancy code here #
      ########################
  
      print("FPS: ", 1.0 / (time.time() - start_time)) # FPS = 1 / time to process loop
  

• If you want the average frame rate over x seconds, you can do like so (counter needed) :

  import time
  
  start_time = time.time()
  x = 1 # displays the frame rate every 1 second
  counter = 0
  while True:
  
      ########################
      # your fancy code here #
      ########################
  
      counter+=1
      if (time.time() - start_time) > x :
          print("FPS: ", counter / (time.time() - start_time))
          counter = 0
          start_time = time.time()
  

Hope it helps!

double fps=cvGetCaptureProperty(capture, CV_CAP_PROP_FPS); 

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;
}