C++以http接口推送json流和图片流

最新推荐文章于 2023-04-30 13:49:06 发布
最新推荐文章于 2023-04-30 13:49:06 发布
阅读量773 收藏 5
点赞数
分类专栏： 常用的小代码 文章标签： c++ http json
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/skyli114/article/details/126628476
版权

一、C++推送json流

C++代码：

//
// a single-threaded, multi client(using select), debug webserver - streaming out mjpg.
//  on win, _WIN32 has to be defined, must link against ws2_32.lib (socks on linux are for free)
//

//
// socket related abstractions:
//
#ifdef _WIN32  
    #include <winsock.h>
    #include <windows.h>
    #include <time.h>
    #define PORT        unsigned long
    #define ADDRPOINTER   int*
    struct _INIT_W32DATA
    {
       WSADATA w;
       _INIT_W32DATA() { WSAStartup( MAKEWORD( 2, 1 ), &w ); }
    } _init_once;
#else       /* ! win32 */
    #include <unistd.h>
    #include <sys/time.h>
    #include <sys/types.h>
    #include <sys/socket.h>
    #include <netdb.h>
    #include <netinet/in.h>
    #include <arpa/inet.h>
    #define PORT        unsigned short
    #define SOCKET    int
    #define HOSTENT  struct hostent
    #define SOCKADDR    struct sockaddr
    #define SOCKADDR_IN  struct sockaddr_in
    #define ADDRPOINTER  unsigned int*
    #define INVALID_SOCKET -1
    #define SOCKET_ERROR   -1
#endif /* _WIN32 */


#include<signal.h>

#include <iostream>
using std::cerr;
using std::endl;

#include "opencv2/opencv.hpp"
using namespace cv;

static int close_socket(SOCKET s) {
    std::cout << "close_socket function "<< endl;
    int close_output = ::shutdown(s, 1); // 0 close input, 1 close output, 2 close both
    char *buf = (char *)calloc(1024, sizeof(char));
    ::recv(s, buf, 1024, 0);
    free(buf);
    int close_input = ::shutdown(s, 0);
    int result = close(s);
    std::cerr << "Close socket: out = " << close_output << ", in = " << close_input << " \n";
    return result;
}


//struct mat_cv : cv::Mat { int a[0]; };

// void send_mjpeg(mat_cv* mat, int port, int timeout, int quality)
// {
//     try {
//         std::lock_guard<std::mutex> lock(mtx_mjpeg);
//         static MJPG_sender wri(port, timeout, quality);
//         //cv::Mat mat = cv::cvarrToMat(ipl);
//         wri.write(*(cv::Mat*)mat);
//         std::cout << " MJPEG-stream sent. \n";
//     }
//     catch (...) {
//         cerr << " Error in send_mjpeg() function \n";
//     }
// }


// =====================================================================================================================================================
class JSON_sender
{
    SOCKET sock;
    SOCKET maxfd;
    fd_set master;
    int timeout; // master sock timeout, shutdown after timeout usec.
    int close_all_sockets;

    int _write(int sock, char const*const s, int len)
    {
        if (len < 1) { len = strlen(s); }
        return ::send(sock, s, len, 0);
    }

public:

    JSON_sender(int port = 0, int _timeout = 400000)
        : sock(INVALID_SOCKET)
        , timeout(_timeout)
    {
        close_all_sockets = 0;
        FD_ZERO(&master);
        if (port)
            open(port);
    }

    ~JSON_sender()
    {
        std::cout << "exit JSON_sender "<< std::endl;
        close_all();
        release();
    }

    bool release()
    {
        if (sock != INVALID_SOCKET)
            ::shutdown(sock, 2);
        sock = (INVALID_SOCKET);
        return false;
    }

    void close_all()
    {
        close_all_sockets = 1;
        write("\n]");   // close JSON array
    }

    bool open(int port)
    {
        sock = ::socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

        SOCKADDR_IN address;
        address.sin_addr.s_addr = INADDR_ANY;
        address.sin_family = AF_INET;
        address.sin_port = htons(port);    // ::htons(port);
        int reuse = 1;
        if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (const char*)&reuse, sizeof(reuse)) < 0)
            cerr << "setsockopt(SO_REUSEADDR) failed" << endl;

        // Non-blocking sockets
        // Windows: ioctlsocket() and FIONBIO
        // Linux: fcntl() and O_NONBLOCK
#ifdef WIN32
        unsigned long i_mode = 1;
        int result = ioctlsocket(sock, FIONBIO, &i_mode);
        if (result != NO_ERROR) {
            std::cerr << "ioctlsocket(FIONBIO) failed with error: " << result << std::endl;
            signal(SIGPIPE, SIG_IGN);
        }
#else // WIN32
        ;
        // int flags = fcntl(sock, F_GETFL, 0);
        // fcntl(sock, F_SETFL, flags | O_NONBLOCK);
#endif // WIN32

#ifdef SO_REUSEPORT
        if (setsockopt(sock, SOL_SOCKET, SO_REUSEPORT, (const char*)&reuse, sizeof(reuse)) < 0){
            //signal(SIGPIPE, SIG_IGN);
            cerr << "setsockopt(SO_REUSEPORT) failed" << endl;
        }
#endif
        if (::bind(sock, (SOCKADDR*)&address, sizeof(SOCKADDR_IN)) == SOCKET_ERROR)
        {
            cerr << "error JSON_sender: couldn't bind sock " << sock << " to port " << port << "!" << endl;
            //signal(SIGPIPE, SIG_IGN);
            return release();
        }
        if (::listen(sock, 10) == SOCKET_ERROR)
        {
            cerr << "error JSON_sender: couldn't listen on sock " << sock << " on port " << port << " !" << endl;
            //signal(SIGPIPE, SIG_IGN);
            return release();
        }
        FD_ZERO(&master);
        FD_SET(sock, &master);
        maxfd = sock;
        return true;
    }

    bool isOpened()
    {
        return sock != INVALID_SOCKET;
    }

    bool write(char const* outputbuf)
    {
        fd_set rread = master;
        struct timeval select_timeout = { 0, 0 };
        struct timeval socket_timeout = { 0, timeout };
        if (::select(maxfd + 1, &rread, NULL, NULL, &select_timeout) <= 0){
            signal(SIGPIPE, SIG_IGN);
            return true; // nothing broken, there's just noone listening
        }
        
        int outlen = static_cast<int>(strlen(outputbuf));

#ifdef _WIN32
        for (unsigned i = 0; i<rread.fd_count; i++)
        {
            int addrlen = sizeof(SOCKADDR);
            SOCKET s = rread.fd_array[i];    // fd_set on win is an array, while ...
#else
        for (int s = 0; s <= maxfd; s++)
        {
            socklen_t addrlen = sizeof(SOCKADDR);
            if (!FD_ISSET(s, &rread))      // ... on linux it's a bitmask ;)
                continue;
#endif
            if (s == sock) // request on master socket, accept and send main header.
            {
                SOCKADDR_IN address = { 0 };
                SOCKET      client = ::accept(sock, (SOCKADDR*)&address, &addrlen);
                if (client == SOCKET_ERROR)
                {
                    cerr << "error JSON_sender: couldn't accept connection on sock " << sock << " !" << endl;
                    //signal(SIGPIPE, SIG_IGN);
                    return false;
                }
                if (setsockopt(client, SOL_SOCKET, SO_RCVTIMEO, (char *)&socket_timeout, sizeof(socket_timeout)) < 0) {
                    //signal(SIGPIPE, SIG_IGN);
                    cerr << "error JSON_sender: SO_RCVTIMEO setsockopt failed\n";
                }
                if (setsockopt(client, SOL_SOCKET, SO_SNDTIMEO, (char *)&socket_timeout, sizeof(socket_timeout)) < 0) {
                    //signal(SIGPIPE, SIG_IGN);
                    cerr << "error JSON_sender: SO_SNDTIMEO setsockopt failed\n";
                }
                maxfd = (maxfd>client ? maxfd : client);
                FD_SET(client, &master);
                _write(client, "HTTP/1.0 200 OK\r\n", 0);
                _write(client,
                    "Server: Mozarella/2.2\r\n"
                    "Accept-Range: bytes\r\n"
                    "Connection: close\r\n"
                    "Max-Age: 0\r\n"
                    "Expires: 0\r\n"
                    "Cache-Control: no-cache, private\r\n"
                    "Pragma: no-cache\r\n"
                    "Content-Type: application/json\r\n"
                    //"Content-Type: multipart/x-mixed-replace; boundary=boundary\r\n"
                    "\r\n", 0);
                _write(client, "[\n", 0);   // open JSON array
                int n = _write(client, outputbuf, outlen);
                cerr << "JSON_sender: new client " << client << endl;
            }
            else // existing client, just stream pix
            {
                //char head[400];
                // application/x-resource+json or application/x-collection+json -  when you are representing REST resources and collections
                // application/json or text/json or text/javascript or text/plain.
                // https://stackoverflow.com/questions/477816/what-is-the-correct-json-content-type
                //sprintf(head, "\r\nContent-Length: %zu\r\n\r\n", outlen);
                //sprintf(head, "--boundary\r\nContent-Type: application/json\r\nContent-Length: %zu\r\n\r\n", outlen);
                //_write(s, head, 0);
                if (!close_all_sockets) _write(s, ", \n", 0);
                int n = _write(s, outputbuf, outlen);
                if (n < (int)outlen)
                {
                    cerr << "JSON_sender: kill client " << s << endl;
                    //signal(SIGPIPE, SIG_IGN);
                    //close_socket(s);
                    //::shutdown(s, 2);
                    FD_CLR(s, &master);
                }

                if (close_all_sockets) {
                    int result = close_socket(s);
                    cerr << "JSON_sender: close clinet: " << result << " \n";
                    //signal(SIGPIPE, SIG_IGN);
                    continue;
                }
            }
        }
        if (close_all_sockets) {
            int result = close_socket(sock);
            cerr << "JSON_sender: close acceptor: " << result << " \n\n";
        }
        return true;
        }
};
// ----------------------------------------


int main()
{
    static std::unique_ptr<JSON_sender> js_ptr;
    //static std::mutex mtx;


    while(1)
    {
        try{
            if(!js_ptr) js_ptr.reset(new JSON_sender(22221, 400000));
            
            js_ptr->write("hello world");
            std::cout << " JSON-stream sent. \n";
        }catch (...) {
            std::cout << " Error in send_json() function \n";
        }   
        

    }
    std::cout << "finish" << std::endl;
    return 0;
}

打开浏览器，输入ip地址:22221，就可以看到推送的json流了

二、C++推送图片流

C++代码：

//
// a single-threaded, multi client(using select), debug webserver - streaming out mjpg.
//  on win, _WIN32 has to be defined, must link against ws2_32.lib (socks on linux are for free)
//

//
// socket related abstractions:
//
#ifdef _WIN32  
    #include <winsock.h>
    #include <windows.h>
    #include <time.h>
    #define PORT        unsigned long
    #define ADDRPOINTER   int*
    struct _INIT_W32DATA
    {
       WSADATA w;
       _INIT_W32DATA() { WSAStartup( MAKEWORD( 2, 1 ), &w ); }
    } _init_once;
#else       /* ! win32 */
    #include <unistd.h>
    #include <sys/time.h>
    #include <sys/types.h>
    #include <sys/socket.h>
    #include <netdb.h>
    #include <netinet/in.h>
    #include <arpa/inet.h>
    #define PORT        unsigned short
    #define SOCKET    int
    #define HOSTENT  struct hostent
    #define SOCKADDR    struct sockaddr
    #define SOCKADDR_IN  struct sockaddr_in
    #define ADDRPOINTER  unsigned int*
    #define INVALID_SOCKET -1
    #define SOCKET_ERROR   -1
#endif /* _WIN32 */


#include<signal.h>

#include <iostream>
using std::cerr;
using std::endl;

#include "opencv2/opencv.hpp"
using namespace cv;

// static int close_socket(SOCKET s) {
    // int close_output = ::shutdown(s, 1); // 0 close input, 1 close output, 2 close both
    // char *buf = (char *)calloc(1024, sizeof(char));
    // ::recv(s, buf, 1024, 0);
    // free(buf);
    // int close_input = ::shutdown(s, 0);
    // int result = close(s);
    // std::cerr << "Close socket: out = " << close_output << ", in = " << close_input << " \n";
    // return result;
// }


class MJPG_sender
{
    SOCKET sock;
    SOCKET maxfd;
    fd_set master;
    int timeout; // master sock timeout, shutdown after timeout usec.
    int quality; // jpeg compression [1..100]
    int close_all_sockets;

    int _write(int sock, char const*const s, int len)
    {
        if (len < 1) { len = strlen(s); }
        return ::send(sock, s, len, 0);
    }

public:

    MJPG_sender(int port = 0, int _timeout = 400000, int _quality = 30)
        : sock(INVALID_SOCKET)
        , timeout(_timeout)
        , quality(_quality)
    {
        close_all_sockets = 0;
        FD_ZERO(&master);
        if (port)
            open(port);
    }

    ~MJPG_sender()
    {
        //close_all();
        release();
    }

    bool release()
    {
        if (sock != INVALID_SOCKET)
            ::shutdown(sock, 2);
        sock = (INVALID_SOCKET);
        return false;
    }

    void close_all()
    {
        close_all_sockets = 1;
        cv::Mat tmp(cv::Size(10, 10), CV_8UC3);
        write(tmp);
    }

    bool open(int port)
    {
        sock = ::socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

        SOCKADDR_IN address;
        address.sin_addr.s_addr = INADDR_ANY;
        address.sin_family = AF_INET;
        address.sin_port = htons(port);    // ::htons(port);
        int reuse = 1;
        if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (const char*)&reuse, sizeof(reuse)) < 0)
            cerr << "setsockopt(SO_REUSEADDR) failed" << endl;
            signal(SIGPIPE, SIG_IGN);

        // Non-blocking sockets
        // Windows: ioctlsocket() and FIONBIO
        // Linux: fcntl() and O_NONBLOCK
#ifdef WIN32
        unsigned long i_mode = 1;
        int result = ioctlsocket(sock, FIONBIO, &i_mode);
        if (result != NO_ERROR) {
            std::cerr << "ioctlsocket(FIONBIO) failed with error: " << result << std::endl;
            signal(SIGPIPE, SIG_IGN);
        }
#else // WIN32
        ;
        // int flags = fcntl(sock, F_GETFL, 0);
        // fcntl(sock, F_SETFL, flags | O_NONBLOCK);
#endif // WIN32

#ifdef SO_REUSEPORT
        if (setsockopt(sock, SOL_SOCKET, SO_REUSEPORT, (const char*)&reuse, sizeof(reuse)) < 0)
            cerr << "setsockopt(SO_REUSEPORT) failed" << endl;
            signal(SIGPIPE, SIG_IGN);
#endif
        if (::bind(sock, (SOCKADDR*)&address, sizeof(SOCKADDR_IN)) == SOCKET_ERROR)
        {
            cerr << "error MJPG_sender: couldn't bind sock " << sock << " to port " << port << "!" << endl;
            signal(SIGPIPE, SIG_IGN);
            return release();
        }
        if (::listen(sock, 10) == SOCKET_ERROR)
        {
            cerr << "error MJPG_sender: couldn't listen on sock " << sock << " on port " << port << " !" << endl;
            signal(SIGPIPE, SIG_IGN);
            return release();
        }
        FD_ZERO(&master);
        FD_SET(sock, &master);
        maxfd = sock;
        return true;
    }

    bool isOpened()
    {
        return sock != INVALID_SOCKET;
    }

    bool write(const Mat & frame)
    {
        fd_set rread = master;
        struct timeval select_timeout = { 0, 0 };
        struct timeval socket_timeout = { 0, timeout };
        struct timeval to = {0,timeout};
        //SOCKET maxfd = sock+1;
        if (::select(maxfd+1, &rread, NULL, NULL, &to) <= 0){
            std::cout << "111111111111"<<std::endl;
            signal(SIGPIPE, SIG_IGN);
            return true; // nothing broken, there's just noone listening
        }
            


        std::vector<uchar> outbuf;
        std::vector<int> params;
        params.push_back(IMWRITE_JPEG_QUALITY);
        params.push_back(quality);
        cv::imencode(".jpg", frame, outbuf, params);  //REMOVED FOR COMPATIBILITY
        // https://docs.opencv.org/3.4/d4/da8/group__imgcodecs.html#ga292d81be8d76901bff7988d18d2b42ac
        //std::cerr << "cv::imencode call disabled!" << std::endl;
        int outlen = static_cast<int>(outbuf.size());

#ifdef _WIN32
        for (unsigned i = 0; i<rread.fd_count; i++)
        {
            //int addrlen = sizeof(SOCKADDR);
            SOCKET s = rread.fd_array[i];    // fd_set on win is an array, while ...
#else
        for (int s = 0; s <= maxfd+10; s++)
        //for(int s= 0;s<10000;s++)
        {
            socklen_t addrlen = sizeof(SOCKADDR);
            if (!FD_ISSET(s, &rread))      // ... on linux it's a bitmask ;)
                continue;
#endif
            if (s == sock) // request on master socket, accept and send main header.
            {
                std::cout << "2222222222222"<<std::endl;
                SOCKADDR_IN address = { 0 };
                SOCKET      client = ::accept(sock, (SOCKADDR*)&address, &addrlen);
                if (client == SOCKET_ERROR)
                {
                    cerr << "error MJPG_sender: couldn't accept connection on sock " << sock << " !" << endl;
                    signal(SIGPIPE, SIG_IGN);
                    return false;
                }
                // if (setsockopt(client, SOL_SOCKET, SO_RCVTIMEO, (char *)&socket_timeout, sizeof(socket_timeout)) < 0) {
                    // cerr << "error MJPG_sender: SO_RCVTIMEO setsockopt failed\n";
                // }
                // if (setsockopt(client, SOL_SOCKET, SO_SNDTIMEO, (char *)&socket_timeout, sizeof(socket_timeout)) < 0) {
                    // cerr << "error MJPG_sender: SO_SNDTIMEO setsockopt failed\n";
                // }
                maxfd = (maxfd>client ? maxfd : client);
                FD_SET(client, &master);
                _write(client, "HTTP/1.0 200 OK\r\n", 0);
                _write(client,
                    "Server: Mozarella/2.2\r\n"
                    "Accept-Range: bytes\r\n"
                    "Connection: close\r\n"
                    "Max-Age: 0\r\n"
                    "Expires: 0\r\n"
                    "Cache-Control: no-cache, private\r\n"
                    "Pragma: no-cache\r\n"
                    "Content-Type: multipart/x-mixed-replace; boundary=mjpegstream\r\n"
                    "\r\n", 0);
                cerr << "MJPG_sender: new client " << client << endl;
            }
            else // existing client, just stream pix
            {
                std::cout << "333333333333333333"<<std::endl;
                // if (close_all_sockets) {
                    // int result = close_socket(s);
                    // cerr << "MJPG_sender: close clinet: " << result << " \n";
                    // continue;
                // }

                char head[400];
                sprintf(head, "--mjpegstream\r\nContent-Type: image/jpeg\r\nContent-Length: %zu\r\n\r\n", outlen);
                _write(s, head, 0);
                int n = _write(s, (char*)(&outbuf[0]), outlen);
                cerr << "known client: " << s << ", sent = " << n << ", must be sent outlen = " << outlen << endl;
                if (n < (int)outlen)
                {
                    cerr << "MJPG_sender: kill client " << s << endl;
                    signal(SIGPIPE, SIG_IGN);
                    //::shutdown(s, 2);
                    //close_socket(s);
                    FD_CLR(s, &master);
                }
            }
        }
        // if (close_all_sockets) {
            // int result = close_socket(sock);
            // cerr << "MJPG_sender: close acceptor: " << result << " \n\n";
        // }
        return true;
    }
};
// ----------------------------------------



//struct mat_cv : cv::Mat { int a[0]; };

// void send_mjpeg(mat_cv* mat, int port, int timeout, int quality)
// {
//     try {
//         std::lock_guard<std::mutex> lock(mtx_mjpeg);
//         static MJPG_sender wri(port, timeout, quality);
//         //cv::Mat mat = cv::cvarrToMat(ipl);
//         wri.write(*(cv::Mat*)mat);
//         std::cout << " MJPEG-stream sent. \n";
//     }
//     catch (...) {
//         cerr << " Error in send_mjpeg() function \n";
//     }
// }


int main()
{
    //static std::mutex mtx_mjpeg;
    VideoCapture cap;
    bool ok = cap.open("rtsp://admin:123456@192.168.10.11:554/h264/ch01/main/av_stream");
    if ( ! ok ) 
    {
        printf("no cam found ;(.\n");
        return 1;
    }

    //MJPGWriter wri(22222); // http://your-server:7777
    
    //while( cap.isOpened() && wri.isOpened() )
    while(1)
    {
        try{
            
            Mat frame;
            cap >> frame;

            // wri.write(frame);
            // printf("ok");
            // //imshow("lalala",frame);
            // int k = waitKey(10); 
            // if ( k==27 )
            //   break;
            
            //std::lock_guard<std::mutex> lock(mtx_mjpeg);
            static MJPG_sender wri(22222, 400000, 30);
            
            //cv::Mat mat = cv::cvarrToMat(ipl);
            //wri.write(*(cv::Mat*)frame);
            try{
                wri.write(frame);
            }catch (...) {
                std::cout << " wri.write error";
            }
            
            std::cout << " MJPEG-stream sent. \n";
            //utime.sleep(1)

        }catch (...) {
            VideoCapture cap;
            bool ok = cap.open("rtsp://admin:123456@192.168.10.11:554/h264/ch01/main/av_stream");

            std::cout << " Error in send_mjpeg() function \n";
        }
            
    }
    return 0;
}

打开浏览器，输入ip地址:22222，就可以看到推送的json流了

melicent114
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c++调用ffmpeg api录屏 并进行rtmp推流
08-03
c++调用ffmpeg api录屏，并推流rtmp流
通过HTTP协议利用VC++上传图片至服务器
人的一生应当这样度过：当他回首往事时，不因虚度年华而懊悔，也不因碌碌无为而羞愧！
10-17 3008
由于项目的临时需求，需要将以前抓拍在本机的BMP图片上传至服务器。本文主要记录如何解决这个问题。我们打算用http协议来上传数据，因此要用http协议的POST方式。首先，要理解http的POST协议。它一般由三部分组成：协议头，具体内容以及协议尾。如下例所示：POST /upload_file/UploadFile HTTP/1.1Accept: text/plain, */*Accep
c++通过HTTPS以JSON数据格式微信推送消息
10-25
VC++实现通过HTTPS以JSON数据格式微信推送消息，包含HTTPS协议和JSON协议，VS2008,VS2015
基于live555库的mjpeg流传输c++代码（多播方式）
07-11
基于live555库的mjpeg流传输c++代码（多播方式） 博客地址：https://blog.csdn.net/Di_Wong/article/details/107284635 【使用说明】 1、在http://www.live555.com/ 官网下载live555库 2、将该文件下内容替换到live555库中 3、修改testMJPEGVideoStreamer.cpp中inputFileName和destinationAddress.s_addr的值 4、运行
c++调用ffmpeg api录屏 并进行udp组播推流
08-03
c++调用ffmpeg api录屏，并以udp组播的形式推流
MJPEGWriter：轻量级HTTP服务器，以C ++流式传输您的OpenCV处理
02-03
MJPEGWriter：轻量级HTTP服务器，以C ++流式传输您的OpenCV处理
C++使用http向服务器发送json数据
random_repick的专栏
07-04 2314
http json
c++编写HTTP API服务端/客户端最简单的库，没有之一
热门推荐
HW的博客
01-20 3万+
libhv是c++编写HTTP API 服务端/客户端最简单的库，没有之一。 具有以下特性： 跨平台(Windows, Linux, Mac)； 支持RESTful； 支持application/json、application/x-www-form-urlencoded、multipart/form-data； 内置web service文件服务和indexof service目录服务；
C++实现服务器发送图片
Learning
11-22 7107
C++实现服务器发送图片 这里是一个简单的图片服务器，每次向这个服务器发送请求后，都会得到一个图片。 特点： 负责发送图片的函数，接收的是string类型的值 重点： 在获取string图片的char*数据时，不能使用c_str()，应该使用data() 原因是 c_str()在获取char*类型的数据时，会将\0第一次出现的位置作为字符串结束的位置，而data()则会返回整个字符串中...
C++：发送HTTP请求(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
12-27 208
C++：发送HTTP请求(附完整源码)
以RTMP为例使用FFmpeg进行流媒体推送器.zip
最新发布
12-14
以RTMP为例使用FFmpeg进行流媒体推送器，是使用FFmpeg进行流媒体推送最简单的教程。 1.1版本增加了多平台下编译的支持：Windows，MacOS，以及Linux。
FFmpegDemo_C#推流_c++推流服务器_ffmpeg推流_ffmpeg_推流
09-11
C++调用ffmpeg推流到流媒体服务器
服务器推送(Server Push)
muwenyi的专栏
08-17 2285
专栏：CGI编程文章编号：1532文章类别： 原创作者： 萧寒雪加贴时间：2000-11-6 13:39:57Server Push详解关键词：ASP, Perl, CGI, LINUX, UNIX, NT服务器推送(Server Push) 推送技术的基础思想是将浏览器主动查询信息改为服务器主动发送信息。服务器发送一批数据，浏览器显示这些数据，同时保证
C++简单实现http服务端客户端传输实例
gls_nuaa的博客
04-30 614
C++简单实现http服务端客户端传输实例
流媒体服务器ZLMediaKit
m0_60259116的博客
07-16 5849
流媒体服务器ZLMediaKit
C/C++-----------http协议发送字段，文件，单个和多张图片
weixin_34220963的博客
09-01 408
           关于c/c++ 网络编程，无论在linux还是windows,要说到自由性，和安全性，socket无疑是比较好的！对于socket,因为它的传输协议只有两种tcp和udp,属于网络层，这里我们不去重点讨论。 　　     关于应用层协议http,如何用C/C++的socket来实现数据传输和下载呢？    1. http是超文本协议，用在html文件中，那么对于html是...
C++ http服务器和客户端代码
书生也疯狂
10-09 1326
服务器代码 SOCKET clientSocket=socket(AF_INET,SOCK_STREAM,0); int send_len = 0; int recv_len = 0; //定义服务端套接字，接受请求套接字 SOCKET s_server; //服务端地址客户端地址 SOCKADDR_IN server_addr; //初始化套接字库 WSADATA wsadat...
C++实现WebSocket功能及WebSocket协议详解（附代码websocketfiles）
贝松的博客
09-28 2万+
1. C++实现WebSocket功能的一些参考和建议 1.1 背景 项目中会遇到让已有的C++服务端程序增加WebSocket协议支持，与前端进行通讯。Github上有不少开源的C++代码可以参考，比较知名的如websocketcpp，beast， uWebSockets，restbed等等，不过即便有这些代码参考，也难以快速移植程序到你的现在的C++服务器端程序里，原因大致有下面几点： ...
python获取一张图像或者一个视频中某一点的像素坐标及对应的像素值
G的博客
10-22 9639
import cv2 from pylab import * from PIL import Image import sys user_input = input("如果标视频，请输入1 ；如果标图片，请输入2: ") print("您输入的是：", user_input) def video_flag(): frame = 0 cap = cv2.VideoCapture("E:/JYKJ/20200904coal_volume_video/test-6500-20200912-01
c++ 实现 fmpeg的推流rtmp +http
05-08
FFmpeg是一款开源的音视频处理工具，可以进行音视频的录制、编码、解码、转码、推流等操作。在FFmpeg中，推流操作使用了rtmp和http协议，本文介绍如何使用FFmpeg实现推流到rtmp和http。 首先，我们需要下载FFmpeg工具。在Windows系统中，可以通过命令行或者下载Windows版本的FFmpeg.exe直接进行操作。在Linux系统中，可以通过源码安装FFmpeg，也可以直接使用yum安装。安装完毕之后，我们就可以进行推流操作了。 具体操作步骤如下： 1. 打开命令行工具，输入ffmpeg -i xxx (xxx为要您要推流的文件路径) -c:v xxx (xxx为要采用的视频编码器) -c:a xxx (xxx为要采用的音频编码器) -f flv rtmp://xxx (xxx为您要推流的rtmp地址)，这样就可以将视频推送到rtmp服务器上。推流到http服务器上的命令类似，只需要将rtmp://xxx换成http://xxx即可。 2. 推流到多个rtmp服务器的方法：我们可以使用FFmpeg提供的copy和split指令实现推流到多个rtmp服务器。首先，在命令行中输入ffmpeg -i xxx (xxx为您要推流的文件路径) -c:v xxx (xxx为要采用的视频编码器) -c:a xxx (xxx为要采用的音频编码器) -f flv -c copy (使用copy指令将数据复制到一个输出流上) -fflags +split (使用split指令实现数据复制) "[f=flv]rtmp://xxx1|[f=flv]rtmp://xxx2"，这样就可以将视频同时推流到两个rtmp服务器上。 3. 推流到授权服务器上的方法：有些rtmp和http服务器需要授权才能进行操作。在这种情况下，我们可以使用FFmpeg提供的HTTP认证模块，来实现推流到授权服务器上。在命令行中输入ffmpeg -i xxx (xxx为您要推流的文件路径) -c:v xxx (xxx为要采用的视频编码器) -c:a xxx (xxx为要采用的音频编码器) -f flv -headers "Authorization: Basic xxx" rtmp://xxx (xxx为带有授权的rtmp服务器地址)，这样就可以实现推流到带有授权的rtmp服务器上。 总之，FFmpeg是一个非常强大的音视频处理工具，可以实现非常多样化的操作。通过掌握上述几种方法，您可以轻松地实现推流到rtmp和http服务器上。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值