streaming

type AdaptationSet struct {
	ID               string           `xml:"id,attr"`
	MimeType         string           `xml:"mimeType,attr"`
	SegmentAlignment bool             `xml:"segmentAlignment,attr"`
	StartWithSAP     int              `xml:"startWithSAP,attr"`
	MaxWidth         int              `xml:"maxWidth,attr"`
	MaxHeight        int              `xml:"maxHeight,attr"`
	MaxFrameRate     string           `xml:"maxFrameRate,attr"`
	Par              string           `xml:"par,attr"`
	Representations  []Representation `xml:"Representation"`
}

type AdaptiveQualitySelector struct {
	// contains filtered or unexported fields
}

type AudioTrack struct {
	Language string
	Bitrate  int
	Codec    string
	BaseURL  string
}

type BandwidthMeasurement struct {
	UserID    string
	Bandwidth int // in kbps
	Timestamp time.Time
}

type BandwidthStats struct {
	UserID            string
	TotalBytes        int64
	SessionBytes      int64
	AverageBandwidth  int // in kbps
	PeakBandwidth     int // in kbps
	LastMeasurement   time.Time
	MeasurementWindow time.Duration
}

type BandwidthTracker struct {
	// contains filtered or unexported fields
}

type BaseURL struct {
	Value string `xml:",chardata"`
}

type BufferHealthSample struct {
	Timestamp   time.Time
	BufferLevel time.Duration
	Quality     Quality
	Bandwidth   int // kbps
}

type CostTracker interface {
	TrackDynamoRead(units int)
	TrackDynamoWrite(units int)
}

type DASHGenerator struct {
	// contains filtered or unexported fields
}

type DASHManifest struct {
	MediaID         string
	Duration        float64
	MinBufferTime   float64
	Representations []DASHRepresentation
	ManifestURL     string
	GeneratedAt     time.Time
	CacheDuration   time.Duration

	// Live streaming specific fields
	IsLive                     bool
	AvailabilityStartTime      time.Time
	PublishTime                time.Time
	TimeShiftBufferDepth       float64 // in seconds
	SuggestedPresentationDelay float64 // in seconds
	MinimumUpdatePeriod        float64 // in seconds
}

type DASHRepresentation struct {
	ID              string
	Quality         Quality
	Bandwidth       int
	Width           int
	Height          int
	Codecs          string
	BaseURL         string
	SegmentTemplate string
}

type Event struct {
	SessionID string
	UserID    string
	MediaID   string
	EventType EventType
	Timestamp time.Time

	// Event-specific data
	Quality         Quality
	PreviousQuality Quality
	Duration        time.Duration
	BytesLoaded     int64
	ErrorCode       string
	BufferHealth    float64
	Bandwidth       int
}

type EventType string

type HLSGenerator struct {
	// contains filtered or unexported fields
}

type HLSManifest struct {
	MediaID       string
	Duration      float64
	Variants      []HLSVariant
	MasterURL     string
	GeneratedAt   time.Time
	CacheDuration time.Duration
}

type HLSVariant struct {
	Quality     Quality
	Bandwidth   int
	Resolution  string
	PlaylistURL string
	Codecs      string
}

type Keyframe struct {
	PTS        float64 // Presentation timestamp in seconds
	ByteOffset int64   // Byte offset in the file
	ByteLength int64   // Length of the I-frame data in bytes
	Duration   float64 // Duration until next keyframe
	URI        string  // URI of the segment containing this I-frame
}

type KeyframeEntry struct {
	PTS        float64 `json:"pts"`         // Presentation timestamp in seconds
	DTS        float64 `json:"dts"`         // Decode timestamp in seconds
	ByteOffset int64   `json:"byte_offset"` // Byte offset in the file
	ByteLength int64   `json:"byte_size"`   // Size of I-frame data in bytes
	FrameNum   int     `json:"frame_num"`   // Frame number
	Segment    int     `json:"segment"`     // Which HLS segment contains this keyframe
}

type KeyframeMetadata struct {
	MediaID   string          `json:"media_id"`
	Quality   string          `json:"quality"`
	Keyframes []KeyframeEntry `json:"keyframes"`
	GOP       int             `json:"gop_size,omitempty"`  // Group of Pictures size
	Framerate float64         `json:"framerate,omitempty"` // Video framerate
	Duration  float64         `json:"duration,omitempty"`  // Total duration in seconds
	Codec     string          `json:"codec,omitempty"`     // Video codec (H264, H265, etc.)
}

type LiveMPD struct {
	XMLName                    xml.Name `xml:"MPD"`
	XMLNS                      string   `xml:"xmlns,attr"`
	Type                       string   `xml:"type,attr"`
	AvailabilityStartTime      string   `xml:"availabilityStartTime,attr"`
	PublishTime                string   `xml:"publishTime,attr"`
	MinimumUpdatePeriod        string   `xml:"minimumUpdatePeriod,attr,omitempty"`
	TimeShiftBufferDepth       string   `xml:"timeShiftBufferDepth,attr,omitempty"`
	SuggestedPresentationDelay string   `xml:"suggestedPresentationDelay,attr,omitempty"`
	MinBufferTime              string   `xml:"minBufferTime,attr"`
	Profiles                   string   `xml:"profiles,attr"`
	Periods                    []Period `xml:"Period"`
}

type LiveSegmentTemplate struct {
	Media                  string  `xml:"media,attr"`
	Initialization         string  `xml:"initialization,attr"`
	Duration               int     `xml:"duration,attr,omitempty"`
	Timescale              int     `xml:"timescale,attr"`
	AvailabilityTimeOffset float64 `xml:"availabilityTimeOffset,attr,omitempty"`
	PresentationTimeOffset int64   `xml:"presentationTimeOffset,attr,omitempty"`
	StartNumber            int     `xml:"startNumber,attr,omitempty"`
}

type MPD struct {
	XMLName                   xml.Name `xml:"MPD"`
	XMLNS                     string   `xml:"xmlns,attr"`
	Type                      string   `xml:"type,attr"`
	MediaPresentationDuration string   `xml:"mediaPresentationDuration,attr"`
	MinBufferTime             string   `xml:"minBufferTime,attr"`
	Profiles                  string   `xml:"profiles,attr"`
	Periods                   []Period `xml:"Period"`
}

type MediaFormat = types.MediaFormat

type MediaMetadata struct {
	MediaID            string
	OriginalURL        string
	Duration           float64
	Width              int
	Height             int
	Bitrate            int
	FileSize           int64
	ProcessedAt        time.Time
	AvailableQualities []Quality
	Status             ProcessingStatus

	// Codec information for HLS/DASH manifest generation
	VideoCodec      string                       `json:"video_codec,omitempty"`      // e.g., "avc1.640028"
	AudioCodec      string                       `json:"audio_codec,omitempty"`      // e.g., "mp4a.40.2"
	VideoProfile    string                       `json:"video_profile,omitempty"`    // e.g., "High", "Main", "Baseline"
	VideoLevel      string                       `json:"video_level,omitempty"`      // e.g., "4.0", "3.1"
	QualitySettings map[Quality]QualityCodecInfo `json:"quality_settings,omitempty"` // Per-quality codec info

	// Live streaming specific fields
	IsLive    bool      `json:"is_live,omitempty"`
	StartTime time.Time `json:"start_time,omitempty"`

	// I-frame/keyframe information for trick play
	KeyframePositions []float64 `json:"keyframe_positions,omitempty"` // PTS positions of keyframes in seconds
}

type MediaSessionRepository interface {
	CreateSession(ctx context.Context, session *StreamingSession) error
	GetSession(ctx context.Context, sessionID string) (*StreamingSession, error)
	UpdateSession(ctx context.Context, session *StreamingSession) error
	EndSession(ctx context.Context, sessionID string) error
	GetUserSessions(ctx context.Context, userID string) ([]*StreamingSession, error)
	GetMediaSessions(ctx context.Context, mediaID string, limit int32) ([]*StreamingSession, error)
	CleanupExpiredSessions(ctx context.Context, maxAge time.Duration) error
	SetSessionTTL(ttl time.Duration)
}

type MediaStorage interface {
	GetManifestPath(mediaID string, format MediaFormat, quality Quality) string
	GetSegmentPath(mediaID string, quality Quality, segmentIndex int) string
	GetMediaMetadata(mediaID string) (*MediaMetadata, error)
	ManifestExists(mediaID string, format MediaFormat) (bool, error)
	GetKeyframeData(mediaID string, quality Quality) ([]byte, error)
}

type MediaStreamer interface {
	// Manifest generation
	GenerateHLSManifest(mediaID string) (*HLSManifest, error)
	GenerateDASHManifest(mediaID string) (*DASHManifest, error)

	// Segment management
	GetSegmentURL(mediaID string, quality Quality, segment int) (string, error)
	GetSegmentURLs(mediaID string, quality Quality, startSegment, count int) ([]string, error)

	// Bandwidth tracking
	TrackBandwidth(userID string, bytesTransferred int64) error
	GetBandwidthStats(userID string) (*BandwidthStats, error)

	// Quality selection
	GetOptimalQuality(userID string, availableBandwidth int) Quality
	GetAvailableQualities(mediaID string) ([]QualityInfo, error)

	// Session management
	StartSession(userID, mediaID string, format MediaFormat) (*StreamingSession, error)
	UpdateSession(sessionID string, quality Quality, segmentIndex int, bytesTransferred int64) error
	EndSession(sessionID string) error
	GetSession(sessionID string) (*StreamingSession, error)
}

type MetricsTracker struct {
	// contains filtered or unexported fields
}

type Period struct {
	ID             string          `xml:"id,attr"`
	Start          string          `xml:"start,attr,omitempty"`
	Duration       string          `xml:"duration,attr,omitempty"`
	AdaptationSets []AdaptationSet `xml:"AdaptationSet"`
}

type Preferences struct {
	Username                string `json:"username"`
	DeviceID                string `json:"device_id,omitempty"`
	DefaultQuality          string `json:"default_quality,omitempty"`
	AutoQuality             bool   `json:"auto_quality"`
	PreloadNext             bool   `json:"preload_next"`
	DataSaverMode           bool   `json:"data_saver_mode"`
	PreferredCodec          string `json:"preferred_codec,omitempty"`
	MaxBandwidthMbps        int64  `json:"max_bandwidth_mbps,omitempty"`
	BufferSizeSeconds       int    `json:"buffer_size_seconds,omitempty"`
	HDREnabled              bool   `json:"hdr_enabled"`
	ColorSpace              string `json:"color_space,omitempty"`
	SubtitleEnabled         bool   `json:"subtitle_enabled"`
	SubtitleLanguage        string `json:"subtitle_language,omitempty"`
	AudioDescriptionEnabled bool   `json:"audio_description_enabled"`
	ClosedCaptionsEnabled   bool   `json:"closed_captions_enabled"`
	Version                 int    `json:"version"`
	SchemaVersion           int    `json:"schema_version"`
}

type ProcessingStatus string

type Quality = types.Quality

type QualityCodecInfo struct {
	VideoCodec string `json:"video_codec"` // H.264 profile/level string like "avc1.640028"
	AudioCodec string `json:"audio_codec"` // Audio codec string like "mp4a.40.2"
	Bandwidth  int    `json:"bandwidth"`   // Required bandwidth in bps
	Width      int    `json:"width"`       // Video width in pixels
	Height     int    `json:"height"`      // Video height in pixels
}

type QualityInfo struct {
	Quality    Quality
	Width      int
	Height     int
	Bitrate    int    // in kbps
	Bandwidth  int    // required bandwidth in kbps
	Resolution string // e.g., "1920x1080"
}

type QualityMetrics struct {
	SessionID         string
	AverageQuality    Quality
	QualitySwitches   int
	RebufferEvents    int
	TimeInEachQuality map[Quality]time.Duration
	LastQualityChange time.Time
}

type QualitySelector interface {
	SelectQuality(bandwidth int, bufferHealth float64, availableQualities []Quality) Quality
	UpdateMetrics(sessionID string, rebufferEvents int, qualitySwitches int)
	GetQualityMetrics(sessionID string) *QualityMetrics
}

type Representation struct {
	ID              string      `xml:"id,attr"`
	Bandwidth       int         `xml:"bandwidth,attr"`
	Width           int         `xml:"width,attr"`
	Height          int         `xml:"height,attr"`
	Codecs          string      `xml:"codecs,attr"`
	BaseURL         BaseURL     `xml:"BaseURL"`
	SegmentTemplate interface{} `xml:"SegmentTemplate"`
}

type S3MediaStorage struct {
	// contains filtered or unexported fields
}

type Segment struct {
	Index    int
	Duration float64 // in seconds
	URL      string
	Size     int64 // in bytes
}

type SegmentTemplate struct {
	Media          string `xml:"media,attr"`
	Initialization string `xml:"initialization,attr"`
	StartNumber    int    `xml:"startNumber,attr"`
	Duration       int    `xml:"duration,attr"`
	Timescale      int    `xml:"timescale,attr"`
}

type SessionManager struct {
	// contains filtered or unexported fields
}

type SessionMetrics struct {
	SessionID  string
	UserID     string
	MediaID    string
	StartTime  time.Time
	LastUpdate time.Time

	// Quality tracking
	CurrentQuality    Quality
	QualitySwitches   int
	TimeInEachQuality map[Quality]time.Duration
	LastQualityChange time.Time

	// Rebuffer tracking
	RebufferEvents    int
	TotalRebufferTime time.Duration
	LastRebufferTime  time.Time

	// Performance metrics
	StartupTime        time.Duration
	SegmentSuccessRate float64
	TotalSegments      int
	FailedSegments     int
	BytesTransferred   int64

	// Buffer health history
	BufferHealthHistory []BufferHealthSample

	// QoE calculation
	QoEScore      float64
	LastQoEUpdate time.Time
}

type Streamer struct {
	// contains filtered or unexported fields
}

type StreamingConfig struct {
	CDNBaseURL         string
	S3Bucket           string
	S3Region           string
	SegmentDuration    int // in seconds
	ManifestCacheTTL   time.Duration
	MaxConcurrentJobs  int
	EnableCostTracking bool
	DefaultQuality     Quality

	// Bandwidth thresholds for quality selection (in kbps)
	Bandwidth4K    int
	Bandwidth1080p int
	Bandwidth720p  int
	Bandwidth480p  int
	Bandwidth360p  int
	Bandwidth240p  int
}

type StreamingError struct {
	Code    string
	Message string
	MediaID string
	Details map[string]any
}

type StreamingSession = types.StreamingSession

type SubtitleTrack struct {
	Name       string
	Language   string
	URI        string
	Default    bool
	AutoSelect bool
	Forced     bool
}