Add seg size to segment.json

js/app/components/mobile/ui.tsx

···
 } from "@streamplace/components";
 import { ChevronLeft, SwitchCamera, VolumeX } from "lucide-react-native";
 import { useEffect, useRef, useState } from "react";
-import { Image, Pressable, TouchableWithoutFeedback } from "react-native";
+import { Image, Pressable } from "react-native";
 import Animated, {
   useAnimatedStyle,
   useSharedValue,
···
 
   return (
     <>
-      <TouchableWithoutFeedback onPress={resetFadeTimer}>
+      <Pressable onPress={resetFadeTimer}>
         <Animated.View
           style={[
             layout.position.absolute,
···
             duration={5}
           />
         </Animated.View>
-      </TouchableWithoutFeedback>
+      </Pressable>
 
       {!isSelfAndNotLive && (
         <MobileChatPanel isPlayerRatioGreater={isPlayerRatioGreater} />

js/docs/src/content/docs/lex-reference/place-stream-segment.md

···
 | `creator`    | `string`                    | ✅    |                                                  | Format: `did`      |
 | `video`      | Array of [`#video`](#video) | ❌    |                                                  |                    |
 | `audio`      | Array of [`#audio`](#audio) | ❌    |                                                  |                    |
+| `size`       | `integer`                   | ❌    | The size of the segment in bytes                 |                    |
 
 ---
 
···
               "type": "ref",
               "ref": "#audio"
             }
+          },
+          "size": {
+            "type": "integer",
+            "description": "The size of the segment in bytes"
           }
         }
       }

lexicons/place/stream/segment.json

···
               "type": "ref",
               "ref": "#audio"
             }
+          },
+          "size": {
+            "type": "integer",
+            "description": "The size of the segment in bytes"
           }
         }
       }

pkg/director/stream_session.go

···
 	}()
 	aqt := aqtime.FromTime(not.Segment.StartTime)
 	ctx = log.WithLogValues(ctx, "segID", not.Segment.ID, "repoDID", not.Segment.RepoDID, "timestamp", aqt.FileSafeString())
+	not.Segment.MediaData.SizeB = len(not.Data)
 	err := ss.mod.CreateSegment(not.Segment)
 	if err != nil {
 		return fmt.Errorf("could not add segment to database: %w", err)

pkg/media/validate.go

···
 		RepoDID:       repoDID,
 		StartTime:     meta.StartTime.Time(),
 		Title:         meta.Title,
+		SizeB:         len(buf),
 		MediaData:     mediaData,
 	}
 	mm.newSegmentSubsMutex.RLock()

pkg/model/segment.go

···
 	Video    []*SegmentMediadataVideo `json:"video"`
 	Audio    []*SegmentMediadataAudio `json:"audio"`
 	Duration int64                    `json:"duration"`
+	SizeB    int                      `json:"sizeB"`
 }
 
 // Scan scan value into Jsonb, implements sql.Scanner interface
-func (j *SegmentMediaData) Scan(value interface{}) error {
+func (j *SegmentMediaData) Scan(value any) error {
 	bytes, ok := value.([]byte)
 	if !ok {
 		return errors.New(fmt.Sprint("Failed to unmarshal JSONB value:", value))
···
 	RepoDID       string            `json:"repoDID"              gorm:"index:latest_segments;column:repo_did"`
 	Repo          *Repo             `json:"repo,omitempty"       gorm:"foreignKey:DID;references:RepoDID"`
 	Title         string            `json:"title"`
+	SizeB         int               `json:"sizeB"                gorm:"column:size_b"`
 	MediaData     *SegmentMediaData `json:"mediaData,omitempty"`
 }
 
···
 		return nil, fmt.Errorf("audio data is nil")
 	}
 	duration := s.MediaData.Duration
+	sizei64 := int64(s.SizeB)
 	return &streamplace.Segment{
 		LexiconTypeID: "place.stream.segment",
 		Creator:       s.RepoDID,
···
 		SigningKey:    s.SigningKeyDID,
 		StartTime:     string(aqt),
 		Duration:      &duration,
+		Size:          &sizei64,
 		Video: []*streamplace.Segment_Video{
 			{
 				Codec:  "h264",

pkg/streamplace/cbor_gen.go

···
 	}
 
 	cw := cbg.NewCborWriter(w)
-	fieldCount := 8
+	fieldCount := 9
 
 	if t.Audio == nil {
 		fieldCount--
 	}
 
 	if t.Duration == nil {
+		fieldCount--
+	}
+
+	if t.Size == nil {
 		fieldCount--
 	}
 
···
 	}
 	if _, err := cw.WriteString(string(t.Id)); err != nil {
 		return err
+	}
+
+	// t.Size (int64) (int64)
+	if t.Size != nil {
+
+		if len("size") > 1000000 {
+			return xerrors.Errorf("Value in field \"size\" was too long")
+		}
+
+		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("size"))); err != nil {
+			return err
+		}
+		if _, err := cw.WriteString(string("size")); err != nil {
+			return err
+		}
+
+		if t.Size == nil {
+			if _, err := cw.Write(cbg.CborNull); err != nil {
+				return err
+			}
+		} else {
+			if *t.Size >= 0 {
+				if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(*t.Size)); err != nil {
+					return err
+				}
+			} else {
+				if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-*t.Size-1)); err != nil {
+					return err
+				}
+			}
+		}
+
 	}
 
 	// t.LexiconTypeID (string) (string)
···
 				}
 
 				t.Id = string(sval)
+			}
+			// t.Size (int64) (int64)
+		case "size":
+			{
+
+				b, err := cr.ReadByte()
+				if err != nil {
+					return err
+				}
+				if b != cbg.CborNull[0] {
+					if err := cr.UnreadByte(); err != nil {
+						return err
+					}
+					maj, extra, err := cr.ReadHeader()
+					if err != nil {
+						return err
+					}
+					var extraI int64
+					switch maj {
+					case cbg.MajUnsignedInt:
+						extraI = int64(extra)
+						if extraI < 0 {
+							return fmt.Errorf("int64 positive overflow")
+						}
+					case cbg.MajNegativeInt:
+						extraI = int64(extra)
+						if extraI < 0 {
+							return fmt.Errorf("int64 negative overflow")
+						}
+						extraI = -1 - extraI
+					default:
+						return fmt.Errorf("wrong type for int64 field: %d", maj)
+					}
+
+					t.Size = (*int64)(&extraI)
+				}
 			}
 			// t.LexiconTypeID (string) (string)
 		case "$type":

pkg/streamplace/streamsegment.go

···
 	Id string `json:"id" cborgen:"id"`
 	// signingKey: The DID of the signing key used for this segment
 	SigningKey string `json:"signingKey" cborgen:"signingKey"`
+	// size: The size of the segment in bytes
+	Size *int64 `json:"size,omitempty" cborgen:"size,omitempty"`
 	// startTime: When this segment started
 	StartTime string           `json:"startTime" cborgen:"startTime"`
 	Video     []*Segment_Video `json:"video,omitempty" cborgen:"video,omitempty"`