mirror of
https://github.com/asticode/go-astiav.git
synced 2025-10-05 16:16:50 +08:00
150 lines
2.9 KiB
Go
150 lines
2.9 KiB
Go
package astiav
|
|
|
|
//#cgo pkg-config: libavcodec
|
|
//#include <libavcodec/avcodec.h>
|
|
import "C"
|
|
import (
|
|
"errors"
|
|
"unsafe"
|
|
)
|
|
|
|
// https://github.com/FFmpeg/FFmpeg/blob/n5.0/libavcodec/packet.h#L350
|
|
type Packet struct {
|
|
c *C.struct_AVPacket
|
|
}
|
|
|
|
func newPacketFromC(c *C.struct_AVPacket) *Packet {
|
|
if c == nil {
|
|
return nil
|
|
}
|
|
return &Packet{c: c}
|
|
}
|
|
|
|
func AllocPacket() *Packet {
|
|
return newPacketFromC(C.av_packet_alloc())
|
|
}
|
|
|
|
func (p *Packet) Data() []byte {
|
|
if p.c.data == nil {
|
|
return nil
|
|
}
|
|
return bytesFromC(func(size *C.int) *C.uint8_t {
|
|
*size = p.c.size
|
|
return p.c.data
|
|
})
|
|
}
|
|
|
|
func (p *Packet) Dts() int64 {
|
|
return int64(p.c.dts)
|
|
}
|
|
|
|
func (p *Packet) SetDts(v int64) {
|
|
p.c.dts = C.int64_t(v)
|
|
}
|
|
|
|
func (p *Packet) Duration() int64 {
|
|
return int64(p.c.duration)
|
|
}
|
|
|
|
func (p *Packet) SetDuration(d int64) {
|
|
p.c.duration = C.int64_t(d)
|
|
}
|
|
|
|
func (p *Packet) Flags() PacketFlags {
|
|
return PacketFlags(p.c.flags)
|
|
}
|
|
|
|
func (p *Packet) SetFlags(f PacketFlags) {
|
|
p.c.flags = C.int(f)
|
|
}
|
|
|
|
func (p *Packet) Pos() int64 {
|
|
return int64(p.c.pos)
|
|
}
|
|
|
|
func (p *Packet) SetPos(v int64) {
|
|
p.c.pos = C.int64_t(v)
|
|
}
|
|
|
|
func (p *Packet) Pts() int64 {
|
|
return int64(p.c.pts)
|
|
}
|
|
|
|
func (p *Packet) SetPts(v int64) {
|
|
p.c.pts = C.int64_t(v)
|
|
}
|
|
|
|
func (p *Packet) AddSideData(t PacketSideDataType, data []byte) error {
|
|
// Create buf
|
|
buf := (*C.uint8_t)(C.av_malloc(C.size_t(len(data))))
|
|
if buf == nil {
|
|
return errors.New("astiav: allocating buffer failed")
|
|
}
|
|
C.memcpy(unsafe.Pointer(buf), unsafe.Pointer(&data[0]), C.size_t(len(data)))
|
|
|
|
// Add
|
|
return newError(C.av_packet_add_side_data(p.c, (C.enum_AVPacketSideDataType)(t), buf, C.size_t(len(data))))
|
|
}
|
|
|
|
func (p *Packet) SideData(t PacketSideDataType) []byte {
|
|
return bytesFromC(func(size *C.int) *C.uint8_t {
|
|
return C.av_packet_get_side_data(p.c, (C.enum_AVPacketSideDataType)(t), size)
|
|
})
|
|
}
|
|
|
|
func (p *Packet) Size() int {
|
|
return int(p.c.size)
|
|
}
|
|
|
|
func (p *Packet) SetSize(s int) {
|
|
p.c.size = C.int(s)
|
|
}
|
|
|
|
func (p *Packet) StreamIndex() int {
|
|
return int(p.c.stream_index)
|
|
}
|
|
|
|
func (p *Packet) SetStreamIndex(i int) {
|
|
p.c.stream_index = C.int(i)
|
|
}
|
|
|
|
func (p *Packet) Free() {
|
|
C.av_packet_free(&p.c)
|
|
}
|
|
|
|
func (p *Packet) Clone() *Packet {
|
|
return newPacketFromC(C.av_packet_clone(p.c))
|
|
}
|
|
|
|
func (p *Packet) AllocPayload(s int) error {
|
|
return newError(C.av_new_packet(p.c, C.int(s)))
|
|
}
|
|
|
|
func (p *Packet) Ref(src *Packet) error {
|
|
return newError(C.av_packet_ref(p.c, src.c))
|
|
}
|
|
|
|
func (p *Packet) Unref() {
|
|
C.av_packet_unref(p.c)
|
|
}
|
|
|
|
func (p *Packet) MoveRef(src *Packet) {
|
|
C.av_packet_move_ref(p.c, src.c)
|
|
}
|
|
|
|
func (p *Packet) RescaleTs(src, dst Rational) {
|
|
C.av_packet_rescale_ts(p.c, src.c, dst.c)
|
|
}
|
|
|
|
func (p *Packet) FromData(data []byte) error {
|
|
// Create buf
|
|
buf := (*C.uint8_t)(C.av_malloc(C.size_t(len(data))))
|
|
if buf == nil {
|
|
return errors.New("astiav: allocating buffer failed")
|
|
}
|
|
C.memcpy(unsafe.Pointer(buf), unsafe.Pointer(&data[0]), C.size_t(len(data)))
|
|
|
|
// From data
|
|
return newError(C.av_packet_from_data(p.c, buf, C.int(len(data))))
|
|
}
|