Implementation for SWS scale

README.md

@@ -27,6 +27,7 @@ Examples are located in the [examples](examples) directory and mirror as much as
 |Filtering|[see](examples/filtering/main.go)|[see](https://github.com/FFmpeg/FFmpeg/blob/n5.1.2/doc/examples/filtering_video.c)
 |Remuxing|[see](examples/remuxing/main.go)|[see](https://github.com/FFmpeg/FFmpeg/blob/n5.1.2/doc/examples/remuxing.c)
 |Transcoding|[see](examples/transcoding/main.go)|[see](https://github.com/FFmpeg/FFmpeg/blob/n5.1.2/doc/examples/transcoding.c)
+|Scaling|[see](examples/scaling/main.go)|[see](https://github.com/FFmpeg/FFmpeg/blob/n5.1.2/doc/examples/scaling_video.c)
 
 *Tip: you can use the video sample located in the `testdata` directory for your tests*
 

examples/scaling/main.go

@@ -0,0 +1,74 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+	"image/png"
+	"log"
+	"os"
+
+	"github.com/asticode/go-astiav"
+)
+
+func main() {
+	var (
+		dstFilename string
+		dstWidth    int
+		dstHeight   int
+	)
+
+	flag.StringVar(&dstFilename, "output", "", "Output file name")
+	flag.IntVar(&dstWidth, "w", 0, "Destination width")
+	flag.IntVar(&dstHeight, "h", 0, "Destination height")
+	flag.Parse()
+
+	if dstFilename == "" || dstWidth <= 0 || dstHeight <= 0 {
+		fmt.Fprintf(os.Stderr, "Usage: %s -output output_file -w W -h H\n", os.Args[0])
+		flag.PrintDefaults()
+		os.Exit(1)
+	}
+
+	dstFile, err := os.Create(dstFilename)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "Could not open destination file %s\n", dstFilename)
+		os.Exit(1)
+	}
+	defer dstFile.Close()
+
+	srcW, srcH := 320, 240
+	srcPixFmt, dstPixFmt := astiav.PixelFormatYuv420P, astiav.PixelFormatRgba
+	srcFrame := astiav.AllocFrame()
+	srcFrame.SetHeight(srcH)
+	srcFrame.SetWidth(srcW)
+	srcFrame.SetPixelFormat(srcPixFmt)
+	srcFrame.AllocBuffer(1)
+	srcFrame.ImageFillBlack()
+	defer srcFrame.Free()
+
+	dstFrame := astiav.AllocFrame()
+	defer dstFrame.Free()
+
+	swsCtx := astiav.SwsGetContext(srcW, srcH, srcPixFmt, dstWidth, dstHeight, dstPixFmt, astiav.SWS_POINT, dstFrame)
+	if swsCtx == nil {
+		fmt.Fprintln(os.Stderr, "Unable to create scale context")
+		os.Exit(1)
+	}
+	defer swsCtx.Free()
+
+	err = swsCtx.Scale(srcFrame, dstFrame)
+	if err != nil {
+                log.Fatalf("Unable to scale: %s", err.Error())
+        }
+
+        img, err := dstFrame.Data().Image()
+        if err != nil {
+                log.Fatalf("Unable to get image: %s", err.Error())
+        }
+
+        err = png.Encode(dstFile, img)
+        if err != nil {
+                log.Fatalf("Unable to encode image to png: %s", err.Error())
+        }
+
+	log.Printf("Successfully scale to %dx%d and write image to: %s", dstWidth, dstHeight, dstFilename)
+}

sws_context.go

@@ -0,0 +1,111 @@
+package astiav
+
+//#cgo pkg-config: libswscale
+//#include <libswscale/swscale.h>
+import "C"
+import (
+	"fmt"
+)
+
+// https://github.com/FFmpeg/FFmpeg/blob/n4.2.7/libswscale/swscale_internal.h#L280
+type SWSContext struct {
+	c         *C.struct_SwsContext
+	dstFormat PixelFormat
+	srcFormat PixelFormat
+	srcW      int
+	srcH      int
+	dstW      int
+	dstH      int
+	flags     ScalingAlgorithm
+	dstFrame  *Frame
+}
+
+// https://github.com/FFmpeg/FFmpeg/blob/n5.0/libswscale/swscale.h#L59
+type ScalingAlgorithm int
+
+const (
+	SWS_FAST_BILINEAR ScalingAlgorithm = ScalingAlgorithm(C.SWS_FAST_BILINEAR)
+	SWS_BILINEAR      ScalingAlgorithm = ScalingAlgorithm(C.SWS_BILINEAR)
+	SWS_BICUBIC       ScalingAlgorithm = ScalingAlgorithm(C.SWS_BICUBIC)
+	SWS_X             ScalingAlgorithm = ScalingAlgorithm(C.SWS_X)
+	SWS_POINT         ScalingAlgorithm = ScalingAlgorithm(C.SWS_POINT)
+	SWS_AREA          ScalingAlgorithm = ScalingAlgorithm(C.SWS_AREA)
+	SWS_BICUBLIN      ScalingAlgorithm = ScalingAlgorithm(C.SWS_BICUBLIN)
+	SWS_GAUSS         ScalingAlgorithm = ScalingAlgorithm(C.SWS_GAUSS)
+	SWS_SINC          ScalingAlgorithm = ScalingAlgorithm(C.SWS_SINC)
+	SWS_LANCZOS       ScalingAlgorithm = ScalingAlgorithm(C.SWS_LANCZOS)
+	SWS_SPLINE        ScalingAlgorithm = ScalingAlgorithm(C.SWS_SPLINE)
+)
+
+func SwsGetContext(srcW, srcH int, srcFormat PixelFormat, dstW, dstH int, dstFormat PixelFormat, flags ScalingAlgorithm, dstFrame *Frame) *SWSContext {
+	dstFrame.SetPixelFormat(dstFormat)
+	dstFrame.SetWidth(dstW)
+	dstFrame.SetHeight(dstH)
+	dstFrame.AllocBuffer(1)
+
+	swsCtx := C.sws_getContext(
+		C.int(srcW),
+		C.int(srcH),
+		C.enum_AVPixelFormat(srcFormat),
+		C.int(dstW),
+		C.int(dstH),
+		C.enum_AVPixelFormat(dstFormat),
+		C.int(flags),
+		nil, nil, nil,
+	)
+	if swsCtx == nil {
+		return nil
+	}
+	return &SWSContext{c: swsCtx, dstFormat: dstFormat, srcFormat: srcFormat, srcW: srcW, srcH: srcH, dstW: dstW, dstH: dstH, flags: flags, dstFrame: dstFrame}
+}
+
+func (sc *SWSContext) Scale(srcFrame, dstFrame *Frame) error {
+	height := int(
+		C.sws_scale(
+			sc.c,
+			&srcFrame.c.data[0],
+			&srcFrame.c.linesize[0],
+			0,
+			C.int(srcFrame.Height()),
+			&dstFrame.c.data[0], &dstFrame.c.linesize[0]))
+
+	if height != dstFrame.Height() {
+		return fmt.Errorf("sws_scale did not process all lines, expected: %d, got: %d", dstFrame.Height(), height)
+	}
+	return nil
+}
+
+func (sc *SWSContext) UpdateScalingParameters(dstW, dstH int, dstFormat PixelFormat) error {
+	if sc.dstW != dstW || sc.dstH != dstH || sc.dstFormat != dstFormat {
+		sc.dstW = dstW
+		sc.dstH = dstH
+		sc.dstFormat = dstFormat
+
+		// Reallocate the destination frame buffer
+		sc.dstFrame.SetPixelFormat(dstFormat)
+		sc.dstFrame.SetWidth(dstW)
+		sc.dstFrame.SetHeight(dstH)
+		sc.dstFrame.AllocBuffer(1)
+
+		// Update the sws context
+		sc.c = C.sws_getCachedContext(
+			sc.c,
+			C.int(sc.srcW),
+			C.int(sc.srcH),
+			C.enum_AVPixelFormat(sc.srcFormat),
+			C.int(dstW),
+			C.int(dstH),
+			C.enum_AVPixelFormat(dstFormat),
+			C.int(sc.flags),
+			nil, nil, nil,
+		)
+		if sc.c == nil {
+			return fmt.Errorf("failed to update sws context")
+		}
+	}
+	return nil
+}
+
+func (sc *SWSContext) Free() {
+	C.sws_freeContext(sc.c)
+}

sws_context_test.go

@@ -0,0 +1,66 @@
+package astiav_test
+
+import (
+	"image"
+	"reflect"
+	"testing"
+
+	"github.com/asticode/go-astiav"
+	"github.com/stretchr/testify/require"
+)
+
+// Test constants for source and destination dimensions and formats
+const (
+	srcW = 100
+	srcH = 100
+	dstW = 200
+	dstH = 200
+)
+
+// assertImageType is a helper function to check the type of an image.
+func assertImageType(t *testing.T, img image.Image, expectedType reflect.Type) {
+	actualType := reflect.TypeOf(img)
+	require.Equal(t, expectedType, actualType, "Image type does not match")
+}
+
+// TestSWS tests the scaling functionality provided by the SWSContext.
+func TestSWS(t *testing.T) {
+	// Allocate and initialize source and destination frames
+	srcFrame := astiav.AllocFrame()
+	defer srcFrame.Free()
+	dstFrame := astiav.AllocFrame()
+	defer dstFrame.Free()
+
+	srcFrame.SetHeight(srcH)
+	srcFrame.SetWidth(srcW)
+	srcFrame.SetPixelFormat(astiav.PixelFormatYuv420P)
+	srcFrame.AllocBuffer(1)
+
+	swsc := astiav.SwsGetContext(srcW, srcH, astiav.PixelFormatYuv420P, dstW, dstH, astiav.PixelFormatRgba, astiav.SWS_BILINEAR, dstFrame)
+	require.NotNil(t, swsc)
+
+	err := swsc.Scale(srcFrame, dstFrame)
+	require.NoError(t, err)
+
+	require.Equal(t, dstW, dstFrame.Height())
+	require.Equal(t, dstH, dstFrame.Width())
+	require.Equal(t, astiav.PixelFormatRgba, dstFrame.PixelFormat())
+
+	// Convert frame data to image and perform additional verifications
+	i1, err := dstFrame.Data().Image()
+	require.NoError(t, err)
+	require.Equal(t, dstW, i1.Bounds().Dx())
+	require.Equal(t, dstH, i1.Bounds().Dy())
+	assertImageType(t, i1, reflect.TypeOf((*image.NRGBA)(nil)))
+
+	// Update sws ctx tests
+	err = swsc.UpdateScalingParameters(50, 50, astiav.PixelFormatRgb24)
+	require.NoError(t, err)
+	require.Equal(t, astiav.PixelFormatRgb24, dstFrame.PixelFormat())
+	err = swsc.Scale(srcFrame, dstFrame)
+	require.NoError(t, err)
+	require.Equal(t, dstFrame.Width(), 50)
+	require.Equal(t, dstFrame.Height(), 50)
+
+	swsc.Free()
+}