xref: /external/mp4parser/isoparser/src/main/java/com/googlecode/mp4parser/authoring/tracks/AppendTrack.java

/*
 * 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();
    }

}