VideoStream/service/tool.go

package service

import (
	"VideoStream/dao"
	"VideoStream/proto"
	"VideoStream/worker"
	"fmt"
	"gocv.io/x/gocv"
	"image"
	"image/color"
	"log"
	"net/http"
	"sync"
	"time"
)

var DeviceRWMap = &sync.Map{}

// var DeviceCurrentFrameMap = &sync.Map{}
var DeviceFrameCount map[int]int
var DeviceIsGettingFrame = &sync.Map{}
var Device1CurrentFrame gocv.Mat
var Device50CurrentFrame gocv.Mat
var Device73CurrentFrame gocv.Mat

func SetDeviceCurrentFrame(frame *gocv.Mat, device_id int) error {
	//获取读写锁
	mutex_, ok := DeviceRWMap.Load(device_id)
	if !ok {
		return fmt.Errorf("设备:%s 读写锁不存在", device_id)
	}
	mutex := mutex_.(*sync.RWMutex)
	mutex.Lock()
	defer mutex.Unlock()
	//设置当前帧
	switch device_id {
	case 1:
		if Device1CurrentFrame.Empty() {
			Device1CurrentFrame = gocv.NewMatWithSize((*frame).Rows(), (*frame).Cols(), (*frame).Type())
		}
		(*frame).CopyTo(&Device1CurrentFrame)
	case 50:
		if Device50CurrentFrame.Empty() {
			Device50CurrentFrame = gocv.NewMatWithSize((*frame).Rows(), (*frame).Cols(), (*frame).Type())
		}
		(*frame).CopyTo(&Device50CurrentFrame)
	case 73:
		if Device73CurrentFrame.Empty() {
			Device73CurrentFrame = gocv.NewMatWithSize((*frame).Rows(), (*frame).Cols(), (*frame).Type())
		}
		(*frame).CopyTo(&Device73CurrentFrame)
	}

	frameCount, ok := DeviceFrameCount[device_id]
	if !ok {
		return fmt.Errorf("设备:%s 当前帧计数不存在", device_id)
	}
	frameCount++
	DeviceFrameCount[device_id] = frameCount
	return nil
}

func GetDeviceCurrentFrameV2(frame *gocv.Mat, deviceId int) int {
	defer func() {
		if err := recover(); err != nil {
			log.Printf("设备:%d 错误: %v\n", deviceId, err)
		}
	}()
	//获取读写锁
	mutex_, ok := DeviceRWMap.Load(deviceId)
	if !ok {
		log.Printf("DeviceRWMap 读写锁不存在，device_id: %d \n", deviceId)
		return -1
	}
	mutex, ok := mutex_.(*sync.RWMutex)
	if !ok {
		log.Printf("DeviceRWMap 存储的不是 *sync.RWMutex 类型，device_id: %d \n", deviceId)
		return -1
	}
	mutex.RLock()
	defer mutex.RUnlock()
	//获取当前帧
	switch deviceId {
	case 1:
		if frame.Empty() {
			*frame = gocv.NewMatWithSize(Device1CurrentFrame.Rows(), Device1CurrentFrame.Cols(), Device1CurrentFrame.Type())
		}
		Device1CurrentFrame.CopyTo(frame)
	case 50:
		if frame.Empty() {
			*frame = gocv.NewMatWithSize(Device50CurrentFrame.Rows(), Device50CurrentFrame.Cols(), Device50CurrentFrame.Type())
		}
		Device50CurrentFrame.CopyTo(frame)
	case 73:
		if frame.Empty() {
			*frame = gocv.NewMatWithSize(Device73CurrentFrame.Rows(), Device73CurrentFrame.Cols(), Device73CurrentFrame.Type())
		}
		Device73CurrentFrame.CopyTo(frame)

	}

	frameCount, ok := DeviceFrameCount[deviceId]
	if !ok {
		return -1
	}
	return frameCount
}

func GetDeviceCurrentFrame(deviceId int) (gocv.Mat, int) {
	defer func() {
		if err := recover(); err != nil {
			log.Printf("设备:%d 错误: %v\n", deviceId, err)
		}
	}()

	//获取读写锁
	mutex_, ok := DeviceRWMap.Load(deviceId)
	if !ok {
		log.Printf("DeviceRWMap 读写锁不存在，device_id: %d \n", deviceId)
		return gocv.NewMat(), -1
	}
	mutex, ok := mutex_.(*sync.RWMutex)
	if !ok {
		log.Printf("DeviceRWMap 存储的不是 *sync.RWMutex 类型，device_id: %d \n", deviceId)
		return gocv.NewMat(), -1
	}
	mutex.RLock()
	defer mutex.RUnlock()
	var ret gocv.Mat
	if ret.Empty() {

	}
	//获取当前帧
	switch deviceId {
	case 1:
		if ret.Empty() {
			ret = gocv.NewMatWithSize(Device1CurrentFrame.Rows(), Device1CurrentFrame.Cols(), Device1CurrentFrame.Type())
		}
		Device1CurrentFrame.CopyTo(&ret)
	case 50:
		if ret.Empty() {
			ret = gocv.NewMatWithSize(Device50CurrentFrame.Rows(), Device50CurrentFrame.Cols(), Device50CurrentFrame.Type())
		}
		Device50CurrentFrame.CopyTo(&ret)
	case 73:
		if ret.Empty() {
			ret = gocv.NewMatWithSize(Device73CurrentFrame.Rows(), Device73CurrentFrame.Cols(), Device73CurrentFrame.Type())
		}
		Device73CurrentFrame.CopyTo(&ret)
	}
	frameCount, ok := DeviceFrameCount[deviceId]
	if !ok {
		log.Printf("设备:%d 当前帧计数不存在\n", deviceId)
		frameCount = -1
	}
	return ret, frameCount
}

func getVideoFrame(device proto.DeviceInfo) {
	//捕获异常
	defer func() {
		if err := recover(); err != nil {
			log.Printf("设备:%d 错误: %v\n", device.ID, err)
		}
	}()

	webcam, err := gocv.OpenVideoCapture(device.Stream)
	if err != nil {
		log.Printf("设备:%d 错误: 无法打开视频流，err: %v\n", device.ID, err)
		return
	}
	defer func(webcam *gocv.VideoCapture) {
		err2 := webcam.Close()
		if err2 != nil {
			log.Printf("设备:%d 错误: 无法关闭视频流,%s \n", device.ID, err2.Error())
		}
	}(webcam)
	// 字体相关设置，对应OpenCV默认字体等，这里简化处理，实际可按需求调整
	font := gocv.FontHersheySimplex
	fontScale := 0.5
	fontColor := color.RGBA{G: 255}
	lineType := 2
	z := 0
	var frame gocv.Mat
	frame = gocv.NewMat()
	for {
		if device.LogFrame > 0 && z%device.LogFrame == 0 {
			log.Printf("设备:%d 当前帧: %d\n", device.ID, z)
		}
		if device.NextStop {
			break
		}
		ok := webcam.Read(&frame)
		if !ok {
			log.Printf("设备:%v 错误: 无法从视频流中读取帧\n", device)
			break
		}
		if frame.Empty() {
			log.Printf("设备:%s 错误: 无法从视频流中读取帧\n", device)
			//等待50ms
			time.Sleep(50 * time.Millisecond)
			continue
		}
		height := frame.Rows()
		width := frame.Cols()
		if height < device.CheckFrameHeight || width < device.CheckFrameWidth {
			log.Printf("设备:%s 帧尺寸已改变\n", device)
			break
		}
		currentTime := time.Now().Format("2006-01-02 15:04:05")
		gocv.PutText(&frame, currentTime, image.Point{X: 10, Y: 20}, font, fontScale, fontColor, lineType)
		//需要将帧付给全局变量
		err3 := SetDeviceCurrentFrame(&frame, device.ID)
		if err3 != nil {
			log.Printf("设备:%d 错误: 无法设置当前帧,err:%s \n", device.ID, err3.Error())
		}
		z++
	}
	err2 := frame.Close()
	if err2 != nil {
		log.Printf("设备:%d 错误: 无法释放帧资源,err:%s \n", device.ID, err.Error())
	}
}

// 发起get请求,返回响应状态码
func Get(url string) int {
	req, err := http.NewRequest("GET", url, nil)
	var client = &http.Client{}
	if err != nil {
		return 500
	}
	resp, err := client.Do(req)
	if err != nil {
		return 500
	}
	return resp.StatusCode
}

func GetVideoStream(id int) {
	defer func() {
		if err := recover(); err != nil {
			log.Printf("设备:%d 错误: %v\n", id, err)
		}
	}()
	is_get, ok := DeviceIsGettingFrame.Load(id)
	if !ok {
		log.Printf("device: %d  not found", id)
		return
	}
	if is_get == true {
		log.Printf("device: %d is running!", id)
		return
	}
	for {
		var device proto.DeviceInfo
		var index int
		//获取设备信息
		for i, device1 := range proto.Config.DeviceInfo {
			if device1.ID == id {
				device = device1
				break
			}
			index = i
		}
		if index == len(proto.Config.DeviceInfo) {
			//设备不存在
			log.Printf("device: %d not found", id)
			break
		}
		is_get, ok = DeviceIsGettingFrame.Load(id)
		if is_get == true {
			log.Printf("for device:%d is running!", id)
			break
		}

		if device.NextStop {
			DeviceIsGettingFrame.Store(id, false)
			break
		}
		//设置设备控制信息
		status := Get(device.Control)
		DeviceIsGettingFrame.Store(id, true)
		log.Printf("device: %d set control info status: %d", device.ID, status)
		getVideoFrame(device)
		DeviceIsGettingFrame.Store(id, false)
		//等待1s
		time.Sleep(1 * time.Second)
	}

}

func DoGetVideoStream() {
	for _, device := range proto.Config.DeviceInfo {
		go GetVideoStream(device.ID)
	}
}

func GetDevice(id, auth_id int) dao.Device {
	return dao.FindDeviceByID(id, auth_id)
}

func SetConfigRedis(key, config string) {
	worker.SetRedis(key, config)
}