Blame view

3rdparty/opencv-4.5.4/samples/gpu/video_reader.cpp 2.25 KB
f4334277   Hu Chunming   提交3rdparty
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
  #include <iostream>
  
  #include "opencv2/opencv_modules.hpp"
  
  #if defined(HAVE_OPENCV_CUDACODEC)
  
  #include <string>
  #include <vector>
  #include <algorithm>
  #include <numeric>
  
  #include <opencv2/core.hpp>
  #include <opencv2/core/opengl.hpp>
  #include <opencv2/cudacodec.hpp>
  #include <opencv2/highgui.hpp>
  
  int main(int argc, const char* argv[])
  {
      if (argc != 2)
          return -1;
  
      const std::string fname(argv[1]);
  
      cv::namedWindow("CPU", cv::WINDOW_NORMAL);
      cv::namedWindow("GPU", cv::WINDOW_OPENGL);
      cv::cuda::setGlDevice();
  
      cv::Mat frame;
      cv::VideoCapture reader(fname);
  
      cv::cuda::GpuMat d_frame;
      cv::Ptr<cv::cudacodec::VideoReader> d_reader = cv::cudacodec::createVideoReader(fname);
  
      cv::TickMeter tm;
      std::vector<double> cpu_times;
      std::vector<double> gpu_times;
  
      int gpu_frame_count=0, cpu_frame_count=0;
  
      for (;;)
      {
          tm.reset(); tm.start();
          if (!reader.read(frame))
              break;
          tm.stop();
          cpu_times.push_back(tm.getTimeMilli());
          cpu_frame_count++;
  
          cv::imshow("CPU", frame);
  
          if (cv::waitKey(3) > 0)
              break;
      }
  
      for (;;)
      {
          tm.reset(); tm.start();
          if (!d_reader->nextFrame(d_frame))
              break;
          tm.stop();
          gpu_times.push_back(tm.getTimeMilli());
          gpu_frame_count++;
  
          cv::imshow("GPU", d_frame);
  
          if (cv::waitKey(3) > 0)
              break;
      }
  
      if (!cpu_times.empty() && !gpu_times.empty())
      {
          std::cout << std::endl << "Results:" << std::endl;
  
          std::sort(cpu_times.begin(), cpu_times.end());
          std::sort(gpu_times.begin(), gpu_times.end());
  
          double cpu_avg = std::accumulate(cpu_times.begin(), cpu_times.end(), 0.0) / cpu_times.size();
          double gpu_avg = std::accumulate(gpu_times.begin(), gpu_times.end(), 0.0) / gpu_times.size();
  
          std::cout << "CPU : Avg : " << cpu_avg << " ms FPS : " << 1000.0 / cpu_avg << " Frames " << cpu_frame_count << std::endl;
          std::cout << "GPU : Avg : " << gpu_avg << " ms FPS : " << 1000.0 / gpu_avg << " Frames " << gpu_frame_count << std::endl;
      }
  
      return 0;
  }
  
  #else
  
  int main()
  {
      std::cout << "OpenCV was built without CUDA Video decoding support\n" << std::endl;
      return 0;
  }
  
  #endif