func (self *SimpleH264Writer) prepare() (err error) {
if self.mdatWriter, err = atom.WriteAtomHeader(self.W, "mdat"); err != nil {
return
}
if len(self.SPS) == 0 {
err = fmt.Errorf("invalid SPS")
return
}
if len(self.PPS) == 0 {
err = fmt.Errorf("invalid PPS")
return
}
if self.Width == 0 || self.Height == 0 {
var info *atom.H264SPSInfo
if info, err = atom.ParseH264SPS(self.SPS[1:]); err != nil {
return
}
self.Width = int(info.Width)
self.Height = int(info.Height)
}
self.sampleIdx = 1
self.sample = &atom.SampleTable{
SampleDesc: &atom.SampleDesc{
Avc1Desc: &atom.Avc1Desc{
DataRefIdx: 1,
HorizontalResolution: 72,
VorizontalResolution: 72,
Width: self.Width,
Height: self.Height,
FrameCount: 1,
Depth: 24,
ColorTableId: -1,
Conf: &atom.Avc1Conf{},
},
},
TimeToSample: &atom.TimeToSample{},
SampleToChunk: &atom.SampleToChunk{
Entries: []atom.SampleToChunkEntry{
{
FirstChunk: 1,
SampleDescId: 1,
},
},
},
SampleSize: &atom.SampleSize{},
ChunkOffset: &atom.ChunkOffset{
Entries: []int{8},
},
SyncSample: &atom.SyncSample{},
}
self.sampleToChunk = &self.sample.SampleToChunk.Entries[0]
return
}
func TestConvert(filename string) (err error) {
var osfile *os.File
if osfile, err = os.Open(filename); err != nil {
return
}
var finfo os.FileInfo
if finfo, err = osfile.Stat(); err != nil {
return
}
log.Println("filesize", finfo.Size())
lr := &io.LimitedReader{R: osfile, N: finfo.Size()}
var outfile *os.File
if outfile, err = os.Create(filename + ".out.mp4"); err != nil {
return
}
for lr.N > 0 {
var ar *io.LimitedReader
var cc4 string
if ar, cc4, err = atom.ReadAtomHeader(lr, ""); err != nil {
return
}
if cc4 == "moov" {
curPos, _ := outfile.Seek(0, 1)
origSize := ar.N + 8
var moov *atom.Movie
if moov, err = atom.ReadMovie(ar); err != nil {
return
}
//log.Println(moov.Tracks[0].Media.Info.Data.Refer)
if err = atom.WriteMovie(outfile, moov); err != nil {
return
}
curPosAfterRead, _ := outfile.Seek(0, 1)
bytesWritten := curPosAfterRead - curPos
log.Println("regen moov", "tracks nr", len(moov.Tracks),
"origSize", origSize, "bytesWritten", bytesWritten,
)
padSize := origSize - bytesWritten - 8
aw, _ := atom.WriteAtomHeader(outfile, "free")
atom.WriteDummy(outfile, int(padSize))
aw.Close()
} else {
outcc4 := cc4
if outcc4 != "mdat" {
log.Println("omit", cc4)
outcc4 = "free"
} else {
log.Println("copy", cc4)
}
var aw *atom.Writer
if aw, err = atom.WriteAtomHeader(outfile, outcc4); err != nil {
return
}
if _, err = io.CopyN(aw, ar, ar.N); err != nil {
return
}
if err = aw.Close(); err != nil {
return
}
}
//log.Println("atom", cc4, "left", lr.N)
//atom.ReadDummy(ar, int(ar.N))
}
if err = outfile.Close(); err != nil {
return
}
return
}
