Corrupt .webm file in version 4

[AbolfazlAkhtari]

Your environment.

• Version: v4.0.1
• Browser: -
• Other Information: -

What did you do?

I've set up a webrtc media server using your package. Peers connect to this server and send their tracks to the server and the server broadcasts the received track to other peers. I've followed Save To Disk Example that you have provided to set up a webm saver. This was working correctly until today when I decided to upgrade pion/webrtc/v3 into pion/webrtc/v4

Now with v4 all set up. Everything is working as before. Peers connect to the server and can send media, the media will show correctly on other peers' screens. However, the saved file is broken (please see the attached image to know what I mean by broken)

These are my saver file codes:

package webm_saver

import (
	"fmt"
	"github.com/at-wat/ebml-go/webm"
	"github.com/pion/interceptor/pkg/jitterbuffer"
	"github.com/pion/rtp"
	"github.com/pion/rtp/codecs"
	"github.com/pion/webrtc/v4/pkg/media/samplebuilder"
	"os"
	"poc/pkg/exception"
	"time"
)

const (
	naluTypeBitmask = 0b11111
	naluTypeSPS     = 7
)

type WebmSaver struct {
	AudioWriter, VideoWriter       webm.BlockWriteCloser
	AudioBuilder, VideoBuilder     *samplebuilder.SampleBuilder
	AudioTimestamp, VideoTimestamp time.Duration

	h264JitterBuffer   *jitterbuffer.JitterBuffer
	lastVideoTimestamp uint32

	Status   bool
	UserId   uint
	RoomCode string
	FilePath *string
}

func NewWebmSaver(userId uint, roomCode string) *WebmSaver {
	return &WebmSaver{
		AudioBuilder:     samplebuilder.New(10, &codecs.OpusPacket{}, 48000),
		VideoBuilder:     samplebuilder.New(10, &codecs.VP8Packet{}, 90000),
		h264JitterBuffer: jitterbuffer.New(),
		Status:           true,
		UserId:           userId,
		RoomCode:         roomCode,
	}
}

func (s *WebmSaver) Close() {
	s.Status = false

	fmt.Printf("Finalizing webm...\n")
	if s.AudioWriter != nil {
		if err := s.AudioWriter.Close(); err != nil {
			exception.ReportException(err)
		}
	}
	if s.VideoWriter != nil {
		if err := s.VideoWriter.Close(); err != nil {
			exception.ReportException(err)
		}
	}
}

func (s *WebmSaver) PushOpus(rtpPacket *rtp.Packet) {
	s.AudioBuilder.Push(rtpPacket)

	for {
		sample := s.AudioBuilder.Pop()
		if sample == nil {
			return
		}
		if s.AudioWriter != nil {
			s.AudioTimestamp += sample.Duration
			if _, err := s.AudioWriter.Write(true, int64(s.AudioTimestamp/time.Millisecond), sample.Data); err != nil {
				exception.ReportException(err)
			}
		}
	}
}

func (s *WebmSaver) PushH264(rtpPacket *rtp.Packet) {
	s.h264JitterBuffer.Push(rtpPacket)

	pkt, err := s.h264JitterBuffer.Peek(true)
	if err != nil {
		return
	}

	pkts := []*rtp.Packet{pkt}
	for {
		pkt, err = s.h264JitterBuffer.PeekAtSequence(pkts[len(pkts)-1].SequenceNumber + 1)
		if err != nil {
			return
		}

		// We have popped a whole frame, lets write it
		if pkts[0].Timestamp != pkt.Timestamp {
			break
		}

		pkts = append(pkts, pkt)
	}

	h264Packet := &codecs.H264Packet{}
	data := []byte{}
	for i := range pkts {
		if _, err = s.h264JitterBuffer.PopAtSequence(pkts[i].SequenceNumber); err != nil {
			panic(err)
		}

		out, err := h264Packet.Unmarshal(pkts[i].Payload)
		if err != nil {
			panic(err)
		}
		data = append(data, out...)
	}

	videoKeyframe := (data[4] & naluTypeBitmask) == naluTypeSPS
	if s.VideoWriter == nil && videoKeyframe {
		if s.VideoWriter == nil || s.AudioWriter == nil {
			s.InitWriter(true, 1280, 720)
		}
	}

	samples := uint32(0)
	if s.lastVideoTimestamp != 0 {
		samples = pkts[0].Timestamp - s.lastVideoTimestamp
	}
	s.lastVideoTimestamp = pkts[0].Timestamp

	if s.VideoWriter != nil {
		s.VideoTimestamp += time.Duration(float64(samples) / float64(90000) * float64(time.Second))
		if _, err := s.VideoWriter.Write(videoKeyframe, int64(s.VideoTimestamp/time.Millisecond), data); err != nil {
			panic(err)
		}
	}
}

func (s *WebmSaver) PushVP8(rtpPacket *rtp.Packet) {
	s.VideoBuilder.Push(rtpPacket)

	for {
		sample := s.VideoBuilder.Pop()
		if sample == nil {
			return
		}
		// Read VP8 header.
		videoKeyframe := (sample.Data[0]&0x1 == 0)
		if videoKeyframe {
			// Keyframe has frame information.
			raw := uint(sample.Data[6]) | uint(sample.Data[7])<<8 | uint(sample.Data[8])<<16 | uint(sample.Data[9])<<24
			width := int(raw & 0x3FFF)
			height := int((raw >> 16) & 0x3FFF)

			if s.VideoWriter == nil || s.AudioWriter == nil {
				// Initialize WebM webm_saver using received frame size.
				s.InitWriter(false, width, height)
			}
		}
		if s.VideoWriter != nil {
			s.VideoTimestamp += sample.Duration
			if _, err := s.VideoWriter.Write(videoKeyframe, int64(s.VideoTimestamp/time.Millisecond), sample.Data); err != nil {
				exception.ReportException(err)
			}
		}
	}
}

func (s *WebmSaver) InitWriter(isH264 bool, width, height int) {
	filePath := fmt.Sprintf("storage/records/%v-%v-%v.webm", s.UserId, s.RoomCode, time.Now().Unix())
	w, err := os.OpenFile(filePath, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0o600)
	if err != nil {
		exception.ReportException(err)
	}
	s.FilePath = &filePath

	videoMimeType := "V_VP8"
	if isH264 {
		videoMimeType = "V_MPEG4/ISO/AVC"
	}

	ws, err := webm.NewSimpleBlockWriter(w,
		[]webm.TrackEntry{
			{
				Name:            "Audio",
				TrackNumber:     1,
				TrackUID:        12345,
				CodecID:         "A_OPUS",
				TrackType:       2,
				DefaultDuration: 20000000,
				Audio: &webm.Audio{
					SamplingFrequency: 48000.0,
					Channels:          2,
				},
			}, {
				Name:            "Video",
				TrackNumber:     2,
				TrackUID:        67890,
				CodecID:         videoMimeType,
				TrackType:       1,
				DefaultDuration: 33333333,
				Video: &webm.Video{
					PixelWidth:  uint64(width),
					PixelHeight: uint64(height),
				},
			},
		})
	if err != nil {
		panic(err)
	}
	s.AudioWriter = ws[0]
	s.VideoWriter = ws[1]
}

As I know, the video is coming as a vp8 file.

Do you know why this problem happened and why it didn't happen while I was using version 3?

What did you expect?

I expected the video file to save correctly as it did with the previous version.

What happened?

The saved .webm file is corrupt