Use standard duration types for stream clocks

1 files changed, 122 insertions, 105 deletions

diff --git a/examples/alffplay.cpp b/examples/alffplay.cpp
index 7c6b9f6e..021cdbaf 100644
--- a/examples/alffplay.cpp
+++ b/examples/alffplay.cpp
@@ -36,20 +36,19 @@ extern "C" {
 #include "AL/al.h"
 #include "AL/alext.h"
 
-namespace
-{
+namespace {
 
-static const std::string AppName("alffplay");
+const std::string AppName("alffplay");
 
-static bool do_direct_out = false;
-static bool has_latency_check = false;
-static LPALGETSOURCEDVSOFT alGetSourcedvSOFT;
+bool do_direct_out = false;
+bool has_latency_check = false;
+LPALGETSOURCEI64VSOFT alGetSourcei64vSOFT;
 
-#define AUDIO_BUFFER_TIME 100 /* In milliseconds, per-buffer */
+const std::chrono::duration<double> AVSyncThreshold(0.01);
+const std::chrono::seconds AVNoSyncThreshold(10);
+const std::chrono::milliseconds AudioBufferTime(100); /* Per-buffer */
 #define AUDIO_BUFFER_QUEUE_SIZE 8 /* Number of buffers to queue */
 #define MAX_QUEUE_SIZE (15 * 1024 * 1024) /* Bytes of compressed data to keep queued */
-#define AV_SYNC_THRESHOLD 0.01
-#define AV_NOSYNC_THRESHOLD 10.0
 #define SAMPLE_CORRECTION_MAX_DIFF 0.05
 #define AUDIO_DIFF_AVG_NB 20
 #define VIDEO_PICTURE_QUEUE_SIZE 16
@@ -60,12 +59,12 @@ enum {
     FF_MOVIE_DONE_EVENT
 };
 
-enum {
-    AV_SYNC_AUDIO_MASTER,
-    AV_SYNC_VIDEO_MASTER,
-    AV_SYNC_EXTERNAL_MASTER,
+enum class SyncMaster {
+    Audio,
+    Video,
+    External,
 
-    DEFAULT_AV_SYNC_TYPE = AV_SYNC_EXTERNAL_MASTER
+    Default = External
 };
 
 
@@ -123,7 +122,6 @@ struct AudioState {
 
     /* Used for clock difference average computation */
     struct {
-        std::atomic<int> Clocks; /* In microseconds */
         double Accum;
         double AvgCoeff;
         double Threshold;
@@ -131,7 +129,7 @@ struct AudioState {
     } mDiff;
 
     /* Time (in seconds) of the next sample to be buffered */
-    double mCurrentPts;
+    std::chrono::duration<double> mCurrentPts;
 
     /* Decompressed sample frame, and swresample context for conversion */
     AVFrame           *mDecodedFrame;
@@ -158,7 +156,7 @@ struct AudioState {
 
     AudioState(MovieState *movie)
       : mMovie(movie), mStream(nullptr), mCodecCtx(nullptr)
-      , mDiff{{0}, 0.0, 0.0, 0.0, 0}, mCurrentPts(0.0), mDecodedFrame(nullptr)
+      , mDiff{0.0, 0.0, 0.0, 0}, mCurrentPts(0.0), mDecodedFrame(nullptr)
       , mSwresCtx(nullptr), mDstChanLayout(0), mDstSampleFmt(AV_SAMPLE_FMT_NONE)
       , mSamples(nullptr), mSamplesLen(0), mSamplesPos(0), mSamplesMax(0)
       , mFormat(AL_NONE), mFrameSize(0), mSource(0), mBufferIdx(0)
@@ -180,7 +178,7 @@ struct AudioState {
         avcodec_free_context(&mCodecCtx);
     }
 
-    double getClock();
+    std::chrono::nanoseconds getClock();
 
     int getSync();
     int decodeFrame();
@@ -198,13 +196,13 @@ struct VideoState {
     std::mutex mQueueMtx;
     std::condition_variable mQueueCond;
 
-    double  mClock;
-    double  mFrameTimer;
-    double  mFrameLastPts;
-    double  mFrameLastDelay;
-    double  mCurrentPts;
+    std::chrono::nanoseconds mClock;
+    std::chrono::duration<double> mFrameTimer;
+    std::chrono::nanoseconds mFrameLastPts;
+    std::chrono::nanoseconds mFrameLastDelay;
+    std::chrono::nanoseconds mCurrentPts;
     /* time (av_gettime) at which we updated mCurrentPts - used to have running video pts */
-    int64_t mCurrentPtsTime;
+    std::chrono::microseconds mCurrentPtsTime;
 
     /* Decompressed video frame, and swscale context for conversion */
     AVFrame           *mDecodedFrame;
@@ -214,10 +212,10 @@ struct VideoState {
         SDL_Texture *mImage;
         int mWidth, mHeight; /* Logical image size (actual size may be larger) */
         std::atomic<bool> mUpdated;
-        double mPts;
+        std::chrono::nanoseconds mPts;
 
         Picture()
-          : mImage(nullptr), mWidth(0), mHeight(0), mUpdated(false), mPts(0.0)
+          : mImage(nullptr), mWidth(0), mHeight(0), mUpdated(false), mPts(0)
         { }
         ~Picture()
         {
@@ -235,9 +233,9 @@ struct VideoState {
     std::atomic<bool> mFinalUpdate;
 
     VideoState(MovieState *movie)
-      : mMovie(movie), mStream(nullptr), mCodecCtx(nullptr), mClock(0.0)
-      , mFrameTimer(0.0), mFrameLastPts(0.0), mFrameLastDelay(0.0)
-      , mCurrentPts(0.0), mCurrentPtsTime(0), mDecodedFrame(nullptr)
+      : mMovie(movie), mStream(nullptr), mCodecCtx(nullptr), mClock(0)
+      , mFrameTimer(0.0), mFrameLastPts(0), mFrameLastDelay(0)
+      , mCurrentPts(0), mCurrentPtsTime(0), mDecodedFrame(nullptr)
       , mSwscaleCtx(nullptr), mPictQSize(0), mPictQRead(0), mPictQWrite(0)
       , mFirstUpdate(true), mEOS(false), mFinalUpdate(false)
     { }
@@ -249,24 +247,24 @@ struct VideoState {
         avcodec_free_context(&mCodecCtx);
     }
 
-    double getClock();
+    std::chrono::nanoseconds getClock();
 
     static Uint32 SDLCALL sdl_refresh_timer_cb(Uint32 interval, void *opaque);
-    void schedRefresh(int delay);
+    void schedRefresh(std::chrono::milliseconds delay);
     void display(SDL_Window *screen, SDL_Renderer *renderer);
     void refreshTimer(SDL_Window *screen, SDL_Renderer *renderer);
     void updatePicture(SDL_Window *screen, SDL_Renderer *renderer);
-    int queuePicture(double pts);
-    double synchronize(double pts);
+    int queuePicture(std::chrono::nanoseconds pts);
+    std::chrono::nanoseconds synchronize(std::chrono::nanoseconds pts);
     int handler();
 };
 
 struct MovieState {
     AVFormatContext *mFormatCtx;
 
-    int mAVSyncType;
+    SyncMaster mAVSyncType;
 
-    int64_t mExternalClockBase;
+    std::chrono::microseconds mClockBase;
 
     std::atomic<bool> mQuit;
 
@@ -280,8 +278,8 @@ struct MovieState {
     std::string mFilename;
 
     MovieState(std::string fname)
-      : mFormatCtx(nullptr), mAVSyncType(DEFAULT_AV_SYNC_TYPE)
-      , mExternalClockBase(0), mQuit(false), mAudio(this), mVideo(this)
+      : mFormatCtx(nullptr), mAVSyncType(SyncMaster::Default)
+      , mClockBase(0), mQuit(false), mAudio(this), mVideo(this)
       , mFilename(std::move(fname))
     { }
     ~MovieState()
@@ -296,18 +294,19 @@ struct MovieState {
     bool prepare();
     void setTitle(SDL_Window *window);
 
-    double getClock();
+    std::chrono::nanoseconds getClock();
 
-    double getMasterClock();
+    std::chrono::nanoseconds getMasterClock();
 
     int streamComponentOpen(int stream_index);
     int parse_handler();
 };
 
 
-double AudioState::getClock()
+std::chrono::nanoseconds AudioState::getClock()
 {
-    double pts;
+    using fixed32 = std::chrono::duration<ALint64SOFT,std::ratio<1,(1ll<<32)>>;
+    using nanoseconds = std::chrono::nanoseconds;
 
     std::unique_lock<std::recursive_mutex> lock(mSrcMutex);
     /* The audio clock is the timestamp of the sample currently being heard.
@@ -325,10 +324,10 @@ double AudioState::getClock()
      * OpenAL's current position, and subtracting the source latency from that
      * gives the timestamp of the sample currently at the DAC.
      */
-    pts = mCurrentPts;
+    nanoseconds pts = std::chrono::duration_cast<nanoseconds>(mCurrentPts);
     if(mSource)
     {
-        ALdouble offset[2];
+        ALint64SOFT offset[2];
         ALint queue_size;
         ALint status;
 
@@ -337,7 +336,7 @@ double AudioState::getClock()
          * and getting the state. */
         if(has_latency_check)
         {
-            alGetSourcedvSOFT(mSource, AL_SEC_OFFSET_LATENCY_SOFT, offset);
+            alGetSourcei64vSOFT(mSource, AL_SEC_OFFSET_LATENCY_SOFT, offset);
             alGetSourcei(mSource, AL_BUFFERS_QUEUED, &queue_size);
         }
         else
@@ -345,8 +344,8 @@ double AudioState::getClock()
             ALint ioffset;
             alGetSourcei(mSource, AL_SAMPLE_OFFSET, &ioffset);
             alGetSourcei(mSource, AL_BUFFERS_QUEUED, &queue_size);
-            offset[0] = (double)ioffset / (double)mCodecCtx->sample_rate;
-            offset[1] = 0.0f;
+            offset[0] = (ALint64SOFT)ioffset << 32;
+            offset[1] = 0;
         }
         alGetSourcei(mSource, AL_SOURCE_STATE, &status);
 
@@ -355,26 +354,32 @@ double AudioState::getClock()
          * will put the source into an AL_INITIAL state and clear the queue
          * when it starts recovery. */
         if(status != AL_STOPPED)
-            pts -= queue_size*((double)AUDIO_BUFFER_TIME/1000.0) - offset[0];
+        {
+            pts -= AudioBufferTime*queue_size;
+            pts += std::chrono::duration_cast<nanoseconds>(
+                fixed32(offset[0] / mCodecCtx->sample_rate)
+            );
+        }
         if(status == AL_PLAYING)
-            pts -= offset[1];
+            pts -= nanoseconds(offset[1]);
     }
     lock.unlock();
 
-    return std::max(pts, 0.0);
+    return std::max(pts, std::chrono::nanoseconds::zero());
 }
 
 int AudioState::getSync()
 {
-    double diff, avg_diff, ref_clock;
+    using seconds = std::chrono::duration<double>;
+    double avg_diff;
 
-    if(mMovie->mAVSyncType == AV_SYNC_AUDIO_MASTER)
+    if(mMovie->mAVSyncType == SyncMaster::Audio)
         return 0;
 
-    ref_clock = mMovie->getMasterClock();
-    diff = ref_clock - getClock();
+    auto ref_clock = mMovie->getMasterClock();
+    auto diff = seconds(ref_clock - getClock());
 
-    if(!(fabs(diff) < AV_NOSYNC_THRESHOLD))
+    if(!(diff < AVNoSyncThreshold && diff > -AVNoSyncThreshold))
     {
         /* Difference is TOO big; reset diff stuff */
         mDiff.Accum = 0.0;
@@ -382,17 +387,17 @@ int AudioState::getSync()
     }
 
     /* Accumulate the diffs */
-    mDiff.Accum = mDiff.Accum*mDiff.AvgCoeff + diff;
+    mDiff.Accum = mDiff.Accum*mDiff.AvgCoeff + diff.count();
     avg_diff = mDiff.Accum*(1.0 - mDiff.AvgCoeff);
     if(fabs(avg_diff) < mDiff.Threshold)
         return 0;
 
     /* Constrain the per-update difference to avoid exceedingly large skips */
-    if(!(diff <= SAMPLE_CORRECTION_MAX_DIFF))
-        diff = SAMPLE_CORRECTION_MAX_DIFF;
-    else if(!(diff >= -SAMPLE_CORRECTION_MAX_DIFF))
-        diff = -SAMPLE_CORRECTION_MAX_DIFF;
-    return (int)(diff*mCodecCtx->sample_rate);
+    if(!(diff.count() < SAMPLE_CORRECTION_MAX_DIFF))
+        return (int)(SAMPLE_CORRECTION_MAX_DIFF * mCodecCtx->sample_rate);
+    if(!(diff.count() > -SAMPLE_CORRECTION_MAX_DIFF))
+        return (int)(-SAMPLE_CORRECTION_MAX_DIFF * mCodecCtx->sample_rate);
+    return (int)(diff.count()*mCodecCtx->sample_rate);
 }
 
 int AudioState::decodeFrame()
@@ -425,7 +430,9 @@ int AudioState::decodeFrame()
         /* If provided, update w/ pts */
         int64_t pts = av_frame_get_best_effort_timestamp(mDecodedFrame);
         if(pts != AV_NOPTS_VALUE)
-            mCurrentPts = av_q2d(mStream->time_base)*pts;
+            mCurrentPts = std::chrono::duration_cast<std::chrono::nanoseconds>(
+                std::chrono::duration<double>(av_q2d(mStream->time_base)*pts)
+            );
 
         if(mDecodedFrame->nb_samples > mSamplesMax)
         {
@@ -477,6 +484,9 @@ static void sample_dup(uint8_t *out, const uint8_t *in, int count, int frame_siz
 
 int AudioState::readAudio(uint8_t *samples, int length)
 {
+    using seconds = std::chrono::duration<int64_t>;
+    using nanoseconds = std::chrono::nanoseconds;
+
     int sample_skip = getSync();
     int audio_size = 0;
 
@@ -494,7 +504,7 @@ int AudioState::readAudio(uint8_t *samples, int length)
             mSamplesPos = std::min(mSamplesLen, sample_skip);
             sample_skip -= mSamplesPos;
 
-            mCurrentPts += (double)mSamplesPos / (double)mCodecCtx->sample_rate;
+            mCurrentPts += nanoseconds(seconds(mSamplesPos)) / mCodecCtx->sample_rate;
             continue;
         }
 
@@ -521,7 +531,7 @@ int AudioState::readAudio(uint8_t *samples, int length)
         }
 
         mSamplesPos += rem;
-        mCurrentPts += (double)rem / mCodecCtx->sample_rate;
+        mCurrentPts += nanoseconds(seconds(rem)) / mCodecCtx->sample_rate;
         samples += rem*mFrameSize;
         audio_size += rem;
     }
@@ -531,7 +541,7 @@ int AudioState::readAudio(uint8_t *samples, int length)
         int rem = length - audio_size;
         std::fill_n(samples, rem*mFrameSize,
                     (mDstSampleFmt == AV_SAMPLE_FMT_U8) ? 0x80 : 0x00);
-        mCurrentPts += (double)rem / mCodecCtx->sample_rate;
+        mCurrentPts += nanoseconds(seconds(rem)) / mCodecCtx->sample_rate;
         audio_size += rem;
     }
 
@@ -649,8 +659,8 @@ int AudioState::handler()
             mFormat = AL_FORMAT_STEREO16;
         }
     }
-    ALsizei buffer_len = mCodecCtx->sample_rate * AUDIO_BUFFER_TIME / 1000 *
-            mFrameSize;
+    ALsizei buffer_len = std::chrono::duration_cast<std::chrono::duration<int>>(
+        mCodecCtx->sample_rate * AudioBufferTime).count() * mFrameSize;
     void *samples = av_malloc(buffer_len);
 
     mSamples = NULL;
@@ -741,7 +751,7 @@ int AudioState::handler()
         /* (re)start the source if needed, and wait for a buffer to finish */
         if(state != AL_PLAYING && state != AL_PAUSED)
             alSourcePlay(mSource);
-        SDL_Delay(AUDIO_BUFFER_TIME / 3);
+        SDL_Delay((AudioBufferTime/3).count());
 
         lock.lock();
     }
@@ -759,9 +769,9 @@ finish:
 }
 
 
-double VideoState::getClock()
+std::chrono::nanoseconds VideoState::getClock()
 {
-    double delta = (av_gettime() - mCurrentPtsTime) / 1000000.0;
+    auto delta = std::chrono::microseconds(av_gettime()) - mCurrentPtsTime;
     return mCurrentPts + delta;
 }
 
@@ -775,9 +785,9 @@ Uint32 SDLCALL VideoState::sdl_refresh_timer_cb(Uint32 /*interval*/, void *opaqu
 }
 
 /* Schedules an FF_REFRESH_EVENT event to occur in 'delay' ms. */
-void VideoState::schedRefresh(int delay)
+void VideoState::schedRefresh(std::chrono::milliseconds delay)
 {
-    SDL_AddTimer(delay, sdl_refresh_timer_cb, this);
+    SDL_AddTimer(delay.count(), sdl_refresh_timer_cb, this);
 }
 
 /* Called by VideoState::refreshTimer to display the next video frame. */
@@ -834,7 +844,7 @@ void VideoState::refreshTimer(SDL_Window *screen, SDL_Renderer *renderer)
             mPictQCond.notify_all();
             return;
         }
-        schedRefresh(100);
+        schedRefresh(std::chrono::milliseconds(100));
         return;
     }
 
@@ -845,7 +855,7 @@ retry:
         if(mEOS)
             mFinalUpdate = true;
         else
-            schedRefresh(1);
+            schedRefresh(std::chrono::milliseconds(1));
         lock.unlock();
         mPictQCond.notify_all();
         return;
@@ -853,11 +863,11 @@ retry:
 
     Picture *vp = &mPictQ[mPictQRead];
     mCurrentPts = vp->mPts;
-    mCurrentPtsTime = av_gettime();
+    mCurrentPtsTime = std::chrono::microseconds(av_gettime());
 
     /* Get delay using the frame pts and the pts from last frame. */
-    double delay = vp->mPts - mFrameLastPts;
-    if(delay <= 0 || delay >= 1.0)
+    auto delay = vp->mPts - mFrameLastPts;
+    if(delay <= std::chrono::seconds::zero() || delay >= std::chrono::seconds(1))
     {
         /* If incorrect delay, use previous one. */
         delay = mFrameLastDelay;
@@ -867,33 +877,35 @@ retry:
     mFrameLastPts = vp->mPts;
 
     /* Update delay to sync to clock if not master source. */
-    if(mMovie->mAVSyncType != AV_SYNC_VIDEO_MASTER)
+    if(mMovie->mAVSyncType != SyncMaster::Video)
     {
-        double ref_clock = mMovie->getMasterClock();
-        double diff = vp->mPts - ref_clock;
+        using seconds = std::chrono::duration<double>;
+
+        auto ref_clock = mMovie->getMasterClock();
+        auto diff = seconds(vp->mPts - ref_clock);
 
         /* Skip or repeat the frame. Take delay into account. */
-        double sync_threshold = std::min(delay, AV_SYNC_THRESHOLD);
-        if(fabs(diff) < AV_NOSYNC_THRESHOLD)
+        auto sync_threshold = std::min(seconds(delay), AVSyncThreshold);
+        if(!(diff < AVNoSyncThreshold && diff > -AVNoSyncThreshold))
         {
             if(diff <= -sync_threshold)
-                delay = 0;
+                delay = std::chrono::nanoseconds::zero();
             else if(diff >= sync_threshold)
-                delay *= 2.0;
+                delay *= 2;
         }
     }
 
     mFrameTimer += delay;
     /* Compute the REAL delay. */
-    double actual_delay = mFrameTimer - (av_gettime() / 1000000.0);
-    if(!(actual_delay >= 0.010))
+    auto actual_delay = mFrameTimer - std::chrono::microseconds(av_gettime());
+    if(!(actual_delay >= AVSyncThreshold))
     {
         /* We don't have time to handle this picture, just skip to the next one. */
         mPictQRead = (mPictQRead+1)%mPictQ.size();
         mPictQSize--;
         goto retry;
     }
-    schedRefresh((int)(actual_delay*1000.0 + 0.5));
+    schedRefresh(std::chrono::duration_cast<std::chrono::milliseconds>(actual_delay));
 
     /* Show the picture! */
     display(screen, renderer);
@@ -1001,7 +1013,7 @@ void VideoState::updatePicture(SDL_Window *screen, SDL_Renderer *renderer)
     mPictQCond.notify_one();
 }
 
-int VideoState::queuePicture(double pts)
+int VideoState::queuePicture(std::chrono::nanoseconds pts)
 {
     /* Wait until we have space for a new pic */
     std::unique_lock<std::mutex> lock(mPictQMutex);
@@ -1036,20 +1048,20 @@ int VideoState::queuePicture(double pts)
     return 0;
 }
 
-double VideoState::synchronize(double pts)
+std::chrono::nanoseconds VideoState::synchronize(std::chrono::nanoseconds pts)
 {
-    double frame_delay;
-
-    if(pts == 0.0) /* if we aren't given a pts, set it to the clock */
+    if(pts == std::chrono::nanoseconds::zero()) /* if we aren't given a pts, set it to the clock */
         pts = mClock;
     else /* if we have pts, set video clock to it */
         mClock = pts;
 
     /* update the video clock */
-    frame_delay = av_q2d(mCodecCtx->time_base);
+    auto frame_delay = av_q2d(mCodecCtx->time_base);
     /* if we are repeating a frame, adjust clock accordingly */
     frame_delay += mDecodedFrame->repeat_pict * (frame_delay * 0.5);
-    mClock += frame_delay;
+
+    mClock += std::chrono::duration_cast<std::chrono::nanoseconds>(
+        std::chrono::duration<double>(frame_delay));
     return pts;
 }
 
@@ -1077,8 +1089,12 @@ int VideoState::handler()
             break;
         }
 
-        double pts = synchronize(
-            av_q2d(mStream->time_base) * av_frame_get_best_effort_timestamp(mDecodedFrame)
+        std::chrono::nanoseconds pts = synchronize(
+            std::chrono::duration_cast<std::chrono::nanoseconds>(
+                std::chrono::duration<double>(
+                    av_q2d(mStream->time_base) * av_frame_get_best_effort_timestamp(mDecodedFrame)
+                )
+            )
         );
         if(queuePicture(pts) < 0)
             break;
@@ -1132,7 +1148,7 @@ bool MovieState::prepare()
         return false;
     }
 
-    mVideo.schedRefresh(40);
+    mVideo.schedRefresh(std::chrono::milliseconds(40));
 
     mParseThread = std::thread(std::mem_fn(&MovieState::parse_handler), this);
     return true;
@@ -1148,16 +1164,17 @@ void MovieState::setTitle(SDL_Window *window)
     SDL_SetWindowTitle(window, (mFilename.substr(fpos)+" - "+AppName).c_str());
 }
 
-double MovieState::getClock()
+std::chrono::nanoseconds MovieState::getClock()
 {
-    return (av_gettime()-mExternalClockBase) / 1000000.0;
+    using microseconds = std::chrono::microseconds;
+    return microseconds(av_gettime()) - mClockBase;
 }
 
-double MovieState::getMasterClock()
+std::chrono::nanoseconds MovieState::getMasterClock()
 {
-    if(mAVSyncType == AV_SYNC_VIDEO_MASTER)
+    if(mAVSyncType == SyncMaster::Video)
         return mVideo.getClock();
-    if(mAVSyncType == AV_SYNC_AUDIO_MASTER)
+    if(mAVSyncType == SyncMaster::Audio)
         return mAudio.getClock();
     return getClock();
 }
@@ -1207,9 +1224,9 @@ int MovieState::streamComponentOpen(int stream_index)
             mVideo.mStream = mFormatCtx->streams[stream_index];
             mVideo.mCodecCtx = avctx;
 
-            mVideo.mCurrentPtsTime = av_gettime();
-            mVideo.mFrameTimer = (double)mVideo.mCurrentPtsTime / 1000000.0;
-            mVideo.mFrameLastDelay = 40e-3;
+            mVideo.mCurrentPtsTime = std::chrono::microseconds(av_gettime());
+            mVideo.mFrameTimer = mVideo.mCurrentPtsTime;
+            mVideo.mFrameLastDelay = std::chrono::milliseconds(40);
 
             mVideoThread = std::thread(std::mem_fn(&VideoState::handler), &mVideo);
             break;
@@ -1241,7 +1258,7 @@ int MovieState::parse_handler()
     /* Start the external clock in 50ms, to give the audio and video
      * components time to start without needing to skip ahead.
      */
-    mExternalClockBase = av_gettime() + 50000;
+    mClockBase = std::chrono::microseconds(av_gettime() + 50000);
     if(audio_index >= 0) audio_index = streamComponentOpen(audio_index);
     if(video_index >= 0) video_index = streamComponentOpen(video_index);