http mjpeg 图像读取

http mjpeg 图像格式

网络摄像头的视频流解析直接使用通过http的Mjpeg是具有边界帧信息的multipart/x-mixed-replace，而jpeg数据只是以二进制形式发送。因此，实际上不需要关心HTTP协议标头。所有jpeg帧均以marker开头，0xff 0xd8并以0xff 0xd9 结尾。因此，代码可以从http流中提取此类帧，解码，编码h264 ，重新发送。

抓包

GET /stream/mjpeg HTTP/1.1
Host: 192.168.0.66:2401
Connection: keep-alive
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/90.0.4430.85 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,/;q=0.8,application/signed-exchange;v=b3;q=0.9
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9

HTTP/1.1 200 OK
Content-Type: multipart/x-mixed-replace;boundary=----WebKitFormBoundaryIZDrYHwuf2VJdpHw
Cache-Control: no-cache

------WebKitFormBoundaryIZDrYHwuf2VJdpHw
Content-Type: image/jpg
Content-Length: 61108

…JFIF…

1、python opencv来读 http mjpeg

以下使用python来读http mjpeg，因为python 方便快速，可以做原型方法的测试

import cv2
import requests
import numpy as np
 
r = requests.get('http://192.168.1.xx/mjpeg.cgi', auth=('user', 'password'), stream=True)
if(r.status_code == 200):
    bytes = bytes()
    for chunk in r.iter_content(chunk_size=1024):
        bytes += chunk
        a = bytes.find(b'\xff\xd8')
        b = bytes.find(b'\xff\xd9')
        if a != -1 and b != -1:
            jpg = bytes[a:b+2]
            bytes = bytes[b+2:]
            i = cv2.imdecode(np.fromstring(jpg, dtype=np.uint8), cv2.IMREAD_COLOR)
            cv2.imshow('i', i)
            if cv2.waitKey(1) == 27:
                exit(0)
else:
    print("Received unexpected status code {}".format(r.status_code))

2、java读取

java读取也是很方便的

package net.thistleshrub.mechwarfare.mjpeg;

import java.awt.image.BufferedImage;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.StringWriter;
import java.net.SocketTimeoutException;
import java.net.URL;
import java.net.URLConnection;

import javax.imageio.ImageIO;


public class MjpegRunner implements Runnable
{
	private static final String CONTENT_LENGTH = "Content-length: ";
	private static final String CONTENT_TYPE = "Content-type: image/jpeg";
	private MJpegViewer viewer;
	private InputStream urlStream;
	private StringWriter stringWriter;
	private boolean processing = true;
	
	public MjpegRunner(MJpegViewer viewer, URL url) throws IOException
	{
		this.viewer = viewer;
		URLConnection urlConn = url.openConnection();
		// change the timeout to taste, I like 1 second
		urlConn.setReadTimeout(1000);
		urlConn.connect();
		urlStream = urlConn.getInputStream();
		stringWriter = new StringWriter(128);
	}

	public synchronized void stop()
	{
		processing = false;
	}
	

	@Override
	public void run()
	{
		while(processing)
		{
			try
			{
				byte[] imageBytes = retrieveNextImage();
				ByteArrayInputStream bais = new ByteArrayInputStream(imageBytes);
				
				BufferedImage image = ImageIO.read(bais);
				viewer.setBufferedImage(image);
				
				viewer.repaint();
			}catch(SocketTimeoutException ste){
				System.err.println("failed stream read: " + ste);
				viewer.setFailedString("Lost Camera connection: " + ste);
				viewer.repaint();
				stop();
			}catch(IOException e){
				System.err.println("failed stream read: " + e);
				stop();
			}
		}
		
		// close streams
		try
		{
			urlStream.close();
		}catch(IOException ioe){
			System.err.println("Failed to close the stream: " + ioe);
		}
	}
	
	/**
	 * Using the urlStream get the next JPEG image as a byte[]
	 * @return byte[] of the JPEG
	 * @throws IOException
	 */
	private byte[] retrieveNextImage() throws IOException
	{
		boolean haveHeader = false; 
		int currByte = -1;
		
		String header = null;
		// build headers
		// the DCS-930L stops it's headers
		while((currByte = urlStream.read()) > -1 && !haveHeader)
		{
			stringWriter.write(currByte);
			
			String tempString = stringWriter.toString(); 
			int indexOf = tempString.indexOf(CONTENT_TYPE);
			if(indexOf > 0)
			{
				haveHeader = true;
				header = tempString;
			}
		}		
		
		// 255 indicates the start of the jpeg image
		while((urlStream.read()) != 255)
		{
			// just skip extras
		}
		
		// rest is the buffer
		int contentLength = contentLength(header);
		byte[] imageBytes = new byte[contentLength + 1];
		// since we ate the original 255 , shove it back in
		imageBytes[0] = (byte)255;
		int offset = 1;
		int numRead = 0;
		while (offset < imageBytes.length
			&& (numRead=urlStream.read(imageBytes, offset, imageBytes.length-offset)) >= 0) 
		{
			offset += numRead;
		}       
		
		stringWriter = new StringWriter(128);
		
		return imageBytes;
	}

	// dirty but it works content-length parsing
	private static int contentLength(String header)
	{
		int indexOfContentLength = header.indexOf(CONTENT_LENGTH);
		int valueStartPos = indexOfContentLength + CONTENT_LENGTH.length();
		int indexOfEOL = header.indexOf('\n', indexOfContentLength);
		
		String lengthValStr = header.substring(valueStartPos, indexOfEOL).trim();
		
		int retValue = Integer.parseInt(lengthValStr);
		
		return retValue;
	}
}

3、c++读取

以下这段代码我在其他文章里面写过，现在把他加上，省的其他人找了

void capture_start(s_param *param)
{
	//开始视频采集
	if (param != NULL)
	{
		asio::io_context io_service;
		tcp::resolver resolver(io_service);
		tcp::resolver::query query(param->host, param->port);
		tcp::resolver::iterator endpoint_iterator = resolver.resolve(query);
		tcp::resolver::iterator end;
		tcp::socket socket(io_service);
		//socket.io_control(asio::ip::tcp::socket::non_blocking(true));
		std::error_code error = asio::error::host_not_found;
		while (error && endpoint_iterator != end) {
			socket.close();
			//int timeout = 3000;
			//int nRet = setsockopt(socket.native_handle(), SOL_SOCKET, SO_CONNECT_TIME, (const char*)&timeout, sizeof(timeout));
			socket.connect(*endpoint_iterator++, error);
		}
		if (error) {
			cout << "can not connect the camera!" << endl;
			return;
			//throw asio::system_error(error);
		}

		// Form the request. We specify the "Connection: close" header so that the
		// server will close the socket after transmitting the response. This will
		// allow us to treat all data up until the EOF as the content.
		asio::streambuf request;
		ostream request_stream(&request);
		request_stream << "GET " <<param->route << " HTTP/1.0\r\n";
		request_stream << "Host: " << param->host << "\r\n";
		request_stream << "Accept: */*\r\n";
		request_stream << "Connection: close\r\n\r\n";

		// Send the request.
		asio::write(socket, request);

		// Read the response status line. The response streambuf will automatically
		// grow to accommodate the entire line. The growth may be limited by passing
		// a maximum size to the streambuf constructor.
		asio::streambuf response;
		asio::read_until(socket, response, "\r\n");

		// Check that response is OK.
		istream response_stream(&response);
		string http_version;
		response_stream >> http_version;
		unsigned int status_code;
		response_stream >> status_code;
		string status_message;
		getline(response_stream, status_message);
		if (!response_stream || http_version.substr(0, 5) != "HTTP/") {
			cout << "Invalid response\n";
			return;
		}
		if (status_code != 200) {
			cout << "Response returned with status code " << status_code << "\n";
			return;
		}

		// Read the response headers, which are terminated by a blank line.
		asio::read_until(socket, response, "\r\n\r\n");

		// Get the MIME multipart boundary from the headers.
		regex rx_content_type("Content-Type:.*boundary=(.*)");
		regex rx_content_length("Content-Length: (.*)");

		smatch match;
		string header;
		string boundary;

		while (getline(response_stream, header) && header != "\r") {
			//cout << "HTTP HEADER: " << header << endl;
			if (regex_search(header, match, rx_content_type)) {
				boundary = match[1];
				//cout << "BOUNDARY SELECTED: " << boundary << endl;
			}
		}

		// Abort if a boundary was not found.
		if (boundary == "") {
			cout << "Not a MJPEG stream" << endl;
			return;
		}


		std::vector<uint8_t> buff;
		while (1) {
			asio::read_until(socket, response, boundary);
			while (getline(response_stream, header)) {
				if (header.find(boundary + "\r") != string::npos)
				{
					break;
				}
			}
			uint32_t content_length;
			while (getline(response_stream, header) && header != "\r") {
				if (regex_search(header, match, rx_content_length)) {
					std::ssub_match base_sub_match = match[1];
					content_length = std::atoi(base_sub_match.str().c_str());
				}
			}

			if (response.size() < content_length) {
				asio::read(socket, response, asio::transfer_at_least(
					content_length - response.size()));
			}
			if (buff.size() < content_length) {
				buff.resize(content_length);
			}

			response.sgetn((char*)&buff[0], content_length);
			cv::Mat mat(buff);
			cv::Mat dec = imdecode(Mat(buff), IMREAD_COLOR);
			v_mut_src.lock();
			cv::resize(dec, v_srcImg, cv::Size(CANVAS_WIDTH, CANVAS_HEIGHT));
			v_mut_src.unlock();
			//cout << "RESPONSE SIZE, BEFORE JPEG CONSUME: " << response.size() << endl;
			cv::imshow("windows", v_srcImg);
			cv::waitKey(2);
			response.consume(content_length);
		}
	}
	
	std::cout << "capture break...." << std::endl;
}