go-ffmpeg-ffi/decoder_queue_test.go at master · bstkhq/go-ffmpeg-ffi · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
//go:build amd64 || arm64

package ffmpeg

import (
	"testing"

	"github.com/bstkhq/go-ffmpeg-ffi/avcodec"
	"github.com/bstkhq/go-ffmpeg-ffi/avutil"
)

func TestDecoderPacketQueuePreservesDemuxOrder(t *testing.T) {
	if !requireFFmpeg(t) {
		return
	}

	d := Decoder{
		packet:         avcodec.PacketAlloc(),
		frame:          avutil.FrameAlloc(),
		videoStreamIdx: 0,
		audioStreamIdx: 1,
	}
	if d.packet == nil || d.frame == nil {
		t.Fatal("failed to allocate decoder test data")
	}
	t.Cleanup(func() {
		d.clearDecodeStateLocked()
		avcodec.PacketFree(&d.packet)
		avutil.FrameFree(&d.frame)
	})

	for _, packet := range []struct {
		streamIndex int32
		pts         int64
	}{
		{streamIndex: 0, pts: 10},
		{streamIndex: 1, pts: 20},
		{streamIndex: 0, pts: 30},
		{streamIndex: 1, pts: 40},
	} {
		avcodec.SetPacketStreamIndex(d.packet, packet.streamIndex)
		avcodec.SetPacketPTS(d.packet, packet.pts)
		queued, err := d.queueCurrentPacketLocked()
		if err != nil {
			t.Fatal(err)
		}
		if !queued {
			t.Fatalf("stream %d was not queued", packet.streamIndex)
		}
	}

	packet := d.popQueuedPacketLocked(MediaTypeVideo)
	if packet == nil || avcodec.GetPacketPTS(packet) != 10 {
		t.Fatal("targeted video pop did not return the first video packet")
	}
	avcodec.PacketFree(&packet)

	mediaType, packet := d.popFirstQueuedPacketLocked()
	if mediaType != MediaTypeAudio || avcodec.GetPacketPTS(packet) != 20 {
		t.Fatalf("first remaining packet = (%v, %d), want audio PTS 20", mediaType, avcodec.GetPacketPTS(packet))
	}
	avcodec.PacketFree(&packet)

	mediaType, packet = d.popFirstQueuedPacketLocked()
	if mediaType != MediaTypeVideo || avcodec.GetPacketPTS(packet) != 30 {
		t.Fatalf("second remaining packet = (%v, %d), want video PTS 30", mediaType, avcodec.GetPacketPTS(packet))
	}
	avcodec.PacketFree(&packet)

	packet = d.popQueuedPacketLocked(MediaTypeAudio)
	if packet == nil || avcodec.GetPacketPTS(packet) != 40 {
		t.Fatal("targeted audio pop did not return the remaining audio packet")
	}
	avcodec.PacketFree(&packet)

	if d.packetQueue.len() != 0 {
		t.Fatalf("queue length = %d, want 0", d.packetQueue.len())
	}
}

func TestDecoderPacketPoolReusesReleasedPackets(t *testing.T) {
	if !requireFFmpeg(t) {
		return
	}

	source := avcodec.PacketAlloc()
	if source == nil {
		t.Fatal("failed to allocate source packet")
	}
	defer avcodec.PacketFree(&source)

	d := Decoder{}
	t.Cleanup(func() { d.clearPacketPoolLocked() })

	avcodec.SetPacketPTS(source, 10)
	first, err := d.clonePacketLocked(source)
	if err != nil {
		t.Fatal(err)
	}
	firstAddress := first
	d.recyclePacketLocked(&first)
	if first != nil {
		t.Fatal("recycled packet still has an owner")
	}

	avcodec.SetPacketPTS(source, 20)
	second, err := d.clonePacketLocked(source)
	if err != nil {
		t.Fatal(err)
	}
	if second != firstAddress {
		t.Fatal("packet allocation was not reused")
	}
	if pts := avcodec.GetPacketPTS(second); pts != 20 {
		t.Fatalf("reused packet PTS = %d, want 20", pts)
	}
	d.recyclePacketLocked(&second)
}

func TestDecoderPacketPoolIsBounded(t *testing.T) {
	if !requireFFmpeg(t) {
		return
	}

	d := Decoder{}
	t.Cleanup(func() { d.clearPacketPoolLocked() })
	for range decoderPacketPoolLimit + 1 {
		packet := avcodec.PacketAlloc()
		if packet == nil {
			t.Fatal("failed to allocate packet")
		}
		d.recyclePacketLocked(&packet)
	}

	if count := d.packetPool.len(); count != decoderPacketPoolLimit {
		t.Fatalf("cached packets = %d, want %d", count, decoderPacketPoolLimit)
	}
}