Recherche avancée

Sur d’autres sites (6884)

• How run 2 script python in same time ?

  28 février 2021, par FoxFr

  I explain my need : i wish to run ffmpeg with a python script (that's ok) but i need to know of the script is launched with a blink led connected on the GPIO of my RPI, But i dont know why i can launch my script and start le blink (or just a led on)

  


  Can u help me ? show me the light, please ;)

  


  import RPi.GPIO as GPIO
import time
import os

GPIO.setwarnings(False)
GPIO.setmode(GPIO.BCM)
GPIO.setup(4, GPIO.OUT)
GPIO.setup(22,GPIO.IN)

# fonction qui fait clignoter la led 
def blink(led):
        GPIO.output(led,True)
        time.sleep(0.5)
        GPIO.output(led,False)
        time.sleep(1)

# input of the switch will change the state of the LED
while 1:
        if ( GPIO.input(22) == True ):
                print "start broadcast"
                os.system("sudo /home/pi/videopi/webcam.sh")
                blink(4) << not ok like this !
                time.sleep(1)


  


• Ffmpeg video and audio issues

  17 décembre 2020, par Expressingx

  I'm using ffmpeg libav and I have two problems. I'm automatically finding the decoder for audio and video input, but encoding to H264/AAC, always.

  


  The first problem is that if the camera is capturing in low light the file gets messed up. E.g. If I record 12 secs, the resulting file is indeed 12 secs, but the actual frames are playing till 7 sec and also it is 'fast-forwarded', like the speed is X2, X3 than the actual frame representation. While capturing with good light everything is fine. Not really sure what's happening.

  


  Second problem is video and audio sync. First 10-15mins the synchronization is fine, but after that audio gradually falls behind. E.g. 1 hour file, at the end audio is behind 2-3 seconds.

  


  Some code :

  


  Creating decoders

  


  private void CreateAudioDecoder()
    {
        AVCodecParameters* audioCodecParams = InputFormatContext->streams[AudioStreamIndex]->codecpar;
        AVCodec* audioDecoder = ffmpeg.avcodec_find_decoder(audioCodecParams->codec_id);

        AudioDecodeContext = ffmpeg.avcodec_alloc_context3(audioDecoder);

        if (ffmpeg.avcodec_parameters_to_context(AudioDecodeContext, audioCodecParams) < 0)
        {
        }

        if (ffmpeg.avcodec_open2(AudioDecodeContext, audioDecoder, null) < 0)
        {
        }
    }

    private void CreateVideoDecoder()
    {
        AVStream* videoStream = InputFormatContext->streams[VideoStreamIndex];
        AVCodecParameters* videoCodecParams = videoStream->codecpar;
        AVCodec* videoDecoder = ffmpeg.avcodec_find_decoder(videoCodecParams->codec_id);

        VideoDecodeContext = ffmpeg.avcodec_alloc_context3(videoDecoder);

        if (ffmpeg.avcodec_parameters_to_context(VideoDecodeContext, videoCodecParams) < 0)
        {
        }

        if (ffmpeg.avcodec_open2(VideoDecodeContext, videoDecoder, null) < 0)
        {
        }
    }


  


  Input format context :

  


  private AVFormatContext* CreateFormatContext()
    {
        AVDictionary* options = null;

        ffmpeg.av_dict_set(&options, "packet-buffering", "0", 0);
        ffmpeg.av_dict_set(&options, "sync", "1", 0);
        ffmpeg.av_dict_set(&options, "rtsp_transport", "tcp", 0);
        ffmpeg.av_dict_set(&options, "reconnect", "1", 0);
        ffmpeg.av_dict_set(&options, "max_delay", "0", 0);
        ffmpeg.av_dict_set(&options, "reorder_queue_size", "0", 0);
        ffmpeg.av_dict_set(&options, "skip_frame", "8", 0);
        ffmpeg.av_dict_set(&options, "skip_loop_filter", "48", 0);
        ffmpeg.av_dict_set(&options, "rtbufsize", "1500M", 0);

        AVFormatContext* pInputFmtCtx = ffmpeg.avformat_alloc_context();

        AVInputFormat* inputFormat = null;

        if (!string.IsNullOrEmpty(_format))
        {
            inputFormat = ffmpeg.av_find_input_format(_format);

            if (inputFormat == null)
            {
            }
        }

        int ret = ffmpeg.avformat_open_input(&pInputFmtCtx, _streamUrl, inputFormat, &options);

        if (ret != 0)
        {
        }

        return pInputFmtCtx;
    }


  


  Output context

  


  private AVFormatContext* CreateOutputContext()
    {
        AVFormatContext* pOutputFmtCtx = null;

        if (ffmpeg.avformat_alloc_output_context2(&pOutputFmtCtx, null, null, _fileName) != 0)
        {
        }

        return pOutputFmtCtx;
    }


  


  Encoders

  


  private void CreateH264Encoder(AVStream* inputStream, AVStream* outputStream)
    {
        AVRational framerate = ffmpeg.av_guess_frame_rate(_inputContext.InputFormatContext, inputStream, null);

        AVCodec* videoEncoder;
            videoEncoder = ffmpeg.avcodec_find_encoder_by_name("h264_qsv");
            if (videoEncoder == null)
            {
                videoEncoder = ffmpeg.avcodec_find_encoder_by_name("libx264");
                PixelFormat = AVPixelFormat.AV_PIX_FMT_YUV420P;
            }

        if (videoEncoder == null)
        {
        }

        VideoEncodeContext = ffmpeg.avcodec_alloc_context3(videoEncoder);

        if (VideoEncodeContext == null)
        {
        }

        VideoEncodeContext->width = _inputContext.VideoDecodeContext->width;
        VideoEncodeContext->height = _inputContext.VideoDecodeContext->height;
        VideoEncodeContext->pix_fmt = PixelFormat;
        VideoEncodeContext->bit_rate = H264_ENCODER_BIT_RATE; // 2 * 1000 * 1000
        VideoEncodeContext->rc_buffer_size = H264_ENCODER_BUFFER_SIZE; // 4 * 1000 * 1000
        VideoEncodeContext->rc_max_rate = H264_ENCODER_MAX_RATE; // 2 * 1000 * 1000
        VideoEncodeContext->rc_min_rate = H264_ENCODER_MIN_RATE; // 3 * 1000 * 1000
        VideoEncodeContext->framerate = framerate;
        VideoEncodeContext->max_b_frames = 0;
        VideoEncodeContext->time_base = ffmpeg.av_inv_q(framerate);
        VideoEncodeContext->flags |= ffmpeg.AV_CODEC_FLAG_GLOBAL_HEADER;

        ffmpeg.av_opt_set(VideoEncodeContext->priv_data, "preset", "slow", 0);
        ffmpeg.av_opt_set(VideoEncodeContext->priv_data, "vprofile", "baseline", 0);

        if (ffmpeg.avcodec_open2(VideoEncodeContext, videoEncoder, null) < 0)
        {
        }

        ffmpeg.avcodec_parameters_from_context(outputStream->codecpar, VideoEncodeContext);
    }

    private void CreateAacEncoder(AVStream* outStream)
    {
        AVCodec* audioEncoder = ffmpeg.avcodec_find_encoder(AVCodecID.AV_CODEC_ID_AAC);

        if (audioEncoder == null)

        AudioEncodeContext = ffmpeg.avcodec_alloc_context3(audioEncoder);

        if (AudioEncodeContext == null)

        AudioEncodeContext->bit_rate = 96000;
        AudioEncodeContext->sample_fmt = audioEncoder->sample_fmts[0];
        AudioEncodeContext->sample_rate = _inputContext.AudioDecodeContext->sample_rate;
        AudioEncodeContext->channel_layout = (ulong)ffmpeg.av_get_default_channel_layout(2);
        AudioEncodeContext->channels = 2;

        outStream->time_base.den = _inputContext.AudioDecodeContext->sample_rate;
        outStream->time_base.num = 1;

        AudioEncodeContext->flags |= ffmpeg.AV_CODEC_FLAG_GLOBAL_HEADER;

        if (ffmpeg.avcodec_open2(AudioEncodeContext, audioEncoder, null) < 0)

        ffmpeg.avcodec_parameters_from_context(outStream->codecpar, AudioEncodeContext);
    }


  


  I would really appreciate any help.

  


• fate/matroska : Add test for mastering display metadata

  17 février 2021, par Andreas Rheinhardt

  fate/matroska : Add test for mastering display metadata
  The FATE suite already contains a file containing mastering display
  
  and content light level metadata : Meridian-Apple_ProResProxy-HDR10.mxf
  
  This file is used to test both the Matroska muxer and demuxer.
  Reviewed-by : Ridley Combs <rcombs@rcombs.me>
  
  Signed-off-by : Andreas Rheinhardt <andreas.rheinhardt@gmail.com>
  

  • [DH] tests/fate/matroska.mak
  • [DH] tests/ref/fate/matroska-mastering-display-metadata