FFmpeg实战保存网络流

作者: samychen | 来源:发表于2017-12-05 20:19 被阅读0次

FFmpeg实战保存网络流
fmpeg 下载直播流
FFmpeg流媒体（2）
Ffmpeg音视频常用命令
流媒体
ffmpeg推流及拉流
Qt音视频开发8-ffmpeg保存裸流
常见音视频播放流程
FFmpeg拉Rtmp流并保存视频
Android PC投屏简单尝试(录屏直播)3—软解章(Imag

今天我们开始正式进入FFmpeg的篇章，FFmpeg作为著名的开源框架，可以生成用于处理多媒体框架的库和程序，是音视频界内的圣经，市面上直播开发99%都是基于FFmpeg来开发的，这足以证明FFmpeg的强大。关于FFmpeg的源码和官方文档可以去FFmpeg下载源码和编译好的库。
闲话不多说，下面就开始今天的主要内容，FFmpeg保存网络流到本地
直播不像点播，当我们看到想看的内容时，我们不能倒退回去，但是我们可以保存直播流为本地文件，这样我们想看随时都可以。

保存网络流的流程主要有以下步骤：
第一步：注册所有的组件（编解码、滤镜特效处理库、封装格式处理库、工具库、音频采样数据格式转换库、视频像素数据格式转换等等...）
第二步：获取视频流的封装信息，查找视频和音频流的位置
第三步：查找视频和音频解码器id，根据解码器id打开解码器
第四步：创建输出流并拷贝流上下文信息
第五步：循环读取网络流，解码packet并写入本地
第六步：关闭解码器释放内存

源码

#include "stdafx.h"
#include "pch.h"
#include <string>
#include <memory>
#include <thread>
#include <iostream>
using namespace std;

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;
    }
}
void av_packet_rescale_ts(AVPacket *pkt, AVRational src_tb, AVRational dst_tb)
{
    if (pkt->pts != AV_NOPTS_VALUE)
        pkt->pts = av_rescale_q(pkt->pts, src_tb, dst_tb);
    if (pkt->dts != AV_NOPTS_VALUE)
        pkt->dts = av_rescale_q(pkt->dts, src_tb, dst_tb);
    if (pkt->duration > 0)
        pkt->duration = av_rescale_q(pkt->duration, src_tb, dst_tb);
}
int WritePacket(shared_ptr<AVPacket> packet)
{
    auto inputStream = inputContext->streams[packet->stream_index];
    auto outputStream = outputContext->streams[packet->stream_index];               
    av_packet_rescale_ts(packet.get(),inputStream->time_base,outputStream->time_base);//时间戳转换，输入上下文与输出上下文时间基准不同
    //也可以用av_write_frame
    return av_interleaved_write_frame(outputContext, packet.get());
}

int OpenOutput(string outUrl)
{
    
    int ret  = avformat_alloc_output_context2(&outputContext, nullptr, "mpegts", 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++)
    {
        //输出依赖于输入
        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 CloseInput()
{
    if(inputContext != nullptr)
    {
        avformat_close_input(&inputContext);
    }
}

void CloseOutput()
{
    if(outputContext != nullptr)
    {
        for(int i = 0 ; i < outputContext->nb_streams; i++)
        {
            AVCodecContext *codecContext = outputContext->streams[i]->codec;
            avcodec_close(codecContext);
        }
        avformat_close_input(&outputContext);
    }
}
void Init()
{
    av_register_all();
    avfilter_register_all();
    avformat_network_init();
    av_log_set_level(AV_LOG_ERROR);
}
int main(int argc, char *argv[])
{
    Init();
    int ret = OpenInput("rtmp://v1.one-tv.com/live/mpegts.stream");
    if(ret >= 0)
    {
        //rtmp://192.168.1.107/oflaDemo/test
        //ret = OpenOutput("rtmp://127.0.0.1:1935/live/stream0"); //播放地址为rtmp://127.0.0.1/live/stream0 live=1
        ret = OpenOutput("D:\\test.ts"); 
    }
    if(ret <0) goto Error;

    while(true)
    {
        auto packet = ReadPacketFromSource();
        if(packet)
        {
            ret = WritePacket(packet);
            if(ret >= 0)
            {
                cout<<"WritePacket Success!"<<endl;
            }
            else
            {
                cout<<"WritePacket failed!"<<endl;
            }
        }
        else
        {
            break;
        }
    }
    

Error:
    CloseInput();
    CloseOutput();
    while(true)
    {
        this_thread::sleep_for(chrono::seconds(100));
    }
    return 0;
}

在上面代码函数里面有个函数av_packet_rescale_ts是不是看不懂，其实这里是跳调整时间戳，因为输入和输出流的时间基准不一定相同，所有这里需要进行时间戳转换。

interrupt_cb这个函数的官方解释是为I/O层自定义中断回调，在avformat_open_input之前设置，其实就是读取输入数据时的一个回调，在这里我们稍微做一个超时处理，如果读取超过3秒就返回一个错误码中断读取流数据。

好了，利用FFmpeg保存网络流就是这么简单，这里留个扩展，你可以试试利用FFmpeg保存网络图片。