mirror of
https://github.com/asticode/go-astiav.git
synced 2024-05-28 13:53:18 +08:00
274 lines
6.4 KiB
Go
274 lines
6.4 KiB
Go
package astiav
|
|
|
|
//#cgo pkg-config: libavcodec libavformat
|
|
//#include <libavcodec/avcodec.h>
|
|
//#include <libavformat/avformat.h>
|
|
import "C"
|
|
import (
|
|
"math"
|
|
"unsafe"
|
|
)
|
|
|
|
// https://github.com/FFmpeg/FFmpeg/blob/n5.0/libavformat/avformat.h#L1202
|
|
type FormatContext struct {
|
|
c *C.struct_AVFormatContext
|
|
}
|
|
|
|
func newFormatContextFromC(c *C.struct_AVFormatContext) *FormatContext {
|
|
if c == nil {
|
|
return nil
|
|
}
|
|
fc := &FormatContext{c: c}
|
|
classers.set(fc)
|
|
return fc
|
|
}
|
|
|
|
var _ Classer = (*FormatContext)(nil)
|
|
|
|
func AllocFormatContext() *FormatContext {
|
|
return newFormatContextFromC(C.avformat_alloc_context())
|
|
}
|
|
|
|
func AllocOutputFormatContext(of *OutputFormat, formatName, filename string) (*FormatContext, error) {
|
|
fonc := (*C.char)(nil)
|
|
if len(formatName) > 0 {
|
|
fonc = C.CString(formatName)
|
|
defer C.free(unsafe.Pointer(fonc))
|
|
}
|
|
finc := (*C.char)(nil)
|
|
if len(filename) > 0 {
|
|
finc = C.CString(filename)
|
|
defer C.free(unsafe.Pointer(finc))
|
|
}
|
|
var ofc *C.struct_AVOutputFormat
|
|
if of != nil {
|
|
ofc = of.c
|
|
}
|
|
var fcc *C.struct_AVFormatContext
|
|
if err := newError(C.avformat_alloc_output_context2(&fcc, ofc, fonc, finc)); err != nil {
|
|
return nil, err
|
|
}
|
|
return newFormatContextFromC(fcc), nil
|
|
}
|
|
|
|
func (fc *FormatContext) Free() {
|
|
classers.del(fc)
|
|
C.avformat_free_context(fc.c)
|
|
}
|
|
|
|
func (fc *FormatContext) BitRate() int64 {
|
|
return int64(fc.c.bit_rate)
|
|
}
|
|
|
|
func (fc *FormatContext) Class() *Class {
|
|
return newClassFromC(unsafe.Pointer(fc.c))
|
|
}
|
|
|
|
func (fc *FormatContext) CtxFlags() FormatContextCtxFlags {
|
|
return FormatContextCtxFlags(fc.c.ctx_flags)
|
|
}
|
|
|
|
func (fc *FormatContext) Duration() int64 {
|
|
return int64(fc.c.duration)
|
|
}
|
|
|
|
func (fc *FormatContext) EventFlags() FormatEventFlags {
|
|
return FormatEventFlags(fc.c.event_flags)
|
|
}
|
|
|
|
func (fc *FormatContext) Flags() FormatContextFlags {
|
|
return FormatContextFlags(fc.c.flags)
|
|
}
|
|
|
|
func (fc *FormatContext) SetFlags(f FormatContextFlags) {
|
|
fc.c.flags = C.int(f)
|
|
}
|
|
|
|
func (fc *FormatContext) SetInterruptCallback() IOInterrupter {
|
|
i := newDefaultIOInterrupter()
|
|
fc.c.interrupt_callback = i.c
|
|
return i
|
|
}
|
|
|
|
func (fc *FormatContext) InputFormat() *InputFormat {
|
|
return newInputFormatFromC(fc.c.iformat)
|
|
}
|
|
|
|
func (fc *FormatContext) IOFlags() IOContextFlags {
|
|
return IOContextFlags(fc.c.avio_flags)
|
|
}
|
|
|
|
func (fc *FormatContext) MaxAnalyzeDuration() int64 {
|
|
return int64(fc.c.max_analyze_duration)
|
|
}
|
|
|
|
func (fc *FormatContext) Metadata() *Dictionary {
|
|
return newDictionaryFromC(fc.c.metadata)
|
|
}
|
|
|
|
func (fc *FormatContext) NbStreams() int {
|
|
return int(fc.c.nb_streams)
|
|
}
|
|
|
|
func (fc *FormatContext) OutputFormat() *OutputFormat {
|
|
return newOutputFormatFromC(fc.c.oformat)
|
|
}
|
|
|
|
func (fc *FormatContext) Pb() *IOContext {
|
|
// If the io context has been created using the format context's OpenInput() method, we need to
|
|
// make sure to return the same go struct as the one stored in classers
|
|
if c, ok := classers.get(unsafe.Pointer(fc.c.pb)); ok {
|
|
if v, ok := c.(*IOContext); ok {
|
|
return v
|
|
}
|
|
}
|
|
return newIOContextFromC(fc.c.pb)
|
|
}
|
|
|
|
func (fc *FormatContext) SetPb(i *IOContext) {
|
|
fc.c.pb = i.c
|
|
}
|
|
|
|
func (fc *FormatContext) StartTime() int64 {
|
|
return int64(fc.c.start_time)
|
|
}
|
|
|
|
func (fc *FormatContext) Streams() (ss []*Stream) {
|
|
scs := (*[(math.MaxInt32 - 1) / unsafe.Sizeof((*C.struct_AVStream)(nil))](*C.struct_AVStream))(unsafe.Pointer(fc.c.streams))
|
|
for i := 0; i < fc.NbStreams(); i++ {
|
|
ss = append(ss, newStreamFromC(scs[i]))
|
|
}
|
|
return
|
|
}
|
|
|
|
func (fc *FormatContext) StrictStdCompliance() StrictStdCompliance {
|
|
return StrictStdCompliance(fc.c.strict_std_compliance)
|
|
}
|
|
|
|
func (fc *FormatContext) SetStrictStdCompliance(strictStdCompliance StrictStdCompliance) {
|
|
fc.c.strict_std_compliance = C.int(strictStdCompliance)
|
|
}
|
|
|
|
func (fc *FormatContext) OpenInput(url string, fmt *InputFormat, d *Dictionary) error {
|
|
var urlc *C.char
|
|
if url != "" {
|
|
urlc = C.CString(url)
|
|
defer C.free(unsafe.Pointer(urlc))
|
|
}
|
|
var dc **C.struct_AVDictionary
|
|
if d != nil {
|
|
dc = &d.c
|
|
}
|
|
var fmtc *C.struct_AVInputFormat
|
|
if fmt != nil {
|
|
fmtc = fmt.c
|
|
}
|
|
if err := newError(C.avformat_open_input(&fc.c, urlc, fmtc, dc)); err != nil {
|
|
return err
|
|
}
|
|
if pb := fc.Pb(); pb != nil {
|
|
classers.set(pb)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (fc *FormatContext) CloseInput() {
|
|
if pb := fc.Pb(); pb != nil {
|
|
classers.del(pb)
|
|
}
|
|
classers.del(fc)
|
|
if fc.c != nil {
|
|
C.avformat_close_input(&fc.c)
|
|
}
|
|
}
|
|
|
|
func (fc *FormatContext) NewStream(c *Codec) *Stream {
|
|
var cc *C.struct_AVCodec
|
|
if c != nil {
|
|
cc = c.c
|
|
}
|
|
return newStreamFromC(C.avformat_new_stream(fc.c, cc))
|
|
}
|
|
|
|
func (fc *FormatContext) FindStreamInfo(d *Dictionary) error {
|
|
var dc **C.struct_AVDictionary
|
|
if d != nil {
|
|
dc = &d.c
|
|
}
|
|
return newError(C.avformat_find_stream_info(fc.c, dc))
|
|
}
|
|
|
|
func (fc *FormatContext) ReadFrame(p *Packet) error {
|
|
var pc *C.struct_AVPacket
|
|
if p != nil {
|
|
pc = p.c
|
|
}
|
|
return newError(C.av_read_frame(fc.c, pc))
|
|
}
|
|
|
|
func (fc *FormatContext) SeekFrame(streamIndex int, timestamp int64, f SeekFlags) error {
|
|
return newError(C.av_seek_frame(fc.c, C.int(streamIndex), C.int64_t(timestamp), C.int(f)))
|
|
}
|
|
|
|
func (fc *FormatContext) Flush() error {
|
|
return newError(C.avformat_flush(fc.c))
|
|
}
|
|
|
|
func (fc *FormatContext) WriteHeader(d *Dictionary) error {
|
|
var dc **C.struct_AVDictionary
|
|
if d != nil {
|
|
dc = &d.c
|
|
}
|
|
return newError(C.avformat_write_header(fc.c, dc))
|
|
}
|
|
|
|
func (fc *FormatContext) WriteFrame(p *Packet) error {
|
|
var pc *C.struct_AVPacket
|
|
if p != nil {
|
|
pc = p.c
|
|
}
|
|
return newError(C.av_write_frame(fc.c, pc))
|
|
}
|
|
|
|
func (fc *FormatContext) WriteInterleavedFrame(p *Packet) error {
|
|
var pc *C.struct_AVPacket
|
|
if p != nil {
|
|
pc = p.c
|
|
}
|
|
return newError(C.av_interleaved_write_frame(fc.c, pc))
|
|
}
|
|
|
|
func (fc *FormatContext) WriteTrailer() error {
|
|
return newError(C.av_write_trailer(fc.c))
|
|
}
|
|
|
|
func (fc *FormatContext) GuessSampleAspectRatio(s *Stream, f *Frame) Rational {
|
|
var cf *C.struct_AVFrame
|
|
if f != nil {
|
|
cf = f.c
|
|
}
|
|
return newRationalFromC(C.av_guess_sample_aspect_ratio(fc.c, s.c, cf))
|
|
}
|
|
|
|
func (fc *FormatContext) GuessFrameRate(s *Stream, f *Frame) Rational {
|
|
var cf *C.struct_AVFrame
|
|
if f != nil {
|
|
cf = f.c
|
|
}
|
|
return newRationalFromC(C.av_guess_frame_rate(fc.c, s.c, cf))
|
|
}
|
|
|
|
func (fc *FormatContext) SDPCreate() (string, error) {
|
|
return sdpCreate([]*FormatContext{fc})
|
|
}
|
|
|
|
func sdpCreate(fcs []*FormatContext) (string, error) {
|
|
return stringFromC(1024, func(buf *C.char, size C.size_t) error {
|
|
fccs := []*C.struct_AVFormatContext{}
|
|
for _, fc := range fcs {
|
|
fccs = append(fccs, fc.c)
|
|
}
|
|
return newError(C.av_sdp_create(&fccs[0], C.int(len(fcs)), buf, C.int(size)))
|
|
})
|
|
}
|