diff --git a/avcodec/avcodec.go b/avcodec/avcodec.go
index 77435c8..ebe6148 100644
--- a/avcodec/avcodec.go
+++ b/avcodec/avcodec.go
@@ -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.
diff --git a/avfilter/avfilter.go b/avfilter/avfilter.go
index 1c8f518..6a4362f 100644
--- a/avfilter/avfilter.go
+++ b/avfilter/avfilter.go
@@ -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)))
 }
diff --git a/avformat/avformat.go b/avformat/avformat.go
index 069b763..2ab5682 100644
--- a/avformat/avformat.go
+++ b/avformat/avformat.go
@@ -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.
diff --git a/swresample/swresample.go b/swresample/swresample.go
index 57605ba..7f05566 100644
--- a/swresample/swresample.go
+++ b/swresample/swresample.go
@@ -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
diff --git a/swscale/swscale.go b/swscale/swscale.go
index ed86c7a..2b5f0c2 100644
--- a/swscale/swscale.go
+++ b/swscale/swscale.go
@@ -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())
 }