github/goav
4
0
Fork 0
mirror of https://github.com/giorgisio/goav.git synced 2024-04-21 12:31:56 +00:00
Code Issues Releases Wiki Activity

refactored code; go like syntax

Browse Source
This commit is contained in:
H.G. Giorgis
2015-09-03 17:42:12 -04:00
parent 4fa6efa72e
commit b4e9e6add1
5 changed files with 113 additions and 115 deletions
Download Patch File Download Diff File Expand all files Collapse all files
avcodec/avcodec.go
+10 -10
View File
@@ -34,7 +34,7 @@ type (
BitStreamFilter C.struct_AVBitStreamFilter
BitStreamFilterContext C.struct_AVBitStreamFilterContext
Rational C.struct_AVRational
AvClass C.struct_AVClass
Class C.struct_AVClass
AvHWAccel C.struct_AVHWAccel
AvPacketSideData C.struct_AVPacketSideData
AvPanScan C.struct_AVPanScan
@@ -98,19 +98,19 @@ func (c *Codec) AvcodecAllocContext3() *Context {
return (*Context)(C.avcodec_alloc_context3((*C.struct_AVCodec)(c)))
}
//Get the AvClass for Context.
func AvcodecGetClass() *AvClass {
return (*AvClass)(C.avcodec_get_class())
//Get the Class for Context.
func AvcodecGetClass() *Class {
return (*Class)(C.avcodec_get_class())
}
//Get the AvClass for Frame.
func AvcodecGetFrameClass() *AvClass {
return (*AvClass)(C.avcodec_get_frame_class())
//Get the Class for Frame.
func AvcodecGetFrameClass() *Class {
return (*Class)(C.avcodec_get_frame_class())
}
//Get the AvClass for AvSubtitleRect.
func AvcodecGetSubtitleRectClass() *AvClass {
return (*AvClass)(C.avcodec_get_subtitle_rect_class())
//Get the Class for AvSubtitleRect.
func AvcodecGetSubtitleRectClass() *Class {
return (*Class)(C.avcodec_get_subtitle_rect_class())
}
//Free all allocated data in the given subtitle struct.
avfilter/avfilter.go
+89 -91
View File
@@ -18,17 +18,15 @@ import (
)
type (
AvFilter C.struct_AVFilter
AvFilterContext C.struct_AVFilterContext
AvFilterLink C.struct_AVFilterLink
AvFilterGraph C.struct_AVFilterGraph
AvFilterInOut C.struct_AVFilterInOut
AvFilterPad C.struct_AVFilterPad
Dictionary C.struct_AVDictionary
AvClass C.struct_AVClass
)
type (
MediaType C.enum_AVMediaType
Filter C.struct_AVFilter
Context C.struct_AVFilterContext
Link C.struct_AVFilterLink
Graph C.struct_AVFilterGraph
Input C.struct_AVFilterInOut
Pad C.struct_AVFilterPad
Dictionary C.struct_AVDictionary
Class C.struct_AVClass
MediaType C.enum_AVMediaType
)
//unsigned avfilter_version (void)
@@ -49,57 +47,57 @@ func Avfilter_license() string {
return C.GoString(C.avfilter_license())
}
//int avfilter_pad_count (const AvFilterPad *pads)
//Get the number of elements in a NULL-terminated array of AvFilterPads (e.g.
func Avfilter_pad_count(p *AvFilterPad) int {
//int avfilter_pad_count (const Pad *pads)
//Get the number of elements in a NULL-terminated array of Pads (e.g.
func Avfilter_pad_count(p *Pad) int {
return int(C.avfilter_pad_count((*C.struct_AVFilterPad)(p)))
}
//const char * avfilter_pad_get_name (const AvFilterPad *pads, int pad_idx)
//Get the name of an AvFilterPad.
func Avfilter_pad_get_name(p *AvFilterPad, pi int) string {
//const char * avfilter_pad_get_name (const Pad *pads, int pad_idx)
//Get the name of an Pad.
func Avfilter_pad_get_name(p *Pad, pi int) string {
return C.GoString(C.avfilter_pad_get_name((*C.struct_AVFilterPad)(p), C.int(pi)))
}
//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) MediaType {
//enum MediaType avfilter_pad_get_type (const Pad *pads, int pad_idx)
//Get the type of an Pad.
func Avfilter_pad_get_type(p *Pad, 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)
//int avfilter_link (Context *src, unsigned srcpad, Context *dst, unsigned dstpad)
//Link two filters together.
func Avfilter_link(s *AvFilterContext, sp uint, d *AvFilterContext, dp uint) int {
func Avfilter_link(s *Context, sp uint, d *Context, dp uint) int {
return int(C.avfilter_link((*C.struct_AVFilterContext)(s), C.uint(sp), (*C.struct_AVFilterContext)(d), C.uint(dp)))
}
//void avfilter_link_free (AvFilterLink **link)
//void avfilter_link_free (Link **link)
//Free the link in *link, and set its pointer to NULL.
func Avfilter_link_free(l **AvFilterLink) {
func Avfilter_link_free(l **Link) {
C.avfilter_link_free((**C.struct_AVFilterLink)(unsafe.Pointer(l)))
}
//int avfilter_link_get_channels (AvFilterLink *link)
//int avfilter_link_get_channels (Link *link)
//Get the number of channels of a link.
func Avfilter_link_get_channels(l *AvFilterLink) int {
func Avfilter_link_get_channels(l *Link) int {
return int(C.avfilter_link_get_channels((*C.struct_AVFilterLink)(l)))
}
//void avfilter_link_set_closed (AvFilterLink *link, int closed)
//void avfilter_link_set_closed (Link *link, int closed)
//Set the closed field of a link.
func Avfilter_link_set_closed(l *AvFilterLink, c int) {
func Avfilter_link_set_closed(l *Link, c int) {
C.avfilter_link_set_closed((*C.struct_AVFilterLink)(l), C.int(c))
}
//int avfilter_config_links (AvFilterContext *filter)
//int avfilter_config_links (Context *filter)
//Negotiate the media format, dimensions, etc of all inputs to a filter.
func Avfilter_config_links(f *AvFilterContext) int {
func Avfilter_config_links(f *Context) int {
return int(C.avfilter_config_links((*C.struct_AVFilterContext)(f)))
}
//int avfilter_process_command (AvFilterContext *filter, const char *cmd, const char *arg, char *res, int res_len, int flags)
//int avfilter_process_command (Context *filter, const char *cmd, const char *arg, char *res, int res_len, int flags)
//Make the filter instance process a command.
func Avfilter_process_command(f *AvFilterContext, cmd, arg, res string, l, fl int) int {
func Avfilter_process_command(f *Context, cmd, arg, res string, l, fl int) int {
return int(C.avfilter_process_command((*C.struct_AVFilterContext)(f), C.CString(cmd), C.CString(arg), C.CString(res), C.int(l), C.int(fl)))
}
@@ -109,146 +107,146 @@ func Avfilter_register_all() {
C.avfilter_register_all()
}
//int avfilter_register (AvFilter *filter)
//int avfilter_register (Filter *filter)
//Register a filter.
func Avfilter_register(f *AvFilter) int {
func Avfilter_register(f *Filter) int {
return int(C.avfilter_register((*C.struct_AVFilter)(f)))
}
//const AvFilter * avfilter_get_by_name (const char *name)
//const Filter * avfilter_get_by_name (const char *name)
//Get a filter definition matching the given name.
func Avfilter_get_by_name(n string) *AvFilter {
return (*AvFilter)(C.avfilter_get_by_name(C.CString(n)))
func Avfilter_get_by_name(n string) *Filter {
return (*Filter)(C.avfilter_get_by_name(C.CString(n)))
}
//const AvFilter * avfilter_next (const AvFilter *prev)
//const Filter * avfilter_next (const Filter *prev)
//Iterate over all registered filters.
func Avfilter_next(f *AvFilter) *AvFilter {
return (*AvFilter)(C.avfilter_next((*C.struct_AVFilter)(f)))
func Avfilter_next(f *Filter) *Filter {
return (*Filter)(C.avfilter_next((*C.struct_AVFilter)(f)))
}
//int avfilter_init_str (AvFilterContext *ctx, const char *args)
//int avfilter_init_str (Context *ctx, const char *args)
//Initialize a filter with the supplied parameters.
func Avfilter_init_str(ctx *AvFilterContext, args string) int {
func (ctx *Context) Avfilter_init_str(args string) int {
return int(C.avfilter_init_str((*C.struct_AVFilterContext)(ctx), C.CString(args)))
}
//int avfilter_init_dict (AvFilterContext *ctx, Dictionary **options)
//int avfilter_init_dict (Context *ctx, Dictionary **options)
//Initialize a filter with the supplied dictionary of options.
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))))
func (ctx *Context) Avfilter_init_dict(o **Dictionary) int {
return int(C.avfilter_init_dict((*C.struct_AVFilterContext)(ctx), (**C.struct_AVDictionary)(unsafe.Pointer(o))))
}
//void avfilter_free (AvFilterContext *filter)
//void avfilter_free (Context *filter)
//Free a filter context.
func Avfilter_free(f *AvFilterContext) {
C.avfilter_free((*C.struct_AVFilterContext)(f))
func (ctx *Context) Avfilter_free() {
C.avfilter_free((*C.struct_AVFilterContext)(ctx))
}
//int avfilter_insert_filter (AvFilterLink *link, AvFilterContext *filt, unsigned filt_srcpad_idx, unsigned filt_dstpad_idx)
//int avfilter_insert_filter (Link *link, Context *filt, unsigned filt_srcpad_idx, unsigned filt_dstpad_idx)
//Insert a filter in the middle of an existing link.
func Avfilter_insert_filter(l *AvFilterLink, f *AvFilterContext, fsi, fdi uint) int {
func Avfilter_insert_filter(l *Link, f *Context, fsi, fdi uint) int {
return int(C.avfilter_insert_filter((*C.struct_AVFilterLink)(l), (*C.struct_AVFilterContext)(f), C.uint(fsi), C.uint(fdi)))
}
//const AvClass * avfilter_get_class (void)
//const Class * avfilter_get_class (void)
//avfilter_get_class
func Avfilter_get_class() *AvClass {
return (*AvClass)(C.avfilter_get_class())
func Avfilter_get_class() *Class {
return (*Class)(C.avfilter_get_class())
}
//Allocate a filter graph.
//AvFilterGraph * avfilter_graph_alloc (void)
func Avfilter_graph_alloc() *AvFilterGraph {
return (*AvFilterGraph)(C.avfilter_graph_alloc())
//Graph * avfilter_graph_alloc (void)
func Avfilter_graph_alloc() *Graph {
return (*Graph)(C.avfilter_graph_alloc())
}
//AvFilterContext * avfilter_graph_alloc_filter (AvFilterGraph *graph, const AvFilter *filter, const char *name)
//Context * avfilter_graph_alloc_filter (Graph *graph, const Filter *filter, const char *name)
//Create a new filter instance in a filter graph.
func Avfilter_graph_alloc_filter(g *AvFilterGraph, f *AvFilter, n string) *AvFilterContext {
return (*AvFilterContext)(C.avfilter_graph_alloc_filter((*C.struct_AVFilterGraph)(g), (*C.struct_AVFilter)(f), C.CString(n)))
func Avfilter_graph_alloc_filter(g *Graph, f *Filter, n string) *Context {
return (*Context)(C.avfilter_graph_alloc_filter((*C.struct_AVFilterGraph)(g), (*C.struct_AVFilter)(f), C.CString(n)))
}
//AvFilterContext * avfilter_graph_get_filter (AvFilterGraph *graph, const char *name)
//Context * avfilter_graph_get_filter (Graph *graph, const char *name)
//Get a filter instance identified by instance name from graph.
func Avfilter_graph_get_filter(g *AvFilterGraph, n string) *AvFilterContext {
return (*AvFilterContext)(C.avfilter_graph_get_filter((*C.struct_AVFilterGraph)(g), C.CString(n)))
func Avfilter_graph_get_filter(g *Graph, n string) *Context {
return (*Context)(C.avfilter_graph_get_filter((*C.struct_AVFilterGraph)(g), C.CString(n)))
}
//int avfilter_graph_create_filter (AvFilterContext **filt_ctx, const AvFilter *filt, const char *name, const char *args, void *opaque, AvFilterGraph *graph_ctx)
//int avfilter_graph_create_filter (Context **filt_ctx, const Filter *filt, const char *name, const char *args, void *opaque, Graph *graph_ctx)
//Create and add a filter instance into an existing graph.
func Avfilter_graph_create_filter(cx **AvFilterContext, f *AvFilter, n, a string, o int, g *AvFilterGraph) int {
func Avfilter_graph_create_filter(cx **Context, f *Filter, n, a string, o int, g *Graph) int {
return int(C.avfilter_graph_create_filter((**C.struct_AVFilterContext)(unsafe.Pointer(cx)), (*C.struct_AVFilter)(f), C.CString(n), C.CString(a), unsafe.Pointer(&o), (*C.struct_AVFilterGraph)(g)))
}
//void avfilter_graph_set_auto_convert (AvFilterGraph *graph, unsigned flags)
//void avfilter_graph_set_auto_convert (Graph *graph, unsigned flags)
//Enable or disable automatic format conversion inside the graph.
func Avfilter_graph_set_auto_convert(g *AvFilterGraph, f uint) {
func Avfilter_graph_set_auto_convert(g *Graph, f uint) {
C.avfilter_graph_set_auto_convert((*C.struct_AVFilterGraph)(g), C.uint(f))
}
//int avfilter_graph_config (AvFilterGraph *graphctx, void *log_ctx)
//int avfilter_graph_config (Graph *graphctx, void *log_ctx)
//Check validity and configure all the links and formats in the graph.
func Avfilter_graph_config(g *AvFilterGraph, l int) int {
func Avfilter_graph_config(g *Graph, l int) int {
return int(C.avfilter_graph_config((*C.struct_AVFilterGraph)(g), unsafe.Pointer(&l)))
}
//void avfilter_graph_free (AvFilterGraph **graph)
//void avfilter_graph_free (Graph **graph)
//Free a graph, destroy its links, and set *graph to NULL.
func Avfilter_graph_free(g **AvFilterGraph) {
func Avfilter_graph_free(g **Graph) {
C.avfilter_graph_free((**C.struct_AVFilterGraph)(unsafe.Pointer(g)))
}
//AvFilterInOut * avfilter_inout_alloc (void)
//Allocate a single AvFilterInOut entry.
func Avfilter_inout_alloc() *AvFilterInOut {
return (*AvFilterInOut)(C.avfilter_inout_alloc())
//Input * avfilter_inout_alloc (void)
//Allocate a single Input entry.
func Avfilter_inout_alloc() *Input {
return (*Input)(C.avfilter_inout_alloc())
}
//void avfilter_inout_free (AvFilterInOut **inout)
//Free the supplied list of AvFilterInOut and set *inout to NULL.
func Avfilter_inout_free(i **AvFilterInOut) {
//void avfilter_inout_free (Input **inout)
//Free the supplied list of Input and set *inout to NULL.
func Avfilter_inout_free(i **Input) {
C.avfilter_inout_free((**C.struct_AVFilterInOut)(unsafe.Pointer(i)))
}
//int avfilter_graph_parse (AvFilterGraph *graph, const char *filters, AvFilterInOut *inputs, AvFilterInOut *outputs, void *log_ctx)
//int avfilter_graph_parse (Graph *graph, const char *filters, Input *inputs, Input *outputs, void *log_ctx)
//Add a graph described by a string to a graph.
func Avfilter_graph_parse(g *AvFilterGraph, f string, i, o *AvFilterInOut, l int) int {
func Avfilter_graph_parse(g *Graph, f string, i, o *Input, l int) int {
return int(C.avfilter_graph_parse((*C.struct_AVFilterGraph)(g), C.CString(f), (*C.struct_AVFilterInOut)(i), (*C.struct_AVFilterInOut)(o), unsafe.Pointer(&l)))
}
//int avfilter_graph_parse_ptr (AvFilterGraph *graph, const char *filters, AvFilterInOut **inputs, AvFilterInOut **outputs, void *log_ctx)
//int avfilter_graph_parse_ptr (Graph *graph, const char *filters, Input **inputs, Input **outputs, void *log_ctx)
//Add a graph described by a string to a graph.
func Avfilter_graph_parse_ptr(g *AvFilterGraph, f string, i, o **AvFilterInOut, l int) int {
func Avfilter_graph_parse_ptr(g *Graph, f string, i, o **Input, l int) int {
return int(C.avfilter_graph_parse_ptr((*C.struct_AVFilterGraph)(g), C.CString(f), (**C.struct_AVFilterInOut)(unsafe.Pointer(i)), (**C.struct_AVFilterInOut)(unsafe.Pointer(o)), unsafe.Pointer(&l)))
}
//int avfilter_graph_parse2 (AvFilterGraph *graph, const char *filters, AvFilterInOut **inputs, AvFilterInOut **outputs)
//int avfilter_graph_parse2 (Graph *graph, const char *filters, Input **inputs, Input **outputs)
//Add a graph described by a string to a graph.
func Avfilter_graph_parse2(g *AvFilterGraph, f string, i, o **AvFilterInOut) int {
func Avfilter_graph_parse2(g *Graph, f string, i, o **Input) int {
return int(C.avfilter_graph_parse2((*C.struct_AVFilterGraph)(g), C.CString(f), (**C.struct_AVFilterInOut)(unsafe.Pointer(i)), (**C.struct_AVFilterInOut)(unsafe.Pointer(o))))
}
//int avfilter_graph_send_command (AvFilterGraph *graph, const char *target, const char *cmd, const char *arg, char *res, int res_len, int flags)
//int avfilter_graph_send_command (Graph *graph, const char *target, const char *cmd, const char *arg, char *res, int res_len, int flags)
//Send a command to one or more filter instances.
func Avfilter_graph_send_command(g *AvFilterGraph, t, cmd, arg, res string, resl, f int) int {
func Avfilter_graph_send_command(g *Graph, t, cmd, arg, res string, resl, f int) int {
return int(C.avfilter_graph_send_command((*C.struct_AVFilterGraph)(g), C.CString(t), C.CString(cmd), C.CString(arg), C.CString(res), C.int(resl), C.int(f)))
}
//int avfilter_graph_queue_command (AvFilterGraph *graph, const char *target, const char *cmd, const char *arg, int flags, double ts)
//int avfilter_graph_queue_command (Graph *graph, const char *target, const char *cmd, const char *arg, int flags, double ts)
//Queue a command for one or more filter instances.
func Avfilter_graph_queue_command(g *AvFilterGraph, t, cmd, arg string, f int, ts C.double) int {
func Avfilter_graph_queue_command(g *Graph, t, cmd, arg string, f int, ts C.double) int {
return int(C.avfilter_graph_queue_command((*C.struct_AVFilterGraph)(g), C.CString(t), C.CString(cmd), C.CString(arg), C.int(f), ts))
}
//char * avfilter_graph_dump (AvFilterGraph *graph, const char *options)
//char * avfilter_graph_dump (Graph *graph, const char *options)
//Dump a graph into a human-readable string representation.
func Avfilter_graph_dump(g *AvFilterGraph, o string) string {
func Avfilter_graph_dump(g *Graph, o string) string {
return C.GoString(C.avfilter_graph_dump((*C.struct_AVFilterGraph)(g), C.CString(o)))
}
//int avfilter_graph_request_oldest (AvFilterGraph *graph)
//int avfilter_graph_request_oldest (Graph *graph)
//Request a frame on the oldest sink
func Avfilter_graph_request_oldestlink(g *AvFilterGraph) int {
func Avfilter_graph_request_oldestlink(g *Graph) int {
return int(C.avfilter_graph_request_oldest((*C.struct_AVFilterGraph)(g)))
}
avformat/avformat.go
+4 -4
View File
@@ -45,7 +45,7 @@ type (
Rational C.struct_AVRational
AvCodec C.struct_AVCodec
AvCodecTag C.struct_AVCodecTag
AvClass C.struct_AVClass
Class C.struct_AVClass
AvFormatInternal C.struct_AVFormatInternal
AvIOInterruptCB C.struct_AVIOInterruptCB
AvPacketSideData C.struct_AVPacketSideData
@@ -123,9 +123,9 @@ func AvformatAllocContext() *Context {
return (*Context)(C.avformat_alloc_context())
}
//Get the AvClass for Context.
func AvformatGetClass() *AvClass {
return (*AvClass)(C.avformat_get_class())
//Get the Class for Context.
func AvformatGetClass() *Class {
return (*Class)(C.avformat_get_class())
}
//Get side information from stream.
swresample/swresample.go
+5 -5
View File
@@ -20,14 +20,14 @@ import (
type (
Context C.struct_SwrContext
Frame C.struct_AVFrame
AvClass C.struct_AVClass
Class C.struct_AVClass
AvSampleFormat C.enum_AVSampleFormat
)
//const AvClass * swr_get_class (void)
//Get the AvClass for Context.
func Swr_get_class() *AvClass {
return (*AvClass)(C.swr_get_class())
//const Class * swr_get_class (void)
//Get the Class for Context.
func Swr_get_class() *Class {
return (*Class)(C.swr_get_class())
}
//Context constructor functions
swscale/swscale.go
+5 -5
View File
@@ -24,7 +24,7 @@ type (
Context C.struct_SwsContext
Filter C.struct_SwsFilter
Vector C.struct_SwsVector
AvClass C.struct_AVClass
Class C.struct_AVClass
PixelFormat C.enum_AVPixelFormat
)
@@ -161,7 +161,7 @@ func Sws_cloneVec(a *Vector) *Vector {
}
//Print with av_log() a textual representation of the vector a if log_level <= av_log_level.
func Sws_printVec2(a *Vector, lctx *AvClass, l int) {
func Sws_printVec2(a *Vector, lctx *Class, l int) {
C.sws_printVec2((*C.struct_SwsVector)(a), (*C.struct_AVClass)(lctx), C.int(l))
}
@@ -192,7 +192,7 @@ 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))
}
//Get the AvClass for swsContext.
func Sws_get_class() *AvClass {
return (*AvClass)(C.sws_get_class())
//Get the Class for swsContext.
func Sws_get_class() *Class {
return (*Class)(C.sws_get_class())
}