diff --git a/avcodec/avcodec.go b/avcodec/avcodec.go index ae36810..77435c8 100644 --- a/avcodec/avcodec.go +++ b/avcodec/avcodec.go @@ -22,49 +22,49 @@ import ( ) type ( - AvBitStreamFilter C.struct_AVBitStreamFilter - AvBitStreamFilterContext C.struct_AVBitStreamFilterContext - AvClass C.struct_AVClass - AvCodec C.struct_AVCodec + Codec C.struct_AVCodec Context C.struct_AVCodecContext - AvCodecDescriptor C.struct_AVCodecDescriptor - AvCodecParser C.struct_AVCodecParser - AvCodecParserContext C.struct_AVCodecParserContext - AvDictionary C.struct_AVDictionary - AvFrame C.struct_AVFrame + Descriptor C.struct_AVCodecDescriptor + Parser C.struct_AVCodecParser + ParserContext C.struct_AVCodecParserContext + Dictionary C.struct_AVDictionary + Frame C.struct_AVFrame + MediaType C.enum_AVMediaType + Packet C.struct_AVPacket + BitStreamFilter C.struct_AVBitStreamFilter + BitStreamFilterContext C.struct_AVBitStreamFilterContext + Rational C.struct_AVRational + AvClass C.struct_AVClass AvHWAccel C.struct_AVHWAccel - AvPacket C.struct_AVPacket AvPacketSideData C.struct_AVPacketSideData AvPanScan C.struct_AVPanScan AvPicture C.struct_AVPicture AvProfile C.struct_AVProfile - AvRational C.struct_AVRational AvSubtitle C.struct_AVSubtitle AvSubtitleRect C.struct_AVSubtitleRect RcOverride C.struct_RcOverride AvBufferRef C.struct_AVBufferRef AvAudioServiceType C.enum_AVAudioServiceType AvChromaLocation C.enum_AVChromaLocation - AvCodecId C.enum_AVCodecID + CodecId C.enum_AVCodecID AvColorPrimaries C.enum_AVColorPrimaries AvColorRange C.enum_AVColorRange AvColorSpace C.enum_AVColorSpace AvColorTransferCharacteristic C.enum_AVColorTransferCharacteristic AvDiscard C.enum_AVDiscard AvFieldOrder C.enum_AVFieldOrder - AvMediaType C.enum_AVMediaType AvPacketSideDataType C.enum_AVPacketSideDataType - AvPixelFormat C.enum_AVPixelFormat + PixelFormat C.enum_AVPixelFormat AvSampleFormat C.enum_AVSampleFormat ) -func (c *AvCodec) AvCodecGetMaxLowres() int { +func (c *Codec) AvCodecGetMaxLowres() int { return int(C.av_codec_get_max_lowres((*C.struct_AVCodec)(c))) } //If c is NULL, returns the first registered codec, if c is non-NULL, -func (c *AvCodec) AvCodecNext() *AvCodec { - return (*AvCodec)(C.av_codec_next((*C.struct_AVCodec)(c))) +func (c *Codec) AvCodecNext() *Codec { + return (*Codec)(C.av_codec_next((*C.struct_AVCodec)(c))) } //Return the LIBAvCODEC_VERSION_INT constant. @@ -84,7 +84,7 @@ func AvcodecLicense() string { } //Register the codec codec and initialize libavcodec. -func (c *AvCodec) AvcodecRegister() { +func (c *Codec) AvcodecRegister() { C.avcodec_register((*C.struct_AVCodec)(c)) } @@ -94,7 +94,7 @@ func AvcodecRegisterAll() { } //Allocate an Context and set its fields to default values. -func (c *AvCodec) AvcodecAllocContext3() *Context { +func (c *Codec) AvcodecAllocContext3() *Context { return (*Context)(C.avcodec_alloc_context3((*C.struct_AVCodec)(c))) } @@ -103,7 +103,7 @@ func AvcodecGetClass() *AvClass { return (*AvClass)(C.avcodec_get_class()) } -//Get the AvClass for AvFrame. +//Get the AvClass for Frame. func AvcodecGetFrameClass() *AvClass { return (*AvClass)(C.avcodec_get_frame_class()) } @@ -119,23 +119,23 @@ func AvsubtitleFree(s *AvSubtitle) { } //Pack a dictionary for use in side_data. -func AvPacketPackDictionary(d *AvDictionary, s *int) *uint8 { +func AvPacketPackDictionary(d *Dictionary, s *int) *uint8 { return (*uint8)(C.av_packet_pack_dictionary((*C.struct_AVDictionary)(d), (*C.int)(unsafe.Pointer(s)))) } //Unpack a dictionary from side_data. -func AvPacketUnpackDictionary(d *uint8, s int, dt **AvDictionary) int { +func AvPacketUnpackDictionary(d *uint8, s int, dt **Dictionary) int { return int(C.av_packet_unpack_dictionary((*C.uint8_t)(d), C.int(s), (**C.struct_AVDictionary)(unsafe.Pointer(dt)))) } //Find a registered decoder with a matching codec ID. -func AvcodecFindDecoder(id AvCodecId) *AvCodec { - return (*AvCodec)(C.avcodec_find_decoder((C.enum_AVCodecID)(id))) +func AvcodecFindDecoder(id CodecId) *Codec { + return (*Codec)(C.avcodec_find_decoder((C.enum_AVCodecID)(id))) } //Find a registered decoder with the specified name. -func AvcodecFindDecoderByName(n string) *AvCodec { - return (*AvCodec)(C.avcodec_find_decoder_by_name(C.CString(n))) +func AvcodecFindDecoderByName(n string) *Codec { + return (*Codec)(C.avcodec_find_decoder_by_name(C.CString(n))) } //Converts AvChromaLocation to swscale x/y chroma position. @@ -149,13 +149,13 @@ func AvcodecChromaPosToEnum(x, y int) AvChromaLocation { } //Find a registered encoder with a matching codec ID. -func AvcodecFindEncoder(id AvCodecId) *AvCodec { - return (*AvCodec)(C.avcodec_find_encoder((C.enum_AVCodecID)(id))) +func AvcodecFindEncoder(id CodecId) *Codec { + return (*Codec)(C.avcodec_find_encoder((C.enum_AVCodecID)(id))) } //Find a registered encoder with the specified name. -func AvcodecFindEncoderByName(c string) *AvCodec { - return (*AvCodec)(C.avcodec_find_encoder_by_name(C.CString(c))) +func AvcodecFindEncoderByName(c string) *Codec { + return (*Codec)(C.avcodec_find_encoder_by_name(C.CString(c))) } //Put a string representing the codec tag codec_tag in buf. @@ -168,53 +168,53 @@ func AvcodecString(b string, bs int, ctxt *Context, e int) { } //Return a name for the specified profile, if available. -func (c *AvCodec) AvGetProfileName(p int) string { +func (c *Codec) AvGetProfileName(p int) string { return C.GoString(C.av_get_profile_name((*C.struct_AVCodec)(c), C.int(p))) } -//Fill AvFrame audio data and linesize pointers. -func AvcodecFillAudioFrame(f *AvFrame, c int, s AvSampleFormat, b *uint8, bs, a int) int { +//Fill Frame audio data and linesize pointers. +func AvcodecFillAudioFrame(f *Frame, c int, s AvSampleFormat, b *uint8, bs, a int) int { return int(C.avcodec_fill_audio_frame((*C.struct_AVFrame)(f), C.int(c), (C.enum_AVSampleFormat)(s), (*C.uint8_t)(b), C.int(bs), C.int(a))) } //Return codec bits per sample. -func AvGetBitsPerSample(c AvCodecId) int { +func AvGetBitsPerSample(c CodecId) int { return int(C.av_get_bits_per_sample((C.enum_AVCodecID)(c))) } //Return the PCM codec associated with a sample format. -func AvGetPcmCodec(f AvSampleFormat, b int) AvCodecId { - return (AvCodecId)(C.av_get_pcm_codec((C.enum_AVSampleFormat)(f), C.int(b))) +func AvGetPcmCodec(f AvSampleFormat, b int) CodecId { + return (CodecId)(C.av_get_pcm_codec((C.enum_AVSampleFormat)(f), C.int(b))) } //Return codec bits per sample. -func AvGetExactBitsPerSample(c AvCodecId) int { +func AvGetExactBitsPerSample(c CodecId) int { return int(C.av_get_exact_bits_per_sample((C.enum_AVCodecID)(c))) } //Register a bitstream filter. -func (b *AvBitStreamFilter) AvRegisterBitstreamFilter() { +func (b *BitStreamFilter) AvRegisterBitstreamFilter() { C.av_register_bitstream_filter((*C.struct_AVBitStreamFilter)(b)) } //Create and initialize a bitstream filter context given a bitstream filter name. -func AvBitstreamFilterInit(n string) *AvBitStreamFilterContext { - return (*AvBitStreamFilterContext)(C.av_bitstream_filter_init(C.CString(n))) +func AvBitstreamFilterInit(n string) *BitStreamFilterContext { + return (*BitStreamFilterContext)(C.av_bitstream_filter_init(C.CString(n))) } //Filter bitstream. -func (bfx *AvBitStreamFilterContext) AvBitstreamFilterFilter(ctxt *Context, a string, p **uint8, ps *int, b *uint8, bs, k int) int { +func (bfx *BitStreamFilterContext) AvBitstreamFilterFilter(ctxt *Context, a string, p **uint8, ps *int, b *uint8, bs, k int) int { return int(C.av_bitstream_filter_filter((*C.struct_AVBitStreamFilterContext)(bfx), (*C.struct_AVCodecContext)(ctxt), C.CString(a), (**C.uint8_t)(unsafe.Pointer(p)), (*C.int)(unsafe.Pointer(ps)), (*C.uint8_t)(b), C.int(bs), C.int(k))) } //Release bitstream filter context. -func (bfx *AvBitStreamFilterContext) AvBitstreamFilterClose() { +func (bfx *BitStreamFilterContext) AvBitstreamFilterClose() { C.av_bitstream_filter_close((*C.struct_AVBitStreamFilterContext)(bfx)) } -//AvBitStreamFilter *av_bitstream_filter_next (const AvBitStreamFilter *f) -func (f *AvBitStreamFilter) AvBitstreamFilterNext() *AvBitStreamFilter { - return (*AvBitStreamFilter)(C.av_bitstream_filter_next((*C.struct_AVBitStreamFilter)(f))) +//BitStreamFilter *av_bitstream_filter_next (const BitStreamFilter *f) +func (f *BitStreamFilter) AvBitstreamFilterNext() *BitStreamFilter { + return (*BitStreamFilter)(C.av_bitstream_filter_next((*C.struct_AVBitStreamFilter)(f))) } //Same behaviour av_fast_malloc but the buffer has additional FF_INPUT_BUFFER_PADDING_SIZE at the end which will always be 0. @@ -239,33 +239,33 @@ func (a *AvHWAccel) AvHwaccelNext() *AvHWAccel { } //Get the type of the given codec. -func AvcodecGetType(c AvCodecId) AvMediaType { - return (AvMediaType)(C.avcodec_get_type((C.enum_AVCodecID)(c))) +func AvcodecGetType(c CodecId) MediaType { + return (MediaType)(C.avcodec_get_type((C.enum_AVCodecID)(c))) } //Get the name of a codec. -func AvcodecGetName(d AvCodecId) string { +func AvcodecGetName(d CodecId) string { return C.GoString(C.avcodec_get_name((C.enum_AVCodecID)(d))) } -func (c *AvCodec) AvCodecIsEncoder() int { +func (c *Codec) AvCodecIsEncoder() int { return int(C.av_codec_is_encoder((*C.struct_AVCodec)(c))) } -func (c *AvCodec) AvCodecIsDecoder() int { +func (c *Codec) AvCodecIsDecoder() int { return int(C.av_codec_is_decoder((*C.struct_AVCodec)(c))) } -//const AvCodecDescriptor *avcodec_descriptor_get (enum AvCodecId id) -func AvcodecDescriptorGet(id AvCodecId) *AvCodecDescriptor { - return (*AvCodecDescriptor)(C.avcodec_descriptor_get((C.enum_AVCodecID)(id))) +//const Descriptor *avcodec_descriptor_get (enum CodecId id) +func AvcodecDescriptorGet(id CodecId) *Descriptor { + return (*Descriptor)(C.avcodec_descriptor_get((C.enum_AVCodecID)(id))) } //Iterate over all codec descriptors known to libavcodec. -func AvcodecDescriptorNext(d *AvCodecDescriptor) *AvCodecDescriptor { - return (*AvCodecDescriptor)(C.avcodec_descriptor_next((*C.struct_AVCodecDescriptor)(d))) +func (d *Descriptor) AvcodecDescriptorNext() *Descriptor { + return (*Descriptor)(C.avcodec_descriptor_next((*C.struct_AVCodecDescriptor)(d))) } -func AvcodecDescriptorGetByName(n string) *AvCodecDescriptor { - return (*AvCodecDescriptor)(C.avcodec_descriptor_get_by_name(C.CString(n))) +func AvcodecDescriptorGetByName(n string) *Descriptor { + return (*Descriptor)(C.avcodec_descriptor_get_by_name(C.CString(n))) } diff --git a/avcodec/avpicture.go b/avcodec/avpicture.go index ce44f50..7a5a6bf 100644 --- a/avcodec/avpicture.go +++ b/avcodec/avpicture.go @@ -11,32 +11,32 @@ import ( ) //Setup the picture fields based on the specified image parameters and the provided image data buffer. -func (p *AvPicture) AvpictureFill(pt *uint8, pf AvPixelFormat, w, h int) int { +func (p *AvPicture) AvpictureFill(pt *uint8, pf PixelFormat, w, h int) int { return int(C.avpicture_fill((*C.struct_AVPicture)(p), (*C.uint8_t)(pt), (C.enum_AVPixelFormat)(pf), C.int(w), C.int(h))) } //Copy pixel data from an AvPicture into a buffer. -func (p *AvPicture) AvpictureLayout(pf AvPixelFormat, w, h int, d *string, ds int) int { +func (p *AvPicture) AvpictureLayout(pf PixelFormat, w, h int, d *string, ds int) int { return int(C.avpicture_layout((*C.struct_AVPicture)(p), (C.enum_AVPixelFormat)(pf), C.int(w), C.int(h), (*C.uchar)(unsafe.Pointer(d)), C.int(ds))) } //Copy image src to dst. -func (p *AvPicture) AvPictureCopy(d *AvPicture, pf AvPixelFormat, w, h int) { +func (p *AvPicture) AvPictureCopy(d *AvPicture, pf PixelFormat, w, h int) { C.av_picture_copy((*C.struct_AVPicture)(d), (*C.struct_AVPicture)(p), (C.enum_AVPixelFormat)(pf), C.int(w), C.int(h)) } //Crop image top and left side. -func (p *AvPicture) AvPictureCrop(d *AvPicture, pf AvPixelFormat, t, l int) int { +func (p *AvPicture) AvPictureCrop(d *AvPicture, pf PixelFormat, t, l int) int { return int(C.av_picture_crop((*C.struct_AVPicture)(d), (*C.struct_AVPicture)(p), (C.enum_AVPixelFormat)(pf), C.int(t), C.int(l))) } //Pad image. -func (p *AvPicture) AvPicturePad(d *AvPicture, h, w int, pf AvPixelFormat, t, b, l, r int, c *int) int { +func (p *AvPicture) AvPicturePad(d *AvPicture, h, w int, pf PixelFormat, t, b, l, r int, c *int) int { return int(C.av_picture_pad((*C.struct_AVPicture)(d), (*C.struct_AVPicture)(p), (C.int)(h), (C.int)(w), (C.enum_AVPixelFormat)(pf), (C.int)(t), (C.int)(b), (C.int)(l), (C.int)(r), (*C.int)(unsafe.Pointer(c)))) } //Free a picture previously allocated by avpicture_alloc(). Allocate memory for the pixels of a picture and setup the AvPicture fields for it. -func (p *AvPicture) AvpictureAlloc(t AvPixelFormat, w, h int) int { +func (p *AvPicture) AvpictureAlloc(t PixelFormat, w, h int) int { return int(C.avpicture_alloc((*C.struct_AVPicture)(p), (C.enum_AVPixelFormat)(t), C.int(w), C.int(h))) } @@ -45,6 +45,6 @@ func (p *AvPicture) AvpictureFree() { } //Calculate the size in bytes that a picture of the given width and height would occupy if stored in the given picture format. -func AvpictureGetSize(pf AvPixelFormat, w, h int) int { +func AvpictureGetSize(pf PixelFormat, w, h int) int { return int(C.avpicture_get_size((C.enum_AVPixelFormat)(pf), C.int(w), C.int(h))) } diff --git a/avcodec/context.go b/avcodec/context.go index 5c6d492..3752df8 100644 --- a/avcodec/context.go +++ b/avcodec/context.go @@ -10,19 +10,19 @@ import ( "unsafe" ) -func (ctxt *Context) AvCodecGetPktTimebase() AvRational { - return (AvRational)(C.av_codec_get_pkt_timebase((*C.struct_AVCodecContext)(ctxt))) +func (ctxt *Context) AvCodecGetPktTimebase() Rational { + return (Rational)(C.av_codec_get_pkt_timebase((*C.struct_AVCodecContext)(ctxt))) } -func (ctxt *Context) AvCodecSetPktTimebase(r AvRational) { +func (ctxt *Context) AvCodecSetPktTimebase(r Rational) { C.av_codec_set_pkt_timebase((*C.struct_AVCodecContext)(ctxt), (C.struct_AVRational)(r)) } -func (ctxt *Context) AvCodecGetCodecDescriptor() *AvCodecDescriptor { - return (*AvCodecDescriptor)(C.av_codec_get_codec_descriptor((*C.struct_AVCodecContext)(ctxt))) +func (ctxt *Context) AvCodecGetCodecDescriptor() *Descriptor { + return (*Descriptor)(C.av_codec_get_codec_descriptor((*C.struct_AVCodecContext)(ctxt))) } -func (ctxt *Context) AvCodecSetCodecDescriptor(d *AvCodecDescriptor) { +func (ctxt *Context) AvCodecSetCodecDescriptor(d *Descriptor) { C.av_codec_set_codec_descriptor((*C.struct_AVCodecContext)(ctxt), (*C.struct_AVCodecDescriptor)(d)) } @@ -56,7 +56,7 @@ func (ctxt *Context) AvcodecFreeContext() { } //Set the fields of the given Context to default values corresponding to the given codec (defaults may be codec-dependent). -func (ctxt *Context) AvcodecGetContextDefaults3(c *AvCodec) int { +func (ctxt *Context) AvcodecGetContextDefaults3(c *Codec) int { return int(C.avcodec_get_context_defaults3((*C.struct_AVCodecContext)(ctxt), (*C.struct_AVCodec)(c))) } @@ -65,8 +65,8 @@ func (ctxt *Context) AvcodecCopyContext(ctxt2 *Context) int { return int(C.avcodec_copy_context((*C.struct_AVCodecContext)(ctxt), (*C.struct_AVCodecContext)(ctxt2))) } -//Initialize the Context to use the given AvCodec -func (ctxt *Context) AvcodecOpen2(c *AvCodec, d **AvDictionary) int { +//Initialize the Context to use the given Codec +func (ctxt *Context) AvcodecOpen2(c *Codec, d **Dictionary) int { return int(C.avcodec_open2((*C.struct_AVCodecContext)(ctxt), (*C.struct_AVCodec)(c), (**C.struct_AVDictionary)(unsafe.Pointer(d)))) } @@ -76,7 +76,7 @@ func (ctxt *Context) AvcodecClose() int { } //The default callback for Context.get_buffer2(). -func (s *Context) AvcodecDefaultGetBuffer2(f *AvFrame, l int) int { +func (s *Context) AvcodecDefaultGetBuffer2(f *Frame, l int) int { return int(C.avcodec_default_get_buffer2((*C.struct_AVCodecContext)(s), (*C.struct_AVFrame)(f), C.int(l))) } @@ -91,27 +91,27 @@ func (ctxt *Context) AvcodecAlignDimensions2(w, h *int, l int) { } //Decode the audio frame of size avpkt->size from avpkt->data into frame. -func (ctxt *Context) AvcodecDecodeAudio4(f *AvFrame, g *int, a *AvPacket) int { +func (ctxt *Context) AvcodecDecodeAudio4(f *Frame, g *int, a *Packet) int { return int(C.avcodec_decode_audio4((*C.struct_AVCodecContext)(ctxt), (*C.struct_AVFrame)(f), (*C.int)(unsafe.Pointer(g)), (*C.struct_AVPacket)(a))) } //Decode the video frame of size avpkt->size from avpkt->data into picture. -func (ctxt *Context) AvcodecDecodeVideo2(p *AvFrame, g *int, a *AvPacket) int { +func (ctxt *Context) AvcodecDecodeVideo2(p *Frame, g *int, a *Packet) int { return int(C.avcodec_decode_video2((*C.struct_AVCodecContext)(ctxt), (*C.struct_AVFrame)(p), (*C.int)(unsafe.Pointer(g)), (*C.struct_AVPacket)(a))) } //Decode a subtitle message. -func (ctxt *Context) AvcodecDecodeSubtitle2(s *AvSubtitle, g *int, a *AvPacket) int { +func (ctxt *Context) AvcodecDecodeSubtitle2(s *AvSubtitle, g *int, a *Packet) int { return int(C.avcodec_decode_subtitle2((*C.struct_AVCodecContext)(ctxt), (*C.struct_AVSubtitle)(s), (*C.int)(unsafe.Pointer(g)), (*C.struct_AVPacket)(a))) } //Encode a frame of audio. -func (ctxt *Context) AvcodecEncodeAudio2(p *AvPacket, f *AvFrame, gp *int) int { +func (ctxt *Context) AvcodecEncodeAudio2(p *Packet, f *Frame, gp *int) int { return int(C.avcodec_encode_audio2((*C.struct_AVCodecContext)(ctxt), (*C.struct_AVPacket)(p), (*C.struct_AVFrame)(f), (*C.int)(unsafe.Pointer(gp)))) } //Encode a frame of video -func (ctxt *Context) AvcodecEncodeVideo2(p *AvPacket, f *AvFrame, gp *int) int { +func (ctxt *Context) AvcodecEncodeVideo2(p *Packet, f *Frame, gp *int) int { return int(C.avcodec_encode_video2((*C.struct_AVCodecContext)(ctxt), (*C.struct_AVPacket)(p), (*C.struct_AVFrame)(f), (*C.int)(unsafe.Pointer(gp)))) } @@ -119,8 +119,8 @@ func (ctxt *Context) AvcodecEncodeSubtitle(b *uint8, bs int, s *AvSubtitle) int return int(C.avcodec_encode_subtitle((*C.struct_AVCodecContext)(ctxt), (*C.uint8_t)(b), C.int(bs), (*C.struct_AVSubtitle)(s))) } -func (ctxt *Context) AvcodecDefaultGetFormat(f *AvPixelFormat) AvPixelFormat { - return (AvPixelFormat)(C.avcodec_default_get_format((*C.struct_AVCodecContext)(ctxt), (*C.enum_AVPixelFormat)(f))) +func (ctxt *Context) AvcodecDefaultGetFormat(f *PixelFormat) PixelFormat { + return (PixelFormat)(C.avcodec_default_get_format((*C.struct_AVCodecContext)(ctxt), (*C.enum_AVPixelFormat)(f))) } //Reset the internal decoder state / flush internal buffers. @@ -138,26 +138,26 @@ func (ctxt *Context) AvcodecIsOpen() int { } //Parse a packet. -func (ctxt *Context) AvParserParse2(ctxtp *AvCodecParserContext, p **uint8, ps *int, b *uint8, bs int, pt, dt, po int64) int { +func (ctxt *Context) AvParserParse2(ctxtp *ParserContext, p **uint8, ps *int, b *uint8, bs int, pt, dt, po int64) int { return int(C.av_parser_parse2((*C.struct_AVCodecParserContext)(ctxtp), (*C.struct_AVCodecContext)(ctxt), (**C.uint8_t)(unsafe.Pointer(p)), (*C.int)(unsafe.Pointer(ps)), (*C.uint8_t)(b), C.int(bs), (C.int64_t)(pt), (C.int64_t)(dt), (C.int64_t)(po))) } -func (ctxt *Context) AvParserChange(ctxtp *AvCodecParserContext, pb **uint8, pbs *int, b *uint8, bs, k int) int { +func (ctxt *Context) AvParserChange(ctxtp *ParserContext, pb **uint8, pbs *int, b *uint8, bs, k int) int { return int(C.av_parser_change((*C.struct_AVCodecParserContext)(ctxtp), (*C.struct_AVCodecContext)(ctxt), (**C.uint8_t)(unsafe.Pointer(pb)), (*C.int)(unsafe.Pointer(pbs)), (*C.uint8_t)(b), C.int(bs), C.int(k))) } -func AvParserInit(c int) *AvCodecParserContext { - return (*AvCodecParserContext)(C.av_parser_init(C.int(c))) +func AvParserInit(c int) *ParserContext { + return (*ParserContext)(C.av_parser_init(C.int(c))) } -func AvParserClose(ctxtp *AvCodecParserContext) { +func AvParserClose(ctxtp *ParserContext) { C.av_parser_close((*C.struct_AVCodecParserContext)(ctxtp)) } -func (p *AvCodecParser) AvParserNext() *AvCodecParser { - return (*AvCodecParser)(C.av_parser_next((*C.struct_AVCodecParser)(p))) +func (p *Parser) AvParserNext() *Parser { + return (*Parser)(C.av_parser_next((*C.struct_AVCodecParser)(p))) } -func (p *AvCodecParser) AvRegisterCodecParser() { +func (p *Parser) AvRegisterCodecParser() { C.av_register_codec_parser((*C.struct_AVCodecParser)(p)) } diff --git a/avcodec/context_struct.go b/avcodec/context_struct.go index 8530aa3..088e35c 100644 --- a/avcodec/context_struct.go +++ b/avcodec/context_struct.go @@ -491,16 +491,16 @@ func (ctxt *Context) ChromaSampleLocation() AvChromaLocation { return (AvChromaLocation)(ctxt.chroma_sample_location) } -func (ctxt *Context) CodecDescriptor() *AvCodecDescriptor { - return (*AvCodecDescriptor)(ctxt.codec_descriptor) +func (ctxt *Context) CodecDescriptor() *Descriptor { + return (*Descriptor)(ctxt.codec_descriptor) } -func (ctxt *Context) CodecId() AvCodecId { - return (AvCodecId)(ctxt.codec_id) +func (ctxt *Context) CodecId() CodecId { + return (CodecId)(ctxt.codec_id) } -func (ctxt *Context) CodecType() AvMediaType { - return (AvMediaType)(ctxt.codec_type) +func (ctxt *Context) CodecType() MediaType { + return (MediaType)(ctxt.codec_type) } func (ctxt *Context) ColorPrimaries() AvColorPrimaries { @@ -523,8 +523,8 @@ func (ctxt *Context) FieldOrder() AvFieldOrder { return (AvFieldOrder)(ctxt.field_order) } -func (ctxt *Context) PixFmt() AvPixelFormat { - return (AvPixelFormat)(ctxt.pix_fmt) +func (ctxt *Context) PixFmt() PixelFormat { + return (PixelFormat)(ctxt.pix_fmt) } func (ctxt *Context) RequestSampleFmt() AvSampleFormat { diff --git a/avcodec/packet.go b/avcodec/packet.go index 9446be7..0ba7da9 100644 --- a/avcodec/packet.go +++ b/avcodec/packet.go @@ -11,105 +11,105 @@ import ( ) //Initialize optional fields of a packet with default values. -func (p *AvPacket) AvInitPacket() { +func (p *Packet) AvInitPacket() { C.av_init_packet((*C.struct_AVPacket)(p)) } //Allocate the payload of a packet and initialize its fields with default values. -func (p *AvPacket) AvNewPacket(s int) int { +func (p *Packet) AvNewPacket(s int) int { return int(C.av_new_packet((*C.struct_AVPacket)(p), C.int(s))) } //Reduce packet size, correctly zeroing padding. -func (p *AvPacket) AvShrinkPacket(s int) { +func (p *Packet) AvShrinkPacket(s int) { C.av_shrink_packet((*C.struct_AVPacket)(p), C.int(s)) } //Increase packet size, correctly zeroing padding. -func (p *AvPacket) AvGrowPacket(s int) int { +func (p *Packet) AvGrowPacket(s int) int { return int(C.av_grow_packet((*C.struct_AVPacket)(p), C.int(s))) } //Initialize a reference-counted packet from av_malloc()ed data. -func (p *AvPacket) AvPacketFromData(d *uint8, s int) int { +func (p *Packet) AvPacketFromData(d *uint8, s int) int { return int(C.av_packet_from_data((*C.struct_AVPacket)(p), (*C.uint8_t)(d), C.int(s))) } -func (p *AvPacket) AvDupPacket() int { +func (p *Packet) AvDupPacket() int { return int(C.av_dup_packet((*C.struct_AVPacket)(p))) } //Copy packet, including contents. -func (p *AvPacket) AvCopyPacket(r *AvPacket) int { +func (p *Packet) AvCopyPacket(r *Packet) int { return int(C.av_copy_packet((*C.struct_AVPacket)(p), (*C.struct_AVPacket)(r))) } //Copy packet side data. -func (p *AvPacket) AvCopyPacketSideData(r *AvPacket) int { +func (p *Packet) AvCopyPacketSideData(r *Packet) int { return int(C.av_copy_packet_side_data((*C.struct_AVPacket)(p), (*C.struct_AVPacket)(r))) } //Free a packet. -func (p *AvPacket) AvFreePacket() { +func (p *Packet) AvFreePacket() { C.av_free_packet((*C.struct_AVPacket)(p)) } //Allocate new information of a packet. -func (p *AvPacket) AvPacketNewSideData(t AvPacketSideDataType, s int) *uint8 { +func (p *Packet) AvPacketNewSideData(t AvPacketSideDataType, s int) *uint8 { return (*uint8)(C.av_packet_new_side_data((*C.struct_AVPacket)(p), (C.enum_AVPacketSideDataType)(t), C.int(s))) } //Shrink the already allocated side data buffer. -func (p *AvPacket) AvPacketShrinkSideData(t AvPacketSideDataType, s int) int { +func (p *Packet) AvPacketShrinkSideData(t AvPacketSideDataType, s int) int { return int(C.av_packet_shrink_side_data((*C.struct_AVPacket)(p), (C.enum_AVPacketSideDataType)(t), C.int(s))) } //Get side information from packet. -func (p *AvPacket) AvPacketGetSideData(t AvPacketSideDataType, s *int) *uint8 { +func (p *Packet) AvPacketGetSideData(t AvPacketSideDataType, s *int) *uint8 { return (*uint8)(C.av_packet_get_side_data((*C.struct_AVPacket)(p), (C.enum_AVPacketSideDataType)(t), (*C.int)(unsafe.Pointer(s)))) } -//int av_packet_merge_side_data (AvPacket *pkt) -func (p *AvPacket) AvPacketMergeSideData() int { +//int av_packet_merge_side_data (Packet *pkt) +func (p *Packet) AvPacketMergeSideData() int { return int(C.av_packet_merge_side_data((*C.struct_AVPacket)(p))) } -//int av_packet_split_side_data (AvPacket *pkt) -func (p *AvPacket) AvPacketSplitSideData() int { +//int av_packet_split_side_data (Packet *pkt) +func (p *Packet) AvPacketSplitSideData() int { return int(C.av_packet_split_side_data((*C.struct_AVPacket)(p))) } //Convenience function to free all the side data stored. -func (p *AvPacket) AvPacketFreeSideData() { +func (p *Packet) AvPacketFreeSideData() { C.av_packet_free_side_data((*C.struct_AVPacket)(p)) } //Setup a new reference to the data described by a given packet. -func (p *AvPacket) AvPacketRef(s *AvPacket) int { +func (p *Packet) AvPacketRef(s *Packet) int { return int(C.av_packet_ref((*C.struct_AVPacket)(p), (*C.struct_AVPacket)(s))) } //Wipe the packet. -func (p *AvPacket) AvPacketUnref() { +func (p *Packet) AvPacketUnref() { C.av_packet_unref((*C.struct_AVPacket)(p)) } //Move every field in src to dst and reset src. -func (p *AvPacket) AvPacketMoveRef(s *AvPacket) { +func (p *Packet) AvPacketMoveRef(s *Packet) { C.av_packet_move_ref((*C.struct_AVPacket)(p), (*C.struct_AVPacket)(s)) } //Copy only "properties" fields from src to dst. -func (p *AvPacket) AvPacketCopyProps(s *AvPacket) int { +func (p *Packet) AvPacketCopyProps(s *Packet) int { return int(C.av_packet_copy_props((*C.struct_AVPacket)(p), (*C.struct_AVPacket)(s))) } //Convert valid timing fields (timestamps / durations) in a packet from one timebase to another. -func (p *AvPacket) AvPacketRescaleTs(r, r2 AvRational) { +func (p *Packet) AvPacketRescaleTs(r, r2 Rational) { C.av_packet_rescale_ts((*C.struct_AVPacket)(p), (C.struct_AVRational)(r), (C.struct_AVRational)(r2)) } diff --git a/avcodec/packet_struct.go b/avcodec/packet_struct.go index b0be2dd..019e5ac 100644 --- a/avcodec/packet_struct.go +++ b/avcodec/packet_struct.go @@ -4,36 +4,36 @@ */ package avcodec -func (p *AvPacket) Buf() *AvBufferRef { +func (p *Packet) Buf() *AvBufferRef { return (*AvBufferRef)(p.buf) } -func (p *AvPacket) Duration() int { +func (p *Packet) Duration() int { return int(p.duration) } -func (p *AvPacket) Flags() int { +func (p *Packet) Flags() int { return int(p.flags) } -func (p *AvPacket) SideDataElems() int { +func (p *Packet) SideDataElems() int { return int(p.side_data_elems) } -func (p *AvPacket) Size() int { +func (p *Packet) Size() int { return int(p.size) } -func (p *AvPacket) StreamIndex() int { +func (p *Packet) StreamIndex() int { return int(p.stream_index) } -func (p *AvPacket) ConvergenceDuration() int64 { +func (p *Packet) ConvergenceDuration() int64 { return int64(p.convergence_duration) } -func (p *AvPacket) Dts() int64 { +func (p *Packet) Dts() int64 { return int64(p.dts) } -func (p *AvPacket) Pos() int64 { +func (p *Packet) Pos() int64 { return int64(p.pos) } -func (p *AvPacket) Pts() int64 { +func (p *Packet) Pts() int64 { return int64(p.pts) } -func (p *AvPacket) Data() *uint8 { +func (p *Packet) Data() *uint8 { return (*uint8)(p.data) } diff --git a/avcodec/pixelformat.go b/avcodec/pixelformat.go index c81e91a..dafcfbe 100644 --- a/avcodec/pixelformat.go +++ b/avcodec/pixelformat.go @@ -1,5 +1,5 @@ /* - AvPixelFormat + PixelFormat */ package avcodec @@ -11,24 +11,24 @@ import ( ) //Utility function to access log2_chroma_w log2_chroma_h from the pixel format AvPixFmtDescriptor. -func (p AvPixelFormat) Avcodec_get_chroma_sub_sample(h, v *int) { +func (p PixelFormat) Avcodec_get_chroma_sub_sample(h, v *int) { C.avcodec_get_chroma_sub_sample((C.enum_AVPixelFormat)(p), (*C.int)(unsafe.Pointer(h)), (*C.int)(unsafe.Pointer(v))) } //Return a value representing the fourCC code associated to the pixel format pix_fmt, or 0 if no associated fourCC code can be found. -func (p AvPixelFormat) Avcodec_pix_fmt_to_codec_tag() uint { +func (p PixelFormat) Avcodec_pix_fmt_to_codec_tag() uint { return uint(C.avcodec_pix_fmt_to_codec_tag((C.enum_AVPixelFormat)(p))) } -func (p AvPixelFormat) Avcodec_get_pix_fmt_loss(f AvPixelFormat, a int) int { +func (p PixelFormat) Avcodec_get_pix_fmt_loss(f PixelFormat, a int) int { return int(C.avcodec_get_pix_fmt_loss((C.enum_AVPixelFormat)(p), (C.enum_AVPixelFormat)(f), C.int(a))) } //Find the best pixel format to convert to given a certain source pixel format. -func (p *AvPixelFormat) Avcodec_find_best_pix_fmt_of_list(s AvPixelFormat, a int, l *int) AvPixelFormat { - return (AvPixelFormat)(C.avcodec_find_best_pix_fmt_of_list((*C.enum_AVPixelFormat)(p), (C.enum_AVPixelFormat)(s), C.int(a), (*C.int)(unsafe.Pointer(l)))) +func (p *PixelFormat) Avcodec_find_best_pix_fmt_of_list(s PixelFormat, a int, l *int) PixelFormat { + return (PixelFormat)(C.avcodec_find_best_pix_fmt_of_list((*C.enum_AVPixelFormat)(p), (C.enum_AVPixelFormat)(s), C.int(a), (*C.int)(unsafe.Pointer(l)))) } -func (p AvPixelFormat) Avcodec_find_best_pix_fmt_of_2(f2, s AvPixelFormat, a int, l *int) AvPixelFormat { - return (AvPixelFormat)(C.avcodec_find_best_pix_fmt_of_2((C.enum_AVPixelFormat)(p), (C.enum_AVPixelFormat)(f2), (C.enum_AVPixelFormat)(s), C.int(a), (*C.int)(unsafe.Pointer(l)))) +func (p PixelFormat) Avcodec_find_best_pix_fmt_of_2(f2, s PixelFormat, a int, l *int) PixelFormat { + return (PixelFormat)(C.avcodec_find_best_pix_fmt_of_2((C.enum_AVPixelFormat)(p), (C.enum_AVPixelFormat)(f2), (C.enum_AVPixelFormat)(s), C.int(a), (*C.int)(unsafe.Pointer(l)))) } diff --git a/avdevice/avdevice.go b/avdevice/avdevice.go index 5868556..0c1c029 100644 --- a/avdevice/avdevice.go +++ b/avdevice/avdevice.go @@ -23,10 +23,10 @@ type ( AvDeviceCapabilitiesQuery C.struct_AVDeviceCapabilitiesQuery AvDeviceInfo C.struct_AVDeviceInfo AvDeviceInfoList C.struct_AVDeviceInfoList - AvInputFormat C.struct_AVInputFormat - AvOutputFormat C.struct_AVOutputFormat + InputFormat C.struct_AVInputFormat + OutputFormat C.struct_AVOutputFormat AvFormatContext C.struct_AVFormatContext - AvDictionary C.struct_AVDictionary + Dictionary C.struct_AVDictionary AvAppToDevMessageType C.enum_AVAppToDevMessageType AvDevToAppMessageType C.enum_AVDevToAppMessageType ) @@ -55,28 +55,28 @@ func Avdevice_register_all() { C.avdevice_register_all() } -//AvInputFormat * av_input_audio_device_next (AvInputFormat *d) +//InputFormat * av_input_audio_device_next (InputFormat *d) //Audio input devices iterator. -func Av_input_audio_device_next(d *AvInputFormat) *AvInputFormat { - return (*AvInputFormat)(C.av_input_audio_device_next((*C.struct_AVInputFormat)(d))) +func Av_input_audio_device_next(d *InputFormat) *InputFormat { + return (*InputFormat)(C.av_input_audio_device_next((*C.struct_AVInputFormat)(d))) } -//AvInputFormat * av_input_video_device_next (AvInputFormat *d) +//InputFormat * av_input_video_device_next (InputFormat *d) //Video input devices iterator. -func Av_input_video_device_next(d *AvInputFormat) *AvInputFormat { - return (*AvInputFormat)(C.av_input_video_device_next((*C.struct_AVInputFormat)(d))) +func Av_input_video_device_next(d *InputFormat) *InputFormat { + return (*InputFormat)(C.av_input_video_device_next((*C.struct_AVInputFormat)(d))) } -//AvOutputFormat * av_output_audio_device_next (AvOutputFormat *d) +//OutputFormat * av_output_audio_device_next (OutputFormat *d) //Audio output devices iterator. -func Av_output_audio_device_next(d *AvOutputFormat) *AvOutputFormat { - return (*AvOutputFormat)(C.av_output_audio_device_next((*C.struct_AVOutputFormat)(d))) +func Av_output_audio_device_next(d *OutputFormat) *OutputFormat { + return (*OutputFormat)(C.av_output_audio_device_next((*C.struct_AVOutputFormat)(d))) } -//AvOutputFormat * av_output_video_device_next (AvOutputFormat *d) +//OutputFormat * av_output_video_device_next (OutputFormat *d) //Video output devices iterator. -func Av_output_video_device_next(d *AvOutputFormat) *AvOutputFormat { - return (*AvOutputFormat)(C.av_output_video_device_next((*C.struct_AVOutputFormat)(d))) +func Av_output_video_device_next(d *OutputFormat) *OutputFormat { + return (*OutputFormat)(C.av_output_video_device_next((*C.struct_AVOutputFormat)(d))) } //int avdevice_app_to_dev_control_message (struct AvFormatContext *s, enum AvAppToDevMessageType type, void *data, size_t data_size) @@ -91,9 +91,9 @@ func Avdevice_dev_to_app_control_message(fcxt *AvFormatContext, m AvDevToAppMess return int(C.avdevice_dev_to_app_control_message((*C.struct_AVFormatContext)(fcxt), (C.enum_AVDevToAppMessageType)(m), unsafe.Pointer(&da), C.size_t(d))) } -//int avdevice_capabilities_create (AvDeviceCapabilitiesQuery **caps, AvFormatContext *s, AvDictionary **device_options) +//int avdevice_capabilities_create (AvDeviceCapabilitiesQuery **caps, AvFormatContext *s, Dictionary **device_options) //Initialize capabilities probing API based on AvOption API. -func Avdevice_capabilities_create(c **AvDeviceCapabilitiesQuery, s *AvFormatContext, d **AvDictionary) int { +func Avdevice_capabilities_create(c **AvDeviceCapabilitiesQuery, s *AvFormatContext, d **Dictionary) int { return int(C.avdevice_capabilities_create((**C.struct_AVDeviceCapabilitiesQuery)(unsafe.Pointer(c)), (*C.struct_AVFormatContext)(s), (**C.struct_AVDictionary)(unsafe.Pointer(d)))) } @@ -115,13 +115,13 @@ func Avdevice_free_list_devices(d **AvDeviceInfoList) { C.avdevice_free_list_devices((**C.struct_AVDeviceInfoList)(unsafe.Pointer(d))) } -// //int avdevice_list_input_sources (struct AvInputFormat *device, const char *device_name, AvDictionary *device_options, AvDeviceInfoList **device_list) +// //int avdevice_list_input_sources (struct InputFormat *device, const char *device_name, Dictionary *device_options, AvDeviceInfoList **device_list) // //List devices. -// func Avdevice_list_input_sources(d *AvInputFormat, dv string, do *AvDictionary, dl **AvDeviceInfoList) int { +// func Avdevice_list_input_sources(d *InputFormat, dv string, do *Dictionary, dl **AvDeviceInfoList) int { // return int(C.avdevice_list_input_sources((*C.struct_AVInputFormat)(d), C.CString(dv), (*C.struct_AVDictionary)(do), (**C.struct_AVDeviceInfoList)(unsafe.Pointer(dl)))) // } -// //int avdevice_list_output_sinks (struct AvOutputFormat *device, const char *device_name, AvDictionary *device_options, AvDeviceInfoList **device_list) -// func Avdevice_list_output_sinks(d *AvOutputFormat, dn string, di *AvDictionary, dl **AvDeviceInfoList) int { +// //int avdevice_list_output_sinks (struct OutputFormat *device, const char *device_name, Dictionary *device_options, AvDeviceInfoList **device_list) +// func Avdevice_list_output_sinks(d *OutputFormat, dn string, di *Dictionary, dl **AvDeviceInfoList) int { // return int(C.avdevice_list_output_sinks((*C.struct_AVOutputFormat)(d), C.CString(dn), (*C.struct_AVDictionary)(di), (**C.struct_AVDeviceInfoList)(unsafe.Pointer(dl)))) // } diff --git a/avfilter/avfilter.go b/avfilter/avfilter.go index 1d94750..1c8f518 100644 --- a/avfilter/avfilter.go +++ b/avfilter/avfilter.go @@ -24,11 +24,11 @@ type ( AvFilterGraph C.struct_AVFilterGraph AvFilterInOut C.struct_AVFilterInOut AvFilterPad C.struct_AVFilterPad - AvDictionary C.struct_AVDictionary + Dictionary C.struct_AVDictionary AvClass C.struct_AVClass ) type ( - AvMediaType C.enum_AVMediaType + MediaType C.enum_AVMediaType ) //unsigned avfilter_version (void) @@ -61,10 +61,10 @@ func Avfilter_pad_get_name(p *AvFilterPad, pi int) string { return C.GoString(C.avfilter_pad_get_name((*C.struct_AVFilterPad)(p), C.int(pi))) } -//enum AvMediaType avfilter_pad_get_type (const AvFilterPad *pads, int pad_idx) +//enum MediaType avfilter_pad_get_type (const AvFilterPad *pads, int pad_idx) //Get the type of an AvFilterPad. -func Avfilter_pad_get_type(p *AvFilterPad, pi int) AvMediaType { - return (AvMediaType)(C.avfilter_pad_get_type((*C.struct_AVFilterPad)(p), C.int(pi))) +func Avfilter_pad_get_type(p *AvFilterPad, pi int) MediaType { + return (MediaType)(C.avfilter_pad_get_type((*C.struct_AVFilterPad)(p), C.int(pi))) } //int avfilter_link (AvFilterContext *src, unsigned srcpad, AvFilterContext *dst, unsigned dstpad) @@ -133,9 +133,9 @@ func Avfilter_init_str(ctx *AvFilterContext, args string) int { return int(C.avfilter_init_str((*C.struct_AVFilterContext)(ctx), C.CString(args))) } -//int avfilter_init_dict (AvFilterContext *ctx, AvDictionary **options) +//int avfilter_init_dict (AvFilterContext *ctx, Dictionary **options) //Initialize a filter with the supplied dictionary of options. -func Avfilter_init_dict(f *AvFilterContext, o **AvDictionary) int { +func Avfilter_init_dict(f *AvFilterContext, o **Dictionary) int { return int(C.avfilter_init_dict((*C.struct_AVFilterContext)(f), (**C.struct_AVDictionary)(unsafe.Pointer(o)))) } diff --git a/avformat/avformat.go b/avformat/avformat.go index ee15c42..069b763 100644 --- a/avformat/avformat.go +++ b/avformat/avformat.go @@ -28,241 +28,207 @@ import ( type ( AvProbeData C.struct_AVProbeData - AvOutputFormat C.struct_AVOutputFormat - AvInputFormat C.struct_AVInputFormat + InputFormat C.struct_AVInputFormat + OutputFormat C.struct_AVOutputFormat + Context C.struct_AVFormatContext + Frame C.struct_AVFrame + CodecContext C.struct_AVCodecContext + Dictionary C.struct_AVDictionary AvIndexEntry C.struct_AVIndexEntry - AvStream C.struct_AVStream + Stream C.struct_AVStream AvProgram C.struct_AVProgram AvChapter C.struct_AVChapter - Context C.struct_AVFormatContext AvPacketList C.struct_AVPacketList - AvPacket C.struct_AVPacket - AvCodecParserContext C.struct_AVCodecParserContext + Packet C.struct_AVPacket + CodecParserContext C.struct_AVCodecParserContext AvIOContext C.struct_AVIOContext - AvRational C.struct_AVRational + Rational 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 + MediaType C.enum_AVMediaType AvDurationEstimationMethod C.enum_AVDurationEstimationMethod AvPacketSideDataType C.enum_AVPacketSideDataType - AvCodecId C.enum_AVCodecID + CodecId C.enum_AVCodecID ) type File C.FILE -//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 (ctxt *AvIOContext) AvGetPacket(pkt *AvPacket, s int) int { +func (ctxt *AvIOContext) AvGetPacket(pkt *Packet, 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 (ctxt *AvIOContext) AvAppendPacket(pkt *AvPacket, s int) int { +//Read data and append it to the current content of the Packet. +func (ctxt *AvIOContext) AvAppendPacket(pkt *Packet, s int) int { return int(C.av_append_packet((*C.struct_AVIOContext)(ctxt), (*C.struct_AVPacket)(pkt), C.int(s))) } -//unsigned avformat_version (void) //Return the LIBAvFORMAT_VERSION_INT constant. func AvformatVersion() uint { return uint(C.avformat_version()) } -//const char * avformat_configuration (void) //Return the libavformat build-time configuration. func AvformatConfiguration() string { return C.GoString(C.avformat_configuration()) } -//const char * avformat_license (void) //Return the libavformat license. func AvformatLicense() string { return C.GoString(C.avformat_license()) } -//void av_register_all (void) //Initialize libavformat and register all the muxers, demuxers and protocols. func AvRegisterAll() { C.av_register_all() } -//void av_register_input_format (AvInputFormat *format) -func AvRegisterInputFormat(f *AvInputFormat) { +func AvRegisterInputFormat(f *InputFormat) { C.av_register_input_format((*C.struct_AVInputFormat)(f)) } -//void av_register_output_format (AvOutputFormat *format) -func (f *AvOutputFormat) AvRegisterOutputFormat() { +func (f *OutputFormat) AvRegisterOutputFormat() { C.av_register_output_format((*C.struct_AVOutputFormat)(f)) } -//int avformat_network_init (void) //Do global initialization of network components. func AvformatNetworkInit() int { return int(C.avformat_network_init()) } -//int avformat_network_deinit (void) //Undo the initialization done by avformat_network_init. func AvformatNetworkDeinit() int { return int(C.avformat_network_deinit()) } -//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 (f *AvInputFormat) AvIformatNext() *AvInputFormat { - return (*AvInputFormat)(C.av_iformat_next((*C.struct_AVInputFormat)(f))) +func (f *InputFormat) AvIformatNext() *InputFormat { + return (*InputFormat)(C.av_iformat_next((*C.struct_AVInputFormat)(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 (f *AvOutputFormat) AvOformatNext() *AvOutputFormat { - return (*AvOutputFormat)(C.av_oformat_next((*C.struct_AVOutputFormat)(f))) +func (f *OutputFormat) AvOformatNext() *OutputFormat { + return (*OutputFormat)(C.av_oformat_next((*C.struct_AVOutputFormat)(f))) } -//Context * avformat_alloc_context (void) //Allocate an Context. func AvformatAllocContext() *Context { return (*Context)(C.avformat_alloc_context()) } -//const AvClass * avformat_get_class (void) //Get the AvClass for Context. func AvformatGetClass() *AvClass { return (*AvClass)(C.avformat_get_class()) } -//uint8_t * av_stream_get_side_data (AvStream *stream, enum AvPacketSideDataType type, int *size) //Get side information from stream. -func (s *AvStream) AvStreamGetSideData(t AvPacketSideDataType, z int) *uint8 { +func (s *Stream) AvStreamGetSideData(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)))) } -//int avformat_alloc_output_context2 (Context **ctx, AvOutputFormat *oformat, const char *format_name, const char *filename) //Allocate an Context for an output format. -func AvformatAllocOutputContext2(ctx **Context, o *AvOutputFormat, fo, fi string) int { +func AvformatAllocOutputContext2(ctx **Context, o *OutputFormat, 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 AvFindInputFormat(s string) *AvInputFormat { - return (*AvInputFormat)(C.av_find_input_format(C.CString(s))) +//Find InputFormat based on the short name of the input format. +func AvFindInputFormat(s string) *InputFormat { + return (*InputFormat)(C.av_find_input_format(C.CString(s))) } -//AvInputFormat * av_probe_input_format (AvProbeData *pd, int is_opened) //Guess the file format. -func AvProbeInputFormat(pd *AvProbeData, i int) *AvInputFormat { - return (*AvInputFormat)(C.av_probe_input_format((*C.struct_AVProbeData)(pd), C.int(i))) +func AvProbeInputFormat(pd *AvProbeData, i int) *InputFormat { + return (*InputFormat)(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) //Guess the file format. -func AvProbeInputFormat2(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 AvProbeInputFormat2(pd *AvProbeData, o int, sm *int) *InputFormat { + return (*InputFormat)(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) //Guess the file format. -func AvProbeInputFormat3(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 AvProbeInputFormat3(pd *AvProbeData, o int, sl *int) *InputFormat { + return (*InputFormat)(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) //Probe a bytestream to determine the input format. -func AvProbeInputBuffer2(pb *AvIOContext, f **AvInputFormat, fi string, l int, o, m uint) int { +func AvProbeInputBuffer2(pb *AvIOContext, f **InputFormat, 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) //Like av_probe_input_buffer2() but returns 0 on success. -func AvProbeInputBuffer(pb *AvIOContext, f **AvInputFormat, fi string, l int, o, m uint) int { +func AvProbeInputBuffer(pb *AvIOContext, f **InputFormat, 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 (Context **ps, const char *filename, AvInputFormat *fmt, AvDictionary **options) //Open an input stream and read the header. -func AvformatOpenInput(ps **Context, fi string, fmt *AvInputFormat, d **AvDictionary) int { +func AvformatOpenInput(ps **Context, fi string, fmt *InputFormat, d **Dictionary) 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)))) } -//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 AvGuessFormat(sn, f, mt string) *AvOutputFormat { - return (*AvOutputFormat)(C.av_guess_format(C.CString(sn), C.CString(f), C.CString(mt))) +func AvGuessFormat(sn, f, mt string) *OutputFormat { + return (*OutputFormat)(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) //Guess the codec ID based upon muxer and filename. -func AvGuessCodec(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 AvGuessCodec(fmt *OutputFormat, sn, f, mt string, t MediaType) CodecId { + return (CodecId)(C.av_guess_codec((*C.struct_AVOutputFormat)(fmt), C.CString(sn), C.CString(f), C.CString(mt), (C.enum_AVMediaType)(t))) } -//void av_hex_dump (FILE *f, const uint8_t *buf, int size) //Send a nice hexadecimal dump of a buffer to the specified file stream. func AvHexDump(f *File, b *uint8, s int) { C.av_hex_dump((*C.FILE)(f), (*C.uint8_t)(b), C.int(s)) } -//void av_hex_dump_log (void *avcl, int level, const uint8_t *buf, int size) //Send a nice hexadecimal dump of a buffer to the log. func AvHexDumpLog(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) //Send a nice dump of a packet to the specified file stream. -func AvPktDump2(f *File, pkt *AvPacket, dp int, st *AvStream) { +func AvPktDump2(f *File, pkt *Packet, dp int, st *Stream) { 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) //Send a nice dump of a packet to the log. -func AvPktDumpLog2(a int, l int, pkt *AvPacket, dp int, st *AvStream) { +func AvPktDumpLog2(a int, l int, pkt *Packet, dp int, st *Stream) { 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 AvCodecGetId(t **AvCodecTag, tag uint) AvCodecId { - return (AvCodecId)(C.av_codec_get_id((**C.struct_AVCodecTag)(unsafe.Pointer(t)), C.uint(tag))) +//enum CodecId av_codec_get_id (const struct AvCodecTag *const *tags, unsigned int tag) +//Get the CodecId for the given codec tag tag. +func AvCodecGetId(t **AvCodecTag, tag uint) CodecId { + return (CodecId)(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) //Get the codec tag for the given codec id id. -func AvCodecGetTag(t **AvCodecTag, id AvCodecId) uint { +func AvCodecGetTag(t **AvCodecTag, id CodecId) 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) //Get the codec tag for the given codec id. -func AvCodecGetTag2(t **AvCodecTag, id AvCodecId, tag *uint) int { +func AvCodecGetTag2(t **AvCodecTag, id CodecId, 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_index_search_timestamp (AvStream *st, int64_t timestamp, int flags) //Get the index for a specific timestamp. -func AvIndexSearchTimestamp(st *AvStream, t int64, f int) int { +func AvIndexSearchTimestamp(st *Stream, 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) //Add an index entry into a sorted list. -func AvAddIndexEntry(st *AvStream, pos, t, int64, s, d, f int) int { +func AvAddIndexEntry(st *Stream, 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))) } -//void av_url_split (char *proto, int proto_size, char *authorization, int authorization_size, char *hostname, int hostname_size, int *port_ptr, char *path, int path_size, const char *url) //Split a URL string into components. func AvUrlSplit(p string, ps int, a string, as int, h string, hs int, pp *int, path string, psize int, url string) { 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)) @@ -274,13 +240,11 @@ func AvGetFrameFilename(b string, bs int, pa string, n int) int { return int(C.av_get_frame_filename(C.CString(b), C.int(bs), C.CString(pa), C.int(n))) } -//int av_filename_number_test (const char *filename) //Check whether filename actually is a numbered sequence generator. func AvFilenameNumberTest(f string) int { return int(C.av_filename_number_test(C.CString(f))) } -//int av_sdp_create (Context *ac[], int n_files, char *buf, int size) //Generate an SDP for an RTP session. func AvSdpCreate(ac **Context, 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))) @@ -292,13 +256,11 @@ func AvMatchExt(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) //Test if the given container can store a codec. -func AvformatQueryCodec(o *AvOutputFormat, cd AvCodecId, sc int) int { +func AvformatQueryCodec(o *OutputFormat, cd CodecId, 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 AvformatGetRiffVideoTags() *AvCodecTag { return (*AvCodecTag)(C.avformat_get_riff_video_tags()) } @@ -308,12 +270,10 @@ func AvformatGetRiffAudioTags() *AvCodecTag { return (*AvCodecTag)(C.avformat_get_riff_audio_tags()) } -//struct AvCodecTag * avformat_get_mov_video_tags (void) func AvformatGetMovVideoTags() *AvCodecTag { return (*AvCodecTag)(C.avformat_get_mov_video_tags()) } -//struct AvCodecTag * avformat_get_mov_audio_tags (void) func AvformatGetMovAudioTags() *AvCodecTag { return (*AvCodecTag)(C.avformat_get_mov_audio_tags()) } diff --git a/avformat/context.go b/avformat/context.go index 99d4e60..bf7dea5 100644 --- a/avformat/context.go +++ b/avformat/context.go @@ -104,10 +104,10 @@ func (s *Context) AvformatFreeContext() { C.avformat_free_context((*C.struct_AVFormatContext)(s)) } -//AvStream * avformat_new_stream (Context *s, const AvCodec *c) +//Stream * avformat_new_stream (Context *s, const AvCodec *c) //Add a new stream to a media file. -func (s *Context) AvformatNewStream(c *AvCodec) *AvStream { - return (*AvStream)(C.avformat_new_stream((*C.struct_AVFormatContext)(s), (*C.struct_AVCodec)(c))) +func (s *Context) AvformatNewStream(c *AvCodec) *Stream { + return (*Stream)(C.avformat_new_stream((*C.struct_AVFormatContext)(s), (*C.struct_AVCodec)(c))) } //AvProgram * av_new_program (Context *s, int id) @@ -115,9 +115,9 @@ func (s *Context) AvNewProgram(id int) *AvProgram { return (*AvProgram)(C.av_new_program((*C.struct_AVFormatContext)(s), C.int(id))) } -//int avformat_find_stream_info (Context *ic, AvDictionary **options) +//int avformat_find_stream_info (Context *ic, Dictionary **options) //Read packets of a media file to get stream information. -func (ic *Context) AvformatFindStreamInfo(d **AvDictionary) int { +func (ic *Context) AvformatFindStreamInfo(d **Dictionary) int { return int(C.avformat_find_stream_info((*C.struct_AVFormatContext)(ic), (**C.struct_AVDictionary)(unsafe.Pointer(d)))) } @@ -127,15 +127,15 @@ func (ic *Context) AvFindProgramFromStream(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 (Context *ic, enum AvMediaType type, int wanted_stream_nb, int related_stream, AvCodec **decoder_ret, int flags) +//int av_find_best_stream (Context *ic, enum MediaType type, int wanted_stream_nb, int related_stream, AvCodec **decoder_ret, int flags) //Find the "best" stream in the file. -func AvFindBestStream(ic *Context, t AvMediaType, ws, rs int, c **AvCodec, f int) int { +func AvFindBestStream(ic *Context, t MediaType, 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 (Context *s, AvPacket *pkt) +//int av_read_frame (Context *s, Packet *pkt) //Return the next frame of a stream. -func (s *Context) AvReadFrame(pkt *avcodec.AvPacket) int { +func (s *Context) AvReadFrame(pkt *avcodec.Packet) int { return int(C.av_read_frame((*C.struct_AVFormatContext)(unsafe.Pointer(s)), (*C.struct_AVPacket)(unsafe.Pointer(pkt)))) } @@ -169,33 +169,33 @@ func (s *Context) AvformatCloseInput() { C.avformat_close_input((**C.struct_AVFormatContext)(unsafe.Pointer(s))) } -//int avformat_write_header (Context *s, AvDictionary **options) +//int avformat_write_header (Context *s, Dictionary **options) //Allocate the stream private data and write the stream header to an output media file. -func (s *Context) AvformatWriteHeader(o **AvDictionary) int { +func (s *Context) AvformatWriteHeader(o **Dictionary) int { return int(C.avformat_write_header((*C.struct_AVFormatContext)(s), (**C.struct_AVDictionary)(unsafe.Pointer(o)))) } -//int av_write_frame (Context *s, AvPacket *pkt) +//int av_write_frame (Context *s, Packet *pkt) //Write a packet to an output media file. -func (s *Context) AvWriteFrame(pkt *AvPacket) int { +func (s *Context) AvWriteFrame(pkt *Packet) int { return int(C.av_write_frame((*C.struct_AVFormatContext)(s), (*C.struct_AVPacket)(pkt))) } -//int av_interleaved_write_frame (Context *s, AvPacket *pkt) +//int av_interleaved_write_frame (Context *s, Packet *pkt) //Write a packet to an output media file ensuring correct interleaving. -func (s *Context) AvInterleavedWriteFrame(pkt *AvPacket) int { +func (s *Context) AvInterleavedWriteFrame(pkt *Packet) int { return int(C.av_interleaved_write_frame((*C.struct_AVFormatContext)(s), (*C.struct_AVPacket)(pkt))) } -//int av_write_uncoded_frame (Context *s, int stream_index, AvFrame *frame) +//int av_write_uncoded_frame (Context *s, int stream_index, Frame *frame) //Write a uncoded frame to an output media file. -func (s *Context) AvWriteUncodedFrame(si int, f *AvFrame) int { +func (s *Context) AvWriteUncodedFrame(si int, f *Frame) 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 (Context *s, int stream_index, AvFrame *frame) +//int av_interleaved_write_uncoded_frame (Context *s, int stream_index, Frame *frame) //Write a uncoded frame to an output media file. -func (s *Context) AvInterleavedWriteUncodedFrame(si int, f *AvFrame) int { +func (s *Context) AvInterleavedWriteUncodedFrame(si int, f *Frame) int { return int(C.av_interleaved_write_uncoded_frame((*C.struct_AVFormatContext)(s), C.int(si), (*C.struct_AVFrame)(f))) } @@ -228,21 +228,21 @@ func (ic *Context) AvDumpFormat(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)) } -//AvRational av_guess_sample_aspect_ratio (Context *format, AvStream *stream, AvFrame *frame) +//Rational av_guess_sample_aspect_ratio (Context *format, Stream *stream, Frame *frame) //Guess the sample aspect ratio of a frame, based on both the stream and the frame aspect ratio. -func (f *Context) AvGuessSampleAspectRatio(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 (f *Context) AvGuessSampleAspectRatio(st *Stream, fr *Frame) Rational { + return (Rational)(C.av_guess_sample_aspect_ratio((*C.struct_AVFormatContext)(f), (*C.struct_AVStream)(st), (*C.struct_AVFrame)(fr))) } -//AvRational av_guess_frame_rate (Context *ctx, AvStream *stream, AvFrame *frame) +//Rational av_guess_frame_rate (Context *ctx, Stream *stream, Frame *frame) //Guess the frame rate, based on both the container and codec information. -func (ctx *Context) AvGuessFrameRate(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 (ctx *Context) AvGuessFrameRate(st *Stream, fr *Frame) Rational { + return (Rational)(C.av_guess_frame_rate((*C.struct_AVFormatContext)(ctx), (*C.struct_AVStream)(st), (*C.struct_AVFrame)(fr))) } -//int avformat_match_stream_specifier (Context *s, AvStream *st, const char *spec) +//int avformat_match_stream_specifier (Context *s, Stream *st, const char *spec) //Check if the stream st contained in s is matched by the stream specifier spec. -func (s *Context) AvformatMatchStreamSpecifier(st *AvStream, spec string) int { +func (s *Context) AvformatMatchStreamSpecifier(st *Stream, spec string) int { return int(C.avformat_match_stream_specifier((*C.struct_AVFormatContext)(s), (*C.struct_AVStream)(st), C.CString(spec))) } diff --git a/avformat/context_struct.go b/avformat/context_struct.go index 5bc0a68..eb6e5e6 100644 --- a/avformat/context_struct.go +++ b/avformat/context_struct.go @@ -27,8 +27,8 @@ func (ctxt *Context) VideoCodec() *AvCodec { return (*AvCodec)(unsafe.Pointer(ctxt.video_codec)) } -func (ctxt *Context) Metadata() *AvDictionary { - return (*AvDictionary)(unsafe.Pointer(ctxt.metadata)) +func (ctxt *Context) Metadata() *Dictionary { + return (*Dictionary)(unsafe.Pointer(ctxt.metadata)) } func (ctxt *Context) Internal() *AvFormatInternal { @@ -47,12 +47,12 @@ func (ctxt *Context) Programs() **AvProgram { return (**AvProgram)(unsafe.Pointer(ctxt.programs)) } -func (ctxt *Context) OffsetTimebase() AvRational { - return AvRational(ctxt.offset_timebase) +func (ctxt *Context) OffsetTimebase() Rational { + return Rational(ctxt.offset_timebase) } -func (ctxt *Context) Streams() *AvStream { - return (*AvStream)(unsafe.Pointer(ctxt.streams)) +func (ctxt *Context) Streams() *Stream { + return (*Stream)(unsafe.Pointer(ctxt.streams)) } func (ctxt *Context) Filename() string { @@ -67,16 +67,16 @@ func (ctxt *Context) Filename() string { // return C.GoString(ctxt.format_whitelist) // } -func (ctxt *Context) AudioCodecId() AvCodecId { - return AvCodecId(ctxt.audio_codec_id) +func (ctxt *Context) AudioCodecId() CodecId { + return CodecId(ctxt.audio_codec_id) } -func (ctxt *Context) SubtitleCodecId() AvCodecId { - return AvCodecId(ctxt.subtitle_codec_id) +func (ctxt *Context) SubtitleCodecId() CodecId { + return CodecId(ctxt.subtitle_codec_id) } -func (ctxt *Context) VideoCodecId() AvCodecId { - return AvCodecId(ctxt.video_codec_id) +func (ctxt *Context) VideoCodecId() CodecId { + return CodecId(ctxt.video_codec_id) } func (ctxt *Context) DurationEstimationMethod() AvDurationEstimationMethod { @@ -223,12 +223,12 @@ func (ctxt *Context) StartTimeRealtime() int64 { return int64(ctxt.start_time_realtime) } -func (ctxt *Context) Iformat() *AvInputFormat { - return (*AvInputFormat)(unsafe.Pointer(ctxt.iformat)) +func (ctxt *Context) Iformat() *InputFormat { + return (*InputFormat)(unsafe.Pointer(ctxt.iformat)) } -func (ctxt *Context) Oformat() *AvOutputFormat { - return (*AvOutputFormat)(unsafe.Pointer(ctxt.oformat)) +func (ctxt *Context) Oformat() *OutputFormat { + return (*OutputFormat)(unsafe.Pointer(ctxt.oformat)) } func (ctxt *Context) PacketBuffer() *AvPacketList { diff --git a/avformat/stream.go b/avformat/stream.go index 8cb3eaf..2ac1528 100644 --- a/avformat/stream.go +++ b/avformat/stream.go @@ -7,33 +7,33 @@ package avformat //#include import "C" -//AvRational av_stream_get_r_frame_rate (const AvStream *s) -func (s *AvStream) AvStreamGetRFrameRate() AvRational { - return (AvRational)(C.av_stream_get_r_frame_rate((*C.struct_AVStream)(s))) +//Rational av_stream_get_r_frame_rate (const Stream *s) +func (s *Stream) AvStreamGetRFrameRate() Rational { + return (Rational)(C.av_stream_get_r_frame_rate((*C.struct_AVStream)(s))) } -//void av_stream_set_r_frame_rate (AvStream *s, AvRational r) -func (s *AvStream) AvStreamSetRFrameRate(r AvRational) { +//void av_stream_set_r_frame_rate (Stream *s, Rational r) +func (s *Stream) AvStreamSetRFrameRate(r Rational) { 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 (s *AvStream) AvStreamGetParser() *AvCodecParserContext { - return (*AvCodecParserContext)(C.av_stream_get_parser((*C.struct_AVStream)(s))) +//struct CodecParserContext * av_stream_get_parser (const Stream *s) +func (s *Stream) AvStreamGetParser() *CodecParserContext { + return (*CodecParserContext)(C.av_stream_get_parser((*C.struct_AVStream)(s))) } -// //char * av_stream_get_recommended_encoder_configuration (const AvStream *s) -// func (s *AvStream) AvStreamGetRecommendedEncoderConfiguration() string { +// //char * av_stream_get_recommended_encoder_configuration (const Stream *s) +// func (s *Stream) AvStreamGetRecommendedEncoderConfiguration() 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 (s *AvStream) AvStreamSetRecommendedEncoderConfiguration( c string) { +// //void av_stream_set_recommended_encoder_configuration (Stream *s, char *configuration) +// func (s *Stream) AvStreamSetRecommendedEncoderConfiguration( 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 Stream *st) //Returns the pts of the last muxed packet + its duration. -func (s *AvStream) AvStreamGetEndPts() int64 { +func (s *Stream) AvStreamGetEndPts() int64 { return int64(C.av_stream_get_end_pts((*C.struct_AVStream)(s))) } diff --git a/avformat/stream_struct.go b/avformat/stream_struct.go index eec114e..8fdcc3c 100644 --- a/avformat/stream_struct.go +++ b/avformat/stream_struct.go @@ -11,218 +11,218 @@ import ( "unsafe" ) -func (avs *AvStream) Codec() *AvCodecContext { - return (*AvCodecContext)(unsafe.Pointer(avs.codec)) +func (avs *Stream) Codec() *CodecContext { + return (*CodecContext)(unsafe.Pointer(avs.codec)) } -func (avs *AvStream) Metadata() *AvDictionary { - return (*AvDictionary)(unsafe.Pointer(avs.metadata)) +func (avs *Stream) Metadata() *Dictionary { + return (*Dictionary)(unsafe.Pointer(avs.metadata)) } -func (avs *AvStream) IndexEntries() *AvIndexEntry { +func (avs *Stream) IndexEntries() *AvIndexEntry { return (*AvIndexEntry)(unsafe.Pointer(avs.index_entries)) } -func (avs *AvStream) AttachedPic() AvPacket { - return AvPacket(avs.attached_pic) +func (avs *Stream) AttachedPic() Packet { + return Packet(avs.attached_pic) } -func (avs *AvStream) SideData() *AvPacketSideData { +func (avs *Stream) SideData() *AvPacketSideData { return (*AvPacketSideData)(unsafe.Pointer(avs.side_data)) } -func (avs *AvStream) ProbeData() AvProbeData { +func (avs *Stream) ProbeData() AvProbeData { return AvProbeData(avs.probe_data) } -func (avs *AvStream) AvgFrameRate() AvRational { - return AvRational(avs.avg_frame_rate) +func (avs *Stream) AvgFrameRate() Rational { + return Rational(avs.avg_frame_rate) } -// func (avs *AvStream) DisplayAspectRatio() *AvRational { -// return (*AvRational)(unsafe.Pointer(avs.display_aspect_ratio)) +// func (avs *Stream) DisplayAspectRatio() *Rational { +// return (*Rational)(unsafe.Pointer(avs.display_aspect_ratio)) // } -func (avs *AvStream) RFrameRate() AvRational { - return AvRational(avs.r_frame_rate) +func (avs *Stream) RFrameRate() Rational { + return Rational(avs.r_frame_rate) } -func (avs *AvStream) SampleAspectRatio() AvRational { - return AvRational(avs.sample_aspect_ratio) +func (avs *Stream) SampleAspectRatio() Rational { + return Rational(avs.sample_aspect_ratio) } -func (avs *AvStream) TimeBase() AvRational { - return AvRational(avs.time_base) +func (avs *Stream) TimeBase() Rational { + return Rational(avs.time_base) } -// func (avs *AvStream) RecommendedEncoderConfiguration() string { +// func (avs *Stream) RecommendedEncoderConfiguration() string { // return C.GoString(avs.recommended_encoder_configuration) // } -func (avs *AvStream) Discard() AvDiscard { +func (avs *Stream) Discard() AvDiscard { return AvDiscard(avs.discard) } -func (avs *AvStream) NeedParsing() AvStreamParseType { +func (avs *Stream) NeedParsing() AvStreamParseType { return AvStreamParseType(avs.need_parsing) } -func (avs *AvStream) CodecInfoNbFrames() int { +func (avs *Stream) CodecInfoNbFrames() int { return int(avs.codec_info_nb_frames) } -func (avs *AvStream) Disposition() int { +func (avs *Stream) Disposition() int { return int(avs.disposition) } -func (avs *AvStream) EventFlags() int { +func (avs *Stream) EventFlags() int { return int(avs.event_flags) } -func (avs *AvStream) Id() int { +func (avs *Stream) Id() int { return int(avs.id) } -func (avs *AvStream) Index() int { +func (avs *Stream) Index() int { return int(avs.index) } -func (avs *AvStream) InjectGlobalSideData() int { +func (avs *Stream) InjectGlobalSideData() int { return int(avs.inject_global_side_data) } -func (avs *AvStream) LastIpDuration() int { +func (avs *Stream) LastIpDuration() int { return int(avs.last_IP_duration) } -func (avs *AvStream) NbDecodedFrames() int { +func (avs *Stream) NbDecodedFrames() int { return int(avs.nb_decoded_frames) } -func (avs *AvStream) NbIndexEntries() int { +func (avs *Stream) NbIndexEntries() int { return int(avs.nb_index_entries) } -func (avs *AvStream) NbSideData() int { +func (avs *Stream) NbSideData() int { return int(avs.nb_side_data) } -func (avs *AvStream) ProbePackets() int { +func (avs *Stream) ProbePackets() int { return int(avs.probe_packets) } -func (avs *AvStream) PtsWrapBehavior() int { +func (avs *Stream) PtsWrapBehavior() int { return int(avs.pts_wrap_behavior) } -func (avs *AvStream) RequestProbe() int { +func (avs *Stream) RequestProbe() int { return int(avs.request_probe) } -func (avs *AvStream) SkipSamples() int { +func (avs *Stream) SkipSamples() int { return int(avs.skip_samples) } -func (avs *AvStream) SkipToKeyframe() int { +func (avs *Stream) SkipToKeyframe() int { return int(avs.skip_to_keyframe) } -func (avs *AvStream) StreamIdentifier() int { +func (avs *Stream) StreamIdentifier() int { return int(avs.stream_identifier) } -func (avs *AvStream) UpdateInitialDurationsDone() int { +func (avs *Stream) UpdateInitialDurationsDone() int { return int(avs.update_initial_durations_done) } -func (avs *AvStream) CurDts() int64 { +func (avs *Stream) CurDts() int64 { return int64(avs.cur_dts) } -func (avs *AvStream) Duration() int64 { +func (avs *Stream) Duration() int64 { return int64(avs.duration) } -// func (avs *AvStream) FirstDiscardSample() int64 { +// func (avs *Stream) FirstDiscardSample() int64 { // return int64(avs.first_discard_sample) // } -func (avs *AvStream) FirstDts() int64 { +func (avs *Stream) FirstDts() int64 { return int64(avs.first_dts) } -func (avs *AvStream) InterleaverChunkDuration() int64 { +func (avs *Stream) InterleaverChunkDuration() int64 { return int64(avs.interleaver_chunk_duration) } -func (avs *AvStream) InterleaverChunkSize() int64 { +func (avs *Stream) InterleaverChunkSize() int64 { return int64(avs.interleaver_chunk_size) } -// func (avs *AvStream) LastDiscardSample() int64 { +// func (avs *Stream) LastDiscardSample() int64 { // return int64(avs.last_discard_sample) // } -func (avs *AvStream) LastDtsForOrderCheck() int64 { +func (avs *Stream) LastDtsForOrderCheck() int64 { return int64(avs.last_dts_for_order_check) } -func (avs *AvStream) LastIpPts() int64 { +func (avs *Stream) LastIpPts() int64 { return int64(avs.last_IP_pts) } -func (avs *AvStream) MuxTsOffset() int64 { +func (avs *Stream) MuxTsOffset() int64 { return int64(avs.mux_ts_offset) } -func (avs *AvStream) NbFrames() int64 { +func (avs *Stream) NbFrames() int64 { return int64(avs.nb_frames) } -func (avs *AvStream) PtsBuffer() int64 { +func (avs *Stream) PtsBuffer() int64 { return int64(avs.pts_buffer[0]) } -func (avs *AvStream) PtsReorderError() int64 { +func (avs *Stream) PtsReorderError() int64 { return int64(avs.pts_reorder_error[0]) } -func (avs *AvStream) PtsWrapReference() int64 { +func (avs *Stream) PtsWrapReference() int64 { return int64(avs.pts_wrap_reference) } -// func (avs *AvStream) StartSkipSamples() int64 { +// func (avs *Stream) StartSkipSamples() int64 { // return int64(avs.start_skip_samples) // } -func (avs *AvStream) StartTime() int64 { +func (avs *Stream) StartTime() int64 { return int64(avs.start_time) } -func (avs *AvStream) Parser() *AvCodecParserContext { - return (*AvCodecParserContext)(unsafe.Pointer(avs.parser)) +func (avs *Stream) Parser() *CodecParserContext { + return (*CodecParserContext)(unsafe.Pointer(avs.parser)) } -func (avs *AvStream) LastInPacketBuffer() *AvPacketList { +func (avs *Stream) LastInPacketBuffer() *AvPacketList { return (*AvPacketList)(unsafe.Pointer(avs.last_in_packet_buffer)) } -// func (avs *AvStream) PrivPts() *FFFrac { +// func (avs *Stream) PrivPts() *FFFrac { // return (*FFFrac)(unsafe.Pointer(avs.priv_pts)) // } -func (avs *AvStream) DtsMisordered() uint8 { +func (avs *Stream) DtsMisordered() uint8 { return uint8(avs.dts_misordered) } -func (avs *AvStream) DtsOrdered() uint8 { +func (avs *Stream) DtsOrdered() uint8 { return uint8(avs.dts_ordered) } -func (avs *AvStream) PtsReorderErrorCount() uint8 { +func (avs *Stream) PtsReorderErrorCount() uint8 { return uint8(avs.pts_reorder_error_count[0]) } -func (avs *AvStream) IndexEntriesAllocatedSize() uint { +func (avs *Stream) IndexEntriesAllocatedSize() uint { return uint(avs.index_entries_allocated_size) } diff --git a/avutil/avutil.go b/avutil/avutil.go index 186132b..e4ec3c3 100644 --- a/avutil/avutil.go +++ b/avutil/avutil.go @@ -18,11 +18,11 @@ import ( ) type ( - AvOptions C.struct_AVOptions - AvDictionary C.struct_AVDictionary + Options C.struct_AVOptions + Dictionary C.struct_AVDictionary AvTree C.struct_AVTree - AvRational C.struct_AVRational - AvMediaType C.enum_AVMediaType + Rational C.struct_AVRational + MediaType C.enum_AVMediaType AvPictureType C.enum_AVPictureType File C.FILE ) @@ -45,9 +45,9 @@ func Avutil_license() string { return C.GoString(C.avutil_license()) } -//const char * av_get_media_type_string (enum AvMediaType media_type) +//const char * av_get_media_type_string (enum MediaType media_type) //Return a string describing the media_type enum, NULL if media_type is unknown. -func Av_get_media_type_string(mt AvMediaType) string { +func Av_get_media_type_string(mt MediaType) string { return C.GoString(C.av_get_media_type_string((C.enum_AVMediaType)(mt))) } @@ -76,8 +76,8 @@ func Av_fopen_utf8(p, m string) *File { return (*File)(f) } -//AvRational av_get_time_base_q (void) +//Rational av_get_time_base_q (void) //Return the fractional representation of the internal time base. -func Av_get_time_base_q() AvRational { - return (AvRational)(C.av_get_time_base_q()) +func Av_get_time_base_q() Rational { + return (Rational)(C.av_get_time_base_q()) } diff --git a/avutil/frame.go b/avutil/frame.go index c0d2dbf..4da748a 100644 --- a/avutil/frame.go +++ b/avutil/frame.go @@ -18,122 +18,122 @@ type ( AvBuffer C.struct_AVBuffer AvBufferRef C.struct_AVBufferRef AvBufferPool C.struct_AVBufferPool - AvFrame C.struct_AVFrame + Frame C.struct_AVFrame AvFrameSideData C.struct_AVFrameSideData AvFrameSideDataType C.enum_AVFrameSideDataType ) -//AvDictionary ** avpriv_frame_get_metadatap (AvFrame *frame) -func Avpriv_frame_get_metadatap(f *AvFrame) **AvDictionary { - return (**AvDictionary)(unsafe.Pointer(C.avpriv_frame_get_metadatap((*C.struct_AVFrame)(unsafe.Pointer(f))))) +//Dictionary ** avpriv_frame_get_metadatap (Frame *frame) +func Avpriv_frame_get_metadatap(f *Frame) **Dictionary { + return (**Dictionary)(unsafe.Pointer(C.avpriv_frame_get_metadatap((*C.struct_AVFrame)(unsafe.Pointer(f))))) } -//int av_frame_set_qp_table (AvFrame *f, AvBufferRef *buf, int stride, int qp_type) -func Av_frame_set_qp_table(f *AvFrame, b *AvBufferRef, s, q int) int { +//int av_frame_set_qp_table (Frame *f, AvBufferRef *buf, int stride, int qp_type) +func Av_frame_set_qp_table(f *Frame, b *AvBufferRef, s, q int) int { return int(C.av_frame_set_qp_table((*C.struct_AVFrame)(unsafe.Pointer(f)), (*C.struct_AVBufferRef)(unsafe.Pointer(b)), C.int(s), C.int(q))) } -//int8_t * av_frame_get_qp_table (AvFrame *f, int *stride, int *type) -func Av_frame_get_qp_table(f *AvFrame, s, t *int) int8 { +//int8_t * av_frame_get_qp_table (Frame *f, int *stride, int *type) +func Av_frame_get_qp_table(f *Frame, s, t *int) int8 { return int8(*C.av_frame_get_qp_table((*C.struct_AVFrame)(unsafe.Pointer(f)), (*C.int)(unsafe.Pointer(s)), (*C.int)(unsafe.Pointer(t)))) } -// //static void get_frame_defaults (AvFrame *frame) -// func Get_frame_defaults(f *AvFrame) { +// //static void get_frame_defaults (Frame *frame) +// func Get_frame_defaults(f *Frame) { // C.get_frame_defaults(*C.struct_AVFrame(f)) // } -//AvFrame * av_frame_alloc (void) -//Allocate an AvFrame and set its fields to default values. -func Av_frame_alloc() *AvFrame { - return (*AvFrame)(unsafe.Pointer(C.av_frame_alloc())) +//Frame * av_frame_alloc (void) +//Allocate an Frame and set its fields to default values. +func Av_frame_alloc() *Frame { + return (*Frame)(unsafe.Pointer(C.av_frame_alloc())) } -//void av_frame_free (AvFrame **frame) +//void av_frame_free (Frame **frame) //Free the frame and any dynamically allocated objects in it, e.g. -func Av_frame_free(f *AvFrame) { +func Av_frame_free(f *Frame) { C.av_frame_free((**C.struct_AVFrame)(unsafe.Pointer(f))) } -// //static int get_video_buffer (AvFrame *frame, int align) -// func Get_video_buffer(f *AvFrame, a int) int { +// //static int get_video_buffer (Frame *frame, int align) +// func Get_video_buffer(f *Frame, a int) int { // return int(C.get_video_buffer(f, C.int(a))) // } -// //static int get_audio_buffer (AvFrame *frame, int align) -// func Get_audio_buffer(f *AvFrame, a int) int { +// //static int get_audio_buffer (Frame *frame, int align) +// func Get_audio_buffer(f *Frame, a int) int { // return C.get_audio_buffer(f, C.int(a)) // } -//int av_frame_get_buffer (AvFrame *frame, int align) +//int av_frame_get_buffer (Frame *frame, int align) //Allocate new buffer(s) for audio or video data. -func Av_frame_get_buffer(f *AvFrame, a int) int { +func Av_frame_get_buffer(f *Frame, a int) int { return int(C.av_frame_get_buffer((*C.struct_AVFrame)(unsafe.Pointer(f)), C.int(a))) } -//int av_frame_ref (AvFrame *dst, AvFrame *src) +//int av_frame_ref (Frame *dst, Frame *src) //Setup a new reference to the data described by an given frame. -func Av_frame_ref(d, s *AvFrame) int { +func Av_frame_ref(d, s *Frame) int { return int(C.av_frame_ref((*C.struct_AVFrame)(unsafe.Pointer(d)), (*C.struct_AVFrame)(unsafe.Pointer(s)))) } -//AvFrame * av_frame_clone (AvFrame *src) +//Frame * av_frame_clone (Frame *src) //Create a new frame that references the same data as src. -func Av_frame_clone(f *AvFrame) *AvFrame { - return (*AvFrame)(C.av_frame_clone((*C.struct_AVFrame)(unsafe.Pointer(f)))) +func Av_frame_clone(f *Frame) *Frame { + return (*Frame)(C.av_frame_clone((*C.struct_AVFrame)(unsafe.Pointer(f)))) } -//void av_frame_unref (AvFrame *frame) +//void av_frame_unref (Frame *frame) //Unreference all the buffers referenced by frame and reset the frame fields. -func Av_frame_unref(f *AvFrame) { +func Av_frame_unref(f *Frame) { cf := (*C.struct_AVFrame)(unsafe.Pointer(f)) C.av_frame_unref(cf) } -//void av_frame_move_ref (AvFrame *dst, AvFrame *src) +//void av_frame_move_ref (Frame *dst, Frame *src) //Move everythnig contained in src to dst and reset src. -func Av_frame_move_ref(d, s *AvFrame) { +func Av_frame_move_ref(d, s *Frame) { C.av_frame_move_ref((*C.struct_AVFrame)(unsafe.Pointer(d)), (*C.struct_AVFrame)(unsafe.Pointer(s))) } -//int av_frame_is_writable (AvFrame *frame) +//int av_frame_is_writable (Frame *frame) //Check if the frame data is writable. -func Av_frame_is_writable(f *AvFrame) int { +func Av_frame_is_writable(f *Frame) int { return int(C.av_frame_is_writable((*C.struct_AVFrame)(unsafe.Pointer(f)))) } -//int av_frame_make_writable (AvFrame *frame) +//int av_frame_make_writable (Frame *frame) //Ensure that the frame data is writable, avoiding data copy if possible. -func Av_frame_make_writable(f *AvFrame) int { +func Av_frame_make_writable(f *Frame) int { return int(C.av_frame_make_writable((*C.struct_AVFrame)(unsafe.Pointer(f)))) } -//int av_frame_copy_props (AvFrame *dst, const AvFrame *src) +//int av_frame_copy_props (Frame *dst, const Frame *src) //Copy only "metadata" fields from src to dst. -func Av_frame_copy_props(d, s *AvFrame) int { +func Av_frame_copy_props(d, s *Frame) int { return int(C.av_frame_copy_props((*C.struct_AVFrame)(unsafe.Pointer(d)), (*C.struct_AVFrame)(unsafe.Pointer(s)))) } -//AvBufferRef * av_frame_get_plane_buffer (AvFrame *frame, int plane) +//AvBufferRef * av_frame_get_plane_buffer (Frame *frame, int plane) //Get the buffer reference a given data plane is stored in. -func Av_frame_get_plane_buffer(f *AvFrame, p int) *AvBufferRef { +func Av_frame_get_plane_buffer(f *Frame, p int) *AvBufferRef { return (*AvBufferRef)(C.av_frame_get_plane_buffer((*C.struct_AVFrame)(unsafe.Pointer(f)), C.int(p))) } -//AvFrameSideData * av_frame_new_side_data (AvFrame *frame, enum AvFrameSideDataType type, int size) +//AvFrameSideData * av_frame_new_side_data (Frame *frame, enum AvFrameSideDataType type, int size) //Add a new side data to a frame. -func Av_frame_new_side_data(f *AvFrame, d AvFrameSideDataType, s int) *AvFrameSideData { +func Av_frame_new_side_data(f *Frame, d AvFrameSideDataType, s int) *AvFrameSideData { return (*AvFrameSideData)(C.av_frame_new_side_data((*C.struct_AVFrame)(unsafe.Pointer(f)), (C.enum_AVFrameSideDataType)(d), C.int(s))) } -//AvFrameSideData * av_frame_get_side_data (AvFrame *frame, enum AvFrameSideDataType type) -func Av_frame_get_side_data(f *AvFrame, t AvFrameSideDataType) *AvFrameSideData { +//AvFrameSideData * av_frame_get_side_data (Frame *frame, enum AvFrameSideDataType type) +func Av_frame_get_side_data(f *Frame, t AvFrameSideDataType) *AvFrameSideData { return (*AvFrameSideData)(C.av_frame_get_side_data((*C.struct_AVFrame)(unsafe.Pointer(f)), (C.enum_AVFrameSideDataType)(t))) } -func Data(f *AvFrame) *uint8 { +func Data(f *Frame) *uint8 { return (*uint8)(unsafe.Pointer((*C.uint8_t)(unsafe.Pointer(&f.data)))) } -func Linesize(f *AvFrame) int { +func Linesize(f *Frame) int { return int(*(*C.int)(unsafe.Pointer(&f.linesize))) } diff --git a/example/tutorial01.c.source b/example/tutorial01.c.source deleted file mode 100644 index cc08825..0000000 --- a/example/tutorial01.c.source +++ /dev/null @@ -1,195 +0,0 @@ -// tutorial01.c -// Code based on a tutorial by Martin Bohme (boehme@inb.uni-luebeckREMOVETHIS.de) -// Tested on Gentoo, CVS version 5/01/07 compiled with GCC 4.1.1 -// With updates from https://github.com/chelyaev/ffmpeg-tutorial -// Updates tested on: -// LAvC 54.59.100, LAvF 54.29.104, LSWS 2.1.101 -// on GCC 4.7.2 in Debian February 2015 - -// A small sample program that shows how to use libavformat and libavcodec to -// read video from a file. -// -// Use -// -// gcc -o tutorial01 tutorial01.c -lavformat -lavcodec -lswscale -lz -// -// to build (assuming libavformat and libavcodec are correctly installed -// your system). -// -// Run using -// -// tutorial01 myvideofile.mpg -// -// to write the first five frames from "myvideofile.mpg" to disk in PPM -// format. - -#include -#include -#include - -#include - -// compatibility with newer API -#if LIBAvCODEC_VERSION_INT < Av_VERSION_INT(55,28,1) -#define av_frame_alloc avcodec_alloc_frame -#define av_frame_free avcodec_free_frame -#endif - -void SaveFrame(AvFrame *pFrame, int width, int height, int iFrame) { - FILE *pFile; - char szFilename[32]; - int y; - - // Open file - sprintf(szFilename, "frame%d.ppm", iFrame); - pFile=fopen(szFilename, "wb"); - if(pFile==NULL) - return; - - // Write header - fprintf(pFile, "P6\n%d %d\n255\n", width, height); - - // Write pixel data - for(y=0; ydata[0]+y*pFrame->linesize[0], 1, width*3, pFile); - - // Close file - fclose(pFile); -} - -int main(int argc, char *argv[]) { - // Initalizing these to NULL prevents segfaults! - AvFormatContext *pFormatCtx = NULL; - int i, videoStream; - AvCodecContext *pCodecCtxOrig = NULL; - AvCodecContext *pCodecCtx = NULL; - AvCodec *pCodec = NULL; - AvFrame *pFrame = NULL; - AvFrame *pFrameRGB = NULL; - AvPacket packet; - int frameFinished; - int numBytes; - uint8_t *buffer = NULL; - struct SwsContext *sws_ctx = NULL; - - if(argc < 2) { - printf("Please provide a movie file\n"); - return -1; - } - // Register all formats and codecs - av_register_all(); - - // Open video file - if(avformat_open_input(&pFormatCtx, argv[1], NULL, NULL)!=0) - return -1; // Couldn't open file - - // Retrieve stream information - if(avformat_find_stream_info(pFormatCtx, NULL)<0) - return -1; // Couldn't find stream information - - // Dump information about file onto standard error - av_dump_format(pFormatCtx, 0, argv[1], 0); - - // Find the first video stream - videoStream=-1; - for(i=0; inb_streams; i++) - if(pFormatCtx->streams[i]->codec->codec_type==AvMEDIA_TYPE_VIDEO) { - videoStream=i; - break; - } - if(videoStream==-1) - return -1; // Didn't find a video stream - - // Get a pointer to the codec context for the video stream - pCodecCtxOrig=pFormatCtx->streams[videoStream]->codec; - // Find the decoder for the video stream - pCodec=avcodec_find_decoder(pCodecCtxOrig->codec_id); - if(pCodec==NULL) { - fprintf(stderr, "Unsupported codec!\n"); - return -1; // Codec not found - } - // Copy context - pCodecCtx = avcodec_alloc_context3(pCodec); - if(avcodec_copy_context(pCodecCtx, pCodecCtxOrig) != 0) { - fprintf(stderr, "Couldn't copy codec context"); - return -1; // Error copying codec context - } - - // Open codec - if(avcodec_open2(pCodecCtx, pCodec, NULL)<0) - return -1; // Could not open codec - - // Allocate video frame - pFrame=av_frame_alloc(); - - // Allocate an AvFrame structure - pFrameRGB=av_frame_alloc(); - if(pFrameRGB==NULL) - return -1; - - // Determine required buffer size and allocate buffer - numBytes=avpicture_get_size(PIX_FMT_RGB24, pCodecCtx->width, - pCodecCtx->height); - buffer=(uint8_t *)av_malloc(numBytes*sizeof(uint8_t)); - - // Assign appropriate parts of buffer to image planes in pFrameRGB - // Note that pFrameRGB is an AvFrame, but AvFrame is a superset - // of AvPicture - avpicture_fill((AvPicture *)pFrameRGB, buffer, PIX_FMT_RGB24, - pCodecCtx->width, pCodecCtx->height); - - // initialize SWS context for software scaling - sws_ctx = sws_getContext(pCodecCtx->width, - pCodecCtx->height, - pCodecCtx->pix_fmt, - pCodecCtx->width, - pCodecCtx->height, - PIX_FMT_RGB24, - SWS_BILINEAR, - NULL, - NULL, - NULL - ); - - // Read frames and save first five frames to disk - i=0; - while(av_read_frame(pFormatCtx, &packet)>=0) { - // Is this a packet from the video stream? - if(packet.stream_index==videoStream) { - // Decode video frame - avcodec_decode_video2(pCodecCtx, pFrame, &frameFinished, &packet); - - // Did we get a video frame? - if(frameFinished) { - // Convert the image from its native format to RGB - sws_scale(sws_ctx, (uint8_t const * const *)pFrame->data, - pFrame->linesize, 0, pCodecCtx->height, - pFrameRGB->data, pFrameRGB->linesize); - - // Save the frame to disk - if(++i<=5) - SaveFrame(pFrameRGB, pCodecCtx->width, pCodecCtx->height, - i); - } - } - - // Free the packet that was allocated by av_read_frame - av_free_packet(&packet); - } - - // Free the RGB image - av_free(buffer); - av_frame_free(&pFrameRGB); - - // Free the YUV frame - av_frame_free(&pFrame); - - // Close the codecs - avcodec_close(pCodecCtx); - avcodec_close(pCodecCtxOrig); - - // Close the video file - avformat_close_input(&pFormatCtx); - - return 0; -} \ No newline at end of file diff --git a/example/tutorial01.go b/example/tutorial01.go index 761fce1..ef71110 100644 --- a/example/tutorial01.go +++ b/example/tutorial01.go @@ -19,17 +19,17 @@ func main() { ctxtFormat *avformat.Context ctxtSource *avcodec.Context ctxtDest *avcodec.Context - videoCodec *avcodec.AvCodec - videoFrame *avutil.AvFrame - videoFrameRGB *avutil.AvFrame - packet *avcodec.AvPacket - ctxtSws *swscale.SwsContext + videoCodec *avcodec.Codec + videoFrame *avutil.Frame + videoFrameRGB *avutil.Frame + packet *avcodec.Packet + ctxtSws *swscale.Context videoStream int frameFinished int numBytes int url string ) - //media_type *avutil.AvMediaType + //media_type *avutil.MediaType // Register all formats and codecs avformat.AvRegisterAll() @@ -66,7 +66,7 @@ func main() { log.Println("Stream Number:", i) //FIX: AvMEDIA_TYPE_VIDEO - if (*avformat.AvCodecContext)(s.Codec()) != nil { + if (*avformat.CodecContext)(s.Codec()) != nil { videoStream = i break } @@ -118,15 +118,15 @@ func main() { // Allocate video frame videoFrame = avutil.Av_frame_alloc() - // Allocate an AvFrame structure + // Allocate an Frame structure if videoFrameRGB = avutil.Av_frame_alloc(); videoFrameRGB == nil { return } //##TODO - var a swscale.AvPixelFormat + var a swscale.PixelFormat var b int - //avcodec.AvPixelFormat + //avcodec.PixelFormat //avcodec.PIX_FMT_RGB24 //avcodec.SWS_BILINEAR @@ -135,20 +135,20 @@ func main() { pix_fmt := ctxtDest.PixFmt() // Determine required buffer size and allocate buffer - numBytes = avcodec.AvpictureGetSize((avcodec.AvPixelFormat)(a), w, h) + numBytes = avcodec.AvpictureGetSize((avcodec.PixelFormat)(a), w, h) buffer := avutil.Av_malloc(uintptr(numBytes)) // Assign appropriate parts of buffer to image planes in videoFrameRGB - // Note that videoFrameRGB is an AvFrame, but AvFrame is a superset + // Note that videoFrameRGB is an Frame, but Frame is a superset // of AvPicture avp := (*avcodec.AvPicture)(unsafe.Pointer(videoFrameRGB)) - avp.AvpictureFill((*uint8)(buffer), (avcodec.AvPixelFormat)(a), w, h) + avp.AvpictureFill((*uint8)(buffer), (avcodec.PixelFormat)(a), w, h) // initialize SWS context for software scaling ctxtSws = swscale.Sws_getContext(w, h, - (swscale.AvPixelFormat)(pix_fmt), + (swscale.PixelFormat)(pix_fmt), w, h, a, @@ -166,7 +166,7 @@ func main() { s := packet.StreamIndex() if s == videoStream { // Decode video frame - ctxtDest.AvcodecDecodeVideo2((*avcodec.AvFrame)(unsafe.Pointer(videoFrame)), &frameFinished, packet) + ctxtDest.AvcodecDecodeVideo2((*avcodec.Frame)(unsafe.Pointer(videoFrame)), &frameFinished, packet) // Did we get a video frame? if frameFinished > 0 { @@ -212,7 +212,7 @@ func main() { } -func saveFrame(videoFrame *avutil.AvFrame, width int, height int, iFrame int) { +func saveFrame(videoFrame *avutil.Frame, width int, height int, iFrame int) { var szFilename string var y int diff --git a/swresample/swresample.go b/swresample/swresample.go index 59d863b..57605ba 100644 --- a/swresample/swresample.go +++ b/swresample/swresample.go @@ -18,105 +18,105 @@ import ( ) type ( - SwrContext C.struct_SwrContext - AvFrame C.struct_AVFrame + Context C.struct_SwrContext + Frame C.struct_AVFrame AvClass C.struct_AVClass AvSampleFormat C.enum_AVSampleFormat ) //const AvClass * swr_get_class (void) -//Get the AvClass for SwrContext. +//Get the AvClass for Context. func Swr_get_class() *AvClass { return (*AvClass)(C.swr_get_class()) } -//SwrContext constructor functions -//struct SwrContext * swr_alloc (void) -//Allocate SwrContext. -func Swr_alloc() *SwrContext { - return (*SwrContext)(C.swr_alloc()) +//Context constructor functions +//struct Context * swr_alloc (void) +//Allocate Context. +func Swr_alloc() *Context { + return (*Context)(C.swr_alloc()) } -//int swr_init (struct SwrContext *s) +//int swr_init (struct Context *s) //Initialize context after user parameters have been set. -func Swr_init(s *SwrContext) int { +func Swr_init(s *Context) int { return int(C.swr_init((*C.struct_SwrContext)(s))) } -//int swr_is_initialized (struct SwrContext *s) +//int swr_is_initialized (struct Context *s) //Check whether an swr context has been initialized or not. -func Swr_is_initialized(s *SwrContext) int { +func Swr_is_initialized(s *Context) int { return int(C.swr_is_initialized((*C.struct_SwrContext)(s))) } -//struct SwrContext * swr_alloc_set_opts (struct SwrContext *s, int64_t out_ch_layout, enum AvSampleFormat out_sample_fmt, int out_sample_rate, int64_t in_ch_layout, enum AvSampleFormat in_sample_fmt, int in_sample_rate, int log_offset, void *log_ctx) -//Allocate SwrContext if needed and set/reset common parameters. -func Swr_alloc_set_opts(s *SwrContext, ocl int64, osf AvSampleFormat, osr int, icl int64, isf AvSampleFormat, isr, lo, lc int) *SwrContext { - return (*SwrContext)(C.swr_alloc_set_opts((*C.struct_SwrContext)(s), C.int64_t(ocl), (C.enum_AVSampleFormat)(osf), C.int(osr), C.int64_t(icl), (C.enum_AVSampleFormat)(isf), C.int(isr), C.int(lo), unsafe.Pointer(&lc))) +//struct Context * swr_alloc_set_opts (struct Context *s, int64_t out_ch_layout, enum AvSampleFormat out_sample_fmt, int out_sample_rate, int64_t in_ch_layout, enum AvSampleFormat in_sample_fmt, int in_sample_rate, int log_offset, void *log_ctx) +//Allocate Context if needed and set/reset common parameters. +func Swr_alloc_set_opts(s *Context, ocl int64, osf AvSampleFormat, osr int, icl int64, isf AvSampleFormat, isr, lo, lc int) *Context { + return (*Context)(C.swr_alloc_set_opts((*C.struct_SwrContext)(s), C.int64_t(ocl), (C.enum_AVSampleFormat)(osf), C.int(osr), C.int64_t(icl), (C.enum_AVSampleFormat)(isf), C.int(isr), C.int(lo), unsafe.Pointer(&lc))) } -//SwrContext destructor functions -//void swr_free (struct SwrContext **s) -//Free the given SwrContext and set the pointer to NULL. -func Swr_free(s **SwrContext) { +//Context destructor functions +//void swr_free (struct Context **s) +//Free the given Context and set the pointer to NULL. +func Swr_free(s **Context) { C.swr_free((**C.struct_SwrContext)(unsafe.Pointer(s))) } -//void swr_close (struct SwrContext *s) +//void swr_close (struct Context *s) //Closes the context so that swr_is_initialized() returns 0. -func Swr_close(s *SwrContext) { +func Swr_close(s *Context) { C.swr_close((*C.struct_SwrContext)(s)) } //Core conversion functions -//int swr_convert (struct SwrContext *s, uint8_t **out, int out_count, const uint8_t **in, int in_count) +//int swr_convert (struct Context *s, uint8_t **out, int out_count, const uint8_t **in, int in_count) //Convert audio. -func Swr_convert(s *SwrContext, out **uint8, oc int, in **uint8, ic int) int { +func Swr_convert(s *Context, out **uint8, oc int, in **uint8, ic int) int { return int(C.swr_convert((*C.struct_SwrContext)(s), (**C.uint8_t)(unsafe.Pointer(out)), C.int(oc), (**C.uint8_t)(unsafe.Pointer(in)), C.int(ic))) } -//int64_t swr_next_pts (struct SwrContext *s, int64_t pts) +//int64_t swr_next_pts (struct Context *s, int64_t pts) //Convert the next timestamp from input to output timestamps are in 1/(in_sample_rate * out_sample_rate) units. -func Swr_next_pts(s *SwrContext, pts int64) int64 { +func Swr_next_pts(s *Context, pts int64) int64 { return int64(C.swr_next_pts((*C.struct_SwrContext)(s), C.int64_t(pts))) } //Low-level option setting functions //These functons provide a means to set low-level options that is not possible with the AvOption API. -//int swr_set_compensation (struct SwrContext *s, int sample_delta, int compensation_distance) +//int swr_set_compensation (struct Context *s, int sample_delta, int compensation_distance) //Activate resampling compensation ("soft" compensation). -func Swr_set_compensation(s *SwrContext, sd, cd int) int { +func Swr_set_compensation(s *Context, sd, cd int) int { return int(C.swr_set_compensation((*C.struct_SwrContext)(s), C.int(sd), C.int(cd))) } -//int swr_set_channel_mapping (struct SwrContext *s, const int *channel_map) +//int swr_set_channel_mapping (struct Context *s, const int *channel_map) //Set a customized input channel mapping. -func Swr_set_channel_mapping(s *SwrContext, cm *int) int { +func Swr_set_channel_mapping(s *Context, cm *int) int { return int(C.swr_set_channel_mapping((*C.struct_SwrContext)(s), (*C.int)(unsafe.Pointer(cm)))) } -//int swr_set_matrix (struct SwrContext *s, const double *matrix, int stride) +//int swr_set_matrix (struct Context *s, const double *matrix, int stride) //Set a customized remix matrix. -func Swr_set_matrix(s *SwrContext, m *int, t int) int { +func Swr_set_matrix(s *Context, m *int, t int) int { return int(C.swr_set_matrix((*C.struct_SwrContext)(s), (*C.double)(unsafe.Pointer(m)), C.int(t))) } //Sample handling functions -//int swr_drop_output (struct SwrContext *s, int count) +//int swr_drop_output (struct Context *s, int count) //Drops the specified number of output samples. -func Swr_drop_output(s *SwrContext, c int) int { +func Swr_drop_output(s *Context, c int) int { return int(C.swr_drop_output((*C.struct_SwrContext)(s), C.int(c))) } -//int swr_inject_silence (struct SwrContext *s, int count) +//int swr_inject_silence (struct Context *s, int count) //Injects the specified number of silence samples. -func Swr_inject_silence(s *SwrContext, c int) int { +func Swr_inject_silence(s *Context, c int) int { return int(C.swr_inject_silence((*C.struct_SwrContext)(s), C.int(c))) } -//int64_t swr_get_delay (struct SwrContext *s, int64_t base) +//int64_t swr_get_delay (struct Context *s, int64_t base) //Gets the delay the next input sample will experience relative to the next output sample. -func Swr_get_delay(s *SwrContext, b int64) int64 { +func Swr_get_delay(s *Context, b int64) int64 { return int64(C.swr_get_delay((*C.struct_SwrContext)(s), C.int64_t(b))) } @@ -139,15 +139,15 @@ func Swresample_license() string { return C.GoString(C.swresample_license()) } -//AvFrame based API -//int swr_convert_frame (SwrContext *swr, AvFrame *output, const AvFrame *input) -//Convert the samples in the input AvFrame and write them to the output AvFrame. -func Swr_convert_frame(s *SwrContext, o, i *AvFrame) int { +//Frame based API +//int swr_convert_frame (Context *swr, Frame *output, const Frame *input) +//Convert the samples in the input Frame and write them to the output Frame. +func Swr_convert_frame(s *Context, o, i *Frame) int { return int(C.swr_convert_frame((*C.struct_SwrContext)(s), (*C.struct_AVFrame)(o), (*C.struct_AVFrame)(i))) } -//int swr_config_frame (SwrContext *swr, const AvFrame *out, const AvFrame *in) -//Configure or reconfigure the SwrContext using the information provided by the AvFrames. -func Swr_config_frame(s *SwrContext, o, i *AvFrame) int { +//int swr_config_frame (Context *swr, const Frame *out, const Frame *in) +//Configure or reconfigure the Context using the information provided by the AvFrames. +func Swr_config_frame(s *Context, o, i *Frame) int { return int(C.swr_config_frame((*C.struct_SwrContext)(s), (*C.struct_AVFrame)(o), (*C.struct_AVFrame)(i))) } diff --git a/swscale/swscale.go b/swscale/swscale.go index 8de927d..ed86c7a 100644 --- a/swscale/swscale.go +++ b/swscale/swscale.go @@ -21,81 +21,69 @@ import ( ) type ( - SwsContext C.struct_SwsContext - SwsFilter C.struct_SwsFilter - SwsVector C.struct_SwsVector - AvClass C.struct_AVClass - AvPixelFormat C.enum_AVPixelFormat + Context C.struct_SwsContext + Filter C.struct_SwsFilter + Vector C.struct_SwsVector + AvClass C.struct_AVClass + PixelFormat C.enum_AVPixelFormat ) -//unsigned swscale_version (void) //Return the LIBSWSCALE_VERSION_INT constant. func Swscale_version() uint { return uint(C.swscale_version()) } -//const char * swscale_configuration (void) //Return the libswscale build-time configuration. func Swscale_configuration() string { return C.GoString(C.swscale_configuration()) } -//const char * swscale_license (void) //Return the libswscale license. func Swscale_license() string { return C.GoString(C.swscale_license()) } -//const int * sws_getCoefficients (int colorspace) //Return a pointer to yuv<->rgb coefficients for the given colorspace suitable for sws_setColorspaceDetails(). func Sws_getCoefficients(c int) *int { return (*int)(unsafe.Pointer(C.sws_getCoefficients(C.int(c)))) } -//int sws_isSupportedInput (enum AvPixelFormat pix_fmt) //Return a positive value if pix_fmt is a supported input format, 0 otherwise. -func Sws_isSupportedInput(p AvPixelFormat) int { +func Sws_isSupportedInput(p PixelFormat) int { return int(C.sws_isSupportedInput((C.enum_AVPixelFormat)(p))) } -//int sws_isSupportedOutput (enum AvPixelFormat pix_fmt) //Return a positive value if pix_fmt is a supported output format, 0 otherwise. -func Sws_isSupportedOutput(p AvPixelFormat) int { +func Sws_isSupportedOutput(p PixelFormat) int { return int(C.sws_isSupportedOutput((C.enum_AVPixelFormat)(p))) } -//int sws_isSupportedEndiannessConversion (enum AvPixelFormat pix_fmt) -func Sws_isSupportedEndiannessConversion(p AvPixelFormat) int { +func Sws_isSupportedEndiannessConversion(p PixelFormat) int { return int(C.sws_isSupportedEndiannessConversion((C.enum_AVPixelFormat)(p))) } -//struct SwsContext * sws_alloc_context (void) -//Allocate an empty SwsContext. -func Sws_alloc_context() *SwsContext { - return (*SwsContext)(C.sws_alloc_context()) +//Allocate an empty Context. +func Sws_alloc_context() *Context { + return (*Context)(C.sws_alloc_context()) } -//int sws_init_context (struct SwsContext *sws_context, SwsFilter *srcFilter, SwsFilter *dstFilter) //Initialize the swscaler context sws_context. -func Sws_init_context(ctxt *SwsContext, sf, df *SwsFilter) int { +func Sws_init_context(ctxt *Context, sf, df *Filter) int { return int(C.sws_init_context((*C.struct_SwsContext)(ctxt), (*C.struct_SwsFilter)(sf), (*C.struct_SwsFilter)(df))) } -//void sws_freeContext (struct SwsContext *swsContext) //Free the swscaler context swsContext. -func Sws_freeContext(ctxt *SwsContext) { +func Sws_freeContext(ctxt *Context) { C.sws_freeContext((*C.struct_SwsContext)(ctxt)) } -//struct SwsContext * sws_getContext (int srcW, int srcH, enum AvPixelFormat srcFormat, int dstW, int dstH, enum AvPixelFormat dstFormat, int flags, SwsFilter *srcFilter, SwsFilter *dstFilter, const double *param) -//Allocate and return an SwsContext. -func Sws_getContext(sw, sh int, sf AvPixelFormat, dw, dh int, df AvPixelFormat, f int, sfl, dfl *SwsFilter, p *int) *SwsContext { - return (*SwsContext)(C.sws_getContext(C.int(sw), C.int(sh), (C.enum_AVPixelFormat)(sf), C.int(dw), C.int(dh), (C.enum_AVPixelFormat)(df), C.int(f), (*C.struct_SwsFilter)(sfl), (*C.struct_SwsFilter)(dfl), (*C.double)(unsafe.Pointer(p)))) +//Allocate and return an Context. +func Sws_getContext(sw, sh int, sf PixelFormat, dw, dh int, df PixelFormat, f int, sfl, dfl *Filter, p *int) *Context { + return (*Context)(C.sws_getContext(C.int(sw), C.int(sh), (C.enum_AVPixelFormat)(sf), C.int(dw), C.int(dh), (C.enum_AVPixelFormat)(df), C.int(f), (*C.struct_SwsFilter)(sfl), (*C.struct_SwsFilter)(dfl), (*C.double)(unsafe.Pointer(p)))) } -////int sws_scale (struct SwsContext *c, const uint8_t *const srcSlice[], const int srcStride[], int srcSliceY, int srcSliceH, uint8_t *const dst[], const int dstStride[]) ////Scale the image slice in srcSlice and put the resulting scaled slice in the image in dst. -func Sws_scale(ctxt *SwsContext, src *uint8, str int, y, h int, d *uint8, ds int) int { +func Sws_scale(ctxt *Context, src *uint8, str int, y, h int, d *uint8, ds int) int { cctxt := (*C.struct_SwsContext)(unsafe.Pointer(ctxt)) csrc := (*C.uint8_t)(unsafe.Pointer(src)) cstr := (*C.int)(unsafe.Pointer(&str)) @@ -104,15 +92,13 @@ func Sws_scale(ctxt *SwsContext, src *uint8, str int, y, h int, d *uint8, ds int return int(C.sws_scale(cctxt, &csrc, cstr, C.int(y), C.int(h), &cd, cds)) } -//int sws_setColorspaceDetails (struct SwsContext *c, const int inv_table[4], int srcRange, const int table[4], int dstRange, int brightness, int contrast, int saturation) -func Sws_setColorspaceDetails(ctxt *SwsContext, it *int, sr int, t *int, dr, b, c, s int) int { +func Sws_setColorspaceDetails(ctxt *Context, it *int, sr int, t *int, dr, b, c, s int) int { cit := (*C.int)(unsafe.Pointer(it)) ct := (*C.int)(unsafe.Pointer(t)) return int(C.sws_setColorspaceDetails((*C.struct_SwsContext)(ctxt), cit, C.int(sr), ct, C.int(dr), C.int(b), C.int(c), C.int(s))) } -//int sws_getColorspaceDetails (struct SwsContext *c, int **inv_table, int *srcRange, int **table, int *dstRange, int *brightness, int *contrast, int *saturation) -func Sws_getColorspaceDetails(ctxt *SwsContext, it, sr, t, dr, b, c, s *int) int { +func Sws_getColorspaceDetails(ctxt *Context, it, sr, t, dr, b, c, s *int) int { cit := (**C.int)(unsafe.Pointer(it)) csr := (*C.int)(unsafe.Pointer(sr)) ct := (**C.int)(unsafe.Pointer(t)) @@ -123,108 +109,89 @@ func Sws_getColorspaceDetails(ctxt *SwsContext, it, sr, t, dr, b, c, s *int) int return int(C.sws_getColorspaceDetails((*C.struct_SwsContext)(ctxt), cit, csr, ct, cdr, cb, cc, cs)) } -//SwsVector * sws_allocVec (int length) //Allocate and return an uninitialized vector with length coefficients. func Sws_allocVec(l int) *C.struct_SwsVector { return C.sws_allocVec(C.int(l)) } -//SwsVector * sws_getGaussianVec (double variance, double quality) //Return a normalized Gaussian curve used to filter stuff quality = 3 is high quality, lower is lower quality. -func Sws_getGaussianVec(v, q float64) *SwsVector { - return (*SwsVector)(unsafe.Pointer(C.sws_getGaussianVec(C.double(v), C.double(q)))) +func Sws_getGaussianVec(v, q float64) *Vector { + return (*Vector)(unsafe.Pointer(C.sws_getGaussianVec(C.double(v), C.double(q)))) } -//SwsVector * sws_getConstVec (double c, int length) //Allocate and return a vector with length coefficients, all with the same value c. -func Sws_getConstVec(c float64, l int) *SwsVector { - return (*SwsVector)(unsafe.Pointer(C.sws_getConstVec(C.double(c), C.int(l)))) +func Sws_getConstVec(c float64, l int) *Vector { + return (*Vector)(unsafe.Pointer(C.sws_getConstVec(C.double(c), C.int(l)))) } -//SwsVector * sws_getIdentityVec (void) //Allocate and return a vector with just one coefficient, with value 1.0. -func Sws_getIdentityVec() *SwsVector { - return (*SwsVector)(unsafe.Pointer(C.sws_getIdentityVec())) +func Sws_getIdentityVec() *Vector { + return (*Vector)(unsafe.Pointer(C.sws_getIdentityVec())) } -//void sws_scaleVec (SwsVector *a, double scalar) //Scale all the coefficients of a by the scalar value. -func Sws_scaleVec(a *SwsVector, s float64) { +func Sws_scaleVec(a *Vector, s float64) { C.sws_scaleVec((*C.struct_SwsVector)(unsafe.Pointer(a)), C.double(s)) } -//void sws_normalizeVec (SwsVector *a, double height) //Scale all the coefficients of a so that their sum equals height. -func Sws_normalizeVec(a *SwsVector, h float64) { +func Sws_normalizeVec(a *Vector, h float64) { C.sws_normalizeVec((*C.struct_SwsVector)(a), C.double(h)) } -//void sws_convVec (SwsVector *a, SwsVector *b) -func Sws_convVec(a, b *SwsVector) { +func Sws_convVec(a, b *Vector) { C.sws_convVec((*C.struct_SwsVector)(a), (*C.struct_SwsVector)(b)) } -//void sws_addVec (SwsVector *a, SwsVector *b) -func Sws_addVec(a, b *SwsVector) { +func Sws_addVec(a, b *Vector) { C.sws_addVec((*C.struct_SwsVector)(a), (*C.struct_SwsVector)(b)) } -//void sws_subVec (SwsVector *a, SwsVector *b) -func Sws_subVec(a, b *SwsVector) { +func Sws_subVec(a, b *Vector) { C.sws_subVec((*C.struct_SwsVector)(a), (*C.struct_SwsVector)(b)) } -//void sws_shiftVec (SwsVector *a, int shift) -func Sws_shiftVec(a *SwsVector, s int) { +func Sws_shiftVec(a *Vector, s int) { C.sws_shiftVec((*C.struct_SwsVector)(a), C.int(s)) } -//SwsVector * sws_cloneVec (SwsVector *a) //Allocate and return a clone of the vector a, that is a vector with the same coefficients as a. -func Sws_cloneVec(a *SwsVector) *SwsVector { - return (*SwsVector)(unsafe.Pointer(C.sws_cloneVec((*C.struct_SwsVector)(a)))) +func Sws_cloneVec(a *Vector) *Vector { + return (*Vector)(unsafe.Pointer(C.sws_cloneVec((*C.struct_SwsVector)(a)))) } -//void sws_printVec2 (SwsVector *a, AvClass *log_ctx, int log_level) //Print with av_log() a textual representation of the vector a if log_level <= av_log_level. -func Sws_printVec2(a *SwsVector, lctx *AvClass, l int) { +func Sws_printVec2(a *Vector, lctx *AvClass, l int) { C.sws_printVec2((*C.struct_SwsVector)(a), (*C.struct_AVClass)(lctx), C.int(l)) } -//void sws_freeVec (SwsVector *a) -func Sws_freeVec(a *SwsVector) { +func Sws_freeVec(a *Vector) { C.sws_freeVec((*C.struct_SwsVector)(a)) } -//SwsFilter * sws_getDefaultFilter (float lumaGBlur, float chromaGBlur, float lumaSharpen, float chromaSharpen, float chromaHShift, float chromaVShift, int verbose) -func Sws_getDefaultFilter(lb, cb, ls, cs, chs, cvs float32, v int) *SwsFilter { - return (*SwsFilter)(unsafe.Pointer(C.sws_getDefaultFilter(C.float(lb), C.float(cb), C.float(ls), C.float(cs), C.float(chs), C.float(cvs), C.int(v)))) +func Sws_getDefaultFilter(lb, cb, ls, cs, chs, cvs float32, v int) *Filter { + return (*Filter)(unsafe.Pointer(C.sws_getDefaultFilter(C.float(lb), C.float(cb), C.float(ls), C.float(cs), C.float(chs), C.float(cvs), C.int(v)))) } -//void sws_freeFilter (SwsFilter *filter) -func Sws_freeFilter(f *SwsFilter) { +func Sws_freeFilter(f *Filter) { C.sws_freeFilter((*C.struct_SwsFilter)(f)) } -//struct SwsContext * sws_getCachedContext (struct SwsContext *context, int srcW, int srcH, enum AvPixelFormat srcFormat, int dstW, int dstH, enum AvPixelFormat dstFormat, int flags, SwsFilter *srcFilter, SwsFilter *dstFilter, const double *param) //Check if context can be reused, otherwise reallocate a new one. -func Sws_getCachedContext(ctxt *SwsContext, sw, sh int, sf AvPixelFormat, dw, dh int, df AvPixelFormat, f int, sfl, dfl *SwsFilter, p *float64) *SwsContext { - return (*SwsContext)(C.sws_getCachedContext((*C.struct_SwsContext)(ctxt), C.int(sw), C.int(sh), (C.enum_AVPixelFormat)(sf), C.int(dw), C.int(dh), (C.enum_AVPixelFormat)(df), C.int(f), (*C.struct_SwsFilter)(sfl), (*C.struct_SwsFilter)(dfl), (*C.double)(p))) +func Sws_getCachedContext(ctxt *Context, sw, sh int, sf PixelFormat, dw, dh int, df PixelFormat, f int, sfl, dfl *Filter, p *float64) *Context { + return (*Context)(C.sws_getCachedContext((*C.struct_SwsContext)(ctxt), C.int(sw), C.int(sh), (C.enum_AVPixelFormat)(sf), C.int(dw), C.int(dh), (C.enum_AVPixelFormat)(df), C.int(f), (*C.struct_SwsFilter)(sfl), (*C.struct_SwsFilter)(dfl), (*C.double)(p))) } -//void sws_convertPalette8ToPacked32 (const uint8_t *src, uint8_t *dst, int num_pixels, const uint8_t *palette) //Convert an 8-bit paletted frame into a frame with a color depth of 32 bits. func Sws_convertPalette8ToPacked32(s, d *uint8, px int, p *uint8) { C.sws_convertPalette8ToPacked32((*C.uint8_t)(s), (*C.uint8_t)(d), C.int(px), (*C.uint8_t)(p)) } -//void sws_convertPalette8ToPacked24 (const uint8_t *src, uint8_t *dst, int num_pixels, const uint8_t *palette) //Convert an 8-bit paletted frame into a frame with a color depth of 24 bits. func Sws_convertPalette8ToPacked24(s, d *uint8, px int, p *uint8) { C.sws_convertPalette8ToPacked24((*C.uint8_t)(s), (*C.uint8_t)(d), C.int(px), (*C.uint8_t)(p)) } -//const AvClass * sws_get_class (void) //Get the AvClass for swsContext. func Sws_get_class() *AvClass { return (*AvClass)(C.sws_get_class())