update

decoder.go

@@ -17,7 +17,7 @@ import (
 )
 
 type Decoder struct {
-	decoder *C.gpujpeg_decoder
+	decoder C.gogpujpeg_decoder
 }
 
 func CreateDecoder() (*Decoder, error) {
@@ -29,7 +29,7 @@ func CreateDecoder() (*Decoder, error) {
 }
 
 func (d *Decoder) Init(param *Param, paramImage *ParamImage) {
-	C.gpujpeg_decoder_init(d.decoder, &param.param, &paramImage.param)
+	C.gpujpeg_decoder_init(d.decoder, param.param, paramImage.param)
 }
 
 func (d *Decoder) SetOutput(cs ColorSpace, fmt PixelFormat) {

encoder.go

@@ -0,0 +1,48 @@
+package gpujpeg
+
+/*
+#cgo LDFLAGS: -lgpujpeg
+#include <libgpujpeg/gpujpeg.h>
+#include <libgpujpeg/gpujpeg_common.h>
+#include <libgpujpeg/gpujpeg_encoder.h>
+#include <libgpujpeg/gpujpeg_decoder.h>
+#include <libgpujpeg/gpujpeg_type.h>
+#include <libgpujpeg/gpujpeg_version.h>
+#include "wrapper.h"
+*/
+import "C"
+import (
+	"errors"
+	"unsafe"
+)
+
+type Encoder struct {
+	encoder C.gogpujpeg_encoder
+}
+
+func CreateEncoder() (*Encoder, error) {
+	d := &Encoder{encoder: C.create_encoder()}
+	if d.encoder == nil {
+		return nil, errors.New("Can't create encoder")
+	}
+	return d, nil
+}
+
+func (e *Encoder) Encode(image []byte, param *Param, paramImage *ParamImage) (data []byte, err error) {
+	size := C.int(0)
+	result := C.encode(e.encoder, param.param, paramImage.param, (*C.uchar)(unsafe.Pointer(&image[0])), &size)
+
+	if size == C.int(0) {
+		return nil, errors.New("Can't encode")
+	}
+
+	data = make([]byte, int(size))
+
+	copy(data, *(*[]byte)(unsafe.Pointer(&result)))
+	C.gpujpeg_image_destroy(result)
+	return
+}
+
+func (d *Encoder) Free() {
+	C.gpujpeg_encoder_destroy(d.encoder)
+}

example/decode.go

@@ -3,6 +3,7 @@ package main
 import (
 	"fmt"
 	"io/ioutil"
+	"os"
 	"time"
 
 	"github.com/Danile71/go-gpujpeg"
@@ -18,13 +19,14 @@ func main() {
 		return
 	}
 
-	imageParam, count, err := gpujpeg.ReadImageInfo(data)
+	imageParam, _, err := gpujpeg.ReadImageInfo(data)
 	if err != nil {
 		fmt.Println(err)
 		return
 	}
+	defer imageParam.Free()
 
-	fmt.Println("width", imageParam.Width(), imageParam.Height(), imageParam.PixelFormat(), imageParam.ColorSpace(), imageParam.CompCount(), count)
+	fmt.Println("image width", imageParam.Width(), " height", imageParam.Height())
 	start := time.Now()
 
 	decoder, err := gpujpeg.CreateDecoder()
@@ -34,13 +36,13 @@ func main() {
 	}
 	defer decoder.Free()
 
-	decoder.SetOutput(gpujpeg.GPUJPEG_YCBCR_JPEG, gpujpeg.GPUJPEG_420_U8_P0P1P2)
+	decoder.SetOutput(gpujpeg.GPUJPEG_RGB, gpujpeg.GPUJPEG_420_U8_P0P1P2)
 
 	result, err := decoder.Decode(data)
 	if err != nil {
 		fmt.Println(err)
 		return
 	}
-	fmt.Println("result", len(result), time.Since(start))
-
+	fmt.Println(time.Since(start))
+	ioutil.WriteFile("result.rgb", result, os.ModePerm)
 }

param.go

@@ -13,18 +13,22 @@ package gpujpeg
 import "C"
 
 type Param struct {
-	param C.gpujpeg_parameters
+	param C.gogpujpeg_parameters
 }
 
 func SetParam() *Param {
-	p := &Param{}
-	C.gpujpeg_set_default_parameters(&p.param)
-	// p.param.restart_interval = 1
-	// p.param.interleaved = 1
-	// p.param.color_space_internal = 82
+	p := &Param{param: C.malloc_gpujpeg_parameters()}
+	C.gpujpeg_set_default_parameters(p.param)
 	return p
 }
 
+func (p *Param) Free() {
+	C.free_gpujpeg_parameters(p.param)
+	p.param = nil
+	p = nil
+}
+
+// get params
 func (p *Param) RestartInterval() int {
 	return int(p.param.restart_interval)
 }
@@ -37,6 +41,15 @@ func (p *Param) ColorSpaceInternal() int {
 	return int(p.param.color_space_internal)
 }
 
+func (p *Param) Quality() int {
+	return int(p.param.quality)
+}
+
+func (p *Param) SamplingFactor(i int) (byte, byte) {
+	return byte(p.param.sampling_factor[i].vertical), byte(p.param.sampling_factor[i].horizontal)
+}
+
+//set params
 func (p *Param) SetRestartInterval(i int) {
 	p.param.restart_interval = C.int(i)
 }
@@ -48,3 +61,12 @@ func (p *Param) SetInterleaved(i int) {
 func (p *Param) SetColorSpaceInternal(c uint32) {
 	p.param.color_space_internal = c
 }
+
+func (p *Param) SetQuality(q int) {
+	p.param.quality = C.int(q)
+}
+
+func (p *Param) SetSamplingFactor(i int, v, h byte) {
+	p.param.sampling_factor[i].vertical = C.uchar(v)
+	p.param.sampling_factor[i].horizontal = C.uchar(h)
+}

paramimage.go

@@ -72,7 +72,7 @@ func (d PixelFormat) String() string {
 }
 
 type ParamImage struct {
-	param C.gpujpeg_image_parameters
+	param C.gogpujpeg_image_parameters
 }
 
 func (p *ParamImage) Width() int {
@@ -116,19 +116,25 @@ func (p *ParamImage) SetPixelFormat(pf PixelFormat) {
 }
 
 func SetImageParam() *ParamImage {
-	p := &ParamImage{}
-	C.gpujpeg_image_set_default_parameters(&p.param)
+	p := &ParamImage{param: C.malloc_gpujpeg_image_parameters()}
+	C.gpujpeg_image_set_default_parameters(p.param)
 	return p
 }
 
 func ReadImageInfo(image []byte) (*ParamImage, int, error) {
-	p := &ParamImage{}
+	p := &ParamImage{param: C.malloc_gpujpeg_image_parameters()}
 
 	segment_count := C.int(0)
 
-	if C.gpujpeg_decoder_get_image_info((*C.uchar)(unsafe.Pointer(&image[0])), C.int(len(image)), &p.param, &segment_count) != C.int(0) {
+	if C.gpujpeg_decoder_get_image_info((*C.uchar)(unsafe.Pointer(&image[0])), C.int(len(image)), p.param, &segment_count) != C.int(0) {
 		return nil, 0, errors.New("Can't decode image info")
 	}
 
 	return p, int(segment_count), nil
 }
+
+func (p *ParamImage) Free() {
+	C.free_gpujpeg_image_parameters(p.param)
+	p.param = nil
+	p = nil
+}

wrapper.c

@@ -6,6 +6,36 @@
 #include <libgpujpeg/gpujpeg_version.h>
 #include "wrapper.h"
 
-gpujpeg_decoder *create_decoder() {
+gogpujpeg_decoder create_decoder() {
     return gpujpeg_decoder_create(0);
 }
+
+gogpujpeg_encoder create_encoder() {
+    return gpujpeg_encoder_create(0);
+}
+
+uint8_t * encode(gogpujpeg_encoder encoder,gogpujpeg_parameters param, gogpujpeg_image_parameters param_image,uint8_t* data ,int *image_compressed_size) {
+    uint8_t* image_compressed = NULL;
+	gpujpeg_encoder_input encoder_input;
+	gpujpeg_encoder_input_set_image(&encoder_input, data);
+    	if (gpujpeg_encoder_encode(encoder, param, param_image, &encoder_input, &image_compressed,
+		image_compressed_size) != 0) {
+    }
+    return image_compressed;
+}
+
+gogpujpeg_parameters malloc_gpujpeg_parameters() {
+    return malloc(sizeof(struct gpujpeg_parameters));
+}
+
+void free_gpujpeg_parameters(gogpujpeg_parameters params) {
+    free(params);
+}
+
+gogpujpeg_image_parameters malloc_gpujpeg_image_parameters() {
+    return malloc(sizeof(struct gpujpeg_image_parameters));
+}
+
+void free_gpujpeg_image_parameters(gogpujpeg_image_parameters params) {
+    free(params);
+}

wrapper.h

@@ -2,6 +2,8 @@
 #ifndef WRAPPER_H
 #define WRAPPER_H
 
+#include <stdio.h>
+#include <stdlib.h>
 #include <libgpujpeg/gpujpeg.h>
 #include <libgpujpeg/gpujpeg_common.h>
 #include <libgpujpeg/gpujpeg_encoder.h>
@@ -9,11 +11,23 @@
 #include <libgpujpeg/gpujpeg_type.h>
 #include <libgpujpeg/gpujpeg_version.h>
 
-typedef struct gpujpeg_decoder gpujpeg_decoder;
-typedef struct gpujpeg_parameters gpujpeg_parameters;
-typedef struct gpujpeg_image_parameters gpujpeg_image_parameters;
+typedef struct gpujpeg_decoder *gogpujpeg_decoder;
+typedef struct gpujpeg_encoder *gogpujpeg_encoder;
+
+typedef struct gpujpeg_parameters *gogpujpeg_parameters;
+typedef struct gpujpeg_image_parameters *gogpujpeg_image_parameters;
+
 typedef struct gpujpeg_decoder_output gpujpeg_decoder_output;
+typedef struct gpujpeg_encoder_input gpujpeg_encoder_input;
 
-gpujpeg_decoder *create_decoder();
+gogpujpeg_decoder create_decoder();
+gogpujpeg_encoder create_encoder();
 
+gogpujpeg_parameters malloc_gpujpeg_parameters();
+void free_gpujpeg_parameters(gogpujpeg_parameters p);
+
+gogpujpeg_image_parameters malloc_gpujpeg_image_parameters();
+void free_gpujpeg_image_parameters(gogpujpeg_image_parameters p);
+
+uint8_t * encode(gogpujpeg_encoder encoder,gogpujpeg_parameters param, gogpujpeg_image_parameters param_image,uint8_t* data ,int *image_compressed_size);
 #endif /* WRAPPER_H */