Alessandro Ros
3 years ago
committed by
GitHub
47 changed files with 70 additions and 8846 deletions
@ -1,127 +0,0 @@ |
|||||||
package hls |
|
||||||
|
|
||||||
import ( |
|
||||||
"context" |
|
||||||
"fmt" |
|
||||||
"net/url" |
|
||||||
"time" |
|
||||||
|
|
||||||
"github.com/aler9/gortsplib/v2/pkg/format" |
|
||||||
|
|
||||||
"github.com/aler9/rtsp-simple-server/internal/logger" |
|
||||||
) |
|
||||||
|
|
||||||
const ( |
|
||||||
clientMPEGTSEntryQueueSize = 100 |
|
||||||
clientFMP4MaxPartTracksPerSegment = 200 |
|
||||||
clientLiveStartingInvPosition = 3 |
|
||||||
clientLiveMaxInvPosition = 5 |
|
||||||
clientMaxDTSRTCDiff = 10 * time.Second |
|
||||||
) |
|
||||||
|
|
||||||
func clientAbsoluteURL(base *url.URL, relative string) (*url.URL, error) { |
|
||||||
u, err := url.Parse(relative) |
|
||||||
if err != nil { |
|
||||||
return nil, err |
|
||||||
} |
|
||||||
return base.ResolveReference(u), nil |
|
||||||
} |
|
||||||
|
|
||||||
// ClientLogger allows to receive log lines.
|
|
||||||
type ClientLogger interface { |
|
||||||
Log(level logger.Level, format string, args ...interface{}) |
|
||||||
} |
|
||||||
|
|
||||||
// Client is a HLS client.
|
|
||||||
type Client struct { |
|
||||||
fingerprint string |
|
||||||
logger ClientLogger |
|
||||||
|
|
||||||
ctx context.Context |
|
||||||
ctxCancel func() |
|
||||||
onTracks func([]format.Format) error |
|
||||||
onData map[format.Format]func(time.Duration, interface{}) |
|
||||||
playlistURL *url.URL |
|
||||||
|
|
||||||
// out
|
|
||||||
outErr chan error |
|
||||||
} |
|
||||||
|
|
||||||
// NewClient allocates a Client.
|
|
||||||
func NewClient( |
|
||||||
playlistURLStr string, |
|
||||||
fingerprint string, |
|
||||||
logger ClientLogger, |
|
||||||
) (*Client, error) { |
|
||||||
playlistURL, err := url.Parse(playlistURLStr) |
|
||||||
if err != nil { |
|
||||||
return nil, err |
|
||||||
} |
|
||||||
|
|
||||||
ctx, ctxCancel := context.WithCancel(context.Background()) |
|
||||||
|
|
||||||
c := &Client{ |
|
||||||
fingerprint: fingerprint, |
|
||||||
logger: logger, |
|
||||||
ctx: ctx, |
|
||||||
ctxCancel: ctxCancel, |
|
||||||
playlistURL: playlistURL, |
|
||||||
onData: make(map[format.Format]func(time.Duration, interface{})), |
|
||||||
outErr: make(chan error, 1), |
|
||||||
} |
|
||||||
|
|
||||||
return c, nil |
|
||||||
} |
|
||||||
|
|
||||||
// Start starts the client.
|
|
||||||
func (c *Client) Start() { |
|
||||||
go c.run() |
|
||||||
} |
|
||||||
|
|
||||||
// Close closes all the Client resources.
|
|
||||||
func (c *Client) Close() { |
|
||||||
c.ctxCancel() |
|
||||||
} |
|
||||||
|
|
||||||
// Wait waits for any error of the Client.
|
|
||||||
func (c *Client) Wait() chan error { |
|
||||||
return c.outErr |
|
||||||
} |
|
||||||
|
|
||||||
// OnTracks sets a callback that is called when tracks are read.
|
|
||||||
func (c *Client) OnTracks(cb func([]format.Format) error) { |
|
||||||
c.onTracks = cb |
|
||||||
} |
|
||||||
|
|
||||||
// OnData sets a callback that is called when data arrives.
|
|
||||||
func (c *Client) OnData(forma format.Format, cb func(time.Duration, interface{})) { |
|
||||||
c.onData[forma] = cb |
|
||||||
} |
|
||||||
|
|
||||||
func (c *Client) run() { |
|
||||||
c.outErr <- c.runInner() |
|
||||||
} |
|
||||||
|
|
||||||
func (c *Client) runInner() error { |
|
||||||
rp := newClientRoutinePool() |
|
||||||
|
|
||||||
dl := newClientDownloaderPrimary( |
|
||||||
c.playlistURL, |
|
||||||
c.fingerprint, |
|
||||||
c.logger, |
|
||||||
rp, |
|
||||||
c.onTracks, |
|
||||||
c.onData, |
|
||||||
) |
|
||||||
rp.add(dl) |
|
||||||
|
|
||||||
select { |
|
||||||
case err := <-rp.errorChan(): |
|
||||||
rp.close() |
|
||||||
return err |
|
||||||
|
|
||||||
case <-c.ctx.Done(): |
|
||||||
rp.close() |
|
||||||
return fmt.Errorf("terminated") |
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,297 +0,0 @@ |
|||||||
package hls |
|
||||||
|
|
||||||
import ( |
|
||||||
"context" |
|
||||||
"crypto/sha256" |
|
||||||
"crypto/tls" |
|
||||||
"encoding/hex" |
|
||||||
"fmt" |
|
||||||
"io" |
|
||||||
"net/http" |
|
||||||
"net/url" |
|
||||||
"strings" |
|
||||||
"time" |
|
||||||
|
|
||||||
"github.com/aler9/gortsplib/v2/pkg/format" |
|
||||||
gm3u8 "github.com/grafov/m3u8" |
|
||||||
|
|
||||||
"github.com/aler9/rtsp-simple-server/internal/hls/m3u8" |
|
||||||
"github.com/aler9/rtsp-simple-server/internal/logger" |
|
||||||
) |
|
||||||
|
|
||||||
func clientDownloadPlaylist(ctx context.Context, httpClient *http.Client, ur *url.URL) (m3u8.Playlist, error) { |
|
||||||
req, err := http.NewRequestWithContext(ctx, http.MethodGet, ur.String(), nil) |
|
||||||
if err != nil { |
|
||||||
return nil, err |
|
||||||
} |
|
||||||
|
|
||||||
res, err := httpClient.Do(req) |
|
||||||
if err != nil { |
|
||||||
return nil, err |
|
||||||
} |
|
||||||
defer res.Body.Close() |
|
||||||
|
|
||||||
if res.StatusCode != http.StatusOK { |
|
||||||
return nil, fmt.Errorf("bad status code: %d", res.StatusCode) |
|
||||||
} |
|
||||||
|
|
||||||
byts, err := io.ReadAll(res.Body) |
|
||||||
if err != nil { |
|
||||||
return nil, err |
|
||||||
} |
|
||||||
|
|
||||||
return m3u8.Unmarshal(byts) |
|
||||||
} |
|
||||||
|
|
||||||
func pickLeadingPlaylist(variants []*gm3u8.Variant) *gm3u8.Variant { |
|
||||||
var candidates []*gm3u8.Variant //nolint:prealloc
|
|
||||||
for _, v := range variants { |
|
||||||
if v.Codecs != "" && !codecParametersAreSupported(v.Codecs) { |
|
||||||
continue |
|
||||||
} |
|
||||||
candidates = append(candidates, v) |
|
||||||
} |
|
||||||
if candidates == nil { |
|
||||||
return nil |
|
||||||
} |
|
||||||
|
|
||||||
// pick the variant with the greatest bandwidth
|
|
||||||
var leadingPlaylist *gm3u8.Variant |
|
||||||
for _, v := range candidates { |
|
||||||
if leadingPlaylist == nil || |
|
||||||
v.VariantParams.Bandwidth > leadingPlaylist.VariantParams.Bandwidth { |
|
||||||
leadingPlaylist = v |
|
||||||
} |
|
||||||
} |
|
||||||
return leadingPlaylist |
|
||||||
} |
|
||||||
|
|
||||||
func pickAudioPlaylist(alternatives []*gm3u8.Alternative, groupID string) *gm3u8.Alternative { |
|
||||||
candidates := func() []*gm3u8.Alternative { |
|
||||||
var ret []*gm3u8.Alternative |
|
||||||
for _, alt := range alternatives { |
|
||||||
if alt.GroupId == groupID { |
|
||||||
ret = append(ret, alt) |
|
||||||
} |
|
||||||
} |
|
||||||
return ret |
|
||||||
}() |
|
||||||
if candidates == nil { |
|
||||||
return nil |
|
||||||
} |
|
||||||
|
|
||||||
// pick the default audio playlist
|
|
||||||
for _, alt := range candidates { |
|
||||||
if alt.Default { |
|
||||||
return alt |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
// alternatively, pick the first one
|
|
||||||
return candidates[0] |
|
||||||
} |
|
||||||
|
|
||||||
type clientTimeSync interface{} |
|
||||||
|
|
||||||
type clientDownloaderPrimary struct { |
|
||||||
primaryPlaylistURL *url.URL |
|
||||||
logger ClientLogger |
|
||||||
onTracks func([]format.Format) error |
|
||||||
onData map[format.Format]func(time.Duration, interface{}) |
|
||||||
rp *clientRoutinePool |
|
||||||
|
|
||||||
httpClient *http.Client |
|
||||||
leadingTimeSync clientTimeSync |
|
||||||
|
|
||||||
// in
|
|
||||||
streamTracks chan []format.Format |
|
||||||
|
|
||||||
// out
|
|
||||||
startStreaming chan struct{} |
|
||||||
leadingTimeSyncReady chan struct{} |
|
||||||
} |
|
||||||
|
|
||||||
func newClientDownloaderPrimary( |
|
||||||
primaryPlaylistURL *url.URL, |
|
||||||
fingerprint string, |
|
||||||
logger ClientLogger, |
|
||||||
rp *clientRoutinePool, |
|
||||||
onTracks func([]format.Format) error, |
|
||||||
onData map[format.Format]func(time.Duration, interface{}), |
|
||||||
) *clientDownloaderPrimary { |
|
||||||
var tlsConfig *tls.Config |
|
||||||
if fingerprint != "" { |
|
||||||
tlsConfig = &tls.Config{ |
|
||||||
InsecureSkipVerify: true, |
|
||||||
VerifyConnection: func(cs tls.ConnectionState) error { |
|
||||||
h := sha256.New() |
|
||||||
h.Write(cs.PeerCertificates[0].Raw) |
|
||||||
hstr := hex.EncodeToString(h.Sum(nil)) |
|
||||||
fingerprintLower := strings.ToLower(fingerprint) |
|
||||||
|
|
||||||
if hstr != fingerprintLower { |
|
||||||
return fmt.Errorf("server fingerprint do not match: expected %s, got %s", |
|
||||||
fingerprintLower, hstr) |
|
||||||
} |
|
||||||
|
|
||||||
return nil |
|
||||||
}, |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
return &clientDownloaderPrimary{ |
|
||||||
primaryPlaylistURL: primaryPlaylistURL, |
|
||||||
logger: logger, |
|
||||||
onTracks: onTracks, |
|
||||||
onData: onData, |
|
||||||
rp: rp, |
|
||||||
httpClient: &http.Client{ |
|
||||||
Transport: &http.Transport{ |
|
||||||
TLSClientConfig: tlsConfig, |
|
||||||
}, |
|
||||||
}, |
|
||||||
streamTracks: make(chan []format.Format), |
|
||||||
startStreaming: make(chan struct{}), |
|
||||||
leadingTimeSyncReady: make(chan struct{}), |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
func (d *clientDownloaderPrimary) run(ctx context.Context) error { |
|
||||||
d.logger.Log(logger.Debug, "downloading primary playlist %s", d.primaryPlaylistURL) |
|
||||||
|
|
||||||
pl, err := clientDownloadPlaylist(ctx, d.httpClient, d.primaryPlaylistURL) |
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
|
|
||||||
streamCount := 0 |
|
||||||
|
|
||||||
switch plt := pl.(type) { |
|
||||||
case *m3u8.MediaPlaylist: |
|
||||||
d.logger.Log(logger.Debug, "primary playlist is a stream playlist") |
|
||||||
ds := newClientDownloaderStream( |
|
||||||
true, |
|
||||||
d.httpClient, |
|
||||||
d.primaryPlaylistURL, |
|
||||||
plt, |
|
||||||
d.logger, |
|
||||||
d.rp, |
|
||||||
d.onStreamTracks, |
|
||||||
d.onSetLeadingTimeSync, |
|
||||||
d.onGetLeadingTimeSync, |
|
||||||
d.onData, |
|
||||||
) |
|
||||||
d.rp.add(ds) |
|
||||||
streamCount++ |
|
||||||
|
|
||||||
case *m3u8.MasterPlaylist: |
|
||||||
leadingPlaylist := pickLeadingPlaylist(plt.Variants) |
|
||||||
if leadingPlaylist == nil { |
|
||||||
return fmt.Errorf("no variants with supported codecs found") |
|
||||||
} |
|
||||||
|
|
||||||
u, err := clientAbsoluteURL(d.primaryPlaylistURL, leadingPlaylist.URI) |
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
|
|
||||||
ds := newClientDownloaderStream( |
|
||||||
true, |
|
||||||
d.httpClient, |
|
||||||
u, |
|
||||||
nil, |
|
||||||
d.logger, |
|
||||||
d.rp, |
|
||||||
d.onStreamTracks, |
|
||||||
d.onSetLeadingTimeSync, |
|
||||||
d.onGetLeadingTimeSync, |
|
||||||
d.onData, |
|
||||||
) |
|
||||||
d.rp.add(ds) |
|
||||||
streamCount++ |
|
||||||
|
|
||||||
if leadingPlaylist.Audio != "" { |
|
||||||
audioPlaylist := pickAudioPlaylist(plt.Alternatives, leadingPlaylist.Audio) |
|
||||||
if audioPlaylist == nil { |
|
||||||
return fmt.Errorf("audio playlist with id \"%s\" not found", leadingPlaylist.Audio) |
|
||||||
} |
|
||||||
|
|
||||||
u, err := clientAbsoluteURL(d.primaryPlaylistURL, audioPlaylist.URI) |
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
|
|
||||||
ds := newClientDownloaderStream( |
|
||||||
false, |
|
||||||
d.httpClient, |
|
||||||
u, |
|
||||||
nil, |
|
||||||
d.logger, |
|
||||||
d.rp, |
|
||||||
d.onStreamTracks, |
|
||||||
d.onSetLeadingTimeSync, |
|
||||||
d.onGetLeadingTimeSync, |
|
||||||
d.onData, |
|
||||||
) |
|
||||||
d.rp.add(ds) |
|
||||||
streamCount++ |
|
||||||
} |
|
||||||
|
|
||||||
default: |
|
||||||
return fmt.Errorf("invalid playlist") |
|
||||||
} |
|
||||||
|
|
||||||
var tracks []format.Format |
|
||||||
|
|
||||||
for i := 0; i < streamCount; i++ { |
|
||||||
select { |
|
||||||
case streamTracks := <-d.streamTracks: |
|
||||||
tracks = append(tracks, streamTracks...) |
|
||||||
case <-ctx.Done(): |
|
||||||
return fmt.Errorf("terminated") |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
if len(tracks) == 0 { |
|
||||||
return fmt.Errorf("no supported tracks found") |
|
||||||
} |
|
||||||
|
|
||||||
err = d.onTracks(tracks) |
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
|
|
||||||
close(d.startStreaming) |
|
||||||
|
|
||||||
return nil |
|
||||||
} |
|
||||||
|
|
||||||
func (d *clientDownloaderPrimary) onStreamTracks(ctx context.Context, tracks []format.Format) bool { |
|
||||||
select { |
|
||||||
case d.streamTracks <- tracks: |
|
||||||
case <-ctx.Done(): |
|
||||||
return false |
|
||||||
} |
|
||||||
|
|
||||||
select { |
|
||||||
case <-d.startStreaming: |
|
||||||
case <-ctx.Done(): |
|
||||||
return false |
|
||||||
} |
|
||||||
|
|
||||||
return true |
|
||||||
} |
|
||||||
|
|
||||||
func (d *clientDownloaderPrimary) onSetLeadingTimeSync(ts clientTimeSync) { |
|
||||||
d.leadingTimeSync = ts |
|
||||||
close(d.leadingTimeSyncReady) |
|
||||||
} |
|
||||||
|
|
||||||
func (d *clientDownloaderPrimary) onGetLeadingTimeSync(ctx context.Context) (clientTimeSync, bool) { |
|
||||||
select { |
|
||||||
case <-d.leadingTimeSyncReady: |
|
||||||
case <-ctx.Done(): |
|
||||||
return nil, false |
|
||||||
} |
|
||||||
return d.leadingTimeSync, true |
|
||||||
} |
|
||||||
@ -1,260 +0,0 @@ |
|||||||
package hls |
|
||||||
|
|
||||||
import ( |
|
||||||
"context" |
|
||||||
"fmt" |
|
||||||
"io" |
|
||||||
"net/http" |
|
||||||
"net/url" |
|
||||||
"strconv" |
|
||||||
"time" |
|
||||||
|
|
||||||
"github.com/aler9/gortsplib/v2/pkg/format" |
|
||||||
gm3u8 "github.com/grafov/m3u8" |
|
||||||
|
|
||||||
"github.com/aler9/rtsp-simple-server/internal/hls/m3u8" |
|
||||||
"github.com/aler9/rtsp-simple-server/internal/logger" |
|
||||||
) |
|
||||||
|
|
||||||
func segmentsLen(segments []*gm3u8.MediaSegment) int { |
|
||||||
for i, seg := range segments { |
|
||||||
if seg == nil { |
|
||||||
return i |
|
||||||
} |
|
||||||
} |
|
||||||
return 0 |
|
||||||
} |
|
||||||
|
|
||||||
func findSegmentWithInvPosition(segments []*gm3u8.MediaSegment, pos int) *gm3u8.MediaSegment { |
|
||||||
index := len(segments) - pos |
|
||||||
if index < 0 { |
|
||||||
return nil |
|
||||||
} |
|
||||||
|
|
||||||
return segments[index] |
|
||||||
} |
|
||||||
|
|
||||||
func findSegmentWithID(seqNo uint64, segments []*gm3u8.MediaSegment, id uint64) (*gm3u8.MediaSegment, int) { |
|
||||||
index := int(int64(id) - int64(seqNo)) |
|
||||||
if index < 0 || index >= len(segments) { |
|
||||||
return nil, 0 |
|
||||||
} |
|
||||||
|
|
||||||
return segments[index], len(segments) - index |
|
||||||
} |
|
||||||
|
|
||||||
type clientDownloaderStream struct { |
|
||||||
isLeading bool |
|
||||||
httpClient *http.Client |
|
||||||
playlistURL *url.URL |
|
||||||
initialPlaylist *m3u8.MediaPlaylist |
|
||||||
logger ClientLogger |
|
||||||
rp *clientRoutinePool |
|
||||||
onStreamTracks func(context.Context, []format.Format) bool |
|
||||||
onSetLeadingTimeSync func(clientTimeSync) |
|
||||||
onGetLeadingTimeSync func(context.Context) (clientTimeSync, bool) |
|
||||||
onData map[format.Format]func(time.Duration, interface{}) |
|
||||||
|
|
||||||
curSegmentID *uint64 |
|
||||||
} |
|
||||||
|
|
||||||
func newClientDownloaderStream( |
|
||||||
isLeading bool, |
|
||||||
httpClient *http.Client, |
|
||||||
playlistURL *url.URL, |
|
||||||
initialPlaylist *m3u8.MediaPlaylist, |
|
||||||
logger ClientLogger, |
|
||||||
rp *clientRoutinePool, |
|
||||||
onStreamTracks func(context.Context, []format.Format) bool, |
|
||||||
onSetLeadingTimeSync func(clientTimeSync), |
|
||||||
onGetLeadingTimeSync func(context.Context) (clientTimeSync, bool), |
|
||||||
onData map[format.Format]func(time.Duration, interface{}), |
|
||||||
) *clientDownloaderStream { |
|
||||||
return &clientDownloaderStream{ |
|
||||||
isLeading: isLeading, |
|
||||||
httpClient: httpClient, |
|
||||||
playlistURL: playlistURL, |
|
||||||
initialPlaylist: initialPlaylist, |
|
||||||
logger: logger, |
|
||||||
rp: rp, |
|
||||||
onStreamTracks: onStreamTracks, |
|
||||||
onSetLeadingTimeSync: onSetLeadingTimeSync, |
|
||||||
onGetLeadingTimeSync: onGetLeadingTimeSync, |
|
||||||
onData: onData, |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
func (d *clientDownloaderStream) run(ctx context.Context) error { |
|
||||||
initialPlaylist := d.initialPlaylist |
|
||||||
d.initialPlaylist = nil |
|
||||||
if initialPlaylist == nil { |
|
||||||
var err error |
|
||||||
initialPlaylist, err = d.downloadPlaylist(ctx) |
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
segmentQueue := newClientSegmentQueue() |
|
||||||
|
|
||||||
if initialPlaylist.Map != nil && initialPlaylist.Map.URI != "" { |
|
||||||
byts, err := d.downloadSegment(ctx, initialPlaylist.Map.URI, initialPlaylist.Map.Offset, initialPlaylist.Map.Limit) |
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
|
|
||||||
proc, err := newClientProcessorFMP4( |
|
||||||
ctx, |
|
||||||
d.isLeading, |
|
||||||
byts, |
|
||||||
segmentQueue, |
|
||||||
d.logger, |
|
||||||
d.rp, |
|
||||||
d.onStreamTracks, |
|
||||||
d.onSetLeadingTimeSync, |
|
||||||
d.onGetLeadingTimeSync, |
|
||||||
d.onData, |
|
||||||
) |
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
|
|
||||||
d.rp.add(proc) |
|
||||||
} else { |
|
||||||
proc := newClientProcessorMPEGTS( |
|
||||||
d.isLeading, |
|
||||||
segmentQueue, |
|
||||||
d.logger, |
|
||||||
d.rp, |
|
||||||
d.onStreamTracks, |
|
||||||
d.onSetLeadingTimeSync, |
|
||||||
d.onGetLeadingTimeSync, |
|
||||||
d.onData, |
|
||||||
) |
|
||||||
d.rp.add(proc) |
|
||||||
} |
|
||||||
|
|
||||||
err := d.fillSegmentQueue(ctx, initialPlaylist, segmentQueue) |
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
|
|
||||||
for { |
|
||||||
ok := segmentQueue.waitUntilSizeIsBelow(ctx, 1) |
|
||||||
if !ok { |
|
||||||
return fmt.Errorf("terminated") |
|
||||||
} |
|
||||||
|
|
||||||
pl, err := d.downloadPlaylist(ctx) |
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
|
|
||||||
err = d.fillSegmentQueue(ctx, pl, segmentQueue) |
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
func (d *clientDownloaderStream) downloadPlaylist(ctx context.Context) (*m3u8.MediaPlaylist, error) { |
|
||||||
d.logger.Log(logger.Debug, "downloading stream playlist %s", d.playlistURL.String()) |
|
||||||
|
|
||||||
pl, err := clientDownloadPlaylist(ctx, d.httpClient, d.playlistURL) |
|
||||||
if err != nil { |
|
||||||
return nil, err |
|
||||||
} |
|
||||||
|
|
||||||
plt, ok := pl.(*m3u8.MediaPlaylist) |
|
||||||
if !ok { |
|
||||||
return nil, fmt.Errorf("invalid playlist") |
|
||||||
} |
|
||||||
|
|
||||||
return plt, nil |
|
||||||
} |
|
||||||
|
|
||||||
func (d *clientDownloaderStream) downloadSegment(ctx context.Context, |
|
||||||
uri string, offset int64, limit int64, |
|
||||||
) ([]byte, error) { |
|
||||||
u, err := clientAbsoluteURL(d.playlistURL, uri) |
|
||||||
if err != nil { |
|
||||||
return nil, err |
|
||||||
} |
|
||||||
|
|
||||||
d.logger.Log(logger.Debug, "downloading segment %s", u) |
|
||||||
req, err := http.NewRequestWithContext(ctx, http.MethodGet, u.String(), nil) |
|
||||||
if err != nil { |
|
||||||
return nil, err |
|
||||||
} |
|
||||||
|
|
||||||
if limit != 0 { |
|
||||||
req.Header.Add("Range", "bytes="+strconv.FormatInt(offset, 10)+"-"+strconv.FormatInt(offset+limit-1, 10)) |
|
||||||
} |
|
||||||
|
|
||||||
res, err := d.httpClient.Do(req) |
|
||||||
if err != nil { |
|
||||||
return nil, err |
|
||||||
} |
|
||||||
defer res.Body.Close() |
|
||||||
|
|
||||||
if res.StatusCode != http.StatusOK && res.StatusCode != http.StatusPartialContent { |
|
||||||
return nil, fmt.Errorf("bad status code: %d", res.StatusCode) |
|
||||||
} |
|
||||||
|
|
||||||
byts, err := io.ReadAll(res.Body) |
|
||||||
if err != nil { |
|
||||||
return nil, err |
|
||||||
} |
|
||||||
|
|
||||||
return byts, nil |
|
||||||
} |
|
||||||
|
|
||||||
func (d *clientDownloaderStream) fillSegmentQueue(ctx context.Context, |
|
||||||
pl *m3u8.MediaPlaylist, segmentQueue *clientSegmentQueue, |
|
||||||
) error { |
|
||||||
pl.Segments = pl.Segments[:segmentsLen(pl.Segments)] |
|
||||||
var seg *gm3u8.MediaSegment |
|
||||||
|
|
||||||
if d.curSegmentID == nil { |
|
||||||
if !pl.Closed { // live stream: start from clientLiveStartingInvPosition
|
|
||||||
seg = findSegmentWithInvPosition(pl.Segments, clientLiveStartingInvPosition) |
|
||||||
if seg == nil { |
|
||||||
return fmt.Errorf("there aren't enough segments to fill the buffer") |
|
||||||
} |
|
||||||
} else { // VOD stream: start from beginning
|
|
||||||
if len(pl.Segments) == 0 { |
|
||||||
return fmt.Errorf("no segments found") |
|
||||||
} |
|
||||||
seg = pl.Segments[0] |
|
||||||
} |
|
||||||
} else { |
|
||||||
var invPos int |
|
||||||
seg, invPos = findSegmentWithID(pl.SeqNo, pl.Segments, *d.curSegmentID+1) |
|
||||||
if seg == nil { |
|
||||||
return fmt.Errorf("following segment not found or not ready yet") |
|
||||||
} |
|
||||||
|
|
||||||
d.logger.Log(logger.Debug, "segment inverse position: %d", invPos) |
|
||||||
|
|
||||||
if !pl.Closed && invPos > clientLiveMaxInvPosition { |
|
||||||
return fmt.Errorf("playback is too late") |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
v := seg.SeqId |
|
||||||
d.curSegmentID = &v |
|
||||||
|
|
||||||
byts, err := d.downloadSegment(ctx, seg.URI, seg.Offset, seg.Limit) |
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
|
|
||||||
segmentQueue.push(byts) |
|
||||||
|
|
||||||
if pl.Closed && pl.Segments[len(pl.Segments)-1] == seg { |
|
||||||
<-ctx.Done() |
|
||||||
return fmt.Errorf("stream has ended") |
|
||||||
} |
|
||||||
|
|
||||||
return nil |
|
||||||
} |
|
||||||
@ -1,221 +0,0 @@ |
|||||||
package hls |
|
||||||
|
|
||||||
import ( |
|
||||||
"context" |
|
||||||
"fmt" |
|
||||||
"time" |
|
||||||
|
|
||||||
"github.com/aler9/gortsplib/v2/pkg/codecs/h264" |
|
||||||
"github.com/aler9/gortsplib/v2/pkg/format" |
|
||||||
|
|
||||||
"github.com/aler9/rtsp-simple-server/internal/hls/fmp4" |
|
||||||
) |
|
||||||
|
|
||||||
func fmp4PickLeadingTrack(init *fmp4.Init) int { |
|
||||||
// pick first video track
|
|
||||||
for _, track := range init.Tracks { |
|
||||||
switch track.Format.(type) { |
|
||||||
case *format.H264, *format.H265: |
|
||||||
return track.ID |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
// otherwise, pick first track
|
|
||||||
return init.Tracks[0].ID |
|
||||||
} |
|
||||||
|
|
||||||
type clientProcessorFMP4 struct { |
|
||||||
isLeading bool |
|
||||||
segmentQueue *clientSegmentQueue |
|
||||||
logger ClientLogger |
|
||||||
rp *clientRoutinePool |
|
||||||
onSetLeadingTimeSync func(clientTimeSync) |
|
||||||
onGetLeadingTimeSync func(context.Context) (clientTimeSync, bool) |
|
||||||
onData map[format.Format]func(time.Duration, interface{}) |
|
||||||
|
|
||||||
init fmp4.Init |
|
||||||
leadingTrackID int |
|
||||||
trackProcs map[int]*clientProcessorFMP4Track |
|
||||||
|
|
||||||
// in
|
|
||||||
subpartProcessed chan struct{} |
|
||||||
} |
|
||||||
|
|
||||||
func newClientProcessorFMP4( |
|
||||||
ctx context.Context, |
|
||||||
isLeading bool, |
|
||||||
initFile []byte, |
|
||||||
segmentQueue *clientSegmentQueue, |
|
||||||
logger ClientLogger, |
|
||||||
rp *clientRoutinePool, |
|
||||||
onStreamFormats func(context.Context, []format.Format) bool, |
|
||||||
onSetLeadingTimeSync func(clientTimeSync), |
|
||||||
onGetLeadingTimeSync func(context.Context) (clientTimeSync, bool), |
|
||||||
onData map[format.Format]func(time.Duration, interface{}), |
|
||||||
) (*clientProcessorFMP4, error) { |
|
||||||
p := &clientProcessorFMP4{ |
|
||||||
isLeading: isLeading, |
|
||||||
segmentQueue: segmentQueue, |
|
||||||
logger: logger, |
|
||||||
rp: rp, |
|
||||||
onSetLeadingTimeSync: onSetLeadingTimeSync, |
|
||||||
onGetLeadingTimeSync: onGetLeadingTimeSync, |
|
||||||
onData: onData, |
|
||||||
subpartProcessed: make(chan struct{}, clientFMP4MaxPartTracksPerSegment), |
|
||||||
} |
|
||||||
|
|
||||||
err := p.init.Unmarshal(initFile) |
|
||||||
if err != nil { |
|
||||||
return nil, err |
|
||||||
} |
|
||||||
|
|
||||||
p.leadingTrackID = fmp4PickLeadingTrack(&p.init) |
|
||||||
|
|
||||||
tracks := make([]format.Format, len(p.init.Tracks)) |
|
||||||
for i, track := range p.init.Tracks { |
|
||||||
tracks[i] = track.Format |
|
||||||
} |
|
||||||
|
|
||||||
ok := onStreamFormats(ctx, tracks) |
|
||||||
if !ok { |
|
||||||
return nil, fmt.Errorf("terminated") |
|
||||||
} |
|
||||||
|
|
||||||
return p, nil |
|
||||||
} |
|
||||||
|
|
||||||
func (p *clientProcessorFMP4) run(ctx context.Context) error { |
|
||||||
for { |
|
||||||
seg, ok := p.segmentQueue.pull(ctx) |
|
||||||
if !ok { |
|
||||||
return fmt.Errorf("terminated") |
|
||||||
} |
|
||||||
|
|
||||||
err := p.processSegment(ctx, seg) |
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
func (p *clientProcessorFMP4) processSegment(ctx context.Context, byts []byte) error { |
|
||||||
var parts fmp4.Parts |
|
||||||
err := parts.Unmarshal(byts) |
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
|
|
||||||
processingCount := 0 |
|
||||||
|
|
||||||
for _, part := range parts { |
|
||||||
for _, track := range part.Tracks { |
|
||||||
if p.trackProcs == nil { |
|
||||||
var ts *clientTimeSyncFMP4 |
|
||||||
|
|
||||||
if p.isLeading { |
|
||||||
if track.ID != p.leadingTrackID { |
|
||||||
continue |
|
||||||
} |
|
||||||
|
|
||||||
timeScale := func() uint32 { |
|
||||||
for _, track := range p.init.Tracks { |
|
||||||
if track.ID == p.leadingTrackID { |
|
||||||
return track.TimeScale |
|
||||||
} |
|
||||||
} |
|
||||||
return 0 |
|
||||||
}() |
|
||||||
ts = newClientTimeSyncFMP4(timeScale, track.BaseTime) |
|
||||||
p.onSetLeadingTimeSync(ts) |
|
||||||
} else { |
|
||||||
rawTS, ok := p.onGetLeadingTimeSync(ctx) |
|
||||||
if !ok { |
|
||||||
return fmt.Errorf("terminated") |
|
||||||
} |
|
||||||
|
|
||||||
ts, ok = rawTS.(*clientTimeSyncFMP4) |
|
||||||
if !ok { |
|
||||||
return fmt.Errorf("stream playlists are mixed MPEGTS/FMP4") |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
p.initializeTrackProcs(ts) |
|
||||||
} |
|
||||||
|
|
||||||
proc, ok := p.trackProcs[track.ID] |
|
||||||
if !ok { |
|
||||||
continue |
|
||||||
} |
|
||||||
|
|
||||||
if processingCount >= (clientFMP4MaxPartTracksPerSegment - 1) { |
|
||||||
return fmt.Errorf("too many part tracks at once") |
|
||||||
} |
|
||||||
|
|
||||||
select { |
|
||||||
case proc.queue <- track: |
|
||||||
case <-ctx.Done(): |
|
||||||
return fmt.Errorf("terminated") |
|
||||||
} |
|
||||||
processingCount++ |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
for i := 0; i < processingCount; i++ { |
|
||||||
select { |
|
||||||
case <-p.subpartProcessed: |
|
||||||
case <-ctx.Done(): |
|
||||||
return fmt.Errorf("terminated") |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
return nil |
|
||||||
} |
|
||||||
|
|
||||||
func (p *clientProcessorFMP4) onPartTrackProcessed(ctx context.Context) { |
|
||||||
select { |
|
||||||
case p.subpartProcessed <- struct{}{}: |
|
||||||
case <-ctx.Done(): |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
func (p *clientProcessorFMP4) initializeTrackProcs(ts *clientTimeSyncFMP4) { |
|
||||||
p.trackProcs = make(map[int]*clientProcessorFMP4Track) |
|
||||||
|
|
||||||
for _, track := range p.init.Tracks { |
|
||||||
var cb func(time.Duration, []byte) error |
|
||||||
|
|
||||||
cb2, ok := p.onData[track.Format] |
|
||||||
if !ok { |
|
||||||
cb2 = func(time.Duration, interface{}) { |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
switch track.Format.(type) { |
|
||||||
case *format.H264, *format.H265: |
|
||||||
cb = func(pts time.Duration, payload []byte) error { |
|
||||||
nalus, err := h264.AVCCUnmarshal(payload) |
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
|
|
||||||
cb2(pts, nalus) |
|
||||||
return nil |
|
||||||
} |
|
||||||
|
|
||||||
case *format.MPEG4Audio, *format.Opus: |
|
||||||
cb = func(pts time.Duration, payload []byte) error { |
|
||||||
cb2(pts, payload) |
|
||||||
return nil |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
proc := newClientProcessorFMP4Track( |
|
||||||
track.TimeScale, |
|
||||||
ts, |
|
||||||
p.onPartTrackProcessed, |
|
||||||
cb, |
|
||||||
) |
|
||||||
p.rp.add(proc) |
|
||||||
p.trackProcs[track.ID] = proc |
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,72 +0,0 @@ |
|||||||
package hls |
|
||||||
|
|
||||||
import ( |
|
||||||
"context" |
|
||||||
"time" |
|
||||||
|
|
||||||
"github.com/aler9/rtsp-simple-server/internal/hls/fmp4" |
|
||||||
) |
|
||||||
|
|
||||||
type clientProcessorFMP4Track struct { |
|
||||||
timeScale uint32 |
|
||||||
ts *clientTimeSyncFMP4 |
|
||||||
onPartTrackProcessed func(context.Context) |
|
||||||
onEntry func(time.Duration, []byte) error |
|
||||||
|
|
||||||
// in
|
|
||||||
queue chan *fmp4.PartTrack |
|
||||||
} |
|
||||||
|
|
||||||
func newClientProcessorFMP4Track( |
|
||||||
timeScale uint32, |
|
||||||
ts *clientTimeSyncFMP4, |
|
||||||
onPartTrackProcessed func(context.Context), |
|
||||||
onEntry func(time.Duration, []byte) error, |
|
||||||
) *clientProcessorFMP4Track { |
|
||||||
return &clientProcessorFMP4Track{ |
|
||||||
timeScale: timeScale, |
|
||||||
ts: ts, |
|
||||||
onPartTrackProcessed: onPartTrackProcessed, |
|
||||||
onEntry: onEntry, |
|
||||||
queue: make(chan *fmp4.PartTrack, clientFMP4MaxPartTracksPerSegment), |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
func (t *clientProcessorFMP4Track) run(ctx context.Context) error { |
|
||||||
for { |
|
||||||
select { |
|
||||||
case entry := <-t.queue: |
|
||||||
err := t.processPartTrack(ctx, entry) |
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
|
|
||||||
t.onPartTrackProcessed(ctx) |
|
||||||
|
|
||||||
case <-ctx.Done(): |
|
||||||
return nil |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
func (t *clientProcessorFMP4Track) processPartTrack(ctx context.Context, pt *fmp4.PartTrack) error { |
|
||||||
rawDTS := pt.BaseTime |
|
||||||
|
|
||||||
for _, sample := range pt.Samples { |
|
||||||
pts, err := t.ts.convertAndSync(ctx, t.timeScale, rawDTS, sample.PTSOffset) |
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
|
|
||||||
if pts >= 0 { // silently discard packets prior to the first packet of the leading track
|
|
||||||
err = t.onEntry(pts, sample.Payload) |
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
rawDTS += uint64(sample.Duration) |
|
||||||
} |
|
||||||
|
|
||||||
return nil |
|
||||||
} |
|
||||||
@ -1,221 +0,0 @@ |
|||||||
package hls |
|
||||||
|
|
||||||
import ( |
|
||||||
"bytes" |
|
||||||
"context" |
|
||||||
"fmt" |
|
||||||
"strings" |
|
||||||
"time" |
|
||||||
|
|
||||||
"github.com/aler9/gortsplib/v2/pkg/codecs/h264" |
|
||||||
"github.com/aler9/gortsplib/v2/pkg/codecs/mpeg4audio" |
|
||||||
"github.com/aler9/gortsplib/v2/pkg/format" |
|
||||||
"github.com/asticode/go-astits" |
|
||||||
|
|
||||||
"github.com/aler9/rtsp-simple-server/internal/hls/mpegts" |
|
||||||
"github.com/aler9/rtsp-simple-server/internal/logger" |
|
||||||
) |
|
||||||
|
|
||||||
func mpegtsPickLeadingTrack(mpegtsTracks []*mpegts.Track) uint16 { |
|
||||||
// pick first video track
|
|
||||||
for _, mt := range mpegtsTracks { |
|
||||||
if _, ok := mt.Format.(*format.H264); ok { |
|
||||||
return mt.ES.ElementaryPID |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
// otherwise, pick first track
|
|
||||||
return mpegtsTracks[0].ES.ElementaryPID |
|
||||||
} |
|
||||||
|
|
||||||
type clientProcessorMPEGTS struct { |
|
||||||
isLeading bool |
|
||||||
segmentQueue *clientSegmentQueue |
|
||||||
logger ClientLogger |
|
||||||
rp *clientRoutinePool |
|
||||||
onStreamFormats func(context.Context, []format.Format) bool |
|
||||||
onSetLeadingTimeSync func(clientTimeSync) |
|
||||||
onGetLeadingTimeSync func(context.Context) (clientTimeSync, bool) |
|
||||||
onData map[format.Format]func(time.Duration, interface{}) |
|
||||||
|
|
||||||
mpegtsTracks []*mpegts.Track |
|
||||||
leadingTrackPID uint16 |
|
||||||
trackProcs map[uint16]*clientProcessorMPEGTSTrack |
|
||||||
} |
|
||||||
|
|
||||||
func newClientProcessorMPEGTS( |
|
||||||
isLeading bool, |
|
||||||
segmentQueue *clientSegmentQueue, |
|
||||||
logger ClientLogger, |
|
||||||
rp *clientRoutinePool, |
|
||||||
onStreamFormats func(context.Context, []format.Format) bool, |
|
||||||
onSetLeadingTimeSync func(clientTimeSync), |
|
||||||
onGetLeadingTimeSync func(context.Context) (clientTimeSync, bool), |
|
||||||
onData map[format.Format]func(time.Duration, interface{}), |
|
||||||
) *clientProcessorMPEGTS { |
|
||||||
return &clientProcessorMPEGTS{ |
|
||||||
isLeading: isLeading, |
|
||||||
segmentQueue: segmentQueue, |
|
||||||
logger: logger, |
|
||||||
rp: rp, |
|
||||||
onStreamFormats: onStreamFormats, |
|
||||||
onSetLeadingTimeSync: onSetLeadingTimeSync, |
|
||||||
onGetLeadingTimeSync: onGetLeadingTimeSync, |
|
||||||
onData: onData, |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
func (p *clientProcessorMPEGTS) run(ctx context.Context) error { |
|
||||||
for { |
|
||||||
seg, ok := p.segmentQueue.pull(ctx) |
|
||||||
if !ok { |
|
||||||
return fmt.Errorf("terminated") |
|
||||||
} |
|
||||||
|
|
||||||
err := p.processSegment(ctx, seg) |
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
func (p *clientProcessorMPEGTS) processSegment(ctx context.Context, byts []byte) error { |
|
||||||
if p.mpegtsTracks == nil { |
|
||||||
var err error |
|
||||||
p.mpegtsTracks, err = mpegts.FindTracks(byts) |
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
|
|
||||||
p.leadingTrackPID = mpegtsPickLeadingTrack(p.mpegtsTracks) |
|
||||||
|
|
||||||
tracks := make([]format.Format, len(p.mpegtsTracks)) |
|
||||||
for i, mt := range p.mpegtsTracks { |
|
||||||
tracks[i] = mt.Format |
|
||||||
} |
|
||||||
|
|
||||||
ok := p.onStreamFormats(ctx, tracks) |
|
||||||
if !ok { |
|
||||||
return fmt.Errorf("terminated") |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
dem := astits.NewDemuxer(context.Background(), bytes.NewReader(byts)) |
|
||||||
|
|
||||||
for { |
|
||||||
data, err := dem.NextData() |
|
||||||
if err != nil { |
|
||||||
if err == astits.ErrNoMorePackets { |
|
||||||
return nil |
|
||||||
} |
|
||||||
if strings.HasPrefix(err.Error(), "astits: parsing PES data failed") { |
|
||||||
continue |
|
||||||
} |
|
||||||
return err |
|
||||||
} |
|
||||||
|
|
||||||
if data.PES == nil { |
|
||||||
continue |
|
||||||
} |
|
||||||
|
|
||||||
if data.PES.Header.OptionalHeader == nil || |
|
||||||
data.PES.Header.OptionalHeader.PTSDTSIndicator == astits.PTSDTSIndicatorNoPTSOrDTS || |
|
||||||
data.PES.Header.OptionalHeader.PTSDTSIndicator == astits.PTSDTSIndicatorIsForbidden { |
|
||||||
return fmt.Errorf("PTS is missing") |
|
||||||
} |
|
||||||
|
|
||||||
if p.trackProcs == nil { |
|
||||||
var ts *clientTimeSyncMPEGTS |
|
||||||
|
|
||||||
if p.isLeading { |
|
||||||
if data.PID != p.leadingTrackPID { |
|
||||||
continue |
|
||||||
} |
|
||||||
|
|
||||||
var dts int64 |
|
||||||
if data.PES.Header.OptionalHeader.PTSDTSIndicator == astits.PTSDTSIndicatorBothPresent { |
|
||||||
dts = data.PES.Header.OptionalHeader.DTS.Base |
|
||||||
} else { |
|
||||||
dts = data.PES.Header.OptionalHeader.PTS.Base |
|
||||||
} |
|
||||||
|
|
||||||
ts = newClientTimeSyncMPEGTS(dts) |
|
||||||
p.onSetLeadingTimeSync(ts) |
|
||||||
} else { |
|
||||||
rawTS, ok := p.onGetLeadingTimeSync(ctx) |
|
||||||
if !ok { |
|
||||||
return fmt.Errorf("terminated") |
|
||||||
} |
|
||||||
|
|
||||||
ts, ok = rawTS.(*clientTimeSyncMPEGTS) |
|
||||||
if !ok { |
|
||||||
return fmt.Errorf("stream playlists are mixed MPEGTS/FMP4") |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
p.initializeTrackProcs(ts) |
|
||||||
} |
|
||||||
|
|
||||||
proc, ok := p.trackProcs[data.PID] |
|
||||||
if !ok { |
|
||||||
continue |
|
||||||
} |
|
||||||
|
|
||||||
select { |
|
||||||
case proc.queue <- data.PES: |
|
||||||
case <-ctx.Done(): |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
func (p *clientProcessorMPEGTS) initializeTrackProcs(ts *clientTimeSyncMPEGTS) { |
|
||||||
p.trackProcs = make(map[uint16]*clientProcessorMPEGTSTrack) |
|
||||||
|
|
||||||
for _, track := range p.mpegtsTracks { |
|
||||||
var cb func(time.Duration, []byte) error |
|
||||||
|
|
||||||
cb2, ok := p.onData[track.Format] |
|
||||||
if !ok { |
|
||||||
cb2 = func(time.Duration, interface{}) { |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
switch track.Format.(type) { |
|
||||||
case *format.H264: |
|
||||||
cb = func(pts time.Duration, payload []byte) error { |
|
||||||
nalus, err := h264.AnnexBUnmarshal(payload) |
|
||||||
if err != nil { |
|
||||||
p.logger.Log(logger.Warn, "unable to decode Annex-B: %s", err) |
|
||||||
return nil |
|
||||||
} |
|
||||||
|
|
||||||
cb2(pts, nalus) |
|
||||||
return nil |
|
||||||
} |
|
||||||
|
|
||||||
case *format.MPEG4Audio: |
|
||||||
cb = func(pts time.Duration, payload []byte) error { |
|
||||||
var adtsPkts mpeg4audio.ADTSPackets |
|
||||||
err := adtsPkts.Unmarshal(payload) |
|
||||||
if err != nil { |
|
||||||
return fmt.Errorf("unable to decode ADTS: %s", err) |
|
||||||
} |
|
||||||
|
|
||||||
for i, pkt := range adtsPkts { |
|
||||||
cb2( |
|
||||||
pts+time.Duration(i)*mpeg4audio.SamplesPerAccessUnit*time.Second/time.Duration(pkt.SampleRate), |
|
||||||
pkt.AU) |
|
||||||
} |
|
||||||
|
|
||||||
return nil |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
proc := newClientProcessorMPEGTSTrack( |
|
||||||
ts, |
|
||||||
cb, |
|
||||||
) |
|
||||||
p.rp.add(proc) |
|
||||||
p.trackProcs[track.ES.ElementaryPID] = proc |
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,63 +0,0 @@ |
|||||||
package hls |
|
||||||
|
|
||||||
import ( |
|
||||||
"context" |
|
||||||
"time" |
|
||||||
|
|
||||||
"github.com/asticode/go-astits" |
|
||||||
) |
|
||||||
|
|
||||||
type clientProcessorMPEGTSTrack struct { |
|
||||||
ts *clientTimeSyncMPEGTS |
|
||||||
onEntry func(time.Duration, []byte) error |
|
||||||
|
|
||||||
queue chan *astits.PESData |
|
||||||
} |
|
||||||
|
|
||||||
func newClientProcessorMPEGTSTrack( |
|
||||||
ts *clientTimeSyncMPEGTS, |
|
||||||
onEntry func(time.Duration, []byte) error, |
|
||||||
) *clientProcessorMPEGTSTrack { |
|
||||||
return &clientProcessorMPEGTSTrack{ |
|
||||||
ts: ts, |
|
||||||
onEntry: onEntry, |
|
||||||
queue: make(chan *astits.PESData, clientMPEGTSEntryQueueSize), |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
func (t *clientProcessorMPEGTSTrack) run(ctx context.Context) error { |
|
||||||
for { |
|
||||||
select { |
|
||||||
case pes := <-t.queue: |
|
||||||
err := t.processEntry(ctx, pes) |
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
|
|
||||||
case <-ctx.Done(): |
|
||||||
return nil |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
func (t *clientProcessorMPEGTSTrack) processEntry(ctx context.Context, pes *astits.PESData) error { |
|
||||||
rawPTS := pes.Header.OptionalHeader.PTS.Base |
|
||||||
var rawDTS int64 |
|
||||||
if pes.Header.OptionalHeader.PTSDTSIndicator == astits.PTSDTSIndicatorBothPresent { |
|
||||||
rawDTS = pes.Header.OptionalHeader.DTS.Base |
|
||||||
} else { |
|
||||||
rawDTS = rawPTS |
|
||||||
} |
|
||||||
|
|
||||||
pts, err := t.ts.convertAndSync(ctx, rawDTS, rawPTS) |
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
|
|
||||||
// silently discard packets prior to the first packet of the leading track
|
|
||||||
if pts < 0 { |
|
||||||
return nil |
|
||||||
} |
|
||||||
|
|
||||||
return t.onEntry(pts, pes.Data) |
|
||||||
} |
|
||||||
@ -1,52 +0,0 @@ |
|||||||
package hls |
|
||||||
|
|
||||||
import ( |
|
||||||
"context" |
|
||||||
"sync" |
|
||||||
) |
|
||||||
|
|
||||||
type clientRoutinePoolRunnable interface { |
|
||||||
run(context.Context) error |
|
||||||
} |
|
||||||
|
|
||||||
type clientRoutinePool struct { |
|
||||||
ctx context.Context |
|
||||||
ctxCancel func() |
|
||||||
wg sync.WaitGroup |
|
||||||
|
|
||||||
err chan error |
|
||||||
} |
|
||||||
|
|
||||||
func newClientRoutinePool() *clientRoutinePool { |
|
||||||
ctx, ctxCancel := context.WithCancel(context.Background()) |
|
||||||
|
|
||||||
return &clientRoutinePool{ |
|
||||||
ctx: ctx, |
|
||||||
ctxCancel: ctxCancel, |
|
||||||
err: make(chan error), |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
func (rp *clientRoutinePool) close() { |
|
||||||
rp.ctxCancel() |
|
||||||
rp.wg.Wait() |
|
||||||
} |
|
||||||
|
|
||||||
func (rp *clientRoutinePool) errorChan() chan error { |
|
||||||
return rp.err |
|
||||||
} |
|
||||||
|
|
||||||
func (rp *clientRoutinePool) add(r clientRoutinePoolRunnable) { |
|
||||||
rp.wg.Add(1) |
|
||||||
go func() { |
|
||||||
defer rp.wg.Done() |
|
||||||
|
|
||||||
err := r.run(rp.ctx) |
|
||||||
if err != nil { |
|
||||||
select { |
|
||||||
case rp.err <- err: |
|
||||||
case <-rp.ctx.Done(): |
|
||||||
} |
|
||||||
} |
|
||||||
}() |
|
||||||
} |
|
||||||
@ -1,79 +0,0 @@ |
|||||||
package hls |
|
||||||
|
|
||||||
import ( |
|
||||||
"context" |
|
||||||
"sync" |
|
||||||
) |
|
||||||
|
|
||||||
type clientSegmentQueue struct { |
|
||||||
mutex sync.Mutex |
|
||||||
queue [][]byte |
|
||||||
didPush chan struct{} |
|
||||||
didPull chan struct{} |
|
||||||
} |
|
||||||
|
|
||||||
func newClientSegmentQueue() *clientSegmentQueue { |
|
||||||
return &clientSegmentQueue{ |
|
||||||
didPush: make(chan struct{}), |
|
||||||
didPull: make(chan struct{}), |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
func (q *clientSegmentQueue) push(seg []byte) { |
|
||||||
q.mutex.Lock() |
|
||||||
|
|
||||||
queueWasEmpty := (len(q.queue) == 0) |
|
||||||
q.queue = append(q.queue, seg) |
|
||||||
|
|
||||||
if queueWasEmpty { |
|
||||||
close(q.didPush) |
|
||||||
q.didPush = make(chan struct{}) |
|
||||||
} |
|
||||||
|
|
||||||
q.mutex.Unlock() |
|
||||||
} |
|
||||||
|
|
||||||
func (q *clientSegmentQueue) waitUntilSizeIsBelow(ctx context.Context, n int) bool { |
|
||||||
q.mutex.Lock() |
|
||||||
|
|
||||||
for len(q.queue) > n { |
|
||||||
q.mutex.Unlock() |
|
||||||
|
|
||||||
select { |
|
||||||
case <-q.didPull: |
|
||||||
case <-ctx.Done(): |
|
||||||
return false |
|
||||||
} |
|
||||||
|
|
||||||
q.mutex.Lock() |
|
||||||
} |
|
||||||
|
|
||||||
q.mutex.Unlock() |
|
||||||
return true |
|
||||||
} |
|
||||||
|
|
||||||
func (q *clientSegmentQueue) pull(ctx context.Context) ([]byte, bool) { |
|
||||||
q.mutex.Lock() |
|
||||||
|
|
||||||
for len(q.queue) == 0 { |
|
||||||
didPush := q.didPush |
|
||||||
q.mutex.Unlock() |
|
||||||
|
|
||||||
select { |
|
||||||
case <-didPush: |
|
||||||
case <-ctx.Done(): |
|
||||||
return nil, false |
|
||||||
} |
|
||||||
|
|
||||||
q.mutex.Lock() |
|
||||||
} |
|
||||||
|
|
||||||
var seg []byte |
|
||||||
seg, q.queue = q.queue[0], q.queue[1:] |
|
||||||
|
|
||||||
close(q.didPull) |
|
||||||
q.didPull = make(chan struct{}) |
|
||||||
|
|
||||||
q.mutex.Unlock() |
|
||||||
return seg, true |
|
||||||
} |
|
||||||
@ -1,445 +0,0 @@ |
|||||||
package hls |
|
||||||
|
|
||||||
import ( |
|
||||||
"bytes" |
|
||||||
"context" |
|
||||||
"io" |
|
||||||
"log" |
|
||||||
"net" |
|
||||||
"net/http" |
|
||||||
"os" |
|
||||||
"testing" |
|
||||||
"time" |
|
||||||
|
|
||||||
"github.com/aler9/gortsplib/v2/pkg/codecs/h264" |
|
||||||
"github.com/aler9/gortsplib/v2/pkg/format" |
|
||||||
"github.com/asticode/go-astits" |
|
||||||
"github.com/gin-gonic/gin" |
|
||||||
"github.com/stretchr/testify/require" |
|
||||||
|
|
||||||
"github.com/aler9/rtsp-simple-server/internal/hls/fmp4" |
|
||||||
"github.com/aler9/rtsp-simple-server/internal/logger" |
|
||||||
) |
|
||||||
|
|
||||||
type testLogger struct{} |
|
||||||
|
|
||||||
func (testLogger) Log(level logger.Level, format string, args ...interface{}) { |
|
||||||
log.Printf(format, args...) |
|
||||||
} |
|
||||||
|
|
||||||
var serverCert = []byte(`-----BEGIN CERTIFICATE----- |
|
||||||
MIIDazCCAlOgAwIBAgIUXw1hEC3LFpTsllv7D3ARJyEq7sIwDQYJKoZIhvcNAQEL |
|
||||||
BQAwRTELMAkGA1UEBhMCQVUxEzARBgNVBAgMClNvbWUtU3RhdGUxITAfBgNVBAoM |
|
||||||
GEludGVybmV0IFdpZGdpdHMgUHR5IEx0ZDAeFw0yMDEyMTMxNzQ0NThaFw0zMDEy |
|
||||||
MTExNzQ0NThaMEUxCzAJBgNVBAYTAkFVMRMwEQYDVQQIDApTb21lLVN0YXRlMSEw |
|
||||||
HwYDVQQKDBhJbnRlcm5ldCBXaWRnaXRzIFB0eSBMdGQwggEiMA0GCSqGSIb3DQEB |
|
||||||
AQUAA4IBDwAwggEKAoIBAQDG8DyyS51810GsGwgWr5rjJK7OE1kTTLSNEEKax8Bj |
|
||||||
zOyiaz8rA2JGl2VUEpi2UjDr9Cm7nd+YIEVs91IIBOb7LGqObBh1kGF3u5aZxLkv |
|
||||||
NJE+HrLVvUhaDobK2NU+Wibqc/EI3DfUkt1rSINvv9flwTFu1qHeuLWhoySzDKEp |
|
||||||
OzYxpFhwjVSokZIjT4Red3OtFz7gl2E6OAWe2qoh5CwLYVdMWtKR0Xuw3BkDPk9I |
|
||||||
qkQKx3fqv97LPEzhyZYjDT5WvGrgZ1WDAN3booxXF3oA1H3GHQc4m/vcLatOtb8e |
|
||||||
nI59gMQLEbnp08cl873bAuNuM95EZieXTHNbwUnq5iybAgMBAAGjUzBRMB0GA1Ud |
|
||||||
DgQWBBQBKhJh8eWu0a4au9X/2fKhkFX2vjAfBgNVHSMEGDAWgBQBKhJh8eWu0a4a |
|
||||||
u9X/2fKhkFX2vjAPBgNVHRMBAf8EBTADAQH/MA0GCSqGSIb3DQEBCwUAA4IBAQBj |
|
||||||
3aCW0YPKukYgVK9cwN0IbVy/D0C1UPT4nupJcy/E0iC7MXPZ9D/SZxYQoAkdptdO |
|
||||||
xfI+RXkpQZLdODNx9uvV+cHyZHZyjtE5ENu/i5Rer2cWI/mSLZm5lUQyx+0KZ2Yu |
|
||||||
tEI1bsebDK30msa8QSTn0WidW9XhFnl3gRi4wRdimcQapOWYVs7ih+nAlSvng7NI |
|
||||||
XpAyRs8PIEbpDDBMWnldrX4TP6EWYUi49gCp8OUDRREKX3l6Ls1vZ02F34yHIt/7 |
|
||||||
7IV/XSKG096bhW+icKBWV0IpcEsgTzPK1J1hMxgjhzIMxGboAeUU+kidthOob6Sd |
|
||||||
XQxaORfgM//NzX9LhUPk
|
|
||||||
-----END CERTIFICATE----- |
|
||||||
`) |
|
||||||
|
|
||||||
var serverKey = []byte(`-----BEGIN RSA PRIVATE KEY----- |
|
||||||
MIIEogIBAAKCAQEAxvA8skudfNdBrBsIFq+a4ySuzhNZE0y0jRBCmsfAY8zsoms/ |
|
||||||
KwNiRpdlVBKYtlIw6/Qpu53fmCBFbPdSCATm+yxqjmwYdZBhd7uWmcS5LzSRPh6y |
|
||||||
1b1IWg6GytjVPlom6nPxCNw31JLda0iDb7/X5cExbtah3ri1oaMkswyhKTs2MaRY |
|
||||||
cI1UqJGSI0+EXndzrRc+4JdhOjgFntqqIeQsC2FXTFrSkdF7sNwZAz5PSKpECsd3 |
|
||||||
6r/eyzxM4cmWIw0+Vrxq4GdVgwDd26KMVxd6ANR9xh0HOJv73C2rTrW/HpyOfYDE |
|
||||||
CxG56dPHJfO92wLjbjPeRGYnl0xzW8FJ6uYsmwIDAQABAoIBACi0BKcyQ3HElSJC |
|
||||||
kaAao+Uvnzh4yvPg8Nwf5JDIp/uDdTMyIEWLtrLczRWrjGVZYbsVROinP5VfnPTT |
|
||||||
kYwkfKINj2u+gC6lsNuPnRuvHXikF8eO/mYvCTur1zZvsQnF5kp4GGwIqr+qoPUP |
|
||||||
bB0UMndG1PdpoMryHe+JcrvTrLHDmCeH10TqOwMsQMLHYLkowvxwJWsmTY7/Qr5S |
|
||||||
Wm3PPpOcW2i0uyPVuyuv4yD1368fqnqJ8QFsQp1K6QtYsNnJ71Hut1/IoxK/e6hj |
|
||||||
5Z+byKtHVtmcLnABuoOT7BhleJNFBksX9sh83jid4tMBgci+zXNeGmgqo2EmaWAb |
|
||||||
agQslkECgYEA8B1rzjOHVQx/vwSzDa4XOrpoHQRfyElrGNz9JVBvnoC7AorezBXQ |
|
||||||
M9WTHQIFTGMjzD8pb+YJGi3gj93VN51r0SmJRxBaBRh1ZZI9kFiFzngYev8POgD3 |
|
||||||
ygmlS3kTHCNxCK/CJkB+/jMBgtPj5ygDpCWVcTSuWlQFphePkW7jaaECgYEA1Blz |
|
||||||
ulqgAyJHZaqgcbcCsI2q6m527hVr9pjzNjIVmkwu38yS9RTCgdlbEVVDnS0hoifl |
|
||||||
+jVMEGXjF3xjyMvL50BKbQUH+KAa+V4n1WGlnZOxX9TMny8MBjEuSX2+362vQ3BX |
|
||||||
4vOlX00gvoc+sY+lrzvfx/OdPCHQGVYzoKCxhLsCgYA07HcviuIAV/HsO2/vyvhp |
|
||||||
xF5gTu+BqNUHNOZDDDid+ge+Jre2yfQLCL8VPLXIQW3Jff53IH/PGl+NtjphuLvj |
|
||||||
7UDJvgvpZZuymIojP6+2c3gJ3CASC9aR3JBnUzdoE1O9s2eaoMqc4scpe+SWtZYf |
|
||||||
3vzSZ+cqF6zrD/Rf/M35IQKBgHTU4E6ShPm09CcoaeC5sp2WK8OevZw/6IyZi78a |
|
||||||
r5Oiy18zzO97U/k6xVMy6F+38ILl/2Rn31JZDVJujniY6eSkIVsUHmPxrWoXV1HO |
|
||||||
y++U32uuSFiXDcSLarfIsE992MEJLSAynbF1Rsgsr3gXbGiuToJRyxbIeVy7gwzD |
|
||||||
94TpAoGAY4/PejWQj9psZfAhyk5dRGra++gYRQ/gK1IIc1g+Dd2/BxbT/RHr05GK |
|
||||||
6vwrfjsoRyMWteC1SsNs/CurjfQ/jqCfHNP5XPvxgd5Ec8sRJIiV7V5RTuWJsPu1 |
|
||||||
+3K6cnKEyg+0ekYmLertRFIY6SwWmY1fyKgTvxudMcsBY7dC4xs= |
|
||||||
-----END RSA PRIVATE KEY----- |
|
||||||
`) |
|
||||||
|
|
||||||
func writeTempFile(byts []byte) (string, error) { |
|
||||||
tmpf, err := os.CreateTemp(os.TempDir(), "rtsp-") |
|
||||||
if err != nil { |
|
||||||
return "", err |
|
||||||
} |
|
||||||
defer tmpf.Close() |
|
||||||
|
|
||||||
_, err = tmpf.Write(byts) |
|
||||||
if err != nil { |
|
||||||
return "", err |
|
||||||
} |
|
||||||
|
|
||||||
return tmpf.Name(), nil |
|
||||||
} |
|
||||||
|
|
||||||
func mpegtsSegment(w io.Writer) { |
|
||||||
mux := astits.NewMuxer(context.Background(), w) |
|
||||||
mux.AddElementaryStream(astits.PMTElementaryStream{ |
|
||||||
ElementaryPID: 256, |
|
||||||
StreamType: astits.StreamTypeH264Video, |
|
||||||
}) |
|
||||||
mux.SetPCRPID(256) |
|
||||||
mux.WriteTables() |
|
||||||
|
|
||||||
enc, _ := h264.AnnexBMarshal([][]byte{ |
|
||||||
{7, 1, 2, 3}, // SPS
|
|
||||||
{8}, // PPS
|
|
||||||
{5}, // IDR
|
|
||||||
}) |
|
||||||
|
|
||||||
mux.WriteData(&astits.MuxerData{ |
|
||||||
PID: 256, |
|
||||||
PES: &astits.PESData{ |
|
||||||
Header: &astits.PESHeader{ |
|
||||||
OptionalHeader: &astits.PESOptionalHeader{ |
|
||||||
MarkerBits: 2, |
|
||||||
PTSDTSIndicator: astits.PTSDTSIndicatorBothPresent, |
|
||||||
PTS: &astits.ClockReference{Base: 90000}, // +1 sec
|
|
||||||
DTS: &astits.ClockReference{Base: 0x1FFFFFFFF - 90000 + 1}, // -1 sec
|
|
||||||
}, |
|
||||||
StreamID: 224, // = video
|
|
||||||
}, |
|
||||||
Data: enc, |
|
||||||
}, |
|
||||||
}) |
|
||||||
} |
|
||||||
|
|
||||||
func mp4Init(t *testing.T, w io.Writer) { |
|
||||||
i := &fmp4.Init{ |
|
||||||
Tracks: []*fmp4.InitTrack{ |
|
||||||
{ |
|
||||||
ID: 1, |
|
||||||
TimeScale: 90000, |
|
||||||
Format: &format.H264{ |
|
||||||
SPS: []byte{ |
|
||||||
0x67, 0x42, 0xc0, 0x28, 0xd9, 0x00, 0x78, 0x02, |
|
||||||
0x27, 0xe5, 0x84, 0x00, 0x00, 0x03, 0x00, 0x04, |
|
||||||
0x00, 0x00, 0x03, 0x00, 0xf0, 0x3c, 0x60, 0xc9, |
|
||||||
0x20, |
|
||||||
}, |
|
||||||
PPS: []byte{0x01, 0x02, 0x03, 0x04}, |
|
||||||
}, |
|
||||||
}, |
|
||||||
}, |
|
||||||
} |
|
||||||
|
|
||||||
byts, err := i.Marshal() |
|
||||||
require.NoError(t, err) |
|
||||||
|
|
||||||
_, err = w.Write(byts) |
|
||||||
require.NoError(t, err) |
|
||||||
} |
|
||||||
|
|
||||||
func mp4Segment(t *testing.T, w io.Writer) { |
|
||||||
payload, _ := h264.AVCCMarshal([][]byte{ |
|
||||||
{7, 1, 2, 3}, // SPS
|
|
||||||
{8}, // PPS
|
|
||||||
{5}, // IDR
|
|
||||||
}) |
|
||||||
|
|
||||||
p := &fmp4.Part{ |
|
||||||
Tracks: []*fmp4.PartTrack{ |
|
||||||
{ |
|
||||||
ID: 1, |
|
||||||
IsVideo: true, |
|
||||||
Samples: []*fmp4.PartSample{{ |
|
||||||
Duration: 90000 / 30, |
|
||||||
PTSOffset: 90000 * 2, |
|
||||||
Payload: payload, |
|
||||||
}}, |
|
||||||
}, |
|
||||||
}, |
|
||||||
} |
|
||||||
|
|
||||||
byts, err := p.Marshal() |
|
||||||
require.NoError(t, err) |
|
||||||
|
|
||||||
_, err = w.Write(byts) |
|
||||||
require.NoError(t, err) |
|
||||||
} |
|
||||||
|
|
||||||
type testHLSServer struct { |
|
||||||
s *http.Server |
|
||||||
} |
|
||||||
|
|
||||||
func newTestHLSServer(router http.Handler, isTLS bool) (*testHLSServer, error) { |
|
||||||
ln, err := net.Listen("tcp", "localhost:5780") |
|
||||||
if err != nil { |
|
||||||
return nil, err |
|
||||||
} |
|
||||||
|
|
||||||
s := &testHLSServer{ |
|
||||||
s: &http.Server{Handler: router}, |
|
||||||
} |
|
||||||
|
|
||||||
if isTLS { |
|
||||||
go func() { |
|
||||||
serverCertFpath, err := writeTempFile(serverCert) |
|
||||||
if err != nil { |
|
||||||
panic(err) |
|
||||||
} |
|
||||||
defer os.Remove(serverCertFpath) |
|
||||||
|
|
||||||
serverKeyFpath, err := writeTempFile(serverKey) |
|
||||||
if err != nil { |
|
||||||
panic(err) |
|
||||||
} |
|
||||||
defer os.Remove(serverKeyFpath) |
|
||||||
|
|
||||||
s.s.ServeTLS(ln, serverCertFpath, serverKeyFpath) |
|
||||||
}() |
|
||||||
} else { |
|
||||||
go s.s.Serve(ln) |
|
||||||
} |
|
||||||
|
|
||||||
return s, nil |
|
||||||
} |
|
||||||
|
|
||||||
func (s *testHLSServer) close() { |
|
||||||
s.s.Shutdown(context.Background()) |
|
||||||
} |
|
||||||
|
|
||||||
func TestClientMPEGTS(t *testing.T) { |
|
||||||
for _, ca := range []string{ |
|
||||||
"plain", |
|
||||||
"tls", |
|
||||||
"segment with query", |
|
||||||
} { |
|
||||||
t.Run(ca, func(t *testing.T) { |
|
||||||
gin.SetMode(gin.ReleaseMode) |
|
||||||
router := gin.New() |
|
||||||
|
|
||||||
segment := "segment.ts" |
|
||||||
if ca == "segment with query" { |
|
||||||
segment = "segment.ts?key=val" |
|
||||||
} |
|
||||||
sent := false |
|
||||||
|
|
||||||
router.GET("/stream.m3u8", func(ctx *gin.Context) { |
|
||||||
if sent { |
|
||||||
return |
|
||||||
} |
|
||||||
sent = true |
|
||||||
|
|
||||||
ctx.Writer.Header().Set("Content-Type", `application/x-mpegURL`) |
|
||||||
io.Copy(ctx.Writer, bytes.NewReader([]byte(`#EXTM3U |
|
||||||
#EXT-X-VERSION:3 |
|
||||||
#EXT-X-ALLOW-CACHE:NO |
|
||||||
#EXT-X-TARGETDURATION:2 |
|
||||||
#EXT-X-MEDIA-SEQUENCE:0 |
|
||||||
#EXTINF:2, |
|
||||||
`+segment+` |
|
||||||
#EXT-X-ENDLIST |
|
||||||
`))) |
|
||||||
}) |
|
||||||
|
|
||||||
router.GET("/segment.ts", func(ctx *gin.Context) { |
|
||||||
if ca == "segment with query" { |
|
||||||
require.Equal(t, "val", ctx.Query("key")) |
|
||||||
} |
|
||||||
ctx.Writer.Header().Set("Content-Type", `video/MP2T`) |
|
||||||
mpegtsSegment(ctx.Writer) |
|
||||||
}) |
|
||||||
|
|
||||||
s, err := newTestHLSServer(router, ca == "tls") |
|
||||||
require.NoError(t, err) |
|
||||||
defer s.close() |
|
||||||
|
|
||||||
packetRecv := make(chan struct{}) |
|
||||||
|
|
||||||
prefix := "http" |
|
||||||
if ca == "tls" { |
|
||||||
prefix = "https" |
|
||||||
} |
|
||||||
|
|
||||||
c, err := NewClient( |
|
||||||
prefix+"://localhost:5780/stream.m3u8", |
|
||||||
"33949E05FFFB5FF3E8AA16F8213A6251B4D9363804BA53233C4DA9A46D6F2739", |
|
||||||
testLogger{}, |
|
||||||
) |
|
||||||
require.NoError(t, err) |
|
||||||
|
|
||||||
onH264 := func(pts time.Duration, unit interface{}) { |
|
||||||
require.Equal(t, 2*time.Second, pts) |
|
||||||
require.Equal(t, [][]byte{ |
|
||||||
{7, 1, 2, 3}, |
|
||||||
{8}, |
|
||||||
{5}, |
|
||||||
}, unit) |
|
||||||
close(packetRecv) |
|
||||||
} |
|
||||||
|
|
||||||
c.OnTracks(func(tracks []format.Format) error { |
|
||||||
require.Equal(t, 1, len(tracks)) |
|
||||||
require.Equal(t, &format.H264{ |
|
||||||
PayloadTyp: 96, |
|
||||||
PacketizationMode: 1, |
|
||||||
}, tracks[0]) |
|
||||||
c.OnData(tracks[0], onH264) |
|
||||||
return nil |
|
||||||
}) |
|
||||||
|
|
||||||
c.Start() |
|
||||||
|
|
||||||
<-packetRecv |
|
||||||
|
|
||||||
c.Close() |
|
||||||
<-c.Wait() |
|
||||||
}) |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
func TestClientFMP4(t *testing.T) { |
|
||||||
gin.SetMode(gin.ReleaseMode) |
|
||||||
router := gin.New() |
|
||||||
|
|
||||||
router.GET("/stream.m3u8", func(ctx *gin.Context) { |
|
||||||
ctx.Writer.Header().Set("Content-Type", `application/x-mpegURL`) |
|
||||||
io.Copy(ctx.Writer, bytes.NewReader([]byte(`#EXTM3U |
|
||||||
#EXT-X-VERSION:7 |
|
||||||
#EXT-X-MEDIA-SEQUENCE:20 |
|
||||||
#EXT-X-INDEPENDENT-SEGMENTS |
|
||||||
#EXT-X-MAP:URI="init.mp4" |
|
||||||
#EXTINF:2, |
|
||||||
segment.mp4 |
|
||||||
#EXT-X-ENDLIST |
|
||||||
`))) |
|
||||||
}) |
|
||||||
|
|
||||||
router.GET("/init.mp4", func(ctx *gin.Context) { |
|
||||||
ctx.Writer.Header().Set("Content-Type", `video/mp4`) |
|
||||||
mp4Init(t, ctx.Writer) |
|
||||||
}) |
|
||||||
|
|
||||||
router.GET("/segment.mp4", func(ctx *gin.Context) { |
|
||||||
ctx.Writer.Header().Set("Content-Type", `video/mp4`) |
|
||||||
mp4Segment(t, ctx.Writer) |
|
||||||
}) |
|
||||||
|
|
||||||
s, err := newTestHLSServer(router, false) |
|
||||||
require.NoError(t, err) |
|
||||||
defer s.close() |
|
||||||
|
|
||||||
packetRecv := make(chan struct{}) |
|
||||||
|
|
||||||
onH264 := func(pts time.Duration, unit interface{}) { |
|
||||||
require.Equal(t, 2*time.Second, pts) |
|
||||||
require.Equal(t, [][]byte{ |
|
||||||
{7, 1, 2, 3}, |
|
||||||
{8}, |
|
||||||
{5}, |
|
||||||
}, unit) |
|
||||||
close(packetRecv) |
|
||||||
} |
|
||||||
|
|
||||||
c, err := NewClient( |
|
||||||
"http://localhost:5780/stream.m3u8", |
|
||||||
"", |
|
||||||
testLogger{}, |
|
||||||
) |
|
||||||
require.NoError(t, err) |
|
||||||
|
|
||||||
c.OnTracks(func(tracks []format.Format) error { |
|
||||||
require.Equal(t, 1, len(tracks)) |
|
||||||
_, ok := tracks[0].(*format.H264) |
|
||||||
require.Equal(t, true, ok) |
|
||||||
c.OnData(tracks[0], onH264) |
|
||||||
return nil |
|
||||||
}) |
|
||||||
|
|
||||||
c.Start() |
|
||||||
|
|
||||||
<-packetRecv |
|
||||||
|
|
||||||
c.Close() |
|
||||||
<-c.Wait() |
|
||||||
} |
|
||||||
|
|
||||||
func TestClientInvalidSequenceID(t *testing.T) { |
|
||||||
router := gin.New() |
|
||||||
firstPlaylist := true |
|
||||||
|
|
||||||
router.GET("/stream.m3u8", func(ctx *gin.Context) { |
|
||||||
ctx.Writer.Header().Set("Content-Type", `application/x-mpegURL`) |
|
||||||
|
|
||||||
if firstPlaylist { |
|
||||||
firstPlaylist = false |
|
||||||
io.Copy(ctx.Writer, bytes.NewReader([]byte( |
|
||||||
`#EXTM3U |
|
||||||
#EXT-X-VERSION:3 |
|
||||||
#EXT-X-ALLOW-CACHE:NO |
|
||||||
#EXT-X-TARGETDURATION:2 |
|
||||||
#EXT-X-MEDIA-SEQUENCE:2 |
|
||||||
#EXTINF:2, |
|
||||||
segment1.ts |
|
||||||
#EXTINF:2, |
|
||||||
segment1.ts |
|
||||||
#EXTINF:2, |
|
||||||
segment1.ts |
|
||||||
`))) |
|
||||||
} else { |
|
||||||
io.Copy(ctx.Writer, bytes.NewReader([]byte( |
|
||||||
`#EXTM3U |
|
||||||
#EXT-X-VERSION:3 |
|
||||||
#EXT-X-ALLOW-CACHE:NO |
|
||||||
#EXT-X-TARGETDURATION:2 |
|
||||||
#EXT-X-MEDIA-SEQUENCE:4 |
|
||||||
#EXTINF:2, |
|
||||||
segment1.ts |
|
||||||
#EXTINF:2, |
|
||||||
segment1.ts |
|
||||||
#EXTINF:2, |
|
||||||
segment1.ts |
|
||||||
`))) |
|
||||||
} |
|
||||||
}) |
|
||||||
|
|
||||||
router.GET("/segment1.ts", func(ctx *gin.Context) { |
|
||||||
ctx.Writer.Header().Set("Content-Type", `video/MP2T`) |
|
||||||
mpegtsSegment(ctx.Writer) |
|
||||||
}) |
|
||||||
|
|
||||||
s, err := newTestHLSServer(router, false) |
|
||||||
require.NoError(t, err) |
|
||||||
defer s.close() |
|
||||||
|
|
||||||
c, err := NewClient( |
|
||||||
"http://localhost:5780/stream.m3u8", |
|
||||||
"", |
|
||||||
testLogger{}, |
|
||||||
) |
|
||||||
require.NoError(t, err) |
|
||||||
|
|
||||||
c.OnTracks(func(tracks []format.Format) error { |
|
||||||
return nil |
|
||||||
}) |
|
||||||
|
|
||||||
c.Start() |
|
||||||
|
|
||||||
err = <-c.Wait() |
|
||||||
require.EqualError(t, err, "following segment not found or not ready yet") |
|
||||||
|
|
||||||
c.Close() |
|
||||||
} |
|
||||||
@ -1,59 +0,0 @@ |
|||||||
package hls |
|
||||||
|
|
||||||
import ( |
|
||||||
"context" |
|
||||||
"fmt" |
|
||||||
"time" |
|
||||||
) |
|
||||||
|
|
||||||
func durationGoToMp4(v time.Duration, timeScale uint32) uint64 { |
|
||||||
timeScale64 := uint64(timeScale) |
|
||||||
secs := v / time.Second |
|
||||||
dec := v % time.Second |
|
||||||
return uint64(secs)*timeScale64 + uint64(dec)*timeScale64/uint64(time.Second) |
|
||||||
} |
|
||||||
|
|
||||||
func durationMp4ToGo(v uint64, timeScale uint32) time.Duration { |
|
||||||
timeScale64 := uint64(timeScale) |
|
||||||
secs := v / timeScale64 |
|
||||||
dec := v % timeScale64 |
|
||||||
return time.Duration(secs)*time.Second + time.Duration(dec)*time.Second/time.Duration(timeScale64) |
|
||||||
} |
|
||||||
|
|
||||||
type clientTimeSyncFMP4 struct { |
|
||||||
startRTC time.Time |
|
||||||
startDTS time.Duration |
|
||||||
} |
|
||||||
|
|
||||||
func newClientTimeSyncFMP4(timeScale uint32, baseTime uint64) *clientTimeSyncFMP4 { |
|
||||||
return &clientTimeSyncFMP4{ |
|
||||||
startRTC: time.Now(), |
|
||||||
startDTS: durationMp4ToGo(baseTime, timeScale), |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
func (ts *clientTimeSyncFMP4) convertAndSync(ctx context.Context, timeScale uint32, |
|
||||||
rawDTS uint64, ptsOffset int32, |
|
||||||
) (time.Duration, error) { |
|
||||||
pts := durationMp4ToGo(rawDTS+uint64(ptsOffset), timeScale) |
|
||||||
dts := durationMp4ToGo(rawDTS, timeScale) |
|
||||||
|
|
||||||
pts -= ts.startDTS |
|
||||||
dts -= ts.startDTS |
|
||||||
|
|
||||||
elapsed := time.Since(ts.startRTC) |
|
||||||
if dts > elapsed { |
|
||||||
diff := dts - elapsed |
|
||||||
if diff > clientMaxDTSRTCDiff { |
|
||||||
return 0, fmt.Errorf("difference between DTS and RTC is too big") |
|
||||||
} |
|
||||||
|
|
||||||
select { |
|
||||||
case <-time.After(diff): |
|
||||||
case <-ctx.Done(): |
|
||||||
return 0, fmt.Errorf("terminated") |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
return pts, nil |
|
||||||
} |
|
||||||
@ -1,46 +0,0 @@ |
|||||||
package hls |
|
||||||
|
|
||||||
import ( |
|
||||||
"context" |
|
||||||
"fmt" |
|
||||||
"sync" |
|
||||||
"time" |
|
||||||
|
|
||||||
"github.com/aler9/rtsp-simple-server/internal/hls/mpegtstimedec" |
|
||||||
) |
|
||||||
|
|
||||||
type clientTimeSyncMPEGTS struct { |
|
||||||
startRTC time.Time |
|
||||||
td *mpegtstimedec.Decoder |
|
||||||
mutex sync.Mutex |
|
||||||
} |
|
||||||
|
|
||||||
func newClientTimeSyncMPEGTS(startDTS int64) *clientTimeSyncMPEGTS { |
|
||||||
return &clientTimeSyncMPEGTS{ |
|
||||||
startRTC: time.Now(), |
|
||||||
td: mpegtstimedec.New(startDTS), |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
func (ts *clientTimeSyncMPEGTS) convertAndSync(ctx context.Context, rawDTS int64, rawPTS int64) (time.Duration, error) { |
|
||||||
ts.mutex.Lock() |
|
||||||
dts := ts.td.Decode(rawDTS) |
|
||||||
pts := ts.td.Decode(rawPTS) |
|
||||||
ts.mutex.Unlock() |
|
||||||
|
|
||||||
elapsed := time.Since(ts.startRTC) |
|
||||||
if dts > elapsed { |
|
||||||
diff := dts - elapsed |
|
||||||
if diff > clientMaxDTSRTCDiff { |
|
||||||
return 0, fmt.Errorf("difference between DTS and RTC is too big") |
|
||||||
} |
|
||||||
|
|
||||||
select { |
|
||||||
case <-time.After(diff): |
|
||||||
case <-ctx.Done(): |
|
||||||
return 0, fmt.Errorf("terminated") |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
return pts, nil |
|
||||||
} |
|
||||||
@ -1,143 +0,0 @@ |
|||||||
package hls |
|
||||||
|
|
||||||
import ( |
|
||||||
"encoding/hex" |
|
||||||
"fmt" |
|
||||||
"strconv" |
|
||||||
"strings" |
|
||||||
|
|
||||||
"github.com/aler9/gortsplib/v2/pkg/codecs/h265" |
|
||||||
"github.com/aler9/gortsplib/v2/pkg/format" |
|
||||||
) |
|
||||||
|
|
||||||
func encodeProfileSpace(v uint8) string { |
|
||||||
switch v { |
|
||||||
case 1: |
|
||||||
return "A" |
|
||||||
case 2: |
|
||||||
return "B" |
|
||||||
case 3: |
|
||||||
return "C" |
|
||||||
} |
|
||||||
return "" |
|
||||||
} |
|
||||||
|
|
||||||
func encodeCompatibilityFlag(v [32]bool) string { |
|
||||||
var o uint32 |
|
||||||
for i, b := range v { |
|
||||||
if b { |
|
||||||
o |= 1 << i |
|
||||||
} |
|
||||||
} |
|
||||||
return fmt.Sprintf("%x", o) |
|
||||||
} |
|
||||||
|
|
||||||
func encodeGeneralTierFlag(v uint8) string { |
|
||||||
if v > 0 { |
|
||||||
return "H" |
|
||||||
} |
|
||||||
return "L" |
|
||||||
} |
|
||||||
|
|
||||||
func encodeGeneralConstraintIndicatorFlags(v *h265.SPS_ProfileTierLevel) string { |
|
||||||
var ret []string |
|
||||||
|
|
||||||
var o1 uint8 |
|
||||||
if v.GeneralProgressiveSourceFlag { |
|
||||||
o1 |= 1 << 7 |
|
||||||
} |
|
||||||
if v.GeneralInterlacedSourceFlag { |
|
||||||
o1 |= 1 << 6 |
|
||||||
} |
|
||||||
if v.GeneralNonPackedConstraintFlag { |
|
||||||
o1 |= 1 << 5 |
|
||||||
} |
|
||||||
if v.GeneralFrameOnlyConstraintFlag { |
|
||||||
o1 |= 1 << 4 |
|
||||||
} |
|
||||||
if v.GeneralMax12bitConstraintFlag { |
|
||||||
o1 |= 1 << 3 |
|
||||||
} |
|
||||||
if v.GeneralMax10bitConstraintFlag { |
|
||||||
o1 |= 1 << 2 |
|
||||||
} |
|
||||||
if v.GeneralMax8bitConstraintFlag { |
|
||||||
o1 |= 1 << 1 |
|
||||||
} |
|
||||||
if v.GeneralMax422ChromeConstraintFlag { |
|
||||||
o1 |= 1 << 0 |
|
||||||
} |
|
||||||
|
|
||||||
ret = append(ret, fmt.Sprintf("%x", o1)) |
|
||||||
|
|
||||||
var o2 uint8 |
|
||||||
if v.GeneralMax420ChromaConstraintFlag { |
|
||||||
o2 |= 1 << 7 |
|
||||||
} |
|
||||||
if v.GeneralMaxMonochromeConstraintFlag { |
|
||||||
o2 |= 1 << 6 |
|
||||||
} |
|
||||||
if v.GeneralIntraConstraintFlag { |
|
||||||
o2 |= 1 << 5 |
|
||||||
} |
|
||||||
if v.GeneralOnePictureOnlyConstraintFlag { |
|
||||||
o2 |= 1 << 4 |
|
||||||
} |
|
||||||
if v.GeneralLowerBitRateConstraintFlag { |
|
||||||
o2 |= 1 << 3 |
|
||||||
} |
|
||||||
if v.GeneralMax14BitConstraintFlag { |
|
||||||
o2 |= 1 << 2 |
|
||||||
} |
|
||||||
|
|
||||||
if o2 != 0 { |
|
||||||
ret = append(ret, fmt.Sprintf("%x", o2)) |
|
||||||
} |
|
||||||
|
|
||||||
return strings.Join(ret, ".") |
|
||||||
} |
|
||||||
|
|
||||||
func codecParametersGenerate(track format.Format) string { |
|
||||||
switch ttrack := track.(type) { |
|
||||||
case *format.H264: |
|
||||||
sps := ttrack.SafeSPS() |
|
||||||
if len(sps) >= 4 { |
|
||||||
return "avc1." + hex.EncodeToString(sps[1:4]) |
|
||||||
} |
|
||||||
|
|
||||||
case *format.H265: |
|
||||||
var sps h265.SPS |
|
||||||
err := sps.Unmarshal(ttrack.SafeSPS()) |
|
||||||
if err == nil { |
|
||||||
return "hvc1." + |
|
||||||
encodeProfileSpace(sps.ProfileTierLevel.GeneralProfileSpace) + |
|
||||||
strconv.FormatInt(int64(sps.ProfileTierLevel.GeneralProfileIdc), 10) + "." + |
|
||||||
encodeCompatibilityFlag(sps.ProfileTierLevel.GeneralProfileCompatibilityFlag) + "." + |
|
||||||
encodeGeneralTierFlag(sps.ProfileTierLevel.GeneralTierFlag) + |
|
||||||
strconv.FormatInt(int64(sps.ProfileTierLevel.GeneralLevelIdc), 10) + "." + |
|
||||||
encodeGeneralConstraintIndicatorFlags(&sps.ProfileTierLevel) |
|
||||||
} |
|
||||||
|
|
||||||
case *format.MPEG4Audio: |
|
||||||
// https://developer.mozilla.org/en-US/docs/Web/Media/Formats/codecs_parameter
|
|
||||||
return "mp4a.40." + strconv.FormatInt(int64(ttrack.Config.Type), 10) |
|
||||||
|
|
||||||
case *format.Opus: |
|
||||||
return "opus" |
|
||||||
} |
|
||||||
|
|
||||||
return "" |
|
||||||
} |
|
||||||
|
|
||||||
func codecParametersAreSupported(codecs string) bool { |
|
||||||
for _, codec := range strings.Split(codecs, ",") { |
|
||||||
if !strings.HasPrefix(codec, "avc1.") && |
|
||||||
!strings.HasPrefix(codec, "hvc1.") && |
|
||||||
!strings.HasPrefix(codec, "hev1.") && |
|
||||||
!strings.HasPrefix(codec, "mp4a.") && |
|
||||||
codec != "opus" { |
|
||||||
return false |
|
||||||
} |
|
||||||
} |
|
||||||
return true |
|
||||||
} |
|
||||||
@ -1,53 +0,0 @@ |
|||||||
//nolint:gochecknoinits,revive,gocritic
|
|
||||||
package fmp4 |
|
||||||
|
|
||||||
import ( |
|
||||||
gomp4 "github.com/abema/go-mp4" |
|
||||||
) |
|
||||||
|
|
||||||
func BoxTypeOpus() gomp4.BoxType { return gomp4.StrToBoxType("Opus") } |
|
||||||
|
|
||||||
func init() { |
|
||||||
gomp4.AddAnyTypeBoxDef(&gomp4.AudioSampleEntry{}, BoxTypeOpus()) |
|
||||||
} |
|
||||||
|
|
||||||
func BoxTypeDOps() gomp4.BoxType { return gomp4.StrToBoxType("dOps") } |
|
||||||
|
|
||||||
func init() { |
|
||||||
gomp4.AddBoxDef(&DOps{}) |
|
||||||
} |
|
||||||
|
|
||||||
type DOpsChannelMappingTable struct{} |
|
||||||
|
|
||||||
type DOps struct { |
|
||||||
gomp4.Box |
|
||||||
Version uint8 `mp4:"0,size=8"` |
|
||||||
OutputChannelCount uint8 `mp4:"1,size=8"` |
|
||||||
PreSkip uint16 `mp4:"2,size=16"` |
|
||||||
InputSampleRate uint32 `mp4:"3,size=32"` |
|
||||||
OutputGain int16 `mp4:"4,size=16"` |
|
||||||
ChannelMappingFamily uint8 `mp4:"5,size=8"` |
|
||||||
StreamCount uint8 `mp4:"6,opt=dynamic,size=8"` |
|
||||||
CoupledCount uint8 `mp4:"7,opt=dynamic,size=8"` |
|
||||||
ChannelMapping []uint8 `mp4:"8,opt=dynamic,size=8,len=dynamic"` |
|
||||||
} |
|
||||||
|
|
||||||
func (DOps) GetType() gomp4.BoxType { |
|
||||||
return BoxTypeDOps() |
|
||||||
} |
|
||||||
|
|
||||||
func (dops DOps) IsOptFieldEnabled(name string, ctx gomp4.Context) bool { |
|
||||||
switch name { |
|
||||||
case "StreamCount", "CoupledCount", "ChannelMapping": |
|
||||||
return dops.ChannelMappingFamily != 0 |
|
||||||
} |
|
||||||
return false |
|
||||||
} |
|
||||||
|
|
||||||
func (ops DOps) GetFieldLength(name string, ctx gomp4.Context) uint { |
|
||||||
switch name { |
|
||||||
case "ChannelMapping": |
|
||||||
return uint(ops.OutputChannelCount) |
|
||||||
} |
|
||||||
return 0 |
|
||||||
} |
|
||||||
@ -1,2 +0,0 @@ |
|||||||
// Package fmp4 contains a fMP4 reader and writer.
|
|
||||||
package fmp4 |
|
||||||
@ -1,363 +0,0 @@ |
|||||||
package fmp4 |
|
||||||
|
|
||||||
import ( |
|
||||||
"bytes" |
|
||||||
"fmt" |
|
||||||
|
|
||||||
gomp4 "github.com/abema/go-mp4" |
|
||||||
"github.com/aler9/gortsplib/v2/pkg/codecs/h265" |
|
||||||
"github.com/aler9/gortsplib/v2/pkg/codecs/mpeg4audio" |
|
||||||
"github.com/aler9/gortsplib/v2/pkg/format" |
|
||||||
) |
|
||||||
|
|
||||||
// Init is a FMP4 initialization file.
|
|
||||||
type Init struct { |
|
||||||
Tracks []*InitTrack |
|
||||||
} |
|
||||||
|
|
||||||
// Unmarshal decodes a FMP4 initialization file.
|
|
||||||
func (i *Init) Unmarshal(byts []byte) error { |
|
||||||
type readState int |
|
||||||
|
|
||||||
const ( |
|
||||||
waitingTrak readState = iota |
|
||||||
waitingTkhd |
|
||||||
waitingMdhd |
|
||||||
waitingCodec |
|
||||||
waitingAvcC |
|
||||||
waitingHvcC |
|
||||||
waitingEsds |
|
||||||
waitingDOps |
|
||||||
) |
|
||||||
|
|
||||||
state := waitingTrak |
|
||||||
var curTrack *InitTrack |
|
||||||
|
|
||||||
_, err := gomp4.ReadBoxStructure(bytes.NewReader(byts), func(h *gomp4.ReadHandle) (interface{}, error) { |
|
||||||
switch h.BoxInfo.Type.String() { |
|
||||||
case "trak": |
|
||||||
if state != waitingTrak { |
|
||||||
return nil, fmt.Errorf("unexpected box 'trak'") |
|
||||||
} |
|
||||||
|
|
||||||
curTrack = &InitTrack{} |
|
||||||
i.Tracks = append(i.Tracks, curTrack) |
|
||||||
state = waitingTkhd |
|
||||||
|
|
||||||
case "tkhd": |
|
||||||
if state != waitingTkhd { |
|
||||||
return nil, fmt.Errorf("unexpected box 'tkhd'") |
|
||||||
} |
|
||||||
|
|
||||||
box, _, err := h.ReadPayload() |
|
||||||
if err != nil { |
|
||||||
return nil, err |
|
||||||
} |
|
||||||
tkhd := box.(*gomp4.Tkhd) |
|
||||||
|
|
||||||
curTrack.ID = int(tkhd.TrackID) |
|
||||||
state = waitingMdhd |
|
||||||
|
|
||||||
case "mdhd": |
|
||||||
if state != waitingMdhd { |
|
||||||
return nil, fmt.Errorf("unexpected box 'mdhd'") |
|
||||||
} |
|
||||||
|
|
||||||
box, _, err := h.ReadPayload() |
|
||||||
if err != nil { |
|
||||||
return nil, err |
|
||||||
} |
|
||||||
mdhd := box.(*gomp4.Mdhd) |
|
||||||
|
|
||||||
curTrack.TimeScale = mdhd.Timescale |
|
||||||
state = waitingCodec |
|
||||||
|
|
||||||
case "avc1": |
|
||||||
if state != waitingCodec { |
|
||||||
return nil, fmt.Errorf("unexpected box 'avc1'") |
|
||||||
} |
|
||||||
state = waitingAvcC |
|
||||||
|
|
||||||
case "avcC": |
|
||||||
if state != waitingAvcC { |
|
||||||
return nil, fmt.Errorf("unexpected box 'avcC'") |
|
||||||
} |
|
||||||
|
|
||||||
box, _, err := h.ReadPayload() |
|
||||||
if err != nil { |
|
||||||
return nil, err |
|
||||||
} |
|
||||||
avcc := box.(*gomp4.AVCDecoderConfiguration) |
|
||||||
|
|
||||||
if len(avcc.SequenceParameterSets) > 1 { |
|
||||||
return nil, fmt.Errorf("multiple SPS are not supported") |
|
||||||
} |
|
||||||
|
|
||||||
var sps []byte |
|
||||||
if len(avcc.SequenceParameterSets) == 1 { |
|
||||||
sps = avcc.SequenceParameterSets[0].NALUnit |
|
||||||
} |
|
||||||
|
|
||||||
if len(avcc.PictureParameterSets) > 1 { |
|
||||||
return nil, fmt.Errorf("multiple PPS are not supported") |
|
||||||
} |
|
||||||
|
|
||||||
var pps []byte |
|
||||||
if len(avcc.PictureParameterSets) == 1 { |
|
||||||
pps = avcc.PictureParameterSets[0].NALUnit |
|
||||||
} |
|
||||||
|
|
||||||
curTrack.Format = &format.H264{ |
|
||||||
PayloadTyp: 96, |
|
||||||
SPS: sps, |
|
||||||
PPS: pps, |
|
||||||
PacketizationMode: 1, |
|
||||||
} |
|
||||||
state = waitingTrak |
|
||||||
|
|
||||||
case "hev1", "hvc1": |
|
||||||
if state != waitingCodec { |
|
||||||
return nil, fmt.Errorf("unexpected box 'hev1'") |
|
||||||
} |
|
||||||
state = waitingHvcC |
|
||||||
|
|
||||||
case "hvcC": |
|
||||||
if state != waitingHvcC { |
|
||||||
return nil, fmt.Errorf("unexpected box 'hvcC'") |
|
||||||
} |
|
||||||
|
|
||||||
box, _, err := h.ReadPayload() |
|
||||||
if err != nil { |
|
||||||
return nil, err |
|
||||||
} |
|
||||||
hvcc := box.(*gomp4.HvcC) |
|
||||||
|
|
||||||
var vps []byte |
|
||||||
var sps []byte |
|
||||||
var pps []byte |
|
||||||
|
|
||||||
for _, arr := range hvcc.NaluArrays { |
|
||||||
switch h265.NALUType(arr.NaluType) { |
|
||||||
case h265.NALUType_VPS_NUT, h265.NALUType_SPS_NUT, h265.NALUType_PPS_NUT: |
|
||||||
if arr.NumNalus != 1 { |
|
||||||
return nil, fmt.Errorf("multiple VPS/SPS/PPS are not supported") |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
switch h265.NALUType(arr.NaluType) { |
|
||||||
case h265.NALUType_VPS_NUT: |
|
||||||
vps = arr.Nalus[0].NALUnit |
|
||||||
|
|
||||||
case h265.NALUType_SPS_NUT: |
|
||||||
sps = arr.Nalus[0].NALUnit |
|
||||||
|
|
||||||
case h265.NALUType_PPS_NUT: |
|
||||||
pps = arr.Nalus[0].NALUnit |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
if vps == nil { |
|
||||||
return nil, fmt.Errorf("VPS not provided") |
|
||||||
} |
|
||||||
|
|
||||||
if sps == nil { |
|
||||||
return nil, fmt.Errorf("SPS not provided") |
|
||||||
} |
|
||||||
|
|
||||||
if pps == nil { |
|
||||||
return nil, fmt.Errorf("PPS not provided") |
|
||||||
} |
|
||||||
|
|
||||||
curTrack.Format = &format.H265{ |
|
||||||
PayloadTyp: 96, |
|
||||||
VPS: vps, |
|
||||||
SPS: sps, |
|
||||||
PPS: pps, |
|
||||||
} |
|
||||||
state = waitingTrak |
|
||||||
|
|
||||||
case "mp4a": |
|
||||||
if state != waitingCodec { |
|
||||||
return nil, fmt.Errorf("unexpected box 'mp4a'") |
|
||||||
} |
|
||||||
state = waitingEsds |
|
||||||
|
|
||||||
case "esds": |
|
||||||
if state != waitingEsds { |
|
||||||
return nil, fmt.Errorf("unexpected box 'esds'") |
|
||||||
} |
|
||||||
|
|
||||||
box, _, err := h.ReadPayload() |
|
||||||
if err != nil { |
|
||||||
return nil, err |
|
||||||
} |
|
||||||
esds := box.(*gomp4.Esds) |
|
||||||
|
|
||||||
encodedConf := func() []byte { |
|
||||||
for _, desc := range esds.Descriptors { |
|
||||||
if desc.Tag == gomp4.DecSpecificInfoTag { |
|
||||||
return desc.Data |
|
||||||
} |
|
||||||
} |
|
||||||
return nil |
|
||||||
}() |
|
||||||
if encodedConf == nil { |
|
||||||
return nil, fmt.Errorf("unable to find MPEG4-audio configuration") |
|
||||||
} |
|
||||||
|
|
||||||
var c mpeg4audio.Config |
|
||||||
err = c.Unmarshal(encodedConf) |
|
||||||
if err != nil { |
|
||||||
return nil, fmt.Errorf("invalid MPEG4-audio configuration: %s", err) |
|
||||||
} |
|
||||||
|
|
||||||
curTrack.Format = &format.MPEG4Audio{ |
|
||||||
PayloadTyp: 96, |
|
||||||
Config: &c, |
|
||||||
SizeLength: 13, |
|
||||||
IndexLength: 3, |
|
||||||
IndexDeltaLength: 3, |
|
||||||
} |
|
||||||
state = waitingTrak |
|
||||||
|
|
||||||
case "Opus": |
|
||||||
if state != waitingCodec { |
|
||||||
return nil, fmt.Errorf("unexpected box 'Opus'") |
|
||||||
} |
|
||||||
state = waitingDOps |
|
||||||
|
|
||||||
case "dOps": |
|
||||||
if state != waitingDOps { |
|
||||||
return nil, fmt.Errorf("unexpected box 'dOps'") |
|
||||||
} |
|
||||||
|
|
||||||
box, _, err := h.ReadPayload() |
|
||||||
if err != nil { |
|
||||||
return nil, err |
|
||||||
} |
|
||||||
dops := box.(*DOps) |
|
||||||
|
|
||||||
curTrack.Format = &format.Opus{ |
|
||||||
PayloadTyp: 96, |
|
||||||
SampleRate: int(dops.InputSampleRate), |
|
||||||
ChannelCount: int(dops.OutputChannelCount), |
|
||||||
} |
|
||||||
state = waitingTrak |
|
||||||
|
|
||||||
case "ac-3": // ac-3, not supported yet
|
|
||||||
i.Tracks = i.Tracks[:len(i.Tracks)-1] |
|
||||||
state = waitingTrak |
|
||||||
return nil, nil |
|
||||||
|
|
||||||
case "ec-3": // ec-3, not supported yet
|
|
||||||
i.Tracks = i.Tracks[:len(i.Tracks)-1] |
|
||||||
state = waitingTrak |
|
||||||
return nil, nil |
|
||||||
|
|
||||||
case "c608", "c708": // closed captions, not supported yet
|
|
||||||
i.Tracks = i.Tracks[:len(i.Tracks)-1] |
|
||||||
state = waitingTrak |
|
||||||
return nil, nil |
|
||||||
|
|
||||||
case "chrm", "nmhd": |
|
||||||
return nil, nil |
|
||||||
} |
|
||||||
|
|
||||||
return h.Expand() |
|
||||||
}) |
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
|
|
||||||
if state != waitingTrak { |
|
||||||
return fmt.Errorf("parse error") |
|
||||||
} |
|
||||||
|
|
||||||
if len(i.Tracks) == 0 { |
|
||||||
return fmt.Errorf("no tracks found") |
|
||||||
} |
|
||||||
|
|
||||||
return nil |
|
||||||
} |
|
||||||
|
|
||||||
// Marshal encodes a FMP4 initialization file.
|
|
||||||
func (i *Init) Marshal() ([]byte, error) { |
|
||||||
/* |
|
||||||
- ftyp |
|
||||||
- moov |
|
||||||
- mvhd |
|
||||||
- trak |
|
||||||
- trak |
|
||||||
- ... |
|
||||||
- mvex |
|
||||||
- trex |
|
||||||
- trex |
|
||||||
- ... |
|
||||||
*/ |
|
||||||
|
|
||||||
w := newMP4Writer() |
|
||||||
|
|
||||||
_, err := w.WriteBox(&gomp4.Ftyp{ // <ftyp/>
|
|
||||||
MajorBrand: [4]byte{'m', 'p', '4', '2'}, |
|
||||||
MinorVersion: 1, |
|
||||||
CompatibleBrands: []gomp4.CompatibleBrandElem{ |
|
||||||
{CompatibleBrand: [4]byte{'m', 'p', '4', '1'}}, |
|
||||||
{CompatibleBrand: [4]byte{'m', 'p', '4', '2'}}, |
|
||||||
{CompatibleBrand: [4]byte{'i', 's', 'o', 'm'}}, |
|
||||||
{CompatibleBrand: [4]byte{'h', 'l', 's', 'f'}}, |
|
||||||
}, |
|
||||||
}) |
|
||||||
if err != nil { |
|
||||||
return nil, err |
|
||||||
} |
|
||||||
|
|
||||||
_, err = w.writeBoxStart(&gomp4.Moov{}) // <moov>
|
|
||||||
if err != nil { |
|
||||||
return nil, err |
|
||||||
} |
|
||||||
|
|
||||||
_, err = w.WriteBox(&gomp4.Mvhd{ // <mvhd/>
|
|
||||||
Timescale: 1000, |
|
||||||
Rate: 65536, |
|
||||||
Volume: 256, |
|
||||||
Matrix: [9]int32{0x00010000, 0, 0, 0, 0x00010000, 0, 0, 0, 0x40000000}, |
|
||||||
NextTrackID: 4294967295, |
|
||||||
}) |
|
||||||
if err != nil { |
|
||||||
return nil, err |
|
||||||
} |
|
||||||
|
|
||||||
for _, track := range i.Tracks { |
|
||||||
err := track.marshal(w) |
|
||||||
if err != nil { |
|
||||||
return nil, err |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
_, err = w.writeBoxStart(&gomp4.Mvex{}) // <mvex>
|
|
||||||
if err != nil { |
|
||||||
return nil, err |
|
||||||
} |
|
||||||
|
|
||||||
for _, track := range i.Tracks { |
|
||||||
_, err = w.WriteBox(&gomp4.Trex{ // <trex/>
|
|
||||||
TrackID: uint32(track.ID), |
|
||||||
DefaultSampleDescriptionIndex: 1, |
|
||||||
}) |
|
||||||
if err != nil { |
|
||||||
return nil, err |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
err = w.writeBoxEnd() // </mvex>
|
|
||||||
if err != nil { |
|
||||||
return nil, err |
|
||||||
} |
|
||||||
|
|
||||||
err = w.writeBoxEnd() // </moov>
|
|
||||||
if err != nil { |
|
||||||
return nil, err |
|
||||||
} |
|
||||||
|
|
||||||
return w.bytes(), nil |
|
||||||
} |
|
||||||
File diff suppressed because it is too large
Load Diff
@ -1,526 +0,0 @@ |
|||||||
package fmp4 |
|
||||||
|
|
||||||
import ( |
|
||||||
gomp4 "github.com/abema/go-mp4" |
|
||||||
"github.com/aler9/gortsplib/v2/pkg/codecs/h264" |
|
||||||
"github.com/aler9/gortsplib/v2/pkg/codecs/h265" |
|
||||||
"github.com/aler9/gortsplib/v2/pkg/format" |
|
||||||
) |
|
||||||
|
|
||||||
// InitTrack is a track of Init.
|
|
||||||
type InitTrack struct { |
|
||||||
ID int |
|
||||||
TimeScale uint32 |
|
||||||
Format format.Format |
|
||||||
} |
|
||||||
|
|
||||||
func (track *InitTrack) marshal(w *mp4Writer) error { |
|
||||||
/* |
|
||||||
trak |
|
||||||
- tkhd |
|
||||||
- mdia |
|
||||||
- mdhd |
|
||||||
- hdlr |
|
||||||
- minf |
|
||||||
- vmhd (video) |
|
||||||
- smhd (audio) |
|
||||||
- dinf |
|
||||||
- dref |
|
||||||
- url |
|
||||||
- stbl |
|
||||||
- stsd |
|
||||||
- avc1 (h264) |
|
||||||
- avcC |
|
||||||
- btrt |
|
||||||
- hev1 (h265) |
|
||||||
- hvcC |
|
||||||
- mp4a (mpeg4audio) |
|
||||||
- esds |
|
||||||
- btrt |
|
||||||
- Opus (opus) |
|
||||||
- dOps |
|
||||||
- btrt |
|
||||||
- stts |
|
||||||
- stsc |
|
||||||
- stsz |
|
||||||
- stco |
|
||||||
*/ |
|
||||||
|
|
||||||
_, err := w.writeBoxStart(&gomp4.Trak{}) // <trak>
|
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
|
|
||||||
var h264SPS []byte |
|
||||||
var h264PPS []byte |
|
||||||
var h264SPSP h264.SPS |
|
||||||
|
|
||||||
var h265VPS []byte |
|
||||||
var h265SPS []byte |
|
||||||
var h265PPS []byte |
|
||||||
var h265SPSP h265.SPS |
|
||||||
|
|
||||||
var width int |
|
||||||
var height int |
|
||||||
|
|
||||||
switch ttrack := track.Format.(type) { |
|
||||||
case *format.H264: |
|
||||||
h264SPS = ttrack.SafeSPS() |
|
||||||
h264PPS = ttrack.SafePPS() |
|
||||||
|
|
||||||
err = h264SPSP.Unmarshal(h264SPS) |
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
|
|
||||||
width = h264SPSP.Width() |
|
||||||
height = h264SPSP.Height() |
|
||||||
|
|
||||||
case *format.H265: |
|
||||||
h265VPS = ttrack.SafeVPS() |
|
||||||
h265SPS = ttrack.SafeSPS() |
|
||||||
h265PPS = ttrack.SafePPS() |
|
||||||
|
|
||||||
err = h265SPSP.Unmarshal(h265SPS) |
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
|
|
||||||
width = h265SPSP.Width() |
|
||||||
height = h265SPSP.Height() |
|
||||||
} |
|
||||||
|
|
||||||
switch track.Format.(type) { |
|
||||||
case *format.H264, *format.H265: |
|
||||||
_, err = w.WriteBox(&gomp4.Tkhd{ // <tkhd/>
|
|
||||||
FullBox: gomp4.FullBox{ |
|
||||||
Flags: [3]byte{0, 0, 3}, |
|
||||||
}, |
|
||||||
TrackID: uint32(track.ID), |
|
||||||
Width: uint32(width * 65536), |
|
||||||
Height: uint32(height * 65536), |
|
||||||
Matrix: [9]int32{0x10000, 0, 0, 0, 0x10000, 0, 0, 0, 0x40000000}, |
|
||||||
}) |
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
|
|
||||||
case *format.MPEG4Audio, *format.Opus: |
|
||||||
_, err = w.WriteBox(&gomp4.Tkhd{ // <tkhd/>
|
|
||||||
FullBox: gomp4.FullBox{ |
|
||||||
Flags: [3]byte{0, 0, 3}, |
|
||||||
}, |
|
||||||
TrackID: uint32(track.ID), |
|
||||||
AlternateGroup: 1, |
|
||||||
Volume: 256, |
|
||||||
Matrix: [9]int32{0x10000, 0, 0, 0, 0x10000, 0, 0, 0, 0x40000000}, |
|
||||||
}) |
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
_, err = w.writeBoxStart(&gomp4.Mdia{}) // <mdia>
|
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
|
|
||||||
_, err = w.WriteBox(&gomp4.Mdhd{ // <mdhd/>
|
|
||||||
Timescale: track.TimeScale, |
|
||||||
Language: [3]byte{'u', 'n', 'd'}, |
|
||||||
}) |
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
|
|
||||||
switch track.Format.(type) { |
|
||||||
case *format.H264, *format.H265: |
|
||||||
_, err = w.WriteBox(&gomp4.Hdlr{ // <hdlr/>
|
|
||||||
HandlerType: [4]byte{'v', 'i', 'd', 'e'}, |
|
||||||
Name: "VideoHandler", |
|
||||||
}) |
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
|
|
||||||
case *format.MPEG4Audio, *format.Opus: |
|
||||||
_, err = w.WriteBox(&gomp4.Hdlr{ // <hdlr/>
|
|
||||||
HandlerType: [4]byte{'s', 'o', 'u', 'n'}, |
|
||||||
Name: "SoundHandler", |
|
||||||
}) |
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
_, err = w.writeBoxStart(&gomp4.Minf{}) // <minf>
|
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
|
|
||||||
switch track.Format.(type) { |
|
||||||
case *format.H264, *format.H265: |
|
||||||
_, err = w.WriteBox(&gomp4.Vmhd{ // <vmhd/>
|
|
||||||
FullBox: gomp4.FullBox{ |
|
||||||
Flags: [3]byte{0, 0, 1}, |
|
||||||
}, |
|
||||||
}) |
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
|
|
||||||
case *format.MPEG4Audio, *format.Opus: |
|
||||||
_, err = w.WriteBox(&gomp4.Smhd{ // <smhd/>
|
|
||||||
}) |
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
_, err = w.writeBoxStart(&gomp4.Dinf{}) // <dinf>
|
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
|
|
||||||
_, err = w.writeBoxStart(&gomp4.Dref{ // <dref>
|
|
||||||
EntryCount: 1, |
|
||||||
}) |
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
|
|
||||||
_, err = w.WriteBox(&gomp4.Url{ // <url/>
|
|
||||||
FullBox: gomp4.FullBox{ |
|
||||||
Flags: [3]byte{0, 0, 1}, |
|
||||||
}, |
|
||||||
}) |
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
|
|
||||||
err = w.writeBoxEnd() // </dref>
|
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
|
|
||||||
err = w.writeBoxEnd() // </dinf>
|
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
|
|
||||||
_, err = w.writeBoxStart(&gomp4.Stbl{}) // <stbl>
|
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
|
|
||||||
_, err = w.writeBoxStart(&gomp4.Stsd{ // <stsd>
|
|
||||||
EntryCount: 1, |
|
||||||
}) |
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
|
|
||||||
switch ttrack := track.Format.(type) { |
|
||||||
case *format.H264: |
|
||||||
_, err = w.writeBoxStart(&gomp4.VisualSampleEntry{ // <avc1>
|
|
||||||
SampleEntry: gomp4.SampleEntry{ |
|
||||||
AnyTypeBox: gomp4.AnyTypeBox{ |
|
||||||
Type: gomp4.BoxTypeAvc1(), |
|
||||||
}, |
|
||||||
DataReferenceIndex: 1, |
|
||||||
}, |
|
||||||
Width: uint16(width), |
|
||||||
Height: uint16(height), |
|
||||||
Horizresolution: 4718592, |
|
||||||
Vertresolution: 4718592, |
|
||||||
FrameCount: 1, |
|
||||||
Depth: 24, |
|
||||||
PreDefined3: -1, |
|
||||||
}) |
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
|
|
||||||
_, err = w.WriteBox(&gomp4.AVCDecoderConfiguration{ // <avcc/>
|
|
||||||
AnyTypeBox: gomp4.AnyTypeBox{ |
|
||||||
Type: gomp4.BoxTypeAvcC(), |
|
||||||
}, |
|
||||||
ConfigurationVersion: 1, |
|
||||||
Profile: h264SPSP.ProfileIdc, |
|
||||||
ProfileCompatibility: h264SPS[2], |
|
||||||
Level: h264SPSP.LevelIdc, |
|
||||||
LengthSizeMinusOne: 3, |
|
||||||
NumOfSequenceParameterSets: 1, |
|
||||||
SequenceParameterSets: []gomp4.AVCParameterSet{ |
|
||||||
{ |
|
||||||
Length: uint16(len(h264SPS)), |
|
||||||
NALUnit: h264SPS, |
|
||||||
}, |
|
||||||
}, |
|
||||||
NumOfPictureParameterSets: 1, |
|
||||||
PictureParameterSets: []gomp4.AVCParameterSet{ |
|
||||||
{ |
|
||||||
Length: uint16(len(h264PPS)), |
|
||||||
NALUnit: h264PPS, |
|
||||||
}, |
|
||||||
}, |
|
||||||
}) |
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
|
|
||||||
_, err = w.WriteBox(&gomp4.Btrt{ // <btrt/>
|
|
||||||
MaxBitrate: 1000000, |
|
||||||
AvgBitrate: 1000000, |
|
||||||
}) |
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
|
|
||||||
err = w.writeBoxEnd() // </avc1>
|
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
|
|
||||||
case *format.H265: |
|
||||||
_, err = w.writeBoxStart(&gomp4.VisualSampleEntry{ // <hev1>
|
|
||||||
SampleEntry: gomp4.SampleEntry{ |
|
||||||
AnyTypeBox: gomp4.AnyTypeBox{ |
|
||||||
Type: gomp4.BoxTypeHev1(), |
|
||||||
}, |
|
||||||
DataReferenceIndex: 1, |
|
||||||
}, |
|
||||||
Width: uint16(width), |
|
||||||
Height: uint16(height), |
|
||||||
Horizresolution: 4718592, |
|
||||||
Vertresolution: 4718592, |
|
||||||
FrameCount: 1, |
|
||||||
Depth: 24, |
|
||||||
PreDefined3: -1, |
|
||||||
}) |
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
|
|
||||||
_, err = w.WriteBox(&gomp4.HvcC{ // <hvcC/>
|
|
||||||
ConfigurationVersion: 1, |
|
||||||
GeneralProfileIdc: h265SPSP.ProfileTierLevel.GeneralProfileIdc, |
|
||||||
GeneralProfileCompatibility: h265SPSP.ProfileTierLevel.GeneralProfileCompatibilityFlag, |
|
||||||
GeneralConstraintIndicator: [6]uint8{ |
|
||||||
h265SPS[7], h265SPS[8], h265SPS[9], |
|
||||||
h265SPS[10], h265SPS[11], h265SPS[12], |
|
||||||
}, |
|
||||||
GeneralLevelIdc: h265SPSP.ProfileTierLevel.GeneralLevelIdc, |
|
||||||
// MinSpatialSegmentationIdc
|
|
||||||
// ParallelismType
|
|
||||||
ChromaFormatIdc: uint8(h265SPSP.ChromaFormatIdc), |
|
||||||
BitDepthLumaMinus8: uint8(h265SPSP.BitDepthLumaMinus8), |
|
||||||
BitDepthChromaMinus8: uint8(h265SPSP.BitDepthChromaMinus8), |
|
||||||
// AvgFrameRate
|
|
||||||
// ConstantFrameRate
|
|
||||||
NumTemporalLayers: 1, |
|
||||||
// TemporalIdNested
|
|
||||||
LengthSizeMinusOne: 3, |
|
||||||
NumOfNaluArrays: 3, |
|
||||||
NaluArrays: []gomp4.HEVCNaluArray{ |
|
||||||
{ |
|
||||||
NaluType: byte(h265.NALUType_VPS_NUT), |
|
||||||
NumNalus: 1, |
|
||||||
Nalus: []gomp4.HEVCNalu{{ |
|
||||||
Length: uint16(len(h265VPS)), |
|
||||||
NALUnit: h265VPS, |
|
||||||
}}, |
|
||||||
}, |
|
||||||
{ |
|
||||||
NaluType: byte(h265.NALUType_SPS_NUT), |
|
||||||
NumNalus: 1, |
|
||||||
Nalus: []gomp4.HEVCNalu{{ |
|
||||||
Length: uint16(len(h265SPS)), |
|
||||||
NALUnit: h265SPS, |
|
||||||
}}, |
|
||||||
}, |
|
||||||
{ |
|
||||||
NaluType: byte(h265.NALUType_PPS_NUT), |
|
||||||
NumNalus: 1, |
|
||||||
Nalus: []gomp4.HEVCNalu{{ |
|
||||||
Length: uint16(len(h265PPS)), |
|
||||||
NALUnit: h265PPS, |
|
||||||
}}, |
|
||||||
}, |
|
||||||
}, |
|
||||||
}) |
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
|
|
||||||
_, err = w.WriteBox(&gomp4.Btrt{ // <btrt/>
|
|
||||||
MaxBitrate: 1000000, |
|
||||||
AvgBitrate: 1000000, |
|
||||||
}) |
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
|
|
||||||
err = w.writeBoxEnd() // </hev1>
|
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
|
|
||||||
case *format.MPEG4Audio: |
|
||||||
_, err = w.writeBoxStart(&gomp4.AudioSampleEntry{ // <mp4a>
|
|
||||||
SampleEntry: gomp4.SampleEntry{ |
|
||||||
AnyTypeBox: gomp4.AnyTypeBox{ |
|
||||||
Type: gomp4.BoxTypeMp4a(), |
|
||||||
}, |
|
||||||
DataReferenceIndex: 1, |
|
||||||
}, |
|
||||||
ChannelCount: uint16(ttrack.Config.ChannelCount), |
|
||||||
SampleSize: 16, |
|
||||||
SampleRate: uint32(ttrack.ClockRate() * 65536), |
|
||||||
}) |
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
|
|
||||||
enc, _ := ttrack.Config.Marshal() |
|
||||||
|
|
||||||
_, err = w.WriteBox(&gomp4.Esds{ // <esds/>
|
|
||||||
Descriptors: []gomp4.Descriptor{ |
|
||||||
{ |
|
||||||
Tag: gomp4.ESDescrTag, |
|
||||||
Size: 32 + uint32(len(enc)), |
|
||||||
ESDescriptor: &gomp4.ESDescriptor{ |
|
||||||
ESID: uint16(track.ID), |
|
||||||
}, |
|
||||||
}, |
|
||||||
{ |
|
||||||
Tag: gomp4.DecoderConfigDescrTag, |
|
||||||
Size: 18 + uint32(len(enc)), |
|
||||||
DecoderConfigDescriptor: &gomp4.DecoderConfigDescriptor{ |
|
||||||
ObjectTypeIndication: 0x40, |
|
||||||
StreamType: 0x05, |
|
||||||
UpStream: false, |
|
||||||
Reserved: true, |
|
||||||
MaxBitrate: 128825, |
|
||||||
AvgBitrate: 128825, |
|
||||||
}, |
|
||||||
}, |
|
||||||
{ |
|
||||||
Tag: gomp4.DecSpecificInfoTag, |
|
||||||
Size: uint32(len(enc)), |
|
||||||
Data: enc, |
|
||||||
}, |
|
||||||
{ |
|
||||||
Tag: gomp4.SLConfigDescrTag, |
|
||||||
Size: 1, |
|
||||||
Data: []byte{0x02}, |
|
||||||
}, |
|
||||||
}, |
|
||||||
}) |
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
|
|
||||||
_, err = w.WriteBox(&gomp4.Btrt{ // <btrt/>
|
|
||||||
MaxBitrate: 128825, |
|
||||||
AvgBitrate: 128825, |
|
||||||
}) |
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
|
|
||||||
err = w.writeBoxEnd() // </mp4a>
|
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
|
|
||||||
case *format.Opus: |
|
||||||
_, err = w.writeBoxStart(&gomp4.AudioSampleEntry{ // <Opus>
|
|
||||||
SampleEntry: gomp4.SampleEntry{ |
|
||||||
AnyTypeBox: gomp4.AnyTypeBox{ |
|
||||||
Type: BoxTypeOpus(), |
|
||||||
}, |
|
||||||
DataReferenceIndex: 1, |
|
||||||
}, |
|
||||||
ChannelCount: uint16(ttrack.ChannelCount), |
|
||||||
SampleSize: 16, |
|
||||||
SampleRate: uint32(ttrack.ClockRate() * 65536), |
|
||||||
}) |
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
|
|
||||||
_, err = w.WriteBox(&DOps{ // <dOps/>
|
|
||||||
OutputChannelCount: uint8(ttrack.ChannelCount), |
|
||||||
PreSkip: 312, |
|
||||||
InputSampleRate: uint32(ttrack.ClockRate()), |
|
||||||
}) |
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
|
|
||||||
_, err = w.WriteBox(&gomp4.Btrt{ // <btrt/>
|
|
||||||
MaxBitrate: 128825, |
|
||||||
AvgBitrate: 128825, |
|
||||||
}) |
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
|
|
||||||
err = w.writeBoxEnd() // </Opus>
|
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
err = w.writeBoxEnd() // </stsd>
|
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
|
|
||||||
_, err = w.WriteBox(&gomp4.Stts{ // <stts>
|
|
||||||
}) |
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
|
|
||||||
_, err = w.WriteBox(&gomp4.Stsc{ // <stsc>
|
|
||||||
}) |
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
|
|
||||||
_, err = w.WriteBox(&gomp4.Stsz{ // <stsz>
|
|
||||||
}) |
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
|
|
||||||
_, err = w.WriteBox(&gomp4.Stco{ // <stco>
|
|
||||||
}) |
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
|
|
||||||
err = w.writeBoxEnd() // </stbl>
|
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
|
|
||||||
err = w.writeBoxEnd() // </minf>
|
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
|
|
||||||
err = w.writeBoxEnd() // </mdia>
|
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
|
|
||||||
err = w.writeBoxEnd() // </trak>
|
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
|
|
||||||
return nil |
|
||||||
} |
|
||||||
@ -1,93 +0,0 @@ |
|||||||
package fmp4 |
|
||||||
|
|
||||||
import ( |
|
||||||
"io" |
|
||||||
|
|
||||||
gomp4 "github.com/abema/go-mp4" |
|
||||||
"github.com/orcaman/writerseeker" |
|
||||||
) |
|
||||||
|
|
||||||
type mp4Writer struct { |
|
||||||
buf *writerseeker.WriterSeeker |
|
||||||
w *gomp4.Writer |
|
||||||
} |
|
||||||
|
|
||||||
func newMP4Writer() *mp4Writer { |
|
||||||
w := &mp4Writer{ |
|
||||||
buf: &writerseeker.WriterSeeker{}, |
|
||||||
} |
|
||||||
|
|
||||||
w.w = gomp4.NewWriter(w.buf) |
|
||||||
|
|
||||||
return w |
|
||||||
} |
|
||||||
|
|
||||||
func (w *mp4Writer) writeBoxStart(box gomp4.IImmutableBox) (int, error) { |
|
||||||
bi := &gomp4.BoxInfo{ |
|
||||||
Type: box.GetType(), |
|
||||||
} |
|
||||||
var err error |
|
||||||
bi, err = w.w.StartBox(bi) |
|
||||||
if err != nil { |
|
||||||
return 0, err |
|
||||||
} |
|
||||||
|
|
||||||
_, err = gomp4.Marshal(w.w, box, gomp4.Context{}) |
|
||||||
if err != nil { |
|
||||||
return 0, err |
|
||||||
} |
|
||||||
|
|
||||||
return int(bi.Offset), nil |
|
||||||
} |
|
||||||
|
|
||||||
func (w *mp4Writer) writeBoxEnd() error { |
|
||||||
_, err := w.w.EndBox() |
|
||||||
return err |
|
||||||
} |
|
||||||
|
|
||||||
func (w *mp4Writer) WriteBox(box gomp4.IImmutableBox) (int, error) { |
|
||||||
off, err := w.writeBoxStart(box) |
|
||||||
if err != nil { |
|
||||||
return 0, err |
|
||||||
} |
|
||||||
|
|
||||||
err = w.writeBoxEnd() |
|
||||||
if err != nil { |
|
||||||
return 0, err |
|
||||||
} |
|
||||||
|
|
||||||
return off, nil |
|
||||||
} |
|
||||||
|
|
||||||
func (w *mp4Writer) rewriteBox(off int, box gomp4.IImmutableBox) error { |
|
||||||
prevOff, err := w.w.Seek(0, io.SeekCurrent) |
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
|
|
||||||
_, err = w.w.Seek(int64(off), io.SeekStart) |
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
|
|
||||||
_, err = w.writeBoxStart(box) |
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
|
|
||||||
err = w.writeBoxEnd() |
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
|
|
||||||
_, err = w.w.Seek(prevOff, io.SeekStart) |
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
|
|
||||||
return nil |
|
||||||
} |
|
||||||
|
|
||||||
func (w *mp4Writer) bytes() []byte { |
|
||||||
return w.buf.Bytes() |
|
||||||
} |
|
||||||
@ -1,263 +0,0 @@ |
|||||||
package fmp4 |
|
||||||
|
|
||||||
import ( |
|
||||||
"bytes" |
|
||||||
"fmt" |
|
||||||
|
|
||||||
gomp4 "github.com/abema/go-mp4" |
|
||||||
) |
|
||||||
|
|
||||||
const ( |
|
||||||
trunFlagDataOffsetPreset = 0x01 |
|
||||||
trunFlagSampleDurationPresent = 0x100 |
|
||||||
trunFlagSampleSizePresent = 0x200 |
|
||||||
trunFlagSampleFlagsPresent = 0x400 |
|
||||||
trunFlagSampleCompositionTimeOffsetPresentOrV1 = 0x800 |
|
||||||
|
|
||||||
sampleFlagIsNonSyncSample = 1 << 16 |
|
||||||
) |
|
||||||
|
|
||||||
// Part is a FMP4 part file.
|
|
||||||
type Part struct { |
|
||||||
Tracks []*PartTrack |
|
||||||
} |
|
||||||
|
|
||||||
// Parts is a sequence of FMP4 parts.
|
|
||||||
type Parts []*Part |
|
||||||
|
|
||||||
// Unmarshal decodes one or more FMP4 parts.
|
|
||||||
func (ps *Parts) Unmarshal(byts []byte) error { |
|
||||||
type readState int |
|
||||||
|
|
||||||
const ( |
|
||||||
waitingMoof readState = iota |
|
||||||
waitingTraf |
|
||||||
waitingTfdtTfhdTrun |
|
||||||
) |
|
||||||
|
|
||||||
state := waitingMoof |
|
||||||
var curPart *Part |
|
||||||
var moofOffset uint64 |
|
||||||
var curTrack *PartTrack |
|
||||||
var tfdt *gomp4.Tfdt |
|
||||||
var tfhd *gomp4.Tfhd |
|
||||||
|
|
||||||
_, err := gomp4.ReadBoxStructure(bytes.NewReader(byts), func(h *gomp4.ReadHandle) (interface{}, error) { |
|
||||||
switch h.BoxInfo.Type.String() { |
|
||||||
case "moof": |
|
||||||
if state != waitingMoof { |
|
||||||
return nil, fmt.Errorf("unexpected moof") |
|
||||||
} |
|
||||||
|
|
||||||
curPart = &Part{} |
|
||||||
*ps = append(*ps, curPart) |
|
||||||
moofOffset = h.BoxInfo.Offset |
|
||||||
state = waitingTraf |
|
||||||
|
|
||||||
case "traf": |
|
||||||
if state != waitingTraf && state != waitingTfdtTfhdTrun { |
|
||||||
return nil, fmt.Errorf("unexpected traf") |
|
||||||
} |
|
||||||
|
|
||||||
if curTrack != nil { |
|
||||||
if tfdt == nil || tfhd == nil || curTrack.Samples == nil { |
|
||||||
return nil, fmt.Errorf("parse error") |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
curTrack = &PartTrack{} |
|
||||||
curPart.Tracks = append(curPart.Tracks, curTrack) |
|
||||||
tfdt = nil |
|
||||||
tfhd = nil |
|
||||||
state = waitingTfdtTfhdTrun |
|
||||||
|
|
||||||
case "tfhd": |
|
||||||
if state != waitingTfdtTfhdTrun || tfhd != nil { |
|
||||||
return nil, fmt.Errorf("unexpected tfhd") |
|
||||||
} |
|
||||||
|
|
||||||
box, _, err := h.ReadPayload() |
|
||||||
if err != nil { |
|
||||||
return nil, err |
|
||||||
} |
|
||||||
|
|
||||||
tfhd = box.(*gomp4.Tfhd) |
|
||||||
curTrack.ID = int(tfhd.TrackID) |
|
||||||
|
|
||||||
case "tfdt": |
|
||||||
if state != waitingTfdtTfhdTrun || tfdt != nil { |
|
||||||
return nil, fmt.Errorf("unexpected tfdt") |
|
||||||
} |
|
||||||
|
|
||||||
box, _, err := h.ReadPayload() |
|
||||||
if err != nil { |
|
||||||
return nil, err |
|
||||||
} |
|
||||||
|
|
||||||
tfdt = box.(*gomp4.Tfdt) |
|
||||||
|
|
||||||
if tfdt.FullBox.Version != 1 { |
|
||||||
return nil, fmt.Errorf("unsupported tfdt version") |
|
||||||
} |
|
||||||
|
|
||||||
curTrack.BaseTime = tfdt.BaseMediaDecodeTimeV1 |
|
||||||
|
|
||||||
case "trun": |
|
||||||
if state != waitingTfdtTfhdTrun || tfhd == nil { |
|
||||||
return nil, fmt.Errorf("unexpected trun") |
|
||||||
} |
|
||||||
|
|
||||||
box, _, err := h.ReadPayload() |
|
||||||
if err != nil { |
|
||||||
return nil, err |
|
||||||
} |
|
||||||
trun := box.(*gomp4.Trun) |
|
||||||
|
|
||||||
trunFlags := uint16(trun.Flags[1])<<8 | uint16(trun.Flags[2]) |
|
||||||
if (trunFlags & trunFlagDataOffsetPreset) == 0 { |
|
||||||
return nil, fmt.Errorf("unsupported flags") |
|
||||||
} |
|
||||||
|
|
||||||
existing := len(curTrack.Samples) |
|
||||||
tmp := make([]*PartSample, existing+len(trun.Entries)) |
|
||||||
copy(tmp, curTrack.Samples) |
|
||||||
curTrack.Samples = tmp |
|
||||||
|
|
||||||
ptr := byts[uint64(trun.DataOffset)+moofOffset:] |
|
||||||
|
|
||||||
for i, e := range trun.Entries { |
|
||||||
s := &PartSample{} |
|
||||||
|
|
||||||
if (trunFlags & trunFlagSampleDurationPresent) != 0 { |
|
||||||
s.Duration = e.SampleDuration |
|
||||||
} else { |
|
||||||
s.Duration = tfhd.DefaultSampleDuration |
|
||||||
} |
|
||||||
|
|
||||||
s.PTSOffset = e.SampleCompositionTimeOffsetV1 |
|
||||||
|
|
||||||
var sampleFlags uint32 |
|
||||||
if (trunFlags & trunFlagSampleFlagsPresent) != 0 { |
|
||||||
sampleFlags = e.SampleFlags |
|
||||||
} else { |
|
||||||
sampleFlags = tfhd.DefaultSampleFlags |
|
||||||
} |
|
||||||
s.IsNonSyncSample = ((sampleFlags & sampleFlagIsNonSyncSample) != 0) |
|
||||||
|
|
||||||
var size uint32 |
|
||||||
if (trunFlags & trunFlagSampleSizePresent) != 0 { |
|
||||||
size = e.SampleSize |
|
||||||
} else { |
|
||||||
size = tfhd.DefaultSampleSize |
|
||||||
} |
|
||||||
|
|
||||||
s.Payload = ptr[:size] |
|
||||||
ptr = ptr[size:] |
|
||||||
|
|
||||||
curTrack.Samples[existing+i] = s |
|
||||||
} |
|
||||||
|
|
||||||
case "mdat": |
|
||||||
if state != waitingTraf && state != waitingTfdtTfhdTrun { |
|
||||||
return nil, fmt.Errorf("unexpected mdat") |
|
||||||
} |
|
||||||
|
|
||||||
if curTrack != nil { |
|
||||||
if tfdt == nil || tfhd == nil || curTrack.Samples == nil { |
|
||||||
return nil, fmt.Errorf("parse error") |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
state = waitingMoof |
|
||||||
return nil, nil |
|
||||||
} |
|
||||||
|
|
||||||
return h.Expand() |
|
||||||
}) |
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
|
|
||||||
if state != waitingMoof { |
|
||||||
return fmt.Errorf("decode error") |
|
||||||
} |
|
||||||
|
|
||||||
return nil |
|
||||||
} |
|
||||||
|
|
||||||
// Marshal encodes a FMP4 part file.
|
|
||||||
func (p *Part) Marshal() ([]byte, error) { |
|
||||||
/* |
|
||||||
moof |
|
||||||
- mfhd |
|
||||||
- traf (video) |
|
||||||
- traf (audio) |
|
||||||
mdat |
|
||||||
*/ |
|
||||||
|
|
||||||
w := newMP4Writer() |
|
||||||
|
|
||||||
moofOffset, err := w.writeBoxStart(&gomp4.Moof{}) // <moof>
|
|
||||||
if err != nil { |
|
||||||
return nil, err |
|
||||||
} |
|
||||||
|
|
||||||
_, err = w.WriteBox(&gomp4.Mfhd{ // <mfhd/>
|
|
||||||
SequenceNumber: 0, |
|
||||||
}) |
|
||||||
if err != nil { |
|
||||||
return nil, err |
|
||||||
} |
|
||||||
|
|
||||||
trackLen := len(p.Tracks) |
|
||||||
truns := make([]*gomp4.Trun, trackLen) |
|
||||||
trunOffsets := make([]int, trackLen) |
|
||||||
dataOffsets := make([]int, trackLen) |
|
||||||
dataSize := 0 |
|
||||||
|
|
||||||
for i, track := range p.Tracks { |
|
||||||
trun, trunOffset, err := track.marshal(w) |
|
||||||
if err != nil { |
|
||||||
return nil, err |
|
||||||
} |
|
||||||
|
|
||||||
dataOffsets[i] = dataSize |
|
||||||
|
|
||||||
for _, sample := range track.Samples { |
|
||||||
dataSize += len(sample.Payload) |
|
||||||
} |
|
||||||
|
|
||||||
truns[i] = trun |
|
||||||
trunOffsets[i] = trunOffset |
|
||||||
} |
|
||||||
|
|
||||||
err = w.writeBoxEnd() // </moof>
|
|
||||||
if err != nil { |
|
||||||
return nil, err |
|
||||||
} |
|
||||||
|
|
||||||
mdat := &gomp4.Mdat{} // <mdat/>
|
|
||||||
mdat.Data = make([]byte, dataSize) |
|
||||||
pos := 0 |
|
||||||
|
|
||||||
for _, track := range p.Tracks { |
|
||||||
for _, sample := range track.Samples { |
|
||||||
pos += copy(mdat.Data[pos:], sample.Payload) |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
mdatOffset, err := w.WriteBox(mdat) |
|
||||||
if err != nil { |
|
||||||
return nil, err |
|
||||||
} |
|
||||||
|
|
||||||
for i := range p.Tracks { |
|
||||||
truns[i].DataOffset = int32(dataOffsets[i] + mdatOffset - moofOffset + 8) |
|
||||||
err = w.rewriteBox(trunOffsets[i], truns[i]) |
|
||||||
if err != nil { |
|
||||||
return nil, err |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
return w.bytes(), nil |
|
||||||
} |
|
||||||
@ -1,249 +0,0 @@ |
|||||||
package fmp4 |
|
||||||
|
|
||||||
import ( |
|
||||||
"bytes" |
|
||||||
"testing" |
|
||||||
|
|
||||||
gomp4 "github.com/abema/go-mp4" |
|
||||||
"github.com/stretchr/testify/require" |
|
||||||
) |
|
||||||
|
|
||||||
func testMP4(t *testing.T, byts []byte, boxes []gomp4.BoxPath) { |
|
||||||
i := 0 |
|
||||||
_, err := gomp4.ReadBoxStructure(bytes.NewReader(byts), func(h *gomp4.ReadHandle) (interface{}, error) { |
|
||||||
require.Equal(t, boxes[i], h.Path) |
|
||||||
i++ |
|
||||||
return h.Expand() |
|
||||||
}) |
|
||||||
require.NoError(t, err) |
|
||||||
} |
|
||||||
|
|
||||||
func TestPartMarshal(t *testing.T) { |
|
||||||
testVideoSamples := []*PartSample{ |
|
||||||
{ |
|
||||||
Duration: 2 * 90000, |
|
||||||
Payload: []byte{ |
|
||||||
0x00, 0x00, 0x00, 0x04, |
|
||||||
0x01, 0x02, 0x03, 0x04, // SPS
|
|
||||||
0x00, 0x00, 0x00, 0x01, |
|
||||||
0x08, // PPS
|
|
||||||
0x00, 0x00, 0x00, 0x01, |
|
||||||
0x05, // IDR
|
|
||||||
}, |
|
||||||
}, |
|
||||||
{ |
|
||||||
Duration: 2 * 90000, |
|
||||||
Payload: []byte{ |
|
||||||
0x00, 0x00, 0x00, 0x01, |
|
||||||
0x01, // non-IDR
|
|
||||||
}, |
|
||||||
IsNonSyncSample: true, |
|
||||||
}, |
|
||||||
{ |
|
||||||
Duration: 1 * 90000, |
|
||||||
Payload: []byte{ |
|
||||||
0x00, 0x00, 0x00, 0x01, |
|
||||||
0x01, // non-IDR
|
|
||||||
}, |
|
||||||
IsNonSyncSample: true, |
|
||||||
}, |
|
||||||
} |
|
||||||
|
|
||||||
testAudioSamples := []*PartSample{ |
|
||||||
{ |
|
||||||
Duration: 500 * 48000 / 1000, |
|
||||||
Payload: []byte{ |
|
||||||
0x01, 0x02, 0x03, 0x04, |
|
||||||
}, |
|
||||||
}, |
|
||||||
{ |
|
||||||
Duration: 1 * 48000, |
|
||||||
Payload: []byte{ |
|
||||||
0x01, 0x02, 0x03, 0x04, |
|
||||||
}, |
|
||||||
}, |
|
||||||
} |
|
||||||
|
|
||||||
t.Run("video + audio", func(t *testing.T) { |
|
||||||
part := Part{ |
|
||||||
Tracks: []*PartTrack{ |
|
||||||
{ |
|
||||||
ID: 1, |
|
||||||
Samples: testVideoSamples, |
|
||||||
IsVideo: true, |
|
||||||
}, |
|
||||||
{ |
|
||||||
ID: 2, |
|
||||||
BaseTime: 3 * 48000, |
|
||||||
Samples: testAudioSamples, |
|
||||||
}, |
|
||||||
}, |
|
||||||
} |
|
||||||
|
|
||||||
byts, err := part.Marshal() |
|
||||||
require.NoError(t, err) |
|
||||||
|
|
||||||
boxes := []gomp4.BoxPath{ |
|
||||||
{gomp4.BoxTypeMoof()}, |
|
||||||
{gomp4.BoxTypeMoof(), gomp4.BoxTypeMfhd()}, |
|
||||||
{gomp4.BoxTypeMoof(), gomp4.BoxTypeTraf()}, |
|
||||||
{gomp4.BoxTypeMoof(), gomp4.BoxTypeTraf(), gomp4.BoxTypeTfhd()}, |
|
||||||
{gomp4.BoxTypeMoof(), gomp4.BoxTypeTraf(), gomp4.BoxTypeTfdt()}, |
|
||||||
{gomp4.BoxTypeMoof(), gomp4.BoxTypeTraf(), gomp4.BoxTypeTrun()}, |
|
||||||
{gomp4.BoxTypeMoof(), gomp4.BoxTypeTraf()}, |
|
||||||
{gomp4.BoxTypeMoof(), gomp4.BoxTypeTraf(), gomp4.BoxTypeTfhd()}, |
|
||||||
{gomp4.BoxTypeMoof(), gomp4.BoxTypeTraf(), gomp4.BoxTypeTfdt()}, |
|
||||||
{gomp4.BoxTypeMoof(), gomp4.BoxTypeTraf(), gomp4.BoxTypeTrun()}, |
|
||||||
{gomp4.BoxTypeMdat()}, |
|
||||||
} |
|
||||||
testMP4(t, byts, boxes) |
|
||||||
}) |
|
||||||
|
|
||||||
t.Run("video only", func(t *testing.T) { |
|
||||||
part := Part{ |
|
||||||
Tracks: []*PartTrack{ |
|
||||||
{ |
|
||||||
ID: 1, |
|
||||||
Samples: testVideoSamples, |
|
||||||
IsVideo: true, |
|
||||||
}, |
|
||||||
}, |
|
||||||
} |
|
||||||
|
|
||||||
byts, err := part.Marshal() |
|
||||||
require.NoError(t, err) |
|
||||||
|
|
||||||
boxes := []gomp4.BoxPath{ |
|
||||||
{gomp4.BoxTypeMoof()}, |
|
||||||
{gomp4.BoxTypeMoof(), gomp4.BoxTypeMfhd()}, |
|
||||||
{gomp4.BoxTypeMoof(), gomp4.BoxTypeTraf()}, |
|
||||||
{gomp4.BoxTypeMoof(), gomp4.BoxTypeTraf(), gomp4.BoxTypeTfhd()}, |
|
||||||
{gomp4.BoxTypeMoof(), gomp4.BoxTypeTraf(), gomp4.BoxTypeTfdt()}, |
|
||||||
{gomp4.BoxTypeMoof(), gomp4.BoxTypeTraf(), gomp4.BoxTypeTrun()}, |
|
||||||
{gomp4.BoxTypeMdat()}, |
|
||||||
} |
|
||||||
testMP4(t, byts, boxes) |
|
||||||
}) |
|
||||||
|
|
||||||
t.Run("audio only", func(t *testing.T) { |
|
||||||
part := Part{ |
|
||||||
Tracks: []*PartTrack{ |
|
||||||
{ |
|
||||||
ID: 1, |
|
||||||
Samples: testAudioSamples, |
|
||||||
}, |
|
||||||
}, |
|
||||||
} |
|
||||||
|
|
||||||
byts, err := part.Marshal() |
|
||||||
require.NoError(t, err) |
|
||||||
|
|
||||||
boxes := []gomp4.BoxPath{ |
|
||||||
{gomp4.BoxTypeMoof()}, |
|
||||||
{gomp4.BoxTypeMoof(), gomp4.BoxTypeMfhd()}, |
|
||||||
{gomp4.BoxTypeMoof(), gomp4.BoxTypeTraf()}, |
|
||||||
{gomp4.BoxTypeMoof(), gomp4.BoxTypeTraf(), gomp4.BoxTypeTfhd()}, |
|
||||||
{gomp4.BoxTypeMoof(), gomp4.BoxTypeTraf(), gomp4.BoxTypeTfdt()}, |
|
||||||
{gomp4.BoxTypeMoof(), gomp4.BoxTypeTraf(), gomp4.BoxTypeTrun()}, |
|
||||||
{gomp4.BoxTypeMdat()}, |
|
||||||
} |
|
||||||
testMP4(t, byts, boxes) |
|
||||||
}) |
|
||||||
} |
|
||||||
|
|
||||||
func TestPartUnmarshal(t *testing.T) { |
|
||||||
byts := []byte{ |
|
||||||
0x00, 0x00, 0x00, 0xd8, 0x6d, 0x6f, 0x6f, 0x66, |
|
||||||
0x00, 0x00, 0x00, 0x10, 0x6d, 0x66, 0x68, 0x64, |
|
||||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
|
||||||
0x00, 0x00, 0x00, 0x70, 0x74, 0x72, 0x61, 0x66, |
|
||||||
0x00, 0x00, 0x00, 0x10, 0x74, 0x66, 0x68, 0x64, |
|
||||||
0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, |
|
||||||
0x00, 0x00, 0x00, 0x14, 0x74, 0x66, 0x64, 0x74, |
|
||||||
0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
|
||||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x44, |
|
||||||
0x74, 0x72, 0x75, 0x6e, 0x01, 0x00, 0x0f, 0x01, |
|
||||||
0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0xe0, |
|
||||||
0x00, 0x02, 0xbf, 0x20, 0x00, 0x00, 0x00, 0x12, |
|
||||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
|
||||||
0x00, 0x02, 0xbf, 0x20, 0x00, 0x00, 0x00, 0x05, |
|
||||||
0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
|
||||||
0x00, 0x01, 0x5f, 0x90, 0x00, 0x00, 0x00, 0x05, |
|
||||||
0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
|
||||||
0x00, 0x00, 0x00, 0x50, 0x74, 0x72, 0x61, 0x66, |
|
||||||
0x00, 0x00, 0x00, 0x10, 0x74, 0x66, 0x68, 0x64, |
|
||||||
0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, |
|
||||||
0x00, 0x00, 0x00, 0x14, 0x74, 0x66, 0x64, 0x74, |
|
||||||
0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
|
||||||
0x00, 0x02, 0x32, 0x80, 0x00, 0x00, 0x00, 0x24, |
|
||||||
0x74, 0x72, 0x75, 0x6e, 0x01, 0x00, 0x03, 0x01, |
|
||||||
0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0xfc, |
|
||||||
0x00, 0x00, 0x5d, 0xc0, 0x00, 0x00, 0x00, 0x04, |
|
||||||
0x00, 0x00, 0xbb, 0x80, 0x00, 0x00, 0x00, 0x04, |
|
||||||
0x00, 0x00, 0x00, 0x2c, 0x6d, 0x64, 0x61, 0x74, |
|
||||||
0x00, 0x00, 0x00, 0x04, 0x01, 0x02, 0x03, 0x04, |
|
||||||
0x00, 0x00, 0x00, 0x01, 0x08, 0x00, 0x00, 0x00, |
|
||||||
0x01, 0x05, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, |
|
||||||
0x00, 0x00, 0x01, 0x01, 0x01, 0x02, 0x03, 0x04, |
|
||||||
0x01, 0x02, 0x03, 0x04, |
|
||||||
} |
|
||||||
|
|
||||||
var parts Parts |
|
||||||
err := parts.Unmarshal(byts) |
|
||||||
require.NoError(t, err) |
|
||||||
|
|
||||||
require.Equal(t, Parts{{ |
|
||||||
Tracks: []*PartTrack{ |
|
||||||
{ |
|
||||||
ID: 1, |
|
||||||
Samples: []*PartSample{ |
|
||||||
{ |
|
||||||
Duration: 2 * 90000, |
|
||||||
Payload: []byte{ |
|
||||||
0x00, 0x00, 0x00, 0x04, |
|
||||||
0x01, 0x02, 0x03, 0x04, // SPS
|
|
||||||
0x00, 0x00, 0x00, 0x01, |
|
||||||
0x08, // PPS
|
|
||||||
0x00, 0x00, 0x00, 0x01, |
|
||||||
0x05, // IDR
|
|
||||||
}, |
|
||||||
}, |
|
||||||
{ |
|
||||||
Duration: 2 * 90000, |
|
||||||
Payload: []byte{ |
|
||||||
0x00, 0x00, 0x00, 0x01, |
|
||||||
0x01, // non-IDR
|
|
||||||
}, |
|
||||||
IsNonSyncSample: true, |
|
||||||
}, |
|
||||||
{ |
|
||||||
Duration: 1 * 90000, |
|
||||||
Payload: []byte{ |
|
||||||
0x00, 0x00, 0x00, 0x01, |
|
||||||
0x01, // non-IDR
|
|
||||||
}, |
|
||||||
IsNonSyncSample: true, |
|
||||||
}, |
|
||||||
}, |
|
||||||
}, |
|
||||||
{ |
|
||||||
ID: 2, |
|
||||||
BaseTime: 3 * 48000, |
|
||||||
Samples: []*PartSample{ |
|
||||||
{ |
|
||||||
Duration: 500 * 48000 / 1000, |
|
||||||
Payload: []byte{ |
|
||||||
0x01, 0x02, 0x03, 0x04, |
|
||||||
}, |
|
||||||
}, |
|
||||||
{ |
|
||||||
Duration: 1 * 48000, |
|
||||||
Payload: []byte{ |
|
||||||
0x01, 0x02, 0x03, 0x04, |
|
||||||
}, |
|
||||||
}, |
|
||||||
}, |
|
||||||
}, |
|
||||||
}, |
|
||||||
}}, parts) |
|
||||||
} |
|
||||||
@ -1,111 +0,0 @@ |
|||||||
package fmp4 |
|
||||||
|
|
||||||
import ( |
|
||||||
gomp4 "github.com/abema/go-mp4" |
|
||||||
) |
|
||||||
|
|
||||||
// PartSample is a sample of a PartTrack.
|
|
||||||
type PartSample struct { |
|
||||||
Duration uint32 |
|
||||||
PTSOffset int32 |
|
||||||
IsNonSyncSample bool |
|
||||||
Payload []byte |
|
||||||
} |
|
||||||
|
|
||||||
// PartTrack is a track of Part.
|
|
||||||
type PartTrack struct { |
|
||||||
ID int |
|
||||||
BaseTime uint64 |
|
||||||
Samples []*PartSample |
|
||||||
IsVideo bool // marshal only
|
|
||||||
} |
|
||||||
|
|
||||||
func (pt *PartTrack) marshal(w *mp4Writer) (*gomp4.Trun, int, error) { |
|
||||||
/* |
|
||||||
traf |
|
||||||
- tfhd |
|
||||||
- tfdt |
|
||||||
- trun |
|
||||||
*/ |
|
||||||
|
|
||||||
_, err := w.writeBoxStart(&gomp4.Traf{}) // <traf>
|
|
||||||
if err != nil { |
|
||||||
return nil, 0, err |
|
||||||
} |
|
||||||
|
|
||||||
flags := 0 |
|
||||||
|
|
||||||
_, err = w.WriteBox(&gomp4.Tfhd{ // <tfhd/>
|
|
||||||
FullBox: gomp4.FullBox{ |
|
||||||
Flags: [3]byte{2, byte(flags >> 8), byte(flags)}, |
|
||||||
}, |
|
||||||
TrackID: uint32(pt.ID), |
|
||||||
}) |
|
||||||
if err != nil { |
|
||||||
return nil, 0, err |
|
||||||
} |
|
||||||
|
|
||||||
_, err = w.WriteBox(&gomp4.Tfdt{ // <tfdt/>
|
|
||||||
FullBox: gomp4.FullBox{ |
|
||||||
Version: 1, |
|
||||||
}, |
|
||||||
// sum of decode durations of all earlier samples
|
|
||||||
BaseMediaDecodeTimeV1: pt.BaseTime, |
|
||||||
}) |
|
||||||
if err != nil { |
|
||||||
return nil, 0, err |
|
||||||
} |
|
||||||
|
|
||||||
if pt.IsVideo { |
|
||||||
flags = trunFlagDataOffsetPreset | |
|
||||||
trunFlagSampleDurationPresent | |
|
||||||
trunFlagSampleSizePresent | |
|
||||||
trunFlagSampleFlagsPresent | |
|
||||||
trunFlagSampleCompositionTimeOffsetPresentOrV1 |
|
||||||
} else { |
|
||||||
flags = trunFlagDataOffsetPreset | |
|
||||||
trunFlagSampleDurationPresent | |
|
||||||
trunFlagSampleSizePresent |
|
||||||
} |
|
||||||
|
|
||||||
trun := &gomp4.Trun{ // <trun/>
|
|
||||||
FullBox: gomp4.FullBox{ |
|
||||||
Version: 1, |
|
||||||
Flags: [3]byte{0, byte(flags >> 8), byte(flags)}, |
|
||||||
}, |
|
||||||
SampleCount: uint32(len(pt.Samples)), |
|
||||||
} |
|
||||||
|
|
||||||
for _, sample := range pt.Samples { |
|
||||||
if pt.IsVideo { |
|
||||||
var flags uint32 |
|
||||||
if sample.IsNonSyncSample { |
|
||||||
flags |= sampleFlagIsNonSyncSample |
|
||||||
} |
|
||||||
|
|
||||||
trun.Entries = append(trun.Entries, gomp4.TrunEntry{ |
|
||||||
SampleDuration: sample.Duration, |
|
||||||
SampleSize: uint32(len(sample.Payload)), |
|
||||||
SampleFlags: flags, |
|
||||||
SampleCompositionTimeOffsetV1: sample.PTSOffset, |
|
||||||
}) |
|
||||||
} else { |
|
||||||
trun.Entries = append(trun.Entries, gomp4.TrunEntry{ |
|
||||||
SampleDuration: sample.Duration, |
|
||||||
SampleSize: uint32(len(sample.Payload)), |
|
||||||
}) |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
trunOffset, err := w.WriteBox(trun) |
|
||||||
if err != nil { |
|
||||||
return nil, 0, err |
|
||||||
} |
|
||||||
|
|
||||||
err = w.writeBoxEnd() // </traf>
|
|
||||||
if err != nil { |
|
||||||
return nil, 0, err |
|
||||||
} |
|
||||||
|
|
||||||
return trun, trunOffset, nil |
|
||||||
} |
|
||||||
@ -1,106 +0,0 @@ |
|||||||
// Package m3u8 contains a M3U8 parser.
|
|
||||||
package m3u8 |
|
||||||
|
|
||||||
import ( |
|
||||||
"bytes" |
|
||||||
"errors" |
|
||||||
"regexp" |
|
||||||
"strings" |
|
||||||
|
|
||||||
gm3u8 "github.com/grafov/m3u8" |
|
||||||
) |
|
||||||
|
|
||||||
var reKeyValue = regexp.MustCompile(`([a-zA-Z0-9_-]+)=("[^"]+"|[^",]+)`) |
|
||||||
|
|
||||||
func decodeParamsLine(line string) map[string]string { |
|
||||||
out := make(map[string]string) |
|
||||||
for _, kv := range reKeyValue.FindAllStringSubmatch(line, -1) { |
|
||||||
k, v := kv[1], kv[2] |
|
||||||
out[k] = strings.Trim(v, ` "`) |
|
||||||
} |
|
||||||
return out |
|
||||||
} |
|
||||||
|
|
||||||
// MasterPlaylist is a master playlist.
|
|
||||||
type MasterPlaylist struct { |
|
||||||
gm3u8.MasterPlaylist |
|
||||||
Alternatives []*gm3u8.Alternative |
|
||||||
} |
|
||||||
|
|
||||||
func (MasterPlaylist) isPlaylist() {} |
|
||||||
|
|
||||||
func newMasterPlaylist(byts []byte, mpl *gm3u8.MasterPlaylist) (*MasterPlaylist, error) { |
|
||||||
var alternatives []*gm3u8.Alternative |
|
||||||
|
|
||||||
// https://github.com/grafov/m3u8/blob/036100c52a87e26c62be56df85450e9c703201a6/reader.go#L301
|
|
||||||
for _, line := range strings.Split(string(byts), "\n") { |
|
||||||
if strings.HasPrefix(line, "#EXT-X-MEDIA:") { |
|
||||||
var alt gm3u8.Alternative |
|
||||||
for k, v := range decodeParamsLine(line[13:]) { |
|
||||||
switch k { |
|
||||||
case "TYPE": |
|
||||||
alt.Type = v |
|
||||||
case "GROUP-ID": |
|
||||||
alt.GroupId = v |
|
||||||
case "LANGUAGE": |
|
||||||
alt.Language = v |
|
||||||
case "NAME": |
|
||||||
alt.Name = v |
|
||||||
case "DEFAULT": |
|
||||||
switch { |
|
||||||
case strings.ToUpper(v) == "YES": |
|
||||||
alt.Default = true |
|
||||||
case strings.ToUpper(v) == "NO": |
|
||||||
alt.Default = false |
|
||||||
default: |
|
||||||
return nil, errors.New("value must be YES or NO") |
|
||||||
} |
|
||||||
case "AUTOSELECT": |
|
||||||
alt.Autoselect = v |
|
||||||
case "FORCED": |
|
||||||
alt.Forced = v |
|
||||||
case "CHARACTERISTICS": |
|
||||||
alt.Characteristics = v |
|
||||||
case "SUBTITLES": |
|
||||||
alt.Subtitles = v |
|
||||||
case "URI": |
|
||||||
alt.URI = v |
|
||||||
} |
|
||||||
} |
|
||||||
alternatives = append(alternatives, &alt) |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
return &MasterPlaylist{ |
|
||||||
MasterPlaylist: *mpl, |
|
||||||
Alternatives: alternatives, |
|
||||||
}, nil |
|
||||||
} |
|
||||||
|
|
||||||
// MediaPlaylist is a media playlist.
|
|
||||||
type MediaPlaylist gm3u8.MediaPlaylist |
|
||||||
|
|
||||||
func (MediaPlaylist) isPlaylist() {} |
|
||||||
|
|
||||||
// Playlist is a M3U8 playlist.
|
|
||||||
type Playlist interface { |
|
||||||
isPlaylist() |
|
||||||
} |
|
||||||
|
|
||||||
// Unmarshal decodes a M3U8 Playlist.
|
|
||||||
func Unmarshal(byts []byte) (Playlist, error) { |
|
||||||
pl, _, err := gm3u8.Decode(*(bytes.NewBuffer(byts)), true) |
|
||||||
if err != nil { |
|
||||||
return nil, err |
|
||||||
} |
|
||||||
|
|
||||||
switch tpl := pl.(type) { |
|
||||||
case *gm3u8.MasterPlaylist: |
|
||||||
return newMasterPlaylist(byts, tpl) |
|
||||||
|
|
||||||
case *gm3u8.MediaPlaylist: |
|
||||||
return (*MediaPlaylist)(tpl), nil |
|
||||||
} |
|
||||||
|
|
||||||
panic("unexpected playlist type") |
|
||||||
} |
|
||||||
@ -1,106 +0,0 @@ |
|||||||
package mpegts |
|
||||||
|
|
||||||
import ( |
|
||||||
"bytes" |
|
||||||
"context" |
|
||||||
"fmt" |
|
||||||
|
|
||||||
"github.com/aler9/gortsplib/v2/pkg/codecs/mpeg4audio" |
|
||||||
"github.com/aler9/gortsplib/v2/pkg/format" |
|
||||||
"github.com/asticode/go-astits" |
|
||||||
) |
|
||||||
|
|
||||||
func findMPEG4AudioConfig(dem *astits.Demuxer, pid uint16) (*mpeg4audio.Config, error) { |
|
||||||
for { |
|
||||||
data, err := dem.NextData() |
|
||||||
if err != nil { |
|
||||||
return nil, err |
|
||||||
} |
|
||||||
|
|
||||||
if data.PES == nil || data.PID != pid { |
|
||||||
continue |
|
||||||
} |
|
||||||
|
|
||||||
var adtsPkts mpeg4audio.ADTSPackets |
|
||||||
err = adtsPkts.Unmarshal(data.PES.Data) |
|
||||||
if err != nil { |
|
||||||
return nil, fmt.Errorf("unable to decode ADTS: %s", err) |
|
||||||
} |
|
||||||
|
|
||||||
pkt := adtsPkts[0] |
|
||||||
return &mpeg4audio.Config{ |
|
||||||
Type: pkt.Type, |
|
||||||
SampleRate: pkt.SampleRate, |
|
||||||
ChannelCount: pkt.ChannelCount, |
|
||||||
}, nil |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
// Track is a MPEG-TS track.
|
|
||||||
type Track struct { |
|
||||||
ES *astits.PMTElementaryStream |
|
||||||
Format format.Format |
|
||||||
} |
|
||||||
|
|
||||||
// FindTracks finds the tracks in a MPEG-TS stream.
|
|
||||||
func FindTracks(byts []byte) ([]*Track, error) { |
|
||||||
var tracks []*Track |
|
||||||
dem := astits.NewDemuxer(context.Background(), bytes.NewReader(byts)) |
|
||||||
|
|
||||||
for { |
|
||||||
data, err := dem.NextData() |
|
||||||
if err != nil { |
|
||||||
return nil, err |
|
||||||
} |
|
||||||
|
|
||||||
if data.PMT != nil { |
|
||||||
for _, es := range data.PMT.ElementaryStreams { |
|
||||||
switch es.StreamType { |
|
||||||
case astits.StreamTypeH264Video, |
|
||||||
astits.StreamTypeAACAudio: |
|
||||||
|
|
||||||
case astits.StreamTypeMetadata: |
|
||||||
continue |
|
||||||
|
|
||||||
default: |
|
||||||
return nil, fmt.Errorf("track type %d not supported (yet)", es.StreamType) |
|
||||||
} |
|
||||||
|
|
||||||
tracks = append(tracks, &Track{ |
|
||||||
ES: es, |
|
||||||
}) |
|
||||||
} |
|
||||||
break |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
if tracks == nil { |
|
||||||
return nil, fmt.Errorf("no tracks found") |
|
||||||
} |
|
||||||
|
|
||||||
for _, t := range tracks { |
|
||||||
switch t.ES.StreamType { |
|
||||||
case astits.StreamTypeH264Video: |
|
||||||
t.Format = &format.H264{ |
|
||||||
PayloadTyp: 96, |
|
||||||
PacketizationMode: 1, |
|
||||||
} |
|
||||||
|
|
||||||
case astits.StreamTypeAACAudio: |
|
||||||
conf, err := findMPEG4AudioConfig(dem, t.ES.ElementaryPID) |
|
||||||
if err != nil { |
|
||||||
return nil, err |
|
||||||
} |
|
||||||
|
|
||||||
t.Format = &format.MPEG4Audio{ |
|
||||||
PayloadTyp: 96, |
|
||||||
Config: conf, |
|
||||||
SizeLength: 13, |
|
||||||
IndexLength: 3, |
|
||||||
IndexDeltaLength: 3, |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
return tracks, nil |
|
||||||
} |
|
||||||
@ -1,201 +0,0 @@ |
|||||||
// Package mpegts contains a MPEG-TS reader and writer.
|
|
||||||
package mpegts |
|
||||||
|
|
||||||
import ( |
|
||||||
"bytes" |
|
||||||
"context" |
|
||||||
"time" |
|
||||||
|
|
||||||
"github.com/aler9/gortsplib/v2/pkg/codecs/h264" |
|
||||||
"github.com/aler9/gortsplib/v2/pkg/codecs/mpeg4audio" |
|
||||||
"github.com/aler9/gortsplib/v2/pkg/format" |
|
||||||
"github.com/asticode/go-astits" |
|
||||||
) |
|
||||||
|
|
||||||
const ( |
|
||||||
pcrOffset = 400 * time.Millisecond // 2 samples @ 5fps
|
|
||||||
) |
|
||||||
|
|
||||||
type writerFunc func(p []byte) (int, error) |
|
||||||
|
|
||||||
func (f writerFunc) Write(p []byte) (int, error) { |
|
||||||
return f(p) |
|
||||||
} |
|
||||||
|
|
||||||
// Writer is a MPEG-TS writer.
|
|
||||||
type Writer struct { |
|
||||||
videoFormat *format.H264 |
|
||||||
audioFormat *format.MPEG4Audio |
|
||||||
|
|
||||||
buf *bytes.Buffer |
|
||||||
inner *astits.Muxer |
|
||||||
pcrCounter int |
|
||||||
} |
|
||||||
|
|
||||||
// NewWriter allocates a Writer.
|
|
||||||
func NewWriter( |
|
||||||
videoFormat *format.H264, |
|
||||||
audioFormat *format.MPEG4Audio, |
|
||||||
) *Writer { |
|
||||||
w := &Writer{ |
|
||||||
videoFormat: videoFormat, |
|
||||||
audioFormat: audioFormat, |
|
||||||
buf: bytes.NewBuffer(nil), |
|
||||||
} |
|
||||||
|
|
||||||
w.inner = astits.NewMuxer( |
|
||||||
context.Background(), |
|
||||||
writerFunc(func(p []byte) (int, error) { |
|
||||||
return w.buf.Write(p) |
|
||||||
})) |
|
||||||
|
|
||||||
if videoFormat != nil { |
|
||||||
w.inner.AddElementaryStream(astits.PMTElementaryStream{ |
|
||||||
ElementaryPID: 256, |
|
||||||
StreamType: astits.StreamTypeH264Video, |
|
||||||
}) |
|
||||||
} |
|
||||||
|
|
||||||
if audioFormat != nil { |
|
||||||
w.inner.AddElementaryStream(astits.PMTElementaryStream{ |
|
||||||
ElementaryPID: 257, |
|
||||||
StreamType: astits.StreamTypeAACAudio, |
|
||||||
}) |
|
||||||
} |
|
||||||
|
|
||||||
if videoFormat != nil { |
|
||||||
w.inner.SetPCRPID(256) |
|
||||||
} else { |
|
||||||
w.inner.SetPCRPID(257) |
|
||||||
} |
|
||||||
|
|
||||||
// WriteTable() is not necessary
|
|
||||||
// since it's called automatically when WriteData() is called with
|
|
||||||
// * PID == PCRPID
|
|
||||||
// * AdaptationField != nil
|
|
||||||
// * RandomAccessIndicator = true
|
|
||||||
|
|
||||||
return w |
|
||||||
} |
|
||||||
|
|
||||||
// GenerateSegment generates a MPEG-TS segment.
|
|
||||||
func (w *Writer) GenerateSegment() []byte { |
|
||||||
w.pcrCounter = 0 |
|
||||||
ret := w.buf.Bytes() |
|
||||||
w.buf = bytes.NewBuffer(nil) |
|
||||||
return ret |
|
||||||
} |
|
||||||
|
|
||||||
// WriteH264 writes a H264 access unit.
|
|
||||||
func (w *Writer) WriteH264( |
|
||||||
pcr time.Duration, |
|
||||||
dts time.Duration, |
|
||||||
pts time.Duration, |
|
||||||
idrPresent bool, |
|
||||||
nalus [][]byte, |
|
||||||
) error { |
|
||||||
// prepend an AUD. This is required by video.js and iOS
|
|
||||||
nalus = append([][]byte{{byte(h264.NALUTypeAccessUnitDelimiter), 240}}, nalus...) |
|
||||||
|
|
||||||
enc, err := h264.AnnexBMarshal(nalus) |
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
|
|
||||||
var af *astits.PacketAdaptationField |
|
||||||
|
|
||||||
if idrPresent { |
|
||||||
af = &astits.PacketAdaptationField{} |
|
||||||
af.RandomAccessIndicator = true |
|
||||||
} |
|
||||||
|
|
||||||
// send PCR once in a while
|
|
||||||
if w.pcrCounter == 0 { |
|
||||||
if af == nil { |
|
||||||
af = &astits.PacketAdaptationField{} |
|
||||||
} |
|
||||||
af.HasPCR = true |
|
||||||
af.PCR = &astits.ClockReference{Base: int64(pcr.Seconds() * 90000)} |
|
||||||
w.pcrCounter = 3 |
|
||||||
} |
|
||||||
w.pcrCounter-- |
|
||||||
|
|
||||||
oh := &astits.PESOptionalHeader{ |
|
||||||
MarkerBits: 2, |
|
||||||
} |
|
||||||
|
|
||||||
if dts == pts { |
|
||||||
oh.PTSDTSIndicator = astits.PTSDTSIndicatorOnlyPTS |
|
||||||
oh.PTS = &astits.ClockReference{Base: int64((pts + pcrOffset).Seconds() * 90000)} |
|
||||||
} else { |
|
||||||
oh.PTSDTSIndicator = astits.PTSDTSIndicatorBothPresent |
|
||||||
oh.DTS = &astits.ClockReference{Base: int64((dts + pcrOffset).Seconds() * 90000)} |
|
||||||
oh.PTS = &astits.ClockReference{Base: int64((pts + pcrOffset).Seconds() * 90000)} |
|
||||||
} |
|
||||||
|
|
||||||
_, err = w.inner.WriteData(&astits.MuxerData{ |
|
||||||
PID: 256, |
|
||||||
AdaptationField: af, |
|
||||||
PES: &astits.PESData{ |
|
||||||
Header: &astits.PESHeader{ |
|
||||||
OptionalHeader: oh, |
|
||||||
StreamID: 224, // video
|
|
||||||
}, |
|
||||||
Data: enc, |
|
||||||
}, |
|
||||||
}) |
|
||||||
return err |
|
||||||
} |
|
||||||
|
|
||||||
// WriteAAC writes an AAC AU.
|
|
||||||
func (w *Writer) WriteAAC( |
|
||||||
pcr time.Duration, |
|
||||||
pts time.Duration, |
|
||||||
au []byte, |
|
||||||
) error { |
|
||||||
pkts := mpeg4audio.ADTSPackets{ |
|
||||||
{ |
|
||||||
Type: w.audioFormat.Config.Type, |
|
||||||
SampleRate: w.audioFormat.Config.SampleRate, |
|
||||||
ChannelCount: w.audioFormat.Config.ChannelCount, |
|
||||||
AU: au, |
|
||||||
}, |
|
||||||
} |
|
||||||
|
|
||||||
enc, err := pkts.Marshal() |
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
|
|
||||||
af := &astits.PacketAdaptationField{ |
|
||||||
RandomAccessIndicator: true, |
|
||||||
} |
|
||||||
|
|
||||||
if w.videoFormat == nil { |
|
||||||
// send PCR once in a while
|
|
||||||
if w.pcrCounter == 0 { |
|
||||||
af.HasPCR = true |
|
||||||
af.PCR = &astits.ClockReference{Base: int64(pcr.Seconds() * 90000)} |
|
||||||
w.pcrCounter = 3 |
|
||||||
} |
|
||||||
w.pcrCounter-- |
|
||||||
} |
|
||||||
|
|
||||||
_, err = w.inner.WriteData(&astits.MuxerData{ |
|
||||||
PID: 257, |
|
||||||
AdaptationField: af, |
|
||||||
PES: &astits.PESData{ |
|
||||||
Header: &astits.PESHeader{ |
|
||||||
OptionalHeader: &astits.PESOptionalHeader{ |
|
||||||
MarkerBits: 2, |
|
||||||
PTSDTSIndicator: astits.PTSDTSIndicatorOnlyPTS, |
|
||||||
PTS: &astits.ClockReference{Base: int64((pts + pcrOffset).Seconds() * 90000)}, |
|
||||||
}, |
|
||||||
PacketLength: uint16(len(enc) + 8), |
|
||||||
StreamID: 192, // audio
|
|
||||||
}, |
|
||||||
Data: enc, |
|
||||||
}, |
|
||||||
}) |
|
||||||
return err |
|
||||||
} |
|
||||||
@ -1,371 +0,0 @@ |
|||||||
package mpegts |
|
||||||
|
|
||||||
import ( |
|
||||||
"bytes" |
|
||||||
"context" |
|
||||||
"testing" |
|
||||||
"time" |
|
||||||
|
|
||||||
"github.com/aler9/gortsplib/v2/pkg/codecs/h264" |
|
||||||
"github.com/aler9/gortsplib/v2/pkg/codecs/mpeg4audio" |
|
||||||
"github.com/aler9/gortsplib/v2/pkg/format" |
|
||||||
"github.com/asticode/go-astits" |
|
||||||
"github.com/stretchr/testify/require" |
|
||||||
) |
|
||||||
|
|
||||||
func TestWriter(t *testing.T) { |
|
||||||
testSPS := []byte{ |
|
||||||
0x67, 0x42, 0xc0, 0x28, 0xd9, 0x00, 0x78, 0x02, |
|
||||||
0x27, 0xe5, 0x84, 0x00, 0x00, 0x03, 0x00, 0x04, |
|
||||||
0x00, 0x00, 0x03, 0x00, 0xf0, 0x3c, 0x60, 0xc9, |
|
||||||
0x20, |
|
||||||
} |
|
||||||
|
|
||||||
testVideoTrack := &format.H264{ |
|
||||||
PayloadTyp: 96, |
|
||||||
SPS: testSPS, |
|
||||||
PPS: []byte{0x08}, |
|
||||||
PacketizationMode: 1, |
|
||||||
} |
|
||||||
|
|
||||||
testAudioTrack := &format.MPEG4Audio{ |
|
||||||
PayloadTyp: 97, |
|
||||||
Config: &mpeg4audio.Config{ |
|
||||||
Type: 2, |
|
||||||
SampleRate: 44100, |
|
||||||
ChannelCount: 2, |
|
||||||
}, |
|
||||||
SizeLength: 13, |
|
||||||
IndexLength: 3, |
|
||||||
IndexDeltaLength: 3, |
|
||||||
} |
|
||||||
|
|
||||||
type videoSample struct { |
|
||||||
NALUs [][]byte |
|
||||||
PTS time.Duration |
|
||||||
DTS time.Duration |
|
||||||
} |
|
||||||
|
|
||||||
type audioSample struct { |
|
||||||
AU []byte |
|
||||||
PTS time.Duration |
|
||||||
} |
|
||||||
|
|
||||||
type sample interface{} |
|
||||||
|
|
||||||
testSamples := []sample{ |
|
||||||
videoSample{ |
|
||||||
NALUs: [][]byte{ |
|
||||||
testSPS, // SPS
|
|
||||||
{8}, // PPS
|
|
||||||
{5}, // IDR
|
|
||||||
}, |
|
||||||
PTS: 2 * time.Second, |
|
||||||
DTS: 2 * time.Second, |
|
||||||
}, |
|
||||||
audioSample{ |
|
||||||
AU: []byte{ |
|
||||||
0x01, 0x02, 0x03, 0x04, |
|
||||||
}, |
|
||||||
PTS: 3 * time.Second, |
|
||||||
}, |
|
||||||
audioSample{ |
|
||||||
AU: []byte{ |
|
||||||
0x01, 0x02, 0x03, 0x04, |
|
||||||
}, |
|
||||||
PTS: 3500 * time.Millisecond, |
|
||||||
}, |
|
||||||
videoSample{ |
|
||||||
NALUs: [][]byte{ |
|
||||||
{1}, // non-IDR
|
|
||||||
}, |
|
||||||
PTS: 4 * time.Second, |
|
||||||
DTS: 4 * time.Second, |
|
||||||
}, |
|
||||||
audioSample{ |
|
||||||
AU: []byte{ |
|
||||||
0x01, 0x02, 0x03, 0x04, |
|
||||||
}, |
|
||||||
PTS: 4500 * time.Millisecond, |
|
||||||
}, |
|
||||||
videoSample{ |
|
||||||
NALUs: [][]byte{ |
|
||||||
{1}, // non-IDR
|
|
||||||
}, |
|
||||||
PTS: 6 * time.Second, |
|
||||||
DTS: 6 * time.Second, |
|
||||||
}, |
|
||||||
} |
|
||||||
|
|
||||||
t.Run("video + audio", func(t *testing.T) { |
|
||||||
w := NewWriter(testVideoTrack, testAudioTrack) |
|
||||||
|
|
||||||
for _, sample := range testSamples { |
|
||||||
switch tsample := sample.(type) { |
|
||||||
case videoSample: |
|
||||||
err := w.WriteH264( |
|
||||||
tsample.DTS-2*time.Second, |
|
||||||
tsample.DTS, |
|
||||||
tsample.PTS, |
|
||||||
h264.IDRPresent(tsample.NALUs), |
|
||||||
tsample.NALUs) |
|
||||||
require.NoError(t, err) |
|
||||||
|
|
||||||
case audioSample: |
|
||||||
err := w.WriteAAC( |
|
||||||
tsample.PTS-2*time.Second, |
|
||||||
tsample.PTS, |
|
||||||
tsample.AU) |
|
||||||
require.NoError(t, err) |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
byts := w.GenerateSegment() |
|
||||||
|
|
||||||
dem := astits.NewDemuxer(context.Background(), bytes.NewReader(byts), |
|
||||||
astits.DemuxerOptPacketSize(188)) |
|
||||||
|
|
||||||
// PMT
|
|
||||||
pkt, err := dem.NextPacket() |
|
||||||
require.NoError(t, err) |
|
||||||
require.Equal(t, &astits.Packet{ |
|
||||||
Header: &astits.PacketHeader{ |
|
||||||
HasPayload: true, |
|
||||||
PayloadUnitStartIndicator: true, |
|
||||||
PID: 0, |
|
||||||
}, |
|
||||||
Payload: append([]byte{ |
|
||||||
0x00, 0x00, 0xb0, 0x0d, 0x00, 0x00, 0xc1, 0x00, |
|
||||||
0x00, 0x00, 0x01, 0xf0, 0x00, 0x71, 0x10, 0xd8, |
|
||||||
0x78, |
|
||||||
}, bytes.Repeat([]byte{0xff}, 167)...), |
|
||||||
}, pkt) |
|
||||||
|
|
||||||
// PAT
|
|
||||||
pkt, err = dem.NextPacket() |
|
||||||
require.NoError(t, err) |
|
||||||
require.Equal(t, &astits.Packet{ |
|
||||||
Header: &astits.PacketHeader{ |
|
||||||
HasPayload: true, |
|
||||||
PayloadUnitStartIndicator: true, |
|
||||||
PID: 4096, |
|
||||||
}, |
|
||||||
Payload: append([]byte{ |
|
||||||
0x00, 0x02, 0xb0, 0x17, 0x00, 0x01, 0xc1, 0x00, |
|
||||||
0x00, 0xe1, 0x00, 0xf0, 0x00, 0x1b, 0xe1, 0x00, |
|
||||||
0xf0, 0x00, 0x0f, 0xe1, 0x01, 0xf0, 0x00, 0x2f, |
|
||||||
0x44, 0xb9, 0x9b, |
|
||||||
}, bytes.Repeat([]byte{0xff}, 157)...), |
|
||||||
}, pkt) |
|
||||||
|
|
||||||
// PES (H264)
|
|
||||||
pkt, err = dem.NextPacket() |
|
||||||
require.NoError(t, err) |
|
||||||
require.Equal(t, &astits.Packet{ |
|
||||||
AdaptationField: &astits.PacketAdaptationField{ |
|
||||||
Length: 124, |
|
||||||
StuffingLength: 117, |
|
||||||
HasPCR: true, |
|
||||||
PCR: &astits.ClockReference{}, |
|
||||||
RandomAccessIndicator: true, |
|
||||||
}, |
|
||||||
Header: &astits.PacketHeader{ |
|
||||||
HasAdaptationField: true, |
|
||||||
HasPayload: true, |
|
||||||
PayloadUnitStartIndicator: true, |
|
||||||
PID: 256, |
|
||||||
}, |
|
||||||
Payload: []byte{ |
|
||||||
0x00, 0x00, 0x01, 0xe0, 0x00, 0x00, 0x80, 0x80, |
|
||||||
0x05, 0x21, 0x00, 0x0d, 0x97, 0x81, 0x00, 0x00, |
|
||||||
0x00, 0x01, 0x09, 0xf0, 0x00, 0x00, 0x00, 0x01, |
|
||||||
0x67, 0x42, 0xc0, 0x28, 0xd9, 0x00, 0x78, 0x02, |
|
||||||
0x27, 0xe5, 0x84, 0x00, 0x00, 0x03, 0x00, 0x04, |
|
||||||
0x00, 0x00, 0x03, 0x00, 0xf0, 0x3c, 0x60, 0xc9, |
|
||||||
0x20, 0x00, 0x00, 0x00, 0x01, 0x08, 0x00, 0x00, |
|
||||||
0x00, 0x01, 0x05, |
|
||||||
}, |
|
||||||
}, pkt) |
|
||||||
|
|
||||||
// PES (AAC)
|
|
||||||
pkt, err = dem.NextPacket() |
|
||||||
require.NoError(t, err) |
|
||||||
require.Equal(t, &astits.Packet{ |
|
||||||
AdaptationField: &astits.PacketAdaptationField{ |
|
||||||
Length: 158, |
|
||||||
StuffingLength: 157, |
|
||||||
RandomAccessIndicator: true, |
|
||||||
}, |
|
||||||
Header: &astits.PacketHeader{ |
|
||||||
HasAdaptationField: true, |
|
||||||
HasPayload: true, |
|
||||||
PayloadUnitStartIndicator: true, |
|
||||||
PID: 257, |
|
||||||
}, |
|
||||||
Payload: []byte{ |
|
||||||
0x00, 0x00, 0x01, 0xc0, 0x00, 0x13, 0x80, 0x80, |
|
||||||
0x05, 0x21, 0x00, 0x13, 0x56, 0xa1, 0xff, 0xf1, |
|
||||||
0x50, 0x80, 0x01, 0x7f, 0xfc, 0x01, 0x02, 0x03, |
|
||||||
0x04, |
|
||||||
}, |
|
||||||
}, pkt) |
|
||||||
}) |
|
||||||
|
|
||||||
t.Run("video only", func(t *testing.T) { |
|
||||||
w := NewWriter(testVideoTrack, nil) |
|
||||||
|
|
||||||
for _, sample := range testSamples { |
|
||||||
if tsample, ok := sample.(videoSample); ok { |
|
||||||
err := w.WriteH264( |
|
||||||
tsample.DTS-2*time.Second, |
|
||||||
tsample.DTS, |
|
||||||
tsample.PTS, |
|
||||||
h264.IDRPresent(tsample.NALUs), |
|
||||||
tsample.NALUs) |
|
||||||
require.NoError(t, err) |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
byts := w.GenerateSegment() |
|
||||||
|
|
||||||
dem := astits.NewDemuxer(context.Background(), bytes.NewReader(byts), |
|
||||||
astits.DemuxerOptPacketSize(188)) |
|
||||||
|
|
||||||
// PMT
|
|
||||||
pkt, err := dem.NextPacket() |
|
||||||
require.NoError(t, err) |
|
||||||
require.Equal(t, &astits.Packet{ |
|
||||||
Header: &astits.PacketHeader{ |
|
||||||
HasPayload: true, |
|
||||||
PayloadUnitStartIndicator: true, |
|
||||||
PID: 0, |
|
||||||
}, |
|
||||||
Payload: append([]byte{ |
|
||||||
0x00, 0x00, 0xb0, 0x0d, 0x00, 0x00, 0xc1, 0x00, |
|
||||||
0x00, 0x00, 0x01, 0xf0, 0x00, 0x71, 0x10, 0xd8, |
|
||||||
0x78, |
|
||||||
}, bytes.Repeat([]byte{0xff}, 167)...), |
|
||||||
}, pkt) |
|
||||||
|
|
||||||
// PAT
|
|
||||||
pkt, err = dem.NextPacket() |
|
||||||
require.NoError(t, err) |
|
||||||
require.Equal(t, &astits.Packet{ |
|
||||||
Header: &astits.PacketHeader{ |
|
||||||
HasPayload: true, |
|
||||||
PayloadUnitStartIndicator: true, |
|
||||||
PID: 4096, |
|
||||||
}, |
|
||||||
Payload: append([]byte{ |
|
||||||
0x00, 0x02, 0xb0, 0x12, 0x00, 0x01, 0xc1, 0x00, |
|
||||||
0x00, 0xe1, 0x00, 0xf0, 0x00, 0x1b, 0xe1, 0x00, |
|
||||||
0xf0, 0x00, 0x15, 0xbd, 0x4d, 0x56, |
|
||||||
}, bytes.Repeat([]byte{0xff}, 162)...), |
|
||||||
}, pkt) |
|
||||||
|
|
||||||
// PES (H264)
|
|
||||||
pkt, err = dem.NextPacket() |
|
||||||
require.NoError(t, err) |
|
||||||
require.Equal(t, &astits.Packet{ |
|
||||||
AdaptationField: &astits.PacketAdaptationField{ |
|
||||||
Length: 124, |
|
||||||
StuffingLength: 117, |
|
||||||
HasPCR: true, |
|
||||||
PCR: &astits.ClockReference{}, |
|
||||||
RandomAccessIndicator: true, |
|
||||||
}, |
|
||||||
Header: &astits.PacketHeader{ |
|
||||||
HasAdaptationField: true, |
|
||||||
HasPayload: true, |
|
||||||
PayloadUnitStartIndicator: true, |
|
||||||
PID: 256, |
|
||||||
}, |
|
||||||
Payload: []byte{ |
|
||||||
0x00, 0x00, 0x01, 0xe0, 0x00, 0x00, 0x80, 0x80, |
|
||||||
0x05, 0x21, 0x00, 0x0d, 0x97, 0x81, 0x00, 0x00, |
|
||||||
0x00, 0x01, 0x09, 0xf0, 0x00, 0x00, 0x00, 0x01, |
|
||||||
0x67, 0x42, 0xc0, 0x28, 0xd9, 0x00, 0x78, 0x02, |
|
||||||
0x27, 0xe5, 0x84, 0x00, 0x00, 0x03, 0x00, 0x04, |
|
||||||
0x00, 0x00, 0x03, 0x00, 0xf0, 0x3c, 0x60, 0xc9, |
|
||||||
0x20, 0x00, 0x00, 0x00, 0x01, 0x08, 0x00, 0x00, |
|
||||||
0x00, 0x01, 0x05, |
|
||||||
}, |
|
||||||
}, pkt) |
|
||||||
}) |
|
||||||
|
|
||||||
t.Run("audio only", func(t *testing.T) { |
|
||||||
w := NewWriter(nil, testAudioTrack) |
|
||||||
|
|
||||||
for _, sample := range testSamples { |
|
||||||
if tsample, ok := sample.(audioSample); ok { |
|
||||||
err := w.WriteAAC( |
|
||||||
tsample.PTS-2*time.Second, |
|
||||||
tsample.PTS, |
|
||||||
tsample.AU) |
|
||||||
require.NoError(t, err) |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
byts := w.GenerateSegment() |
|
||||||
|
|
||||||
dem := astits.NewDemuxer(context.Background(), bytes.NewReader(byts), |
|
||||||
astits.DemuxerOptPacketSize(188)) |
|
||||||
|
|
||||||
// PMT
|
|
||||||
pkt, err := dem.NextPacket() |
|
||||||
require.NoError(t, err) |
|
||||||
require.Equal(t, &astits.Packet{ |
|
||||||
Header: &astits.PacketHeader{ |
|
||||||
HasPayload: true, |
|
||||||
PayloadUnitStartIndicator: true, |
|
||||||
PID: 0, |
|
||||||
}, |
|
||||||
Payload: append([]byte{ |
|
||||||
0x00, 0x00, 0xb0, 0x0d, 0x00, 0x00, 0xc1, 0x00, |
|
||||||
0x00, 0x00, 0x01, 0xf0, 0x00, 0x71, 0x10, 0xd8, |
|
||||||
0x78, |
|
||||||
}, bytes.Repeat([]byte{0xff}, 167)...), |
|
||||||
}, pkt) |
|
||||||
|
|
||||||
// PAT
|
|
||||||
pkt, err = dem.NextPacket() |
|
||||||
require.NoError(t, err) |
|
||||||
require.Equal(t, &astits.Packet{ |
|
||||||
Header: &astits.PacketHeader{ |
|
||||||
HasPayload: true, |
|
||||||
PayloadUnitStartIndicator: true, |
|
||||||
PID: 4096, |
|
||||||
}, |
|
||||||
Payload: append([]byte{ |
|
||||||
0x00, 0x02, 0xb0, 0x12, 0x00, 0x01, 0xc1, 0x00, |
|
||||||
0x00, 0xe1, 0x01, 0xf0, 0x00, 0x0f, 0xe1, 0x01, |
|
||||||
0xf0, 0x00, 0xec, 0xe2, 0xb0, 0x94, |
|
||||||
}, bytes.Repeat([]byte{0xff}, 162)...), |
|
||||||
}, pkt) |
|
||||||
|
|
||||||
// PES (AAC)
|
|
||||||
pkt, err = dem.NextPacket() |
|
||||||
require.NoError(t, err) |
|
||||||
require.Equal(t, &astits.Packet{ |
|
||||||
AdaptationField: &astits.PacketAdaptationField{ |
|
||||||
Length: 158, |
|
||||||
StuffingLength: 151, |
|
||||||
RandomAccessIndicator: true, |
|
||||||
HasPCR: true, |
|
||||||
PCR: &astits.ClockReference{Base: 90000}, |
|
||||||
}, |
|
||||||
Header: &astits.PacketHeader{ |
|
||||||
HasAdaptationField: true, |
|
||||||
HasPayload: true, |
|
||||||
PayloadUnitStartIndicator: true, |
|
||||||
PID: 257, |
|
||||||
}, |
|
||||||
Payload: []byte{ |
|
||||||
0x00, 0x00, 0x01, 0xc0, 0x00, 0x13, 0x80, 0x80, |
|
||||||
0x05, 0x21, 0x00, 0x13, 0x56, 0xa1, 0xff, 0xf1, |
|
||||||
0x50, 0x80, 0x01, 0x7f, 0xfc, 0x01, 0x02, 0x03, |
|
||||||
0x04, |
|
||||||
}, |
|
||||||
}, pkt) |
|
||||||
}) |
|
||||||
} |
|
||||||
@ -1,46 +0,0 @@ |
|||||||
// Package mpegtstimedec contains a MPEG-TS timestamp decoder.
|
|
||||||
package mpegtstimedec |
|
||||||
|
|
||||||
import ( |
|
||||||
"time" |
|
||||||
) |
|
||||||
|
|
||||||
const ( |
|
||||||
maximum = 0x1FFFFFFFF // 33 bits
|
|
||||||
negativeThreshold = 0x1FFFFFFFF / 2 |
|
||||||
clockRate = 90000 |
|
||||||
) |
|
||||||
|
|
||||||
// Decoder is a MPEG-TS timestamp decoder.
|
|
||||||
type Decoder struct { |
|
||||||
overall time.Duration |
|
||||||
prev int64 |
|
||||||
} |
|
||||||
|
|
||||||
// New allocates a Decoder.
|
|
||||||
func New(start int64) *Decoder { |
|
||||||
return &Decoder{ |
|
||||||
prev: start, |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
// Decode decodes a MPEG-TS timestamp.
|
|
||||||
func (d *Decoder) Decode(ts int64) time.Duration { |
|
||||||
diff := (ts - d.prev) & maximum |
|
||||||
|
|
||||||
// negative difference
|
|
||||||
if diff > negativeThreshold { |
|
||||||
diff = (d.prev - ts) & maximum |
|
||||||
d.prev = ts |
|
||||||
d.overall -= time.Duration(diff) |
|
||||||
} else { |
|
||||||
d.prev = ts |
|
||||||
d.overall += time.Duration(diff) |
|
||||||
} |
|
||||||
|
|
||||||
// avoid an int64 overflow and preserve resolution by splitting division into two parts:
|
|
||||||
// first add the integer part, then the decimal part.
|
|
||||||
secs := d.overall / clockRate |
|
||||||
dec := d.overall % clockRate |
|
||||||
return secs*time.Second + dec*time.Second/clockRate |
|
||||||
} |
|
||||||
@ -1,72 +0,0 @@ |
|||||||
package mpegtstimedec |
|
||||||
|
|
||||||
import ( |
|
||||||
"testing" |
|
||||||
"time" |
|
||||||
|
|
||||||
"github.com/stretchr/testify/require" |
|
||||||
) |
|
||||||
|
|
||||||
func TestNegativeDiff(t *testing.T) { |
|
||||||
d := New(64523434) |
|
||||||
|
|
||||||
ts := d.Decode(64523434 - 90000) |
|
||||||
require.Equal(t, -1*time.Second, ts) |
|
||||||
|
|
||||||
ts = d.Decode(64523434) |
|
||||||
require.Equal(t, time.Duration(0), ts) |
|
||||||
|
|
||||||
ts = d.Decode(64523434 + 90000*2) |
|
||||||
require.Equal(t, 2*time.Second, ts) |
|
||||||
|
|
||||||
ts = d.Decode(64523434 + 90000) |
|
||||||
require.Equal(t, 1*time.Second, ts) |
|
||||||
} |
|
||||||
|
|
||||||
func TestOverflow(t *testing.T) { |
|
||||||
d := New(0x1FFFFFFFF - 20) |
|
||||||
|
|
||||||
i := int64(0x1FFFFFFFF - 20) |
|
||||||
secs := time.Duration(0) |
|
||||||
const stride = 150 |
|
||||||
lim := int64(uint64(0x1FFFFFFFF - (stride * 90000))) |
|
||||||
|
|
||||||
for n := 0; n < 100; n++ { |
|
||||||
// overflow
|
|
||||||
i += 90000 * stride |
|
||||||
secs += stride |
|
||||||
ts := d.Decode(i) |
|
||||||
require.Equal(t, secs*time.Second, ts) |
|
||||||
|
|
||||||
// reach 2^32 slowly
|
|
||||||
secs += stride |
|
||||||
i += 90000 * stride |
|
||||||
for ; i < lim; i += 90000 * stride { |
|
||||||
ts = d.Decode(i) |
|
||||||
require.Equal(t, secs*time.Second, ts) |
|
||||||
secs += stride |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
func TestOverflowAndBack(t *testing.T) { |
|
||||||
d := New(0x1FFFFFFFF - 90000 + 1) |
|
||||||
|
|
||||||
ts := d.Decode(0x1FFFFFFFF - 90000 + 1) |
|
||||||
require.Equal(t, time.Duration(0), ts) |
|
||||||
|
|
||||||
ts = d.Decode(90000) |
|
||||||
require.Equal(t, 2*time.Second, ts) |
|
||||||
|
|
||||||
ts = d.Decode(0x1FFFFFFFF - 90000 + 1) |
|
||||||
require.Equal(t, time.Duration(0), ts) |
|
||||||
|
|
||||||
ts = d.Decode(0x1FFFFFFFF - 90000*2 + 1) |
|
||||||
require.Equal(t, -1*time.Second, ts) |
|
||||||
|
|
||||||
ts = d.Decode(0x1FFFFFFFF - 90000 + 1) |
|
||||||
require.Equal(t, time.Duration(0), ts) |
|
||||||
|
|
||||||
ts = d.Decode(90000) |
|
||||||
require.Equal(t, 2*time.Second, ts) |
|
||||||
} |
|
||||||
@ -1,100 +0,0 @@ |
|||||||
// Package hls contains a HLS muxer and client.
|
|
||||||
package hls |
|
||||||
|
|
||||||
import ( |
|
||||||
"io" |
|
||||||
"time" |
|
||||||
|
|
||||||
"github.com/aler9/gortsplib/v2/pkg/format" |
|
||||||
) |
|
||||||
|
|
||||||
// MuxerFileResponse is a response of the Muxer's File() func.
|
|
||||||
type MuxerFileResponse struct { |
|
||||||
Status int |
|
||||||
Header map[string]string |
|
||||||
Body io.Reader |
|
||||||
} |
|
||||||
|
|
||||||
// Muxer is a HLS muxer.
|
|
||||||
type Muxer struct { |
|
||||||
primaryPlaylist *muxerPrimaryPlaylist |
|
||||||
variant muxerVariant |
|
||||||
} |
|
||||||
|
|
||||||
// NewMuxer allocates a Muxer.
|
|
||||||
func NewMuxer( |
|
||||||
variant MuxerVariant, |
|
||||||
segmentCount int, |
|
||||||
segmentDuration time.Duration, |
|
||||||
partDuration time.Duration, |
|
||||||
segmentMaxSize uint64, |
|
||||||
videoTrack format.Format, |
|
||||||
audioTrack format.Format, |
|
||||||
) (*Muxer, error) { |
|
||||||
m := &Muxer{} |
|
||||||
|
|
||||||
switch variant { |
|
||||||
case MuxerVariantMPEGTS: |
|
||||||
var err error |
|
||||||
m.variant, err = newMuxerVariantMPEGTS( |
|
||||||
segmentCount, |
|
||||||
segmentDuration, |
|
||||||
segmentMaxSize, |
|
||||||
videoTrack, |
|
||||||
audioTrack, |
|
||||||
) |
|
||||||
if err != nil { |
|
||||||
return nil, err |
|
||||||
} |
|
||||||
|
|
||||||
case MuxerVariantFMP4: |
|
||||||
m.variant = newMuxerVariantFMP4( |
|
||||||
false, |
|
||||||
segmentCount, |
|
||||||
segmentDuration, |
|
||||||
partDuration, |
|
||||||
segmentMaxSize, |
|
||||||
videoTrack, |
|
||||||
audioTrack, |
|
||||||
) |
|
||||||
|
|
||||||
default: // MuxerVariantLowLatency
|
|
||||||
m.variant = newMuxerVariantFMP4( |
|
||||||
true, |
|
||||||
segmentCount, |
|
||||||
segmentDuration, |
|
||||||
partDuration, |
|
||||||
segmentMaxSize, |
|
||||||
videoTrack, |
|
||||||
audioTrack, |
|
||||||
) |
|
||||||
} |
|
||||||
|
|
||||||
m.primaryPlaylist = newMuxerPrimaryPlaylist(variant != MuxerVariantMPEGTS, videoTrack, audioTrack) |
|
||||||
|
|
||||||
return m, nil |
|
||||||
} |
|
||||||
|
|
||||||
// Close closes a Muxer.
|
|
||||||
func (m *Muxer) Close() { |
|
||||||
m.variant.close() |
|
||||||
} |
|
||||||
|
|
||||||
// WriteH26x writes an H264 or an H265 access unit.
|
|
||||||
func (m *Muxer) WriteH26x(ntp time.Time, pts time.Duration, au [][]byte) error { |
|
||||||
return m.variant.writeH26x(ntp, pts, au) |
|
||||||
} |
|
||||||
|
|
||||||
// WriteAudio writes an audio access unit.
|
|
||||||
func (m *Muxer) WriteAudio(ntp time.Time, pts time.Duration, au []byte) error { |
|
||||||
return m.variant.writeAudio(ntp, pts, au) |
|
||||||
} |
|
||||||
|
|
||||||
// File returns a file reader.
|
|
||||||
func (m *Muxer) File(name string, msn string, part string, skip string) *MuxerFileResponse { |
|
||||||
if name == "index.m3u8" { |
|
||||||
return m.primaryPlaylist.file() |
|
||||||
} |
|
||||||
|
|
||||||
return m.variant.file(name, msn, part, skip) |
|
||||||
} |
|
||||||
@ -1,62 +0,0 @@ |
|||||||
package hls |
|
||||||
|
|
||||||
import ( |
|
||||||
"bytes" |
|
||||||
"io" |
|
||||||
"net/http" |
|
||||||
"strconv" |
|
||||||
"strings" |
|
||||||
|
|
||||||
"github.com/aler9/gortsplib/v2/pkg/format" |
|
||||||
) |
|
||||||
|
|
||||||
type muxerPrimaryPlaylist struct { |
|
||||||
fmp4 bool |
|
||||||
videoTrack format.Format |
|
||||||
audioTrack format.Format |
|
||||||
} |
|
||||||
|
|
||||||
func newMuxerPrimaryPlaylist( |
|
||||||
fmp4 bool, |
|
||||||
videoTrack format.Format, |
|
||||||
audioTrack format.Format, |
|
||||||
) *muxerPrimaryPlaylist { |
|
||||||
return &muxerPrimaryPlaylist{ |
|
||||||
fmp4: fmp4, |
|
||||||
videoTrack: videoTrack, |
|
||||||
audioTrack: audioTrack, |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
func (p *muxerPrimaryPlaylist) file() *MuxerFileResponse { |
|
||||||
return &MuxerFileResponse{ |
|
||||||
Status: http.StatusOK, |
|
||||||
Header: map[string]string{ |
|
||||||
"Content-Type": `application/x-mpegURL`, |
|
||||||
}, |
|
||||||
Body: func() io.Reader { |
|
||||||
var codecs []string |
|
||||||
|
|
||||||
if p.videoTrack != nil { |
|
||||||
codecs = append(codecs, codecParametersGenerate(p.videoTrack)) |
|
||||||
} |
|
||||||
if p.audioTrack != nil { |
|
||||||
codecs = append(codecs, codecParametersGenerate(p.audioTrack)) |
|
||||||
} |
|
||||||
|
|
||||||
var version int |
|
||||||
if !p.fmp4 { |
|
||||||
version = 3 |
|
||||||
} else { |
|
||||||
version = 9 |
|
||||||
} |
|
||||||
|
|
||||||
return bytes.NewReader([]byte("#EXTM3U\n" + |
|
||||||
"#EXT-X-VERSION:" + strconv.FormatInt(int64(version), 10) + "\n" + |
|
||||||
"#EXT-X-INDEPENDENT-SEGMENTS\n" + |
|
||||||
"\n" + |
|
||||||
"#EXT-X-STREAM-INF:BANDWIDTH=200000,CODECS=\"" + strings.Join(codecs, ",") + "\"\n" + |
|
||||||
"stream.m3u8\n")) |
|
||||||
}(), |
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,595 +0,0 @@ |
|||||||
package hls |
|
||||||
|
|
||||||
import ( |
|
||||||
"io" |
|
||||||
"net/http" |
|
||||||
"regexp" |
|
||||||
"testing" |
|
||||||
"time" |
|
||||||
|
|
||||||
"github.com/aler9/gortsplib/v2/pkg/codecs/mpeg4audio" |
|
||||||
"github.com/aler9/gortsplib/v2/pkg/format" |
|
||||||
"github.com/stretchr/testify/require" |
|
||||||
) |
|
||||||
|
|
||||||
var testTime = time.Date(2010, 0o1, 0o1, 0o1, 0o1, 0o1, 0, time.UTC) |
|
||||||
|
|
||||||
// baseline profile without POC
|
|
||||||
var testSPS = []byte{ |
|
||||||
0x67, 0x42, 0xc0, 0x28, 0xd9, 0x00, 0x78, 0x02, |
|
||||||
0x27, 0xe5, 0x84, 0x00, 0x00, 0x03, 0x00, 0x04, |
|
||||||
0x00, 0x00, 0x03, 0x00, 0xf0, 0x3c, 0x60, 0xc9, |
|
||||||
0x20, |
|
||||||
} |
|
||||||
|
|
||||||
func TestMuxerVideoAudio(t *testing.T) { |
|
||||||
videoTrack := &format.H264{ |
|
||||||
PayloadTyp: 96, |
|
||||||
SPS: testSPS, |
|
||||||
PPS: []byte{0x08}, |
|
||||||
PacketizationMode: 1, |
|
||||||
} |
|
||||||
|
|
||||||
audioTrack := &format.MPEG4Audio{ |
|
||||||
PayloadTyp: 97, |
|
||||||
Config: &mpeg4audio.Config{ |
|
||||||
Type: 2, |
|
||||||
SampleRate: 44100, |
|
||||||
ChannelCount: 2, |
|
||||||
}, |
|
||||||
SizeLength: 13, |
|
||||||
IndexLength: 3, |
|
||||||
IndexDeltaLength: 3, |
|
||||||
} |
|
||||||
|
|
||||||
for _, ca := range []string{ |
|
||||||
"mpegts", |
|
||||||
"fmp4", |
|
||||||
"lowLatency", |
|
||||||
} { |
|
||||||
t.Run(ca, func(t *testing.T) { |
|
||||||
var v MuxerVariant |
|
||||||
switch ca { |
|
||||||
case "mpegts": |
|
||||||
v = MuxerVariantMPEGTS |
|
||||||
|
|
||||||
case "fmp4": |
|
||||||
v = MuxerVariantFMP4 |
|
||||||
|
|
||||||
case "lowLatency": |
|
||||||
v = MuxerVariantLowLatency |
|
||||||
} |
|
||||||
|
|
||||||
m, err := NewMuxer(v, 3, 1*time.Second, 0, 50*1024*1024, videoTrack, audioTrack) |
|
||||||
require.NoError(t, err) |
|
||||||
defer m.Close() |
|
||||||
|
|
||||||
// access unit without IDR
|
|
||||||
d := 1 * time.Second |
|
||||||
err = m.WriteH26x(testTime.Add(d-1*time.Second), d, [][]byte{ |
|
||||||
{0x06}, |
|
||||||
{0x07}, |
|
||||||
}) |
|
||||||
require.NoError(t, err) |
|
||||||
|
|
||||||
// access unit with IDR
|
|
||||||
d = 2 * time.Second |
|
||||||
err = m.WriteH26x(testTime.Add(d-1*time.Second), d, [][]byte{ |
|
||||||
testSPS, // SPS
|
|
||||||
{8}, // PPS
|
|
||||||
{5}, // IDR
|
|
||||||
}) |
|
||||||
require.NoError(t, err) |
|
||||||
|
|
||||||
d = 3 * time.Second |
|
||||||
err = m.WriteAudio(testTime.Add(d-1*time.Second), d, []byte{ |
|
||||||
0x01, 0x02, 0x03, 0x04, |
|
||||||
}) |
|
||||||
require.NoError(t, err) |
|
||||||
|
|
||||||
d = 3500 * time.Millisecond |
|
||||||
err = m.WriteAudio(testTime.Add(d-1*time.Second), d, []byte{ |
|
||||||
0x01, 0x02, 0x03, 0x04, |
|
||||||
}) |
|
||||||
require.NoError(t, err) |
|
||||||
|
|
||||||
// access unit without IDR
|
|
||||||
d = 4 * time.Second |
|
||||||
err = m.WriteH26x(testTime.Add(d-1*time.Second), d, [][]byte{ |
|
||||||
{1}, // non-IDR
|
|
||||||
}) |
|
||||||
require.NoError(t, err) |
|
||||||
|
|
||||||
d = 4500 * time.Millisecond |
|
||||||
err = m.WriteAudio(testTime.Add(d-1*time.Second), d, []byte{ |
|
||||||
0x01, 0x02, 0x03, 0x04, |
|
||||||
}) |
|
||||||
require.NoError(t, err) |
|
||||||
|
|
||||||
// access unit with IDR
|
|
||||||
d = 6 * time.Second |
|
||||||
err = m.WriteH26x(testTime.Add(d-1*time.Second), d, [][]byte{ |
|
||||||
{5}, // IDR
|
|
||||||
}) |
|
||||||
require.NoError(t, err) |
|
||||||
|
|
||||||
// access unit with IDR
|
|
||||||
d = 7 * time.Second |
|
||||||
err = m.WriteH26x(testTime.Add(d-1*time.Second), d, [][]byte{ |
|
||||||
{5}, // IDR
|
|
||||||
}) |
|
||||||
require.NoError(t, err) |
|
||||||
|
|
||||||
byts, err := io.ReadAll(m.File("index.m3u8", "", "", "").Body) |
|
||||||
require.NoError(t, err) |
|
||||||
|
|
||||||
switch ca { |
|
||||||
case "mpegts": |
|
||||||
require.Equal(t, "#EXTM3U\n"+ |
|
||||||
"#EXT-X-VERSION:3\n"+ |
|
||||||
"#EXT-X-INDEPENDENT-SEGMENTS\n"+ |
|
||||||
"\n"+ |
|
||||||
"#EXT-X-STREAM-INF:BANDWIDTH=200000,CODECS=\"avc1.42c028,mp4a.40.2\"\n"+ |
|
||||||
"stream.m3u8\n", string(byts)) |
|
||||||
|
|
||||||
case "fmp4", "lowLatency": |
|
||||||
require.Equal(t, "#EXTM3U\n"+ |
|
||||||
"#EXT-X-VERSION:9\n"+ |
|
||||||
"#EXT-X-INDEPENDENT-SEGMENTS\n"+ |
|
||||||
"\n"+ |
|
||||||
"#EXT-X-STREAM-INF:BANDWIDTH=200000,CODECS=\"avc1.42c028,mp4a.40.2\"\n"+ |
|
||||||
"stream.m3u8\n", string(byts)) |
|
||||||
} |
|
||||||
|
|
||||||
byts, err = io.ReadAll(m.File("stream.m3u8", "", "", "").Body) |
|
||||||
require.NoError(t, err) |
|
||||||
|
|
||||||
switch ca { |
|
||||||
case "mpegts": |
|
||||||
re := regexp.MustCompile(`^#EXTM3U\n` + |
|
||||||
`#EXT-X-VERSION:3\n` + |
|
||||||
`#EXT-X-ALLOW-CACHE:NO\n` + |
|
||||||
`#EXT-X-TARGETDURATION:4\n` + |
|
||||||
`#EXT-X-MEDIA-SEQUENCE:0\n` + |
|
||||||
`#EXT-X-PROGRAM-DATE-TIME:(.*?)\n` + |
|
||||||
`#EXTINF:4,\n` + |
|
||||||
`(seg0\.ts)\n` + |
|
||||||
`#EXT-X-PROGRAM-DATE-TIME:(.*?)\n` + |
|
||||||
`#EXTINF:1,\n` + |
|
||||||
`(seg1\.ts)\n$`) |
|
||||||
ma := re.FindStringSubmatch(string(byts)) |
|
||||||
require.NotEqual(t, 0, len(ma)) |
|
||||||
|
|
||||||
seg := m.File(ma[2], "", "", "") |
|
||||||
require.Equal(t, http.StatusOK, seg.Status) |
|
||||||
_, err := io.ReadAll(seg.Body) |
|
||||||
require.NoError(t, err) |
|
||||||
|
|
||||||
case "fmp4": |
|
||||||
re := regexp.MustCompile(`^#EXTM3U\n` + |
|
||||||
`#EXT-X-VERSION:9\n` + |
|
||||||
`#EXT-X-TARGETDURATION:4\n` + |
|
||||||
`#EXT-X-MEDIA-SEQUENCE:0\n` + |
|
||||||
`#EXT-X-MAP:URI="init.mp4"\n` + |
|
||||||
`#EXT-X-PROGRAM-DATE-TIME:(.*?)\n` + |
|
||||||
`#EXTINF:4.00000,\n` + |
|
||||||
`(seg0\.mp4)\n` + |
|
||||||
`#EXT-X-PROGRAM-DATE-TIME:(.*?)\n` + |
|
||||||
`#EXTINF:1.00000,\n` + |
|
||||||
`(seg1\.mp4)\n$`) |
|
||||||
ma := re.FindStringSubmatch(string(byts)) |
|
||||||
require.NotEqual(t, 0, len(ma)) |
|
||||||
|
|
||||||
init := m.File("init.mp4", "", "", "") |
|
||||||
require.Equal(t, http.StatusOK, init.Status) |
|
||||||
_, err := io.ReadAll(init.Body) |
|
||||||
require.NoError(t, err) |
|
||||||
|
|
||||||
seg := m.File(ma[2], "", "", "") |
|
||||||
require.Equal(t, http.StatusOK, seg.Status) |
|
||||||
_, err = io.ReadAll(seg.Body) |
|
||||||
require.NoError(t, err) |
|
||||||
|
|
||||||
case "lowLatency": |
|
||||||
require.Equal(t, |
|
||||||
"#EXTM3U\n"+ |
|
||||||
"#EXT-X-VERSION:9\n"+ |
|
||||||
"#EXT-X-TARGETDURATION:4\n"+ |
|
||||||
"#EXT-X-SERVER-CONTROL:CAN-BLOCK-RELOAD=YES,PART-HOLD-BACK=5.00000,CAN-SKIP-UNTIL=24\n"+ |
|
||||||
"#EXT-X-PART-INF:PART-TARGET=2\n"+ |
|
||||||
"#EXT-X-MEDIA-SEQUENCE:2\n"+ |
|
||||||
"#EXT-X-MAP:URI=\"init.mp4\"\n"+ |
|
||||||
"#EXT-X-GAP\n"+ |
|
||||||
"#EXTINF:4.00000,\n"+ |
|
||||||
"gap.mp4\n"+ |
|
||||||
"#EXT-X-GAP\n"+ |
|
||||||
"#EXTINF:4.00000,\n"+ |
|
||||||
"gap.mp4\n"+ |
|
||||||
"#EXT-X-GAP\n"+ |
|
||||||
"#EXTINF:4.00000,\n"+ |
|
||||||
"gap.mp4\n"+ |
|
||||||
"#EXT-X-GAP\n"+ |
|
||||||
"#EXTINF:4.00000,\n"+ |
|
||||||
"gap.mp4\n"+ |
|
||||||
"#EXT-X-GAP\n"+ |
|
||||||
"#EXTINF:4.00000,\n"+ |
|
||||||
"gap.mp4\n"+ |
|
||||||
"#EXT-X-PROGRAM-DATE-TIME:2010-01-01T01:01:02Z\n"+ |
|
||||||
"#EXT-X-PART:DURATION=2.00000,URI=\"part0.mp4\",INDEPENDENT=YES\n"+ |
|
||||||
"#EXT-X-PART:DURATION=2.00000,URI=\"part1.mp4\"\n"+ |
|
||||||
"#EXTINF:4.00000,\n"+ |
|
||||||
"seg7.mp4\n"+ |
|
||||||
"#EXT-X-PROGRAM-DATE-TIME:2010-01-01T01:01:06Z\n"+ |
|
||||||
"#EXT-X-PART:DURATION=1.00000,URI=\"part3.mp4\",INDEPENDENT=YES\n"+ |
|
||||||
"#EXTINF:1.00000,\n"+ |
|
||||||
"seg8.mp4\n"+ |
|
||||||
"#EXT-X-PRELOAD-HINT:TYPE=PART,URI=\"part4.mp4\"\n", string(byts)) |
|
||||||
|
|
||||||
part := m.File("part3.mp4", "", "", "") |
|
||||||
require.Equal(t, http.StatusOK, part.Status) |
|
||||||
_, err = io.ReadAll(part.Body) |
|
||||||
require.NoError(t, err) |
|
||||||
|
|
||||||
recv := make(chan struct{}) |
|
||||||
|
|
||||||
go func() { |
|
||||||
part = m.File("part4.mp4", "", "", "") |
|
||||||
_, err := io.ReadAll(part.Body) |
|
||||||
require.NoError(t, err) |
|
||||||
close(recv) |
|
||||||
}() |
|
||||||
|
|
||||||
d = 9 * time.Second |
|
||||||
err = m.WriteH26x(testTime.Add(d-1*time.Second), d, [][]byte{ |
|
||||||
{1}, // non-IDR
|
|
||||||
}) |
|
||||||
require.NoError(t, err) |
|
||||||
|
|
||||||
<-recv |
|
||||||
} |
|
||||||
}) |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
func TestMuxerVideoOnly(t *testing.T) { |
|
||||||
videoTrack := &format.H264{ |
|
||||||
PayloadTyp: 96, |
|
||||||
SPS: testSPS, |
|
||||||
PPS: []byte{0x08}, |
|
||||||
PacketizationMode: 1, |
|
||||||
} |
|
||||||
|
|
||||||
for _, ca := range []string{ |
|
||||||
"mpegts", |
|
||||||
"fmp4", |
|
||||||
} { |
|
||||||
t.Run(ca, func(t *testing.T) { |
|
||||||
var v MuxerVariant |
|
||||||
if ca == "mpegts" { |
|
||||||
v = MuxerVariantMPEGTS |
|
||||||
} else { |
|
||||||
v = MuxerVariantFMP4 |
|
||||||
} |
|
||||||
|
|
||||||
m, err := NewMuxer(v, 3, 1*time.Second, 0, 50*1024*1024, videoTrack, nil) |
|
||||||
require.NoError(t, err) |
|
||||||
defer m.Close() |
|
||||||
|
|
||||||
// access unit with IDR
|
|
||||||
d := 2 * time.Second |
|
||||||
err = m.WriteH26x(testTime.Add(d-2*time.Second), d, [][]byte{ |
|
||||||
testSPS, // SPS
|
|
||||||
{8}, // PPS
|
|
||||||
{5}, // IDR
|
|
||||||
}) |
|
||||||
require.NoError(t, err) |
|
||||||
|
|
||||||
// access unit with IDR
|
|
||||||
d = 6 * time.Second |
|
||||||
err = m.WriteH26x(testTime.Add(d-2*time.Second), d, [][]byte{ |
|
||||||
{5}, // IDR
|
|
||||||
}) |
|
||||||
require.NoError(t, err) |
|
||||||
|
|
||||||
// access unit with IDR
|
|
||||||
d = 7 * time.Second |
|
||||||
err = m.WriteH26x(testTime.Add(d-2*time.Second), d, [][]byte{ |
|
||||||
{5}, // IDR
|
|
||||||
}) |
|
||||||
require.NoError(t, err) |
|
||||||
|
|
||||||
byts, err := io.ReadAll(m.File("index.m3u8", "", "", "").Body) |
|
||||||
require.NoError(t, err) |
|
||||||
|
|
||||||
if ca == "mpegts" { |
|
||||||
require.Equal(t, "#EXTM3U\n"+ |
|
||||||
"#EXT-X-VERSION:3\n"+ |
|
||||||
"#EXT-X-INDEPENDENT-SEGMENTS\n"+ |
|
||||||
"\n"+ |
|
||||||
"#EXT-X-STREAM-INF:BANDWIDTH=200000,CODECS=\"avc1.42c028\"\n"+ |
|
||||||
"stream.m3u8\n", string(byts)) |
|
||||||
} else { |
|
||||||
require.Equal(t, "#EXTM3U\n"+ |
|
||||||
"#EXT-X-VERSION:9\n"+ |
|
||||||
"#EXT-X-INDEPENDENT-SEGMENTS\n"+ |
|
||||||
"\n"+ |
|
||||||
"#EXT-X-STREAM-INF:BANDWIDTH=200000,CODECS=\"avc1.42c028\"\n"+ |
|
||||||
"stream.m3u8\n", string(byts)) |
|
||||||
} |
|
||||||
|
|
||||||
byts, err = io.ReadAll(m.File("stream.m3u8", "", "", "").Body) |
|
||||||
require.NoError(t, err) |
|
||||||
|
|
||||||
var ma []string |
|
||||||
if ca == "mpegts" { |
|
||||||
re := regexp.MustCompile(`^#EXTM3U\n` + |
|
||||||
`#EXT-X-VERSION:3\n` + |
|
||||||
`#EXT-X-ALLOW-CACHE:NO\n` + |
|
||||||
`#EXT-X-TARGETDURATION:4\n` + |
|
||||||
`#EXT-X-MEDIA-SEQUENCE:0\n` + |
|
||||||
`#EXT-X-PROGRAM-DATE-TIME:(.*?)\n` + |
|
||||||
`#EXTINF:4,\n` + |
|
||||||
`(seg0\.ts)\n` + |
|
||||||
`#EXT-X-PROGRAM-DATE-TIME:(.*?)\n` + |
|
||||||
`#EXTINF:1,\n` + |
|
||||||
`(seg1\.ts)\n$`) |
|
||||||
ma = re.FindStringSubmatch(string(byts)) |
|
||||||
} else { |
|
||||||
re := regexp.MustCompile(`^#EXTM3U\n` + |
|
||||||
`#EXT-X-VERSION:9\n` + |
|
||||||
`#EXT-X-TARGETDURATION:4\n` + |
|
||||||
`#EXT-X-MEDIA-SEQUENCE:0\n` + |
|
||||||
`#EXT-X-MAP:URI="init.mp4"\n` + |
|
||||||
`#EXT-X-PROGRAM-DATE-TIME:(.*?)\n` + |
|
||||||
`#EXTINF:4.00000,\n` + |
|
||||||
`(seg0\.mp4)\n` + |
|
||||||
`#EXT-X-PROGRAM-DATE-TIME:(.*?)\n` + |
|
||||||
`#EXTINF:1.00000,\n` + |
|
||||||
`(seg1\.mp4)\n$`) |
|
||||||
ma = re.FindStringSubmatch(string(byts)) |
|
||||||
} |
|
||||||
require.NotEqual(t, 0, len(ma)) |
|
||||||
|
|
||||||
if ca == "mpegts" { |
|
||||||
_, err := io.ReadAll(m.File(ma[2], "", "", "").Body) |
|
||||||
require.NoError(t, err) |
|
||||||
} else { |
|
||||||
_, err := io.ReadAll(m.File("init.mp4", "", "", "").Body) |
|
||||||
require.NoError(t, err) |
|
||||||
|
|
||||||
_, err = io.ReadAll(m.File(ma[2], "", "", "").Body) |
|
||||||
require.NoError(t, err) |
|
||||||
} |
|
||||||
}) |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
func TestMuxerAudioOnly(t *testing.T) { |
|
||||||
audioTrack := &format.MPEG4Audio{ |
|
||||||
PayloadTyp: 97, |
|
||||||
Config: &mpeg4audio.Config{ |
|
||||||
Type: 2, |
|
||||||
SampleRate: 44100, |
|
||||||
ChannelCount: 2, |
|
||||||
}, |
|
||||||
SizeLength: 13, |
|
||||||
IndexLength: 3, |
|
||||||
IndexDeltaLength: 3, |
|
||||||
} |
|
||||||
|
|
||||||
for _, ca := range []string{ |
|
||||||
"mpegts", |
|
||||||
"fmp4", |
|
||||||
} { |
|
||||||
t.Run(ca, func(t *testing.T) { |
|
||||||
var v MuxerVariant |
|
||||||
if ca == "mpegts" { |
|
||||||
v = MuxerVariantMPEGTS |
|
||||||
} else { |
|
||||||
v = MuxerVariantFMP4 |
|
||||||
} |
|
||||||
|
|
||||||
m, err := NewMuxer(v, 3, 1*time.Second, 0, 50*1024*1024, nil, audioTrack) |
|
||||||
require.NoError(t, err) |
|
||||||
defer m.Close() |
|
||||||
|
|
||||||
for i := 0; i < 100; i++ { |
|
||||||
d := 1 * time.Second |
|
||||||
err = m.WriteAudio(testTime.Add(d-1*time.Second), d, []byte{ |
|
||||||
0x01, 0x02, 0x03, 0x04, |
|
||||||
}) |
|
||||||
require.NoError(t, err) |
|
||||||
} |
|
||||||
|
|
||||||
d := 2 * time.Second |
|
||||||
err = m.WriteAudio(testTime.Add(d-1*time.Second), d, []byte{ |
|
||||||
0x01, 0x02, 0x03, 0x04, |
|
||||||
}) |
|
||||||
require.NoError(t, err) |
|
||||||
|
|
||||||
d = 3 * time.Second |
|
||||||
err = m.WriteAudio(testTime.Add(d-1*time.Second), d, []byte{ |
|
||||||
0x01, 0x02, 0x03, 0x04, |
|
||||||
}) |
|
||||||
require.NoError(t, err) |
|
||||||
|
|
||||||
byts, err := io.ReadAll(m.File("index.m3u8", "", "", "").Body) |
|
||||||
require.NoError(t, err) |
|
||||||
|
|
||||||
if ca == "mpegts" { |
|
||||||
require.Equal(t, "#EXTM3U\n"+ |
|
||||||
"#EXT-X-VERSION:3\n"+ |
|
||||||
"#EXT-X-INDEPENDENT-SEGMENTS\n"+ |
|
||||||
"\n"+ |
|
||||||
"#EXT-X-STREAM-INF:BANDWIDTH=200000,CODECS=\"mp4a.40.2\"\n"+ |
|
||||||
"stream.m3u8\n", string(byts)) |
|
||||||
} else { |
|
||||||
require.Equal(t, "#EXTM3U\n"+ |
|
||||||
"#EXT-X-VERSION:9\n"+ |
|
||||||
"#EXT-X-INDEPENDENT-SEGMENTS\n"+ |
|
||||||
"\n"+ |
|
||||||
"#EXT-X-STREAM-INF:BANDWIDTH=200000,CODECS=\"mp4a.40.2\"\n"+ |
|
||||||
"stream.m3u8\n", string(byts)) |
|
||||||
} |
|
||||||
|
|
||||||
byts, err = io.ReadAll(m.File("stream.m3u8", "", "", "").Body) |
|
||||||
require.NoError(t, err) |
|
||||||
|
|
||||||
var ma []string |
|
||||||
if ca == "mpegts" { |
|
||||||
re := regexp.MustCompile(`^#EXTM3U\n` + |
|
||||||
`#EXT-X-VERSION:3\n` + |
|
||||||
`#EXT-X-ALLOW-CACHE:NO\n` + |
|
||||||
`#EXT-X-TARGETDURATION:1\n` + |
|
||||||
`#EXT-X-MEDIA-SEQUENCE:0\n` + |
|
||||||
`#EXT-X-PROGRAM-DATE-TIME:(.*?)\n` + |
|
||||||
`#EXTINF:1,\n` + |
|
||||||
`(seg0\.ts)\n$`) |
|
||||||
ma = re.FindStringSubmatch(string(byts)) |
|
||||||
} else { |
|
||||||
re := regexp.MustCompile(`^#EXTM3U\n` + |
|
||||||
`#EXT-X-VERSION:9\n` + |
|
||||||
`#EXT-X-TARGETDURATION:2\n` + |
|
||||||
`#EXT-X-MEDIA-SEQUENCE:0\n` + |
|
||||||
`#EXT-X-MAP:URI="init.mp4"\n` + |
|
||||||
`#EXT-X-PROGRAM-DATE-TIME:(.*?)\n` + |
|
||||||
`#EXTINF:2.32200,\n` + |
|
||||||
`(seg0\.mp4)\n` + |
|
||||||
`#EXT-X-PROGRAM-DATE-TIME:(.*?)\n` + |
|
||||||
`#EXTINF:0.02322,\n` + |
|
||||||
`(seg1\.mp4)\n$`) |
|
||||||
ma = re.FindStringSubmatch(string(byts)) |
|
||||||
} |
|
||||||
require.NotEqual(t, 0, len(ma)) |
|
||||||
|
|
||||||
if ca == "mpegts" { |
|
||||||
_, err := io.ReadAll(m.File(ma[2], "", "", "").Body) |
|
||||||
require.NoError(t, err) |
|
||||||
} else { |
|
||||||
_, err := io.ReadAll(m.File("init.mp4", "", "", "").Body) |
|
||||||
require.NoError(t, err) |
|
||||||
|
|
||||||
_, err = io.ReadAll(m.File(ma[2], "", "", "").Body) |
|
||||||
require.NoError(t, err) |
|
||||||
} |
|
||||||
}) |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
func TestMuxerCloseBeforeFirstSegmentReader(t *testing.T) { |
|
||||||
videoTrack := &format.H264{ |
|
||||||
PayloadTyp: 96, |
|
||||||
SPS: testSPS, |
|
||||||
PPS: []byte{0x08}, |
|
||||||
PacketizationMode: 1, |
|
||||||
} |
|
||||||
|
|
||||||
m, err := NewMuxer(MuxerVariantMPEGTS, 3, 1*time.Second, 0, 50*1024*1024, videoTrack, nil) |
|
||||||
require.NoError(t, err) |
|
||||||
|
|
||||||
// access unit with IDR
|
|
||||||
err = m.WriteH26x(testTime, 2*time.Second, [][]byte{ |
|
||||||
testSPS, // SPS
|
|
||||||
{8}, // PPS
|
|
||||||
{5}, // IDR
|
|
||||||
}) |
|
||||||
require.NoError(t, err) |
|
||||||
|
|
||||||
m.Close() |
|
||||||
|
|
||||||
b := m.File("stream.m3u8", "", "", "").Body |
|
||||||
require.Equal(t, nil, b) |
|
||||||
} |
|
||||||
|
|
||||||
func TestMuxerMaxSegmentSize(t *testing.T) { |
|
||||||
videoTrack := &format.H264{ |
|
||||||
PayloadTyp: 96, |
|
||||||
SPS: testSPS, |
|
||||||
PPS: []byte{0x08}, |
|
||||||
PacketizationMode: 1, |
|
||||||
} |
|
||||||
|
|
||||||
m, err := NewMuxer(MuxerVariantMPEGTS, 3, 1*time.Second, 0, 0, videoTrack, nil) |
|
||||||
require.NoError(t, err) |
|
||||||
defer m.Close() |
|
||||||
|
|
||||||
err = m.WriteH26x(testTime, 2*time.Second, [][]byte{ |
|
||||||
testSPS, |
|
||||||
{5}, // IDR
|
|
||||||
}) |
|
||||||
require.EqualError(t, err, "reached maximum segment size") |
|
||||||
} |
|
||||||
|
|
||||||
func TestMuxerDoubleRead(t *testing.T) { |
|
||||||
videoTrack := &format.H264{ |
|
||||||
PayloadTyp: 96, |
|
||||||
SPS: testSPS, |
|
||||||
PPS: []byte{0x08}, |
|
||||||
PacketizationMode: 1, |
|
||||||
} |
|
||||||
|
|
||||||
m, err := NewMuxer(MuxerVariantMPEGTS, 3, 1*time.Second, 0, 50*1024*1024, videoTrack, nil) |
|
||||||
require.NoError(t, err) |
|
||||||
defer m.Close() |
|
||||||
|
|
||||||
err = m.WriteH26x(testTime, 0, [][]byte{ |
|
||||||
testSPS, |
|
||||||
{5}, // IDR
|
|
||||||
{1}, |
|
||||||
}) |
|
||||||
require.NoError(t, err) |
|
||||||
|
|
||||||
err = m.WriteH26x(testTime, 2*time.Second, [][]byte{ |
|
||||||
{5}, // IDR
|
|
||||||
{2}, |
|
||||||
}) |
|
||||||
require.NoError(t, err) |
|
||||||
|
|
||||||
byts, err := io.ReadAll(m.File("stream.m3u8", "", "", "").Body) |
|
||||||
require.NoError(t, err) |
|
||||||
|
|
||||||
re := regexp.MustCompile(`^#EXTM3U\n` + |
|
||||||
`#EXT-X-VERSION:3\n` + |
|
||||||
`#EXT-X-ALLOW-CACHE:NO\n` + |
|
||||||
`#EXT-X-TARGETDURATION:2\n` + |
|
||||||
`#EXT-X-MEDIA-SEQUENCE:0\n` + |
|
||||||
`#EXT-X-PROGRAM-DATE-TIME:(.*?)\n` + |
|
||||||
`#EXTINF:2,\n` + |
|
||||||
`(seg0\.ts)\n$`) |
|
||||||
ma := re.FindStringSubmatch(string(byts)) |
|
||||||
require.NotEqual(t, 0, len(ma)) |
|
||||||
|
|
||||||
byts1, err := io.ReadAll(m.File(ma[2], "", "", "").Body) |
|
||||||
require.NoError(t, err) |
|
||||||
|
|
||||||
byts2, err := io.ReadAll(m.File(ma[2], "", "", "").Body) |
|
||||||
require.NoError(t, err) |
|
||||||
require.Equal(t, byts1, byts2) |
|
||||||
} |
|
||||||
|
|
||||||
func TestMuxerFMP4ZeroDuration(t *testing.T) { |
|
||||||
videoTrack := &format.H264{ |
|
||||||
PayloadTyp: 96, |
|
||||||
SPS: testSPS, |
|
||||||
PPS: []byte{0x08}, |
|
||||||
PacketizationMode: 1, |
|
||||||
} |
|
||||||
|
|
||||||
m, err := NewMuxer(MuxerVariantLowLatency, 3, 1*time.Second, 0, 50*1024*1024, videoTrack, nil) |
|
||||||
require.NoError(t, err) |
|
||||||
defer m.Close() |
|
||||||
|
|
||||||
err = m.WriteH26x(time.Now(), 0, [][]byte{ |
|
||||||
testSPS, // SPS
|
|
||||||
{8}, // PPS
|
|
||||||
{5}, // IDR
|
|
||||||
}) |
|
||||||
require.NoError(t, err) |
|
||||||
|
|
||||||
err = m.WriteH26x(time.Now(), 1*time.Nanosecond, [][]byte{ |
|
||||||
testSPS, // SPS
|
|
||||||
{8}, // PPS
|
|
||||||
{5}, // IDR
|
|
||||||
}) |
|
||||||
require.NoError(t, err) |
|
||||||
} |
|
||||||
@ -1,22 +0,0 @@ |
|||||||
package hls |
|
||||||
|
|
||||||
import ( |
|
||||||
"time" |
|
||||||
) |
|
||||||
|
|
||||||
// MuxerVariant is a muxer variant.
|
|
||||||
type MuxerVariant int |
|
||||||
|
|
||||||
// supported variants.
|
|
||||||
const ( |
|
||||||
MuxerVariantMPEGTS MuxerVariant = iota |
|
||||||
MuxerVariantFMP4 |
|
||||||
MuxerVariantLowLatency |
|
||||||
) |
|
||||||
|
|
||||||
type muxerVariant interface { |
|
||||||
close() |
|
||||||
writeH26x(time.Time, time.Duration, [][]byte) error |
|
||||||
writeAudio(time.Time, time.Duration, []byte) error |
|
||||||
file(name string, msn string, part string, skip string) *MuxerFileResponse |
|
||||||
} |
|
||||||
@ -1,163 +0,0 @@ |
|||||||
package hls |
|
||||||
|
|
||||||
import ( |
|
||||||
"bytes" |
|
||||||
"net/http" |
|
||||||
"sync" |
|
||||||
"time" |
|
||||||
|
|
||||||
"github.com/aler9/gortsplib/v2/pkg/format" |
|
||||||
|
|
||||||
"github.com/aler9/rtsp-simple-server/internal/hls/fmp4" |
|
||||||
) |
|
||||||
|
|
||||||
func extractVideoParams(track format.Format) [][]byte { |
|
||||||
switch ttrack := track.(type) { |
|
||||||
case *format.H264: |
|
||||||
params := make([][]byte, 2) |
|
||||||
params[0] = ttrack.SafeSPS() |
|
||||||
params[1] = ttrack.SafePPS() |
|
||||||
return params |
|
||||||
|
|
||||||
case *format.H265: |
|
||||||
params := make([][]byte, 3) |
|
||||||
params[0] = ttrack.SafeVPS() |
|
||||||
params[1] = ttrack.SafeSPS() |
|
||||||
params[2] = ttrack.SafePPS() |
|
||||||
return params |
|
||||||
|
|
||||||
default: |
|
||||||
return nil |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
func videoParamsEqual(p1 [][]byte, p2 [][]byte) bool { |
|
||||||
if len(p1) != len(p2) { |
|
||||||
return true |
|
||||||
} |
|
||||||
|
|
||||||
for i, p := range p1 { |
|
||||||
if !bytes.Equal(p2[i], p) { |
|
||||||
return false |
|
||||||
} |
|
||||||
} |
|
||||||
return true |
|
||||||
} |
|
||||||
|
|
||||||
type muxerVariantFMP4 struct { |
|
||||||
playlist *muxerVariantFMP4Playlist |
|
||||||
segmenter *muxerVariantFMP4Segmenter |
|
||||||
videoTrack format.Format |
|
||||||
audioTrack format.Format |
|
||||||
|
|
||||||
mutex sync.Mutex |
|
||||||
lastVideoParams [][]byte |
|
||||||
initContent []byte |
|
||||||
} |
|
||||||
|
|
||||||
func newMuxerVariantFMP4( |
|
||||||
lowLatency bool, |
|
||||||
segmentCount int, |
|
||||||
segmentDuration time.Duration, |
|
||||||
partDuration time.Duration, |
|
||||||
segmentMaxSize uint64, |
|
||||||
videoTrack format.Format, |
|
||||||
audioTrack format.Format, |
|
||||||
) *muxerVariantFMP4 { |
|
||||||
v := &muxerVariantFMP4{ |
|
||||||
videoTrack: videoTrack, |
|
||||||
audioTrack: audioTrack, |
|
||||||
} |
|
||||||
|
|
||||||
v.playlist = newMuxerVariantFMP4Playlist( |
|
||||||
lowLatency, |
|
||||||
segmentCount, |
|
||||||
videoTrack, |
|
||||||
audioTrack, |
|
||||||
) |
|
||||||
|
|
||||||
v.segmenter = newMuxerVariantFMP4Segmenter( |
|
||||||
lowLatency, |
|
||||||
segmentCount, |
|
||||||
segmentDuration, |
|
||||||
partDuration, |
|
||||||
segmentMaxSize, |
|
||||||
videoTrack, |
|
||||||
audioTrack, |
|
||||||
v.playlist.onSegmentFinalized, |
|
||||||
v.playlist.onPartFinalized, |
|
||||||
) |
|
||||||
|
|
||||||
return v |
|
||||||
} |
|
||||||
|
|
||||||
func (v *muxerVariantFMP4) close() { |
|
||||||
v.playlist.close() |
|
||||||
} |
|
||||||
|
|
||||||
func (v *muxerVariantFMP4) writeH26x(ntp time.Time, pts time.Duration, au [][]byte) error { |
|
||||||
return v.segmenter.writeH26x(ntp, pts, au) |
|
||||||
} |
|
||||||
|
|
||||||
func (v *muxerVariantFMP4) writeAudio(ntp time.Time, pts time.Duration, au []byte) error { |
|
||||||
return v.segmenter.writeAudio(ntp, pts, au) |
|
||||||
} |
|
||||||
|
|
||||||
func (v *muxerVariantFMP4) mustRegenerateInit() bool { |
|
||||||
if v.videoTrack == nil { |
|
||||||
return false |
|
||||||
} |
|
||||||
|
|
||||||
videoParams := extractVideoParams(v.videoTrack) |
|
||||||
if !videoParamsEqual(videoParams, v.lastVideoParams) { |
|
||||||
v.lastVideoParams = videoParams |
|
||||||
return true |
|
||||||
} |
|
||||||
|
|
||||||
return false |
|
||||||
} |
|
||||||
|
|
||||||
func (v *muxerVariantFMP4) file(name string, msn string, part string, skip string) *MuxerFileResponse { |
|
||||||
if name == "init.mp4" { |
|
||||||
v.mutex.Lock() |
|
||||||
defer v.mutex.Unlock() |
|
||||||
|
|
||||||
if v.initContent == nil || v.mustRegenerateInit() { |
|
||||||
init := fmp4.Init{} |
|
||||||
trackID := 1 |
|
||||||
|
|
||||||
if v.videoTrack != nil { |
|
||||||
init.Tracks = append(init.Tracks, &fmp4.InitTrack{ |
|
||||||
ID: trackID, |
|
||||||
TimeScale: 90000, |
|
||||||
Format: v.videoTrack, |
|
||||||
}) |
|
||||||
trackID++ |
|
||||||
} |
|
||||||
|
|
||||||
if v.audioTrack != nil { |
|
||||||
init.Tracks = append(init.Tracks, &fmp4.InitTrack{ |
|
||||||
ID: trackID, |
|
||||||
TimeScale: uint32(v.audioTrack.ClockRate()), |
|
||||||
Format: v.audioTrack, |
|
||||||
}) |
|
||||||
} |
|
||||||
|
|
||||||
var err error |
|
||||||
v.initContent, err = init.Marshal() |
|
||||||
if err != nil { |
|
||||||
return &MuxerFileResponse{Status: http.StatusNotFound} |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
return &MuxerFileResponse{ |
|
||||||
Status: http.StatusOK, |
|
||||||
Header: map[string]string{ |
|
||||||
"Content-Type": "video/mp4", |
|
||||||
}, |
|
||||||
Body: bytes.NewReader(v.initContent), |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
return v.playlist.file(name, msn, part, skip) |
|
||||||
} |
|
||||||
@ -1,140 +0,0 @@ |
|||||||
package hls |
|
||||||
|
|
||||||
import ( |
|
||||||
"bytes" |
|
||||||
"io" |
|
||||||
"strconv" |
|
||||||
"time" |
|
||||||
|
|
||||||
"github.com/aler9/gortsplib/v2/pkg/codecs/mpeg4audio" |
|
||||||
"github.com/aler9/gortsplib/v2/pkg/format" |
|
||||||
|
|
||||||
"github.com/aler9/rtsp-simple-server/internal/hls/fmp4" |
|
||||||
) |
|
||||||
|
|
||||||
func fmp4PartName(id uint64) string { |
|
||||||
return "part" + strconv.FormatUint(id, 10) |
|
||||||
} |
|
||||||
|
|
||||||
type muxerVariantFMP4Part struct { |
|
||||||
videoTrack format.Format |
|
||||||
audioTrack format.Format |
|
||||||
id uint64 |
|
||||||
|
|
||||||
isIndependent bool |
|
||||||
videoSamples []*fmp4.PartSample |
|
||||||
audioSamples []*fmp4.PartSample |
|
||||||
content []byte |
|
||||||
renderedDuration time.Duration |
|
||||||
videoStartDTSFilled bool |
|
||||||
videoStartDTS time.Duration |
|
||||||
audioStartDTSFilled bool |
|
||||||
audioStartDTS time.Duration |
|
||||||
} |
|
||||||
|
|
||||||
func newMuxerVariantFMP4Part( |
|
||||||
videoTrack format.Format, |
|
||||||
audioTrack format.Format, |
|
||||||
id uint64, |
|
||||||
) *muxerVariantFMP4Part { |
|
||||||
p := &muxerVariantFMP4Part{ |
|
||||||
videoTrack: videoTrack, |
|
||||||
audioTrack: audioTrack, |
|
||||||
id: id, |
|
||||||
} |
|
||||||
|
|
||||||
if videoTrack == nil { |
|
||||||
p.isIndependent = true |
|
||||||
} |
|
||||||
|
|
||||||
return p |
|
||||||
} |
|
||||||
|
|
||||||
func (p *muxerVariantFMP4Part) name() string { |
|
||||||
return fmp4PartName(p.id) |
|
||||||
} |
|
||||||
|
|
||||||
func (p *muxerVariantFMP4Part) reader() io.Reader { |
|
||||||
return bytes.NewReader(p.content) |
|
||||||
} |
|
||||||
|
|
||||||
func (p *muxerVariantFMP4Part) duration() time.Duration { |
|
||||||
if p.videoTrack != nil { |
|
||||||
ret := uint64(0) |
|
||||||
for _, e := range p.videoSamples { |
|
||||||
ret += uint64(e.Duration) |
|
||||||
} |
|
||||||
return durationMp4ToGo(ret, 90000) |
|
||||||
} |
|
||||||
|
|
||||||
// use the sum of the default duration of all samples,
|
|
||||||
// not the real duration,
|
|
||||||
// otherwise on iPhone iOS the stream freezes.
|
|
||||||
return time.Duration(len(p.audioSamples)) * time.Second * |
|
||||||
time.Duration(mpeg4audio.SamplesPerAccessUnit) / time.Duration(p.audioTrack.ClockRate()) |
|
||||||
} |
|
||||||
|
|
||||||
func (p *muxerVariantFMP4Part) finalize() error { |
|
||||||
if p.videoSamples != nil || p.audioSamples != nil { |
|
||||||
part := fmp4.Part{} |
|
||||||
|
|
||||||
if p.videoSamples != nil { |
|
||||||
part.Tracks = append(part.Tracks, &fmp4.PartTrack{ |
|
||||||
ID: 1, |
|
||||||
BaseTime: durationGoToMp4(p.videoStartDTS, 90000), |
|
||||||
Samples: p.videoSamples, |
|
||||||
IsVideo: true, |
|
||||||
}) |
|
||||||
} |
|
||||||
|
|
||||||
if p.audioSamples != nil { |
|
||||||
var id int |
|
||||||
if p.videoTrack != nil { |
|
||||||
id = 2 |
|
||||||
} else { |
|
||||||
id = 1 |
|
||||||
} |
|
||||||
|
|
||||||
part.Tracks = append(part.Tracks, &fmp4.PartTrack{ |
|
||||||
ID: id, |
|
||||||
BaseTime: durationGoToMp4(p.audioStartDTS, uint32(p.audioTrack.ClockRate())), |
|
||||||
Samples: p.audioSamples, |
|
||||||
}) |
|
||||||
} |
|
||||||
|
|
||||||
var err error |
|
||||||
p.content, err = part.Marshal() |
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
|
|
||||||
p.renderedDuration = p.duration() |
|
||||||
} |
|
||||||
|
|
||||||
p.videoSamples = nil |
|
||||||
p.audioSamples = nil |
|
||||||
|
|
||||||
return nil |
|
||||||
} |
|
||||||
|
|
||||||
func (p *muxerVariantFMP4Part) writeH264(sample *augmentedVideoSample) { |
|
||||||
if !p.videoStartDTSFilled { |
|
||||||
p.videoStartDTSFilled = true |
|
||||||
p.videoStartDTS = sample.dts |
|
||||||
} |
|
||||||
|
|
||||||
if !sample.IsNonSyncSample { |
|
||||||
p.isIndependent = true |
|
||||||
} |
|
||||||
|
|
||||||
p.videoSamples = append(p.videoSamples, &sample.PartSample) |
|
||||||
} |
|
||||||
|
|
||||||
func (p *muxerVariantFMP4Part) writeAudio(sample *augmentedAudioSample) { |
|
||||||
if !p.audioStartDTSFilled { |
|
||||||
p.audioStartDTSFilled = true |
|
||||||
p.audioStartDTS = sample.dts |
|
||||||
} |
|
||||||
|
|
||||||
p.audioSamples = append(p.audioSamples, &sample.PartSample) |
|
||||||
} |
|
||||||
@ -1,489 +0,0 @@ |
|||||||
package hls |
|
||||||
|
|
||||||
import ( |
|
||||||
"bytes" |
|
||||||
"io" |
|
||||||
"math" |
|
||||||
"net/http" |
|
||||||
"strconv" |
|
||||||
"strings" |
|
||||||
"sync" |
|
||||||
"time" |
|
||||||
|
|
||||||
"github.com/aler9/gortsplib/v2/pkg/format" |
|
||||||
) |
|
||||||
|
|
||||||
type muxerVariantFMP4SegmentOrGap interface { |
|
||||||
getRenderedDuration() time.Duration |
|
||||||
} |
|
||||||
|
|
||||||
type muxerVariantFMP4Gap struct { |
|
||||||
renderedDuration time.Duration |
|
||||||
} |
|
||||||
|
|
||||||
func (g muxerVariantFMP4Gap) getRenderedDuration() time.Duration { |
|
||||||
return g.renderedDuration |
|
||||||
} |
|
||||||
|
|
||||||
func targetDuration(segments []muxerVariantFMP4SegmentOrGap) uint { |
|
||||||
ret := uint(0) |
|
||||||
|
|
||||||
// EXTINF, when rounded to the nearest integer, must be <= EXT-X-TARGETDURATION
|
|
||||||
for _, sog := range segments { |
|
||||||
v := uint(math.Round(sog.getRenderedDuration().Seconds())) |
|
||||||
if v > ret { |
|
||||||
ret = v |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
return ret |
|
||||||
} |
|
||||||
|
|
||||||
func partTargetDuration( |
|
||||||
segments []muxerVariantFMP4SegmentOrGap, |
|
||||||
nextSegmentParts []*muxerVariantFMP4Part, |
|
||||||
) time.Duration { |
|
||||||
var ret time.Duration |
|
||||||
|
|
||||||
for _, sog := range segments { |
|
||||||
seg, ok := sog.(*muxerVariantFMP4Segment) |
|
||||||
if !ok { |
|
||||||
continue |
|
||||||
} |
|
||||||
|
|
||||||
for _, part := range seg.parts { |
|
||||||
if part.renderedDuration > ret { |
|
||||||
ret = part.renderedDuration |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
for _, part := range nextSegmentParts { |
|
||||||
if part.renderedDuration > ret { |
|
||||||
ret = part.renderedDuration |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
return ret |
|
||||||
} |
|
||||||
|
|
||||||
type muxerVariantFMP4Playlist struct { |
|
||||||
lowLatency bool |
|
||||||
segmentCount int |
|
||||||
videoTrack format.Format |
|
||||||
audioTrack format.Format |
|
||||||
|
|
||||||
mutex sync.Mutex |
|
||||||
cond *sync.Cond |
|
||||||
closed bool |
|
||||||
segments []muxerVariantFMP4SegmentOrGap |
|
||||||
segmentsByName map[string]*muxerVariantFMP4Segment |
|
||||||
segmentDeleteCount int |
|
||||||
parts []*muxerVariantFMP4Part |
|
||||||
partsByName map[string]*muxerVariantFMP4Part |
|
||||||
nextSegmentID uint64 |
|
||||||
nextSegmentParts []*muxerVariantFMP4Part |
|
||||||
nextPartID uint64 |
|
||||||
} |
|
||||||
|
|
||||||
func newMuxerVariantFMP4Playlist( |
|
||||||
lowLatency bool, |
|
||||||
segmentCount int, |
|
||||||
videoTrack format.Format, |
|
||||||
audioTrack format.Format, |
|
||||||
) *muxerVariantFMP4Playlist { |
|
||||||
p := &muxerVariantFMP4Playlist{ |
|
||||||
lowLatency: lowLatency, |
|
||||||
segmentCount: segmentCount, |
|
||||||
videoTrack: videoTrack, |
|
||||||
audioTrack: audioTrack, |
|
||||||
segmentsByName: make(map[string]*muxerVariantFMP4Segment), |
|
||||||
partsByName: make(map[string]*muxerVariantFMP4Part), |
|
||||||
} |
|
||||||
p.cond = sync.NewCond(&p.mutex) |
|
||||||
|
|
||||||
return p |
|
||||||
} |
|
||||||
|
|
||||||
func (p *muxerVariantFMP4Playlist) close() { |
|
||||||
func() { |
|
||||||
p.mutex.Lock() |
|
||||||
defer p.mutex.Unlock() |
|
||||||
p.closed = true |
|
||||||
}() |
|
||||||
|
|
||||||
p.cond.Broadcast() |
|
||||||
} |
|
||||||
|
|
||||||
func (p *muxerVariantFMP4Playlist) hasContent() bool { |
|
||||||
if p.lowLatency { |
|
||||||
return len(p.segments) >= 1 |
|
||||||
} |
|
||||||
return len(p.segments) >= 2 |
|
||||||
} |
|
||||||
|
|
||||||
func (p *muxerVariantFMP4Playlist) hasPart(segmentID uint64, partID uint64) bool { |
|
||||||
if !p.hasContent() { |
|
||||||
return false |
|
||||||
} |
|
||||||
|
|
||||||
for _, sop := range p.segments { |
|
||||||
seg, ok := sop.(*muxerVariantFMP4Segment) |
|
||||||
if !ok { |
|
||||||
continue |
|
||||||
} |
|
||||||
|
|
||||||
if segmentID != seg.id { |
|
||||||
continue |
|
||||||
} |
|
||||||
|
|
||||||
// If the Client requests a Part Index greater than that of the final
|
|
||||||
// Partial Segment of the Parent Segment, the Server MUST treat the
|
|
||||||
// request as one for Part Index 0 of the following Parent Segment.
|
|
||||||
if partID >= uint64(len(seg.parts)) { |
|
||||||
segmentID++ |
|
||||||
partID = 0 |
|
||||||
continue |
|
||||||
} |
|
||||||
|
|
||||||
return true |
|
||||||
} |
|
||||||
|
|
||||||
if segmentID != p.nextSegmentID { |
|
||||||
return false |
|
||||||
} |
|
||||||
|
|
||||||
if partID >= uint64(len(p.nextSegmentParts)) { |
|
||||||
return false |
|
||||||
} |
|
||||||
|
|
||||||
return true |
|
||||||
} |
|
||||||
|
|
||||||
func (p *muxerVariantFMP4Playlist) file(name string, msn string, part string, skip string) *MuxerFileResponse { |
|
||||||
switch { |
|
||||||
case name == "stream.m3u8": |
|
||||||
return p.playlistReader(msn, part, skip) |
|
||||||
|
|
||||||
case strings.HasSuffix(name, ".mp4"): |
|
||||||
return p.segmentReader(name) |
|
||||||
|
|
||||||
default: |
|
||||||
return &MuxerFileResponse{Status: http.StatusNotFound} |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
func (p *muxerVariantFMP4Playlist) playlistReader(msn string, part string, skip string) *MuxerFileResponse { |
|
||||||
isDeltaUpdate := false |
|
||||||
|
|
||||||
if p.lowLatency { |
|
||||||
isDeltaUpdate = skip == "YES" || skip == "v2" |
|
||||||
|
|
||||||
var msnint uint64 |
|
||||||
if msn != "" { |
|
||||||
var err error |
|
||||||
msnint, err = strconv.ParseUint(msn, 10, 64) |
|
||||||
if err != nil { |
|
||||||
return &MuxerFileResponse{Status: http.StatusBadRequest} |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
var partint uint64 |
|
||||||
if part != "" { |
|
||||||
var err error |
|
||||||
partint, err = strconv.ParseUint(part, 10, 64) |
|
||||||
if err != nil { |
|
||||||
return &MuxerFileResponse{Status: http.StatusBadRequest} |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
if msn != "" { |
|
||||||
p.mutex.Lock() |
|
||||||
defer p.mutex.Unlock() |
|
||||||
|
|
||||||
// If the _HLS_msn is greater than the Media Sequence Number of the last
|
|
||||||
// Media Segment in the current Playlist plus two, or if the _HLS_part
|
|
||||||
// exceeds the last Partial Segment in the current Playlist by the
|
|
||||||
// Advance Part Limit, then the server SHOULD immediately return Bad
|
|
||||||
// Request, such as HTTP 400.
|
|
||||||
if msnint > (p.nextSegmentID + 1) { |
|
||||||
return &MuxerFileResponse{Status: http.StatusBadRequest} |
|
||||||
} |
|
||||||
|
|
||||||
for !p.closed && !p.hasPart(msnint, partint) { |
|
||||||
p.cond.Wait() |
|
||||||
} |
|
||||||
|
|
||||||
if p.closed { |
|
||||||
return &MuxerFileResponse{Status: http.StatusNotFound} |
|
||||||
} |
|
||||||
|
|
||||||
return &MuxerFileResponse{ |
|
||||||
Status: http.StatusOK, |
|
||||||
Header: map[string]string{ |
|
||||||
"Content-Type": `application/x-mpegURL`, |
|
||||||
}, |
|
||||||
Body: p.fullPlaylist(isDeltaUpdate), |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
// part without msn is not supported.
|
|
||||||
if part != "" { |
|
||||||
return &MuxerFileResponse{Status: http.StatusBadRequest} |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
p.mutex.Lock() |
|
||||||
defer p.mutex.Unlock() |
|
||||||
|
|
||||||
for !p.closed && !p.hasContent() { |
|
||||||
p.cond.Wait() |
|
||||||
} |
|
||||||
|
|
||||||
if p.closed { |
|
||||||
return &MuxerFileResponse{Status: http.StatusNotFound} |
|
||||||
} |
|
||||||
|
|
||||||
return &MuxerFileResponse{ |
|
||||||
Status: http.StatusOK, |
|
||||||
Header: map[string]string{ |
|
||||||
"Content-Type": `application/x-mpegURL`, |
|
||||||
}, |
|
||||||
Body: p.fullPlaylist(isDeltaUpdate), |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
func (p *muxerVariantFMP4Playlist) fullPlaylist(isDeltaUpdate bool) io.Reader { |
|
||||||
cnt := "#EXTM3U\n" |
|
||||||
cnt += "#EXT-X-VERSION:9\n" |
|
||||||
|
|
||||||
targetDuration := targetDuration(p.segments) |
|
||||||
cnt += "#EXT-X-TARGETDURATION:" + strconv.FormatUint(uint64(targetDuration), 10) + "\n" |
|
||||||
|
|
||||||
skipBoundary := float64(targetDuration * 6) |
|
||||||
|
|
||||||
if p.lowLatency { |
|
||||||
partTargetDuration := partTargetDuration(p.segments, p.nextSegmentParts) |
|
||||||
|
|
||||||
// The value is an enumerated-string whose value is YES if the server
|
|
||||||
// supports Blocking Playlist Reload
|
|
||||||
cnt += "#EXT-X-SERVER-CONTROL:CAN-BLOCK-RELOAD=YES" |
|
||||||
|
|
||||||
// The value is a decimal-floating-point number of seconds that
|
|
||||||
// indicates the server-recommended minimum distance from the end of
|
|
||||||
// the Playlist at which clients should begin to play or to which
|
|
||||||
// they should seek when playing in Low-Latency Mode. Its value MUST
|
|
||||||
// be at least twice the Part Target Duration. Its value SHOULD be
|
|
||||||
// at least three times the Part Target Duration.
|
|
||||||
cnt += ",PART-HOLD-BACK=" + strconv.FormatFloat((partTargetDuration).Seconds()*2.5, 'f', 5, 64) |
|
||||||
|
|
||||||
// Indicates that the Server can produce Playlist Delta Updates in
|
|
||||||
// response to the _HLS_skip Delivery Directive. Its value is the
|
|
||||||
// Skip Boundary, a decimal-floating-point number of seconds. The
|
|
||||||
// Skip Boundary MUST be at least six times the Target Duration.
|
|
||||||
cnt += ",CAN-SKIP-UNTIL=" + strconv.FormatFloat(skipBoundary, 'f', -1, 64) |
|
||||||
|
|
||||||
cnt += "\n" |
|
||||||
|
|
||||||
cnt += "#EXT-X-PART-INF:PART-TARGET=" + strconv.FormatFloat(partTargetDuration.Seconds(), 'f', -1, 64) + "\n" |
|
||||||
} |
|
||||||
|
|
||||||
cnt += "#EXT-X-MEDIA-SEQUENCE:" + strconv.FormatInt(int64(p.segmentDeleteCount), 10) + "\n" |
|
||||||
|
|
||||||
skipped := 0 |
|
||||||
|
|
||||||
if !isDeltaUpdate { |
|
||||||
cnt += "#EXT-X-MAP:URI=\"init.mp4\"\n" |
|
||||||
} else { |
|
||||||
var curDuration time.Duration |
|
||||||
shown := 0 |
|
||||||
for _, segment := range p.segments { |
|
||||||
curDuration += segment.getRenderedDuration() |
|
||||||
if curDuration.Seconds() >= skipBoundary { |
|
||||||
break |
|
||||||
} |
|
||||||
shown++ |
|
||||||
} |
|
||||||
skipped = len(p.segments) - shown |
|
||||||
cnt += "#EXT-X-SKIP:SKIPPED-SEGMENTS=" + strconv.FormatInt(int64(skipped), 10) + "\n" |
|
||||||
} |
|
||||||
|
|
||||||
for i, sog := range p.segments { |
|
||||||
if i < skipped { |
|
||||||
continue |
|
||||||
} |
|
||||||
|
|
||||||
switch seg := sog.(type) { |
|
||||||
case *muxerVariantFMP4Segment: |
|
||||||
if (len(p.segments) - i) <= 2 { |
|
||||||
cnt += "#EXT-X-PROGRAM-DATE-TIME:" + seg.startTime.Format("2006-01-02T15:04:05.999Z07:00") + "\n" |
|
||||||
} |
|
||||||
|
|
||||||
if p.lowLatency && (len(p.segments)-i) <= 2 { |
|
||||||
for _, part := range seg.parts { |
|
||||||
cnt += "#EXT-X-PART:DURATION=" + strconv.FormatFloat(part.renderedDuration.Seconds(), 'f', 5, 64) + |
|
||||||
",URI=\"" + part.name() + ".mp4\"" |
|
||||||
if part.isIndependent { |
|
||||||
cnt += ",INDEPENDENT=YES" |
|
||||||
} |
|
||||||
cnt += "\n" |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
cnt += "#EXTINF:" + strconv.FormatFloat(seg.renderedDuration.Seconds(), 'f', 5, 64) + ",\n" + |
|
||||||
seg.name + ".mp4\n" |
|
||||||
|
|
||||||
case *muxerVariantFMP4Gap: |
|
||||||
cnt += "#EXT-X-GAP\n" + |
|
||||||
"#EXTINF:" + strconv.FormatFloat(seg.renderedDuration.Seconds(), 'f', 5, 64) + ",\n" + |
|
||||||
"gap.mp4\n" |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
if p.lowLatency { |
|
||||||
for _, part := range p.nextSegmentParts { |
|
||||||
cnt += "#EXT-X-PART:DURATION=" + strconv.FormatFloat(part.renderedDuration.Seconds(), 'f', 5, 64) + |
|
||||||
",URI=\"" + part.name() + ".mp4\"" |
|
||||||
if part.isIndependent { |
|
||||||
cnt += ",INDEPENDENT=YES" |
|
||||||
} |
|
||||||
cnt += "\n" |
|
||||||
} |
|
||||||
|
|
||||||
// preload hint must always be present
|
|
||||||
// otherwise hls.js goes into a loop
|
|
||||||
cnt += "#EXT-X-PRELOAD-HINT:TYPE=PART,URI=\"" + fmp4PartName(p.nextPartID) + ".mp4\"\n" |
|
||||||
} |
|
||||||
|
|
||||||
return bytes.NewReader([]byte(cnt)) |
|
||||||
} |
|
||||||
|
|
||||||
func (p *muxerVariantFMP4Playlist) segmentReader(fname string) *MuxerFileResponse { |
|
||||||
switch { |
|
||||||
case strings.HasPrefix(fname, "seg"): |
|
||||||
base := strings.TrimSuffix(fname, ".mp4") |
|
||||||
|
|
||||||
p.mutex.Lock() |
|
||||||
segment, ok := p.segmentsByName[base] |
|
||||||
p.mutex.Unlock() |
|
||||||
|
|
||||||
if !ok { |
|
||||||
return &MuxerFileResponse{Status: http.StatusNotFound} |
|
||||||
} |
|
||||||
|
|
||||||
return &MuxerFileResponse{ |
|
||||||
Status: http.StatusOK, |
|
||||||
Header: map[string]string{ |
|
||||||
"Content-Type": "video/mp4", |
|
||||||
}, |
|
||||||
Body: segment.reader(), |
|
||||||
} |
|
||||||
|
|
||||||
case strings.HasPrefix(fname, "part"): |
|
||||||
base := strings.TrimSuffix(fname, ".mp4") |
|
||||||
|
|
||||||
p.mutex.Lock() |
|
||||||
part, ok := p.partsByName[base] |
|
||||||
nextPartID := p.nextPartID |
|
||||||
p.mutex.Unlock() |
|
||||||
|
|
||||||
if ok { |
|
||||||
return &MuxerFileResponse{ |
|
||||||
Status: http.StatusOK, |
|
||||||
Header: map[string]string{ |
|
||||||
"Content-Type": "video/mp4", |
|
||||||
}, |
|
||||||
Body: part.reader(), |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
// EXT-X-PRELOAD-HINT support
|
|
||||||
nextPartName := fmp4PartName(p.nextPartID) |
|
||||||
if base == nextPartName { |
|
||||||
p.mutex.Lock() |
|
||||||
defer p.mutex.Unlock() |
|
||||||
|
|
||||||
for { |
|
||||||
if p.closed { |
|
||||||
break |
|
||||||
} |
|
||||||
|
|
||||||
if p.nextPartID > nextPartID { |
|
||||||
break |
|
||||||
} |
|
||||||
|
|
||||||
p.cond.Wait() |
|
||||||
} |
|
||||||
|
|
||||||
if p.closed { |
|
||||||
return &MuxerFileResponse{Status: http.StatusNotFound} |
|
||||||
} |
|
||||||
|
|
||||||
return &MuxerFileResponse{ |
|
||||||
Status: http.StatusOK, |
|
||||||
Header: map[string]string{ |
|
||||||
"Content-Type": "video/mp4", |
|
||||||
}, |
|
||||||
Body: p.partsByName[nextPartName].reader(), |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
return &MuxerFileResponse{Status: http.StatusNotFound} |
|
||||||
|
|
||||||
default: |
|
||||||
return &MuxerFileResponse{Status: http.StatusNotFound} |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
func (p *muxerVariantFMP4Playlist) onSegmentFinalized(segment *muxerVariantFMP4Segment) { |
|
||||||
func() { |
|
||||||
p.mutex.Lock() |
|
||||||
defer p.mutex.Unlock() |
|
||||||
|
|
||||||
// add initial gaps, required by iOS LL-HLS
|
|
||||||
if p.lowLatency && len(p.segments) == 0 { |
|
||||||
for i := 0; i < 7; i++ { |
|
||||||
p.segments = append(p.segments, &muxerVariantFMP4Gap{ |
|
||||||
renderedDuration: segment.renderedDuration, |
|
||||||
}) |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
p.segmentsByName[segment.name] = segment |
|
||||||
p.segments = append(p.segments, segment) |
|
||||||
p.nextSegmentID = segment.id + 1 |
|
||||||
p.nextSegmentParts = p.nextSegmentParts[:0] |
|
||||||
|
|
||||||
if len(p.segments) > p.segmentCount { |
|
||||||
toDelete := p.segments[0] |
|
||||||
|
|
||||||
if toDeleteSeg, ok := toDelete.(*muxerVariantFMP4Segment); ok { |
|
||||||
for _, part := range toDeleteSeg.parts { |
|
||||||
delete(p.partsByName, part.name()) |
|
||||||
} |
|
||||||
p.parts = p.parts[len(toDeleteSeg.parts):] |
|
||||||
|
|
||||||
delete(p.segmentsByName, toDeleteSeg.name) |
|
||||||
} |
|
||||||
|
|
||||||
p.segments = p.segments[1:] |
|
||||||
p.segmentDeleteCount++ |
|
||||||
} |
|
||||||
}() |
|
||||||
|
|
||||||
p.cond.Broadcast() |
|
||||||
} |
|
||||||
|
|
||||||
func (p *muxerVariantFMP4Playlist) onPartFinalized(part *muxerVariantFMP4Part) { |
|
||||||
func() { |
|
||||||
p.mutex.Lock() |
|
||||||
defer p.mutex.Unlock() |
|
||||||
|
|
||||||
p.partsByName[part.name()] = part |
|
||||||
p.parts = append(p.parts, part) |
|
||||||
p.nextSegmentParts = append(p.nextSegmentParts, part) |
|
||||||
p.nextPartID = part.id + 1 |
|
||||||
}() |
|
||||||
|
|
||||||
p.cond.Broadcast() |
|
||||||
} |
|
||||||
@ -1,186 +0,0 @@ |
|||||||
package hls |
|
||||||
|
|
||||||
import ( |
|
||||||
"fmt" |
|
||||||
"io" |
|
||||||
"strconv" |
|
||||||
"time" |
|
||||||
|
|
||||||
"github.com/aler9/gortsplib/v2/pkg/format" |
|
||||||
) |
|
||||||
|
|
||||||
type partsReader struct { |
|
||||||
parts []*muxerVariantFMP4Part |
|
||||||
curPart int |
|
||||||
curPos int |
|
||||||
} |
|
||||||
|
|
||||||
func (mbr *partsReader) Read(p []byte) (int, error) { |
|
||||||
n := 0 |
|
||||||
lenp := len(p) |
|
||||||
|
|
||||||
for { |
|
||||||
if mbr.curPart >= len(mbr.parts) { |
|
||||||
return n, io.EOF |
|
||||||
} |
|
||||||
|
|
||||||
copied := copy(p[n:], mbr.parts[mbr.curPart].content[mbr.curPos:]) |
|
||||||
mbr.curPos += copied |
|
||||||
n += copied |
|
||||||
|
|
||||||
if mbr.curPos == len(mbr.parts[mbr.curPart].content) { |
|
||||||
mbr.curPart++ |
|
||||||
mbr.curPos = 0 |
|
||||||
} |
|
||||||
|
|
||||||
if n == lenp { |
|
||||||
return n, nil |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
type muxerVariantFMP4Segment struct { |
|
||||||
lowLatency bool |
|
||||||
id uint64 |
|
||||||
startTime time.Time |
|
||||||
startDTS time.Duration |
|
||||||
segmentMaxSize uint64 |
|
||||||
videoTrack format.Format |
|
||||||
audioTrack format.Format |
|
||||||
genPartID func() uint64 |
|
||||||
onPartFinalized func(*muxerVariantFMP4Part) |
|
||||||
|
|
||||||
name string |
|
||||||
size uint64 |
|
||||||
parts []*muxerVariantFMP4Part |
|
||||||
currentPart *muxerVariantFMP4Part |
|
||||||
renderedDuration time.Duration |
|
||||||
} |
|
||||||
|
|
||||||
func newMuxerVariantFMP4Segment( |
|
||||||
lowLatency bool, |
|
||||||
id uint64, |
|
||||||
startTime time.Time, |
|
||||||
startDTS time.Duration, |
|
||||||
segmentMaxSize uint64, |
|
||||||
videoTrack format.Format, |
|
||||||
audioTrack format.Format, |
|
||||||
genPartID func() uint64, |
|
||||||
onPartFinalized func(*muxerVariantFMP4Part), |
|
||||||
) *muxerVariantFMP4Segment { |
|
||||||
s := &muxerVariantFMP4Segment{ |
|
||||||
lowLatency: lowLatency, |
|
||||||
id: id, |
|
||||||
startTime: startTime, |
|
||||||
startDTS: startDTS, |
|
||||||
segmentMaxSize: segmentMaxSize, |
|
||||||
videoTrack: videoTrack, |
|
||||||
audioTrack: audioTrack, |
|
||||||
genPartID: genPartID, |
|
||||||
onPartFinalized: onPartFinalized, |
|
||||||
name: "seg" + strconv.FormatUint(id, 10), |
|
||||||
} |
|
||||||
|
|
||||||
s.currentPart = newMuxerVariantFMP4Part( |
|
||||||
s.videoTrack, |
|
||||||
s.audioTrack, |
|
||||||
s.genPartID(), |
|
||||||
) |
|
||||||
|
|
||||||
return s |
|
||||||
} |
|
||||||
|
|
||||||
func (s *muxerVariantFMP4Segment) reader() io.Reader { |
|
||||||
return &partsReader{parts: s.parts} |
|
||||||
} |
|
||||||
|
|
||||||
func (s *muxerVariantFMP4Segment) getRenderedDuration() time.Duration { |
|
||||||
return s.renderedDuration |
|
||||||
} |
|
||||||
|
|
||||||
func (s *muxerVariantFMP4Segment) finalize( |
|
||||||
nextVideoSampleDTS time.Duration, |
|
||||||
) error { |
|
||||||
err := s.currentPart.finalize() |
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
|
|
||||||
if s.currentPart.content != nil { |
|
||||||
s.onPartFinalized(s.currentPart) |
|
||||||
s.parts = append(s.parts, s.currentPart) |
|
||||||
} |
|
||||||
|
|
||||||
s.currentPart = nil |
|
||||||
|
|
||||||
if s.videoTrack != nil { |
|
||||||
s.renderedDuration = nextVideoSampleDTS - s.startDTS |
|
||||||
} else { |
|
||||||
s.renderedDuration = 0 |
|
||||||
for _, pa := range s.parts { |
|
||||||
s.renderedDuration += pa.renderedDuration |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
return nil |
|
||||||
} |
|
||||||
|
|
||||||
func (s *muxerVariantFMP4Segment) writeH264(sample *augmentedVideoSample, adjustedPartDuration time.Duration) error { |
|
||||||
size := uint64(len(sample.Payload)) |
|
||||||
if (s.size + size) > s.segmentMaxSize { |
|
||||||
return fmt.Errorf("reached maximum segment size") |
|
||||||
} |
|
||||||
s.size += size |
|
||||||
|
|
||||||
s.currentPart.writeH264(sample) |
|
||||||
|
|
||||||
// switch part
|
|
||||||
if s.lowLatency && |
|
||||||
s.currentPart.duration() >= adjustedPartDuration { |
|
||||||
err := s.currentPart.finalize() |
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
|
|
||||||
s.parts = append(s.parts, s.currentPart) |
|
||||||
s.onPartFinalized(s.currentPart) |
|
||||||
|
|
||||||
s.currentPart = newMuxerVariantFMP4Part( |
|
||||||
s.videoTrack, |
|
||||||
s.audioTrack, |
|
||||||
s.genPartID(), |
|
||||||
) |
|
||||||
} |
|
||||||
|
|
||||||
return nil |
|
||||||
} |
|
||||||
|
|
||||||
func (s *muxerVariantFMP4Segment) writeAudio(sample *augmentedAudioSample, adjustedPartDuration time.Duration) error { |
|
||||||
size := uint64(len(sample.Payload)) |
|
||||||
if (s.size + size) > s.segmentMaxSize { |
|
||||||
return fmt.Errorf("reached maximum segment size") |
|
||||||
} |
|
||||||
s.size += size |
|
||||||
|
|
||||||
s.currentPart.writeAudio(sample) |
|
||||||
|
|
||||||
// switch part
|
|
||||||
if s.lowLatency && s.videoTrack == nil && |
|
||||||
s.currentPart.duration() >= adjustedPartDuration { |
|
||||||
err := s.currentPart.finalize() |
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
|
|
||||||
s.parts = append(s.parts, s.currentPart) |
|
||||||
s.onPartFinalized(s.currentPart) |
|
||||||
|
|
||||||
s.currentPart = newMuxerVariantFMP4Part( |
|
||||||
s.videoTrack, |
|
||||||
s.audioTrack, |
|
||||||
s.genPartID(), |
|
||||||
) |
|
||||||
} |
|
||||||
|
|
||||||
return nil |
|
||||||
} |
|
||||||
@ -1,406 +0,0 @@ |
|||||||
package hls |
|
||||||
|
|
||||||
import ( |
|
||||||
"fmt" |
|
||||||
"time" |
|
||||||
|
|
||||||
"github.com/aler9/gortsplib/v2/pkg/codecs/h264" |
|
||||||
"github.com/aler9/gortsplib/v2/pkg/codecs/h265" |
|
||||||
"github.com/aler9/gortsplib/v2/pkg/format" |
|
||||||
|
|
||||||
"github.com/aler9/rtsp-simple-server/internal/hls/fmp4" |
|
||||||
) |
|
||||||
|
|
||||||
func partDurationIsCompatible(partDuration time.Duration, sampleDuration time.Duration) bool { |
|
||||||
if sampleDuration > partDuration { |
|
||||||
return false |
|
||||||
} |
|
||||||
|
|
||||||
f := (partDuration / sampleDuration) |
|
||||||
if (partDuration % sampleDuration) != 0 { |
|
||||||
f++ |
|
||||||
} |
|
||||||
f *= sampleDuration |
|
||||||
|
|
||||||
return partDuration > ((f * 85) / 100) |
|
||||||
} |
|
||||||
|
|
||||||
func partDurationIsCompatibleWithAll(partDuration time.Duration, sampleDurations map[time.Duration]struct{}) bool { |
|
||||||
for sd := range sampleDurations { |
|
||||||
if !partDurationIsCompatible(partDuration, sd) { |
|
||||||
return false |
|
||||||
} |
|
||||||
} |
|
||||||
return true |
|
||||||
} |
|
||||||
|
|
||||||
func findCompatiblePartDuration( |
|
||||||
minPartDuration time.Duration, |
|
||||||
sampleDurations map[time.Duration]struct{}, |
|
||||||
) time.Duration { |
|
||||||
i := minPartDuration |
|
||||||
for ; i < 5*time.Second; i += 5 * time.Millisecond { |
|
||||||
if partDurationIsCompatibleWithAll(i, sampleDurations) { |
|
||||||
break |
|
||||||
} |
|
||||||
} |
|
||||||
return i |
|
||||||
} |
|
||||||
|
|
||||||
type dtsExtractor interface { |
|
||||||
Extract([][]byte, time.Duration) (time.Duration, error) |
|
||||||
} |
|
||||||
|
|
||||||
func allocateDTSExtractor(track format.Format) dtsExtractor { |
|
||||||
switch track.(type) { |
|
||||||
case *format.H264: |
|
||||||
return h264.NewDTSExtractor() |
|
||||||
|
|
||||||
case *format.H265: |
|
||||||
return h265.NewDTSExtractor() |
|
||||||
} |
|
||||||
return nil |
|
||||||
} |
|
||||||
|
|
||||||
type augmentedVideoSample struct { |
|
||||||
fmp4.PartSample |
|
||||||
dts time.Duration |
|
||||||
ntp time.Time |
|
||||||
} |
|
||||||
|
|
||||||
type augmentedAudioSample struct { |
|
||||||
fmp4.PartSample |
|
||||||
dts time.Duration |
|
||||||
ntp time.Time |
|
||||||
} |
|
||||||
|
|
||||||
type muxerVariantFMP4Segmenter struct { |
|
||||||
lowLatency bool |
|
||||||
segmentDuration time.Duration |
|
||||||
partDuration time.Duration |
|
||||||
segmentMaxSize uint64 |
|
||||||
videoTrack format.Format |
|
||||||
audioTrack format.Format |
|
||||||
onSegmentFinalized func(*muxerVariantFMP4Segment) |
|
||||||
onPartFinalized func(*muxerVariantFMP4Part) |
|
||||||
|
|
||||||
startDTS time.Duration |
|
||||||
videoFirstRandomAccessReceived bool |
|
||||||
videoDTSExtractor dtsExtractor |
|
||||||
lastVideoParams [][]byte |
|
||||||
currentSegment *muxerVariantFMP4Segment |
|
||||||
nextSegmentID uint64 |
|
||||||
nextPartID uint64 |
|
||||||
nextVideoSample *augmentedVideoSample |
|
||||||
nextAudioSample *augmentedAudioSample |
|
||||||
firstSegmentFinalized bool |
|
||||||
sampleDurations map[time.Duration]struct{} |
|
||||||
adjustedPartDuration time.Duration |
|
||||||
} |
|
||||||
|
|
||||||
func newMuxerVariantFMP4Segmenter( |
|
||||||
lowLatency bool, |
|
||||||
segmentCount int, |
|
||||||
segmentDuration time.Duration, |
|
||||||
partDuration time.Duration, |
|
||||||
segmentMaxSize uint64, |
|
||||||
videoTrack format.Format, |
|
||||||
audioTrack format.Format, |
|
||||||
onSegmentFinalized func(*muxerVariantFMP4Segment), |
|
||||||
onPartFinalized func(*muxerVariantFMP4Part), |
|
||||||
) *muxerVariantFMP4Segmenter { |
|
||||||
m := &muxerVariantFMP4Segmenter{ |
|
||||||
lowLatency: lowLatency, |
|
||||||
segmentDuration: segmentDuration, |
|
||||||
partDuration: partDuration, |
|
||||||
segmentMaxSize: segmentMaxSize, |
|
||||||
videoTrack: videoTrack, |
|
||||||
audioTrack: audioTrack, |
|
||||||
onSegmentFinalized: onSegmentFinalized, |
|
||||||
onPartFinalized: onPartFinalized, |
|
||||||
sampleDurations: make(map[time.Duration]struct{}), |
|
||||||
} |
|
||||||
|
|
||||||
// add initial gaps, required by iOS LL-HLS
|
|
||||||
if m.lowLatency { |
|
||||||
m.nextSegmentID = 7 |
|
||||||
} |
|
||||||
|
|
||||||
return m |
|
||||||
} |
|
||||||
|
|
||||||
func (m *muxerVariantFMP4Segmenter) genSegmentID() uint64 { |
|
||||||
id := m.nextSegmentID |
|
||||||
m.nextSegmentID++ |
|
||||||
return id |
|
||||||
} |
|
||||||
|
|
||||||
func (m *muxerVariantFMP4Segmenter) genPartID() uint64 { |
|
||||||
id := m.nextPartID |
|
||||||
m.nextPartID++ |
|
||||||
return id |
|
||||||
} |
|
||||||
|
|
||||||
// iPhone iOS fails if part durations are less than 85% of maximum part duration.
|
|
||||||
// find a part duration that is compatible with all received sample durations
|
|
||||||
func (m *muxerVariantFMP4Segmenter) adjustPartDuration(du time.Duration) { |
|
||||||
if !m.lowLatency || m.firstSegmentFinalized { |
|
||||||
return |
|
||||||
} |
|
||||||
|
|
||||||
// avoid a crash by skipping invalid durations
|
|
||||||
if du == 0 { |
|
||||||
return |
|
||||||
} |
|
||||||
|
|
||||||
if _, ok := m.sampleDurations[du]; !ok { |
|
||||||
m.sampleDurations[du] = struct{}{} |
|
||||||
m.adjustedPartDuration = findCompatiblePartDuration( |
|
||||||
m.partDuration, |
|
||||||
m.sampleDurations, |
|
||||||
) |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
func (m *muxerVariantFMP4Segmenter) writeH26x(ntp time.Time, pts time.Duration, au [][]byte) error { |
|
||||||
randomAccessPresent := false |
|
||||||
|
|
||||||
switch m.videoTrack.(type) { |
|
||||||
case *format.H264: |
|
||||||
nonIDRPresent := false |
|
||||||
|
|
||||||
for _, nalu := range au { |
|
||||||
typ := h264.NALUType(nalu[0] & 0x1F) |
|
||||||
|
|
||||||
switch typ { |
|
||||||
case h264.NALUTypeIDR: |
|
||||||
randomAccessPresent = true |
|
||||||
|
|
||||||
case h264.NALUTypeNonIDR: |
|
||||||
nonIDRPresent = true |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
if !randomAccessPresent && !nonIDRPresent { |
|
||||||
return nil |
|
||||||
} |
|
||||||
|
|
||||||
case *format.H265: |
|
||||||
for _, nalu := range au { |
|
||||||
typ := h265.NALUType((nalu[0] >> 1) & 0b111111) |
|
||||||
|
|
||||||
switch typ { |
|
||||||
case h265.NALUType_IDR_W_RADL, h265.NALUType_IDR_N_LP, h265.NALUType_CRA_NUT: |
|
||||||
randomAccessPresent = true |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
return m.writeH26xEntry(ntp, pts, au, randomAccessPresent) |
|
||||||
} |
|
||||||
|
|
||||||
func (m *muxerVariantFMP4Segmenter) writeH26xEntry( |
|
||||||
ntp time.Time, |
|
||||||
pts time.Duration, |
|
||||||
au [][]byte, |
|
||||||
randomAccessPresent bool, |
|
||||||
) error { |
|
||||||
var dts time.Duration |
|
||||||
|
|
||||||
if !m.videoFirstRandomAccessReceived { |
|
||||||
// skip sample silently until we find one with an IDR
|
|
||||||
if !randomAccessPresent { |
|
||||||
return nil |
|
||||||
} |
|
||||||
|
|
||||||
m.videoFirstRandomAccessReceived = true |
|
||||||
m.videoDTSExtractor = allocateDTSExtractor(m.videoTrack) |
|
||||||
m.lastVideoParams = extractVideoParams(m.videoTrack) |
|
||||||
|
|
||||||
var err error |
|
||||||
dts, err = m.videoDTSExtractor.Extract(au, pts) |
|
||||||
if err != nil { |
|
||||||
return fmt.Errorf("unable to extract DTS: %v", err) |
|
||||||
} |
|
||||||
|
|
||||||
m.startDTS = dts |
|
||||||
dts = 0 |
|
||||||
pts -= m.startDTS |
|
||||||
} else { |
|
||||||
var err error |
|
||||||
dts, err = m.videoDTSExtractor.Extract(au, pts) |
|
||||||
if err != nil { |
|
||||||
return fmt.Errorf("unable to extract DTS: %v", err) |
|
||||||
} |
|
||||||
|
|
||||||
dts -= m.startDTS |
|
||||||
pts -= m.startDTS |
|
||||||
} |
|
||||||
|
|
||||||
avcc, err := h264.AVCCMarshal(au) |
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
|
|
||||||
sample := &augmentedVideoSample{ |
|
||||||
PartSample: fmp4.PartSample{ |
|
||||||
PTSOffset: int32(durationGoToMp4(pts-dts, 90000)), |
|
||||||
IsNonSyncSample: !randomAccessPresent, |
|
||||||
Payload: avcc, |
|
||||||
}, |
|
||||||
dts: dts, |
|
||||||
ntp: ntp, |
|
||||||
} |
|
||||||
|
|
||||||
// put samples into a queue in order to
|
|
||||||
// - compute sample duration
|
|
||||||
// - check if next sample is IDR
|
|
||||||
sample, m.nextVideoSample = m.nextVideoSample, sample |
|
||||||
if sample == nil { |
|
||||||
return nil |
|
||||||
} |
|
||||||
sample.Duration = uint32(durationGoToMp4(m.nextVideoSample.dts-sample.dts, 90000)) |
|
||||||
|
|
||||||
if m.currentSegment == nil { |
|
||||||
// create first segment
|
|
||||||
m.currentSegment = newMuxerVariantFMP4Segment( |
|
||||||
m.lowLatency, |
|
||||||
m.genSegmentID(), |
|
||||||
sample.ntp, |
|
||||||
sample.dts, |
|
||||||
m.segmentMaxSize, |
|
||||||
m.videoTrack, |
|
||||||
m.audioTrack, |
|
||||||
m.genPartID, |
|
||||||
m.onPartFinalized, |
|
||||||
) |
|
||||||
} |
|
||||||
|
|
||||||
m.adjustPartDuration(durationMp4ToGo(uint64(sample.Duration), 90000)) |
|
||||||
|
|
||||||
err = m.currentSegment.writeH264(sample, m.adjustedPartDuration) |
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
|
|
||||||
// switch segment
|
|
||||||
if randomAccessPresent { |
|
||||||
videoParams := extractVideoParams(m.videoTrack) |
|
||||||
paramsChanged := !videoParamsEqual(m.lastVideoParams, videoParams) |
|
||||||
|
|
||||||
if (m.nextVideoSample.dts-m.currentSegment.startDTS) >= m.segmentDuration || |
|
||||||
paramsChanged { |
|
||||||
err := m.currentSegment.finalize(m.nextVideoSample.dts) |
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
m.onSegmentFinalized(m.currentSegment) |
|
||||||
|
|
||||||
m.firstSegmentFinalized = true |
|
||||||
|
|
||||||
m.currentSegment = newMuxerVariantFMP4Segment( |
|
||||||
m.lowLatency, |
|
||||||
m.genSegmentID(), |
|
||||||
m.nextVideoSample.ntp, |
|
||||||
m.nextVideoSample.dts, |
|
||||||
m.segmentMaxSize, |
|
||||||
m.videoTrack, |
|
||||||
m.audioTrack, |
|
||||||
m.genPartID, |
|
||||||
m.onPartFinalized, |
|
||||||
) |
|
||||||
|
|
||||||
if paramsChanged { |
|
||||||
m.lastVideoParams = videoParams |
|
||||||
m.firstSegmentFinalized = false |
|
||||||
|
|
||||||
// reset adjusted part duration
|
|
||||||
m.sampleDurations = make(map[time.Duration]struct{}) |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
return nil |
|
||||||
} |
|
||||||
|
|
||||||
func (m *muxerVariantFMP4Segmenter) writeAudio(ntp time.Time, dts time.Duration, au []byte) error { |
|
||||||
if m.videoTrack != nil { |
|
||||||
// wait for the video track
|
|
||||||
if !m.videoFirstRandomAccessReceived { |
|
||||||
return nil |
|
||||||
} |
|
||||||
|
|
||||||
dts -= m.startDTS |
|
||||||
if dts < 0 { |
|
||||||
return nil |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
sample := &augmentedAudioSample{ |
|
||||||
PartSample: fmp4.PartSample{ |
|
||||||
Payload: au, |
|
||||||
}, |
|
||||||
dts: dts, |
|
||||||
ntp: ntp, |
|
||||||
} |
|
||||||
|
|
||||||
// put samples into a queue in order to compute the sample duration
|
|
||||||
sample, m.nextAudioSample = m.nextAudioSample, sample |
|
||||||
if sample == nil { |
|
||||||
return nil |
|
||||||
} |
|
||||||
sample.Duration = uint32(durationGoToMp4(m.nextAudioSample.dts-sample.dts, uint32(m.audioTrack.ClockRate()))) |
|
||||||
|
|
||||||
if m.videoTrack == nil { |
|
||||||
if m.currentSegment == nil { |
|
||||||
// create first segment
|
|
||||||
m.currentSegment = newMuxerVariantFMP4Segment( |
|
||||||
m.lowLatency, |
|
||||||
m.genSegmentID(), |
|
||||||
sample.ntp, |
|
||||||
sample.dts, |
|
||||||
m.segmentMaxSize, |
|
||||||
m.videoTrack, |
|
||||||
m.audioTrack, |
|
||||||
m.genPartID, |
|
||||||
m.onPartFinalized, |
|
||||||
) |
|
||||||
} |
|
||||||
} else { |
|
||||||
// wait for the video track
|
|
||||||
if m.currentSegment == nil { |
|
||||||
return nil |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
err := m.currentSegment.writeAudio(sample, m.partDuration) |
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
|
|
||||||
// switch segment
|
|
||||||
if m.videoTrack == nil && |
|
||||||
(m.nextAudioSample.dts-m.currentSegment.startDTS) >= m.segmentDuration { |
|
||||||
err := m.currentSegment.finalize(0) |
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
m.onSegmentFinalized(m.currentSegment) |
|
||||||
|
|
||||||
m.firstSegmentFinalized = true |
|
||||||
|
|
||||||
m.currentSegment = newMuxerVariantFMP4Segment( |
|
||||||
m.lowLatency, |
|
||||||
m.genSegmentID(), |
|
||||||
m.nextAudioSample.ntp, |
|
||||||
m.nextAudioSample.dts, |
|
||||||
m.segmentMaxSize, |
|
||||||
m.videoTrack, |
|
||||||
m.audioTrack, |
|
||||||
m.genPartID, |
|
||||||
m.onPartFinalized, |
|
||||||
) |
|
||||||
} |
|
||||||
|
|
||||||
return nil |
|
||||||
} |
|
||||||
@ -1,73 +0,0 @@ |
|||||||
package hls |
|
||||||
|
|
||||||
import ( |
|
||||||
"fmt" |
|
||||||
"time" |
|
||||||
|
|
||||||
"github.com/aler9/gortsplib/v2/pkg/format" |
|
||||||
) |
|
||||||
|
|
||||||
type muxerVariantMPEGTS struct { |
|
||||||
playlist *muxerVariantMPEGTSPlaylist |
|
||||||
segmenter *muxerVariantMPEGTSSegmenter |
|
||||||
} |
|
||||||
|
|
||||||
func newMuxerVariantMPEGTS( |
|
||||||
segmentCount int, |
|
||||||
segmentDuration time.Duration, |
|
||||||
segmentMaxSize uint64, |
|
||||||
videoTrack format.Format, |
|
||||||
audioTrack format.Format, |
|
||||||
) (*muxerVariantMPEGTS, error) { |
|
||||||
var videoTrackH264 *format.H264 |
|
||||||
if videoTrack != nil { |
|
||||||
var ok bool |
|
||||||
videoTrackH264, ok = videoTrack.(*format.H264) |
|
||||||
if !ok { |
|
||||||
return nil, fmt.Errorf( |
|
||||||
"the MPEG-TS variant of HLS only supports H264 video. Use the fMP4 or Low-Latency variants instead") |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
var audioTrackMPEG4Audio *format.MPEG4Audio |
|
||||||
if audioTrack != nil { |
|
||||||
var ok bool |
|
||||||
audioTrackMPEG4Audio, ok = audioTrack.(*format.MPEG4Audio) |
|
||||||
if !ok { |
|
||||||
return nil, fmt.Errorf( |
|
||||||
"the MPEG-TS variant of HLS only supports MPEG4-audio. Use the fMP4 or Low-Latency variants instead") |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
v := &muxerVariantMPEGTS{} |
|
||||||
|
|
||||||
v.playlist = newMuxerVariantMPEGTSPlaylist(segmentCount) |
|
||||||
|
|
||||||
v.segmenter = newMuxerVariantMPEGTSSegmenter( |
|
||||||
segmentDuration, |
|
||||||
segmentMaxSize, |
|
||||||
videoTrackH264, |
|
||||||
audioTrackMPEG4Audio, |
|
||||||
func(seg *muxerVariantMPEGTSSegment) { |
|
||||||
v.playlist.pushSegment(seg) |
|
||||||
}, |
|
||||||
) |
|
||||||
|
|
||||||
return v, nil |
|
||||||
} |
|
||||||
|
|
||||||
func (v *muxerVariantMPEGTS) close() { |
|
||||||
v.playlist.close() |
|
||||||
} |
|
||||||
|
|
||||||
func (v *muxerVariantMPEGTS) writeH26x(ntp time.Time, pts time.Duration, nalus [][]byte) error { |
|
||||||
return v.segmenter.writeH264(ntp, pts, nalus) |
|
||||||
} |
|
||||||
|
|
||||||
func (v *muxerVariantMPEGTS) writeAudio(ntp time.Time, pts time.Duration, au []byte) error { |
|
||||||
return v.segmenter.writeAAC(ntp, pts, au) |
|
||||||
} |
|
||||||
|
|
||||||
func (v *muxerVariantMPEGTS) file(name string, msn string, part string, skip string) *MuxerFileResponse { |
|
||||||
return v.playlist.file(name) |
|
||||||
} |
|
||||||
@ -1,145 +0,0 @@ |
|||||||
package hls |
|
||||||
|
|
||||||
import ( |
|
||||||
"bytes" |
|
||||||
"io" |
|
||||||
"math" |
|
||||||
"net/http" |
|
||||||
"strconv" |
|
||||||
"strings" |
|
||||||
"sync" |
|
||||||
) |
|
||||||
|
|
||||||
type muxerVariantMPEGTSPlaylist struct { |
|
||||||
segmentCount int |
|
||||||
|
|
||||||
mutex sync.Mutex |
|
||||||
cond *sync.Cond |
|
||||||
closed bool |
|
||||||
segments []*muxerVariantMPEGTSSegment |
|
||||||
segmentByName map[string]*muxerVariantMPEGTSSegment |
|
||||||
segmentDeleteCount int |
|
||||||
} |
|
||||||
|
|
||||||
func newMuxerVariantMPEGTSPlaylist(segmentCount int) *muxerVariantMPEGTSPlaylist { |
|
||||||
p := &muxerVariantMPEGTSPlaylist{ |
|
||||||
segmentCount: segmentCount, |
|
||||||
segmentByName: make(map[string]*muxerVariantMPEGTSSegment), |
|
||||||
} |
|
||||||
p.cond = sync.NewCond(&p.mutex) |
|
||||||
|
|
||||||
return p |
|
||||||
} |
|
||||||
|
|
||||||
func (p *muxerVariantMPEGTSPlaylist) close() { |
|
||||||
func() { |
|
||||||
p.mutex.Lock() |
|
||||||
defer p.mutex.Unlock() |
|
||||||
p.closed = true |
|
||||||
}() |
|
||||||
|
|
||||||
p.cond.Broadcast() |
|
||||||
} |
|
||||||
|
|
||||||
func (p *muxerVariantMPEGTSPlaylist) file(name string) *MuxerFileResponse { |
|
||||||
switch { |
|
||||||
case name == "stream.m3u8": |
|
||||||
return p.playlistReader() |
|
||||||
|
|
||||||
case strings.HasSuffix(name, ".ts"): |
|
||||||
return p.segmentReader(name) |
|
||||||
|
|
||||||
default: |
|
||||||
return &MuxerFileResponse{Status: http.StatusNotFound} |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
func (p *muxerVariantMPEGTSPlaylist) playlist() io.Reader { |
|
||||||
cnt := "#EXTM3U\n" |
|
||||||
cnt += "#EXT-X-VERSION:3\n" |
|
||||||
cnt += "#EXT-X-ALLOW-CACHE:NO\n" |
|
||||||
|
|
||||||
targetDuration := func() uint { |
|
||||||
ret := uint(0) |
|
||||||
|
|
||||||
// EXTINF, when rounded to the nearest integer, must be <= EXT-X-TARGETDURATION
|
|
||||||
for _, s := range p.segments { |
|
||||||
v2 := uint(math.Round(s.duration().Seconds())) |
|
||||||
if v2 > ret { |
|
||||||
ret = v2 |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
return ret |
|
||||||
}() |
|
||||||
cnt += "#EXT-X-TARGETDURATION:" + strconv.FormatUint(uint64(targetDuration), 10) + "\n" |
|
||||||
|
|
||||||
cnt += "#EXT-X-MEDIA-SEQUENCE:" + strconv.FormatInt(int64(p.segmentDeleteCount), 10) + "\n" |
|
||||||
|
|
||||||
for _, s := range p.segments { |
|
||||||
cnt += "#EXT-X-PROGRAM-DATE-TIME:" + s.startTime.Format("2006-01-02T15:04:05.999Z07:00") + "\n" + |
|
||||||
"#EXTINF:" + strconv.FormatFloat(s.duration().Seconds(), 'f', -1, 64) + ",\n" + |
|
||||||
s.name + ".ts\n" |
|
||||||
} |
|
||||||
|
|
||||||
return bytes.NewReader([]byte(cnt)) |
|
||||||
} |
|
||||||
|
|
||||||
func (p *muxerVariantMPEGTSPlaylist) playlistReader() *MuxerFileResponse { |
|
||||||
p.mutex.Lock() |
|
||||||
defer p.mutex.Unlock() |
|
||||||
|
|
||||||
if !p.closed && len(p.segments) == 0 { |
|
||||||
p.cond.Wait() |
|
||||||
} |
|
||||||
|
|
||||||
if p.closed { |
|
||||||
return &MuxerFileResponse{Status: http.StatusNotFound} |
|
||||||
} |
|
||||||
|
|
||||||
return &MuxerFileResponse{ |
|
||||||
Status: http.StatusOK, |
|
||||||
Header: map[string]string{ |
|
||||||
"Content-Type": `application/x-mpegURL`, |
|
||||||
}, |
|
||||||
Body: p.playlist(), |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
func (p *muxerVariantMPEGTSPlaylist) segmentReader(fname string) *MuxerFileResponse { |
|
||||||
base := strings.TrimSuffix(fname, ".ts") |
|
||||||
|
|
||||||
p.mutex.Lock() |
|
||||||
f, ok := p.segmentByName[base] |
|
||||||
p.mutex.Unlock() |
|
||||||
|
|
||||||
if !ok { |
|
||||||
return &MuxerFileResponse{Status: http.StatusNotFound} |
|
||||||
} |
|
||||||
|
|
||||||
return &MuxerFileResponse{ |
|
||||||
Status: http.StatusOK, |
|
||||||
Header: map[string]string{ |
|
||||||
"Content-Type": "video/MP2T", |
|
||||||
}, |
|
||||||
Body: f.reader(), |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
func (p *muxerVariantMPEGTSPlaylist) pushSegment(t *muxerVariantMPEGTSSegment) { |
|
||||||
func() { |
|
||||||
p.mutex.Lock() |
|
||||||
defer p.mutex.Unlock() |
|
||||||
|
|
||||||
p.segmentByName[t.name] = t |
|
||||||
p.segments = append(p.segments, t) |
|
||||||
|
|
||||||
if len(p.segments) > p.segmentCount { |
|
||||||
delete(p.segmentByName, p.segments[0].name) |
|
||||||
p.segments = p.segments[1:] |
|
||||||
p.segmentDeleteCount++ |
|
||||||
} |
|
||||||
}() |
|
||||||
|
|
||||||
p.cond.Broadcast() |
|
||||||
} |
|
||||||
@ -1,118 +0,0 @@ |
|||||||
package hls |
|
||||||
|
|
||||||
import ( |
|
||||||
"bytes" |
|
||||||
"fmt" |
|
||||||
"io" |
|
||||||
"strconv" |
|
||||||
"time" |
|
||||||
|
|
||||||
"github.com/aler9/gortsplib/v2/pkg/format" |
|
||||||
|
|
||||||
"github.com/aler9/rtsp-simple-server/internal/hls/mpegts" |
|
||||||
) |
|
||||||
|
|
||||||
type muxerVariantMPEGTSSegment struct { |
|
||||||
segmentMaxSize uint64 |
|
||||||
videoTrack *format.H264 |
|
||||||
audioTrack *format.MPEG4Audio |
|
||||||
writer *mpegts.Writer |
|
||||||
|
|
||||||
size uint64 |
|
||||||
startTime time.Time |
|
||||||
name string |
|
||||||
startDTS *time.Duration |
|
||||||
endDTS time.Duration |
|
||||||
audioAUCount int |
|
||||||
content []byte |
|
||||||
} |
|
||||||
|
|
||||||
func newMuxerVariantMPEGTSSegment( |
|
||||||
id uint64, |
|
||||||
startTime time.Time, |
|
||||||
segmentMaxSize uint64, |
|
||||||
videoTrack *format.H264, |
|
||||||
audioTrack *format.MPEG4Audio, |
|
||||||
writer *mpegts.Writer, |
|
||||||
) *muxerVariantMPEGTSSegment { |
|
||||||
t := &muxerVariantMPEGTSSegment{ |
|
||||||
segmentMaxSize: segmentMaxSize, |
|
||||||
videoTrack: videoTrack, |
|
||||||
audioTrack: audioTrack, |
|
||||||
writer: writer, |
|
||||||
startTime: startTime, |
|
||||||
name: "seg" + strconv.FormatUint(id, 10), |
|
||||||
} |
|
||||||
|
|
||||||
return t |
|
||||||
} |
|
||||||
|
|
||||||
func (t *muxerVariantMPEGTSSegment) duration() time.Duration { |
|
||||||
return t.endDTS - *t.startDTS |
|
||||||
} |
|
||||||
|
|
||||||
func (t *muxerVariantMPEGTSSegment) reader() io.Reader { |
|
||||||
return bytes.NewReader(t.content) |
|
||||||
} |
|
||||||
|
|
||||||
func (t *muxerVariantMPEGTSSegment) finalize(endDTS time.Duration) { |
|
||||||
t.endDTS = endDTS |
|
||||||
t.content = t.writer.GenerateSegment() |
|
||||||
} |
|
||||||
|
|
||||||
func (t *muxerVariantMPEGTSSegment) writeH264( |
|
||||||
pcr time.Duration, |
|
||||||
dts time.Duration, |
|
||||||
pts time.Duration, |
|
||||||
idrPresent bool, |
|
||||||
nalus [][]byte, |
|
||||||
) error { |
|
||||||
size := uint64(0) |
|
||||||
for _, nalu := range nalus { |
|
||||||
size += uint64(len(nalu)) |
|
||||||
} |
|
||||||
if (t.size + size) > t.segmentMaxSize { |
|
||||||
return fmt.Errorf("reached maximum segment size") |
|
||||||
} |
|
||||||
t.size += size |
|
||||||
|
|
||||||
err := t.writer.WriteH264(pcr, dts, pts, idrPresent, nalus) |
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
|
|
||||||
if t.startDTS == nil { |
|
||||||
t.startDTS = &dts |
|
||||||
} |
|
||||||
t.endDTS = dts |
|
||||||
|
|
||||||
return nil |
|
||||||
} |
|
||||||
|
|
||||||
func (t *muxerVariantMPEGTSSegment) writeAAC( |
|
||||||
pcr time.Duration, |
|
||||||
pts time.Duration, |
|
||||||
au []byte, |
|
||||||
) error { |
|
||||||
size := uint64(len(au)) |
|
||||||
if (t.size + size) > t.segmentMaxSize { |
|
||||||
return fmt.Errorf("reached maximum segment size") |
|
||||||
} |
|
||||||
t.size += size |
|
||||||
|
|
||||||
err := t.writer.WriteAAC(pcr, pts, au) |
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
|
|
||||||
if t.videoTrack == nil { |
|
||||||
t.audioAUCount++ |
|
||||||
|
|
||||||
if t.startDTS == nil { |
|
||||||
t.startDTS = &pts |
|
||||||
} |
|
||||||
t.endDTS = pts |
|
||||||
} |
|
||||||
|
|
||||||
return nil |
|
||||||
} |
|
||||||
@ -1,193 +0,0 @@ |
|||||||
package hls |
|
||||||
|
|
||||||
import ( |
|
||||||
"fmt" |
|
||||||
"time" |
|
||||||
|
|
||||||
"github.com/aler9/gortsplib/v2/pkg/codecs/h264" |
|
||||||
"github.com/aler9/gortsplib/v2/pkg/format" |
|
||||||
|
|
||||||
"github.com/aler9/rtsp-simple-server/internal/hls/mpegts" |
|
||||||
) |
|
||||||
|
|
||||||
const ( |
|
||||||
mpegtsSegmentMinAUCount = 100 |
|
||||||
) |
|
||||||
|
|
||||||
type muxerVariantMPEGTSSegmenter struct { |
|
||||||
segmentDuration time.Duration |
|
||||||
segmentMaxSize uint64 |
|
||||||
videoTrack *format.H264 |
|
||||||
audioTrack *format.MPEG4Audio |
|
||||||
onSegmentReady func(*muxerVariantMPEGTSSegment) |
|
||||||
|
|
||||||
writer *mpegts.Writer |
|
||||||
nextSegmentID uint64 |
|
||||||
currentSegment *muxerVariantMPEGTSSegment |
|
||||||
videoDTSExtractor *h264.DTSExtractor |
|
||||||
startPCR time.Time |
|
||||||
startDTS time.Duration |
|
||||||
} |
|
||||||
|
|
||||||
func newMuxerVariantMPEGTSSegmenter( |
|
||||||
segmentDuration time.Duration, |
|
||||||
segmentMaxSize uint64, |
|
||||||
videoTrack *format.H264, |
|
||||||
audioTrack *format.MPEG4Audio, |
|
||||||
onSegmentReady func(*muxerVariantMPEGTSSegment), |
|
||||||
) *muxerVariantMPEGTSSegmenter { |
|
||||||
m := &muxerVariantMPEGTSSegmenter{ |
|
||||||
segmentDuration: segmentDuration, |
|
||||||
segmentMaxSize: segmentMaxSize, |
|
||||||
videoTrack: videoTrack, |
|
||||||
audioTrack: audioTrack, |
|
||||||
onSegmentReady: onSegmentReady, |
|
||||||
} |
|
||||||
|
|
||||||
m.writer = mpegts.NewWriter( |
|
||||||
videoTrack, |
|
||||||
audioTrack) |
|
||||||
|
|
||||||
return m |
|
||||||
} |
|
||||||
|
|
||||||
func (m *muxerVariantMPEGTSSegmenter) genSegmentID() uint64 { |
|
||||||
id := m.nextSegmentID |
|
||||||
m.nextSegmentID++ |
|
||||||
return id |
|
||||||
} |
|
||||||
|
|
||||||
func (m *muxerVariantMPEGTSSegmenter) writeH264(ntp time.Time, pts time.Duration, nalus [][]byte) error { |
|
||||||
idrPresent := false |
|
||||||
nonIDRPresent := false |
|
||||||
|
|
||||||
for _, nalu := range nalus { |
|
||||||
typ := h264.NALUType(nalu[0] & 0x1F) |
|
||||||
switch typ { |
|
||||||
case h264.NALUTypeIDR: |
|
||||||
idrPresent = true |
|
||||||
|
|
||||||
case h264.NALUTypeNonIDR: |
|
||||||
nonIDRPresent = true |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
var dts time.Duration |
|
||||||
|
|
||||||
if m.currentSegment == nil { |
|
||||||
// skip groups silently until we find one with a IDR
|
|
||||||
if !idrPresent { |
|
||||||
return nil |
|
||||||
} |
|
||||||
|
|
||||||
m.videoDTSExtractor = h264.NewDTSExtractor() |
|
||||||
|
|
||||||
var err error |
|
||||||
dts, err = m.videoDTSExtractor.Extract(nalus, pts) |
|
||||||
if err != nil { |
|
||||||
return fmt.Errorf("unable to extract DTS: %v", err) |
|
||||||
} |
|
||||||
|
|
||||||
m.startPCR = ntp |
|
||||||
m.startDTS = dts |
|
||||||
dts = 0 |
|
||||||
pts -= m.startDTS |
|
||||||
|
|
||||||
// create first segment
|
|
||||||
m.currentSegment = newMuxerVariantMPEGTSSegment( |
|
||||||
m.genSegmentID(), |
|
||||||
ntp, |
|
||||||
m.segmentMaxSize, |
|
||||||
m.videoTrack, |
|
||||||
m.audioTrack, |
|
||||||
m.writer) |
|
||||||
} else { |
|
||||||
if !idrPresent && !nonIDRPresent { |
|
||||||
return nil |
|
||||||
} |
|
||||||
|
|
||||||
var err error |
|
||||||
dts, err = m.videoDTSExtractor.Extract(nalus, pts) |
|
||||||
if err != nil { |
|
||||||
return fmt.Errorf("unable to extract DTS: %v", err) |
|
||||||
} |
|
||||||
|
|
||||||
dts -= m.startDTS |
|
||||||
pts -= m.startDTS |
|
||||||
|
|
||||||
// switch segment
|
|
||||||
if idrPresent && |
|
||||||
(dts-*m.currentSegment.startDTS) >= m.segmentDuration { |
|
||||||
m.currentSegment.finalize(dts) |
|
||||||
m.onSegmentReady(m.currentSegment) |
|
||||||
m.currentSegment = newMuxerVariantMPEGTSSegment( |
|
||||||
m.genSegmentID(), |
|
||||||
ntp, |
|
||||||
m.segmentMaxSize, |
|
||||||
m.videoTrack, |
|
||||||
m.audioTrack, |
|
||||||
m.writer) |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
err := m.currentSegment.writeH264( |
|
||||||
ntp.Sub(m.startPCR), |
|
||||||
dts, |
|
||||||
pts, |
|
||||||
idrPresent, |
|
||||||
nalus) |
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
|
|
||||||
return nil |
|
||||||
} |
|
||||||
|
|
||||||
func (m *muxerVariantMPEGTSSegmenter) writeAAC(ntp time.Time, pts time.Duration, au []byte) error { |
|
||||||
if m.videoTrack == nil { |
|
||||||
if m.currentSegment == nil { |
|
||||||
m.startPCR = ntp |
|
||||||
m.startDTS = pts |
|
||||||
pts = 0 |
|
||||||
|
|
||||||
// create first segment
|
|
||||||
m.currentSegment = newMuxerVariantMPEGTSSegment( |
|
||||||
m.genSegmentID(), |
|
||||||
ntp, |
|
||||||
m.segmentMaxSize, |
|
||||||
m.videoTrack, |
|
||||||
m.audioTrack, |
|
||||||
m.writer) |
|
||||||
} else { |
|
||||||
pts -= m.startDTS |
|
||||||
|
|
||||||
// switch segment
|
|
||||||
if m.currentSegment.audioAUCount >= mpegtsSegmentMinAUCount && |
|
||||||
(pts-*m.currentSegment.startDTS) >= m.segmentDuration { |
|
||||||
m.currentSegment.finalize(pts) |
|
||||||
m.onSegmentReady(m.currentSegment) |
|
||||||
m.currentSegment = newMuxerVariantMPEGTSSegment( |
|
||||||
m.genSegmentID(), |
|
||||||
ntp, |
|
||||||
m.segmentMaxSize, |
|
||||||
m.videoTrack, |
|
||||||
m.audioTrack, |
|
||||||
m.writer) |
|
||||||
} |
|
||||||
} |
|
||||||
} else { |
|
||||||
// wait for the video track
|
|
||||||
if m.currentSegment == nil { |
|
||||||
return nil |
|
||||||
} |
|
||||||
|
|
||||||
pts -= m.startDTS |
|
||||||
} |
|
||||||
|
|
||||||
err := m.currentSegment.writeAAC(ntp.Sub(m.startPCR), pts, au) |
|
||||||
if err != nil { |
|
||||||
return err |
|
||||||
} |
|
||||||
|
|
||||||
return nil |
|
||||||
} |
|
||||||
Loading…
Reference in new issue