av_interleaved_write_frame을 사용할 때 "moov atom not found"(avio_write_frame 사용시)

Question

ffmpeg 3.3.3 API를 사용하여 임의의 프레임을 가져 와서 비디오를 생성 할 수있는 클래스를 만들려고합니다. 나는 예를 들어 여전히 deprecated 함수를 사용하는 것처럼 보이기 때문에 좋은 예제를 찾기 위해 고심하고있다. 그래서 헤더에있는 문서를 사용하여 패치를 시도하고 사용하고있는 몇 github repos를 참조하여 시도했다. 새 버전. I가 출력하는 부호화 패킷을 작성 av_interleaved_write_frame를 사용하는 경우

다음 ffprobe는 다음 출력 :

[mov,mp4,m4a,3gp,3g2,mj2 @ 0000000002760120] moov atom not found0 
X:\Diagnostics.mp4: Invalid data found when processing input 

ffplay이 ​​방법에 의해 생성 된 파일을 재생할 수 없다. 내가 대신 avio_write하는 통화를 스왑하는 경우

, ffprobe 대신 출력 : 그것은 끝으로 때까지

이

Input #0, h264, from 'X:\Diagnostics.mp4': 
    Duration: N/A, bitrate: N/A 
    Stream #0:0: Video: h264 (Main), yuv420p(progressive), 672x380 [SAR 1:1 DAR 168:95], 25 fps, 25 tbr, 1200k tbn, 50 tbc 

ffplay이 ​​대부분이 파일을 재생할 수 있습니다, 그것은 출력 할 때 :

Input #0, h264, from 'X:\Diagnostics.mp4': 0KB sq= 0B f=0/0 
    Duration: N/A, bitrate: N/A 
    Stream #0:0: Video: h264 (Main), yuv420p(progressive), 672x380 [SAR 1:1 DAR 168:95], 25 fps, 25 tbr, 1200k tbn, 50 tbc 
[h264 @ 000000000254ef80] error while decoding MB 31 22, bytestream -65 
[h264 @ 000000000254ef80] concealing 102 DC, 102 AC, 102 MV errors in I frame 
    nan M-V: nan fd= 1 aq= 0KB vq= 0KB sq= 0B f=0/0 

VLC는 두 가지 방법 중 하나의 파일을 재생할 수 없습니다. 두 번째 방법의 파일은 단일 검정색 프레임을 표시 한 다음 비디오 출력을 숨 깁니다. 첫 번째는 아무 것도 표시하지 않습니다. 둘 다 비디오 재생 시간을 제공하지 않습니다.

여기에 무슨 일이 일어나는지 다른 사람이 있습니까? 나는 유효한 프레임이 잘 들어오고 있기 때문에 내 솔루션이 작동하고 있다고 가정합니다.

코드 :

void main() 
{ 
    OutputStream Stream("Output.mp4", 672, 380, 25, true); 
    Stream.Initialize(); 

    int i = 100; 
    while(i--) 
    { 
     //... Generate a frame 

     Stream.WriteFrame(Frame); 
    } 
    Stream.CloseFile(); 
} 

OutputStream::OutputStream(const std::string& Path, unsigned int Width, unsigned int Height, int Framerate, bool IsBGR) 
: Stream() 
, FrameIndex(0) 
{ 
    auto& ID = *m_InternalData; 

    ID.Path = Path; 

    ID.Width = Width; 
    ID.Height= Height; 
    ID.Framerate.num = Framerate; 
    ID.Framerate.den = 1; 

    ID.PixelFormat = IsBGR ? AV_PIX_FMT_BGR24 : AV_PIX_FMT_RGB24; 
    ID.CodecID = AV_CODEC_ID_H264; 
    ID.CodecTag = 0; 

    ID.AspectRatio.num = 1; 
    ID.AspectRatio.den = 1; 
} 

CameraStreamError OutputStream::Initialize() 
{ 
    av_log_set_callback(&InputStream::LogCallback); 
    av_register_all(); 
    avformat_network_init(); 

    auto& ID = *m_InternalData; 

    av_init_packet(&ID.Packet); 

    int Result = avformat_alloc_output_context2(&ID.FormatContext, nullptr, nullptr, ID.Path.c_str()); 
    if(Result < 0 || !ID.FormatContext) 
    { 
     STREAM_ERROR(UnknownError); 
    } 

    AVCodec* Encoder = avcodec_find_encoder(ID.CodecID); 

    if(!Encoder) 
    { 
     STREAM_ERROR(NoH264Support); 
    } 

    AVStream* OutStream = avformat_new_stream(ID.FormatContext, Encoder); 
    if(!OutStream) 
    { 
     STREAM_ERROR(UnknownError); 
    } 

    ID.CodecContext = avcodec_alloc_context3(Encoder); 
    if(!ID.CodecContext) 
    { 
     STREAM_ERROR(NoH264Support); 
    } 

    ID.CodecContext->time_base = av_inv_q(ID.Framerate); 

    { 
     AVCodecParameters* CodecParams = OutStream->codecpar; 

     CodecParams->width = ID.Width; 
     CodecParams->height = ID.Height; 
     CodecParams->format = AV_PIX_FMT_YUV420P; 
     CodecParams->codec_id = ID.CodecID; 
     CodecParams->codec_type = AVMEDIA_TYPE_VIDEO; 
     CodecParams->profile = FF_PROFILE_H264_MAIN; 
     CodecParams->level = 40; 

     Result = avcodec_parameters_to_context(ID.CodecContext, CodecParams); 
     if(Result < 0) 
     { 
      STREAM_ERROR(EncoderCreationError); 
     } 
    } 

    if(ID.IsVideo) 
    { 
     ID.CodecContext->width = ID.Width; 
     ID.CodecContext->height = ID.Height; 
     ID.CodecContext->sample_aspect_ratio = ID.AspectRatio; 
     ID.CodecContext->time_base = av_inv_q(ID.Framerate); 

     if(Encoder->pix_fmts) 
     { 
      ID.CodecContext->pix_fmt = Encoder->pix_fmts[0]; 
     } 
     else 
     { 
      ID.CodecContext->pix_fmt = ID.PixelFormat; 
     } 
    } 
    //Snip 

    Result = avcodec_open2(ID.CodecContext, Encoder, nullptr); 
    if(Result < 0) 
    { 
     STREAM_ERROR(EncoderCreationError); 
    } 

    Result = avcodec_parameters_from_context(OutStream->codecpar, ID.CodecContext); 
    if(Result < 0) 
    { 
     STREAM_ERROR(EncoderCreationError); 
    } 

    if(ID.FormatContext->oformat->flags & AVFMT_GLOBALHEADER) 
    { 
     ID.CodecContext->flags |= AV_CODEC_FLAG_GLOBAL_HEADER; 
    } 

    OutStream->time_base = ID.CodecContext->time_base; 
    OutStream->avg_frame_rate= av_inv_q(OutStream->time_base); 

    if(!(ID.FormatContext->oformat->flags & AVFMT_NOFILE)) 
    { 
     Result = avio_open(&ID.FormatContext->pb, ID.Path.c_str(), AVIO_FLAG_WRITE); 
     if(Result < 0) 
     { 
      STREAM_ERROR(FileNotWriteable); 
     } 
    } 

    Result = avformat_write_header(ID.FormatContext, nullptr); 
    if(Result < 0) 
    { 
     STREAM_ERROR(WriteFailed); 
    } 

    ID.Output = std::make_unique<FFMPEG::Frame>(ID.CodecContext->width, ID.CodecContext->height, ID.CodecContext->pix_fmt); 

    ID.ConversionContext = sws_getCachedContext(
     ID.ConversionContext, 
     ID.Width, 
     ID.Height, 
     ID.PixelFormat, 
     ID.CodecContext->width, 
     ID.CodecContext->height, 
     ID.CodecContext->pix_fmt, 
     SWS_BICUBIC, 
     NULL, 
     NULL, 
     NULL); 

    return CameraStreamError::Success; 
} 

CameraStreamError OutputStream::WriteFrame(FFMPEG::Frame* Frame) 
{ 
    auto& ID = *m_InternalData; 

    ID.Output->Prepare(); 

    int OutputSliceSize = sws_scale(m_InternalData->ConversionContext, Frame->GetFrame()->data, Frame->GetFrame()->linesize, 0, Frame->GetHeight(), ID.Output->GetFrame()->data, ID.Output->GetFrame()->linesize); 

    ID.Output->GetFrame()->pts = ID.CodecContext->frame_number; 

    int Result = avcodec_send_frame(GetData().CodecContext, ID.Output->GetFrame()); 
    if(Result == AVERROR(EAGAIN)) 
    { 
     CameraStreamError ResultErr = SendAll(); 
     if(ResultErr != CameraStreamError::Success) 
     { 
      return ResultErr; 
     } 
     Result = avcodec_send_frame(GetData().CodecContext, ID.Output->GetFrame()); 
    } 

    if(Result == 0) 
    { 
     CameraStreamError ResultErr = SendAll(); 
     if(ResultErr != CameraStreamError::Success) 
     { 
      return ResultErr; 
     } 
    } 

    FrameIndex++; 

    return CameraStreamError::Success; 
} 

CameraStreamError OutputStream::SendAll(void) 
{ 
    auto& ID = *m_InternalData; 

    int Result; 
    do 
    { 
     AVPacket TempPacket = {}; 
     av_init_packet(&TempPacket); 

     Result = avcodec_receive_packet(GetData().CodecContext, &TempPacket); 
     if(Result == 0) 
     { 
      av_packet_rescale_ts(&TempPacket, ID.CodecContext->time_base, ID.FormatContext->streams[0]->time_base); 

      TempPacket.stream_index = ID.FormatContext->streams[0]->index; 

      //avio_write(ID.FormatContext->pb, TempPacket.data, TempPacket.size); 
      Result = av_interleaved_write_frame(ID.FormatContext, &TempPacket); 
      if(Result < 0) 
      { 
       STREAM_ERROR(WriteFailed); 
      } 

      av_packet_unref(&TempPacket); 
     } 
     else if(Result != AVERROR(EAGAIN)) 
     { 
      continue; 
     } 
     else if(Result != AVERROR_EOF) 
     { 
      break; 
     } 
     else if(Result < 0) 
     { 
      STREAM_ERROR(WriteFailed); 
     } 
    } while (Result == 0); 

    return CameraStreamError::Success; 
} 

CameraStreamError OutputStream::CloseFile() 
{ 
    auto& ID = *m_InternalData; 

    while(true) 
    { 
     //Flush 
     int Result = avcodec_send_frame(ID.CodecContext, nullptr); 
     if(Result == 0) 
     { 
      CameraStreamError StrError = SendAll(); 
      if(StrError != CameraStreamError::Success) 
      { 
       return StrError; 
      } 
     } 
     else if(Result == AVERROR_EOF) 
     { 
      break; 
     } 
     else 
     { 
      STREAM_ERROR(WriteFailed); 
     } 
    } 

    int Result = av_write_trailer(ID.FormatContext); 
    if(Result < 0) 
    { 
     STREAM_ERROR(WriteFailed); 
    } 

    if(!(ID.FormatContext->oformat->flags& AVFMT_NOFILE)) 
    { 
     Result = avio_close(ID.FormatContext->pb); 
     if(Result < 0) 
     { 
      STREAM_ERROR(WriteFailed); 
     } 
    } 

    return CameraStreamError::Success; 
} 

주 나는 몇 가지를 단순화하고 다른 곳에 있었다 몇 비트를 인라인했습니다. 또한 파일을 닫은 후에 일어나는 일들이 무의미하기 때문에 모든 종료 코드를 제거했습니다.

여기에서 전체 저장소 : https://github.com/IanNorris/Witness이 문제를 '진단'출력과 함께 사용하면 출력 파일이 정상입니다. X에는 ​​두 개의 하드 코드 된 경로가 있습니다.

Answer 1

avio_write() 파일은 MP4 파일이 아니며 단순히 AnnexB H.264라고도하는 압축 된 H.264 패킷입니다.

av_interleaved_frame_write()을 사용하여 컨테이너에 파일을 쓰려면 모든 압축 된 비디오/오디오 패킷 뒤에 avformat_write_header() 및 av_write_trailer()을 호출해야합니다. 이 파일이 없으면 파일에 전역 헤더 (예 : MP4의 moov 청크)가 포함되지 않으며 여기에 오류가 실제로 표시된 것처럼 외부 응용 프로그램에서 유효한 파일로 인식되지 않습니다.

자세한 내용은 muxing documentation을 참조하십시오.