acommpelish jimeng AI refactor for PC

api/utils/media_duration.go

@@ -0,0 +1,817 @@
+package utils
+
+import (
+	"context"
+	"encoding/binary"
+	"errors"
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"time"
+)
+
+// AudioDuration returns duration of an audio file.
+// Supported formats: MP3, WAV (auto-detected by header)
+func AudioDuration(path string) (time.Duration, error) {
+	f, err := os.Open(path)
+	if err != nil {
+		return 0, err
+	}
+	defer f.Close()
+
+	// Peek first 12 bytes to detect format
+	head := make([]byte, 12)
+	n, err := io.ReadFull(f, head)
+	if err != nil {
+		return 0, err
+	}
+	if n < 12 {
+		return 0, errors.New("file too small")
+	}
+
+	// WAV: RIFF....WAVE
+	if string(head[0:4]) == "RIFF" && string(head[8:12]) == "WAVE" {
+		if _, err := f.Seek(0, io.SeekStart); err != nil {
+			return 0, err
+		}
+		return wavDuration(f)
+	}
+
+	// MP3 can start with ID3 or frame sync 0xFFEx
+	if string(head[0:3]) == "ID3" || (head[0] == 0xFF && (head[1]&0xE0) == 0xE0) {
+		if _, err := f.Seek(0, io.SeekStart); err != nil {
+			return 0, err
+		}
+		return mp3Duration(f)
+	}
+
+	return 0, errors.New("unsupported audio format")
+}
+
+// AudioDurationFromURL downloads the url to a temp file and returns duration.
+func AudioDurationFromURL(url string) (time.Duration, error) {
+	path, err := fetchURLToTemp(url, 30*time.Second)
+	if err != nil {
+		return 0, err
+	}
+	defer os.Remove(path)
+	return AudioDuration(path)
+}
+
+// VideoDurationMP4 returns duration of an MP4 file (MOV/MP4 base media).
+func VideoDurationMP4(path string) (time.Duration, error) {
+	f, err := os.Open(path)
+	if err != nil {
+		return 0, err
+	}
+	defer f.Close()
+
+	return mp4Duration(f)
+}
+
+// VideoDurationMP4FromURL downloads the url to a temp file and returns duration.
+func VideoDurationMP4FromURL(url string) (time.Duration, error) {
+	path, err := fetchURLToTemp(url, 30*time.Second)
+	if err != nil {
+		return 0, err
+	}
+	defer os.Remove(path)
+	return VideoDurationMP4(path)
+}
+
+// ---------------------- helpers ----------------------
+
+func fetchURLToTemp(url string, timeout time.Duration) (string, error) {
+	ctx, cancel := context.WithTimeout(context.Background(), timeout)
+	defer cancel()
+
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
+	if err != nil {
+		return "", err
+	}
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return "", err
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode != http.StatusOK {
+		return "", fmt.Errorf("http status: %d", resp.StatusCode)
+	}
+
+	tmp, err := os.CreateTemp("", "media-*")
+	if err != nil {
+		return "", err
+	}
+	defer tmp.Close()
+
+	if _, err := io.Copy(tmp, resp.Body); err != nil {
+		path := tmp.Name()
+		_ = os.Remove(path)
+		return "", err
+	}
+	return tmp.Name(), nil
+}
+
+// ---------------------- WAV ----------------------
+
+func wavDuration(r io.ReadSeeker) (time.Duration, error) {
+	// RIFF header already checked outside if needed. We parse chunks to get fmt and data.
+	// WAV little-endian
+	if _, err := r.Seek(0, io.SeekStart); err != nil {
+		return 0, err
+	}
+
+	// Read RIFF header (12 bytes)
+	head := make([]byte, 12)
+	if _, err := io.ReadFull(r, head); err != nil {
+		return 0, err
+	}
+	if string(head[0:4]) != "RIFF" || string(head[8:12]) != "WAVE" {
+		return 0, errors.New("invalid wav header")
+	}
+
+	var sampleRate uint32
+	var numChans uint16
+	var bitsPerSample uint16
+	var byteRate uint32
+	var dataSize uint32
+
+	for {
+		chunkHdr := make([]byte, 8)
+		if _, err := io.ReadFull(r, chunkHdr); err != nil {
+			if errors.Is(err, io.EOF) || errors.Is(err, io.ErrUnexpectedEOF) {
+				break
+			}
+			return 0, err
+		}
+		ckID := string(chunkHdr[0:4])
+		ckSize := binary.LittleEndian.Uint32(chunkHdr[4:8])
+
+		switch ckID {
+		case "fmt ":
+			fmtData := make([]byte, ckSize)
+			if _, err := io.ReadFull(r, fmtData); err != nil {
+				return 0, err
+			}
+			// audioFormat := binary.LittleEndian.Uint16(fmtData[0:2]) // 1 = PCM
+			numChans = binary.LittleEndian.Uint16(fmtData[2:4])
+			sampleRate = binary.LittleEndian.Uint32(fmtData[4:8])
+			byteRate = binary.LittleEndian.Uint32(fmtData[8:12])
+			// blockAlign := binary.LittleEndian.Uint16(fmtData[12:14])
+			if len(fmtData) >= 16 {
+				bitsPerSample = binary.LittleEndian.Uint16(fmtData[14:16])
+			}
+		case "data":
+			dataSize = ckSize
+			// Skip data content
+			if _, err := r.Seek(int64(ckSize), io.SeekCurrent); err != nil {
+				return 0, err
+			}
+		default:
+			// Skip other chunks
+			if _, err := r.Seek(int64(ckSize), io.SeekCurrent); err != nil {
+				return 0, err
+			}
+		}
+		// Chunks are word-aligned (pad byte if odd size)
+		if ckSize%2 == 1 {
+			if _, err := r.Seek(1, io.SeekCurrent); err != nil { // skip pad
+				return 0, err
+			}
+		}
+	}
+
+	if sampleRate == 0 || numChans == 0 {
+		return 0, errors.New("invalid wav fmt")
+	}
+
+	var durationSeconds float64
+	if byteRate != 0 {
+		durationSeconds = float64(dataSize) / float64(byteRate)
+	} else {
+		bytesPerSec := float64(sampleRate) * float64(numChans) * float64(bitsPerSample) / 8.0
+		if bytesPerSec == 0 {
+			return 0, errors.New("invalid wav parameters")
+		}
+		durationSeconds = float64(dataSize) / bytesPerSec
+	}
+	return time.Duration(durationSeconds * float64(time.Second)), nil
+}
+
+// ---------------------- MP3 ----------------------
+
+func mp3Duration(r io.ReadSeeker) (time.Duration, error) {
+	// Strategy:
+	// 1) Skip ID3v2 header if present.
+	// 2) Try read first frame and detect XING/Info or VBRI to get total frames and duration.
+	// 3) If VBR headers not present, fall back to CBR estimation: (audioDataBytes * 8) / bitrate.
+
+	// File size
+	fi, err := fileSizeFromSeeker(r)
+	if err != nil {
+		return 0, err
+	}
+
+	// Skip ID3v2
+	var id3v2Size int64
+	if _, err := r.Seek(0, io.SeekStart); err != nil {
+		return 0, err
+	}
+	id3v2Size, err = skipID3v2(r)
+	if err != nil {
+		return 0, err
+	}
+
+	// Remember audio start offset
+	startOffset, _ := r.Seek(0, io.SeekCurrent)
+
+	// Read first frame header (search sync)
+	off, fh, err := findNextMP3Frame(r)
+	if err != nil {
+		return 0, err
+	}
+	if _, err := r.Seek(off, io.SeekStart); err != nil {
+		return 0, err
+	}
+
+	// Check for XING/Info header in first frame (for VBR)
+	totalFrames, sampleRate, samplesPerFrame, bitrateKbps, vbrFound, err := parseFirstFrameForVBR(r, fh)
+	if err != nil {
+		return 0, err
+	}
+
+	if vbrFound && totalFrames > 0 && sampleRate > 0 && samplesPerFrame > 0 {
+		seconds := (float64(totalFrames) * float64(samplesPerFrame)) / float64(sampleRate)
+		return time.Duration(seconds * float64(time.Second)), nil
+	}
+
+	// Fall back to CBR estimate using bitrate and data size (excluding ID3v2 and ID3v1)
+	// Detect ID3v1 at end (128 bytes TAG)
+	var id3v1Size int64
+	if fi >= 128 {
+		if _, err := r.Seek(fi-128, io.SeekStart); err == nil {
+			buf := make([]byte, 3)
+			if _, err := io.ReadFull(r, buf); err == nil {
+				if string(buf) == "TAG" {
+					id3v1Size = 128
+				}
+			}
+		}
+	}
+
+	audioBytes := fi - id3v2Size - id3v1Size - startOffset
+	if audioBytes <= 0 || bitrateKbps == 0 {
+		return 0, errors.New("unable to estimate mp3 duration")
+	}
+	// bitrateKbps in kbps, bytes -> bits
+	seconds := float64(audioBytes*8) / float64(bitrateKbps*1000)
+	return time.Duration(seconds * float64(time.Second)), nil
+}
+
+type mp3FrameHeader struct {
+	Version     int // 1: MPEG1, 2: MPEG2, 25: MPEG2.5
+	Layer       int // 1,2,3
+	BitrateKbps int
+	SampleRate  int
+	Padding     int
+	ChannelMode int // 0:Stereo,1:Joint,2:Dual,3:Mono
+}
+
+func findNextMP3Frame(r io.ReadSeeker) (int64, mp3FrameHeader, error) {
+	var hdr mp3FrameHeader
+	// Start from current pos and scan up to 64KB
+	start, _ := r.Seek(0, io.SeekCurrent)
+	limit := int64(64 * 1024)
+	buf := make([]byte, limit)
+	n, err := r.Read(buf)
+	if err != nil && !errors.Is(err, io.EOF) {
+		return 0, hdr, err
+	}
+	for i := 0; i+4 <= n; i++ {
+		if buf[i] == 0xFF && (buf[i+1]&0xE0) == 0xE0 { // sync
+			if h, ok := parseMP3Header(buf[i : i+4]); ok {
+				offset := start + int64(i)
+				return offset, h, nil
+			}
+		}
+	}
+	return 0, hdr, errors.New("mp3 frame not found")
+}
+
+func parseMP3Header(b []byte) (mp3FrameHeader, bool) {
+	var h mp3FrameHeader
+	if len(b) < 4 {
+		return h, false
+	}
+	if b[0] != 0xFF || (b[1]&0xE0) != 0xE0 {
+		return h, false
+	}
+	versionBits := (b[1] >> 3) & 0x03
+	layerBits := (b[1] >> 1) & 0x03
+	bitrateBits := (b[2] >> 4) & 0x0F
+	sampleRateBits := (b[2] >> 2) & 0x03
+	paddingBit := (b[2] >> 1) & 0x01
+	channelMode := (b[3] >> 6) & 0x03
+
+	var version int
+	switch versionBits {
+	case 0x00:
+		version = 25 // MPEG 2.5
+	case 0x02:
+		version = 2 // MPEG 2
+	case 0x03:
+		version = 1 // MPEG 1
+	default:
+		return h, false
+	}
+
+	var layer int
+	switch layerBits {
+	case 0x01:
+		layer = 3
+	case 0x02:
+		layer = 2
+	case 0x03:
+		layer = 1
+	default:
+		return h, false
+	}
+
+	br := mp3BitrateKbps(version, layer, int(bitrateBits))
+	if br == 0 {
+		return h, false
+	}
+	sr := mp3SampleRate(version, int(sampleRateBits))
+	if sr == 0 {
+		return h, false
+	}
+
+	h = mp3FrameHeader{
+		Version:     version,
+		Layer:       layer,
+		BitrateKbps: br,
+		SampleRate:  sr,
+		Padding:     int(paddingBit),
+		ChannelMode: int(channelMode),
+	}
+	return h, true
+}
+
+func mp3BitrateKbps(version, layer, index int) int {
+	// index: 1..14 valid; 0,15 invalid
+	if index <= 0 || index == 15 {
+		return 0
+	}
+	// Tables per ISO/IEC 11172-3/13818-3 (common subset)
+	var tbl [15]int
+	if layer == 1 { // Layer I
+		if version == 1 { // MPEG1
+			tbl = [15]int{0, 32, 64, 96, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448}
+		} else { // MPEG2/2.5
+			tbl = [15]int{0, 32, 48, 56, 64, 80, 96, 112, 128, 144, 160, 176, 192, 224, 256}
+		}
+	} else if layer == 2 { // Layer II
+		if version == 1 {
+			tbl = [15]int{0, 32, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384}
+		} else {
+			tbl = [15]int{0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160}
+		}
+	} else { // Layer III
+		if version == 1 {
+			tbl = [15]int{0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320}
+		} else {
+			tbl = [15]int{0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160}
+		}
+	}
+	return tbl[index]
+}
+
+func mp3SampleRate(version, index int) int {
+	if index == 3 {
+		return 0
+	}
+	// base table for MPEG1
+	base := [3]int{44100, 48000, 32000}
+	sr := base[index]
+	if version == 2 { // MPEG2
+		sr /= 2
+	} else if version == 25 { // MPEG2.5
+		sr /= 4
+	}
+	return sr
+}
+
+func samplesPerMP3Frame(version, layer int) int {
+	switch layer {
+	case 1:
+		return 384
+	case 2:
+		return 1152
+	case 3:
+		if version == 1 {
+			return 1152
+		}
+		return 576 // MPEG2/2.5 Layer III
+	default:
+		return 0
+	}
+}
+
+func parseFirstFrameForVBR(r io.ReadSeeker, fh mp3FrameHeader) (totalFrames uint32, sampleRate int, samplesPerFrame int, bitrateKbps int, vbrFound bool, err error) {
+	// After the 4-byte header, possible side info and then XING/Info
+	if _, err = r.Seek(0, io.SeekCurrent); err != nil {
+		return
+	}
+	// Re-read header
+	hdr := make([]byte, 4)
+	if _, err = io.ReadFull(r, hdr); err != nil {
+		return
+	}
+
+	// side info size depends on MPEG version and channel mode (for Layer III)
+	sideInfoSize := 0
+	if fh.Layer == 3 { // Layer III
+		if fh.Version == 1 { // MPEG1
+			if fh.ChannelMode == 3 { // mono
+				sideInfoSize = 17
+			} else {
+				sideInfoSize = 32
+			}
+		} else { // MPEG2/2.5
+			if fh.ChannelMode == 3 {
+				sideInfoSize = 9
+			} else {
+				sideInfoSize = 17
+			}
+		}
+	}
+
+	// Read next up to 120 bytes to search for XING/Info or VBRI
+	buf := make([]byte, sideInfoSize+120)
+	if _, err = io.ReadFull(r, buf); err != nil {
+		// If short, still try within available
+		if !errors.Is(err, io.ErrUnexpectedEOF) && !errors.Is(err, io.EOF) {
+			return
+		}
+	}
+
+	// Search XING/Info signature
+	sigs := [][]byte{[]byte("Xing"), []byte("Info")}
+	for _, sig := range sigs {
+		idx := indexOf(buf, sig)
+		if idx >= 0 {
+			// flags after signature (4 bytes), then if frames flag set, 4 bytes frames
+			if len(buf) >= idx+4+4 {
+				flags := binary.BigEndian.Uint32(buf[idx+4 : idx+8])
+				var frames uint32
+				if (flags & 0x01) != 0 { // frames present
+					if len(buf) >= idx+8+4 {
+						frames = binary.BigEndian.Uint32(buf[idx+8 : idx+12])
+					}
+				}
+				if frames > 0 {
+					vbrFound = true
+					totalFrames = frames
+					sampleRate = fh.SampleRate
+					samplesPerFrame = samplesPerMP3Frame(fh.Version, fh.Layer)
+					bitrateKbps = fh.BitrateKbps
+					return
+				}
+			}
+		}
+	}
+
+	// Check VBRI (usually at 32 bytes after header for MPEG1 Layer III)
+	if len(buf) >= 4 {
+		idx := indexOf(buf, []byte("VBRI"))
+		if idx >= 0 {
+			if len(buf) >= idx+4+2+2+4+4 {
+				// VBRI layout: 'VBRI'(4) + version(2) + delay(2) + quality(2?) varies; but at offset 10 comes bytes: bytes (4), frames (4)
+				// Some docs: offset 10: bytes, offset 14: frames (big-endian)
+				bytesOffset := idx + 10
+				framesOffset := idx + 14
+				if len(buf) >= framesOffset+4 {
+					frames := binary.BigEndian.Uint32(buf[framesOffset : framesOffset+4])
+					if frames > 0 {
+						vbrFound = true
+						totalFrames = frames
+						sampleRate = fh.SampleRate
+						samplesPerFrame = samplesPerMP3Frame(fh.Version, fh.Layer)
+						bitrateKbps = fh.BitrateKbps
+						_ = bytesOffset // not used
+						return
+					}
+				}
+			}
+		}
+	}
+
+	// No VBR header. Provide header info for CBR fallback
+	sampleRate = fh.SampleRate
+	samplesPerFrame = samplesPerMP3Frame(fh.Version, fh.Layer)
+	bitrateKbps = fh.BitrateKbps
+	return
+}
+
+func indexOf(haystack []byte, needle []byte) int {
+	for i := 0; i+len(needle) <= len(haystack); i++ {
+		match := true
+		for j := 0; j < len(needle); j++ {
+			if haystack[i+j] != needle[j] {
+				match = false
+				break
+			}
+		}
+		if match {
+			return i
+		}
+	}
+	return -1
+}
+
+func skipID3v2(r io.ReadSeeker) (int64, error) {
+	if _, err := r.Seek(0, io.SeekStart); err != nil {
+		return 0, err
+	}
+	head := make([]byte, 10)
+	if _, err := io.ReadFull(r, head); err != nil {
+		return 0, nil // no header
+	}
+	if string(head[0:3]) != "ID3" {
+		if _, err := r.Seek(0, io.SeekStart); err != nil {
+			return 0, err
+		}
+		return 0, nil
+	}
+	// size: 4 synchsafe bytes
+	sz := int64((int(head[6]&0x7F) << 21) | (int(head[7]&0x7F) << 14) | (int(head[8]&0x7F) << 7) | int(head[9]&0x7F))
+	// total header size = 10 + sz (+ footer 10 if flag set)
+	footer := int64(0)
+	if (head[5] & 0x10) != 0 { // footer present
+		footer = 10
+	}
+	total := 10 + sz + footer
+	if _, err := r.Seek(total, io.SeekStart); err != nil {
+		return 0, err
+	}
+	return total, nil
+}
+
+func fileSizeFromSeeker(r io.ReadSeeker) (int64, error) {
+	cur, err := r.Seek(0, io.SeekCurrent)
+	if err != nil {
+		return 0, err
+	}
+	end, err := r.Seek(0, io.SeekEnd)
+	if err != nil {
+		return 0, err
+	}
+	if _, err := r.Seek(cur, io.SeekStart); err != nil {
+		return 0, err
+	}
+	return end, nil
+}
+
+// ---------------------- MP4 ----------------------
+
+type mp4BoxHeader struct {
+	Size uint64
+	Type [4]byte
+}
+
+func readBoxHeader(r io.ReadSeeker) (mp4BoxHeader, error) {
+	var h mp4BoxHeader
+	buf := make([]byte, 8)
+	if _, err := io.ReadFull(r, buf); err != nil {
+		return h, err
+	}
+	sz := binary.BigEndian.Uint32(buf[0:4])
+	copy(h.Type[:], buf[4:8])
+	if sz == 1 {
+		// 64-bit size follows
+		ext := make([]byte, 8)
+		if _, err := io.ReadFull(r, ext); err != nil {
+			return h, err
+		}
+		h.Size = binary.BigEndian.Uint64(ext)
+	} else {
+		h.Size = uint64(sz)
+	}
+	return h, nil
+}
+
+func skipBox(r io.ReadSeeker, boxSize uint64, alreadyRead int64) error {
+	toSkip := int64(boxSize) - alreadyRead
+	if toSkip < 0 {
+		return fmt.Errorf("invalid box size")
+	}
+	_, err := r.Seek(toSkip, io.SeekCurrent)
+	return err
+}
+
+func mp4Duration(r io.ReadSeeker) (time.Duration, error) {
+	if _, err := r.Seek(0, io.SeekStart); err != nil {
+		return 0, err
+	}
+	// Find moov box
+	var moovStart int64
+	var moovSize uint64
+	for {
+		pos, _ := r.Seek(0, io.SeekCurrent)
+		h, err := readBoxHeader(r)
+		if err != nil {
+			if errors.Is(err, io.EOF) || errors.Is(err, io.ErrUnexpectedEOF) {
+				break
+			}
+			return 0, err
+		}
+		if string(h.Type[:]) == "moov" {
+			moovStart = pos
+			moovSize = h.Size
+			break
+		}
+		if h.Size < 8 {
+			return 0, errors.New("invalid mp4 box size")
+		}
+		if err := skipBox(r, h.Size, 8); err != nil {
+			return 0, err
+		}
+	}
+	if moovStart == 0 && moovSize == 0 {
+		return 0, errors.New("moov not found")
+	}
+	// Parse inside moov for video trak mdhd, else mvhd
+	if _, err := r.Seek(moovStart+8, io.SeekStart); err != nil { // skip moov header
+		return 0, err
+	}
+	end := moovStart + int64(moovSize)
+	var movieTimescale uint32
+	var movieDuration uint64
+	var foundVideoMdhd bool
+	var mdhdTimescale uint32
+	var mdhdDuration uint64
+
+	for {
+		pos, _ := r.Seek(0, io.SeekCurrent)
+		if pos >= end {
+			break
+		}
+		h, err := readBoxHeader(r)
+		if err != nil {
+			return 0, err
+		}
+		switch string(h.Type[:]) {
+		case "mvhd":
+			// movie header
+			ver := make([]byte, 1)
+			if _, err := io.ReadFull(r, ver); err != nil {
+				return 0, err
+			}
+			if _, err := r.Seek(3, io.SeekCurrent); err != nil { // flags
+				return 0, err
+			}
+			if ver[0] == 1 {
+				// version 1: 64-bit duration
+				buf := make([]byte, 8+8+4+8) // ctime(8) mtime(8) timescale(4) duration(8)
+				if _, err := io.ReadFull(r, buf); err != nil {
+					return 0, err
+				}
+				movieTimescale = binary.BigEndian.Uint32(buf[16:20])
+				movieDuration = binary.BigEndian.Uint64(buf[20:28])
+			} else {
+				buf := make([]byte, 4+4+4+4) // ctime mtime timescale duration
+				if _, err := io.ReadFull(r, buf); err != nil {
+					return 0, err
+				}
+				movieTimescale = binary.BigEndian.Uint32(buf[8:12])
+				movieDuration = uint64(binary.BigEndian.Uint32(buf[12:16]))
+			}
+			// skip rest of mvhd
+			read := int64(1 + 3)
+			if ver[0] == 1 {
+				read += int64(8 + 8 + 4 + 8)
+			} else {
+				read += int64(4 + 4 + 4 + 4)
+			}
+			if err := skipBox(r, h.Size, 8+read); err != nil {
+				return 0, err
+			}
+		case "trak":
+			// parse trak for hdlr and mdhd
+			tEnd := int64(0)
+			if h.Size < 8 {
+				return 0, errors.New("invalid trak size")
+			}
+			tEnd = pos + int64(h.Size)
+			var isVideo bool
+			var tMdhdTimescale uint32
+			var tMdhdDuration uint64
+			for {
+				cpos, _ := r.Seek(0, io.SeekCurrent)
+				if cpos >= tEnd {
+					break
+				}
+				ch, err := readBoxHeader(r)
+				if err != nil {
+					return 0, err
+				}
+				switch string(ch.Type[:]) {
+				case "mdia":
+					mEnd := cpos + int64(ch.Size)
+					for {
+						mpos, _ := r.Seek(0, io.SeekCurrent)
+						if mpos >= mEnd {
+							break
+						}
+						mh, err := readBoxHeader(r)
+						if err != nil {
+							return 0, err
+						}
+						switch string(mh.Type[:]) {
+						case "hdlr":
+							// skip version+flags (4), pre_defined(4)
+							if _, err := r.Seek(8, io.SeekCurrent); err != nil {
+								return 0, err
+							}
+							handler := make([]byte, 4)
+							if _, err := io.ReadFull(r, handler); err != nil {
+								return 0, err
+							}
+							if string(handler) == "vide" {
+								isVideo = true
+							}
+							if err := skipBox(r, mh.Size, 8+8+4); err != nil { // header + skipped + read handler
+								return 0, err
+							}
+						case "mdhd":
+							ver := make([]byte, 1)
+							if _, err := io.ReadFull(r, ver); err != nil {
+								return 0, err
+							}
+							if _, err := r.Seek(3, io.SeekCurrent); err != nil { // flags
+								return 0, err
+							}
+							if ver[0] == 1 {
+								buf := make([]byte, 8+8+4+8)
+								if _, err := io.ReadFull(r, buf); err != nil {
+									return 0, err
+								}
+								tMdhdTimescale = binary.BigEndian.Uint32(buf[16:20])
+								tMdhdDuration = binary.BigEndian.Uint64(buf[20:28])
+							} else {
+								buf := make([]byte, 4+4+4+4)
+								if _, err := io.ReadFull(r, buf); err != nil {
+									return 0, err
+								}
+								tMdhdTimescale = binary.BigEndian.Uint32(buf[8:12])
+								tMdhdDuration = uint64(binary.BigEndian.Uint32(buf[12:16]))
+							}
+							if err := skipBox(r, mh.Size, 8+1+3+int64(lenVersionPayload(ver[0]))); err != nil {
+								return 0, err
+							}
+						default:
+							if err := skipBox(r, mh.Size, 8); err != nil {
+								return 0, err
+							}
+						}
+					}
+				default:
+					if err := skipBox(r, ch.Size, 8); err != nil {
+						return 0, err
+					}
+				}
+			}
+			if isVideo && tMdhdTimescale != 0 && tMdhdDuration != 0 {
+				foundVideoMdhd = true
+				mdhdTimescale = tMdhdTimescale
+				mdhdDuration = tMdhdDuration
+			}
+			// Skip remaining of trak if any
+			if _, err := r.Seek(tEnd, io.SeekStart); err != nil {
+				return 0, err
+			}
+		default:
+			if err := skipBox(r, h.Size, 8); err != nil {
+				return 0, err
+			}
+		}
+	}
+
+	if foundVideoMdhd && mdhdTimescale != 0 {
+		sec := float64(mdhdDuration) / float64(mdhdTimescale)
+		return time.Duration(sec * float64(time.Second)), nil
+	}
+	if movieTimescale != 0 {
+		sec := float64(movieDuration) / float64(movieTimescale)
+		return time.Duration(sec * float64(time.Second)), nil
+	}
+	return 0, errors.New("failed to read mp4 duration")
+}
+
+func lenVersionPayload(ver byte) int {
+	if ver == 1 {
+		return 8 + 8 + 4 + 8
+	}
+	return 4 + 4 + 4 + 4
+}