Untested use of Frame for video/audio content lengths.

[dcpomatic.git] / src / lib / audio_decoder.cc

diff --git a/src/lib/audio_decoder.cc b/src/lib/audio_decoder.cc
index 31dcf2ef910289899b6776b3bfad4209698822a2..a310650c526e20a71fa1fbc6823f6de024ad0186 100644 (file)
--- a/src/lib/audio_decoder.cc
+++ b/src/lib/audio_decoder.cc
@@ -1,5 +1,5 @@
 /*
-    Copyright (C) 2012-2014 Carl Hetherington <cth@carlh.net>
+    Copyright (C) 2012-2015 Carl Hetherington <cth@carlh.net>
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -55,21 +55,21 @@ AudioDecoder::reset_decoded_audio ()
 }
 
 shared_ptr<ContentAudio>
-AudioDecoder::get_audio (AudioFrame frame, AudioFrame length, bool accurate)
+AudioDecoder::get_audio (Frame frame, Frame length, bool accurate)
 {
        shared_ptr<ContentAudio> dec;
 
-       AudioFrame const end = frame + length - 1;
+       Frame const end = frame + length - 1;
                
        if (frame < _decoded_audio.frame || end > (_decoded_audio.frame + length * 4)) {
                /* Either we have no decoded data, or what we do have is a long way from what we want: seek */
-               seek (ContentTime::from_frames (frame, _audio_content->audio_frame_rate()), accurate);
+               seek (ContentTime::from_frames (frame, _audio_content->resampled_audio_frame_rate()), accurate);
        }
 
        /* Offset of the data that we want from the start of _decoded_audio.audio
           (to be set up shortly)
        */
-       AudioFrame decoded_offset = 0;
+       Frame decoded_offset = 0;
        
        /* Now enough pass() calls will either:
         *  (a) give us what we want, or
@@ -80,26 +80,26 @@ AudioDecoder::get_audio (AudioFrame frame, AudioFrame length, bool accurate)
         */
        if (accurate) {
                /* Keep stuffing data into _decoded_audio until we have enough data, or the subclass does not want to give us any more */
-               while ((_decoded_audio.frame > frame || (_decoded_audio.frame + _decoded_audio.audio->frames()) < end) && !pass ()) {}
+               while ((_decoded_audio.frame > frame || (_decoded_audio.frame + _decoded_audio.audio->frames()) < end) && !pass (PASS_REASON_AUDIO)) {}
                decoded_offset = frame - _decoded_audio.frame;
        } else {
-               while (_decoded_audio.audio->frames() < length && !pass ()) {}
+               while (_decoded_audio.audio->frames() < length && !pass (PASS_REASON_AUDIO)) {}
                /* Use decoded_offset of 0, as we don't really care what frames we return */
        }
 
        /* The amount of data available in _decoded_audio.audio starting from `frame'.  This could be -ve
           if pass() returned true before we got enough data.
        */
-       AudioFrame const available = _decoded_audio.audio->frames() - decoded_offset;
+       Frame const available = _decoded_audio.audio->frames() - decoded_offset;
 
        /* We will return either that, or the requested amount, whichever is smaller */
-       AudioFrame const to_return = max ((AudioFrame) 0, min (available, length));
+       Frame const to_return = max ((Frame) 0, min (available, length));
 
        /* Copy our data to the output */
        shared_ptr<AudioBuffers> out (new AudioBuffers (_decoded_audio.audio->channels(), to_return));
        out->copy_from (_decoded_audio.audio.get(), to_return, decoded_offset, 0);
 
-       AudioFrame const remaining = max ((AudioFrame) 0, available - to_return);
+       Frame const remaining = max ((Frame) 0, available - to_return);
 
        /* Clean up decoded; first, move the data after what we just returned to the start of the buffer */
        _decoded_audio.audio->move (decoded_offset + to_return, 0, remaining);
@@ -131,12 +131,12 @@ AudioDecoder::audio (shared_ptr<const AudioBuffers> data, ContentTime time)
                data = _processor->run (data);
        }
 
-       AudioFrame const frame_rate = _audio_content->resampled_audio_frame_rate ();
+       Frame const frame_rate = _audio_content->resampled_audio_frame_rate ();
 
        if (_seek_reference) {
                /* We've had an accurate seek and now we're seeing some data */
                ContentTime const delta = time - _seek_reference.get ();
-               AudioFrame const delta_frames = delta.frames (frame_rate);
+               Frame const delta_frames = delta.frames (frame_rate);
                if (delta_frames > 0) {
                        /* This data comes after the seek time.  Pad the data with some silence. */
                        shared_ptr<AudioBuffers> padded (new AudioBuffers (data->channels(), data->frames() + delta_frames));
@@ -146,8 +146,8 @@ AudioDecoder::audio (shared_ptr<const AudioBuffers> data, ContentTime time)
                        time -= delta;
                } else if (delta_frames < 0) {
                        /* This data comes before the seek time.  Throw some data away */
-                       AudioFrame const to_discard = min (-delta_frames, static_cast<AudioFrame> (data->frames()));
-                       AudioFrame const to_keep = data->frames() - to_discard;
+                       Frame const to_discard = min (-delta_frames, static_cast<Frame> (data->frames()));
+                       Frame const to_keep = data->frames() - to_discard;
                        if (to_keep == 0) {
                                /* We have to throw all this data away, so keep _seek_reference and
                                   try again next time some data arrives.
@@ -166,7 +166,7 @@ AudioDecoder::audio (shared_ptr<const AudioBuffers> data, ContentTime time)
                _audio_position = time.frames (frame_rate);
        }
 
-       assert (_audio_position.get() >= (_decoded_audio.frame + _decoded_audio.audio->frames()));
+       DCPOMATIC_ASSERT (_audio_position.get() >= (_decoded_audio.frame + _decoded_audio.audio->frames()));
 
        add (data);
 }