[ffmpeg][goav]ffmpeg代码例子pcmu重采样并转码aac格式

8k双声道的pcmu格式重采样44.1kHz并转码aac格式例子
src : 其中adts包是给aac填充头部的，这里就没给了。

package main

import(
	"github.com/ailumiyana/goav-incr/goav/avcodec"
	"github.com/ailumiyana/goav-incr/goav/avutil"
	"github.com/ailumiyana/goav-incr/goav/avfilter"

	"unsafe"
	"os"
	"io/ioutil"
	"log"
	"strconv"

	"adts"
)

func main() {
	avutil.AvLogSetLevel(avutil.AV_LOG_TRACE)

	//decoder
	pkt 		   := avcodec.AvPacketAlloc()
	if pkt == nil {
		log.Panic("AvPacketAlloc failed.")
	}

	codec 		   := avcodec.AvcodecFindDecoder(avcodec.CodecId(avcodec.AV_CODEC_ID_PCM_MULAW))
	if codec == nil {
		log.Panic("AvcodecFindDecoder failed.")
	}

	context 	   := codec.AvcodecAllocContext3()
	if context == nil {
		log.Panic("AvcodecAllocContext3 failed.")
	}

	frame   	   := avutil.AvFrameAlloc()
	if frame == nil {
		log.Panic("AvFrameAlloc failed.")
	}

	//设置通道数
	context.SetAudioDecodeParamsTest(2)
	context.AvcodecOpen2(codec, nil)


	//encoder
	codec_enc 		   := avcodec.AvcodecFindEncoder(avcodec.CodecId(avcodec.AV_CODEC_ID_AAC))
	if codec_enc == nil {
		log.Panic("AvcodecFindEncoder failed.")
	}

	pkt_enc  		   := avcodec.AvPacketAlloc()
	if pkt_enc == nil {
		log.Panic("AvPacketAlloc failed.")
	}

	context_enc 	   := codec_enc.AvcodecAllocContext3()
	if context_enc == nil {
		log.Panic("AvcodecAllocContext3 failed.")
	}

	context_enc.SetAudioEncodeParams(128000, 44100, "stereo", avcodec.AV_SAMPLE_FMT_FLTP)

	err := context_enc.AvcodecOpen2(codec_enc, nil)
	if err < 0 {
		log.Panic("AvcodecOpen2 failed.")
	}

	//filter

	graph := avfilter.AvfilterGraphAlloc()
	if graph == nil {
		log.Fatal("AvfilterGraphAlloc Failed.")
	}
	
	inputs  := avfilter.AvfilterInoutAlloc()
	outputs := avfilter.AvfilterInoutAlloc()
	if inputs == nil || outputs == nil {
		log.Fatal("AvfilterInoutAlloc Failed.")
	}

	defer avfilter.AvfilterInoutFree(inputs)
	defer avfilter.AvfilterInoutFree(outputs)

	var buffersrc *avfilter.Filter
	var buffersink *avfilter.Filter
	buffersrc  = avfilter.AvfilterGetByName("abuffer")
	buffersink = avfilter.AvfilterGetByName("abuffersink")

	if buffersink == nil || buffersrc == nil {
		log.Panic("AvfilterGetByName Failed.")
	}

	ret := graph.AvfilterGraphParse2("aresample=44100,aformat=sample_fmts=fltp:channel_layouts=stereo,asetnsamples=1024", &inputs, &outputs)
	if ret < 0 {
		log.Panic("AvfilterInoutAlloc Failed des : ", avutil.ErrorFromCode(ret))
	}

	var ins    []*avfilter.Context
	var outs   []*avfilter.Context
	var frames []*avutil.Frame
	
	// inputs
	index := 0
	for cur := inputs; cur != nil; cur = cur.Next() {
		var in *avfilter.Context
		inName := "in" + strconv.Itoa(index)
		ret = avfilter.AvfilterGraphCreateFilter(&in, buffersrc, inName, "sample_rate=8000:time_base=1/8000:sample_fmt=s16:channel_layout=stereo", 0, graph)
		if ret < 0 {
			log.Panic("AvfilterGraphCreateFilter Failed des : ", avutil.ErrorFromCode(ret))
		}

		ins = append(ins, in)
		ret = avfilter.AvfilterLink(ins[index], 0, cur.FilterContext(), cur.PadIdx())
		if ret < 0 {
			log.Panic("AvfilterLink Failed des : ", avutil.ErrorFromCode(ret))
		}
		index++
	}

	// outputs
	index = 0
	for cur := outputs; cur != nil; cur = cur.Next() {
		var out *avfilter.Context
		outName := "out" + strconv.Itoa(index)
		ret = avfilter.AvfilterGraphCreateFilter(&out, buffersink, outName, "", 0, graph)
		if ret < 0 {
			log.Panic("AvfilterGraphCreateFilter Failed des : ", avutil.ErrorFromCode(ret))
		}

		outs = append(outs, out)
		ret = avfilter.AvfilterLink(cur.FilterContext(), cur.PadIdx(), outs[index], 0)
		if ret < 0 {
			log.Panic("AvfilterLink Failed des : ", avutil.ErrorFromCode(ret))
		}
		index++

		f := avutil.AvFrameAlloc()
		if f == nil {
			log.Panic("AvFrameAlloc failed.")
		}
		frames = append(frames, f)
	}

	ret = graph.AvfilterGraphConfig(0)
	if ret < 0 {
		log.Panic("AvfilterGraphConfig Failed des : ", avutil.ErrorFromCode(ret))
	}

	//input pcm file
	data, errr := ioutil.ReadFile("ilem8kmulaw.pcm")
	if errr != nil {
		log.Panic("File reading error", err)
	}
	l := len(data)
	//parser := make([]byte, 160)

	offset := -160

	//out aac file 
	file, errr := os.Create("./out.aac")
	if errr != nil {
		log.Panic("Error Reading")
	}
	defer file.Close()

	//handle
	apts := int64(0)

	for offset + 160 < l {
		offset+=160
		pkt.AvPacketFromData(data[offset:offset+160], 160)

		ret := context.AvcodecSendPacket(pkt)
		if ret < 0 {
			log.Println("AvcodecSendPacket err ", avutil.ErrorFromCode(ret))
		}
	
		ret = context.AvcodecReceiveFrame((*avcodec.Frame)(unsafe.Pointer(frame)))
		if ret < 0 {
			log.Println("AvcodecReceiveFrame err ", avutil.ErrorFromCode(ret))
		}
		
		if ret == 0 {				
			apts += 160
			frame.SetPts(apts)
			frame.SetSampleRate(8000)
			ret := avfilter.AvBuffersrcAddFrame(ins[0], (*avfilter.Frame)(unsafe.Pointer(frame)))
			if ret < 0 {
				log.Println("AvBuffersrcAddFrame error :", avutil.ErrorFromCode(ret))
			}
			
			log.Println("---------")
			ret = avfilter.AvBufferSinkGetFrame(outs[0], (*avfilter.Frame)(unsafe.Pointer(frames[0])))
			if ret == -11 {
				log.Println("AvBufferSinkGetFrame Failed des : ", ret, avutil.ErrorFromCode(ret))
				avutil.AvFrameUnref(frame)
				continue
			}
			
			if frames[0] != nil {

				ret = context_enc.AvcodecSendFrame((*avcodec.Frame)(unsafe.Pointer(frames[0])))
				if ret < 0 {
					log.Panic("AvcodecSendFrame err ", avutil.ErrorFromCode(ret))
				}
			
				ret := context_enc.AvcodecReceivePacket(pkt_enc)
				if ret < 0 {
					if ret == -11 {
						log.Println("AvcodecReceivePacket Failed des : ", ret, avutil.ErrorFromCode(ret))
						avutil.AvFrameUnref(frame)
						continue
					}
					log.Panic("AvcodecReceivePacket err ", avutil.ErrorFromCode(ret))
				}

				log.Println("=================================")

				if ret == 0 {
					data0 := pkt_enc.Data()
					buf := make([]byte, pkt_enc.GetPacketSize())
					start := uintptr(unsafe.Pointer(data0))
					for i := 0; i < pkt_enc.GetPacketSize(); i++ {
						elem := *(*uint8)(unsafe.Pointer(start + uintptr(i)))
						buf[i] = elem
					}
		
					header := adts.Default()
					header.SetFrameSize(uint16(len(buf)))
					b := append(header.Bytes()[0:], buf[0:]...)
		
					file.Write(b)
				}
		
				avutil.AvFrameUnref(frames[0])
			}
		}
		avutil.AvFrameUnref(frame)
	}

}

detected 8 logical cores
[Parsed_aresample_0 @ 000000000089fe00] Setting 'sample_rate' to value '44100'
[Parsed_aformat_1 @ 00000000001fd5c0] Setting 'sample_fmts' to value 'fltp'
[Parsed_aformat_1 @ 00000000001fd5c0] Setting 'channel_layouts' to value 'stereo'
[Parsed_asetnsamples_2 @ 00000000001fe6c0] Setting 'nb_out_samples' to value '1024'
[in0 @ 00000000001feac0] Setting 'sample_rate' to value '8000'
[in0 @ 00000000001feac0] Setting 'time_base' to value '1/8000'
[in0 @ 00000000001feac0] Setting 'sample_fmt' to value 's16'
[in0 @ 00000000001feac0] Setting 'channel_layout' to value 'stereo'
[in0 @ 00000000001feac0] tb:1/8000 samplefmt:s16 samplerate:8000 chlayout:stereo
[AVFilterGraph @ 0000000003ad6b80] query_formats: 5 queried, 12 merged, 0 already done, 0 delayed
[Parsed_aresample_0 @ 000000000089fe00] [SWR @ 000000000089ffc0] Using fltp internally between filters
[Parsed_aresample_0 @ 000000000089fe00] ch:2 chl:stereo fmt:s16 r:8000Hz -> ch:2 chl:stereo fmt:fltp r:44100Hz