Recherche avancée

Sur d’autres sites (11143)

• lavu/tx : add DCT-II implementation

  19 novembre 2022, par Lynne

  lavu/tx : add DCT-II implementation
  

  • [DH] libavutil/tx.h
  • [DH] libavutil/tx_template.c

• MissingPluginException(No implementation found for method getLogLevel on channel flutter.arthenica.com/ffmpeg_kit)

  21 février 2023, par Gowthamkumar M

  I'm using ffmpeg video conversion in flutter. It's working fine in foreground but when I tried to run it in background using flutter_background_service : ^2.4.6 its throwing the below error.

  


  ════════ Exception caught by services library ══════════════════════════════════&#xA;The following MissingPluginException was thrown while activating platform stream on channel flutter.arthenica.com/ffmpeg_kit_event:&#xA;&#xA;MissingPluginException(No implementation found for method listen on channel flutter.arthenica.com/ffmpeg_kit_event)&#xA;&#xA;When the exception was thrown, this was the stack&#xA;\#0 MethodChannel.\_invokeMethod&#xA;platform_channel.dart:294&#xA;\<asynchronous>&#xA;\#1 EventChannel.receiveBroadcastStream.\<anonymous>&#xA;platform_channel.dart:637&#xA;\<asynchronous>&#xA;</asynchronous></anonymous></asynchronous>

  


  I have updated the flutter and pub packages and other possible solutions which is provided in different community.

  


  below github ticket is for reference.

  


  https://github.com/arthenica/ffmpeg-kit/issues/461

  


• 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