Newest 'ffmpeg' Questions - Stack Overflow

http://stackoverflow.com/questions/tagged/ffmpeg

Les articles publiés sur le site

  • Video slideshow, blinking lines

    19 juillet 2016, par user2455079

    I'm creating video slideshow 

    melt -profile atsc_720p_25 67.jpg length=100 -filter crop center=1 -filter  affine transition.geometry="0=0,0:100%x100%;100=-100,-100:115%x115%" -consumer avformat:out.mp4 vcodec=libx264 vb=3000k

    And i have blinking lines effect which i don't get when make same slideshow via adobe after effects: https://www.youtube.com/watch?v=B41pdpunN9o How can i solve this problem?

  • FFMPEG Encryption of Live Streams

    19 juillet 2016, par trueblue

    I am working on ffmpeg live streaming, where in i need to encrypt Live Streams. I am trying to figure out the same. I worked with AES, but it works only on a stored file. Can I use https or rtmpe etc by using private keys, SSL certificates etc? Anybody who is working on the same, kindly share your thoughts.

    Eg : I am streaming my live cam feed using

    ffmpeg -f video4linux2 -i /dev/video0 http://localhost:8090/feed1.ffm

    I want to take stream1 as Input and Encrypt it continuously. And at the other end I want to decrypt and Play.

  • Spaces in file name (not path) in ProcessStartInfo C#

    19 juillet 2016, par Raulp

    I am running ffmpeg using C# 's ProcessStartInfo where I have to convert the files from one format to another.Those files having no spaces in them is working fine but those having spaces are getting stuck at the error.I think this is due to the spaces in the file name. e.g

      startInfo.Arguments = "-i " + filename+ ".mov-q:a 0 -map a " + filename+ ".mp4";

    filename is derived at the run time by parsing the directory . typical error prone filename e.g is = "this is my file"

    How can this be resolved.

  • IO.copy_stream performance in ruby

    19 juillet 2016, par stiller_leser

    I am trying to continously read a file in ruby (which is growing over time and needs to be processed in a separate process). Currently I am archiving this with the following bit of code:

    r,w = IO.pipe
pid = Process.spawn('ffmpeg'+ffmpeg_args, {STDIN => r, STDERR => STDOUT})
Process.detach pid
while true do
  IO.copy_stream(open(@options['filename']), w)
  sleep 1
end

    However - while working - I can't imagine that this is the most performant way of doing it. An alternative would be to use the following variation:

    step = 1024*4
copied = 0
pid = Process.spawn('ffmpeg'+ffmpeg_args, {STDIN => r, STDERR => STDOUT})
Process.detach pid
while true do
  IO.copy_stream(open(@options['filename']), w, step, copied)
  copied += step
  sleep 1
end

    which would only continously copy parts of the file (the issue here being if the step should ever overreach the end of the file). Other approaches such a simple read-file led to ffmpeg failing when there was no new data. With this solution the frames are dropped if no new data is available (which is what I need).

    Is there a better way (more performant) to archive something like that?

    EDIT:

    Using the method proposed by @RaVeN I am now using the following code:

    open(@options['filename'], 'rb') do |stream|
  stream.seek(0, IO::SEEK_END)
  queue = INotify::Notifier.new
  queue.watch(@options['filename'], :modify) do
    w.write stream.read
  end
  queue.run
end

    However now ffmpeg complaints about invalid data. Is there another method than read?

  • FFmpeg RTP streaming

    19 juillet 2016, par Johnnylin

    Can anyone show me an example code of how to use FFmpeg to encode a ".mp4" video and then output to network stream using RTP(rtp://127.0.0.1:6666). I have searched for it on google but most of them are just command line. Thanks very much.

    UPDATED:

                extern "C"{
            #include avcodec.h>
            #include avformat.h>
            #include swscale.h>
            #include avutil.h>
            #include opt.h>
            #include time.h>

            }
            #include 
            #include 
            #include 
            using namespace std;

            // compatibility with newer API
            #if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(55,28,1)
            #define av_frame_alloc avcodec_alloc_frame
            #define av_frame_free avcodec_free_frame
            #endif
            #define RNDTO2(X) ( ( (X) & 0xFFFFFFFE ))
            #define RNDTO32(X) ( ( (X) % 32 ) ? ( ( (X) + 32 ) & 0xFFFFFFE0 ) : (X) )

            //avcodec_alloc_frame is an old name


            int main(int argc, char *argv[]) {
                // Initalizing these to NULL prevents segfaults!
                AVFormatContext   *pFormatCtx = NULL;
                int               i, videoStream;
                AVCodecContext    *pCodecCtxOrig = NULL;
                AVCodecContext    *pCodecCtx = NULL;
                AVCodec           *pCodec = NULL;
                AVFrame           *pFrame = NULL;
                AVPacket          packet;
                int               frameFinished;
                int               numBytes;
                struct SwsContext *sws_ctx = NULL;
                int frame_index=0;

                if(argc < 2) {
                printf("Please provide a movie file\n");
                return -1;
                }

                // Register all formats and codecs
                av_register_all();

                //initialize network video
                avformat_network_init();


                int errorStatus = 0;
                char errorLog[128] = { 0 };
                av_log_set_level(AV_LOG_TRACE);


                //------------------ This is for local video file --------------
                // Open video file
                if(avformat_open_input(&pFormatCtx, argv[1], NULL, NULL)!=0)
                return -1; // Couldn't open file

                // Retrieve stream information
                if(avformat_find_stream_info(pFormatCtx, NULL)<0)
                return -1; // Couldn't find stream information

                // Find the first video stream
                videoStream=-1;
                for(i=0; inb_streams; i++)
                if(pFormatCtx->streams[i]->codec->codec_type==AVMEDIA_TYPE_VIDEO) {
                  videoStream=i;
                  break;
                }

                // Dump information about file onto standard error
                av_dump_format(pFormatCtx, 0, argv[1], 0);


                if(videoStream==-1)
                    return -1; // Didn't find a video stream

                // Get a pointer to the codec context for the video stream
                pCodecCtxOrig=pFormatCtx->streams[videoStream]->codec;
                // Find the decoder for the video stream
                pCodec=avcodec_find_decoder(pCodecCtxOrig->codec_id);
                if(pCodec==NULL) {
                fprintf(stderr, "Unsupported codec!\n");
                return -1; // Codec not found
                }

                // Copy context
                pCodecCtx = avcodec_alloc_context3(pCodec);
                if(avcodec_copy_context(pCodecCtx, pCodecCtxOrig) != 0) {
                fprintf(stderr, "Couldn't copy codec context");
                return -1; // Error copying codec context
                }

                // Open codec
                if(avcodec_open2(pCodecCtx, pCodec, NULL)<0)
                    return -1; // Could not open codec

                // Allocate video frame
                pFrame=av_frame_alloc();


                // use nvidia codec
                AVCodec* en_codec = avcodec_find_encoder_by_name("nvenc");
                //AVCodec* en_codec = avcodec_find_encoder(AV_CODEC_ID_H264);
                AVCodecContext* nv_codec_context = avcodec_alloc_context3(en_codec);

                nv_codec_context->bit_rate = 1244179;
                nv_codec_context->width = 1920;                               
                nv_codec_context->height = 1080;
                nv_codec_context->time_base.num = 1;                                
                nv_codec_context->time_base.den = 30;                              
                nv_codec_context->gop_size = 10;                                     
                nv_codec_context->max_b_frames = 1;                                  
                nv_codec_context->keyint_min = 1;                                     
                nv_codec_context->i_quant_factor = (float)0.71;                      
                nv_codec_context->b_frame_strategy = 20;                            
                nv_codec_context->qcompress = (float)0.6;                              
                nv_codec_context->qmin = 20;                                      
                nv_codec_context->qmax = 51;                                        
                nv_codec_context->max_qdiff = 4;                                      
                nv_codec_context->refs = 4;                                         
                nv_codec_context->trellis = 1;                                        
                nv_codec_context->pix_fmt = AV_PIX_FMT_YUV420P;                      
                //nv_codec_context->codec_id = AV_CODEC_ID_H264;
                //nv_codec_context->codec_type = AVMEDIA_TYPE_VIDEO;

                if (avcodec_open2(nv_codec_context, en_codec,NULL) < 0) {
                    fprintf(stderr, "Could not open codec\n");
                    exit(1);
                }else printf("\nH264 codec opened\n");


                /******stream*******/

                string m_output("rtp://147.8.179.229:6666");
                AVFormatContext* m_formatContext = NULL;
                AVStream* m_stream = NULL;
                if (avformat_alloc_output_context2(&m_formatContext, NULL, "H264", m_output.c_str()) < 0) {
                       cerr << "Cannot allocate output context: "
                            << av_make_error_string(errorLog, 128, errorStatus) << endl;
                       return -1;
                }

                //AVCodec* tmp_codec = avcodec_find_encoder(AV_CODEC_ID_H264);
                m_stream = avformat_new_stream(m_formatContext, en_codec);
                  if (!m_stream) {
                      cerr << "Cannot create a new stream: "
                         << av_make_error_string(errorLog, 128, errorStatus) << endl;
                    return -1;
                }


                av_dump_format(m_formatContext, 0, m_output.c_str(), 1);

                m_stream->codec->pix_fmt = AV_PIX_FMT_YUV420P;
                m_stream->codec->width = 1920;
                m_stream->codec->height = 1080;
                //m_stream->codec->codec_id = AV_CODEC_ID_H264;
                m_stream->codec->bit_rate = 40000;
                m_stream->codec->time_base.den = 30;
                m_stream->codec->time_base.num = 1;
                m_stream->time_base.den = 30;
                m_stream->time_base.num = 1;

                m_stream->codec->codec_tag = 0;
                if (m_formatContext->oformat->flags & AVFMT_GLOBALHEADER)
                    m_stream->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;


                if (!(m_formatContext->oformat->flags & AVFMT_NOFILE))
                    errorStatus = avio_open(&m_formatContext->pb, m_output.c_str(), AVIO_FLAG_WRITE);



                if ((errorStatus) < 0) {
                    cerr << "Cannot open output: "
                         << av_make_error_string(errorLog, 128, errorStatus) << endl;
                    return -1;
                }


                if (avformat_write_header(m_formatContext, NULL) < 0) {
                    cerr << "Cannot write header to stream: "
                         << av_make_error_string(errorLog, 128, errorStatus) << endl;
                    return -1;
                }


                /******stream*******/

                FILE *fp_yuv = NULL;
                fp_yuv=fopen("output.yuv","wb+");

                // Read frames and save first five frames to disk
                i=0;

                while(av_read_frame(pFormatCtx, &packet)>=0) {
                // Is this a packet from the video stream?
                    if(packet.stream_index==videoStream) {

                        // Decode video frame
                        avcodec_decode_video2(pCodecCtx, pFrame, &frameFinished, &packet);

                        // Did we get a video frame?
                        if(frameFinished) {

                            AVPacket Outpacket;
                            int got_packet_ptr;
                            av_init_packet(&Outpacket);
                            Outpacket.data = NULL;
                            Outpacket.size = 0;
                            int out_size = avcodec_encode_video2(nv_codec_context, &Outpacket, pFrame, &got_packet_ptr);
                            Outpacket.pts = av_rescale_q(pFrame->pts, m_stream->codec->time_base, m_stream->time_base);

                            fwrite(Outpacket.data,1,Outpacket.size,fp_yuv);

                            //av_write_frame(m_formatContext, &Outpacket);
                            av_interleaved_write_frame(m_formatContext, &Outpacket);

                            //Free the packet that was allocated by encoder
                            av_packet_unref(&Outpacket);
                  }
                }

                // Free the packet that was allocated by av_read_frame
                av_packet_unref(&packet);
                }

                fclose(fp_yuv);


                // Free the YUV frame
                av_frame_free(&pFrame);

                // Close the codecs
                avcodec_close(pCodecCtx);
                avcodec_close(pCodecCtxOrig);
                avcodec_close(m_stream->codec);
                avformat_free_context(m_formatContext);

                // Close the video file
                avformat_close_input(&pFormatCtx);


                return 0;
            }

    Above is my code for decoding a .mp4 file, outputting to a network stream through RTP. But it does not work. On the client side, I call VLC library to decode the stream ( VlcMedia(url, _instance) where url is rtp/h264://@147.8.179.229:6666 ). When I change the protocal to UDP, it works. However, it is not stable. The frames jumps and probably the frame lost or something wrong with the pts setting ?

    Can anyone help ? Thanks very much.

Navigation

Sites Web