FFmpeg提取视频参数，以及剪辑视频，拼接视频，合并视频，抽帧等

FFmpeg提取视频参数，以及剪辑视频，拼接视频，合并视频，抽帧等

  • 视频封面图获取
    • 视频

视频封面图获取


#ifndef _BUFFER_CONTAINER_H_
#define _BUFFER_CONTAINER_H_
#include <Memory>



template <typename T>
class BufferContainer
{
public:

    /**
     * @brief Construct a new Buffer Container object 构造函数赋值拷贝内存
     *
     * @param t1
     * @param length
     */
    BufferContainer()
    {

        m_buffer = nullptr;
        m_length = 0;

    }
    /**
     * @brief Construct a new Buffer Container object 构造函数赋值拷贝内存
     *
     * @param t1
     * @param length
     */
    BufferContainer(const T &t1, int length)
    {
        if (t1 && length > 0)
        {
            m_buffer = new T[length];
            memset(m_buffer,0,length* sizeof(T));
            m_length = length;
            memcpy(m_buffer, &t1, length * sizeof(T));
        }
    }
   void setData(T*pData,int length){

        if(pData&&m_buffer){
            delete [] m_buffer;
            m_buffer=nullptr;
        }
        if(length>0&&m_length>0){
                m_length=0;
        }
       m_buffer=new T[length];
       memset(m_buffer,0,length* sizeof(T));
       m_length = length;
       memcpy(m_buffer, pData, length * sizeof(T));

   }

    /**
     * @brief Construct a new Buffer Container object 深拷贝构造函数
     *
     * @param other
     */
    BufferContainer(const BufferContainer &other)
    {
        if (other.m_buffer && other.m_length > 0)
        {
            m_buffer = new T[other.m_length];
            memset(m_buffer,0,other.m_length* sizeof(T));
            m_length = other.m_length;
            memcpy(m_buffer, other.m_buffer, other.m_length * sizeof(T));
        }
    }
    /**
     * @brief Destroy the Buffer Container object  析构函数
     *
     */
    ~BufferContainer()
    {
        if (m_buffer)
        {
            delete[] m_buffer;
            m_buffer = nullptr;
            m_length = 0;
        }
    }
    /**
     * @brief  赋值操作符重载
     *
     * @param other
     * @return BufferContainer&
     */
    BufferContainer &operator=(const BufferContainer &other)
    {
//        if (this != other)
        {
            delete[] m_buffer;
            m_buffer = nullptr;
            m_length = 0;
            if (other.m_buffer)
            {
                m_buffer = new T[other.m_length];
                 memset(m_buffer,0,other.m_length* sizeof(T));
                m_length = other.m_length;
                memcpy(m_buffer, other.m_buffer, sizeof(T) * other.m_length);
            }
        }

        return *this;
    }

    /**
     * @brief 返回数据指针
     *
     * @return T*
     */
    T *data()
    {
        return m_buffer;
    }
    /**
     * @brief 返回数据长度
     *
     * @return int
     */
    int length()
    {
        return m_length;
    }

private:
    T *m_buffer = nullptr;
    int m_length = 0;
};

#endif //_BUFFER_CONTAINER_H_



BufferContainer<unsigned char> VideoEditerBase::thumbnail(const std::string& filePath)
{
	av_register_all();
	BufferContainer<unsigned char> result;

	AVFormatContext* fmtContext = nullptr;
	if (avformat_open_input(&fmtContext, filePath.c_str(), nullptr, nullptr) < 0) {
		return result;
	}
	if (avformat_find_stream_info(fmtContext, nullptr) < 0) {
		avformat_close_input(&fmtContext);
		return result;
	}
	int nStreamIndex = -1;
	AVCodecParameters* codecParameters = nullptr;
	for (int i = 0; i < fmtContext->nb_streams; i++) {
		if (fmtContext->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
			nStreamIndex = i;
			codecParameters = fmtContext->streams[i]->codecpar;
			break;
		}
	}
	if (nStreamIndex == -1) {
		avformat_close_input(&fmtContext);
		return result;
	}
	AVCodec* codec = avcodec_find_decoder(codecParameters->codec_id);

	if (!codec) {
		avformat_close_input(&fmtContext);
		return result;
	}
	AVCodecContext* codecContext = avcodec_alloc_context3(codec);
	if (!codecContext) {
		// ���������������ʧ��
		avformat_close_input(&fmtContext);
		return result;
	}
	if (avcodec_parameters_to_context(codecContext, codecParameters) < 0) {
		// ���ƽ�����������������������ʧ��
		avcodec_free_context(&codecContext);
		avformat_close_input(&fmtContext);
		return result;
	}
	if (avcodec_open2(codecContext, codec, nullptr) < 0) {
		// �򿪽�����ʧ��
		avcodec_free_context(&codecContext);
		avformat_close_input(&fmtContext);
		return result;
	}
	AVPacket packet;
	av_init_packet(&packet);
	packet.data = nullptr;
	packet.size = 0;
	//    bool getFlag=true;
	int frameFinished = 0;
	AVFrame* frame = av_frame_alloc();
	while (av_read_frame(fmtContext, &packet) >= 0) {
		if (packet.stream_index != nStreamIndex) {
			continue;
		}
		int ret = avcodec_decode_video2(codecContext, frame, &frameFinished, &packet);
		if (!frameFinished) {
			continue;
		}
		if (frame) {
			int ret = avcodec_send_packet(codecContext, &packet);
			if (ret >= 0) {
				ret = avcodec_receive_frame(codecContext, frame);
				if (ret >= 0) {
					// ����һ֡����Ϊ����ͼ��
					if (frame->key_frame) {
						AVFrame* rgbFrame = av_frame_alloc();
						if (rgbFrame) {
							rgbFrame->format = AV_PIX_FMT_RGB24;
							rgbFrame->width = frame->width;
							rgbFrame->height = frame->height;

							int bufferSize = av_image_get_buffer_size(AV_PIX_FMT_RGB24, frame->width, frame->height, 1);
							uint8_t* buffer = new uint8_t[bufferSize];
							av_image_fill_arrays(rgbFrame->data, rgbFrame->linesize, buffer, AV_PIX_FMT_RGB24, frame->width, frame->height, 1);

							SwsContext* swsContext = sws_getContext(frame->width, frame->height, codecContext->pix_fmt,
								frame->width, frame->height, AV_PIX_FMT_RGB24, SWS_BICUBIC, nullptr, nullptr, nullptr);
							if (swsContext) {
								sws_scale(swsContext, frame->data, frame->linesize, 0, frame->height, rgbFrame->data, rgbFrame->linesize);
								sws_freeContext(swsContext);

								// �������ͼ���ļ�
								int outputBufferSize = rgbFrame->width * rgbFrame->height * 3;
								unsigned char* outputBuffer = new unsigned char[outputBufferSize];

								for (int i = 0; i < rgbFrame->height; i++) {
									memcpy(outputBuffer + i * rgbFrame->width * 3, rgbFrame->data[0] + i * rgbFrame->linesize[0], rgbFrame->width * 3);
								}
								//                                static int index=0;
								//                                QImage(outputBuffer, rgbFrame->width, rgbFrame->height, QImage::Format_RGB888).copy().save(QString("E:/workspace/build-VideoCodec-Desktop_Qt_5_7_1_MSVC2015_64bit-Debug/debug/%1.jpg").arg(index++));

								result.setData(outputBuffer, outputBufferSize);
								if (outputBuffer) {
									delete[] outputBuffer;
									outputBuffer = nullptr;
								}

							}

							if (buffer) {
								delete[] buffer;
								buffer = nullptr;
							}

							av_frame_free(&rgbFrame);
						}
					}
				}
			}

		}
		av_packet_unref(&packet);
		break;
		
	}

	av_frame_free(&frame);
	avcodec_free_context(&codecContext);
	avformat_close_input(&fmtContext);
	return result;

}

视频

#include "videoeditermp4.h"
#include <QDebug>
extern "C" {
#include "libavformat/avformat.h"
#include "libavcodec/avcodec.h"
#include "libavutil/imgutils.h"
#include "libavutil/opt.h"
#include "libswresample/swresample.h"
#include "libswscale/swscale.h"
}
VideoEditerMp4::VideoEditerMp4()
{

}
VideoEditerMp4::~VideoEditerMp4() {
    stop();
}
void VideoEditerMp4::startClip(std::string input, std::string output, int64_t st, int64_t et)
{
    if(!m_vecInputPaths.empty()){
        m_vecInputPaths.clear();
    }
    //    stop();
    m_vecInputPaths.push_back(input);
    m_outputPath = output;
    m_startTime = st;
    m_endTime = et;
    m_pThread = new std::thread(&VideoEditerMp4::runClip, this);

    m_pThread->detach();
}

void VideoEditerMp4::startMerge(std::vector<std::string>inputs, std::string output)
{
	if (!m_vecInputPaths.empty()) {
		m_vecInputPaths.clear();
	}
	//    stop();
	m_vecInputPaths=inputs;
	m_outputPath = output;
    m_pThread = new std::thread(&VideoEditerMp4::runMerge, this);

	m_pThread->detach();
}

void VideoEditerMp4::runClip()
{
    stateCallBack(RUNNING);

    if (m_vecInputPaths.empty() || m_outputPath.empty()) {

        stateCallBack(FAIL);
        return;
    }
    AVFormatContext* fmtContext = avformat_alloc_context();
    if (avformat_open_input(&fmtContext,m_vecInputPaths.front().c_str() , nullptr, nullptr) < 0) {
        //fprintf(stderr, "�޷��򿪵�һ�������ļ�\n");

        stateCallBack(FAIL);
        return ;
    }
    if (avformat_find_stream_info(fmtContext, nullptr) < 0) {
        //fprintf(stderr, "�޷��ҵ���һ�������ļ�������Ϣ\n");
        avformat_close_input(&fmtContext);

        stateCallBack(FAIL);
        return ;
    }


    int videoStreamIndex = -1;
    for (int i = 0; i < fmtContext->nb_streams; i++) {
        if (fmtContext->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
            videoStreamIndex = i;
            break;
        }
    }

    int audioStreamIndex = -1;
    for (int i = 0; i < fmtContext->nb_streams; i++) {
        if (fmtContext->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
            audioStreamIndex = i;
            break;
        }
    }

    AVFormatContext* output_format_ctx = nullptr;
    if (avformat_alloc_output_context2(&output_format_ctx, nullptr, nullptr, m_outputPath.c_str()))
    {
        avformat_close_input(&fmtContext);
        stateCallBack(FAIL);
        return;
    }
    // ���������ļ�����
    for (int i = 0; i < fmtContext->nb_streams; i++) {
        AVStream* stream = avformat_new_stream(output_format_ctx, nullptr);
        if (!stream) {
            avformat_close_input(&fmtContext);
            avformat_close_input(&output_format_ctx);
            stateCallBack(FAIL);
            return;
        }
        //        stream->time_base=fmtContext->streams[videoStreamIndex]->time_base;
        //        stream->duration=(m_endTime-m_startTime);

        if (avcodec_copy_context(stream->codec, fmtContext->streams[i]->codec)<0) {
            avformat_close_input(&fmtContext);
            avformat_close_input(&output_format_ctx);
            stateCallBack(FAIL);
            return;
        }

        if (avcodec_parameters_copy(stream->codecpar, fmtContext->streams[i]->codecpar) < 0) {
            avformat_close_input(&fmtContext);
            avformat_close_input(&output_format_ctx);
            stateCallBack(FAIL);
            return;
        }


    }
    // ������ļ�
    if (!(output_format_ctx->oformat->flags & AVFMT_NOFILE)) {
        if (avio_open(&output_format_ctx->pb, m_outputPath.c_str(), AVIO_FLAG_WRITE) < 0) {
            //            fprintf(stderr, "�޷�������ļ�\n");

            avformat_close_input(&fmtContext);
            avformat_close_input(&output_format_ctx);

            stateCallBack(FAIL);
            return ;
        }
    }


    // д���ļ�ͷ
    if (avformat_write_header(output_format_ctx, nullptr) < 0) {
        //fprintf(stderr, "�޷�д������ļ�ͷ\n");
        avformat_close_input(&fmtContext);
        avformat_close_input(&output_format_ctx);
        stateCallBack(FAIL);
        return ;
    }


    int64_t videoIndex = 0;
    int64_t audioIndex = 0;

    AVRational  timeBase=fmtContext->streams[videoStreamIndex]->time_base;


    AVPacket packet;
    while (true)
    {
        //����Ƿ�ֹͣ
        if (m_bStop) {

            break;
        }
        if (av_read_frame(fmtContext, &packet) < 0) {

            break;
        }
        if (packet.stream_index == audioStreamIndex) {
            if (packet.pts*av_q2d(timeBase)>= m_startTime && packet.pts*av_q2d(timeBase)<= m_endTime) {
                if (audioIndex % m_interval == 0) {
                    if(audioIndex==0){
                        packet.pts = av_rescale_q(0, timeBase, output_format_ctx->streams[videoStreamIndex]->time_base);
                        packet.dts = av_rescale_q(0, timeBase,  output_format_ctx->streams[videoStreamIndex]->time_base);
                    }else{
                        packet.pts = av_rescale_q(packet.pts-m_startTime/av_q2d(timeBase), timeBase, output_format_ctx->streams[videoStreamIndex]->time_base);
                        packet.dts = av_rescale_q(packet.dts -m_startTime/av_q2d(timeBase), timeBase,  output_format_ctx->streams[videoStreamIndex]->time_base);
                    }

                    packet.duration = av_rescale_q(packet.duration, timeBase,  output_format_ctx->streams[videoStreamIndex]->time_base);
                    av_write_frame(output_format_ctx, &packet);
                    audioIndex++;
                    continue;
                    av_packet_unref(&packet);
                }
                audioIndex++;
            }
        }

        if (packet.stream_index == videoStreamIndex) {
            if (packet.pts*av_q2d(timeBase)>= m_startTime && packet.pts*av_q2d(timeBase)<= m_endTime) {
                qDebug()<<"============>sec:"<<packet.pts*av_q2d(timeBase)<<"<==============";
                if (videoIndex % m_interval == 0) {
                    //                    packet.pts = packet.pts-m_startTime/av_q2d(timeBase);
                    //                    packet.dts = packet.pts;
                    packet.pts = av_rescale_q(packet.pts-m_startTime/av_q2d(timeBase), timeBase, output_format_ctx->streams[videoStreamIndex]->time_base);
                    packet.dts = av_rescale_q(packet.dts -m_startTime/av_q2d(timeBase), timeBase,  output_format_ctx->streams[videoStreamIndex]->time_base);
                    packet.duration = av_rescale_q(packet.duration, timeBase,  output_format_ctx->streams[videoStreamIndex]->time_base);
                    av_write_frame(output_format_ctx, &packet);
                    videoIndex++;
                    av_packet_unref(&packet);
                    continue;
                }
                videoIndex++;
            }
        }

        av_packet_unref(&packet);


        // ����Ƿ���ͣ
        {
            std::unique_lock<std::mutex> lock(m_mutex);
            cv.wait(lock, [this]{
                if (m_bPaused) {
                    stateCallBack(PAUSE);
                }
                return !m_bPaused; });
        }
    }

    // д���ļ�β
    av_write_trailer(output_format_ctx);
    // �ر��ļ�
    avformat_close_input(&fmtContext);
    avio_close(output_format_ctx->pb);
    avformat_free_context(output_format_ctx);
    if (m_bStop) {
        stateCallBack(STOP);
        return;
    }
    stateCallBack(FINISH);
}

void VideoEditerMp4::runMerge()
{
    stateCallBack(RUNNING);

    if (m_vecInputPaths.empty() || m_outputPath.empty()) {

        stateCallBack(FAIL);
        return;
    }
    AVFormatContext* fmtContext = avformat_alloc_context();
    if (avformat_open_input(&fmtContext,m_vecInputPaths.front().c_str() , nullptr, nullptr) < 0) {
        //fprintf(stderr, "�޷��򿪵�һ�������ļ�\n");

        stateCallBack(FAIL);
        return ;
    }
    if (avformat_find_stream_info(fmtContext, nullptr) < 0) {
        //fprintf(stderr, "�޷��ҵ���һ�������ļ�������Ϣ\n");
        avformat_close_input(&fmtContext);

        stateCallBack(FAIL);
        return ;
    }


    int videoStreamIndex = -1;
    for (int i = 0; i < fmtContext->nb_streams; i++) {
        if (fmtContext->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
            videoStreamIndex = i;
            break;
        }
    }

    int audioStreamIndex = -1;
    for (int i = 0; i < fmtContext->nb_streams; i++) {
        if (fmtContext->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
            audioStreamIndex = i;
            break;
        }
    }

    AVFormatContext* output_format_ctx = nullptr;
    if (avformat_alloc_output_context2(&output_format_ctx, nullptr, nullptr, m_outputPath.c_str()))
    {
        avformat_close_input(&fmtContext);
        stateCallBack(FAIL);
        return;
    }
    // ���������ļ�����
    for (int i = 0; i < fmtContext->nb_streams; i++) {
        AVStream* stream = avformat_new_stream(output_format_ctx, nullptr);
        if (!stream) {
            avformat_close_input(&fmtContext);
            avformat_close_input(&output_format_ctx);
            stateCallBack(FAIL);
            return;
        }
        //        stream->time_base=fmtContext->streams[videoStreamIndex]->time_base;
        //        stream->duration=(m_endTime-m_startTime);

        if (avcodec_copy_context(stream->codec, fmtContext->streams[i]->codec)<0) {
            avformat_close_input(&fmtContext);
            avformat_close_input(&output_format_ctx);
            stateCallBack(FAIL);
            return;
        }

        if (avcodec_parameters_copy(stream->codecpar, fmtContext->streams[i]->codecpar) < 0) {
            avformat_close_input(&fmtContext);
            avformat_close_input(&output_format_ctx);
            stateCallBack(FAIL);
            return;
        }


    }
    // ������ļ�
    if (!(output_format_ctx->oformat->flags & AVFMT_NOFILE)) {
        if (avio_open(&output_format_ctx->pb, m_outputPath.c_str(), AVIO_FLAG_WRITE) < 0) {
            //            fprintf(stderr, "�޷�������ļ�\n");

            avformat_close_input(&fmtContext);
            avformat_close_input(&output_format_ctx);

            stateCallBack(FAIL);
            return ;
        }
    }


    // д���ļ�ͷ
    if (avformat_write_header(output_format_ctx, nullptr) < 0) {
        //fprintf(stderr, "�޷�д������ļ�ͷ\n");
        avformat_close_input(&fmtContext);
        avformat_close_input(&output_format_ctx);
        stateCallBack(FAIL);
        return ;
    }


    int64_t videoIndex = 0;
    int64_t audioIndex = 0;

    AVRational  timeBase=fmtContext->streams[videoStreamIndex]->time_base;

    int64_t currentPts=0;
    AVPacket packet;
    for(int k=0;k<m_vecInputPaths.size();k++){
        //����Ƿ�ֹͣ
        if (m_bStop) {

            break;
        }


        avformat_close_input(&fmtContext);

        if (avformat_open_input(&fmtContext,m_vecInputPaths.at(k).c_str() , nullptr, nullptr) < 0) {
            //fprintf(stderr, "�޷��򿪵�һ�������ļ�\n");

            stateCallBack(FAIL);
            return ;
        }
        if (avformat_find_stream_info(fmtContext, nullptr) < 0) {
            //fprintf(stderr, "�޷��ҵ���һ�������ļ�������Ϣ\n");
            avformat_close_input(&fmtContext);

            stateCallBack(FAIL);
            return ;
        }


        int videoStreamIndex = -1;
        for (int i = 0; i < fmtContext->nb_streams; i++) {
            if (fmtContext->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
                videoStreamIndex = i;
                break;
            }
        }

        int audioStreamIndex = -1;
        for (int i = 0; i < fmtContext->nb_streams; i++) {
            if (fmtContext->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
                audioStreamIndex = i;
                break;
            }
        }

        if(k!=0){
            currentPts+=(fmtContext->streams[videoStreamIndex]->duration/1000)/av_q2d(timeBase);
        }
        while (true)
        {
            //����Ƿ�ֹͣ
            if (m_bStop) {

                break;
            }
            if (av_read_frame(fmtContext, &packet) < 0) {

                break;
            }
            if (packet.stream_index == audioStreamIndex) {
                //if (packet.pts*av_q2d(timeBase)>= m_startTime && packet.pts*av_q2d(timeBase)<= m_endTime) {
                    if (audioIndex % m_interval == 0) {
                        if(audioIndex==0){
                            packet.pts = av_rescale_q(0, timeBase, output_format_ctx->streams[videoStreamIndex]->time_base);
                            packet.dts = av_rescale_q(0, timeBase,  output_format_ctx->streams[videoStreamIndex]->time_base);
                        }else{
                            packet.pts = av_rescale_q(packet.pts+currentPts, timeBase, output_format_ctx->streams[videoStreamIndex]->time_base);
                            packet.dts = av_rescale_q(packet.dts+currentPts, timeBase,  output_format_ctx->streams[videoStreamIndex]->time_base);
                        }

                        packet.duration = av_rescale_q(packet.duration, timeBase,  output_format_ctx->streams[videoStreamIndex]->time_base);
                        av_write_frame(output_format_ctx, &packet);
                        audioIndex++;
                        continue;
                        av_packet_unref(&packet);
                    }
                    audioIndex++;
                //}
            }

            if (packet.stream_index == videoStreamIndex) {
                //if (packet.pts*av_q2d(timeBase)>= m_startTime && packet.pts*av_q2d(timeBase)<= m_endTime) {
                    qDebug()<<"============>sec:"<<packet.pts*av_q2d(timeBase)<<"<==============";
                    if (videoIndex % m_interval == 0) {
                        //                    packet.pts = packet.pts-m_startTime/av_q2d(timeBase);
                        //                    packet.dts = packet.pts;
                        if(videoIndex==0){
                            packet.pts = av_rescale_q(0, timeBase, output_format_ctx->streams[videoStreamIndex]->time_base);
                            packet.dts = av_rescale_q(0, timeBase,  output_format_ctx->streams[videoStreamIndex]->time_base);
                        }else{
                            packet.pts = av_rescale_q(packet.pts+currentPts, timeBase, output_format_ctx->streams[videoStreamIndex]->time_base);
                            packet.dts = av_rescale_q(packet.dts+currentPts, timeBase,  output_format_ctx->streams[videoStreamIndex]->time_base);
                        }
                        packet.duration = av_rescale_q(packet.duration, timeBase,  output_format_ctx->streams[videoStreamIndex]->time_base);
                        av_write_frame(output_format_ctx, &packet);
                        videoIndex++;
                        av_packet_unref(&packet);
                        continue;
                    }
                    videoIndex++;
                //}
            }

            av_packet_unref(&packet);


            // ����Ƿ���ͣ
            {
                std::unique_lock<std::mutex> lock(m_mutex);
                cv.wait(lock, [this]{
                    if (m_bPaused) {
                        stateCallBack(PAUSE);
                    }
                    return !m_bPaused; });
            }
        }


    }



    // д���ļ�β
    av_write_trailer(output_format_ctx);
    // �ر��ļ�
    avformat_close_input(&fmtContext);
    avio_close(output_format_ctx->pb);
    avformat_free_context(output_format_ctx);
    if (m_bStop) {
        stateCallBack(STOP);
        return;
    }
    stateCallBack(FINISH);
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mfbz.cn/a/606243.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

分享5个免费AI一键生成毕业论文的网站

分享5个免费AI一键生成毕业论文的网站

一、引言 对于忙碌的学生来说&#xff0c;毕业论文通常是一项艰巨的任务。幸运的是&#xff0c;随着人工智能技术的发展&#xff0c;现在有一些工具可以帮助学生轻松完成论文。本文将介绍五个免费的AI工具&#xff0c;它们能够一键帮助你生成毕业论文&#xff0c;让你的学术生…
阅读更多...
Linux流程控制

Linux流程控制

if语句 基本格式 if condition thencommand1 fi 写成一行 if [ $(ps -ef | grep -c "ssh") -gt 1 ]; then echo "true"; fi if-else语句 格式 if condition thencommand1 command2...commandN elsecommand fi if else- if else if condition1 th…
阅读更多...
wordpress忘记后台密码，在数据库中修改回来，然后再修改回去。

wordpress忘记后台密码，在数据库中修改回来，然后再修改回去。

源地址&#xff1a;https://www.ctvol.com/seoomethods/1421332.html 我们在做wordpess运维的时候&#xff0c;都会遇到很尴尬的时候&#xff0c;有时候在错误运维中&#xff0c;不知道删除了什么东西&#xff0c;造成wordpress后台不能登录&#xff0c;后台页面也直接失效&am…
阅读更多...
Google Chrome浏览器便携增强版 v124.0.6367.61

Google Chrome浏览器便携增强版 v124.0.6367.61

01 软件介绍 Google Chrome v124.0.6367.61&#xff0c;这一版本经过精心设计&#xff0c;集成了一系列的功能增强和关键补丁&#xff0c;旨在提升用户体验。其中&#xff0c;Chrome引入了便携性数据保存选项&#xff0c;优化了标签页及标签栏的操作机制。此外&#xff0c;它还…
阅读更多...
互联网黑话知所多少？

互联网黑话知所多少？

互联网黑话是互联网公司形成的一套带有浓厚互联网行业特色的“非正式语言”。这些黑话通常起源于社交媒体、网络论坛、技术博客以及职场交流中&#xff0c;它们可能是缩写词、行业术语、梗或者其它专业领域的词汇。来盘一盘你常听、常用的互联网黑话都有哪些吧&#xff01;
阅读更多...
分布式与一致性协议之ZAB协议(七)

分布式与一致性协议之ZAB协议(七)

ZAB协议 ZAB协议:如何处理读写请求 你应该有这样的体会&#xff0c;如果你想了解一个网络服务&#xff0c;执行的第一个功能肯定是写操作&#xff0c;然后才会执行读操作。比如&#xff0c;你要了解ZooKeeper&#xff0c;那么肯定会在zkClient.sh命令行中执行写操作(比如crea…
阅读更多...
SAP PP学习笔记09 - 作业区（工作中心Work Center）Customize2（管理码，班次顺序，计算式），标准Text，作业区阶层

SAP PP学习笔记09 - 作业区（工作中心Work Center）Customize2（管理码，班次顺序，计算式），标准Text，作业区阶层

上文讲了作业区&#xff08;工作中心&#xff09;的概念及其中重要字段&#xff0c;以及作业区的部分Customize。 SAP PP学习笔记08 - 作业区&#xff08;工作中心Work Center&#xff09;&#xff0c;作业区Customize-CSDN博客 本文继续讲 作业区的Customize。 Spro > 生…
阅读更多...
杨氏矩阵查找算法

杨氏矩阵查找算法

有一个数字矩阵&#xff0c;矩阵的每行从左到右是递增的&#xff0c;矩阵从上到下是递增的&#xff0c;请编写程序在这样的矩阵中查找某个数字是否存在。 要求&#xff1a;时间复杂度小于O(N); 1.首先更直观地了解一下杨氏矩阵&#xff1a; 123456789 这就是一个简单的杨氏矩…
阅读更多...
【Java】初识网络编程

【Java】初识网络编程

文章目录 前言✍一、互联网的发展1.独立模式2.网络的出现局域网LAN广域网WAN ✍二、网络编程概述✍三、网络编程中的术语介绍IP地址端口号协议OSI七层模型TCP\IP四层模型 ✍四、协议的层级之间是如何配合工作的 前言 在本文中&#xff0c;会对网络编程的一些术语进行解释&#…
阅读更多...
MySQL变量的声明与使用

MySQL变量的声明与使用

set userName 刘德华; SELECT userName : 刘青云; SELECT userName as 读取到的userName变量值; set x5,y7; SELECT x y as 57的结果; set dx0.55,dy2; SELECT dx dy; set result(select dx dy) SELECT result; set cityName1Kabul; SET cityName2Qandahar; SET cityName3…
阅读更多...
【Qt 开发基础体系】字符串类应用和常用的数据类型

【Qt 开发基础体系】字符串类应用和常用的数据类型

文章目录 1. Qt 字符串类应用1.1 操作字符串1.2 QString::append()函数1.3 QString::sprintf()函数1.4 QString::arg()函数 2. 查询字符串2.1 函数 QString::startsWith()2.2 函数 QString::contains()2.3 函数 QString::toInt()2.4 函数 QString::compare()2.5 将 QString 转换…
阅读更多...
RS232引脚方向及意义与接线参考

RS232引脚方向及意义与接线参考

RS232引脚方向及定义编号引脚意义方向作为IO使用说明1CD载波检测(Carrier Detect)计算机《调制解调器输入调制解调器通知计算机有载波被侦测到2RXD接收(Receive)计算机《调制解调器　接收数据3TXD发送(Transmit)计算机》调制解调器　发送数据4DTR数据终端设备(DTE)备好(Data Te…
阅读更多...
揭秘豆瓣网站爬虫：利用lua-resty-request库获取图片链接

揭秘豆瓣网站爬虫：利用lua-resty-request库获取图片链接

介绍 在网络数据采集领域&#xff0c;爬虫技术在图片获取方面具有广泛的应用。而豆瓣网站作为一个内容丰富的综合性平台&#xff0c;其图片资源也是广受关注的热点之一。本文将聚焦于如何利用Lua语言中的lua-resty-request库&#xff0c;高效地从豆瓣网站获取图片链接。我们将…
阅读更多...
RAG 检索的底座：Milvus Cloud向量数据库

RAG 检索的底座：Milvus Cloud向量数据库

在业界实践中，RAG 检索通常与向量数据库密切结合，也催生了基于 ChatGPT + Vector Database + Prompt 的 RAG 解决方案，简称为 CVP 技术栈。这一解决方案依赖于向量数据库高效检索相关信息以增强大型语言模型（LLMs），通过将 LLMs 生成的查询转换为向量，使得 RAG 系统能在向…
阅读更多...
MAcA-PEG-MAcA，Methacrylamide-PEG-Methacrylamide可作为高分子链转移剂或高分子乳化剂使用

MAcA-PEG-MAcA，Methacrylamide-PEG-Methacrylamide可作为高分子链转移剂或高分子乳化剂使用

【试剂详情】 英文名称 MAcA-PEG-MAcA&#xff0c; Methacrylamide-PEG-Methacrylamide 中文名称 聚乙二醇二苯甲醛&#xff0c; 苯甲醛-聚乙二醇-苯甲醛 外观性状 由分子量决定&#xff0c;固体或者液体。 分子量 0.4k&#xff0c;0.6k&#xff0c;1k&#xff0c;2k&am…
阅读更多...
发电机组远程管理，提升管控力，降低运维成本

发电机组远程管理，提升管控力，降低运维成本

发电机组是指发电机发动机以及控制系统的总称&#xff0c;用来把发动机提供的动能转化为电能。它通常由动力系统、控制系统、消音系统、减震系统、排气系统组成。发电机组远程管理系统利用物联网技术与PLC远程控制模块集成解决方案&#xff0c;在提高发电机组的运行效率、降低运…
阅读更多...
用于YouTube推荐的深度神经网络YouTube DNN

用于YouTube推荐的深度神经网络YouTube DNN

这篇论文是最近参加组会看的一篇新论文&#xff0c;论文虽然是2016年出的论文&#xff0c;但是它是YouTube发表的&#xff0c;且是应用在YouTube这样超级大的平台上的一篇工业界的推荐系统的论文&#xff0c;我读完之后也觉得论文有一些可取之处的&#xff0c;所以和大家分享一…
阅读更多...
【Chrome实用命令笔记】

【Chrome实用命令笔记】

文章目录 Chrome实用命令笔记1、chrome基本介绍2. 打开开发者工具&#xff08;DevTools&#xff09;方法一&#xff1a;快捷键方法二&#xff1a;右键菜单方法三&#xff1a;浏览器设置 2. 开发者工具面板Elements面板Console面板Sources面板Network面板Performance面板Memory面…
阅读更多...
数据结构：图

数据结构：图

数据结构&#xff1a;图 前言 在自动化程序分析中&#xff0c;图和树的一些算法起到了至关重要的作用&#xff0c;所以在开始自动化程序分析的研究前&#xff0c;我用了两天复习了一遍数据结构中的图。本章主要内容有图的基本概念&#xff0c;图的存储和图相关的经典算法&…
阅读更多...
十二届蓝桥杯Python组1月中/高级试题 第五题

十二届蓝桥杯Python组1月中/高级试题 第五题

** 十二届蓝桥杯Python组1月中/高级试题 第五题 ** 第五题&#xff08;难度系数 5&#xff0c;35 个计分点&#xff09; 提示信息&#xff1a; 平均数&#xff1a;是指在一组数据中所有数据之和再除以这组数据的个数。 如&#xff1a;“1&#xff0c;2&#xff0c;3&#xf…
阅读更多...
最新文章

Copyright @ 2022~2023

友情链接： 我的编程经验分享 一条长河网 尧图网站开发 尧图建网站