blocks|key|591150|text|OpenCV解|type|unstyled|depth|inlineStyleRanges|entityRanges|data|591151|根据这源，您可以设置cv::VideoCapture对象的缓冲区大小。|offset|length|style|CODE|591152|cv::VideoCapture+cap;
cap.set(CV_CAP_PROP_BUFFERSIZE,+3);+//+internal+buffer+will+now+store+only+3+frames

//+rest+of+your+code...|code-block|syntax|javascript|591153|然而，有一个重要的限制：|591154|存储在内部缓冲区内存中的CV_CAP_PROP_BUFFERSIZE帧数量(注意：目前只支持DC1394+v2.x后端)|blockquote|BOLD|591155|从注释中更新。在较新版本的OpenCV+(3.4%2B)中，限制似乎已经消失，代码使用了限定范围的枚举：|591156|cv::VideoCapture+cap;
cap.set(cv::CAP_PROP_BUFFERSIZE,+3);|591157|哈克卡夫1|591158|如果解决方案不起作用，请看一看这个职位，它解释了如何破解这个问题。|591159|简单地说:查询帧所需的时间是测量的；如果查询的时间太低，就意味着从缓冲区读取了帧，可以丢弃。继续查询帧，直到测量的时间超过某一限制为止。当发生这种情况时，缓冲区为空，返回的帧是最新的。|591160|(链接post上的回答显示:从缓冲区返回帧大约需要返回最新帧的1/8时间。当然，你的里程可能会有所不同！)|591161|哈克卡夫2|591162|在这+post的启发下，另一种解决方案是创建第三个线程，该线程连续高速抓取帧，以保持缓冲区为空。这个线程应该使用cv::VideoCapture.grab()来避免开销。|591163|您可以使用一个简单的自旋锁来同步实际工作线程和第三个线程之间的读取帧。|591164|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.opencv.org/modules/highgui/doc/reading_and_writing_images_and_video.html#videocapture-set|1|http://answers.opencv.org/question/29957/highguivideocapture-buffer-introducing-lag/?answer=38217#post-id-38217/|2|http://www.chiefdelphi.com/forums/archive/index.php/t-123390.html|3|http://docs.opencv.org/modules/highgui/doc/reading_and_writing_images_and_video.html#videocapture-grab^0|0|A|G|2|1|0|0|0|0|15|I|0|4|1A|0|0|0|5|0|0|X|F|4|1|0|0|2K|0|0|1H|0|0|5|0|0|2D|1K|N|1|1|2|1K|N|3|0|0|Z|0^^$0|@$1|2|3|4|5|6|7|1O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1P|8|@$D|1Q|E|1R|F|G]]|9|@$D|1S|E|1T|1|1U]]|A|$]]|$1|H|3|I|5|J|7|1V|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|1W|8|@]|9|@]|A|$]]|$1|O|3|P|5|Q|7|1X|8|@$D|1Y|E|1Z|F|R]]|9|@]|A|$]]|$1|S|3|T|5|6|7|20|8|@$D|21|E|22|F|R]]|9|@]|A|$]]|$1|U|3|V|5|J|7|23|8|@]|9|@]|A|$K|L]]|$1|W|3|X|5|6|7|24|8|@$D|25|E|26|F|R]]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|27|8|@$D|28|E|29|F|R]]|9|@$D|2A|E|2B|1|2C]]|A|$]]|$1|10|3|11|5|6|7|2D|8|@$D|2E|E|2F|F|R]]|9|@]|A|$]]|$1|12|3|13|5|6|7|2G|8|@$D|2H|E|2I|F|R]]|9|@]|A|$]]|$1|14|3|15|5|6|7|2J|8|@$D|2K|E|2L|F|R]]|9|@]|A|$]]|$1|16|3|17|5|6|7|2M|8|@$D|2N|E|2O|F|R]|$D|2P|E|2Q|F|G]]|9|@$D|2R|E|2S|1|2T]|$D|2U|E|2V|1|2W]]|A|$]]|$1|18|3|19|5|6|7|2X|8|@$D|2Y|E|2Z|F|R]]|9|@]|A|$]]|$1|1A|3|-4|5|6|7|30|8|@]|9|@]|A|$]]]|1B|$1C|$5|1D|1E|1F|A|$1G|1H]]|1I|$5|1D|1E|1F|A|$1G|1J]]|1K|$5|1D|1E|1F|A|$1G|1L]]|1M|$5|1D|1E|1F|A|$1G|1N]]]]

<h1>OpenCV Solution</h1>

According to <a href="http://docs.opencv.org/modules/highgui/doc/reading_and_writing_images_and_video.html#videocapture-set" rel="noreferrer">this</a> source, you can set the buffersize of a <code>cv::VideoCapture</code> object.

<pre class="lang-cpp prettyprint-override"><code>cv::VideoCapture cap;
cap.set(CV_CAP_PROP_BUFFERSIZE, 3); // internal buffer will now store only 3 frames

// rest of your code...
</code></pre>

There is an important limitation however:

<blockquote>
 CV_CAP_PROP_BUFFERSIZE Amount of frames stored in internal buffer memory (note: only supported by DC1394 v 2.x backend currently)
</blockquote>

Update from comments. In newer versions of OpenCV (3.4+), the limitation seems to be gone and the code uses scoped enumerations:

<pre class="lang-cpp prettyprint-override"><code>cv::VideoCapture cap;
cap.set(cv::CAP_PROP_BUFFERSIZE, 3);
</code></pre>

<hr>

<h1>Hackaround 1</h1>

If the solution does not work, take a look at <a href="http://answers.opencv.org/question/29957/highguivideocapture-buffer-introducing-lag/?answer=38217#post-id-38217/" rel="noreferrer">this post</a> that explains how to hack around the issue.

In a nutshell: the time needed to query a frame is measured; if it is too low, it means the frame was read from the buffer and can be discarded. Continue querying frames until the time measured exceeds a certain limit. When this happens, the buffer was empty and the returned frame is up to date.

(The answer on the linked post shows: returning a frame from the buffer takes about 1/8th the time of returning an up to date frame. Your mileage may vary, of course!)

<hr>

<h1>Hackaround 2</h1>

A different solution, inspired by <a href="http://www.chiefdelphi.com/forums/archive/index.php/t-123390.html" rel="noreferrer">this</a> post, is to create a third thread that grabs frames continuously at high speed to keep the buffer empty. This thread should use the <a href="http://docs.opencv.org/modules/highgui/doc/reading_and_writing_images_and_video.html#videocapture-grab" rel="noreferrer"><code>cv::VideoCapture.grab()</code></a> to avoid overhead.

You could use a simple spin-lock to synchronize reading frames between the real worker thread and the third thread.

blocks|key|1634192|text|你可以确保抓取帧花了一些时间。编写代码非常简单，尽管有点不可靠；这段代码可能导致死锁。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1634193|#include+<chrono>
using+clock+=+std::chrono::high_resolution_clock;
using+duration_float+=+std::chrono::duration_cast<std::chrono::duration<float>>;
//+...
while+(1)+{
++++TimePoint+time_start+=+clock::now();
++++camera.grab();
++++if+(duration_float(clock::now()+-+time_start).count()+*+camera.get(cv::CAP_PROP_FPS)+>+0.5)+{
++++++++break;
++++}
}
camera.retrieve(dst_image);|code-block|syntax|javascript|1634194|代码使用C%2B%2B11。|1634195|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

You can make sure that grabbing the frame took a bit of time. It is quite simple to code, though a bit unreliable; potentially, this code could lead to a deadlock.

<pre><code>#include &lt;chrono&gt;
using clock = std::chrono::high_resolution_clock;
using duration_float = std::chrono::duration_cast&lt;std::chrono::duration&lt;float&gt;&gt;;
// ...
while (1) {
 TimePoint time_start = clock::now();
 camera.grab();
 if (duration_float(clock::now() - time_start).count() * camera.get(cv::CAP_PROP_FPS) &gt; 0.5) {
 break;
 }
}
camera.retrieve(dst_image);
</code></pre>

The code uses C++11.

blocks|key|1634216|text|伙计们，这是非常愚蠢和讨厌的解决办法，但接受的答案并没有帮助我，因为一些原因。(用python编写代码，但其实质相当清楚)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1634217|#+vcap.set(cv2.CAP_PROP_BUFFERSIZE,+1)
data+=+np.zeros((1140,+2560))
image+=+plt.imshow(data)

while+True:
++++vcap+=+cv2.VideoCapture("rtsp://admin:@192.168.3.231")
++++ret,+frame+=+vcap.read()
++++image.set_data(frame)
++++plt.pause(0.5)+#+any+other+consuming+operation
++++vcap.release()|code-block|syntax|javascript|1634218|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Guys this is pretty stupid and nasty solution, but accepted answer didn't helped me for some reasons. (Code in python but the essence pretty clear)

<pre><code># vcap.set(cv2.CAP_PROP_BUFFERSIZE, 1)
data = np.zeros((1140, 2560))
image = plt.imshow(data)

while True:
 vcap = cv2.VideoCapture("rtsp://admin:@192.168.3.231")
 ret, frame = vcap.read()
 image.set_data(frame)
 plt.pause(0.5) # any other consuming operation
 vcap.release()
</code></pre>

blocks|key|1634242|text|如果你知道你的相机的帧率，你可以使用这个信息(即每秒30帧)来抓取这些帧，直到你得到一个更低的帧速率。它之所以有效，是因为如果抓取功能变得延迟(即获得比标准帧速率更多的时间)，这意味着缓冲区内的每一帧都需要等待下一帧才能从摄像机中获得。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1634243|while(True):
++++prev_time=time.time()
++++ref=vid.grab()
++++if+(time.time()-prev_time)>0.030:#something+around+33+FPS
++++++++break
ret,frame+=+vid.retrieve(ref)|code-block|syntax|javascript|1634244|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

If you know the framerate of your camera you may use this information (i.e. 30 frames per second) to grab the frames until you got a lower frame rate.
It works because if grab function become delayed (i.e. get more time to grab a frame than the standard frame rate), it means that you got every frame inside the buffer and opencv need to wait the next frame to come from camera.

<pre><code>while(True):
 prev_time=time.time()
 ref=vid.grab()
 if (time.time()-prev_time)&gt;0.030:#something around 33 FPS
 break
ret,frame = vid.retrieve(ref)
</code></pre>

blocks|key|2932767|text|如果使用GStreamer管道，则可以选择丢弃旧缓冲区。appsink+drop=true+选项“填充缓冲区队列时丢弃旧缓冲区”。在我的特殊情况下，在实时流处理过程中会出现延迟(不时)，因此需要获得每个VideoCapture.read调用的最新帧。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2932768|#include+<chrono>
#include+<thread>

#include+<opencv4/opencv2/highgui.hpp>

static+constexpr+const+char+*+const+WINDOW+=+"1";

void+video_test()+{
++++//+It+doesn't+work+properly+without+`drop=true`+option
++++cv::VideoCapture+video("v4l2src+device=/dev/video0+!+videoconvert+!+videoscale+!+videorate+!+video/x-raw,width=640+!+appsink+drop=true",+cv::CAP_GSTREAMER);

++++if(!video.isOpened())+{
++++++++return;
++++}

++++cv::namedWindow(
++++++++WINDOW,
++++++++cv::WINDOW_GUI_NORMAL+%7C+cv::WINDOW_NORMAL+%7C+cv::WINDOW_KEEPRATIO
++++);
++++cv::resizeWindow(WINDOW,+700,+700);

++++cv::Mat+frame;
++++const+std::chrono::seconds+sec(1);
++++while(true)+{
++++++++if(!video.read(frame))+{
++++++++++++break;
++++++++}
++++++++std::this_thread::sleep_for(sec);
++++++++cv::imshow(WINDOW,+frame);
++++++++cv::waitKey(1);
++++}
}|code-block|syntax|javascript|2932769|entityMap|0|LINK|mutability|MUTABLE|url|https://gstreamer.freedesktop.org/documentation/app/appsink.html?gi-language=c#appsink:drop^0|S|H|2T|H|1A|2|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]|$9|V|A|W|B|C]]|D|@$9|X|A|Y|1|Z]]|E|$]]|$1|F|3|G|5|H|7|10|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|11|8|@]|D|@]|E|$]]]|L|$M|$5|N|O|P|E|$Q|R]]]]

There is an option to drop old buffers if you use a GStreamer pipeline. <code>appsink drop=true</code> <a href="https://gstreamer.freedesktop.org/documentation/app/appsink.html?gi-language=c#appsink:drop" rel="nofollow noreferrer">option</a> "Drops old buffers when the buffer queue is filled". In my particular case, there is a delay (from time to time) during the live stream processing, so it's needed to get the latest frame each <code>VideoCapture.read</code> call.

<pre><code>#include &lt;chrono&gt;
#include &lt;thread&gt;

#include &lt;opencv4/opencv2/highgui.hpp&gt;

static constexpr const char * const WINDOW = "1";

void video_test() {
 // It doesn't work properly without `drop=true` option
 cv::VideoCapture video("v4l2src device=/dev/video0 ! videoconvert ! videoscale ! videorate ! video/x-raw,width=640 ! appsink drop=true", cv::CAP_GSTREAMER);

 if(!video.isOpened()) {
 return;
 }

 cv::namedWindow(
 WINDOW,
 cv::WINDOW_GUI_NORMAL | cv::WINDOW_NORMAL | cv::WINDOW_KEEPRATIO
 );
 cv::resizeWindow(WINDOW, 700, 700);

 cv::Mat frame;
 const std::chrono::seconds sec(1);
 while(true) {
 if(!video.read(frame)) {
 break;
 }
 std::this_thread::sleep_for(sec);
 cv::imshow(WINDOW, frame);
 cv::waitKey(1);
 }
}
</code></pre>

blocks|key|2932791|text|使用Python在Maarten的答案中实现了Hackaround+2。它启动一个线程，并将最新的框架从camera.read()中保存为一个class属性。在c%2B%2B中也可以使用类似的策略|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2932792|import+threading
import+cv2

#+Define+the+thread+that+will+continuously+pull+frames+from+the+camera
class+CameraBufferCleanerThread(threading.Thread):
++++def+__init__(self,+camera,+name='camera-buffer-cleaner-thread'):
++++++++self.camera+=+camera
++++++++self.last_frame+=+None
++++++++super(CameraBufferCleanerThread,+self).__init__(name=name)
++++++++self.start()

++++def+run(self):
++++++++while+True:
++++++++++++ret,+self.last_frame+=+self.camera.read()

#+Start+the+camera
camera+=+cv2.VideoCapture(0)

#+Start+the+cleaning+thread
cam_cleaner+=+CameraBufferCleanerThread(camera)

#+Use+the+frame+whenever+you+want
while+True:
++++if+cam_cleaner.last_frame+is+not+None:
++++++++cv2.imshow('The+last+frame',+cam_cleaner.last_frame)
++++cv2.waitKey(10)|code-block|syntax|javascript|2932793|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

An implementation of Hackaround 2 in Maarten's answer using Python. It starts a thread and keeps the latest frame from camera.read() as a class attribute. A similar strategy can be done in c++
<pre><code>import threading
import cv2

# Define the thread that will continuously pull frames from the camera
class CameraBufferCleanerThread(threading.Thread):
 def __init__(self, camera, name='camera-buffer-cleaner-thread'):
 self.camera = camera
 self.last_frame = None
 super(CameraBufferCleanerThread, self).__init__(name=name)
 self.start()

 def run(self):
 while True:
 ret, self.last_frame = self.camera.read()

# Start the camera
camera = cv2.VideoCapture(0)

# Start the cleaning thread
cam_cleaner = CameraBufferCleanerThread(camera)

# Use the frame whenever you want
while True:
 if cam_cleaner.last_frame is not None:
 cv2.imshow('The last frame', cam_cleaner.last_frame)
 cv2.waitKey(10)
</code></pre>

I am capturing video through a webcam which gives a mjpeg stream.
I did the video capture in a worker thread.
I start the capture like this:

<pre><code>const std::string videoStreamAddress = "http://192.168.1.173:80/live/0/mjpeg.jpg?x.mjpeg";
qDebug() &lt;&lt; "start";
cap.open(videoStreamAddress);
qDebug() &lt;&lt; "really started";
cap.set(CV_CAP_PROP_FRAME_WIDTH, 720);
cap.set(CV_CAP_PROP_FRAME_HEIGHT, 576);
</code></pre>

the camera is feeding the stream at 20fps.
But if I did the reading in 20fps like this:

<pre><code>if (!cap.isOpened()) return;

 Mat frame;
 cap &gt;&gt; frame; // get a new frame from camera
 mutex.lock();

 m_imageFrame = frame;
 mutex.unlock();
</code></pre>

Then there is a 3+ seconds lag.
The reason is that the captured video is first stored in a buffer.When I first start the camera, the buffer is accumulated but I did not read the frames out. So If I read from the buffer it always gives me the old frames.
The only solutions I have now is to read the buffer at 30fps so it will clean the buffer quickly and there's no more serious lag.

Is there any other possible solution so that I could clean/flush the buffer manually each time I start the camera?

OpenCV VideoCapture lag due to the capture buffer

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋 

腾讯云代码助手

CODING DevOps

Cloud Studio

SDK中心

API中心

命令行工具

我是通过一个摄像头捕捉视频，它提供了一个mjpeg流。我在一个工作线程中拍摄了视频。我就这样开始抓捕：const std::string videoStreamAddress = "http://192.168.1.173:80/live/0/mjpeg.jpg?x.mjpeg";qDebug() << "start"...

问由于捕获缓冲区导致的OpenCV VideoCapture滞后
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问由于捕获缓冲区导致的OpenCV VideoCapture滞后EN