mirror of
https://github.com/giorgisio/goav.git
synced 2024-04-21 12:31:56 +00:00
Partial rewrite: Go like func naming; Objs
This commit is contained in:
H.G. Giorgis
+228
-228
@@ -28,171 +28,171 @@ import (
|
||||
)
|
||||
|
||||
type (
|
||||
AVProbeData C.struct_AVProbeData
|
||||
AVOutputFormat C.struct_AVOutputFormat
|
||||
AVInputFormat C.struct_AVInputFormat
|
||||
AVIndexEntry C.struct_AVIndexEntry
|
||||
AVStream C.struct_AVStream
|
||||
AVProgram C.struct_AVProgram
|
||||
AVChapter C.struct_AVChapter
|
||||
AVFormatContext C.struct_AVFormatContext
|
||||
AVPacketList C.struct_AVPacketList
|
||||
AVPacket C.struct_AVPacket
|
||||
AVCodecParserContext C.struct_AVCodecParserContext
|
||||
AVIOContext C.struct_AVIOContext
|
||||
AVRational C.struct_AVRational
|
||||
AVCodec C.struct_AVCodec
|
||||
AVCodecTag C.struct_AVCodecTag
|
||||
AVDictionary C.struct_AVDictionary
|
||||
AVFrame C.struct_AVFrame
|
||||
AVClass C.struct_AVClass
|
||||
AVCodecContext C.struct_AVCodecContext
|
||||
AVFormatInternal C.struct_AVFormatInternal
|
||||
AVIOInterruptCB C.struct_AVIOInterruptCB
|
||||
AVPacketSideData C.struct_AVPacketSideData
|
||||
AvProbeData C.struct_AVProbeData
|
||||
AvOutputFormat C.struct_AVOutputFormat
|
||||
AvInputFormat C.struct_AVInputFormat
|
||||
AvIndexEntry C.struct_AVIndexEntry
|
||||
AvStream C.struct_AVStream
|
||||
AvProgram C.struct_AVProgram
|
||||
AvChapter C.struct_AVChapter
|
||||
AvFormatContext C.struct_AVFormatContext
|
||||
AvPacketList C.struct_AVPacketList
|
||||
AvPacket C.struct_AVPacket
|
||||
AvCodecParserContext C.struct_AVCodecParserContext
|
||||
AvIOContext C.struct_AVIOContext
|
||||
AvRational C.struct_AVRational
|
||||
AvCodec C.struct_AVCodec
|
||||
AvCodecTag C.struct_AVCodecTag
|
||||
AvDictionary C.struct_AVDictionary
|
||||
AvFrame C.struct_AVFrame
|
||||
AvClass C.struct_AVClass
|
||||
AvCodecContext C.struct_AVCodecContext
|
||||
AvFormatInternal C.struct_AVFormatInternal
|
||||
AvIOInterruptCB C.struct_AVIOInterruptCB
|
||||
AvPacketSideData C.struct_AVPacketSideData
|
||||
FFFrac C.struct_FFFrac
|
||||
AVStreamParseType C.enum_AVStreamParseType
|
||||
AVDiscard C.enum_AVDiscard
|
||||
AVMediaType C.enum_AVMediaType
|
||||
AVDurationEstimationMethod C.enum_AVDurationEstimationMethod
|
||||
AVPacketSideDataType C.enum_AVPacketSideDataType
|
||||
AVCodecID C.enum_AVCodecID
|
||||
AvStreamParseType C.enum_AVStreamParseType
|
||||
AvDiscard C.enum_AVDiscard
|
||||
AvMediaType C.enum_AVMediaType
|
||||
AvDurationEstimationMethod C.enum_AVDurationEstimationMethod
|
||||
AvPacketSideDataType C.enum_AVPacketSideDataType
|
||||
AvCodecId C.enum_AVCodecID
|
||||
)
|
||||
|
||||
type File C.FILE
|
||||
|
||||
//int av_get_packet (AVIOContext *s, AVPacket *pkt, int size)
|
||||
//int av_get_packet (AvIOContext *s, AvPacket *pkt, int size)
|
||||
//Allocate and read the payload of a packet and initialize its fields with default values.
|
||||
func Av_get_packet(ctxt *AVIOContext, pkt *AVPacket, s int) int {
|
||||
func Av_get_packet(ctxt *AvIOContext, pkt *AvPacket, s int) int {
|
||||
return int(C.av_get_packet((*C.struct_AVIOContext)(ctxt), (*C.struct_AVPacket)(pkt), C.int(s)))
|
||||
}
|
||||
|
||||
//int av_append_packet (AVIOContext *s, AVPacket *pkt, int size)
|
||||
//Read data and append it to the current content of the AVPacket.
|
||||
func Av_append_packet(ctxt *AVIOContext, pkt *AVPacket, s int) int {
|
||||
//int av_append_packet (AvIOContext *s, AvPacket *pkt, int size)
|
||||
//Read data and append it to the current content of the AvPacket.
|
||||
func Av_append_packet(ctxt *AvIOContext, pkt *AvPacket, s int) int {
|
||||
return int(C.av_append_packet((*C.struct_AVIOContext)(ctxt), (*C.struct_AVPacket)(pkt), C.int(s)))
|
||||
}
|
||||
|
||||
//AVRational av_stream_get_r_frame_rate (const AVStream *s)
|
||||
func Av_stream_get_r_frame_rate(s *AVStream) AVRational {
|
||||
return (AVRational)(C.av_stream_get_r_frame_rate((*C.struct_AVStream)(s)))
|
||||
//AvRational av_stream_get_r_frame_rate (const AvStream *s)
|
||||
func Av_stream_get_r_frame_rate(s *AvStream) AvRational {
|
||||
return (AvRational)(C.av_stream_get_r_frame_rate((*C.struct_AVStream)(s)))
|
||||
}
|
||||
|
||||
//void av_stream_set_r_frame_rate (AVStream *s, AVRational r)
|
||||
func Av_stream_set_r_frame_rate(s *AVStream, r AVRational) {
|
||||
//void av_stream_set_r_frame_rate (AvStream *s, AvRational r)
|
||||
func Av_stream_set_r_frame_rate(s *AvStream, r AvRational) {
|
||||
C.av_stream_set_r_frame_rate((*C.struct_AVStream)(s), (C.struct_AVRational)(r))
|
||||
}
|
||||
|
||||
//struct AVCodecParserContext * av_stream_get_parser (const AVStream *s)
|
||||
func Av_stream_get_parser(s *AVStream) *AVCodecParserContext {
|
||||
return (*AVCodecParserContext)(C.av_stream_get_parser((*C.struct_AVStream)(s)))
|
||||
//struct AvCodecParserContext * av_stream_get_parser (const AvStream *s)
|
||||
func Av_stream_get_parser(s *AvStream) *AvCodecParserContext {
|
||||
return (*AvCodecParserContext)(C.av_stream_get_parser((*C.struct_AVStream)(s)))
|
||||
}
|
||||
|
||||
// //char * av_stream_get_recommended_encoder_configuration (const AVStream *s)
|
||||
// func Av_stream_get_recommended_encoder_configuration(s *AVStream) string {
|
||||
// //char * av_stream_get_recommended_encoder_configuration (const AvStream *s)
|
||||
// func Av_stream_get_recommended_encoder_configuration(s *AvStream) string {
|
||||
// return C.GoString(C.av_stream_get_recommended_encoder_configuration((*C.struct_AVStream)(s)))
|
||||
// }
|
||||
|
||||
// //void av_stream_set_recommended_encoder_configuration (AVStream *s, char *configuration)
|
||||
// func Av_stream_set_recommended_encoder_configuration(s *AVStream, c string) {
|
||||
// //void av_stream_set_recommended_encoder_configuration (AvStream *s, char *configuration)
|
||||
// func Av_stream_set_recommended_encoder_configuration(s *AvStream, c string) {
|
||||
// C.av_stream_set_recommended_encoder_configuration((*C.struct_AVStream)(s), C.CString(c))
|
||||
// }
|
||||
|
||||
//int64_t av_stream_get_end_pts (const AVStream *st)
|
||||
//int64_t av_stream_get_end_pts (const AvStream *st)
|
||||
//Returns the pts of the last muxed packet + its duration.
|
||||
func Av_stream_get_end_pts(s *AVStream) int64 {
|
||||
func Av_stream_get_end_pts(s *AvStream) int64 {
|
||||
return int64(C.av_stream_get_end_pts((*C.struct_AVStream)(s)))
|
||||
}
|
||||
|
||||
//int av_format_get_probe_score (const AVFormatContext *s)
|
||||
func Av_format_get_probe_score(s *AVFormatContext) int {
|
||||
//int av_format_get_probe_score (const AvFormatContext *s)
|
||||
func Av_format_get_probe_score(s *AvFormatContext) int {
|
||||
return int(C.av_format_get_probe_score((*C.struct_AVFormatContext)(s)))
|
||||
}
|
||||
|
||||
//AVCodec * av_format_get_video_codec (const AVFormatContext *s)
|
||||
func Av_format_get_video_codec(s *AVFormatContext) *AVCodec {
|
||||
return (*AVCodec)(C.av_format_get_video_codec((*C.struct_AVFormatContext)(s)))
|
||||
//AvCodec * av_format_get_video_codec (const AvFormatContext *s)
|
||||
func Av_format_get_video_codec(s *AvFormatContext) *AvCodec {
|
||||
return (*AvCodec)(C.av_format_get_video_codec((*C.struct_AVFormatContext)(s)))
|
||||
}
|
||||
|
||||
//void av_format_set_video_codec (AVFormatContext *s, AVCodec *c)
|
||||
func Av_format_set_video_codec(s *AVFormatContext, c *AVCodec) {
|
||||
//void av_format_set_video_codec (AvFormatContext *s, AvCodec *c)
|
||||
func Av_format_set_video_codec(s *AvFormatContext, c *AvCodec) {
|
||||
C.av_format_set_video_codec((*C.struct_AVFormatContext)(s), (*C.struct_AVCodec)(c))
|
||||
}
|
||||
|
||||
//AVCodec * av_format_get_audio_codec (const AVFormatContext *s)
|
||||
func Av_format_get_audio_codec(s *AVFormatContext) *AVCodec {
|
||||
return (*AVCodec)(C.av_format_get_audio_codec((*C.struct_AVFormatContext)(s)))
|
||||
//AvCodec * av_format_get_audio_codec (const AvFormatContext *s)
|
||||
func Av_format_get_audio_codec(s *AvFormatContext) *AvCodec {
|
||||
return (*AvCodec)(C.av_format_get_audio_codec((*C.struct_AVFormatContext)(s)))
|
||||
}
|
||||
|
||||
//void av_format_set_audio_codec (AVFormatContext *s, AVCodec *c)
|
||||
func Av_format_set_audio_codec(s *AVFormatContext, c *AVCodec) {
|
||||
//void av_format_set_audio_codec (AvFormatContext *s, AvCodec *c)
|
||||
func Av_format_set_audio_codec(s *AvFormatContext, c *AvCodec) {
|
||||
C.av_format_set_audio_codec((*C.struct_AVFormatContext)(s), (*C.struct_AVCodec)(c))
|
||||
}
|
||||
|
||||
//AVCodec * av_format_get_subtitle_codec (const AVFormatContext *s)
|
||||
func Av_format_get_subtitle_codec(s *AVFormatContext) *AVCodec {
|
||||
return (*AVCodec)(C.av_format_get_subtitle_codec((*C.struct_AVFormatContext)(s)))
|
||||
//AvCodec * av_format_get_subtitle_codec (const AvFormatContext *s)
|
||||
func Av_format_get_subtitle_codec(s *AvFormatContext) *AvCodec {
|
||||
return (*AvCodec)(C.av_format_get_subtitle_codec((*C.struct_AVFormatContext)(s)))
|
||||
}
|
||||
|
||||
//void av_format_set_subtitle_codec (AVFormatContext *s, AVCodec *c)
|
||||
func Av_format_set_subtitle_codec(s *AVFormatContext, c *AVCodec) {
|
||||
//void av_format_set_subtitle_codec (AvFormatContext *s, AvCodec *c)
|
||||
func Av_format_set_subtitle_codec(s *AvFormatContext, c *AvCodec) {
|
||||
C.av_format_set_subtitle_codec((*C.struct_AVFormatContext)(s), (*C.struct_AVCodec)(c))
|
||||
}
|
||||
|
||||
// //AVCodec * av_format_get_data_codec (const AVFormatContext *s)
|
||||
// func Av_format_get_data_codec(s *AVFormatContext) *AVCodec {
|
||||
// return (*AVCodec)(C.av_format_get_data_codec((*C.struct_AVFormatContext)(s)))
|
||||
// //AvCodec * av_format_get_data_codec (const AvFormatContext *s)
|
||||
// func Av_format_get_data_codec(s *AvFormatContext) *AvCodec {
|
||||
// return (*AvCodec)(C.av_format_get_data_codec((*C.struct_AVFormatContext)(s)))
|
||||
// }
|
||||
|
||||
// //void av_format_set_data_codec (AVFormatContext *s, AVCodec *c)
|
||||
// func Av_format_set_data_codec(s *AVFormatContext, c *AVCodec) {
|
||||
// //void av_format_set_data_codec (AvFormatContext *s, AvCodec *c)
|
||||
// func Av_format_set_data_codec(s *AvFormatContext, c *AvCodec) {
|
||||
// C.av_format_set_data_codec((*C.struct_AVFormatContext)(s), (*C.struct_AVCodec)(c))
|
||||
// }
|
||||
|
||||
//int av_format_get_metadata_header_padding (const AVFormatContext *s)
|
||||
func Av_format_get_metadata_header_padding(s *AVFormatContext) int {
|
||||
//int av_format_get_metadata_header_padding (const AvFormatContext *s)
|
||||
func Av_format_get_metadata_header_padding(s *AvFormatContext) int {
|
||||
return int(C.av_format_get_metadata_header_padding((*C.struct_AVFormatContext)(s)))
|
||||
}
|
||||
|
||||
//void av_format_set_metadata_header_padding (AVFormatContext *s, int c)
|
||||
func Av_format_set_metadata_header_padding(s *AVFormatContext, c int) {
|
||||
//void av_format_set_metadata_header_padding (AvFormatContext *s, int c)
|
||||
func Av_format_set_metadata_header_padding(s *AvFormatContext, c int) {
|
||||
C.av_format_set_metadata_header_padding((*C.struct_AVFormatContext)(s), C.int(c))
|
||||
}
|
||||
|
||||
//void * av_format_get_opaque (const AVFormatContext *s)
|
||||
func Av_format_get_opaque(s *AVFormatContext) {
|
||||
//void * av_format_get_opaque (const AvFormatContext *s)
|
||||
func Av_format_get_opaque(s *AvFormatContext) {
|
||||
C.av_format_get_opaque((*C.struct_AVFormatContext)(s))
|
||||
}
|
||||
|
||||
//void av_format_set_opaque (AVFormatContext *s, void *opaque)
|
||||
func Av_format_set_opaque(s *AVFormatContext, o int) {
|
||||
//void av_format_set_opaque (AvFormatContext *s, void *opaque)
|
||||
func Av_format_set_opaque(s *AvFormatContext, o int) {
|
||||
C.av_format_set_opaque((*C.struct_AVFormatContext)(s), unsafe.Pointer(&o))
|
||||
}
|
||||
|
||||
//av_format_control_message av_format_get_control_message_cb (const AVFormatContext *s)
|
||||
func Av_format_control_message(s *AVFormatContext) C.av_format_control_message {
|
||||
//av_format_control_message av_format_get_control_message_cb (const AvFormatContext *s)
|
||||
func Av_format_control_message(s *AvFormatContext) C.av_format_control_message {
|
||||
return C.av_format_get_control_message_cb((*C.struct_AVFormatContext)(s))
|
||||
}
|
||||
|
||||
//void av_format_set_control_message_cb (AVFormatContext *s, av_format_control_message callback)
|
||||
func Av_format_set_control_message_cb(s *AVFormatContext, c C.av_format_control_message) {
|
||||
//void av_format_set_control_message_cb (AvFormatContext *s, av_format_control_message callback)
|
||||
func Av_format_set_control_message_cb(s *AvFormatContext, c C.av_format_control_message) {
|
||||
C.av_format_set_control_message_cb((*C.struct_AVFormatContext)(s), c)
|
||||
}
|
||||
|
||||
//void av_format_inject_global_side_data (AVFormatContext *s)
|
||||
//void av_format_inject_global_side_data (AvFormatContext *s)
|
||||
//This function will cause global side data to be injected in the next packet of each stream as well as after any subsequent seek.
|
||||
func Av_format_inject_global_side_data(s *AVFormatContext) {
|
||||
func Av_format_inject_global_side_data(s *AvFormatContext) {
|
||||
C.av_format_inject_global_side_data((*C.struct_AVFormatContext)(s))
|
||||
}
|
||||
|
||||
//enum AVDurationEstimationMethod av_fmt_ctx_get_duration_estimation_method (const AVFormatContext *ctx)
|
||||
//enum AvDurationEstimationMethod av_fmt_ctx_get_duration_estimation_method (const AvFormatContext *ctx)
|
||||
//Returns the method used to set ctx->duration.
|
||||
func Av_fmt_ctx_get_duration_estimation_method(ctx *AVFormatContext) AVDurationEstimationMethod {
|
||||
return (AVDurationEstimationMethod)(C.av_fmt_ctx_get_duration_estimation_method((*C.struct_AVFormatContext)(ctx)))
|
||||
func Av_fmt_ctx_get_duration_estimation_method(ctx *AvFormatContext) AvDurationEstimationMethod {
|
||||
return (AvDurationEstimationMethod)(C.av_fmt_ctx_get_duration_estimation_method((*C.struct_AVFormatContext)(ctx)))
|
||||
}
|
||||
|
||||
//unsigned avformat_version (void)
|
||||
//Return the LIBAVFORMAT_VERSION_INT constant.
|
||||
//Return the LIBAvFORMAT_VERSION_INT constant.
|
||||
func Avformat_version() uint {
|
||||
return uint(C.avformat_version())
|
||||
}
|
||||
@@ -215,13 +215,13 @@ func Av_register_all() {
|
||||
C.av_register_all()
|
||||
}
|
||||
|
||||
//void av_register_input_format (AVInputFormat *format)
|
||||
func Av_register_input_format(f *AVInputFormat) {
|
||||
//void av_register_input_format (AvInputFormat *format)
|
||||
func Av_register_input_format(f *AvInputFormat) {
|
||||
C.av_register_input_format((*C.struct_AVInputFormat)(f))
|
||||
}
|
||||
|
||||
//void av_register_output_format (AVOutputFormat *format)
|
||||
func Av_register_output_format(f *AVOutputFormat) {
|
||||
//void av_register_output_format (AvOutputFormat *format)
|
||||
func Av_register_output_format(f *AvOutputFormat) {
|
||||
C.av_register_output_format((*C.struct_AVOutputFormat)(f))
|
||||
}
|
||||
|
||||
@@ -237,218 +237,218 @@ func Avformat_network_deinit() int {
|
||||
return int(C.avformat_network_deinit())
|
||||
}
|
||||
|
||||
//AVInputFormat * av_iformat_next (const AVInputFormat *f)
|
||||
//AvInputFormat * av_iformat_next (const AvInputFormat *f)
|
||||
//If f is NULL, returns the first registered input format, if f is non-NULL, returns the next registered input format after f or NULL if f is the last one.
|
||||
func Av_iformat_next(f *AVInputFormat) *AVInputFormat {
|
||||
return (*AVInputFormat)(C.av_iformat_next((*C.struct_AVInputFormat)(f)))
|
||||
func Av_iformat_next(f *AvInputFormat) *AvInputFormat {
|
||||
return (*AvInputFormat)(C.av_iformat_next((*C.struct_AVInputFormat)(f)))
|
||||
}
|
||||
|
||||
//AVOutputFormat * av_oformat_next (const AVOutputFormat *f)
|
||||
//AvOutputFormat * av_oformat_next (const AvOutputFormat *f)
|
||||
//If f is NULL, returns the first registered output format, if f is non-NULL, returns the next registered output format after f or NULL if f is the last one.
|
||||
func Av_oformat_next(f *AVOutputFormat) *AVOutputFormat {
|
||||
return (*AVOutputFormat)(C.av_oformat_next((*C.struct_AVOutputFormat)(f)))
|
||||
func Av_oformat_next(f *AvOutputFormat) *AvOutputFormat {
|
||||
return (*AvOutputFormat)(C.av_oformat_next((*C.struct_AVOutputFormat)(f)))
|
||||
}
|
||||
|
||||
//AVFormatContext * avformat_alloc_context (void)
|
||||
//Allocate an AVFormatContext.
|
||||
func Avformat_alloc_context() *AVFormatContext {
|
||||
return (*AVFormatContext)(C.avformat_alloc_context())
|
||||
//AvFormatContext * avformat_alloc_context (void)
|
||||
//Allocate an AvFormatContext.
|
||||
func Avformat_alloc_context() *AvFormatContext {
|
||||
return (*AvFormatContext)(C.avformat_alloc_context())
|
||||
}
|
||||
|
||||
//void avformat_free_context (AVFormatContext *s)
|
||||
//Free an AVFormatContext and all its streams.
|
||||
func Avformat_free_context(s *AVFormatContext) {
|
||||
//void avformat_free_context (AvFormatContext *s)
|
||||
//Free an AvFormatContext and all its streams.
|
||||
func Avformat_free_context(s *AvFormatContext) {
|
||||
C.avformat_free_context((*C.struct_AVFormatContext)(s))
|
||||
}
|
||||
|
||||
//const AVClass * avformat_get_class (void)
|
||||
//Get the AVClass for AVFormatContext.
|
||||
func Avformat_get_class() *AVClass {
|
||||
return (*AVClass)(C.avformat_get_class())
|
||||
//const AvClass * avformat_get_class (void)
|
||||
//Get the AvClass for AvFormatContext.
|
||||
func Avformat_get_class() *AvClass {
|
||||
return (*AvClass)(C.avformat_get_class())
|
||||
}
|
||||
|
||||
//AVStream * avformat_new_stream (AVFormatContext *s, const AVCodec *c)
|
||||
//AvStream * avformat_new_stream (AvFormatContext *s, const AvCodec *c)
|
||||
//Add a new stream to a media file.
|
||||
func Avformat_new_stream(s *AVFormatContext, c *AVCodec) *AVStream {
|
||||
return (*AVStream)(C.avformat_new_stream((*C.struct_AVFormatContext)(s), (*C.struct_AVCodec)(c)))
|
||||
func Avformat_new_stream(s *AvFormatContext, c *AvCodec) *AvStream {
|
||||
return (*AvStream)(C.avformat_new_stream((*C.struct_AVFormatContext)(s), (*C.struct_AVCodec)(c)))
|
||||
}
|
||||
|
||||
//uint8_t * av_stream_get_side_data (AVStream *stream, enum AVPacketSideDataType type, int *size)
|
||||
//uint8_t * av_stream_get_side_data (AvStream *stream, enum AvPacketSideDataType type, int *size)
|
||||
//Get side information from stream.
|
||||
func Av_stream_get_side_data(s *AVStream, t AVPacketSideDataType, z int) *uint8 {
|
||||
func Av_stream_get_side_data(s *AvStream, t AvPacketSideDataType, z int) *uint8 {
|
||||
return (*uint8)(C.av_stream_get_side_data((*C.struct_AVStream)(s), (C.enum_AVPacketSideDataType)(t), (*C.int)(unsafe.Pointer(&z))))
|
||||
}
|
||||
|
||||
//AVProgram * av_new_program (AVFormatContext *s, int id)
|
||||
func Av_new_program(s *AVFormatContext, id int) *AVProgram {
|
||||
return (*AVProgram)(C.av_new_program((*C.struct_AVFormatContext)(s), C.int(id)))
|
||||
//AvProgram * av_new_program (AvFormatContext *s, int id)
|
||||
func Av_new_program(s *AvFormatContext, id int) *AvProgram {
|
||||
return (*AvProgram)(C.av_new_program((*C.struct_AVFormatContext)(s), C.int(id)))
|
||||
}
|
||||
|
||||
//int avformat_alloc_output_context2 (AVFormatContext **ctx, AVOutputFormat *oformat, const char *format_name, const char *filename)
|
||||
//Allocate an AVFormatContext for an output format.
|
||||
func Avformat_alloc_output_context2(ctx **AVFormatContext, o *AVOutputFormat, fo, fi string) int {
|
||||
//int avformat_alloc_output_context2 (AvFormatContext **ctx, AvOutputFormat *oformat, const char *format_name, const char *filename)
|
||||
//Allocate an AvFormatContext for an output format.
|
||||
func Avformat_alloc_output_context2(ctx **AvFormatContext, o *AvOutputFormat, fo, fi string) int {
|
||||
return int(C.avformat_alloc_output_context2((**C.struct_AVFormatContext)(unsafe.Pointer(ctx)), (*C.struct_AVOutputFormat)(o), C.CString(fo), C.CString(fi)))
|
||||
}
|
||||
|
||||
//AVInputFormat * av_find_input_format (const char *short_name)
|
||||
//Find AVInputFormat based on the short name of the input format.
|
||||
func Av_find_input_format(s string) *AVInputFormat {
|
||||
return (*AVInputFormat)(C.av_find_input_format(C.CString(s)))
|
||||
//AvInputFormat * av_find_input_format (const char *short_name)
|
||||
//Find AvInputFormat based on the short name of the input format.
|
||||
func Av_find_input_format(s string) *AvInputFormat {
|
||||
return (*AvInputFormat)(C.av_find_input_format(C.CString(s)))
|
||||
}
|
||||
|
||||
//AVInputFormat * av_probe_input_format (AVProbeData *pd, int is_opened)
|
||||
//AvInputFormat * av_probe_input_format (AvProbeData *pd, int is_opened)
|
||||
//Guess the file format.
|
||||
func Av_probe_input_format(pd *AVProbeData, i int) *AVInputFormat {
|
||||
return (*AVInputFormat)(C.av_probe_input_format((*C.struct_AVProbeData)(pd), C.int(i)))
|
||||
func Av_probe_input_format(pd *AvProbeData, i int) *AvInputFormat {
|
||||
return (*AvInputFormat)(C.av_probe_input_format((*C.struct_AVProbeData)(pd), C.int(i)))
|
||||
}
|
||||
|
||||
//AVInputFormat * av_probe_input_format2 (AVProbeData *pd, int is_opened, int *score_max)
|
||||
//AvInputFormat * av_probe_input_format2 (AvProbeData *pd, int is_opened, int *score_max)
|
||||
//Guess the file format.
|
||||
func Av_probe_input_format2(pd *AVProbeData, o int, sm *int) *AVInputFormat {
|
||||
return (*AVInputFormat)(C.av_probe_input_format2((*C.struct_AVProbeData)(pd), C.int(o), (*C.int)(unsafe.Pointer(sm))))
|
||||
func Av_probe_input_format2(pd *AvProbeData, o int, sm *int) *AvInputFormat {
|
||||
return (*AvInputFormat)(C.av_probe_input_format2((*C.struct_AVProbeData)(pd), C.int(o), (*C.int)(unsafe.Pointer(sm))))
|
||||
}
|
||||
|
||||
//AVInputFormat * av_probe_input_format3 (AVProbeData *pd, int is_opened, int *score_ret)
|
||||
//AvInputFormat * av_probe_input_format3 (AvProbeData *pd, int is_opened, int *score_ret)
|
||||
//Guess the file format.
|
||||
func Av_probe_input_format3(pd *AVProbeData, o int, sl *int) *AVInputFormat {
|
||||
return (*AVInputFormat)(C.av_probe_input_format3((*C.struct_AVProbeData)(pd), C.int(o), (*C.int)(unsafe.Pointer(sl))))
|
||||
func Av_probe_input_format3(pd *AvProbeData, o int, sl *int) *AvInputFormat {
|
||||
return (*AvInputFormat)(C.av_probe_input_format3((*C.struct_AVProbeData)(pd), C.int(o), (*C.int)(unsafe.Pointer(sl))))
|
||||
}
|
||||
|
||||
//int av_probe_input_buffer2 (AVIOContext *pb, AVInputFormat **fmt, const char *filename, void *logctx, unsigned int offset, unsigned int max_probe_size)
|
||||
//int av_probe_input_buffer2 (AvIOContext *pb, AvInputFormat **fmt, const char *filename, void *logctx, unsigned int offset, unsigned int max_probe_size)
|
||||
//Probe a bytestream to determine the input format.
|
||||
func Av_probe_input_buffer2(pb *AVIOContext, f **AVInputFormat, fi string, l int, o, m uint) int {
|
||||
func Av_probe_input_buffer2(pb *AvIOContext, f **AvInputFormat, fi string, l int, o, m uint) int {
|
||||
return int(C.av_probe_input_buffer2((*C.struct_AVIOContext)(pb), (**C.struct_AVInputFormat)(unsafe.Pointer(f)), C.CString(fi), unsafe.Pointer(&l), C.uint(o), C.uint(m)))
|
||||
}
|
||||
|
||||
//int av_probe_input_buffer (AVIOContext *pb, AVInputFormat **fmt, const char *filename, void *logctx, unsigned int offset, unsigned int max_probe_size)
|
||||
//int av_probe_input_buffer (AvIOContext *pb, AvInputFormat **fmt, const char *filename, void *logctx, unsigned int offset, unsigned int max_probe_size)
|
||||
//Like av_probe_input_buffer2() but returns 0 on success.
|
||||
func Av_probe_input_buffer(pb *AVIOContext, f **AVInputFormat, fi string, l int, o, m uint) int {
|
||||
func Av_probe_input_buffer(pb *AvIOContext, f **AvInputFormat, fi string, l int, o, m uint) int {
|
||||
return int(C.av_probe_input_buffer((*C.struct_AVIOContext)(pb), (**C.struct_AVInputFormat)(unsafe.Pointer(f)), C.CString(fi), unsafe.Pointer(&l), C.uint(o), C.uint(m)))
|
||||
}
|
||||
|
||||
//int avformat_open_input (AVFormatContext **ps, const char *filename, AVInputFormat *fmt, AVDictionary **options)
|
||||
//int avformat_open_input (AvFormatContext **ps, const char *filename, AvInputFormat *fmt, AvDictionary **options)
|
||||
//Open an input stream and read the header.
|
||||
func Avformat_open_input(ps **AVFormatContext, fi string, fmt *AVInputFormat, d **AVDictionary) int {
|
||||
func Avformat_open_input(ps **AvFormatContext, fi string, fmt *AvInputFormat, d **AvDictionary) int {
|
||||
return int(C.avformat_open_input((**C.struct_AVFormatContext)(unsafe.Pointer(ps)), C.CString(fi), (*C.struct_AVInputFormat)(fmt), (**C.struct_AVDictionary)(unsafe.Pointer(d))))
|
||||
}
|
||||
|
||||
//int avformat_find_stream_info (AVFormatContext *ic, AVDictionary **options)
|
||||
//int avformat_find_stream_info (AvFormatContext *ic, AvDictionary **options)
|
||||
//Read packets of a media file to get stream information.
|
||||
func Avformat_find_stream_info(ic *AVFormatContext, d **AVDictionary) int {
|
||||
func Avformat_find_stream_info(ic *AvFormatContext, d **AvDictionary) int {
|
||||
return int(C.avformat_find_stream_info((*C.struct_AVFormatContext)(ic), (**C.struct_AVDictionary)(unsafe.Pointer(d))))
|
||||
}
|
||||
|
||||
//AVProgram * av_find_program_from_stream (AVFormatContext *ic, AVProgram *last, int s)
|
||||
//AvProgram * av_find_program_from_stream (AvFormatContext *ic, AvProgram *last, int s)
|
||||
//Find the programs which belong to a given stream.
|
||||
func Av_find_program_from_stream(ic *AVFormatContext, l *AVProgram, s int) *AVProgram {
|
||||
return (*AVProgram)(C.av_find_program_from_stream((*C.struct_AVFormatContext)(ic), (*C.struct_AVProgram)(l), C.int(s)))
|
||||
func Av_find_program_from_stream(ic *AvFormatContext, l *AvProgram, s int) *AvProgram {
|
||||
return (*AvProgram)(C.av_find_program_from_stream((*C.struct_AVFormatContext)(ic), (*C.struct_AVProgram)(l), C.int(s)))
|
||||
}
|
||||
|
||||
//int av_find_best_stream (AVFormatContext *ic, enum AVMediaType type, int wanted_stream_nb, int related_stream, AVCodec **decoder_ret, int flags)
|
||||
//int av_find_best_stream (AvFormatContext *ic, enum AvMediaType type, int wanted_stream_nb, int related_stream, AvCodec **decoder_ret, int flags)
|
||||
//Find the "best" stream in the file.
|
||||
func Av_find_best_stream(ic *AVFormatContext, t AVMediaType, ws, rs int, c **AVCodec, f int) int {
|
||||
func Av_find_best_stream(ic *AvFormatContext, t AvMediaType, ws, rs int, c **AvCodec, f int) int {
|
||||
return int(C.av_find_best_stream((*C.struct_AVFormatContext)(ic), (C.enum_AVMediaType)(t), C.int(ws), C.int(rs), (**C.struct_AVCodec)(unsafe.Pointer(c)), C.int(f)))
|
||||
}
|
||||
|
||||
//int av_read_frame (AVFormatContext *s, AVPacket *pkt)
|
||||
//int av_read_frame (AvFormatContext *s, AvPacket *pkt)
|
||||
//Return the next frame of a stream.
|
||||
func Av_read_frame(s *AVFormatContext, pkt *avcodec.AVPacket) int {
|
||||
func Av_read_frame(s *AvFormatContext, pkt *avcodec.AvPacket) int {
|
||||
return int(C.av_read_frame((*C.struct_AVFormatContext)(unsafe.Pointer(s)), (*C.struct_AVPacket)(unsafe.Pointer(pkt))))
|
||||
}
|
||||
|
||||
//int av_seek_frame (AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
|
||||
//int av_seek_frame (AvFormatContext *s, int stream_index, int64_t timestamp, int flags)
|
||||
//Seek to the keyframe at timestamp.
|
||||
func Av_seek_frame(s *AVFormatContext, st int, t int64, f int) int {
|
||||
func Av_seek_frame(s *AvFormatContext, st int, t int64, f int) int {
|
||||
return int(C.av_seek_frame((*C.struct_AVFormatContext)(s), C.int(st), C.int64_t(t), C.int(f)))
|
||||
}
|
||||
|
||||
//int avformat_seek_file (AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
|
||||
//int avformat_seek_file (AvFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
|
||||
//Seek to timestamp ts.
|
||||
func Avformat_seek_file(s *AVFormatContext, si int, mit, ts, mat int64, f int) int {
|
||||
func Avformat_seek_file(s *AvFormatContext, si int, mit, ts, mat int64, f int) int {
|
||||
return int(C.avformat_seek_file((*C.struct_AVFormatContext)(s), C.int(si), C.int64_t(mit), C.int64_t(ts), C.int64_t(mat), C.int(f)))
|
||||
}
|
||||
|
||||
// //int avformat_flush (AVFormatContext *s)
|
||||
// //int avformat_flush (AvFormatContext *s)
|
||||
// //Discard all internally buffered data.
|
||||
// func Avformat_flush(s *AVFormatContext) int {
|
||||
// func Avformat_flush(s *AvFormatContext) int {
|
||||
// return int(C.avformat_flush((*C.struct_AVFormatContext)(s)))
|
||||
// }
|
||||
|
||||
//int av_read_play (AVFormatContext *s)
|
||||
//int av_read_play (AvFormatContext *s)
|
||||
//Start playing a network-based stream (e.g.
|
||||
func Av_read_play(s *AVFormatContext) int {
|
||||
func Av_read_play(s *AvFormatContext) int {
|
||||
return int(C.av_read_play((*C.struct_AVFormatContext)(s)))
|
||||
}
|
||||
|
||||
//int av_read_pause (AVFormatContext *s)
|
||||
//int av_read_pause (AvFormatContext *s)
|
||||
//Pause a network-based stream (e.g.
|
||||
func Av_read_pause(s *AVFormatContext) int {
|
||||
func Av_read_pause(s *AvFormatContext) int {
|
||||
return int(C.av_read_pause((*C.struct_AVFormatContext)(s)))
|
||||
}
|
||||
|
||||
//void avformat_close_input (AVFormatContext **s)
|
||||
//Close an opened input AVFormatContext.
|
||||
func Avformat_close_input(s *AVFormatContext) {
|
||||
//void avformat_close_input (AvFormatContext **s)
|
||||
//Close an opened input AvFormatContext.
|
||||
func Avformat_close_input(s *AvFormatContext) {
|
||||
C.avformat_close_input((**C.struct_AVFormatContext)(unsafe.Pointer(s)))
|
||||
}
|
||||
|
||||
//int avformat_write_header (AVFormatContext *s, AVDictionary **options)
|
||||
//int avformat_write_header (AvFormatContext *s, AvDictionary **options)
|
||||
//Allocate the stream private data and write the stream header to an output media file.
|
||||
func Avformat_write_header(s *AVFormatContext, o **AVDictionary) int {
|
||||
func Avformat_write_header(s *AvFormatContext, o **AvDictionary) int {
|
||||
return int(C.avformat_write_header((*C.struct_AVFormatContext)(s), (**C.struct_AVDictionary)(unsafe.Pointer(o))))
|
||||
}
|
||||
|
||||
//int av_write_frame (AVFormatContext *s, AVPacket *pkt)
|
||||
//int av_write_frame (AvFormatContext *s, AvPacket *pkt)
|
||||
//Write a packet to an output media file.
|
||||
func Av_write_frame(s *AVFormatContext, pkt *AVPacket) int {
|
||||
func Av_write_frame(s *AvFormatContext, pkt *AvPacket) int {
|
||||
return int(C.av_write_frame((*C.struct_AVFormatContext)(s), (*C.struct_AVPacket)(pkt)))
|
||||
}
|
||||
|
||||
//int av_interleaved_write_frame (AVFormatContext *s, AVPacket *pkt)
|
||||
//int av_interleaved_write_frame (AvFormatContext *s, AvPacket *pkt)
|
||||
//Write a packet to an output media file ensuring correct interleaving.
|
||||
func Av_interleaved_write_frame(s *AVFormatContext, pkt *AVPacket) int {
|
||||
func Av_interleaved_write_frame(s *AvFormatContext, pkt *AvPacket) int {
|
||||
return int(C.av_interleaved_write_frame((*C.struct_AVFormatContext)(s), (*C.struct_AVPacket)(pkt)))
|
||||
}
|
||||
|
||||
//int av_write_uncoded_frame (AVFormatContext *s, int stream_index, AVFrame *frame)
|
||||
//int av_write_uncoded_frame (AvFormatContext *s, int stream_index, AvFrame *frame)
|
||||
//Write a uncoded frame to an output media file.
|
||||
func Av_write_uncoded_frame(s *AVFormatContext, si int, f *AVFrame) int {
|
||||
func Av_write_uncoded_frame(s *AvFormatContext, si int, f *AvFrame) int {
|
||||
return int(C.av_write_uncoded_frame((*C.struct_AVFormatContext)(s), C.int(si), (*C.struct_AVFrame)(f)))
|
||||
}
|
||||
|
||||
//int av_interleaved_write_uncoded_frame (AVFormatContext *s, int stream_index, AVFrame *frame)
|
||||
//int av_interleaved_write_uncoded_frame (AvFormatContext *s, int stream_index, AvFrame *frame)
|
||||
//Write a uncoded frame to an output media file.
|
||||
func Av_interleaved_write_uncoded_frame(s *AVFormatContext, si int, f *AVFrame) int {
|
||||
func Av_interleaved_write_uncoded_frame(s *AvFormatContext, si int, f *AvFrame) int {
|
||||
return int(C.av_interleaved_write_uncoded_frame((*C.struct_AVFormatContext)(s), C.int(si), (*C.struct_AVFrame)(f)))
|
||||
}
|
||||
|
||||
//int av_write_uncoded_frame_query (AVFormatContext *s, int stream_index)
|
||||
//int av_write_uncoded_frame_query (AvFormatContext *s, int stream_index)
|
||||
//Test whether a muxer supports uncoded frame.
|
||||
func Av_write_uncoded_frame_query(s *AVFormatContext, si int) int {
|
||||
func Av_write_uncoded_frame_query(s *AvFormatContext, si int) int {
|
||||
return int(C.av_write_uncoded_frame_query((*C.struct_AVFormatContext)(s), C.int(si)))
|
||||
}
|
||||
|
||||
//int av_write_trailer (AVFormatContext *s)
|
||||
//int av_write_trailer (AvFormatContext *s)
|
||||
//Write the stream trailer to an output media file and free the file private data.
|
||||
func Av_write_trailer(s *AVFormatContext) int {
|
||||
func Av_write_trailer(s *AvFormatContext) int {
|
||||
return int(C.av_write_trailer((*C.struct_AVFormatContext)(s)))
|
||||
}
|
||||
|
||||
//AVOutputFormat * av_guess_format (const char *short_name, const char *filename, const char *mime_type)
|
||||
//AvOutputFormat * av_guess_format (const char *short_name, const char *filename, const char *mime_type)
|
||||
//Return the output format in the list of registered output formats which best matches the provided parameters, or return NULL if there is no match.
|
||||
func Av_guess_format(sn, f, mt string) *AVOutputFormat {
|
||||
return (*AVOutputFormat)(C.av_guess_format(C.CString(sn), C.CString(f), C.CString(mt)))
|
||||
func Av_guess_format(sn, f, mt string) *AvOutputFormat {
|
||||
return (*AvOutputFormat)(C.av_guess_format(C.CString(sn), C.CString(f), C.CString(mt)))
|
||||
}
|
||||
|
||||
//enum AVCodecID av_guess_codec (AVOutputFormat *fmt, const char *short_name, const char *filename, const char *mime_type, enum AVMediaType type)
|
||||
//enum AvCodecId av_guess_codec (AvOutputFormat *fmt, const char *short_name, const char *filename, const char *mime_type, enum AvMediaType type)
|
||||
//Guess the codec ID based upon muxer and filename.
|
||||
func Av_guess_codec(fmt *AVOutputFormat, sn, f, mt string, t AVMediaType) AVCodecID {
|
||||
return (AVCodecID)(C.av_guess_codec((*C.struct_AVOutputFormat)(fmt), C.CString(sn), C.CString(f), C.CString(mt), (C.enum_AVMediaType)(t)))
|
||||
func Av_guess_codec(fmt *AvOutputFormat, sn, f, mt string, t AvMediaType) AvCodecId {
|
||||
return (AvCodecId)(C.av_guess_codec((*C.struct_AVOutputFormat)(fmt), C.CString(sn), C.CString(f), C.CString(mt), (C.enum_AVMediaType)(t)))
|
||||
}
|
||||
|
||||
//int av_get_output_timestamp (struct AVFormatContext *s, int stream, int64_t *dts, int64_t *wall)
|
||||
//int av_get_output_timestamp (struct AvFormatContext *s, int stream, int64_t *dts, int64_t *wall)
|
||||
//Get timing information for the data currently output.
|
||||
func Av_get_output_timestamp(s *AVFormatContext, st int, dts, wall *C.int64_t) int {
|
||||
func Av_get_output_timestamp(s *AvFormatContext, st int, dts, wall *C.int64_t) int {
|
||||
return int(C.av_get_output_timestamp((*C.struct_AVFormatContext)(s), C.int(st), dts, wall))
|
||||
}
|
||||
|
||||
@@ -464,50 +464,50 @@ func Av_hex_dump_log(a, l int, b *uint8, s int) {
|
||||
C.av_hex_dump_log(unsafe.Pointer(&a), C.int(l), (*C.uint8_t)(b), C.int(s))
|
||||
}
|
||||
|
||||
//void av_pkt_dump2 (FILE *f, const AVPacket *pkt, int dump_payload, const AVStream *st)
|
||||
//void av_pkt_dump2 (FILE *f, const AvPacket *pkt, int dump_payload, const AvStream *st)
|
||||
//Send a nice dump of a packet to the specified file stream.
|
||||
func Av_pkt_dump2(f *File, pkt *AVPacket, dp int, st *AVStream) {
|
||||
func Av_pkt_dump2(f *File, pkt *AvPacket, dp int, st *AvStream) {
|
||||
C.av_pkt_dump2((*C.FILE)(f), (*C.struct_AVPacket)(pkt), C.int(dp), (*C.struct_AVStream)(st))
|
||||
}
|
||||
|
||||
//void av_pkt_dump_log2 (void *avcl, int level, const AVPacket *pkt, int dump_payload, const AVStream *st)
|
||||
//void av_pkt_dump_log2 (void *avcl, int level, const AvPacket *pkt, int dump_payload, const AvStream *st)
|
||||
//Send a nice dump of a packet to the log.
|
||||
func Av_pkt_dump_log2(a int, l int, pkt *AVPacket, dp int, st *AVStream) {
|
||||
func Av_pkt_dump_log2(a int, l int, pkt *AvPacket, dp int, st *AvStream) {
|
||||
C.av_pkt_dump_log2(unsafe.Pointer(&a), C.int(l), (*C.struct_AVPacket)(pkt), C.int(dp), (*C.struct_AVStream)(st))
|
||||
}
|
||||
|
||||
//enum AVCodecID av_codec_get_id (const struct AVCodecTag *const *tags, unsigned int tag)
|
||||
//Get the AVCodecID for the given codec tag tag.
|
||||
func Av_codec_get_id(t **AVCodecTag, tag uint) AVCodecID {
|
||||
return (AVCodecID)(C.av_codec_get_id((**C.struct_AVCodecTag)(unsafe.Pointer(t)), C.uint(tag)))
|
||||
//enum AvCodecId av_codec_get_id (const struct AvCodecTag *const *tags, unsigned int tag)
|
||||
//Get the AvCodecId for the given codec tag tag.
|
||||
func Av_codec_get_id(t **AvCodecTag, tag uint) AvCodecId {
|
||||
return (AvCodecId)(C.av_codec_get_id((**C.struct_AVCodecTag)(unsafe.Pointer(t)), C.uint(tag)))
|
||||
}
|
||||
|
||||
//unsigned int av_codec_get_tag (const struct AVCodecTag *const *tags, enum AVCodecID id)
|
||||
//unsigned int av_codec_get_tag (const struct AvCodecTag *const *tags, enum AvCodecId id)
|
||||
//Get the codec tag for the given codec id id.
|
||||
func Av_codec_get_tag(t **AVCodecTag, id AVCodecID) uint {
|
||||
func Av_codec_get_tag(t **AvCodecTag, id AvCodecId) uint {
|
||||
return uint(C.av_codec_get_tag((**C.struct_AVCodecTag)(unsafe.Pointer(t)), (C.enum_AVCodecID)(id)))
|
||||
}
|
||||
|
||||
//int av_codec_get_tag2 (const struct AVCodecTag *const *tags, enum AVCodecID id, unsigned int *tag)
|
||||
//int av_codec_get_tag2 (const struct AvCodecTag *const *tags, enum AvCodecId id, unsigned int *tag)
|
||||
//Get the codec tag for the given codec id.
|
||||
func Av_codec_get_tag2(t **AVCodecTag, id AVCodecID, tag *uint) int {
|
||||
func Av_codec_get_tag2(t **AvCodecTag, id AvCodecId, tag *uint) int {
|
||||
return int(C.av_codec_get_tag2((**C.struct_AVCodecTag)(unsafe.Pointer(t)), (C.enum_AVCodecID)(id), (*C.uint)(unsafe.Pointer(tag))))
|
||||
}
|
||||
|
||||
//int av_find_default_stream_index (AVFormatContext *s)
|
||||
func Av_find_default_stream_index(s *AVFormatContext) int {
|
||||
//int av_find_default_stream_index (AvFormatContext *s)
|
||||
func Av_find_default_stream_index(s *AvFormatContext) int {
|
||||
return int(C.av_find_default_stream_index((*C.struct_AVFormatContext)(s)))
|
||||
}
|
||||
|
||||
//int av_index_search_timestamp (AVStream *st, int64_t timestamp, int flags)
|
||||
//int av_index_search_timestamp (AvStream *st, int64_t timestamp, int flags)
|
||||
//Get the index for a specific timestamp.
|
||||
func Av_index_search_timestamp(st *AVStream, t int64, f int) int {
|
||||
func Av_index_search_timestamp(st *AvStream, t int64, f int) int {
|
||||
return int(C.av_index_search_timestamp((*C.struct_AVStream)(st), C.int64_t(t), C.int(f)))
|
||||
}
|
||||
|
||||
//int av_add_index_entry (AVStream *st, int64_t pos, int64_t timestamp, int size, int distance, int flags)
|
||||
//int av_add_index_entry (AvStream *st, int64_t pos, int64_t timestamp, int size, int distance, int flags)
|
||||
//Add an index entry into a sorted list.
|
||||
func Av_add_index_entry(st *AVStream, pos, t, int64, s, d, f int) int {
|
||||
func Av_add_index_entry(st *AvStream, pos, t, int64, s, d, f int) int {
|
||||
return int(C.av_add_index_entry((*C.struct_AVStream)(st), C.int64_t(pos), C.int64_t(t), C.int(s), C.int(d), C.int(f)))
|
||||
}
|
||||
|
||||
@@ -517,9 +517,9 @@ func Av_url_split(p string, ps int, a string, as int, h string, hs int, pp *int,
|
||||
C.av_url_split(C.CString(p), C.int(ps), C.CString(a), C.int(as), C.CString(h), C.int(hs), (*C.int)(unsafe.Pointer(pp)), C.CString(path), C.int(psize), C.CString(url))
|
||||
}
|
||||
|
||||
//void av_dump_format (AVFormatContext *ic, int index, const char *url, int is_output)
|
||||
//void av_dump_format (AvFormatContext *ic, int index, const char *url, int is_output)
|
||||
//Print detailed information about the input or output format, such as duration, bitrate, streams, container, programs, metadata, side data, codec and time base.
|
||||
func Av_dump_format(ic *AVFormatContext, i int, url string, io int) {
|
||||
func Av_dump_format(ic *AvFormatContext, i int, url string, io int) {
|
||||
C.av_dump_format((*C.struct_AVFormatContext)(unsafe.Pointer(ic)), C.int(i), C.CString(url), C.int(io))
|
||||
}
|
||||
|
||||
@@ -535,9 +535,9 @@ func Av_filename_number_test(f string) int {
|
||||
return int(C.av_filename_number_test(C.CString(f)))
|
||||
}
|
||||
|
||||
//int av_sdp_create (AVFormatContext *ac[], int n_files, char *buf, int size)
|
||||
//int av_sdp_create (AvFormatContext *ac[], int n_files, char *buf, int size)
|
||||
//Generate an SDP for an RTP session.
|
||||
func Av_sdp_create(ac **AVFormatContext, nf int, b string, s int) int {
|
||||
func Av_sdp_create(ac **AvFormatContext, nf int, b string, s int) int {
|
||||
return int(C.av_sdp_create((**C.struct_AVFormatContext)(unsafe.Pointer(ac)), C.int(nf), C.CString(b), C.int(s)))
|
||||
}
|
||||
|
||||
@@ -547,51 +547,51 @@ func Av_match_ext(f, e string) int {
|
||||
return int(C.av_match_ext(C.CString(f), C.CString(e)))
|
||||
}
|
||||
|
||||
//int avformat_query_codec (const AVOutputFormat *ofmt, enum AVCodecID codec_id, int std_compliance)
|
||||
//int avformat_query_codec (const AvOutputFormat *ofmt, enum AvCodecId codec_id, int std_compliance)
|
||||
//Test if the given container can store a codec.
|
||||
func Avformat_query_codec(o *AVOutputFormat, cd AVCodecID, sc int) int {
|
||||
func Avformat_query_codec(o *AvOutputFormat, cd AvCodecId, sc int) int {
|
||||
return int(C.avformat_query_codec((*C.struct_AVOutputFormat)(o), (C.enum_AVCodecID)(cd), C.int(sc)))
|
||||
}
|
||||
|
||||
//struct AVCodecTag * avformat_get_riff_video_tags (void)
|
||||
func Avformat_get_riff_video_tags() *AVCodecTag {
|
||||
return (*AVCodecTag)(C.avformat_get_riff_video_tags())
|
||||
//struct AvCodecTag * avformat_get_riff_video_tags (void)
|
||||
func Avformat_get_riff_video_tags() *AvCodecTag {
|
||||
return (*AvCodecTag)(C.avformat_get_riff_video_tags())
|
||||
}
|
||||
|
||||
//struct AVCodecTag * avformat_get_riff_audio_tags (void)
|
||||
func Avformat_get_riff_audio_tags() *AVCodecTag {
|
||||
return (*AVCodecTag)(C.avformat_get_riff_audio_tags())
|
||||
//struct AvCodecTag * avformat_get_riff_audio_tags (void)
|
||||
func Avformat_get_riff_audio_tags() *AvCodecTag {
|
||||
return (*AvCodecTag)(C.avformat_get_riff_audio_tags())
|
||||
}
|
||||
|
||||
//struct AVCodecTag * avformat_get_mov_video_tags (void)
|
||||
func Avformat_get_mov_video_tags() *AVCodecTag {
|
||||
return (*AVCodecTag)(C.avformat_get_mov_video_tags())
|
||||
//struct AvCodecTag * avformat_get_mov_video_tags (void)
|
||||
func Avformat_get_mov_video_tags() *AvCodecTag {
|
||||
return (*AvCodecTag)(C.avformat_get_mov_video_tags())
|
||||
}
|
||||
|
||||
//struct AVCodecTag * avformat_get_mov_audio_tags (void)
|
||||
func Avformat_get_mov_audio_tags() *AVCodecTag {
|
||||
return (*AVCodecTag)(C.avformat_get_mov_audio_tags())
|
||||
//struct AvCodecTag * avformat_get_mov_audio_tags (void)
|
||||
func Avformat_get_mov_audio_tags() *AvCodecTag {
|
||||
return (*AvCodecTag)(C.avformat_get_mov_audio_tags())
|
||||
}
|
||||
|
||||
//AVRational av_guess_sample_aspect_ratio (AVFormatContext *format, AVStream *stream, AVFrame *frame)
|
||||
//AvRational av_guess_sample_aspect_ratio (AvFormatContext *format, AvStream *stream, AvFrame *frame)
|
||||
//Guess the sample aspect ratio of a frame, based on both the stream and the frame aspect ratio.
|
||||
func Av_guess_sample_aspect_ratio(f *AVFormatContext, st *AVStream, fr *AVFrame) AVRational {
|
||||
return (AVRational)(C.av_guess_sample_aspect_ratio((*C.struct_AVFormatContext)(f), (*C.struct_AVStream)(st), (*C.struct_AVFrame)(fr)))
|
||||
func Av_guess_sample_aspect_ratio(f *AvFormatContext, st *AvStream, fr *AvFrame) AvRational {
|
||||
return (AvRational)(C.av_guess_sample_aspect_ratio((*C.struct_AVFormatContext)(f), (*C.struct_AVStream)(st), (*C.struct_AVFrame)(fr)))
|
||||
}
|
||||
|
||||
//AVRational av_guess_frame_rate (AVFormatContext *ctx, AVStream *stream, AVFrame *frame)
|
||||
//AvRational av_guess_frame_rate (AvFormatContext *ctx, AvStream *stream, AvFrame *frame)
|
||||
//Guess the frame rate, based on both the container and codec information.
|
||||
func Av_guess_frame_rate(ctx *AVFormatContext, st *AVStream, fr *AVFrame) AVRational {
|
||||
return (AVRational)(C.av_guess_frame_rate((*C.struct_AVFormatContext)(ctx), (*C.struct_AVStream)(st), (*C.struct_AVFrame)(fr)))
|
||||
func Av_guess_frame_rate(ctx *AvFormatContext, st *AvStream, fr *AvFrame) AvRational {
|
||||
return (AvRational)(C.av_guess_frame_rate((*C.struct_AVFormatContext)(ctx), (*C.struct_AVStream)(st), (*C.struct_AVFrame)(fr)))
|
||||
}
|
||||
|
||||
//int avformat_match_stream_specifier (AVFormatContext *s, AVStream *st, const char *spec)
|
||||
//int avformat_match_stream_specifier (AvFormatContext *s, AvStream *st, const char *spec)
|
||||
//Check if the stream st contained in s is matched by the stream specifier spec.
|
||||
func Avformat_match_stream_specifier(s *AVFormatContext, st *AVStream, spec string) int {
|
||||
func Avformat_match_stream_specifier(s *AvFormatContext, st *AvStream, spec string) int {
|
||||
return int(C.avformat_match_stream_specifier((*C.struct_AVFormatContext)(s), (*C.struct_AVStream)(st), C.CString(spec)))
|
||||
}
|
||||
|
||||
//int avformat_queue_attached_pictures (AVFormatContext *s)
|
||||
func Avformat_queue_attached_pictures(s *AVFormatContext) int {
|
||||
//int avformat_queue_attached_pictures (AvFormatContext *s)
|
||||
func Avformat_queue_attached_pictures(s *AvFormatContext) int {
|
||||
return int(C.avformat_queue_attached_pictures((*C.struct_AVFormatContext)(s)))
|
||||
}
|
||||
|
||||
+94
-94
@@ -12,284 +12,284 @@ import (
|
||||
)
|
||||
|
||||
// cctx := (*C.struct_AVFormatContext)(ctx)
|
||||
// return (*AVStream)(unsafe.Pointer(cctx.streams))
|
||||
// return (*AvStream)(unsafe.Pointer(cctx.streams))
|
||||
|
||||
func (ctxt *AVFormatContext) Chapters() **AVChapter {
|
||||
return (**AVChapter)(unsafe.Pointer(ctxt.chapters))
|
||||
func (ctxt *AvFormatContext) Chapters() **AvChapter {
|
||||
return (**AvChapter)(unsafe.Pointer(ctxt.chapters))
|
||||
}
|
||||
|
||||
func (ctxt *AVFormatContext) Audio_codec() *AVCodec {
|
||||
return (*AVCodec)(unsafe.Pointer(ctxt.audio_codec))
|
||||
func (ctxt *AvFormatContext) Audio_codec() *AvCodec {
|
||||
return (*AvCodec)(unsafe.Pointer(ctxt.audio_codec))
|
||||
}
|
||||
|
||||
func (ctxt *AVFormatContext) Subtitle_codec() *AVCodec {
|
||||
return (*AVCodec)(unsafe.Pointer(ctxt.subtitle_codec))
|
||||
func (ctxt *AvFormatContext) Subtitle_codec() *AvCodec {
|
||||
return (*AvCodec)(unsafe.Pointer(ctxt.subtitle_codec))
|
||||
}
|
||||
|
||||
func (ctxt *AVFormatContext) Video_codec() *AVCodec {
|
||||
return (*AVCodec)(unsafe.Pointer(ctxt.video_codec))
|
||||
func (ctxt *AvFormatContext) Video_codec() *AvCodec {
|
||||
return (*AvCodec)(unsafe.Pointer(ctxt.video_codec))
|
||||
}
|
||||
|
||||
func (ctxt *AVFormatContext) Metadata() *AVDictionary {
|
||||
return (*AVDictionary)(unsafe.Pointer(ctxt.metadata))
|
||||
func (ctxt *AvFormatContext) Metadata() *AvDictionary {
|
||||
return (*AvDictionary)(unsafe.Pointer(ctxt.metadata))
|
||||
}
|
||||
|
||||
func (ctxt *AVFormatContext) Internal() *AVFormatInternal {
|
||||
return (*AVFormatInternal)(unsafe.Pointer(ctxt.internal))
|
||||
func (ctxt *AvFormatContext) Internal() *AvFormatInternal {
|
||||
return (*AvFormatInternal)(unsafe.Pointer(ctxt.internal))
|
||||
}
|
||||
|
||||
func (ctxt *AVFormatContext) Pb() *AVIOContext {
|
||||
return (*AVIOContext)(unsafe.Pointer(ctxt.pb))
|
||||
func (ctxt *AvFormatContext) Pb() *AvIOContext {
|
||||
return (*AvIOContext)(unsafe.Pointer(ctxt.pb))
|
||||
}
|
||||
|
||||
func (ctxt *AVFormatContext) Interrupt_callback() AVIOInterruptCB {
|
||||
return AVIOInterruptCB(ctxt.interrupt_callback)
|
||||
func (ctxt *AvFormatContext) Interrupt_callback() AvIOInterruptCB {
|
||||
return AvIOInterruptCB(ctxt.interrupt_callback)
|
||||
}
|
||||
|
||||
func (ctxt *AVFormatContext) Programs() **AVProgram {
|
||||
return (**AVProgram)(unsafe.Pointer(ctxt.programs))
|
||||
func (ctxt *AvFormatContext) Programs() **AvProgram {
|
||||
return (**AvProgram)(unsafe.Pointer(ctxt.programs))
|
||||
}
|
||||
|
||||
func (ctxt *AVFormatContext) Offset_timebase() AVRational {
|
||||
return AVRational(ctxt.offset_timebase)
|
||||
func (ctxt *AvFormatContext) Offset_timebase() AvRational {
|
||||
return AvRational(ctxt.offset_timebase)
|
||||
}
|
||||
|
||||
func (ctxt *AVFormatContext) Streams() *AVStream {
|
||||
return (*AVStream)(unsafe.Pointer(ctxt.streams))
|
||||
func (ctxt *AvFormatContext) Streams() *AvStream {
|
||||
return (*AvStream)(unsafe.Pointer(ctxt.streams))
|
||||
}
|
||||
|
||||
func (ctxt *AVFormatContext) Filename() string {
|
||||
func (ctxt *AvFormatContext) Filename() string {
|
||||
return C.GoString((*C.char)(unsafe.Pointer(&ctxt.filename[0])))
|
||||
}
|
||||
|
||||
// func (ctxt *AVFormatContext) Codec_whitelist() string {
|
||||
// func (ctxt *AvFormatContext) Codec_whitelist() string {
|
||||
// return C.GoString(ctxt.codec_whitelist)
|
||||
// }
|
||||
|
||||
// func (ctxt *AVFormatContext) Format_whitelist() string {
|
||||
// func (ctxt *AvFormatContext) Format_whitelist() string {
|
||||
// return C.GoString(ctxt.format_whitelist)
|
||||
// }
|
||||
|
||||
func (ctxt *AVFormatContext) Audio_codec_id() AVCodecID {
|
||||
return AVCodecID(ctxt.audio_codec_id)
|
||||
func (ctxt *AvFormatContext) Audio_codec_id() AvCodecId {
|
||||
return AvCodecId(ctxt.audio_codec_id)
|
||||
}
|
||||
|
||||
func (ctxt *AVFormatContext) Subtitle_codec_id() AVCodecID {
|
||||
return AVCodecID(ctxt.subtitle_codec_id)
|
||||
func (ctxt *AvFormatContext) Subtitle_codec_id() AvCodecId {
|
||||
return AvCodecId(ctxt.subtitle_codec_id)
|
||||
}
|
||||
|
||||
func (ctxt *AVFormatContext) Video_codec_id() AVCodecID {
|
||||
return AVCodecID(ctxt.video_codec_id)
|
||||
func (ctxt *AvFormatContext) Video_codec_id() AvCodecId {
|
||||
return AvCodecId(ctxt.video_codec_id)
|
||||
}
|
||||
|
||||
func (ctxt *AVFormatContext) Duration_estimation_method() AVDurationEstimationMethod {
|
||||
return AVDurationEstimationMethod(ctxt.duration_estimation_method)
|
||||
func (ctxt *AvFormatContext) Duration_estimation_method() AvDurationEstimationMethod {
|
||||
return AvDurationEstimationMethod(ctxt.duration_estimation_method)
|
||||
}
|
||||
|
||||
func (ctxt *AVFormatContext) Audio_preload() int {
|
||||
func (ctxt *AvFormatContext) Audio_preload() int {
|
||||
return int(ctxt.audio_preload)
|
||||
}
|
||||
|
||||
func (ctxt *AVFormatContext) Avio_flags() int {
|
||||
func (ctxt *AvFormatContext) Avio_flags() int {
|
||||
return int(ctxt.avio_flags)
|
||||
}
|
||||
|
||||
func (ctxt *AVFormatContext) Avoid_negative_ts() int {
|
||||
func (ctxt *AvFormatContext) Avoid_negative_ts() int {
|
||||
return int(ctxt.avoid_negative_ts)
|
||||
}
|
||||
|
||||
func (ctxt *AVFormatContext) Bit_rate() int {
|
||||
func (ctxt *AvFormatContext) Bit_rate() int {
|
||||
return int(ctxt.bit_rate)
|
||||
}
|
||||
|
||||
func (ctxt *AVFormatContext) Ctx_flags() int {
|
||||
func (ctxt *AvFormatContext) Ctx_flags() int {
|
||||
return int(ctxt.ctx_flags)
|
||||
}
|
||||
|
||||
func (ctxt *AVFormatContext) Debug() int {
|
||||
func (ctxt *AvFormatContext) Debug() int {
|
||||
return int(ctxt.debug)
|
||||
}
|
||||
|
||||
func (ctxt *AVFormatContext) Error_recognition() int {
|
||||
func (ctxt *AvFormatContext) Error_recognition() int {
|
||||
return int(ctxt.error_recognition)
|
||||
}
|
||||
|
||||
func (ctxt *AVFormatContext) Event_flags() int {
|
||||
func (ctxt *AvFormatContext) Event_flags() int {
|
||||
return int(ctxt.event_flags)
|
||||
}
|
||||
|
||||
func (ctxt *AVFormatContext) Flags() int {
|
||||
func (ctxt *AvFormatContext) Flags() int {
|
||||
return int(ctxt.flags)
|
||||
}
|
||||
|
||||
func (ctxt *AVFormatContext) Flush_packets() int {
|
||||
func (ctxt *AvFormatContext) Flush_packets() int {
|
||||
return int(ctxt.flush_packets)
|
||||
}
|
||||
|
||||
func (ctxt *AVFormatContext) Format_probesize() int {
|
||||
func (ctxt *AvFormatContext) Format_probesize() int {
|
||||
return int(ctxt.format_probesize)
|
||||
}
|
||||
|
||||
func (ctxt *AVFormatContext) Fps_probe_size() int {
|
||||
func (ctxt *AvFormatContext) Fps_probe_size() int {
|
||||
return int(ctxt.fps_probe_size)
|
||||
}
|
||||
|
||||
func (ctxt *AVFormatContext) Io_repositioned() int {
|
||||
func (ctxt *AvFormatContext) Io_repositioned() int {
|
||||
return int(ctxt.io_repositioned)
|
||||
}
|
||||
|
||||
func (ctxt *AVFormatContext) Keylen() int {
|
||||
func (ctxt *AvFormatContext) Keylen() int {
|
||||
return int(ctxt.keylen)
|
||||
}
|
||||
|
||||
func (ctxt *AVFormatContext) Max_chunk_duration() int {
|
||||
func (ctxt *AvFormatContext) Max_chunk_duration() int {
|
||||
return int(ctxt.max_chunk_duration)
|
||||
}
|
||||
|
||||
func (ctxt *AVFormatContext) Max_chunk_size() int {
|
||||
func (ctxt *AvFormatContext) Max_chunk_size() int {
|
||||
return int(ctxt.max_chunk_size)
|
||||
}
|
||||
|
||||
func (ctxt *AVFormatContext) Max_delay() int {
|
||||
func (ctxt *AvFormatContext) Max_delay() int {
|
||||
return int(ctxt.max_delay)
|
||||
}
|
||||
|
||||
func (ctxt *AVFormatContext) Max_ts_probe() int {
|
||||
func (ctxt *AvFormatContext) Max_ts_probe() int {
|
||||
return int(ctxt.max_ts_probe)
|
||||
}
|
||||
|
||||
func (ctxt *AVFormatContext) Metadata_header_padding() int {
|
||||
func (ctxt *AvFormatContext) Metadata_header_padding() int {
|
||||
return int(ctxt.metadata_header_padding)
|
||||
}
|
||||
|
||||
func (ctxt *AVFormatContext) Probe_score() int {
|
||||
func (ctxt *AvFormatContext) Probe_score() int {
|
||||
return int(ctxt.probe_score)
|
||||
}
|
||||
|
||||
func (ctxt *AVFormatContext) Raw_packet_buffer_remaining_size() int {
|
||||
func (ctxt *AvFormatContext) Raw_packet_buffer_remaining_size() int {
|
||||
return int(ctxt.raw_packet_buffer_remaining_size)
|
||||
}
|
||||
|
||||
func (ctxt *AVFormatContext) Seek2any() int {
|
||||
func (ctxt *AvFormatContext) Seek2any() int {
|
||||
return int(ctxt.seek2any)
|
||||
}
|
||||
|
||||
func (ctxt *AVFormatContext) Strict_std_compliance() int {
|
||||
func (ctxt *AvFormatContext) Strict_std_compliance() int {
|
||||
return int(ctxt.strict_std_compliance)
|
||||
}
|
||||
|
||||
func (ctxt *AVFormatContext) Ts_id() int {
|
||||
func (ctxt *AvFormatContext) Ts_id() int {
|
||||
return int(ctxt.ts_id)
|
||||
}
|
||||
|
||||
func (ctxt *AVFormatContext) Use_wallclock_as_timestamps() int {
|
||||
func (ctxt *AvFormatContext) Use_wallclock_as_timestamps() int {
|
||||
return int(ctxt.use_wallclock_as_timestamps)
|
||||
}
|
||||
|
||||
func (ctxt *AVFormatContext) Data_offset() int64 {
|
||||
func (ctxt *AvFormatContext) Data_offset() int64 {
|
||||
return int64(ctxt.data_offset)
|
||||
}
|
||||
|
||||
func (ctxt *AVFormatContext) Duration() int64 {
|
||||
func (ctxt *AvFormatContext) Duration() int64 {
|
||||
return int64(ctxt.duration)
|
||||
}
|
||||
|
||||
func (ctxt *AVFormatContext) Max_analyze_duration2() int64 {
|
||||
func (ctxt *AvFormatContext) Max_analyze_duration2() int64 {
|
||||
return int64(ctxt.max_analyze_duration2)
|
||||
}
|
||||
|
||||
func (ctxt *AVFormatContext) Max_interleave_delta() int64 {
|
||||
func (ctxt *AvFormatContext) Max_interleave_delta() int64 {
|
||||
return int64(ctxt.max_interleave_delta)
|
||||
}
|
||||
|
||||
func (ctxt *AVFormatContext) Offset() int64 {
|
||||
func (ctxt *AvFormatContext) Offset() int64 {
|
||||
return int64(ctxt.offset)
|
||||
}
|
||||
|
||||
func (ctxt *AVFormatContext) Output_ts_offset() int64 {
|
||||
func (ctxt *AvFormatContext) Output_ts_offset() int64 {
|
||||
return int64(ctxt.output_ts_offset)
|
||||
}
|
||||
|
||||
func (ctxt *AVFormatContext) Probesize2() int64 {
|
||||
func (ctxt *AvFormatContext) Probesize2() int64 {
|
||||
return int64(ctxt.probesize2)
|
||||
}
|
||||
|
||||
func (ctxt *AVFormatContext) Skip_initial_bytes() int64 {
|
||||
func (ctxt *AvFormatContext) Skip_initial_bytes() int64 {
|
||||
return int64(ctxt.skip_initial_bytes)
|
||||
}
|
||||
|
||||
func (ctxt *AVFormatContext) Start_time() int64 {
|
||||
func (ctxt *AvFormatContext) Start_time() int64 {
|
||||
return int64(ctxt.start_time)
|
||||
}
|
||||
|
||||
func (ctxt *AVFormatContext) Start_time_realtime() int64 {
|
||||
func (ctxt *AvFormatContext) Start_time_realtime() int64 {
|
||||
return int64(ctxt.start_time_realtime)
|
||||
}
|
||||
|
||||
func (ctxt *AVFormatContext) Iformat() *AVInputFormat {
|
||||
return (*AVInputFormat)(unsafe.Pointer(ctxt.iformat))
|
||||
func (ctxt *AvFormatContext) Iformat() *AvInputFormat {
|
||||
return (*AvInputFormat)(unsafe.Pointer(ctxt.iformat))
|
||||
}
|
||||
|
||||
func (ctxt *AVFormatContext) Oformat() *AVOutputFormat {
|
||||
return (*AVOutputFormat)(unsafe.Pointer(ctxt.oformat))
|
||||
func (ctxt *AvFormatContext) Oformat() *AvOutputFormat {
|
||||
return (*AvOutputFormat)(unsafe.Pointer(ctxt.oformat))
|
||||
}
|
||||
|
||||
func (ctxt *AVFormatContext) Packet_buffer() *AVPacketList {
|
||||
return (*AVPacketList)(unsafe.Pointer(ctxt.packet_buffer))
|
||||
func (ctxt *AvFormatContext) Packet_buffer() *AvPacketList {
|
||||
return (*AvPacketList)(unsafe.Pointer(ctxt.packet_buffer))
|
||||
}
|
||||
|
||||
func (ctxt *AVFormatContext) Packet_buffer_end() *AVPacketList {
|
||||
return (*AVPacketList)(unsafe.Pointer(ctxt.packet_buffer_end))
|
||||
func (ctxt *AvFormatContext) Packet_buffer_end() *AvPacketList {
|
||||
return (*AvPacketList)(unsafe.Pointer(ctxt.packet_buffer_end))
|
||||
}
|
||||
|
||||
func (ctxt *AVFormatContext) Parse_queue() *AVPacketList {
|
||||
return (*AVPacketList)(unsafe.Pointer(ctxt.parse_queue))
|
||||
func (ctxt *AvFormatContext) Parse_queue() *AvPacketList {
|
||||
return (*AvPacketList)(unsafe.Pointer(ctxt.parse_queue))
|
||||
}
|
||||
|
||||
func (ctxt *AVFormatContext) Parse_queue_end() *AVPacketList {
|
||||
return (*AVPacketList)(unsafe.Pointer(ctxt.parse_queue_end))
|
||||
func (ctxt *AvFormatContext) Parse_queue_end() *AvPacketList {
|
||||
return (*AvPacketList)(unsafe.Pointer(ctxt.parse_queue_end))
|
||||
}
|
||||
|
||||
func (ctxt *AVFormatContext) Raw_packet_buffer() *AVPacketList {
|
||||
return (*AVPacketList)(unsafe.Pointer(ctxt.raw_packet_buffer))
|
||||
func (ctxt *AvFormatContext) Raw_packet_buffer() *AvPacketList {
|
||||
return (*AvPacketList)(unsafe.Pointer(ctxt.raw_packet_buffer))
|
||||
}
|
||||
|
||||
func (ctxt *AVFormatContext) Raw_packet_buffer_end() *AVPacketList {
|
||||
return (*AVPacketList)(unsafe.Pointer(ctxt.raw_packet_buffer_end))
|
||||
func (ctxt *AvFormatContext) Raw_packet_buffer_end() *AvPacketList {
|
||||
return (*AvPacketList)(unsafe.Pointer(ctxt.raw_packet_buffer_end))
|
||||
}
|
||||
|
||||
// func (ctxt *AVFormatContext) Dump_separator() uint8 {
|
||||
// func (ctxt *AvFormatContext) Dump_separator() uint8 {
|
||||
// return uint8(ctxt.dump_separator)
|
||||
// }
|
||||
|
||||
func (ctxt *AVFormatContext) Correct_ts_overflow() int {
|
||||
func (ctxt *AvFormatContext) Correct_ts_overflow() int {
|
||||
return int(ctxt.correct_ts_overflow)
|
||||
}
|
||||
|
||||
func (ctxt *AVFormatContext) Max_index_size() uint {
|
||||
func (ctxt *AvFormatContext) Max_index_size() uint {
|
||||
return uint(ctxt.max_index_size)
|
||||
}
|
||||
|
||||
func (ctxt *AVFormatContext) Max_picture_buffer() uint {
|
||||
func (ctxt *AvFormatContext) Max_picture_buffer() uint {
|
||||
return uint(ctxt.max_picture_buffer)
|
||||
}
|
||||
|
||||
func (ctxt *AVFormatContext) Nb_chapters() uint {
|
||||
func (ctxt *AvFormatContext) Nb_chapters() uint {
|
||||
return uint(ctxt.nb_chapters)
|
||||
}
|
||||
|
||||
func (ctxt *AVFormatContext) Nb_programs() uint {
|
||||
func (ctxt *AvFormatContext) Nb_programs() uint {
|
||||
return uint(ctxt.nb_programs)
|
||||
}
|
||||
|
||||
func (ctxt *AVFormatContext) Nb_streams() uint {
|
||||
func (ctxt *AvFormatContext) Nb_streams() uint {
|
||||
return uint(ctxt.nb_streams)
|
||||
}
|
||||
|
||||
func (ctxt *AVFormatContext) Packet_size() uint {
|
||||
func (ctxt *AvFormatContext) Packet_size() uint {
|
||||
return uint(ctxt.packet_size)
|
||||
}
|
||||
|
||||
func (ctxt *AVFormatContext) Probesize() uint {
|
||||
func (ctxt *AvFormatContext) Probesize() uint {
|
||||
return uint(ctxt.probesize)
|
||||
}
|
||||
|
||||
+69
-69
@@ -11,218 +11,218 @@ import (
|
||||
"unsafe"
|
||||
)
|
||||
|
||||
func (avs *AVStream) Codec() *AVCodecContext {
|
||||
return (*AVCodecContext)(unsafe.Pointer(avs.codec))
|
||||
func (avs *AvStream) Codec() *AvCodecContext {
|
||||
return (*AvCodecContext)(unsafe.Pointer(avs.codec))
|
||||
}
|
||||
|
||||
func (avs *AVStream) Metadata() *AVDictionary {
|
||||
return (*AVDictionary)(unsafe.Pointer(avs.metadata))
|
||||
func (avs *AvStream) Metadata() *AvDictionary {
|
||||
return (*AvDictionary)(unsafe.Pointer(avs.metadata))
|
||||
}
|
||||
|
||||
func (avs *AVStream) Index_entries() *AVIndexEntry {
|
||||
return (*AVIndexEntry)(unsafe.Pointer(avs.index_entries))
|
||||
func (avs *AvStream) Index_entries() *AvIndexEntry {
|
||||
return (*AvIndexEntry)(unsafe.Pointer(avs.index_entries))
|
||||
}
|
||||
|
||||
func (avs *AVStream) Attached_pic() AVPacket {
|
||||
return AVPacket(avs.attached_pic)
|
||||
func (avs *AvStream) Attached_pic() AvPacket {
|
||||
return AvPacket(avs.attached_pic)
|
||||
}
|
||||
|
||||
func (avs *AVStream) Side_data() *AVPacketSideData {
|
||||
return (*AVPacketSideData)(unsafe.Pointer(avs.side_data))
|
||||
func (avs *AvStream) Side_data() *AvPacketSideData {
|
||||
return (*AvPacketSideData)(unsafe.Pointer(avs.side_data))
|
||||
}
|
||||
|
||||
func (avs *AVStream) Probe_data() AVProbeData {
|
||||
return AVProbeData(avs.probe_data)
|
||||
func (avs *AvStream) Probe_data() AvProbeData {
|
||||
return AvProbeData(avs.probe_data)
|
||||
}
|
||||
|
||||
func (avs *AVStream) Avg_frame_rate() AVRational {
|
||||
return AVRational(avs.avg_frame_rate)
|
||||
func (avs *AvStream) Avg_frame_rate() AvRational {
|
||||
return AvRational(avs.avg_frame_rate)
|
||||
}
|
||||
|
||||
// func (avs *AVStream) Display_aspect_ratio() *AVRational {
|
||||
// return (*AVRational)(unsafe.Pointer(avs.display_aspect_ratio))
|
||||
// func (avs *AvStream) Display_aspect_ratio() *AvRational {
|
||||
// return (*AvRational)(unsafe.Pointer(avs.display_aspect_ratio))
|
||||
// }
|
||||
|
||||
func (avs *AVStream) R_frame_rate() AVRational {
|
||||
return AVRational(avs.r_frame_rate)
|
||||
func (avs *AvStream) R_frame_rate() AvRational {
|
||||
return AvRational(avs.r_frame_rate)
|
||||
}
|
||||
|
||||
func (avs *AVStream) Sample_aspect_ratio() AVRational {
|
||||
return AVRational(avs.sample_aspect_ratio)
|
||||
func (avs *AvStream) Sample_aspect_ratio() AvRational {
|
||||
return AvRational(avs.sample_aspect_ratio)
|
||||
}
|
||||
|
||||
func (avs *AVStream) Time_base() AVRational {
|
||||
return AVRational(avs.time_base)
|
||||
func (avs *AvStream) Time_base() AvRational {
|
||||
return AvRational(avs.time_base)
|
||||
}
|
||||
|
||||
// func (avs *AVStream) Recommended_encoder_configuration() string {
|
||||
// func (avs *AvStream) Recommended_encoder_configuration() string {
|
||||
// return C.GoString(avs.recommended_encoder_configuration)
|
||||
// }
|
||||
|
||||
func (avs *AVStream) Discard() AVDiscard {
|
||||
return AVDiscard(avs.discard)
|
||||
func (avs *AvStream) Discard() AvDiscard {
|
||||
return AvDiscard(avs.discard)
|
||||
}
|
||||
|
||||
func (avs *AVStream) Need_parsing() AVStreamParseType {
|
||||
return AVStreamParseType(avs.need_parsing)
|
||||
func (avs *AvStream) Need_parsing() AvStreamParseType {
|
||||
return AvStreamParseType(avs.need_parsing)
|
||||
}
|
||||
|
||||
func (avs *AVStream) Codec_info_nb_frames() int {
|
||||
func (avs *AvStream) Codec_info_nb_frames() int {
|
||||
return int(avs.codec_info_nb_frames)
|
||||
}
|
||||
|
||||
func (avs *AVStream) Disposition() int {
|
||||
func (avs *AvStream) Disposition() int {
|
||||
return int(avs.disposition)
|
||||
}
|
||||
|
||||
func (avs *AVStream) Event_flags() int {
|
||||
func (avs *AvStream) Event_flags() int {
|
||||
return int(avs.event_flags)
|
||||
}
|
||||
|
||||
func (avs *AVStream) Id() int {
|
||||
func (avs *AvStream) Id() int {
|
||||
return int(avs.id)
|
||||
}
|
||||
|
||||
func (avs *AVStream) Index() int {
|
||||
func (avs *AvStream) Index() int {
|
||||
return int(avs.index)
|
||||
}
|
||||
|
||||
func (avs *AVStream) Inject_global_side_data() int {
|
||||
func (avs *AvStream) Inject_global_side_data() int {
|
||||
return int(avs.inject_global_side_data)
|
||||
}
|
||||
|
||||
func (avs *AVStream) Last_ip_duration() int {
|
||||
func (avs *AvStream) Last_ip_duration() int {
|
||||
return int(avs.last_IP_duration)
|
||||
}
|
||||
|
||||
func (avs *AVStream) Nb_decoded_frames() int {
|
||||
func (avs *AvStream) Nb_decoded_frames() int {
|
||||
return int(avs.nb_decoded_frames)
|
||||
}
|
||||
|
||||
func (avs *AVStream) Nb_index_entries() int {
|
||||
func (avs *AvStream) Nb_index_entries() int {
|
||||
return int(avs.nb_index_entries)
|
||||
}
|
||||
|
||||
func (avs *AVStream) Nb_side_data() int {
|
||||
func (avs *AvStream) Nb_side_data() int {
|
||||
return int(avs.nb_side_data)
|
||||
}
|
||||
|
||||
func (avs *AVStream) Probe_packets() int {
|
||||
func (avs *AvStream) Probe_packets() int {
|
||||
return int(avs.probe_packets)
|
||||
}
|
||||
|
||||
func (avs *AVStream) Pts_wrap_behavior() int {
|
||||
func (avs *AvStream) Pts_wrap_behavior() int {
|
||||
return int(avs.pts_wrap_behavior)
|
||||
}
|
||||
|
||||
func (avs *AVStream) Request_probe() int {
|
||||
func (avs *AvStream) Request_probe() int {
|
||||
return int(avs.request_probe)
|
||||
}
|
||||
|
||||
func (avs *AVStream) Skip_samples() int {
|
||||
func (avs *AvStream) Skip_samples() int {
|
||||
return int(avs.skip_samples)
|
||||
}
|
||||
|
||||
func (avs *AVStream) Skip_to_keyframe() int {
|
||||
func (avs *AvStream) Skip_to_keyframe() int {
|
||||
return int(avs.skip_to_keyframe)
|
||||
}
|
||||
|
||||
func (avs *AVStream) Stream_identifier() int {
|
||||
func (avs *AvStream) Stream_identifier() int {
|
||||
return int(avs.stream_identifier)
|
||||
}
|
||||
|
||||
func (avs *AVStream) Update_initial_durations_done() int {
|
||||
func (avs *AvStream) Update_initial_durations_done() int {
|
||||
return int(avs.update_initial_durations_done)
|
||||
}
|
||||
|
||||
func (avs *AVStream) Cur_dts() int64 {
|
||||
func (avs *AvStream) Cur_dts() int64 {
|
||||
return int64(avs.cur_dts)
|
||||
}
|
||||
|
||||
func (avs *AVStream) Duration() int64 {
|
||||
func (avs *AvStream) Duration() int64 {
|
||||
return int64(avs.duration)
|
||||
}
|
||||
|
||||
// func (avs *AVStream) First_discard_sample() int64 {
|
||||
// func (avs *AvStream) First_discard_sample() int64 {
|
||||
// return int64(avs.first_discard_sample)
|
||||
// }
|
||||
|
||||
func (avs *AVStream) First_dts() int64 {
|
||||
func (avs *AvStream) First_dts() int64 {
|
||||
return int64(avs.first_dts)
|
||||
}
|
||||
|
||||
func (avs *AVStream) Interleaver_chunk_duration() int64 {
|
||||
func (avs *AvStream) Interleaver_chunk_duration() int64 {
|
||||
return int64(avs.interleaver_chunk_duration)
|
||||
}
|
||||
|
||||
func (avs *AVStream) Interleaver_chunk_size() int64 {
|
||||
func (avs *AvStream) Interleaver_chunk_size() int64 {
|
||||
return int64(avs.interleaver_chunk_size)
|
||||
}
|
||||
|
||||
// func (avs *AVStream) Last_discard_sample() int64 {
|
||||
// func (avs *AvStream) Last_discard_sample() int64 {
|
||||
// return int64(avs.last_discard_sample)
|
||||
// }
|
||||
|
||||
func (avs *AVStream) Last_dts_for_order_check() int64 {
|
||||
func (avs *AvStream) Last_dts_for_order_check() int64 {
|
||||
return int64(avs.last_dts_for_order_check)
|
||||
}
|
||||
|
||||
func (avs *AVStream) Last_ip_pts() int64 {
|
||||
func (avs *AvStream) Last_ip_pts() int64 {
|
||||
return int64(avs.last_IP_pts)
|
||||
}
|
||||
|
||||
func (avs *AVStream) Mux_ts_offset() int64 {
|
||||
func (avs *AvStream) Mux_ts_offset() int64 {
|
||||
return int64(avs.mux_ts_offset)
|
||||
}
|
||||
|
||||
func (avs *AVStream) Nb_frames() int64 {
|
||||
func (avs *AvStream) Nb_frames() int64 {
|
||||
return int64(avs.nb_frames)
|
||||
}
|
||||
|
||||
func (avs *AVStream) Pts_buffer() int64 {
|
||||
func (avs *AvStream) Pts_buffer() int64 {
|
||||
return int64(avs.pts_buffer[0])
|
||||
}
|
||||
|
||||
func (avs *AVStream) Pts_reorder_error() int64 {
|
||||
func (avs *AvStream) Pts_reorder_error() int64 {
|
||||
return int64(avs.pts_reorder_error[0])
|
||||
}
|
||||
|
||||
func (avs *AVStream) Pts_wrap_reference() int64 {
|
||||
func (avs *AvStream) Pts_wrap_reference() int64 {
|
||||
return int64(avs.pts_wrap_reference)
|
||||
}
|
||||
|
||||
// func (avs *AVStream) Start_skip_samples() int64 {
|
||||
// func (avs *AvStream) Start_skip_samples() int64 {
|
||||
// return int64(avs.start_skip_samples)
|
||||
// }
|
||||
|
||||
func (avs *AVStream) Start_time() int64 {
|
||||
func (avs *AvStream) Start_time() int64 {
|
||||
return int64(avs.start_time)
|
||||
}
|
||||
|
||||
func (avs *AVStream) Parser() *AVCodecParserContext {
|
||||
return (*AVCodecParserContext)(unsafe.Pointer(avs.parser))
|
||||
func (avs *AvStream) Parser() *AvCodecParserContext {
|
||||
return (*AvCodecParserContext)(unsafe.Pointer(avs.parser))
|
||||
}
|
||||
|
||||
func (avs *AVStream) Last_in_packet_buffer() *AVPacketList {
|
||||
return (*AVPacketList)(unsafe.Pointer(avs.last_in_packet_buffer))
|
||||
func (avs *AvStream) Last_in_packet_buffer() *AvPacketList {
|
||||
return (*AvPacketList)(unsafe.Pointer(avs.last_in_packet_buffer))
|
||||
}
|
||||
|
||||
// func (avs *AVStream) Priv_pts() *FFFrac {
|
||||
// func (avs *AvStream) Priv_pts() *FFFrac {
|
||||
// return (*FFFrac)(unsafe.Pointer(avs.priv_pts))
|
||||
// }
|
||||
|
||||
func (avs *AVStream) Dts_misordered() uint8 {
|
||||
func (avs *AvStream) Dts_misordered() uint8 {
|
||||
return uint8(avs.dts_misordered)
|
||||
}
|
||||
|
||||
func (avs *AVStream) Dts_ordered() uint8 {
|
||||
func (avs *AvStream) Dts_ordered() uint8 {
|
||||
return uint8(avs.dts_ordered)
|
||||
}
|
||||
|
||||
func (avs *AVStream) Pts_reorder_error_count() uint8 {
|
||||
func (avs *AvStream) Pts_reorder_error_count() uint8 {
|
||||
return uint8(avs.pts_reorder_error_count[0])
|
||||
}
|
||||
|
||||
func (avs *AVStream) Index_entries_allocated_size() uint {
|
||||
func (avs *AvStream) Index_entries_allocated_size() uint {
|
||||
return uint(avs.index_entries_allocated_size)
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user