Recherche avancée

Sur d’autres sites (5421)

• FFMpeg Coding in C : Encoder returns EOF at first interaction. Encoder not opened correctly ? [closed]

  26 février, par Davidhohey

  as I'm fairly new to FFMpeg Programming and C in general, the code looks like a mess.

  


  I have smashed my head against a wall trying to get this code to work for about a week.

  


  int decode_encode_pipeline(AVFormatContext *Input_Format_Context, AVFormatContext *Output_Format_Context, int *streams_list){

    const AVCodec *DECodec, *ENCodec;
    AVCodecContext *DECodecContext = NULL, *ENCodecContext = NULL;
    AVCodecParameters *CodecParameters = NULL;
    AVDictionary *opts = NULL;
    AVPacket *Packet;
    AVFrame *Frame;
    int check;

    Packet = av_packet_alloc();
    if(!Packet){
    
        printf("\nFehler bei Allocating Packet");
    
        return 0;
    
    }

    Frame = av_frame_alloc();
    if(!Frame){
    
        printf("\nFehler bei Allocating Frame");
    
        return 0;
    
    }

    CodecParameters = Input_Format_Context->streams[Packet->stream_index]->codecpar;
    if(!CodecParameters){

        printf("\nCodecParameters konnte nicht erstellt oder zugewiesen werden.");

    }

    DECodec = avcodec_find_decoder(CodecParameters->codec_id);
    if(!DECodec){
    
        printf("\nCodec nicht gefunden");
    
        return 0;
    
    }

    DECodecContext = avcodec_alloc_context3(DECodec);
    if (!DECodecContext){
    
        printf("\nFehler bei Allocating CodecContext");
    
        return 0;
    
    }

    ENCodec = avcodec_find_encoder(CodecParameters->codec_id);
    if(!DECodec){
    
        printf("\nCodec nicht gefunden");
    
        return 0;
    
    }

    ENCodecContext = avcodec_alloc_context3(ENCodec);
    if (!ENCodecContext){
    
        printf("\nFehler bei Allocating CodecContext");
    
        return 0;
    
    }

    check = avformat_write_header(Output_Format_Context, &opts);
    if(check < 0){

        printf("\nFehler beim Öffnen des Output Files.");
        
        return 1;

    }

    avcodec_parameters_to_context(DECodecContext, CodecParameters);
    avcodec_parameters_to_context(ENCodecContext, CodecParameters);

    ENCodecContext->width = DECodecContext->width;
    ENCodecContext->height = DECodecContext->height;
    ENCodecContext->bit_rate = DECodecContext->bit_rate;
    ENCodecContext->time_base = (AVRational){1, 30};
    ENCodecContext->framerate = DECodecContext->framerate;
    ENCodecContext->gop_size = DECodecContext->gop_size;
    ENCodecContext->max_b_frames = DECodecContext->max_b_frames;
    ENCodecContext->pix_fmt = DECodecContext->pix_fmt;
    if(ENCodec->id == AV_CODEC_ID_H264){

        av_opt_set(ENCodecContext->priv_data, "preset", "slow", 0);

    }

    check = avcodec_open2(DECodecContext, DECodec, NULL);
    if(check < 0){
    
        printf("\nFehler bei Öffnen von DECodec");
    
        return 1;
    
    }

    check = avcodec_open2(ENCodecContext, ENCodec, NULL);
    if(check < 0){
    
        printf("\nFehler bei Öffnen von ENCodec");
    
        return 1;
    
    }

    while(1){
    
        check = av_read_frame(Input_Format_Context, Packet);
        if(check < 0){
        
            break;
        
        }

        AVStream *in_stream, *out_stream;

        in_stream  = Input_Format_Context->streams[Packet->stream_index];
        out_stream = Output_Format_Context->streams[Packet->stream_index];

        if(in_stream->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && Packet->stream_index == streams_list[Packet->stream_index]){

            check = avcodec_send_packet(DECodecContext, Packet);
            if(check < 0){

                printf("\nFehler bei Encoding");

                return 1;

            }

            AVPacket *EncodedPacket;
            EncodedPacket = av_packet_alloc();
            if(!EncodedPacket){
        
                printf("\nFehler bei Allocating Packet");
        
                return 1;
        
            }

            /*While Loop Decoding*/
            while(check >= 0){
    
                check = avcodec_receive_frame(DECodecContext, Frame);
                if(check == AVERROR(EAGAIN)){
        
                    continue;
        
                }else if(check == AVERROR_EOF){
                    
                    break;
                    
                }else if(check < 0){
        
                    printf("\nFehler bei Decoding");
        
                    return 1;
        
                }

                /*Convert Colorspace*/
                struct SwsContext *SwsContexttoRGB = sws_getContext(Frame->width, Frame->height, Frame->format, Frame->width, Frame->height, AV_PIX_FMT_RGB24, SWS_BILINEAR, NULL, NULL, NULL);
                struct SwsContext *SwsContexttoOriginal = sws_getContext(Frame->width, Frame->height, AV_PIX_FMT_RGB24, Frame->width, Frame->height, Frame->format, SWS_BILINEAR, NULL, NULL, NULL);
                if(!SwsContexttoRGB || !SwsContexttoOriginal){

                    printf("\nSwsContext konnte nicht befüllt werden.");

                    return 1;

                }   

                if(Frame->linesize < 0){

                    printf("\nFehler: linesize ist negativ und nicht kompatibel\n");

                    return 1;

                }

                AVFrame *RGBFrame;
                RGBFrame = av_frame_alloc();
                if(!RGBFrame){

                    printf("\nFehler bei der Reservierung für den RGBFrame");

                    return 1;

                }
                /*
                int number_bytes = av_image_get_buffer_size(AV_PIX_FMT_RGB24, Frame->width, Frame->height, 1);
                if(number_bytes < 0){

                    printf("\nFehler bei der Berechnung der benoetigten Bytes fuer Konvertierung");

                    return 1;

                }
                
                uint8_t *rgb_buffer = (uint8_t *)av_malloc(number_bytes*sizeof(uint8_t));
                if(rgb_buffer == NULL){

                    printf("\nFehler bei der Reservierung für den RGBBuffer");

                    return 1;

                }

                check = av_image_fill_arrays(RGBFrame->data, RGBFrame->linesize, rgb_buffer, AV_PIX_FMT_RGB24, Frame->width, Frame->height, 1);
                if(check < 0){

                    printf("\nFehler bei der Zuweisung der RGB Daten");

                    return 1;

                }*/

                //sws_scale(SwsContexttoRGB, (const uint8_t * const *)Frame->data, Frame->linesize, 0, Frame->height, RGBFrame->data, RGBFrame->linesize);
                sws_scale_frame(SwsContexttoRGB, Frame, RGBFrame);
                printf("\nIch habe die Daten zu RGB konvertiert.");

                //sws_scale(SwsContexttoOriginal, (const uint8_t * const *)RGBFrame->data, RGBFrame->linesize, 0, Frame->height, Frame->data, Frame->linesize);
                sws_scale_frame(SwsContexttoOriginal, RGBFrame, Frame);
                printf("\nIch habe die Daten zurück ins Original konvertiert.");

                Frame->format = ENCodecContext->pix_fmt;
                Frame->width  = ENCodecContext->width;
                Frame->height = ENCodecContext->height;
                
                check = av_frame_get_buffer(Frame, 0);
                if(check < 0){
        
                    printf("\nFehler bei Allocating Frame Buffer");
        
                    return 1;
        
                }

                /* Encoding */
                check = av_frame_make_writable(Frame);
                if(check < 0){

                    printf("\nFehler bei Make Frame Writable");

                    return 1;

                }

                encode(ENCodecContext, Frame, EncodedPacket, Output_Format_Context);

                sws_freeContext(SwsContexttoRGB);
                sws_freeContext(SwsContexttoOriginal);
                av_frame_free(&RGBFrame);
                //av_free(rgb_buffer);

            }

            /* Flushing Encoder */
            encode(ENCodecContext, NULL, EncodedPacket, Output_Format_Context);

            //avcodec_flush_buffers(DECodecContext);
            //avcodec_flush_buffers(ENCodecContext);

            av_packet_free(&EncodedPacket);

        }else{

            av_interleaved_write_frame(Output_Format_Context, Packet);

        }

    }

    av_write_trailer(Output_Format_Context); 

    /* Memory Free */
    avcodec_free_context(&DECodecContext);
    avcodec_free_context(&ENCodecContext);
    avcodec_parameters_free(&CodecParameters);
    av_frame_free(&Frame);
    av_packet_free(&Packet);

    return 0;

}



  


  The function encode looks as follows :

  


  static void encode(AVCodecContext *ENCodecContext, AVFrame *Frame, AVPacket *EncodedPacket, AVFormatContext *Output_Format_Context){

    int check;



    check = avcodec_send_frame(ENCodecContext, Frame);
    if(check == AVERROR(EAGAIN)){
        printf("\nEAGAIN");
    } 
    if(check == AVERROR_EOF){
        printf("\nEOF");
    }
    if(check == AVERROR(EINVAL)){
        printf("\nEINVAL");
    }
    if(check == AVERROR(ENOMEM)){
        printf("\nENOMEM");
    }
    if(check < 0){

        printf("\nFehler bei Encoding Send Frame. Check = %d", check);

        return;

    }

    while(check >= 0){

        check = avcodec_receive_packet(ENCodecContext, EncodedPacket);
        if(check == AVERROR(EAGAIN) || check == AVERROR_EOF){

            return;

        }else if(check < 0){

            printf("\nFehler bei Encoding");

            return;

        }

        if (av_interleaved_write_frame(Output_Format_Context, EncodedPacket) < 0) {

            printf("\nFehler beim Muxen des Paketes.");
            break;

        }

        av_packet_unref(EncodedPacket);

    }

    return;

}


  


  The program should decode a video into the individual frames convert them to RGB24, so I can work with the raw data of the frame, then convert it back to the original format and encode the frames.

  


  The encoder doesn't play nice, as I get an EOF error at avcodec_send_frame().
But I couldn't figure it out why the encoder behaves like this.
And yes I have read the docs and example files, but either I'm massivly missing a crucial detail or I'm just ****.

  


  Any and all help will be and is massivly appreciated.

  


  PS. : The used libraries are libavutil, libavformat, libavcodec, libswscale. All installed with the "-dev" suffix through linux commandline. Should all be the version 7.0 libraries.

  


  Thanks in advance.
With best regards.

  


  

  • Read the docs

  


  • Shifting the encoding step out of the decoding while loop

  


  


• Making 'zIndex' a configurable option.

  3 décembre 2013, par JamesMGreene

  Making 'zIndex' a configurable option.
  Temporary workaround for Issue #237.
  Fixes #275.

• Please tell us how to set up the option of HLS ffmpeg ?

  17 décembre 2014, par Mr.Park

  My ffmpeg Option :

  ffmpeg -i test.mp4 -max_delay 50000 -map 0:v -map 0:a -c copy -flags:v +global_header -bsf:v h264_mp4toannexb -f ssegment -segment_time 10 -segment_list playlist.m3u8 -segment_format mpegts -initial_offset 10  segment_%05d.ts

  if the WIFI, .m3u8 file plays not loading.

  if the 3G, the loading takes longer.

  my Works :

  .m3u8 URL : http://mytest/test/test.m3u8

  Simply call this URL into browser

  my Question is :

  Question 1.
  Can I split the HD video in .mp4 smaller capacity .ts files to .m3u8 file through the option of ffmpeg ?

  Question 2.
  .m3u8 when you play there a set way of WIFI and 3G options for ffmpeg ?