Recherche avancée

Sur d’autres sites (8192)

• How to stich images into a video with resolution larger then 4K using FFMPEG ?

  14 janvier 2023, par Aviram Fireberger

  I have a folder with images that I've extracted from one video.
The resolution for each image is 5760 X 2880.
All images are in the following format :
out-1.jpg, out-2.jpg , out-3.jpg ..... out-1000.jpg

  


  I tried couple of different ways to stich them :

  


  Using CPU - libx264

  


  ffmpeg -r 30 -f image2 -s 5760X2880 -start_number 1 -i "AllFrames/out-%d.jpg" -vframes 119 -vcodec libx264 -crf 25  -pix_fmt yuv420p "/AllVideoChunks/Chunk_1.mp4"


  


  Worked well but the speed is about X0.05 only.

  


  Using GPU - h264_nvenc

  


  ffmpeg -r 30 -f image2 -s 4000X2000 -start_number 1 -i "AllFrames/out-%d.jpg" -vframes 119 -vcodec h264_nvenc -gpu  0 -preset slow -b:v 75M  -pix_fmt yuv420p"/AllVideoChunks/Chunk_1.mp4"


  


  Working very fast and high quality, but the problem is that I can't use it for images and output bigger then width 4096

  


  Using GPU - hevc_nvenc

  


  ffmpeg -r 30 -f image2 -s 5760X2880 -start_number 1 -i "AllFrames/out-%d.jpg" -vframes 119 -vcodec hevc_nvenc -gpu  0 -preset slow -b:v 75M  -pix_fmt yuv420p"/AllVideoChunks/Chunk_1.mp4"


  


  Working X10 more then the CPU at the speed of X0.5, good quality, but the problem is that I can't use it in normal players (can't play it in Unity)

  


  Is there another video codec that can work on GPU that support more then 4K resolution ?
Can I transform the 'hevc_nvenc ' output to 'h264' on GPU in higher resolution ? should I do this transformation on CPU ?

  


• avcodec/bink : Fix off by 1 error in ref end

  11 janvier 2023, par Michael Niedermayer

  avcodec/bink : Fix off by 1 error in ref end
  Fixes : out of array access
  
  Fixes : 48567/clusterfuzz-testcase-minimized-ffmpeg_AV_CODEC_ID_BINK_fuzzer-6657932926517248
  Alterantivly to this it is possibly to allocate a bigger array
  Note : oss-fuzz assigned this issue to a unrelated theora bug so the bug number matches that
  Found-by : continuous fuzzing process https://github.com/google/oss-fuzz/tree/master/projects/ffmpeg
  
  Signed-off-by : Michael Niedermayer <michael@niedermayer.cc>
  

  • [DH] libavcodec/bink.c

• Is there a pure golang implementation of aac transcode opus ? [closed]

  15 février 2023, par fanzhang

  Please note : pure golang implementation, no ffmpeg-wrapper / c-go

  


  Is there a pure golang implementation of aac transcode opus ?

  


  I've written a streaming-WebRTC gateway app that can convert av streams from streaming devices to WebRTC via pion, but now there's a tricky problem, the audio encoding provided by these media devices is usually aac(WebRTC do not support aac), I can't find a library that implements aac -> opus (or pcm -> opus) in pure go, only some library based on c-go (like this one). The c-go based library has some limitations, e.g. it can't be self-contained, so there a pure golang implementation of aac transcode opus ?

  


  The code (snippet) below is my current implementation using Glimesh's fdk-aac and hraban's opus

  


  ...

    // 音频相关配置
    // https://github.com/Glimesh/go-fdkaac
    aacDecoder := fdkaac.NewAacDecoder()
    defer func() {
        _ = aacDecoder.Close()
    }()
    aacDecoderInitDone := false

    var opusEncoder *hrabanopus.Encoder
    minAudioSampleRate := 16000
    var opusAudioBuffer []byte
    opusBlockSize := 960
    opusBufferSize := 1000
    opusFramesSize := 120

...

            // 用 AAC 的元数据初始化 AAC 编码器
            // https://github.com/winlinvip/go-fdkaac
            if tag.AACPacketType == flvio.AAC_SEQHDR {
                if !aacDecoderInitDone {
                    if err := aacDecoder.InitRaw(tagData); err != nil {
                        return errors.Wrapf(err, "从 %s.%s 的(音频元数据 %s)标签初始化 AAC 解码器失败", flowControlGroup, streamKey, hex.EncodeToString(tagData))
                    }
                    aacDecoderInitDone = true

                    logrus.Infof("从 %s.%s 的(音频元数据 %s)标签初始化了 AAC 解码器 %p", flowControlGroup, streamKey, hex.EncodeToString(tagData), aacDecoder)
                }
            } else {
                tagDataString := hex.EncodeToString(tagData)
                logrus.Tracef("使用已初始化了的 AAC 解码器 %p 解码 %s.%s 的音频数据 %s", aacDecoder, flowControlGroup, streamKey, tagDataString)

                // 解码 AAC 为 PCM
                decodeResult, err := aacDecoder.Decode(tagData)
                if err != nil {
                    return errors.Wrapf(err, "从 %s.%s 的标签解码 PCM 数据失败", flowControlGroup, streamKey)
                }

                rate := aacDecoder.SampleRate()
                channels := aacDecoder.NumChannels()

                if rate < minAudioSampleRate {
                    logrus.Tracef("从 %s.%s 的标签解码 PCM 数据得到音频采样频 %d小于要求的最小值(%d),将忽略编码opus的操作", flowControlGroup, streamKey, rate, minAudioSampleRate)
                } else {
                    if opusEncoder == nil {
                        oEncoder, err := hrabanopus.NewEncoder(rate, channels, hrabanopus.AppAudio)
                        if err != nil {
                            return err
                        }
                        opusEncoder = oEncoder
                    }

                    // https://github.com/Glimesh/waveguide/blob/a7e7745be31d0a112aa6adb6437df03960c4a5c5/internal/inputs/rtmp/rtmp.go#L289
                    // https://github.com/xiangxud/rtmp-to-webrtc/blob/07d7da9197cedc3756a1c87389806c3670b9c909/rtmp.go#L168
                    for opusAudioBuffer = append(opusAudioBuffer, decodeResult...); len(opusAudioBuffer) >= opusBlockSize*4; opusAudioBuffer = opusAudioBuffer[opusBlockSize*4:] {
                        pcm16 := make([]int16, opusBlockSize*2)
                        pcm16len := len(pcm16)
                        for i := 0; i < pcm16len; i++ {
                            pcm16[i] = int16(binary.LittleEndian.Uint16(opusAudioBuffer[i*2:]))
                        }
                        opusData := make([]byte, opusBufferSize)
                        n, err := opusEncoder.Encode(pcm16, opusData)
                        if err != nil {
                            return err
                        }
                        opusOutput := opusData[:n]

                        // https://datatracker.ietf.org/doc/html/rfc6716#section-2.1.4
                        // Opus can encode frames of 2.5, 5, 10, 20, 40, or 60 ms.  It can also
                        // combine multiple frames into packets of up to 120 ms.  For real-time
                        // applications, sending fewer packets per second reduces the bitrate,
                        // since it reduces the overhead from IP, UDP, and RTP headers.
                        // However, it increases latency and sensitivity to packet losses, as
                        // losing one packet constitutes a loss of a bigger chunk of audio.
                        // Increasing the frame duration also slightly improves coding
                        // efficiency, but the gain becomes small for frame sizes above 20 ms.
                        // For this reason, 20 ms frames are a good choice for most
                        // applications.
                        sampleDuration := time.Duration(opusFramesSize) * time.Millisecond
                        sample := media.Sample{
                            Data:     opusOutput,
                            Duration: sampleDuration,
                        }
                        if err := audioTrack.WriteSample(sample); err != nil {
                            return err
                        }
                    }
                }
            }

...


  


  Also, is there a pure-go ffmpeg alternative ? not wrappers