Refactoring.

writer/cmd/main.go

@@ -2,13 +2,12 @@ package main
 
 import (
 	"flag"
+	"git.insit.tech/psa/rtsp_reader-writer/writer/internal/config"
+	"git.insit.tech/psa/rtsp_reader-writer/writer/internal/ingest/rtsp"
 	"log"
-	"writer/internal/config"
-	"writer/internal/procRTSP"
 )
 
 func main() {
-
 	directory := flag.String("dir", "/home/psa/GoRepository", "directory")
 	flag.Parse()
 
@@ -23,9 +22,9 @@ func main() {
 		log.Printf("start recording on camera: %s\n", link)
 
 		go func() {
-			err = procRTSP.ProcRTSP(*directory, 1, link)
+			err = rtsp.RTSP(*directory, 60, link)
 			if err != nil {
-				panic(err)
+				log.Printf("procRTSP function error for camera %s: %s", link, err.Error())
 			}
 		}()
 	}

writer/go.mod

@@ -1,4 +1,4 @@
-module writer
+module git.insit.tech/psa/rtsp_reader-writer
 
 go 1.23.6
 

writer/internal/auth/auth.go

@@ -0,0 +1 @@
+package auth

writer/internal/config/parser.go

@@ -0,0 +1,23 @@
+package config
+
+import (
+	"gopkg.in/yaml.v3"
+	"os"
+)
+
+// ParseCamerasYAML parses camera links from YAML file into struct Cameras.
+func ParseCamerasYAML(dir string) (map[string]string, error) {
+	var CamerasYAML map[string]string
+
+	data, err := os.ReadFile(dir + "/rtsp_reader-writer/writer/internal/config/source.yaml")
+	if err != nil {
+		return CamerasYAML, err
+	}
+
+	err = yaml.Unmarshal(data, &CamerasYAML)
+	if err != nil {
+		return CamerasYAML, err
+	}
+
+	return CamerasYAML, nil
+}

writer/internal/config/source.yaml

@@ -32,5 +32,5 @@
 #camera_32:     rtsp://intercom-video-1.insit.ru/dp-woxvkbynctgfbuztsalttgburbpvjf
 #camera_33:     rtsp://intercom-video-1.insit.ru/dp-fdzbasqehtptsuhxnjeqqnlrixfahcgvlcr
 #camera_34:     rtsp://intercom-video-1.insit.ru/dp-exyeqscyamrbkwkjifagouyprtsdoe
-camera_35:     rtsp://intercom-video-2.insit.ru/dp-sutyagina3a-iv-uujtwbsjekv
+#camera_35:     rtsp://intercom-video-2.insit.ru/dp-sutyagina3a-iv-uujtwbsjekv
 camera_36:     rtsp://intercom-video-1.insit.ru/dp-wyshispseamhqmnhkqwkbarshnrvni

writer/internal/ingest/rtsp/g711.go

@@ -1,4 +1,4 @@
-package media
+package rtsp
 
 import (
 	"errors"

writer/internal/ingest/rtsp/h264.go

@@ -1,4 +1,4 @@
-package media
+package rtsp
 
 import (
 	"errors"

writer/internal/ingest/rtsp/pcm_to_aac.go

@@ -1,4 +1,4 @@
-package converter
+package rtsp
 
 import (
 	"bytes"

writer/internal/ingest/rtsp/rtsp.go

@@ -1,8 +1,10 @@
-package procRTSP
+package rtsp
 
 import (
 	"errors"
 	"fmt"
+	"git.insit.tech/psa/rtsp_reader-writer/writer/internal/storage"
+	"git.insit.tech/psa/rtsp_reader-writer/writer/pkg/converter"
 	"git.insit.tech/sas/rtsp_proxy/protos/gens"
 	"github.com/bluenviron/gortsplib/v4"
 	"github.com/bluenviron/gortsplib/v4/pkg/base"
@@ -14,14 +16,11 @@ import (
 	"os"
 	"strings"
 	"time"
-	"writer/internal/config"
-	"writer/internal/media"
-	"writer/pkg/converter"
 )
 
 // StartWriter starts the program.
 func StartWriter(dir string, period int, URI string) error {
-	err := ProcRTSP(dir, period, URI)
+	err := RTSP(dir, period, URI)
 	if err != nil {
 
 		// Temporary solution for inner cameras.
@@ -36,19 +35,14 @@ func StartWriter(dir string, period int, URI string) error {
 	return nil
 }
 
-// ProcRTSP process RTSP protocol and writes H264 and PCM flows into TS container.
-func ProcRTSP(dir string, period int, link string) error {
+// RTSP processes RTSP protocol.
+func RTSP(dir string, period int, link string) error {
 	resolutions := []string{"1280x720"}
 
-	// Return the last part of the URI after "/".
-	cuttedURI := config.CutURI(link)
+	// Create file name structure and directory for files.
+	cuttedURI := storage.CutURI(link)
+	fn := storage.CreateFileName(dir, resolutions, cuttedURI, period)
 
-	// Create FileName structure
-	fn := config.CreateFileName(dir, resolutions, cuttedURI, period)
-
-	////////////////////////////////////////////////////////////////////////////////////////
-
-	// Create directory for files according to resolutions.
 	err := os.MkdirAll(fmt.Sprintf("%s", fn.Path), 0755)
 	if err != nil {
 		return fmt.Errorf("mkdirall error: %w", err)
@@ -57,48 +51,42 @@ func ProcRTSP(dir string, period int, link string) error {
 	// Create M3U8 playlist.
 	go gens.MediaPlaylistGenerator(dir+"/data/"+cuttedURI, "", fn.Duration, resolutions)
 
-	////////////////////////////////////////////////////////////////////////////////////////
-
-	// Initialise client.
+	// Connect to the server.
 	c := gortsplib.Client{
 		UserAgent: "PSA",
 	}
 
-	// Parse URL.
 	u, err := base.ParseURL(link)
 	if err != nil {
 		return fmt.Errorf("parse URL error: %w", err)
 	}
 
-	// Connect to the server.
 	err = c.Start(u.Scheme, u.Host)
 	if err != nil {
 		return fmt.Errorf("connect to the server error: %w", err)
 	}
 	defer c.Close()
 
-	// Find available medias.
-	desc, _, err := c.Describe(u)
+	desc, r, err := c.Describe(u)
 	if err != nil || desc == nil {
 		log.Printf("medias not found for camera [%s]: %v", link, err)
 		return nil
 	}
 
-	////////////////////////////////////////////////////////////////////////////////////////
+	///////////////
 
-	// Find the H264 media and format.
+	// Find formats.
 	//var run bool
-	h264Format, h264Media, err := media.CheckH264Format(desc)
+	h264Format, h264Media, err := CheckH264Format(desc)
 	if err != nil {
 		log.Printf("H264 format not found: %v", err)
 		//run = true
 	}
 
-	//// Find the G711 media and format.
-	//g711Format, g711Media, err := media.CheckG711Format(desc)
+	//g711Format, g711Media, err := CheckG711Format(desc)
 	//if err != nil {
 	//	log.Printf("G711 format not found: %v", err)
-	//	run = true
+	//	// run = true
 	//}
 
 	// Initialising variable for AAC.
@@ -120,7 +108,7 @@ func ProcRTSP(dir string, period int, link string) error {
 	////////////////////////////////////////////////////////////////////////////////////////
 
 	// Wait for the next period.
-	config.Waiter(period)
+	storage.WaitPeriod(period)
 	log.Println("Start recording")
 
 	////////////////////////////////////////////////////////////////////////////////////////
@@ -153,7 +141,7 @@ func ProcRTSP(dir string, period int, link string) error {
 		switch forma.(type) {
 		case *format.H264:
 			// Process H264 flow and return PTS and AU.
-			pts, au, err := media.ProcH264(&c, h264Media, h264RTPDec, pkt)
+			pts, au, err := ProcH264(&c, h264Media, h264RTPDec, pkt)
 			if err != nil {
 				//log.Printf("%s: process H264 error: %s\n", cuttedURI, err)
 			}
@@ -197,7 +185,7 @@ func ProcRTSP(dir string, period int, link string) error {
 	}
 
 	// Create ticker for rotation files.
-	ticker := time.NewTicker(time.Duration(period) * time.Minute)
+	ticker := time.NewTicker(time.Duration(period) * time.Second)
 	defer ticker.Stop()
 
 	// Rotate files.
@@ -234,12 +222,12 @@ func changeDomain(directory string, period int, URI string, err error) error {
 	err2 := errors.New("404 (Not found)")
 	if errors.As(err, &err2) {
 		if strings.Contains(URI, "video-1") {
-			err = ProcRTSP(directory, period, strings.Replace(URI, "video-1", "video-2", 1))
+			err = RTSP(directory, period, strings.Replace(URI, "video-1", "video-2", 1))
 			if err != nil {
 				return err
 			}
 		} else {
-			err = ProcRTSP(directory, period, strings.Replace(URI, "video-2", "video-1", 1))
+			err = RTSP(directory, period, strings.Replace(URI, "video-2", "video-1", 1))
 			if err != nil {
 				return err
 			}

writer/internal/storage/file.go

@@ -0,0 +1,19 @@
+package storage
+
+import "time"
+
+type Segment struct {
+	Start    time.Time
+	Duration time.Duration
+
+	H264 byte
+	G711 byte
+
+	SPS []byte
+	PPS []byte
+}
+
+type StreamRecord struct {
+	ID       string
+	Segments []Segment
+}

writer/internal/storage/segmenter.go

@@ -0,0 +1 @@
+package storage

writer/pkg/parser/parser.go

@@ -1 +0,0 @@
-package parser