添加mp3音频时长获取

util/common/mp3duration.go

@@ -0,0 +1,220 @@
+package common
+
+import (
+	"bytes"
+	"encoding/binary"
+	"io"
+	"math"
+	"mime/multipart"
+)
+
+import (
+	"errors"
+)
+
+var (
+	versions = []string{"2.5", "x", "2", "1"}
+	layers   = []string{"x", "3", "2", "1"}
+	bitRates = map[string][]int{
+		"V1Lx": []int{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+		"V1L1": []int{0, 32, 64, 96, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448},
+		"V1L2": []int{0, 32, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384},
+		"V1L3": []int{0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320},
+		"V2Lx": []int{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+		"V2L1": []int{0, 32, 48, 56, 64, 80, 96, 112, 128, 144, 160, 176, 192, 224, 256},
+		"V2L2": []int{0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160},
+		"V2L3": []int{0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160},
+		"VxLx": []int{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+		"VxL1": []int{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+		"VxL2": []int{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+		"VxL3": []int{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+	}
+	sampleRates = map[string][]int{
+		"x":   []int{0, 0, 0},
+		"1":   []int{44100, 48000, 32000},
+		"2":   []int{22050, 24000, 16000},
+		"2.5": []int{11025, 12000, 8000},
+	}
+	samples = map[string]map[string]int{
+		"x": {
+			"x": 0,
+			"1": 0,
+			"2": 0,
+			"3": 0,
+		},
+		"1": { //MPEGv1,     Layers 1,2,3
+			"x": 0,
+			"1": 384,
+			"2": 1152,
+			"3": 1152,
+		},
+		"2": { //MPEGv2/2.5, Layers 1,2,3
+			"x": 0,
+			"1": 384,
+			"2": 1152,
+			"3": 576,
+		},
+	}
+)
+
+type frame struct {
+	bitRate    int
+	sampleRate int
+	frameSize  int
+	sample     int
+}
+
+func skipID3(buffer []byte) int {
+	var id3v2Flags, z0, z1, z2, z3 byte
+	var tagSize, footerSize int
+
+	//http://id3.org/d3v2.3.0
+	if buffer[0] == 0x49 && buffer[1] == 0x44 && buffer[2] == 0x33 { //'ID3'
+		id3v2Flags = buffer[5]
+		if (id3v2Flags & 0x10) != 0 {
+			footerSize = 10
+		} else {
+			footerSize = 0
+		}
+
+		//ID3 size encoding is crazy (7 bits in each of 4 bytes)
+		z0 = buffer[6]
+		z1 = buffer[7]
+		z2 = buffer[8]
+		z3 = buffer[9]
+		if ((z0 & 0x80) == 0) && ((z1 & 0x80) == 0) && ((z2 & 0x80) == 0) && ((z3 & 0x80) == 0) {
+			tagSize = (((int)(z0 & 0x7f)) * 2097152) +
+				(((int)(z1 & 0x7f)) * 16384) +
+				(((int)(z2 & 0x7f)) * 128) +
+				((int)(z3 & 0x7f))
+			return 10 + tagSize + footerSize
+		}
+	}
+	return 0
+}
+
+func frameSize(samples int, layer string, bitRate, sampleRate, paddingBit int) int {
+	if sampleRate == 0 {
+		return 0
+	} else if layer == "1" {
+		return ((samples * bitRate * 125 / sampleRate) + paddingBit*4)
+	} else { //layer 2, 3
+		return (((samples * bitRate * 125) / sampleRate) + paddingBit)
+	}
+}
+
+func parseFrameHeader(header []byte) *frame {
+	b1 := header[1]
+	b2 := header[2]
+
+	versionBits := (b1 & 0x18) >> 3
+	version := versions[versionBits]
+
+	var simpleVersion string
+	if version == "2.5" {
+		simpleVersion = "2"
+	} else {
+		simpleVersion = version
+	}
+
+	layerBits := (b1 & 0x06) >> 1
+	layer := layers[layerBits]
+
+	bitRateKey := "V" + simpleVersion + "L" + layer
+	bitRateIndex := (b2 & 0xf0) >> 4
+
+	var bitRate int
+	frameBitRates, exists := bitRates[bitRateKey]
+	if exists && int(bitRateIndex) < len(frameBitRates) {
+		bitRate = frameBitRates[bitRateIndex]
+	} else {
+		bitRate = 0
+	}
+
+	sampleRateIdx := (b2 & 0x0c) >> 2
+	var sampleRate int
+	frameSampleRates, exists := sampleRates[version]
+	if exists && int(sampleRateIdx) < len(frameSampleRates) {
+		sampleRate = frameSampleRates[sampleRateIdx]
+	} else {
+		sampleRate = 0
+	}
+	sample := samples[simpleVersion][layer]
+
+	paddingBit := (b2 & 0x02) >> 1
+	return &frame{
+		bitRate:    bitRate,
+		sampleRate: sampleRate,
+		frameSize:  frameSize(sample, layer, bitRate, sampleRate, int(paddingBit)),
+		sample:     sample,
+	}
+}
+
+func round(duration float64) float64 {
+	return math.Round(duration*1000) / 1000 //round to nearest ms
+}
+
+// BoxHeader 信息头
+type BoxHeader2 struct {
+	Size       uint32
+	FourccType [4]byte
+	Size64     uint64
+}
+
+func getHeaderBoxInfo2(data []byte) (boxHeader BoxHeader2) {
+	buf := bytes.NewBuffer(data)
+	binary.Read(buf, binary.BigEndian, &boxHeader)
+	return
+}
+
+// Calculate returns the duration of an mp3 file
+func GetMP3PlayDuration(file multipart.File) (duration float64, err error) {
+	var size int64
+	var info = make([]byte, 0x10)
+	var boxHeader BoxHeader2
+	file.ReadAt(info, 0)
+	boxHeader = getHeaderBoxInfo2(info)
+	size = int64(boxHeader.Size64)
+	buffer := make([]byte, 100)
+	if err != nil {
+		return
+	}
+	var bytesRead int
+	bytesRead, err = file.Read(buffer)
+	if err != nil {
+		return
+	}
+	if bytesRead < 100 {
+		err = errors.New("Corrupt file")
+		return
+	}
+	offset := int64(skipID3(buffer))
+	buffer = make([]byte, 10)
+	for offset < size {
+		bytesRead, e := file.ReadAt(buffer, offset)
+		if e != nil && e != io.EOF {
+			err = e
+			return
+		}
+		if bytesRead < 10 {
+			duration = round(duration)
+			return
+		}
+
+		if buffer[0] == 0xff && (buffer[1]&0xe0) == 0xe0 {
+			info := parseFrameHeader(buffer)
+			if info.frameSize > 0 && info.sample > 0 {
+				offset += int64(info.frameSize)
+				duration += (float64(info.sample) / float64(info.sampleRate))
+			} else {
+				offset++ //Corrupt file?
+			}
+		} else if buffer[0] == 0x54 && buffer[1] == 0x41 && buffer[2] == 0x47 { //'TAG'
+			offset += 128 //Skip over id3v1 tag size
+		} else {
+			offset++ //Corrupt file?
+		}
+	}
+	duration = round(duration)
+	return
+}

util/common/mp3mp4_duration.go

@@ -14,7 +14,8 @@ func GetMediaDuration(reader multipart.File, contentType string) (int, error) {
 		duration, err = GetMP4Duration(reader)
 	}
 	if contentType == "audio/mpeg" {
-		duration, err = GetMP3PlayDuration(reader)
+		playDuration, _ := GetMP3PlayDuration(reader)
+		duration = int(playDuration)
 	}
 	if err != nil {
 		return 0, err
@@ -35,6 +36,7 @@ func GetMP4Duration(reader multipart.File) (lengthOfTime int, err error) {
 		}
 		boxHeader = getHeaderBoxInfo(info)
 		fourccType := getFourccType(boxHeader)
+
 		if fourccType == "moov" {
 			break
 		}
@@ -62,23 +64,6 @@ func GetMP4Duration(reader multipart.File) (lengthOfTime int, err error) {
 	return
 }
 
-// GetMP3PlayDuration 获取mp3时长，以秒计
-func GetMP3PlayDuration(reader multipart.File) (seconds int, err error) {
-	return 0, nil
-	//buf := bytes.NewBuffer(nil)
-	//if _, err := io.Copy(buf, reader); err != nil {
-	//	return 0, err
-	//}
-	//mp3Data := buf.Bytes()
-	//dec, _, err := minimp3.DecodeFull(mp3Data)
-	//if err != nil {
-	//	return 0, err
-	//}
-	//// 音乐时长 = (文件大小(byte) - 128(ID3信息)) * 8(to bit) / (码率(kbps b:bit) * 1000)(kilo bit to bit)
-	//seconds = (len(mp3Data) - 128) * 8 / (dec.Kbps * 1000)
-	//return seconds, nil
-}
-
 // BoxHeader 信息头
 type BoxHeader struct {
 	Size       uint32