diff options
Diffstat (limited to 'isoparser/src/main/java/com/googlecode/mp4parser/authoring/tracks/.svn/text-base/AppendTrack.java.svn-base')
| -rw-r--r-- | isoparser/src/main/java/com/googlecode/mp4parser/authoring/tracks/.svn/text-base/AppendTrack.java.svn-base | 348 |
1 files changed, 348 insertions, 0 deletions
diff --git a/isoparser/src/main/java/com/googlecode/mp4parser/authoring/tracks/.svn/text-base/AppendTrack.java.svn-base b/isoparser/src/main/java/com/googlecode/mp4parser/authoring/tracks/.svn/text-base/AppendTrack.java.svn-base new file mode 100644 index 0000000..93ee0cd --- /dev/null +++ b/isoparser/src/main/java/com/googlecode/mp4parser/authoring/tracks/.svn/text-base/AppendTrack.java.svn-base @@ -0,0 +1,348 @@ +/* + * Copyright 2012 Sebastian Annies, Hamburg + * + * Licensed under the Apache License, Version 2.0 (the License); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.googlecode.mp4parser.authoring.tracks; + +import com.coremedia.iso.boxes.*; +import com.coremedia.iso.boxes.sampleentry.AudioSampleEntry; +import com.googlecode.mp4parser.authoring.AbstractTrack; +import com.googlecode.mp4parser.authoring.Track; +import com.googlecode.mp4parser.authoring.TrackMetaData; +import com.googlecode.mp4parser.boxes.mp4.ESDescriptorBox; +import com.googlecode.mp4parser.boxes.mp4.objectdescriptors.DecoderConfigDescriptor; +import com.googlecode.mp4parser.boxes.mp4.objectdescriptors.ESDescriptor; + +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.nio.ByteBuffer; +import java.nio.channels.Channels; +import java.util.*; + +/** + * Appends two or more <code>Tracks</code> of the same type. No only that the type must be equal + * also the decoder settings must be the same. + */ +public class AppendTrack extends AbstractTrack { + Track[] tracks; + SampleDescriptionBox stsd; + + public AppendTrack(Track... tracks) throws IOException { + this.tracks = tracks; + + for (Track track : tracks) { + + if (stsd == null) { + stsd = track.getSampleDescriptionBox(); + } else { + ByteArrayOutputStream curBaos = new ByteArrayOutputStream(); + ByteArrayOutputStream refBaos = new ByteArrayOutputStream(); + track.getSampleDescriptionBox().getBox(Channels.newChannel(curBaos)); + stsd.getBox(Channels.newChannel(refBaos)); + byte[] cur = curBaos.toByteArray(); + byte[] ref = refBaos.toByteArray(); + + if (!Arrays.equals(ref, cur)) { + SampleDescriptionBox curStsd = track.getSampleDescriptionBox(); + if (stsd.getBoxes().size() == 1 && curStsd.getBoxes().size() == 1) { + if (stsd.getBoxes().get(0) instanceof AudioSampleEntry && curStsd.getBoxes().get(0) instanceof AudioSampleEntry) { + AudioSampleEntry aseResult = mergeAudioSampleEntries((AudioSampleEntry) stsd.getBoxes().get(0), (AudioSampleEntry) curStsd.getBoxes().get(0)); + if (aseResult != null) { + stsd.setBoxes(Collections.<Box>singletonList(aseResult)); + return; + } + } + } + throw new IOException("Cannot append " + track + " to " + tracks[0] + " since their Sample Description Boxes differ: \n" + track.getSampleDescriptionBox() + "\n vs. \n" + tracks[0].getSampleDescriptionBox()); + } + } + } + } + + private AudioSampleEntry mergeAudioSampleEntries(AudioSampleEntry ase1, AudioSampleEntry ase2) throws IOException { + if (ase1.getType().equals(ase2.getType())) { + AudioSampleEntry ase = new AudioSampleEntry(ase2.getType()); + if (ase1.getBytesPerFrame() == ase2.getBytesPerFrame()) { + ase.setBytesPerFrame(ase1.getBytesPerFrame()); + } else { + return null; + } + if (ase1.getBytesPerPacket() == ase2.getBytesPerPacket()) { + ase.setBytesPerPacket(ase1.getBytesPerPacket()); + } else { + return null; + } + if (ase1.getBytesPerSample() == ase2.getBytesPerSample()) { + ase.setBytesPerSample(ase1.getBytesPerSample()); + } else { + return null; + } + if (ase1.getChannelCount() == ase2.getChannelCount()) { + ase.setChannelCount(ase1.getChannelCount()); + } else { + return null; + } + if (ase1.getPacketSize() == ase2.getPacketSize()) { + ase.setPacketSize(ase1.getPacketSize()); + } else { + return null; + } + if (ase1.getCompressionId() == ase2.getCompressionId()) { + ase.setCompressionId(ase1.getCompressionId()); + } else { + return null; + } + if (ase1.getSampleRate() == ase2.getSampleRate()) { + ase.setSampleRate(ase1.getSampleRate()); + } else { + return null; + } + if (ase1.getSampleSize() == ase2.getSampleSize()) { + ase.setSampleSize(ase1.getSampleSize()); + } else { + return null; + } + if (ase1.getSamplesPerPacket() == ase2.getSamplesPerPacket()) { + ase.setSamplesPerPacket(ase1.getSamplesPerPacket()); + } else { + return null; + } + if (ase1.getSoundVersion() == ase2.getSoundVersion()) { + ase.setSoundVersion(ase1.getSoundVersion()); + } else { + return null; + } + if (Arrays.equals(ase1.getSoundVersion2Data(), ase2.getSoundVersion2Data())) { + ase.setSoundVersion2Data(ase1.getSoundVersion2Data()); + } else { + return null; + } + if (ase1.getBoxes().size() == ase2.getBoxes().size()) { + Iterator<Box> bxs1 = ase1.getBoxes().iterator(); + Iterator<Box> bxs2 = ase2.getBoxes().iterator(); + while (bxs1.hasNext()) { + Box cur1 = bxs1.next(); + Box cur2 = bxs2.next(); + ByteArrayOutputStream baos1 = new ByteArrayOutputStream(); + ByteArrayOutputStream baos2 = new ByteArrayOutputStream(); + cur1.getBox(Channels.newChannel(baos1)); + cur2.getBox(Channels.newChannel(baos2)); + if (Arrays.equals(baos1.toByteArray(), baos2.toByteArray())) { + ase.addBox(cur1); + } else { + if (ESDescriptorBox.TYPE.equals(cur1.getType()) && ESDescriptorBox.TYPE.equals(cur2.getType())) { + ESDescriptorBox esdsBox1 = (ESDescriptorBox) cur1; + ESDescriptorBox esdsBox2 = (ESDescriptorBox) cur2; + ESDescriptor esds1 = esdsBox1.getEsDescriptor(); + ESDescriptor esds2 = esdsBox2.getEsDescriptor(); + if (esds1.getURLFlag() != esds2.getURLFlag()) { + return null; + } + if (esds1.getURLLength() != esds2.getURLLength()) { + return null; + } + if (esds1.getDependsOnEsId() != esds2.getDependsOnEsId()) { + return null; + } + if (esds1.getEsId() != esds2.getEsId()) { + return null; + } + if (esds1.getoCREsId() != esds2.getoCREsId()) { + return null; + } + if (esds1.getoCRstreamFlag() != esds2.getoCRstreamFlag()) { + return null; + } + if (esds1.getRemoteODFlag() != esds2.getRemoteODFlag()) { + return null; + } + if (esds1.getStreamDependenceFlag() != esds2.getStreamDependenceFlag()) { + return null; + } + if (esds1.getStreamPriority() != esds2.getStreamPriority()) { + return null; + } + if (esds1.getURLString() != null ? !esds1.getURLString().equals(esds2.getURLString()) : esds2.getURLString() != null) { + return null; + } + if (esds1.getDecoderConfigDescriptor() != null ? !esds1.getDecoderConfigDescriptor().equals(esds2.getDecoderConfigDescriptor()) : esds2.getDecoderConfigDescriptor() != null) { + DecoderConfigDescriptor dcd1 = esds1.getDecoderConfigDescriptor(); + DecoderConfigDescriptor dcd2 = esds2.getDecoderConfigDescriptor(); + if (!dcd1.getAudioSpecificInfo().equals(dcd2.getAudioSpecificInfo())) { + return null; + } + if (dcd1.getAvgBitRate() != dcd2.getAvgBitRate()) { + // I don't care + } + if (dcd1.getBufferSizeDB() != dcd2.getBufferSizeDB()) { + // I don't care + } + + if (dcd1.getDecoderSpecificInfo() != null ? !dcd1.getDecoderSpecificInfo().equals(dcd2.getDecoderSpecificInfo()) : dcd2.getDecoderSpecificInfo() != null) { + return null; + } + + if (dcd1.getMaxBitRate() != dcd2.getMaxBitRate()) { + // I don't care + } + if (!dcd1.getProfileLevelIndicationDescriptors().equals(dcd2.getProfileLevelIndicationDescriptors())) { + return null; + } + + if (dcd1.getObjectTypeIndication() != dcd2.getObjectTypeIndication()) { + return null; + } + if (dcd1.getStreamType() != dcd2.getStreamType()) { + return null; + } + if (dcd1.getUpStream() != dcd2.getUpStream()) { + return null; + } + + + } + if (esds1.getOtherDescriptors() != null ? !esds1.getOtherDescriptors().equals(esds2.getOtherDescriptors()) : esds2.getOtherDescriptors() != null) { + return null; + } + if (esds1.getSlConfigDescriptor() != null ? !esds1.getSlConfigDescriptor().equals(esds2.getSlConfigDescriptor()) : esds2.getSlConfigDescriptor() != null) { + return null; + } + ase.addBox(cur1); + } + } + } + } + return ase; + } else { + return null; + } + + + } + + + public List<ByteBuffer> getSamples() { + ArrayList<ByteBuffer> lists = new ArrayList<ByteBuffer>(); + + for (Track track : tracks) { + lists.addAll(track.getSamples()); + } + + return lists; + } + + public SampleDescriptionBox getSampleDescriptionBox() { + return stsd; + } + + public List<TimeToSampleBox.Entry> getDecodingTimeEntries() { + if (tracks[0].getDecodingTimeEntries() != null && !tracks[0].getDecodingTimeEntries().isEmpty()) { + List<long[]> lists = new LinkedList<long[]>(); + for (Track track : tracks) { + lists.add(TimeToSampleBox.blowupTimeToSamples(track.getDecodingTimeEntries())); + } + + LinkedList<TimeToSampleBox.Entry> returnDecodingEntries = new LinkedList<TimeToSampleBox.Entry>(); + for (long[] list : lists) { + for (long nuDecodingTime : list) { + if (returnDecodingEntries.isEmpty() || returnDecodingEntries.getLast().getDelta() != nuDecodingTime) { + TimeToSampleBox.Entry e = new TimeToSampleBox.Entry(1, nuDecodingTime); + returnDecodingEntries.add(e); + } else { + TimeToSampleBox.Entry e = returnDecodingEntries.getLast(); + e.setCount(e.getCount() + 1); + } + } + } + return returnDecodingEntries; + } else { + return null; + } + } + + public List<CompositionTimeToSample.Entry> getCompositionTimeEntries() { + if (tracks[0].getCompositionTimeEntries() != null && !tracks[0].getCompositionTimeEntries().isEmpty()) { + List<int[]> lists = new LinkedList<int[]>(); + for (Track track : tracks) { + lists.add(CompositionTimeToSample.blowupCompositionTimes(track.getCompositionTimeEntries())); + } + LinkedList<CompositionTimeToSample.Entry> compositionTimeEntries = new LinkedList<CompositionTimeToSample.Entry>(); + for (int[] list : lists) { + for (int compositionTime : list) { + if (compositionTimeEntries.isEmpty() || compositionTimeEntries.getLast().getOffset() != compositionTime) { + CompositionTimeToSample.Entry e = new CompositionTimeToSample.Entry(1, compositionTime); + compositionTimeEntries.add(e); + } else { + CompositionTimeToSample.Entry e = compositionTimeEntries.getLast(); + e.setCount(e.getCount() + 1); + } + } + } + return compositionTimeEntries; + } else { + return null; + } + } + + public long[] getSyncSamples() { + if (tracks[0].getSyncSamples() != null && tracks[0].getSyncSamples().length > 0) { + int numSyncSamples = 0; + for (Track track : tracks) { + numSyncSamples += track.getSyncSamples().length; + } + long[] returnSyncSamples = new long[numSyncSamples]; + + int pos = 0; + long samplesBefore = 0; + for (Track track : tracks) { + for (long l : track.getSyncSamples()) { + returnSyncSamples[pos++] = samplesBefore + l; + } + samplesBefore += track.getSamples().size(); + } + return returnSyncSamples; + } else { + return null; + } + } + + public List<SampleDependencyTypeBox.Entry> getSampleDependencies() { + if (tracks[0].getSampleDependencies() != null && !tracks[0].getSampleDependencies().isEmpty()) { + List<SampleDependencyTypeBox.Entry> list = new LinkedList<SampleDependencyTypeBox.Entry>(); + for (Track track : tracks) { + list.addAll(track.getSampleDependencies()); + } + return list; + } else { + return null; + } + } + + public TrackMetaData getTrackMetaData() { + return tracks[0].getTrackMetaData(); + } + + public String getHandler() { + return tracks[0].getHandler(); + } + + public Box getMediaHeaderBox() { + return tracks[0].getMediaHeaderBox(); + } + + public SubSampleInformationBox getSubsampleInformationBox() { + return tracks[0].getSubsampleInformationBox(); + } + +} |