예제 #1
0
 protected static long getDuration(Track track) {
   long duration = 0;
   for (TimeToSampleBox.Entry entry : track.getDecodingTimeEntries()) {
     duration += entry.getCount() * entry.getDelta();
   }
   return duration;
 }
예제 #2
0
 /**
  * we try to get the nearest synchronized sample to our desired start time. Afterwards, we are
  * ready to crop each track of the video.
  */
 private double correctTimeToNextSyncSample(Track track, double cropVidPlace, boolean nextPlace) {
   double[] timeOfSyncSamples = new double[track.getSyncSamples().length];
   long currentSample = 0;
   double currentTime = 0;
   for (int i = 0; i < track.getDecodingTimeEntries().size(); i++) {
     TimeToSampleBox.Entry entry = track.getDecodingTimeEntries().get(i);
     for (int j = 0; j < entry.getCount(); j++) {
       if (Arrays.binarySearch(track.getSyncSamples(), currentSample + 1) >= 0) {
         // samples always start with 1 but we start with zero therefore +1
         timeOfSyncSamples[Arrays.binarySearch(track.getSyncSamples(), currentSample + 1)] =
             currentTime;
       }
       currentTime += (double) entry.getDelta() / (double) track.getTrackMetaData().getTimescale();
       currentSample++;
     }
   }
   double previous = 0;
   for (double timeOfSyncSample : timeOfSyncSamples) {
     if (timeOfSyncSample > cropVidPlace) {
       if (nextPlace) {
         return timeOfSyncSample;
       } else {
         return previous;
       }
     }
     previous = timeOfSyncSample;
   }
   return timeOfSyncSamples[timeOfSyncSamples.length - 1];
 }
  private static long[] getTimes(Movie m, Track track) {
    long[] syncSamples = track.getSyncSamples();
    long[] syncSampleTimes = new long[syncSamples.length];
    Queue<TimeToSampleBox.Entry> timeQueue =
        new LinkedList<TimeToSampleBox.Entry>(track.getDecodingTimeEntries());

    int currentSample = 1; // first syncsample is 1
    long currentDuration = 0;
    long currentDelta = 0;
    int currentSyncSampleIndex = 0;
    long left = 0;

    long timeScale = 1;
    for (Track track1 : m.getTracks()) {
      if (track1.getHandler().equals(track.getHandler())) {
        if (track1.getTrackMetaData().getTimescale() != track.getTrackMetaData().getTimescale()) {
          timeScale = lcm(timeScale, track1.getTrackMetaData().getTimescale());
        }
      }
    }

    while (currentSample <= syncSamples[syncSamples.length - 1]) {
      if (currentSample++ == syncSamples[currentSyncSampleIndex]) {
        syncSampleTimes[currentSyncSampleIndex++] = currentDuration * timeScale;
      }
      if (left-- == 0) {
        TimeToSampleBox.Entry entry = timeQueue.poll();
        left = entry.getCount() - 1;
        currentDelta = entry.getDelta();
      }
      currentDuration += currentDelta;
    }
    return syncSampleTimes;
  }
예제 #4
0
  protected void createStts(Track track, SampleTableBox stbl) {
    TimeToSampleBox.Entry lastEntry = null;
    List<TimeToSampleBox.Entry> entries = new ArrayList<TimeToSampleBox.Entry>();

    for (long delta : track.getSampleDurations()) {
      if (lastEntry != null && lastEntry.getDelta() == delta) {
        lastEntry.setCount(lastEntry.getCount() + 1);
      } else {
        lastEntry = new TimeToSampleBox.Entry(1, delta);
        entries.add(lastEntry);
      }
    }
    TimeToSampleBox stts = new TimeToSampleBox();
    stts.setEntries(entries);
    stbl.addBox(stts);
  }
예제 #5
0
  /**
   * all the trimming happens in this method.
   *
   * <p>STEP A ==>> For each track in the video, we first get the start time for all the tracks.
   *
   * <p>STEP B ==>> For each track in the video, we crop the tracks with a 'start time' and 'end
   * time' and add it to the Movie object.
   *
   * <p>STEP C ==>> Finally write the newly created movie to the disk.
   */
  private String cropSelectedVideo() {
    FileInputStream fileInputStream = null;
    FileChannel fileChannel = null;
    try {

      File videoFile = new File(mFullPathToVideoFile);
      fileInputStream = new FileInputStream(videoFile);
      fileChannel = fileInputStream.getChannel();
      Movie movie = MovieCreator.build(fileChannel);
      if (movie == null) {
        return null;
      } else {
        List<Track> tracks = movie.getTracks();
        movie.setTracks(new LinkedList<Track>());

        boolean timeCorrected = false;
        if ((tracks == null) && (tracks.size() <= 0)) {
          return null;
        } else {
          /**
           * here we try to find a track that has sync samples. Since we can only start decoding at
           * such a sample we should make sure that the start of the fragment is exactly the such a
           * frame.
           */
          for (Track track : tracks) {
            if (track.getSyncSamples() != null && track.getSyncSamples().length > 0) {
              if (timeCorrected) {
                /**
                 * This exception here can be false position in case we have multiple tracks with
                 * sync sample at exactly the same position. E.g. a single movie containing multiple
                 * qualities of the same video.
                 */
              } else {
                mStartTime = correctTimeToNextSyncSample(track, mStartTime, false);
                mEndTime = correctTimeToNextSyncSample(track, mEndTime, true);
                timeCorrected = true;
              }
            }
          }

          for (Track track : tracks) {
            long currentVidSample = 0;
            double currentTime = 0;
            long startVidSample = -1;
            long endVidSample = -1;

            for (int i = 0; i < track.getDecodingTimeEntries().size(); i++) {
              TimeToSampleBox.Entry myEntry = track.getDecodingTimeEntries().get(i);

              for (int j = 0; j < myEntry.getCount(); j++) {
                // I am trying to find the start time and end time when the trimmimg occurs
                if (currentTime <= mStartTime) {
                  // our current video sample is before the starting time for the crop
                  // if the startVidSample is equal to the length of the video,
                  // an error happened, and we should throw an exception
                  startVidSample =
                      currentVidSample; // the new begining of the video will be set to this place
                  // of the video
                } else if (currentTime <= mEndTime) {
                  // our current video sample is after the starting time for the crop
                  // but  before the end time of the crop
                  endVidSample =
                      currentVidSample; // the new end of the video will be set to this place of the
                  // video
                } else {
                  // our current video sample is after the end time of the cropping
                  // we just stop this this loop
                  break;
                }

                // getDelta() : the amount of time the current video sample covers
                currentTime +=
                    (double) myEntry.getDelta() / (double) track.getTrackMetaData().getTimescale();
                currentVidSample++;
              }
            }
            movie.addTrack(new CroppedTrack(track, startVidSample, endVidSample));
          }
        }
      }

      IsoFile isoFile = new DefaultMp4Builder().build(movie);
      /** STEP C ==>> After we created the Movie, we have to place it into a nonvolatile memory. */
      return Util.placeFileInNonVolatileDrive(isoFile, mVideFolderPath, "trim_output");

    } catch (Exception e) {
      Log.e(TAG, "IO ERROR: " + e);
    } finally {
      if (fileInputStream != null) {
        try {
          fileInputStream.close();
        } catch (IOException e) {
          Log.e(TAG, "IO ERROR: " + e);
        }
      }
      if (fileChannel != null) {
        try {
          fileChannel.close();
        } catch (IOException e) {
          Log.e(TAG, "IO ERROR: " + e);
        }
      }
    }
    return null;
  }