标签：int 保存 ret 王纲 codec packet av include 图片

#ifndef PCH_H
#define PCH_H
extern "C"
{
    #include "libavutil/opt.h"
    #include "libavutil/channel_layout.h"
    #include "libavutil/common.h"
    #include "libavutil/imgutils.h"
    #include "libavutil/mathematics.h"
    #include "libavutil/samplefmt.h"
    #include "libavutil/time.h"
    #include "libavutil/fifo.h"
    #include "libavcodec/avcodec.h"
    #include "libavformat/avformat.h"
    #include "libavformat/avio.h"
    //#include "libavfilter/avfiltergraph.h"
    #include "libavfilter/avfilter.h"
    #include "libavfilter/buffersink.h"
    #include "libavfilter/buffersrc.h"
    #include "libswscale/swscale.h"
    #include "libswresample/swresample.h"
}
#endif

// CGFileCut.cpp : 定义控制台应用程序的入口点。
//
/* Copyright [c] 2018-2028 By www.chungen90.com Allrights Reserved 
   This file give a simple example of getting picture form 
   real stream.   Any questions, you can join QQ group for
   help, QQ Group number:127903734 or 766718184.
*/
//#include "stdafx.h"
#include <string>
#include <memory>
#include <thread>
#include <iostream>
#include <iostream>
using namespace std;
#include "pch.h"

AVFormatContext *inputContext = nullptr;
AVFormatContext * outputContext;
int64_t lastReadPacktTime ;

static int interrupt_cb(void *ctx)
{
    int  timeout  = 3;
    if(av_gettime() - lastReadPacktTime > timeout *1000 *1000)
    {
        return -1;
    }
    return 0;
}

int OpenInput(string inputUrl)
{
    inputContext = avformat_alloc_context();    
    lastReadPacktTime = av_gettime();
    inputContext->interrupt_callback.callback = interrupt_cb;
    int ret = avformat_open_input(&inputContext, inputUrl.c_str(), nullptr,nullptr);
    if(ret < 0)
    {
        av_log(NULL, AV_LOG_ERROR, "Input file open input failed\n");
        return  ret;
    }
    ret = avformat_find_stream_info(inputContext,nullptr);
    if(ret < 0)
    {
        av_log(NULL, AV_LOG_ERROR, "Find input file stream inform failed\n");
    }
    else
    {
        av_log(NULL, AV_LOG_FATAL, "Open input file  %s success\n",inputUrl.c_str());
    }
    return ret;
}


shared_ptr<AVPacket> ReadPacketFromSource()
{
    shared_ptr<AVPacket> packet(static_cast<AVPacket*>(av_malloc(sizeof(AVPacket))), [&](AVPacket *p) { av_packet_free(&p); av_freep(&p);});
    av_init_packet(packet.get());
    lastReadPacktTime = av_gettime();
    int ret = av_read_frame(inputContext, packet.get());
    if(ret >= 0)
    {
        return packet;
    }
    else
    {
        return nullptr;
    }
}

int OpenOutput(string outUrl)
{

    int ret  = avformat_alloc_output_context2(&outputContext, nullptr, "singlejpeg", outUrl.c_str());
    if(ret < 0)
    {
        av_log(NULL, AV_LOG_ERROR, "open output context failed\n");
        goto Error;
    }

    ret = avio_open2(&outputContext->pb, outUrl.c_str(), AVIO_FLAG_WRITE,nullptr, nullptr);    
    if(ret < 0)
    {
        av_log(NULL, AV_LOG_ERROR, "open avio failed");
        goto Error;
    }

    for(int i = 0; i < inputContext->nb_streams; i++)
    {
        if(inputContext->streams[i]->codec->codec_type == AVMediaType::AVMEDIA_TYPE_AUDIO)
        {
            continue;
        }
        AVStream * stream = avformat_new_stream(outputContext, inputContext->streams[i]->codec->codec);                
        ret = avcodec_copy_context(stream->codec, inputContext->streams[i]->codec);    
        if(ret < 0)
        {
            av_log(NULL, AV_LOG_ERROR, "copy coddec context failed");
            goto Error;
        }
    }

    ret = avformat_write_header(outputContext, nullptr);
    if(ret < 0)
    {
        av_log(NULL, AV_LOG_ERROR, "format write header failed");
        goto Error;
    }

    av_log(NULL, AV_LOG_FATAL, " Open output file success %s\n",outUrl.c_str());            
    return ret ;
Error:
    if(outputContext)
    {
        for(int i = 0; i < outputContext->nb_streams; i++)
        {
            avcodec_close(outputContext->streams[i]->codec);
        }
        avformat_close_input(&outputContext);
    }
    return ret ;
}

void Init()
{
    av_register_all();
    avfilter_register_all();
    avformat_network_init();
    av_log_set_level(AV_LOG_WARNING);
}

void CloseInput()
{
    if(inputContext != nullptr)
    {
        avformat_close_input(&inputContext);
    }
}

void CloseOutput()
{
    if(outputContext != nullptr)
    {
        int ret = av_write_trailer(outputContext);
        for(int i = 0 ; i < outputContext->nb_streams; i++)
        {
            AVCodecContext *codecContext = outputContext->streams[i]->codec;
            avcodec_close(codecContext);
        }
        avformat_close_input(&outputContext);
    }
}

int WritePacket(shared_ptr<AVPacket> packet)
{
    auto inputStream = inputContext->streams[packet->stream_index];
    auto outputStream = outputContext->streams[packet->stream_index];                
    return av_interleaved_write_frame(outputContext, packet.get());
}

int InitDecodeContext(AVStream *inputStream)
{    
    auto codecId = inputStream->codec->codec_id;
    auto codec = avcodec_find_decoder(codecId);
    if (!codec)
    {
        return -1;
    }

    int ret = avcodec_open2(inputStream->codec, codec, NULL);
    return ret;

}

int initEncoderCodec(AVStream* inputStream,AVCodecContext **encodeContext)
    {
        AVCodec *  picCodec;
        
        picCodec = avcodec_find_encoder(AV_CODEC_ID_MJPEG);        
        (*encodeContext) = avcodec_alloc_context3(picCodec);
    
        (*encodeContext)->codec_id = picCodec->id;
        (*encodeContext)->time_base.num = inputStream->codec->time_base.num;
        (*encodeContext)->time_base.den = inputStream->codec->time_base.den;
        (*encodeContext)->pix_fmt =  *picCodec->pix_fmts;
        (*encodeContext)->width = inputStream->codec->width;
        (*encodeContext)->height =inputStream->codec->height;
        int ret = avcodec_open2((*encodeContext), picCodec, nullptr);
        if (ret < 0)
        {
            std::cout<<"open video codec failed"<<endl;
            return  ret;
        }
            return 1;
    }

bool Decode(AVStream* inputStream,AVPacket* packet, AVFrame *frame)
{
    int gotFrame = 0;
    auto hr = avcodec_decode_video2(inputStream->codec, frame, &gotFrame, packet);
    if (hr >= 0 && gotFrame != 0)
    {
        return true;
    }
    return false;
}


std::shared_ptr<AVPacket> Encode(AVCodecContext *encodeContext,AVFrame * frame)
{
    int gotOutput = 0;
    std::shared_ptr<AVPacket> pkt(static_cast<AVPacket*>(av_malloc(sizeof(AVPacket))), [&](AVPacket *p) { av_packet_free(&p); av_freep(&p); });
    av_init_packet(pkt.get());
    pkt->data = NULL;
    pkt->size = 0;
    int ret = avcodec_encode_video2(encodeContext, pkt.get(), frame, &gotOutput);
    if (ret >= 0 && gotOutput)
    {
        return pkt;
    }
    else
    {
        return nullptr;
    }
}


int main(int argc, char* argv[])
{
    Init();
    int ret = OpenInput("D:\\test.mp4");
    if(ret >= 0)
    {
        ret = OpenOutput("D:\\test.jpg"); 
    }
    if(ret <0) goto Error;

    AVCodecContext *encodeContext = nullptr;
    InitDecodeContext(inputContext->streams[0]);
    AVFrame *videoFrame = av_frame_alloc();
    initEncoderCodec(inputContext->streams[0],&encodeContext);

     while(true)
     {
        auto packet = ReadPacketFromSource();
        if(packet && packet->stream_index == 0)
        {
            if(Decode(inputContext->streams[0],packet.get(),videoFrame))
            {
                auto packetEncode = Encode(encodeContext,videoFrame);
                if(packetEncode)
                {
                    ret = WritePacket(packetEncode);
                    if(ret >= 0)
                    {
                        break;
                    }
                }

            }
                        
        }
        
     }
     cout <<"Get Picture End "<<endl;
     av_frame_free(&videoFrame);
     avcodec_close(encodeContext);
    Error:
    CloseInput();
    CloseOutput();
    
    while(true)
    {
        this_thread::sleep_for(chrono::seconds(100));
    }
    return 0;
}

标签：int,保存,ret,王纲,codec,packet,av,include,图片
来源： https://www.cnblogs.com/zeliangzhang/p/15752447.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。