FFMpeg-如何从'；mp4和x27；集装箱至'；ts'；容器

我有这个ffmpeg命令

ffmpeg-ic:\input.mp4-vcodec copy-acodec copy-vbsf h264_mp4toanexb c:\output.ts

上述命令成功地将input.mp4转换为output.ts

我需要通过代码实现相同的功能（使用ffmpeg库）

---

有人知道如何在不解码和编码的情况下从一个容器复制到另一个容器吗？

如果您只是在寻找流复制，您可以很容易地做到这一点。 您可以参考以下步骤

//1. Do initialization using 

    av_register_all();

// 2. Open input file using  

    avformat_open_input( &m_informat, filename.c_str(), 0, 0));

//3. Find input stream info.

     if ((ret = avformat_find_stream_info(m_informat, 0))< 0)
        {
           av_strerror(ret,errbuf,sizeof(errbuf));
           PRINT_VAL("Not Able to find stream info:: ", errbuf)
           ret = -1;
           return ret;
        }

        for (unsigned int i = 0; i<m_informat->nb_streams; i++)
        {
           if(m_informat->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO)
           {
              PRINT_MSG("Found Video Stream ")
              m_in_vid_strm_idx = i;
              m_in_vid_strm = m_informat->streams[i];
           }

        if(m_informat->streams[i]->codec->codec_type == AVMEDIA_TYPE_AUDIO)
        {
            m_in_aud_strm_idx = i;
            m_in_aud_strm = m_informat->streams[i];
         }


// 4. Create ouputfile  and allocate output format.

   AVOutputFormat *outfmt = NULL;
   std::string outfile = std::string(filename) + "clip_out.ts";
        outfmt = av_guess_format(NULL,outfile.c_str(),NULL);
     if(outfmt == NULL)
        {
            ret = -1;
            return ret;
        }
        else
        {
            m_outformat = avformat_alloc_context();
            if(m_outformat)
            {
                m_outformat->oformat = outfmt;
                _snprintf(m_outformat->filename, 
                 sizeof(m_outformat->filename), "%s", outfile.c_str());    
            }
            else
            {
                ret = -1;
                return ret;
            }
        }

//5. Add audio and video stream to output format.

        AVCodec *out_vid_codec,*out_aud_codec;
        out_vid_codec = out_aud_codec = NULL;

        if(outfmt->video_codec != AV_CODEC_ID_NONE && m_in_vid_strm != NULL)
        {
            out_vid_codec = avcodec_find_encoder(outfmt->video_codec);
            if(NULL == out_vid_codec)
            {
                PRINT_MSG("Could Not Find Vid Encoder")
                ret = -1;
                return ret;
            }
            else
            {
                PRINT_MSG("Found Out Vid Encoder ")
                m_out_vid_strm = avformat_new_stream(m_outformat, out_vid_codec);
                if(NULL == m_out_vid_strm)
                {
                     PRINT_MSG("Failed to Allocate Output Vid Strm ")
                     ret = -1;
                     return ret;
                }
                else
                {
                     PRINT_MSG("Allocated Video Stream ")
                     if(avcodec_copy_context(m_out_vid_strm->codec, 
                        m_informat->streams[m_in_vid_strm_idx]->codec) != 0)
                     {
                        PRINT_MSG("Failed to Copy Context ")
                        ret = -1;
                        return ret;
                     }
                     else
                     {
                        m_out_vid_strm->sample_aspect_ratio.den = 
                        m_out_vid_strm->codec->sample_aspect_ratio.den;

                        m_out_vid_strm->sample_aspect_ratio.num = 
                        m_in_vid_strm->codec->sample_aspect_ratio.num;
                        PRINT_MSG("Copied Context ")
                        m_out_vid_strm->codec->codec_id = m_in_vid_strm->codec->codec_id;
                        m_out_vid_strm->codec->time_base.num = 1;
                        m_out_vid_strm->codec->time_base.den = 
                        m_fps*(m_in_vid_strm->codec->ticks_per_frame);         
                        m_out_vid_strm->time_base.num = 1;
                        m_out_vid_strm->time_base.den = 1000;
                        m_out_vid_strm->r_frame_rate.num = m_fps;
                        m_out_vid_strm->r_frame_rate.den = 1;
                        m_out_vid_strm->avg_frame_rate.den = 1;
                        m_out_vid_strm->avg_frame_rate.num = m_fps;
                        m_out_vid_strm->duration = (m_out_end_time - m_out_start_time)*1000;
                     }
                   }
                }
          }

        if(outfmt->audio_codec != AV_CODEC_ID_NONE && m_in_aud_strm != NULL)
        {
            out_aud_codec = avcodec_find_encoder(outfmt->audio_codec);
            if(NULL == out_aud_codec)
            {
                PRINT_MSG("Could Not Find Out Aud Encoder ")
                ret = -1;
                return ret;
            }
            else
            {
                PRINT_MSG("Found Out Aud Encoder ")
                m_out_aud_strm = avformat_new_stream(m_outformat, out_aud_codec);
                if(NULL == m_out_aud_strm)
                {
                    PRINT_MSG("Failed to Allocate Out Vid Strm ")
                    ret = -1;
                    return ret;
                }
                else
                {
                    if(avcodec_copy_context(m_out_aud_strm->codec, 
                       m_informat->streams[m_in_aud_strm_idx]->codec) != 0)
                    {
                        PRINT_MSG("Failed to Copy Context ")
                        ret = -1;
                        return ret;
                    }
                    else
                     {
                        PRINT_MSG("Copied Context ")
                        m_out_aud_strm->codec->codec_id = m_in_aud_strm->codec->codec_id;
                        m_out_aud_strm->codec->codec_tag = 0;
                        m_out_aud_strm->pts = m_in_aud_strm->pts;
                        m_out_aud_strm->duration = m_in_aud_strm->duration;
                        m_out_aud_strm->time_base.num = m_in_aud_strm->time_base.num;
                        m_out_aud_strm->time_base.den = m_in_aud_strm->time_base.den;

                    }
                }
             }
          }
 // 6. Finally output header.
      if (!(outfmt->flags & AVFMT_NOFILE)) 
          {
            if (avio_open2(&m_outformat->pb, outfile.c_str(), AVIO_FLAG_WRITE,NULL, NULL) < 0) 
            {
                    PRINT_VAL("Could Not Open File ", outfile)
                    ret = -1;
                    return ret;
            }
          }
            /* Write the stream header, if any. */
          if (avformat_write_header(m_outformat, NULL) < 0) 
          {
                PRINT_VAL("Error Occurred While Writing Header ", outfile)
                ret = -1;
                return ret;
          }
          else
          {
                PRINT_MSG("Written Output header ")
                m_init_done = true;
          }

// 7. Now in while loop read frame using av_read_frame and write to output format using 
//  av_interleaved_write_frame(). You can use following loop

      while(av_read_frame(m_informat, &pkt) >= 0 && (m_num_frames-- > 0))
            {
                if(pkt.stream_index == m_in_vid_strm_idx)
                {
                    PRINT_VAL("ACTUAL VID Pkt PTS ",av_rescale_q(pkt.pts,m_in_vid_strm->time_base, m_in_vid_strm->codec->time_base))
                    PRINT_VAL("ACTUAL VID Pkt DTS ", av_rescale_q(pkt.dts, m_in_vid_strm->time_base, m_in_vid_strm->codec->time_base ))
                    av_init_packet(&outpkt);
                    if(pkt.pts != AV_NOPTS_VALUE)
                    {
                        if(last_vid_pts == vid_pts)
                        {
                            vid_pts++;
                            last_vid_pts = vid_pts;
                        }
                        outpkt.pts = vid_pts;   
                        PRINT_VAL("ReScaled VID Pts ", outpkt.pts)
                    }
                    else
                    {
                        outpkt.pts = AV_NOPTS_VALUE;
                    }

                    if(pkt.dts == AV_NOPTS_VALUE)
                    {
                        outpkt.dts = AV_NOPTS_VALUE;
                    }
                    else
                    {
                        outpkt.dts = vid_pts;
                        PRINT_VAL("ReScaled VID Dts ", outpkt.dts)
                        PRINT_MSG("=======================================")
                    }

                    outpkt.data = pkt.data;
                    outpkt.size = pkt.size;
                    outpkt.stream_index = pkt.stream_index;
                    outpkt.flags |= AV_PKT_FLAG_KEY;
                    last_vid_pts = vid_pts;
                    if(av_interleaved_write_frame(m_outformat, &outpkt) < 0)
                    {
                        PRINT_MSG("Failed Video Write ")
                    }
                    else
                    {
                        m_out_vid_strm->codec->frame_number++;
                    }
                    av_free_packet(&outpkt);
                    av_free_packet(&pkt);
                }
                else if(pkt.stream_index == m_in_aud_strm_idx)
                {
                    PRINT_VAL("ACTUAL AUD Pkt PTS ", av_rescale_q(pkt.pts, m_in_aud_strm->time_base, m_in_aud_strm->codec->time_base))
                    PRINT_VAL("ACTUAL AUD Pkt DTS ", av_rescale_q(pkt.dts, m_in_aud_strm->time_base, m_in_aud_strm->codec->time_base))
                    //num_aud_pkt++;
                    av_init_packet(&outpkt);
                    if(pkt.pts != AV_NOPTS_VALUE)
                    {
                        outpkt.pts = aud_pts;
                        PRINT_VAL("ReScaled AUD PTS ", outpkt.pts)
                    }
                    else
                    {
                        outpkt.pts = AV_NOPTS_VALUE;
                    }

                    if(pkt.dts == AV_NOPTS_VALUE)
                    {
                        outpkt.dts = AV_NOPTS_VALUE;
                    }
                    else
                    {
                        outpkt.dts = aud_pts;
                        PRINT_VAL("ReScaled AUD DTS ", outpkt.dts)
                        PRINT_MSG("====================================")
                        if( outpkt.pts >= outpkt.dts)
                        {
                            outpkt.dts = outpkt.pts;
                        }
                        if(outpkt.dts == aud_dts)
                        {
                            outpkt.dts++;
                        }
                        if(outpkt.pts < outpkt.dts)
                        {
                            outpkt.pts = outpkt.dts;
                            aud_pts = outpkt.pts;
                        }
                    }

                    outpkt.data = pkt.data;
                    outpkt.size = pkt.size;
                    outpkt.stream_index = pkt.stream_index;
                    outpkt.flags |= AV_PKT_FLAG_KEY;
                    vid_pts = aud_pts;
                    aud_pts++;
                    if(av_interleaved_write_frame(m_outformat, &outpkt) < 0)
                    {
                        PRINT_MSG("Faile Audio Write ")
                    }
                    else
                    {
                        m_out_aud_strm->codec->frame_number++;
                    }
                    av_free_packet(&outpkt);
                    av_free_packet(&pkt);
            }
            else
            {
                PRINT_MSG("Got Unknown Pkt ")
                //num_unkwn_pkt++;
            }
            //num_total_pkt++;
        }

//8. Finally write trailer and clean up everything

     av_write_trailer(m_outformat);
        av_free_packet(&outpkt);
        av_free_packet(&pkt);

//1。使用
av_寄存器_all（）；
// 2. 使用打开输入文件
avformat_open_输入（&m_informat，filename.c_str（），0，0））；
//3. 查找输入流信息。
如果（（ret=avformat\u find\u stream\u info（m\u informat，0））<0）
{
av_strerror（ret、errbuf、sizeof（errbuf））；
打印值（“无法找到流信息：：”，errbuf）
ret=-1；
返回ret；
}
for（无符号整数i=0；inb_流；i++）
{
如果（m_informat->streams[i]->codec->codec_type==AVMEDIA_type_VIDEO）
{
打印消息（“找到的视频流”）
m_in_vid_strm_idx=i；
m_in_vid_strm=m_informat->streams[i]；
}
如果（m_informat->streams[i]->codec->codec_type==AVMEDIA_type_AUDIO）
{
m_in_aud_strm_idx=i；
m_in_aud_strm=m_informat->streams[i]；
}
//4.创建输出文件并分配输出格式。
AVOutputFormat*OUTPMT=NULL；
std:：string outfile=std:：string（文件名）+“clip_out.ts”；
outpmt=av_guess_格式（NULL，outfile.c_str（），NULL）；
如果（outpmt==NULL）
{
ret=-1；
返回ret；
}
其他的
{
m_outformat=avformat_alloc_context（）；
if（m_格式外）
{
m_outformat->oformat=outpmt；
_snprintf（m_outformat->filename，
sizeof（m_outformat->filename），“%s”，outfile.c_str（）；
}
其他的
{
ret=-1；
返回ret；
}
}
//5.将音频和视频流添加到输出格式。
AVCodec*输出视频编解码器，*输出音频编解码器；
out\u vid\u codec=out\u aud\u codec=NULL；
如果（outpmt->video\u codec！=AV\u codec\u ID\u NONE&&m\u in\u vid\u strm！=NULL）
{
out\u vid\u codec=avcodec\u find\u编码器（outpmt->video\u codec）；
if（NULL==输出视频编解码器）
{
打印消息（“找不到视频编码器”）
ret=-1；
返回ret；
}
其他的
{
打印消息（“找到视频编码器”）
m_out_vid_strm=avformat_new_流（m_outformat，out_vid_codec）；
if（NULL==m\u out\u vid\u strm）
{
打印消息（“分配输出视频Strm失败”）
ret=-1；
返回ret；
}
其他的
{
打印消息（“分配的视频流”）
如果（avcodec\U copy\U）上下文（m\U out\U vid\U strm->codec，
m_informat->streams[m_in_vid_strm_idx]->编解码器）！=0）
{
打印消息（“复制上下文失败”）
ret=-1；
返回ret；
}
其他的
{
m_out_vid_strm->sample_aspect_ratio.den=
m_out_vid_strm->codec->sample\u aspect\u ratio.den；
m_out_vid_strm->sample_aspect_ratio.num=
m_in_vid_strm->codec->sample\u aspect\u ratio.num；
打印消息（“复制的上下文”）
m_out_vid_strm->codec->codec_id=m_in_vid_strm->codec->codec_id；
m_out_vid_strm->codec->time_base.num=1；
m_out_vid_strm->codec->time_base.den=
m_fps*（m_in_vid_strm->codec->ticks_per_frame）；
m_out_vid_strm->time_base.num=1；
m_out_vid_strm->time_base.den=1000；
m_out_vid_strm->r_frame_rate.num=m_fps；
m_out_vid_strm->r_frame_rate.den=1；
m_out_vid_strm->avg_frame_rate.den=1；
m_out_vid_strm->avg_frame_rate.num=m_fps；
m_out vid_strm->duration=（m_out end_time-m_out start_time）*1000；
}
}
}
}
如果（outpmt->audio\u codec！=AV\u codec\u ID\u NONE&&m\u in\u aud\u strm！=NULL）
{
out\u aud\u codec=avcodec\u find\u编码器（outpmt->audio\u codec）；
if（NULL==out\u aud\u编解码器）
{
打印消息（“无法找到Aud编码器”）
ret=-1；
返回ret；
}
其他的
{
打印消息（“找到Aud编码器”）
m_out_aud_strm=avformat_new_stream（m_outformat，out_aud_codec）；
if（NULL==m\u out\u aud\u strm）
{
打印消息（“未能分配出Vid Strm”）
ret=-1；
返回ret；
}
其他的
{
如果（avcodec\u copy\u context）（m\u out\u aud\u strm->codec，
m_informat->streams[m_in_aud_strm_idx]->编解码器）！=0）
{
打印消息（“复制上下文失败”）
ret=-1；
返回ret；
}
其他的
{
打印消息（“复制的上下文”）
m_out_aud_strm->codec->codec_id=m_in_aud_strm->codec->codec_id；