feat: update with ProcessingLogger adapter

Author: RaphReynaud

pkg/cmd/raw-recording-tool/extract_audio.go

@@ -95,7 +95,18 @@ func runExtractAudio(cmd *cobra.Command, args []string) error {
 	}
 
 	// Extract audio tracks
-	if err := processing.ExtractTracks(globalArgs.WorkDir, globalArgs.Output, userID, sessionID, trackID, metadata, "audio", "both", fillGaps, fixDtx, logger); err != nil {
+	extractor := processing.NewTrackExtractor(logger)
+	if _, err := extractor.ExtractTracks(&processing.TrackExtractorConfig{
+		WorkDir:   globalArgs.WorkDir,
+		OutputDir: globalArgs.Output,
+		UserID:    userID,
+		SessionID: sessionID,
+		TrackID:   trackID,
+		TrackKind: TrackTypeAudio,
+		MediaType: "both",
+		FillGap:   fillGaps,
+		FillDtx:   fixDtx,
+	}, metadata); err != nil {
 		return fmt.Errorf("failed to extract audio: %w", err)
 	}
 

pkg/cmd/raw-recording-tool/extract_video.go

@@ -93,7 +93,18 @@ func runExtractVideo(cmd *cobra.Command, args []string) error {
 	}
 
 	// Extract video tracks
-	if err := processing.ExtractTracks(globalArgs.WorkDir, globalArgs.Output, userID, sessionID, trackID, metadata, "video", "both", fillGaps, false, logger); err != nil {
+	extractor := processing.NewTrackExtractor(logger)
+	if _, err := extractor.ExtractTracks(&processing.TrackExtractorConfig{
+		WorkDir:   globalArgs.WorkDir,
+		OutputDir: globalArgs.Output,
+		UserID:    userID,
+		SessionID: sessionID,
+		TrackID:   trackID,
+		TrackKind: TrackTypeVideo,
+		MediaType: "both",
+		FillGap:   fillGaps,
+		FillDtx:   false,
+	}, metadata); err != nil {
 		return fmt.Errorf("failed to extract video tracks: %w", err)
 	}
 

pkg/cmd/raw-recording-tool/mix_audio.go

@@ -74,7 +74,7 @@ func runMixAudio(cmd *cobra.Command, args []string) error {
 		WithScreenshare: false,
 		WithExtract:     true,
 		WithCleanup:     false,
-	}, metadata, logger)
+	}, metadata)
 
 	logger.Info("Mix-audio command completed successfully")
 	return nil

pkg/cmd/raw-recording-tool/mux_av.go

@@ -119,16 +119,16 @@ func runMuxAV(cmd *cobra.Command, args []string) error {
 
 	// Mux audio/video tracks
 	muxer := processing.NewAudioVideoMuxer(logger)
-	if err := muxer.MuxAudioVideoTracks(&processing.AudioVideoMuxerConfig{
+	if _, err := muxer.MuxAudioVideoTracks(&processing.AudioVideoMuxerConfig{
 		WorkDir:     globalArgs.WorkDir,
 		OutputDir:   globalArgs.Output,
 		UserID:      userID,
 		SessionID:   sessionID,
 		TrackID:     trackID,
-		Media:       media,
+		MediaType:   media,
 		WithExtract: true,
 		WithCleanup: false,
-	}, metadata, logger); err != nil {
+	}, metadata); err != nil {
 		return fmt.Errorf("failed to mux audio/video tracks: %w", err)
 	}
 

pkg/cmd/raw-recording-tool/process_all.go

@@ -110,12 +110,33 @@ func runProcessAll(cmd *cobra.Command, args []string) error {
 	}
 
 	// Extract audio tracks
-	if err := processing.ExtractTracks(globalArgs.WorkDir, globalArgs.Output, "", "", "", metadata, "audio", "both", true, true, logger); err != nil {
+	extractor := processing.NewTrackExtractor(logger)
+	if _, err := extractor.ExtractTracks(&processing.TrackExtractorConfig{
+		WorkDir:   globalArgs.WorkDir,
+		OutputDir: globalArgs.Output,
+		UserID:    "",
+		SessionID: "",
+		TrackID:   "",
+		TrackKind: TrackTypeAudio,
+		MediaType: "both",
+		FillGap:   true,
+		FillDtx:   true,
+	}, metadata); err != nil {
 		return fmt.Errorf("failed to extract audio tracks: %w", err)
 	}
 
 	// Extract video tracks
-	if err := processing.ExtractTracks(globalArgs.WorkDir, globalArgs.Output, "", "", "", metadata, "video", "both", true, true, logger); err != nil {
+	if _, err := extractor.ExtractTracks(&processing.TrackExtractorConfig{
+		WorkDir:   globalArgs.WorkDir,
+		OutputDir: globalArgs.Output,
+		UserID:    "",
+		SessionID: "",
+		TrackID:   "",
+		TrackKind: TrackTypeVideo,
+		MediaType: "both",
+		FillGap:   true,
+		FillDtx:   true,
+	}, metadata); err != nil {
 		return fmt.Errorf("failed to extract video tracks: %w", err)
 	}
 
@@ -127,20 +148,20 @@ func runProcessAll(cmd *cobra.Command, args []string) error {
 		WithScreenshare: false,
 		WithExtract:     false,
 		WithCleanup:     false,
-	}, metadata, logger)
+	}, metadata)
 
 	// Mux audio/video tracks
 	muxer := processing.NewAudioVideoMuxer(logger)
-	if err := muxer.MuxAudioVideoTracks(&processing.AudioVideoMuxerConfig{
+	if _, err := muxer.MuxAudioVideoTracks(&processing.AudioVideoMuxerConfig{
 		WorkDir:     globalArgs.WorkDir,
 		OutputDir:   globalArgs.Output,
 		UserID:      "",
 		SessionID:   "",
 		TrackID:     "",
-		Media:       "",
+		MediaType:   "",
 		WithExtract: false,
 		WithCleanup: false,
-	}, metadata, logger); err != nil {
+	}, metadata); err != nil {
 		return fmt.Errorf("failed to mux audio/video tracks: %w", err)
 	}
 

pkg/cmd/raw-recording-tool/processing/archive_input.go

@@ -8,13 +8,11 @@ import (
 	"os"
 	"path/filepath"
 	"strings"
-
-	"github.com/GetStream/getstream-go/v3"
 )
 
 // extractToTempDir extracts archive to temp directory or returns the directory path
 // Returns: (workingDir, cleanupFunc, error)
-func ExtractToTempDir(inputPath string, logger *getstream.DefaultLogger) (string, func(), error) {
+func ExtractToTempDir(inputPath string, logger *ProcessingLogger) (string, func(), error) {
 	// If it's already a directory, just return it
 	if stat, err := os.Stat(inputPath); err == nil && stat.IsDir() {
 		logger.Debug("Input is already a directory: %s", inputPath)
@@ -48,7 +46,7 @@ func ExtractToTempDir(inputPath string, logger *getstream.DefaultLogger) (string
 }
 
 // extractTarGzToDir extracts a tar.gz file to the specified directory
-func extractTarGzToDir(tarGzPath, destDir string, logger *getstream.DefaultLogger) error {
+func extractTarGzToDir(tarGzPath, destDir string, logger *ProcessingLogger) error {
 	file, err := os.Open(tarGzPath)
 	if err != nil {
 		return fmt.Errorf("failed to open tar.gz file: %w", err)

pkg/cmd/raw-recording-tool/processing/archive_json.go

@@ -1,8 +1,14 @@
 package processing
 
+import "time"
+
 type SessionTimingMetadata struct {
-	ParticipantID string `json:"participant_id"`
-	UserSessionID string `json:"user_session_id"`
+	CallType      string    `json:"call_type"`
+	CallID        string    `json:"call_id"`
+	CallSessionID string    `json:"call_session_id"`
+	CallStartTime time.Time `json:"call_start_time"`
+	ParticipantID string    `json:"participant_id"`
+	UserSessionID string    `json:"user_session_id"`
 	Segments      struct {
 		Audio []*SegmentMetadata `json:"audio"`
 		Video []*SegmentMetadata `json:"video"`
@@ -27,4 +33,12 @@ type SegmentMetadata struct {
 	FirstRtcpNtpTimestamp int64  `json:"first_rtcp_ntp_timestamp,omitempty"`
 	LastRtcpRtpTimestamp  uint32 `json:"last_rtcp_rtp_timestamp,omitempty"`
 	LastRtcpNtpTimestamp  int64  `json:"last_rtcp_ntp_timestamp,omitempty"`
+
+	FirstKeyFrameOffsetMs *int64                 `json:"first_key_frame_offset_ms,omitempty"`
+	MaxFrameDimension     *SegmentFrameDimension `json:"max_frame_dimension,omitempty"`
+}
+
+type SegmentFrameDimension struct {
+	Width  uint32 `json:"width,omitempty"`
+	Height uint32 `json:"height,omitempty"`
 }

pkg/cmd/raw-recording-tool/processing/archive_metadata.go

@@ -10,22 +10,28 @@ import (
 	"path/filepath"
 	"sort"
 	"strings"
-
-	"github.com/GetStream/getstream-go/v3"
+	"time"
 )
 
 // TrackInfo represents a single track with its metadata (deduplicated across segments)
 type TrackInfo struct {
-	UserID        string         `json:"userId"`        // participant_id from timing metadata
-	SessionID     string         `json:"sessionId"`     // user_session_id from timing metadata
-	TrackID       string         `json:"trackId"`       // track_id from segment
-	TrackType     string         `json:"trackType"`     // "audio" or "video" (cleaned from TRACK_TYPE_*)
-	IsScreenshare bool           `json:"isScreenshare"` // true if this is a screenshare track
-	Codec         string         `json:"codec"`         // codec info
-	SegmentCount  int            `json:"segmentCount"`  // number of segments for this track
-	Segments      []*SegmentInfo `json:"segments"`      // list of filenames (for JSON output only)
-
-	ConcatenatedContainerPath string
+	CallType       string         `json:"callType"`       // call_type from timing metadata
+	CallID         string         `json:"callId"`         // call_id from timing metadata
+	CallSessionID  string         `json:"callSessionId"`  // call_session_id from timing metadata
+	CallStartTime  time.Time      `json:"callStartTime"`  // call_start_time from timing metadata
+	UserID         string         `json:"userId"`         // participant_id from timing metadata
+	SessionID      string         `json:"sessionId"`      // user_session_id from timing metadata
+	TrackID        string         `json:"trackId"`        // track_id from segment
+	TrackType      string         `json:"trackType"`      // track_type from segment
+	TrackKind      string         `json:"trackKind"`      // "audio" or "video" (cleaned from TRACK_TYPE_*)
+	IsScreenshare  bool           `json:"isScreenshare"`  // true if this is a screenshare track
+	Codec          string         `json:"codec"`          // codec info
+	SegmentCount   int            `json:"segmentCount"`   // number of segments for this track
+	TrackStartTime time.Time      `json:"trackStartTime"` // first_rtp_unix_timestamp from segment
+	TrackEndTime   time.Time      `json:"trackEndTime"`   // last_rtp_unix_timestamp from segment
+	Segments       []*SegmentInfo `json:"segments"`       // list of filenames (for JSON output only)
+
+	ConcatenatedTrackFileInfo *TrackFileInfo
 }
 
 type SegmentInfo struct {
@@ -35,7 +41,13 @@ type SegmentInfo struct {
 	SdpPath       string
 	ContainerPath string
 	ContainerExt  string
-	FFMpegOffset  int64
+}
+
+type TrackFileInfo struct {
+	Name              string
+	StartAt           time.Time
+	EndAt             time.Time
+	MaxFrameDimension SegmentFrameDimension
 }
 
 // RecordingMetadata contains all tracks and session information
@@ -47,11 +59,11 @@ type RecordingMetadata struct {
 
 // MetadataParser handles parsing of raw recording files
 type MetadataParser struct {
-	logger *getstream.DefaultLogger
+	logger *ProcessingLogger
 }
 
 // NewMetadataParser creates a new metadata parser
-func NewMetadataParser(logger *getstream.DefaultLogger) *MetadataParser {
+func NewMetadataParser(logger *ProcessingLogger) *MetadataParser {
 	return &MetadataParser{
 		logger: logger,
 	}
@@ -197,27 +209,42 @@ func (p *MetadataParser) parseTimingMetadataFile(data []byte) ([]*TrackInfo, err
 	// Use a map to deduplicate tracks by unique key
 	trackMap := make(map[string]*TrackInfo)
 
-	processSegment := func(segment *SegmentMetadata, trackType string) {
+	processSegment := func(segment *SegmentMetadata, trackKind string) {
 		key := fmt.Sprintf("%s|%s|%s|%s",
 			sessionMetadata.ParticipantID,
 			sessionMetadata.UserSessionID,
 			segment.TrackID,
-			trackType)
+			trackKind)
 
 		if existingTrack, exists := trackMap[key]; exists {
 			existingTrack.Segments = append(existingTrack.Segments, &SegmentInfo{metadata: segment})
 			existingTrack.SegmentCount++
+
+			ts, te := time.UnixMilli(segment.FirstRtpUnixTimestamp), time.UnixMilli(segment.LastRtpUnixTimestamp)
+			if ts.Before(existingTrack.TrackStartTime) {
+				existingTrack.TrackStartTime = ts
+			}
+			if te.After(existingTrack.TrackEndTime) {
+				existingTrack.TrackEndTime = te
+			}
 		} else {
 			// Create new track
 			track := &TrackInfo{
-				UserID:        sessionMetadata.ParticipantID,
-				SessionID:     sessionMetadata.UserSessionID,
-				TrackID:       segment.TrackID,
-				TrackType:     p.cleanTrackType(segment.TrackType),
-				IsScreenshare: p.isScreenshareTrack(segment.TrackType),
-				Codec:         segment.Codec,
-				SegmentCount:  1,
-				Segments:      []*SegmentInfo{{metadata: segment}},
+				CallType:       sessionMetadata.CallType,
+				CallID:         sessionMetadata.CallID,
+				CallSessionID:  sessionMetadata.CallSessionID,
+				CallStartTime:  sessionMetadata.CallStartTime,
+				UserID:         sessionMetadata.ParticipantID,
+				SessionID:      sessionMetadata.UserSessionID,
+				TrackID:        segment.TrackID,
+				TrackType:      segment.TrackType,
+				TrackKind:      p.cleanTrackType(segment.TrackType),
+				IsScreenshare:  p.isScreenshareTrack(segment.TrackType),
+				Codec:          segment.Codec,
+				SegmentCount:   1,
+				TrackStartTime: time.UnixMilli(segment.FirstRtpUnixTimestamp),
+				TrackEndTime:   time.UnixMilli(segment.LastRtpUnixTimestamp),
+				Segments:       []*SegmentInfo{{metadata: segment}},
 			}
 			trackMap[key] = track
 		}
@@ -254,9 +281,9 @@ func (p *MetadataParser) isScreenshareTrack(trackType string) bool {
 func (p *MetadataParser) cleanTrackType(trackType string) string {
 	switch trackType {
 	case "TRACK_TYPE_AUDIO", "TRACK_TYPE_SCREEN_SHARE_AUDIO":
-		return "audio"
+		return trackKindAudio
 	case "TRACK_TYPE_VIDEO", "TRACK_TYPE_SCREEN_SHARE":
-		return "video"
+		return trackKindVideo
 	default:
 		return strings.ToLower(trackType)
 	}
@@ -298,20 +325,20 @@ func (p *MetadataParser) extractUniqueSessions(tracks []*TrackInfo) []string {
 // Only one filter (userID, sessionID, or trackID) can be specified at a time
 // Empty values are ignored, specific values must match
 // If all are empty, all tracks are returned
-func FilterTracks(tracks []*TrackInfo, userID, sessionID, trackID, trackType, mediaFilter string) []*TrackInfo {
+func FilterTracks(tracks []*TrackInfo, userID, sessionID, trackID, trackKind, mediaType string) []*TrackInfo {
 	filtered := make([]*TrackInfo, 0)
 
 	for _, track := range tracks {
-		if trackType != "" && track.TrackType != trackType {
-			continue // Skip tracks with wrong TrackType
+		if trackKind != "" && track.TrackKind != trackKind {
+			continue // Skip tracks with wrong trackKind
 		}
 
 		// Apply media type filtering if specified
-		if mediaFilter != "" && mediaFilter != "both" {
-			if mediaFilter == "user" && track.IsScreenshare {
+		if mediaType != "" && mediaType != mediaTypeBoth {
+			if mediaType == mediaTypeUser && track.IsScreenshare {
 				continue // Skip display tracks when only user requested
 			}
-			if mediaFilter == "display" && !track.IsScreenshare {
+			if mediaType == mediaTypeDisplay && !track.IsScreenshare {
 				continue // Skip user tracks when only display requested
 			}
 		}