bug fixed declaration

zhangmeng

2021-05-25 7950b86a4bf821e126d5e5659b772ce32faa1445

 goffmpeg.go

@@ -13,6 +13,8 @@
)

const (
   // ScaleNone self add no scale raw frame data
   ScaleNone = 0
   // ScaleFastBilinear SWS_FAST_BILINEAR
   ScaleFastBilinear = 1
   // ScaleBilinear SWS_BILINEAR
@@ -37,6 +39,12 @@
   ScaleSpline = 0x400
)

// SrcFormat format NV
const SrcFormat = 23

// DstFormat format
const DstFormat = 3

var libcffmpeg C.libcffmpeg

// InitFFmpeg init ffmepg
@@ -59,39 +67,83 @@
   }
}

// Config config
type Config struct {
   Scale  int
   Width  int
   Height int
   GB     bool
   CPU    bool
}

// GoFFMPEG handle for c
type GoFFMPEG struct {
   ffmpeg C.cffmpeg
}

// New 2nd new
func New(conf Config) *GoFFMPEG {
func New(GB, CPU bool) *GoFFMPEG {

   var l *C.char

   logit := 0
   f := C.wrap_fn_create(C.int(logit), l)
   f := C.wrap_fn_create(unsafe.Pointer(libcffmpeg))

   if f == nil {
      return nil
   }
   if conf.Scale != 0 && conf.Width != 0 && conf.Height != 0 {
      C.wrap_fn_scale(f, C.int(conf.Width), C.int(conf.Height), C.int(conf.Scale))
   if GB {
      C.wrap_fn_run_gb28181(unsafe.Pointer(libcffmpeg), f)
   }
   if conf.GB {
      C.wrap_fn_run_gb28181(f)
   if CPU {
      C.wrap_fn_use_cpu(unsafe.Pointer(libcffmpeg), f)
   }
   if conf.CPU {
      C.wrap_fn_use_cpu(f)

   return &GoFFMPEG{
      ffmpeg: f,
   }
}

// NewWithDevID 2nd new
func NewWithDevID(GB, CPU bool, devID int) *GoFFMPEG {

   f := C.wrap_fn_create(unsafe.Pointer(libcffmpeg))

   if f == nil {
      return nil
   }
   if GB {
      C.wrap_fn_run_gb28181(unsafe.Pointer(libcffmpeg), f)
   }
   if CPU {
      C.wrap_fn_use_cpu(unsafe.Pointer(libcffmpeg), f)
   } else if devID > -1 {
      r := C.wrap_fn_set_devid(unsafe.Pointer(libcffmpeg), f, C.int(devID))
      if r != 0 {
         if f != nil {
            C.wrap_fn_destroy(unsafe.Pointer(libcffmpeg), f)
         }
         FreeFFmpeg()
         return nil
      }
   }

   return &GoFFMPEG{
      ffmpeg: f,
   }
}

// NewWithLogAndDevID log
func NewWithLogAndDevID(GB, CPU bool, devID int, ffmpegLog string) *GoFFMPEG {
   lf := C.CString(ffmpegLog)
   defer C.free(unsafe.Pointer(lf))

   f := C.wrap_fn_create2(unsafe.Pointer(libcffmpeg), lf)
   if f == nil {
      return nil
   }
   if GB {
      C.wrap_fn_run_gb28181(unsafe.Pointer(libcffmpeg), f)
   }
   if CPU {
      C.wrap_fn_use_cpu(unsafe.Pointer(libcffmpeg), f)
   } else if devID > -1 {
      r := C.wrap_fn_set_devid(unsafe.Pointer(libcffmpeg), f, C.int(devID))
      if r != 0 {
         if f != nil {
            C.wrap_fn_destroy(unsafe.Pointer(libcffmpeg), f)
         }
         FreeFFmpeg()
         return nil
      }
   }

   return &GoFFMPEG{
@@ -100,23 +152,19 @@
}

// NewWithLog log
func NewWithLog(conf Config, logfile string) *GoFFMPEG {
   lf := C.CString(logfile)
func NewWithLog(GB, CPU bool, ffmpegLog string) *GoFFMPEG {
   lf := C.CString(ffmpegLog)
   defer C.free(unsafe.Pointer(lf))

   logit := 1
   f := C.wrap_fn_create(C.int(logit), lf)
   f := C.wrap_fn_create2(unsafe.Pointer(libcffmpeg), lf)
   if f == nil {
      return nil
   }
   if conf.Scale != 0 && conf.Width != 0 && conf.Height != 0 {
      C.wrap_fn_scale(f, C.int(conf.Width), C.int(conf.Height), C.int(conf.Scale))
   if GB {
      C.wrap_fn_run_gb28181(unsafe.Pointer(libcffmpeg), f)
   }
   if conf.GB {
      C.wrap_fn_run_gb28181(f)
   }
   if conf.CPU {
      C.wrap_fn_use_cpu(f)
   if CPU {
      C.wrap_fn_use_cpu(unsafe.Pointer(libcffmpeg), f)
   }

   return &GoFFMPEG{
@@ -126,7 +174,9 @@

// Free free handle
func (h *GoFFMPEG) Free() {
   C.wrap_fn_destroy(h.ffmpeg)
   if h.ffmpeg != nil {
      C.wrap_fn_destroy(unsafe.Pointer(libcffmpeg), h.ffmpeg)
   }
}

// Run ffmpeg
@@ -134,162 +184,39 @@
   in := C.CString(input)
   defer C.free(unsafe.Pointer(in))

   C.wrap_fn_run(h.ffmpeg, in)
   C.wrap_fn_run(unsafe.Pointer(libcffmpeg), h.ffmpeg, in)
}

// FireRecorder fire recorder
func (h *GoFFMPEG) FireRecorder(sid string, id int64) {
   csid := C.CString(sid)
   defer C.free(unsafe.Pointer(csid))
   C.wrap_fn_fire_recorder(h.ffmpeg, csid, C.long(id))
}

// BuildRecorder build recorder
func (h *GoFFMPEG) BuildRecorder(sid, output string, mind, maxd int, audio bool) {
   out := C.CString(output)
   defer C.free(unsafe.Pointer(out))
   csid := C.CString(sid)
   defer C.free(unsafe.Pointer(csid))

   a := 0
   if audio {
      a = 1
   }
   C.wrap_fn_recorder(h.ffmpeg, csid, out, C.int(mind), C.int(maxd), C.int(a))
}

// GetInfoRecorder info
func (h *GoFFMPEG) GetInfoRecorder() (string, int, string) {
   var i C.int = -1

   var id *C.char
   var idl C.int

   var p *C.char
   var pl C.int

   C.wrap_fn_info_recorder(h.ffmpeg, &i, &id, &idl, &p, &pl)
   // if p == nil {
   //    return -1, ""
   // }
   gID := C.GoString(id)
   C.free(unsafe.Pointer(id))
   path := C.GoString(p)
   C.free(unsafe.Pointer(p))

   // fmt.Println("Go get info : ", path, " len: ", l)

   return gID, int(i), path
}

// BuildDecoder build decoder
func (h *GoFFMPEG) BuildDecoder() {
   C.wrap_fn_decoder(h.ffmpeg)
}

// GetPicDecoder get pic from decoder
func (h *GoFFMPEG) GetPicDecoder() ([]byte, int, int, int64) {
   var width C.int
   var height C.int
   var fid C.long

   p := C.wrap_fn_decoder_pic(h.ffmpeg, &width, &height, &fid)
   if width == 0 && height == 0 {
      return nil, 0, 0, 0
   }
   defer C.free(unsafe.Pointer(p))
   d := C.GoBytes(p, width*height*3)
   wid := int(width)
   hei := int(height)
   gfid := int64(fid)
   return d, wid, hei, gfid
}

//GetAVPacket get AVPacket
func (h *GoFFMPEG) GetAVPacket() ([]byte, int, int) {
   var key C.int
   var size C.int

   p := C.wrap_fn_get_avpacket(h.ffmpeg, &size, &key)
   if size <= 0 {
      return nil, 0, -1
   }
   defer C.free(unsafe.Pointer(p))
   d := C.GoBytes(p, size)
   s := int(size)
   k := int(key)

   return d, s, k
}

/////////////// for decoder

// Decode decode jpeg file
// return val: -1 open error; -2, find stream error; -3, converter create error
func Decode(input string, gb bool) ([]byte, int, int) {
// Run2 ffmpeg
func (h *GoFFMPEG) Run2(input string, minDuration int) {
   in := C.CString(input)
   defer C.free(unsafe.Pointer(in))

   withGB := 0
   if gb {
      withGB = 1
   }

   var width C.int
   var height C.int
   p := C.wrap_fn_decode(in, C.int(withGB), &width, &height)
   defer C.free(p)

   if width > 0 && height > 0 {
      data := C.GoBytes(p, width*height*3)
      wid := int(width)
      hei := int(height)
      return data, wid, hei
   }
   return nil, int(width), int(height)
   C.wrap_fn_run(unsafe.Pointer(libcffmpeg), h.ffmpeg, in)
}

///////////////for encoder

// GoEncoder encoder
type GoEncoder struct {
   enc C.cencoder
// FPS fps
func (h *GoFFMPEG) FPS() int {
   return int(C.wrap_fn_fps(unsafe.Pointer(libcffmpeg), h.ffmpeg))
}

// NewEncoder encoder
func NewEncoder(w, h, fps, br, sFlag, gi int) *GoEncoder {
   if w <= 0 || h <= 0 {
      return nil
// ReleaseC release c memory
func ReleaseC(p unsafe.Pointer) {
   if p == nil {
      return
   }

   return &GoEncoder{
      enc: C.wrap_fn_create_encoder(C.int(w), C.int(h), C.int(fps), C.int(br), C.int(sFlag), C.int(gi)),
   }
   C.free(unsafe.Pointer(p))
}

// Free free
func (e *GoEncoder) Free() {
   C.wrap_fn_destroy_encoder(e.enc)
}
// GetGBJpg Get GB28181 Jpg
func GetGBJpg(rtspURL string, maxTry int) []byte {
   rtsp := C.CString(rtspURL)
   defer C.free(unsafe.Pointer(rtsp))
   var jpgLen C.int

// Encode pic
func (e *GoEncoder) Encode(in []byte, w, h int) ([]byte, int, bool) {
   pic := C.wrap_fn_get_gb28181_pic(unsafe.Pointer(libcffmpeg), rtsp, &jpgLen, C.int(maxTry))
   defer C.free(unsafe.Pointer(pic))

   var size C.int
   var key C.int
   cin := C.CBytes(in)
   defer C.free(cin)

   p := C.wrap_fn_encode(e.enc, cin, C.int(w), C.int(h), &size, &key)
   defer C.free(p)
   if p != nil && size > 0 {
      b := C.GoBytes(p, size)

      isKey := false
      if key > 0 {
         isKey = true
      }
      return b, int(size), isKey
   }
   return nil, 0, false
   retJpg := C.GoBytes(unsafe.Pointer(pic), jpgLen)
   return retJpg
}