Changeset 42162

Timestamp:

04/12/18 15:06:43 (5 years ago)

Author:

obi

Message:

update libeplayer3 to v47

Location:

titan/libeplayer3

Files:

• container/container_ffmpeg.c (modified) (33 diffs)
• container/flv2mpeg4_ffmpeg.c (modified) (1 diff)
• container/mpeg4p2_ffmpeg.c (modified) (1 diff)
• include/common.h (modified) (2 diffs)
• include/manager.h (modified) (1 diff)
• include/output.h (modified) (2 diffs)
• include/playback.h (modified) (1 diff)
• include/writer.h (modified) (3 diffs)
• main/exteplayer.c (modified) (17 diffs)
• output/linuxdvb_mipsel.c (modified) (56 diffs)
• output/output.c (modified) (2 diffs)
• output/writer/mipsel/aac.c (modified) (5 diffs)
• output/writer/mipsel/h264.c (modified) (8 diffs)
• output/writer/mipsel/h265.c (modified) (3 diffs)
• output/writer/mipsel/lpcm.c (modified) (1 diff)
• output/writer/mipsel/mpeg4.c (modified) (2 diffs)
• output/writer/mipsel/vp.c (modified) (2 diffs)
• output/writer/mipsel/wmv.c (modified) (1 diff)
• output/writer/mipsel/writer.c (modified) (2 diffs)
• output/writer/sh4/aac.c (modified) (1 diff)
• output/writer/sh4/h264.c (modified) (4 diffs)
• playback/playback.c (modified) (3 diffs)

titan/libeplayer3/container/container_ffmpeg.c

@@ -146 +146 @@
 static int32_t seek_target_flag = 0;
 
+static int32_t mutexInitialized = 0;
+
 /* ***************************** */
 /* Prototypes                    */
@@ -164 +166 @@
     progressive_playback = val;
 }
+
+static void initMutex(void)
+{
+    pthread_mutex_init(&mutex, NULL);
+    mutexInitialized = 1;
+}
+
+static void getMutex(const char *filename __attribute__((unused)), const char *function __attribute__((unused)), int32_t line)
+{
+    ffmpeg_printf(100, "::%d requesting mutex\n", line);
+
+    if (!mutexInitialized)
+    {
+        initMutex();
+    }
+
+    pthread_mutex_lock(&mutex);
+
+    ffmpeg_printf(100, "::%d received mutex\n", line);
+}
+
+static void releaseMutex(const char *filename __attribute__((unused)), const const char *function __attribute__((unused)), int32_t line) 
+{
+    pthread_mutex_unlock(&mutex);
+
+    ffmpeg_printf(100, "::%d released mutex\n", line);
+}
+
+typedef int32_t (* Write_FN) (void  *, void *);
+
+static int32_t Write(Write_FN WriteFun, void *context, void *privateData, int64_t pts)
+{
+    /* Because Write is blocking we will release mutex which protect 
+     * avformat structures, during write time
+     */
+    int32_t ret = 0;
+    releaseMutex(__FILE__, __FUNCTION__,__LINE__);
+    ret = WriteFun(context, privateData);
+    getMutex(__FILE__, __FUNCTION__,__LINE__);
+    return ret;
+}
+
 
 #include "buff_ffmpeg.c"
@@ -426 +470 @@
 }
 
-static int32_t mutexInitialized = 0;
+//static int32_t mutexInitialized = 0;
 
 void sel_program_id_set(const int32_t val)
@@ -496 +540 @@
 {
     return av_dict_set(&avio_opts, key, value, flags);
-}
-
-static void initMutex(void)
-{
-    pthread_mutex_init(&mutex, NULL);
-    mutexInitialized = 1;
-}
-
-static void getMutex(const char *filename __attribute__((unused)), const char *function __attribute__((unused)), int32_t line)
-{
-    ffmpeg_printf(100, "::%d requesting mutex\n", line);
-
-    if (!mutexInitialized)
-    {
-        initMutex();
-    }
-
-    pthread_mutex_lock(&mutex);
-
-    ffmpeg_printf(100, "::%d received mutex\n", line);
-}
-
-static void releaseMutex(const char *filename __attribute__((unused)), const const char *function __attribute__((unused)), int32_t line) 
-{
-    pthread_mutex_unlock(&mutex);
-
-    ffmpeg_printf(100, "::%d released mutex\n", line);
 }
 
@@ -703 +720 @@
         pts = INVALID_PTS_VALUE;
     }
+    else
+    {
+        pts &= 0x01FFFFFFFF; // PES header can handle only 33 bit PTS
+    }
 
     return pts;
@@ -798 +819 @@
     while ( context && context->playback && context->playback->isPlaying ) 
     {
+        /* When user press PAUSE we call pause on AUDIO and VIDEO decoders, 
+         * we will not wait here because we can still fill 
+         * DVB drivers buffers at PAUSE time
+         * 
+         * In the future we can add buffering queue before injection in to 
+         * AUDIO, VIDEO decoders, so we can not wait here
+         */
+#ifdef __sh__
         //IF MOVIE IS PAUSED, WAIT
         if (context->playback->isPaused) 
@@ -806 +835 @@
             continue;
         }
+#endif
 
         if (context->playback->isSeeking) 
@@ -929 +959 @@
             
             reset_finish_timeout();
-
-            if (context->manager->video->Command(context, MANAGER_GET_TRACK, &videoTrack) < 0)
-            {
-                ffmpeg_err("error getting video track\n");
+            if(avContextTab[cAVIdx]->streams[packet.stream_index]->discard != AVDISCARD_ALL)
+            {
+                if (context->manager->video->Command(context, MANAGER_GET_TRACK, &videoTrack) < 0)
+                {
+                    ffmpeg_err("error getting video track\n");
+                }
+                
+                if (context->manager->audio->Command(context, MANAGER_GET_TRACK, &audioTrack) < 0)
+                {
+                    ffmpeg_err("error getting audio track\n");
+                }
+                
+                if (context->manager->subtitle->Command(context, MANAGER_GET_TRACK, &subtitleTrack) < 0)
+                {
+                    ffmpeg_err("error getting subtitle track\n");
+                }
+            }
+            else
+            {
+                ffmpeg_printf(1, "SKIP DISCARDED PACKET stream_index[%d] pid[%d]\n", packet.size, (int)packet.stream_index, pid);
             }
             
-            if (context->manager->audio->Command(context, MANAGER_GET_TRACK, &audioTrack) < 0)
-            {
-                ffmpeg_err("error getting audio track\n");
-            }
-            
-            if (context->manager->subtitle->Command(context, MANAGER_GET_TRACK, &subtitleTrack) < 0)
-            {
-                ffmpeg_err("error getting subtitle track\n");
-            }
-
             ffmpeg_printf(200, "packet.size %d - index %d\n", packet.size, pid);
 
@@ -1037 +1073 @@
                     }
 
-                    if (context->output->video->Write(context, &avOut) < 0)
+                    if (Write(context->output->video->Write, context, &avOut, pts) < 0)
                     {
                         ffmpeg_err("writing data to video device failed\n");
@@ -1113 +1149 @@
                     avOut.type       = "audio";
 
-                    if (context->output->audio->Write(context, &avOut) < 0)
+                    if (Write(context->output->audio->Write, context, &avOut, pts) < 0)
                     {
                         ffmpeg_err("(raw pcm) writing data to audio device failed\n");
@@ -1308 +1344 @@
                         avOut.type       = "audio";
 
-                        if (!context->playback->BackWard && context->output->audio->Write(context, &avOut) < 0)
+                        if (!context->playback->BackWard && Write(context->output->audio->Write, context, &avOut, pts) < 0)
                         {
                             ffmpeg_err("writing data to audio device failed\n");
@@ -1331 +1367 @@
                     avOut.type       = "audio";
 
-                    if (!context->playback->BackWard && context->output->audio->Write(context, &avOut) < 0)
+                    if (!context->playback->BackWard && Write(context->output->audio->Write, context, &avOut, pts) < 0)
                     {
                         ffmpeg_err("(aac) writing data to audio device failed\n");
@@ -1349 +1385 @@
                     avOut.type       = "audio";
 
-                    if (!context->playback->BackWard && context->output->audio->Write(context, &avOut) < 0)
+                    if (!context->playback->BackWard && Write(context->output->audio->Write, context, &avOut, pts) < 0)
                     {
                         ffmpeg_err("writing data to audio device failed\n");
@@ -1397 +1433 @@
                     //obi (end)
 
-                    if (context->output->subtitle->Write(context, &subOut) < 0)
+                    if (Write(context->output->subtitle->Write, context, &subOut, pts) < 0)
                     {
                         ffmpeg_err("writing data to teletext fifo failed\n");
@@ -1545 +1581 @@
 
 #ifdef SAM_CUSTOM_IO
+typedef struct CustomIOCtx_t 
+{ 
+    FILE *pFile;
+    FILE *pMoovFile;
+    int64_t iOffset;
+    
+    char *szFile;
+    uint64_t iFileSize;
+    char *szMoovAtomFile;
+    uint64_t iMoovAtomOffset;
+} CustomIOCtx_t;
+
+CustomIOCtx_t* custom_io_tab[IPTV_AV_CONTEXT_MAX_NUM] = {NULL, NULL};
+
 int SAM_ReadFunc(void *ptr, uint8_t *buffer, int lSize)
 {
-    size_t ret = fread ( (void *) buffer, (size_t) 1, (size_t) lSize, (FILE *)ptr );
-    return (int)ret;
+    CustomIOCtx_t *io = (CustomIOCtx_t *)ptr;
+    int ret = 0;
+    
+    if (!io->pMoovFile)
+    {
+        ret = (int)fread( (void *) buffer, (size_t) 1, (size_t) lSize, io->pFile );
+    }
+    else
+    {
+        if (io->iOffset < io->iMoovAtomOffset)
+        {
+            ret = (int)fread( (void *) buffer, (size_t) 1, (size_t) lSize, io->pFile );
+            buffer += ret;
+            lSize -= ret;
+        }
+        
+        if (io->iOffset + ret >= io->iMoovAtomOffset)
+        {
+            if (ret)
+            {
+                if (fseeko(io->pMoovFile, io->iOffset + ret - io->iMoovAtomOffset, SEEK_SET))
+                {
+                    // something goes wrong
+                    ffmpeg_err("fseeko on moov atom file fail \n");
+                    lSize = 0;
+                }
+            }
+            
+            ret += (int)fread( (void *) buffer, (size_t) 1, (size_t) lSize, io->pMoovFile );
+        }
+        
+        io->iOffset += ret;
+    }
+    return ret;
 }
 
 // whence: SEEK_SET, SEEK_CUR, SEEK_END (like fseek) and AVSEEK_SIZE
-int64_t SAM_SeekFunc(void* ptr, int64_t pos, int whence)
+int64_t SAM_SeekFunc(void *ptr, int64_t pos, int whence)
 {   
-    if( AVSEEK_SIZE == whence )
-    {
-        return -1;
-    }
-    int ret = fseeko((FILE *)ptr, (off_t)pos, whence);
-    if(0 == ret)
-    {
-        return (off_t)ftello((FILE *)ptr);
+    CustomIOCtx_t *io = (CustomIOCtx_t *)ptr;
+    int64_t ret = -1;
+    if (!io->pMoovFile)
+    {
+        if( AVSEEK_SIZE != whence )
+        {
+            ret = (int64_t)fseeko(io->pFile, (off_t)pos, whence);
+            if(0 == ret)
+            {
+                ret = (int64_t)ftello(io->pFile);
+            }
+        }
+    }
+    else
+    {
+        switch(whence)
+        {
+            case SEEK_SET:
+                ret = pos;
+                break;
+            case SEEK_CUR:
+                ret += pos;
+                break;
+            case SEEK_END:
+                ret = io->iFileSize + pos;
+                break;
+            case AVSEEK_SIZE:
+                return io->iFileSize;
+            default:
+                return -1;
+        }
+        
+        if (ret >= 0 && ret <= io->iFileSize)
+        {
+            if (ret < io->iMoovAtomOffset)
+            {
+                if(!fseeko(io->pFile, (off_t)ret, SEEK_SET))
+                    io->iOffset = ret;
+                else
+                    ret = -1;
+            }
+            else
+            {
+                if(!fseeko(io->pMoovFile, (off_t)(ret - io->iMoovAtomOffset), SEEK_SET))
+                    io->iOffset = ret;
+                else
+                    ret = -1;
+            }
+        }
+        else
+        {
+            ret = -1;
+        }
     }
     return ret;
 }
 
-AVIOContext* container_ffmpeg_get_avio_context(char *filename, size_t avio_ctx_buffer_size)
-{
-        if(strstr(filename, "file://") == filename)
-        {
-            filename += 7;
-        }
+AVIOContext* container_ffmpeg_get_avio_context(CustomIOCtx_t *custom_io, size_t avio_ctx_buffer_size)
+{
+    if(strstr(custom_io->szFile, "file://") == custom_io->szFile)
+        custom_io->szFile += 7;
+    
+    custom_io->pFile = fopen(custom_io->szFile, "rb");
+    if(NULL == custom_io->pFile)
+    {
+        return NULL;
+    }
+    
+    if (custom_io->szMoovAtomFile && custom_io->szMoovAtomFile[0] != '\0')
+    {
+        if(strstr(custom_io->szMoovAtomFile, "file://") == custom_io->szMoovAtomFile)
+            custom_io->szMoovAtomFile += 7;
         
-        FILE *pFile = fopen(filename, "rb");
-        if(NULL == pFile)
-        {
+        custom_io->pMoovFile = fopen(custom_io->szMoovAtomFile, "rb");
+        if(NULL == custom_io->pMoovFile)
+        {
+            fclose(custom_io->pFile);
             return NULL;
         }
-        
-        AVIOContext *avio_ctx = NULL;
-        uint8_t *avio_ctx_buffer = NULL;
-        
-        avio_ctx_buffer = av_malloc(avio_ctx_buffer_size);
-        if (!avio_ctx_buffer) 
-        {
-            return NULL;
-        }
-        avio_ctx = avio_alloc_context(avio_ctx_buffer, avio_ctx_buffer_size, 0, pFile, &SAM_ReadFunc, NULL, &SAM_SeekFunc);
-        if (!avio_ctx) 
-        {
-            return NULL;
-        }
-        return avio_ctx;
+    }
+    
+    AVIOContext *avio_ctx = NULL;
+    uint8_t *avio_ctx_buffer = NULL;
+    
+    avio_ctx_buffer = av_malloc(avio_ctx_buffer_size);
+    if (!avio_ctx_buffer) 
+    {
+        return NULL;
+    }
+    avio_ctx = avio_alloc_context(avio_ctx_buffer, avio_ctx_buffer_size, 0, custom_io, &SAM_ReadFunc, NULL, &SAM_SeekFunc);
+    if (!avio_ctx) 
+    {
+        return NULL;
+    }
+    return avio_ctx;
 }
 #endif
 
-int32_t container_ffmpeg_init_av_context(Context_t *context, char *filename, int32_t AVIdx)
+int32_t container_ffmpeg_init_av_context(Context_t *context, char *filename, uint64_t fileSize, char *moovAtomFile, uint64_t moovAtomOffset, int32_t AVIdx)
 {
     int32_t err = 0;
@@ -1608 +1746 @@
        0 == strncmp(filename, "file://", 7))
     {
-        AVIOContext *avio_ctx = container_ffmpeg_get_avio_context(filename, 4096);
+        AVIOContext *avio_ctx = NULL;
+        custom_io_tab[AVIdx] = malloc(sizeof(CustomIOCtx_t));
+        sizeof(custom_io_tab[AVIdx], 0x00, sizeof(CustomIOCtx_t));
+        
+        custom_io_tab[AVIdx]->szFile = filename;
+        custom_io_tab[AVIdx]->iFileSize = fileSize;
+        custom_io_tab[AVIdx]->szMoovAtomFile = moovAtomFile;
+        custom_io_tab[AVIdx]->iMoovAtomOffset = moovAtomOffset;
+        
+        avio_ctx = container_ffmpeg_get_avio_context(custom_io_tab[AVIdx], 4096);
         if(avio_ctx)
         {
@@ -1616 +1763 @@
         else
         {
+            free(custom_io_tab[AVIdx]);
+            custom_io_tab[AVIdx] = NULL;
             return cERR_CONTAINER_FFMPEG_OPEN;
         }
@@ -2154 +2303 @@
  
     context->playback->abortRequested = 0;
-    int32_t res = container_ffmpeg_init_av_context(context, playFilesNames->szFirstFile, 0);
+    int32_t res = container_ffmpeg_init_av_context(context, playFilesNames->szFirstFile, playFilesNames->iFirstFileSize, \
+                                                   playFilesNames->szFirstMoovAtomFile, playFilesNames->iFirstMoovAtomOffset, 0);
     if(0 != res)
     {
@@ -2160 +2310 @@
     }
 
-    if(playFilesNames->szSecondFile)
-    {
-        res = container_ffmpeg_init_av_context(context, playFilesNames->szSecondFile, 1);
+    if(playFilesNames->szSecondFile && playFilesNames->szSecondFile[0] != '\0')
+    {
+        res = container_ffmpeg_init_av_context(context, playFilesNames->szSecondFile, playFilesNames->iSecondFileSize, \
+                                               playFilesNames->szSecondMoovAtomFile, playFilesNames->iSecondMoovAtomOffset, 1);
     }
     
@@ -2183 +2334 @@
 int32_t container_ffmpeg_update_tracks(Context_t *context, char *filename, int32_t initial)
 {
-    Track_t *audioTrack = NULL;
-    Track_t *subtitleTrack = NULL;
+    Track_t *currAudioTrack = NULL;
+    Track_t *currSubtitleTrack = NULL;
+    uint32_t addedVideoTracksCount = 0;
     
     if (terminating)
@@ -2191 +2343 @@
     }
     
+    getMutex(__FILE__, __FUNCTION__,__LINE__);
+    
     if (initial && context->manager->subtitle)
     {
-        context->manager->subtitle->Command(context, MANAGER_GET_TRACK, &subtitleTrack);
+        context->manager->subtitle->Command(context, MANAGER_GET_TRACK, &currSubtitleTrack);
     }
 
     if (context->manager->audio)
     {
-        context->manager->audio->Command(context, MANAGER_GET_TRACK, &audioTrack);
+        context->manager->audio->Command(context, MANAGER_GET_TRACK, &currAudioTrack);
     }
 
@@ -2217 +2371 @@
     }
 #endif
-
 
     ffmpeg_printf(20, "dump format\n");
@@ -2295 +2448 @@
                 }
                 
-                if (!isStreamFromSelProg)
+                if (!isStreamFromSelProg) {
+                    stream->discard = AVDISCARD_ALL;
+                    ffmpeg_printf(1, "cAVIdx[%d]: add DISCARD flag to  stream index[%d]\n", cAVIdx, stream->index);
                     continue; // skip this stream
+                }
             }
 
@@ -2329 +2485 @@
             case AVMEDIA_TYPE_VIDEO:
                 ffmpeg_printf(10, "CODEC_TYPE_VIDEO %d\n", get_codecpar(stream)->codec_type);
-
+                stream->discard = AVDISCARD_ALL; /* by default we discard all video streams */
                 if (encoding != NULL) 
                 {
@@ -2409 +2565 @@
                             ffmpeg_err("failed to add track %d\n", n);
                         }
+                        else
+                        {
+                            if (addedVideoTracksCount == 0) /* at now we can handle only first video track */
+                            {
+                                stream->discard = AVDISCARD_DEFAULT;
+                            }
+                            addedVideoTracksCount += 1;
+                        }
                     }
                 }
@@ -2418 +2582 @@
             case AVMEDIA_TYPE_AUDIO:
                 ffmpeg_printf(10, "CODEC_TYPE_AUDIO %d\n",get_codecpar(stream)->codec_type);
-
+                stream->discard = AVDISCARD_ALL;
                 if (encoding != NULL)
                 {
@@ -2790 +2954 @@
             case AVMEDIA_TYPE_NB:
             default:
+                stream->discard = AVDISCARD_ALL;
                 ffmpeg_err("not handled or unknown codec_type %d\n", get_codecpar(stream)->codec_type);
              break;
@@ -2796 +2961 @@
     
     }
-
+    
+    if (context->manager->audio)
+    {
+        Track_t *Tracks = NULL;
+        int32_t TrackCount = 0;
+        int32_t selTrackIdx = -1;
+        
+        context->manager->audio->Command(context, MANAGER_REF_LIST, &Tracks);
+        context->manager->audio->Command(context, MANAGER_REF_LIST_SIZE, &TrackCount);
+        if (Tracks && TrackCount)
+        {
+            int32_t i;
+            for (i=0; i < TrackCount; ++i)
+            {
+                if (Tracks[i].pending || Tracks[i].Id < 0)
+                    continue;
+                
+                if (selTrackIdx == -1)
+                    selTrackIdx = i;
+                    
+                if (currAudioTrack && currAudioTrack->Id == Tracks[i].Id)
+                {
+                    selTrackIdx = i;
+                    break;
+                }
+            }
+            
+            if (selTrackIdx > -1)
+            {
+                ((AVStream*)Tracks[selTrackIdx].stream)->discard = AVDISCARD_DEFAULT;
+                if (!currAudioTrack || currAudioTrack->Id != Tracks[selTrackIdx].Id )
+                {
+                    context->manager->audio->Command(context, MANAGER_SET, &Tracks[selTrackIdx].Id);
+                }
+            }
+        }
+    }
+    
+    releaseMutex(__FILE__, __FUNCTION__,__LINE__);
     return cERR_CONTAINER_FFMPEG_NO_ERROR;
 }
@@ -3119 +3322 @@
     }
 
-    getMutex(__FILE__, __FUNCTION__,__LINE__);
+//    getMutex(__FILE__, __FUNCTION__,__LINE__);
 
     if (!context->playback || !context->playback->isPlaying)
@@ -3138 +3341 @@
         */
 
+        getMutex(__FILE__, __FUNCTION__,__LINE__);
         off_t pos = avio_tell(avContextTab[0]->pb);
+        releaseMutex(__FILE__, __FUNCTION__,__LINE__);
 
         ffmpeg_printf(10, "pos %lld %d\n", pos, avContextTab[0]->bit_rate);
@@ -3172 +3377 @@
     }
 
-    releaseMutex(__FILE__, __FUNCTION__,__LINE__);
+//    releaseMutex(__FILE__, __FUNCTION__,__LINE__);
     return cERR_CONTAINER_FFMPEG_NO_ERROR;
 }
@@ -3233 +3438 @@
 {
     ffmpeg_printf(10, "track %d\n", *arg);
+    getMutex(__FILE__, __FUNCTION__,__LINE__);
+    if (context->manager->audio)
+    {
+        Track_t *Tracks = NULL;
+        int32_t TrackCount = 0;
+        
+        context->manager->audio->Command(context, MANAGER_REF_LIST, &Tracks);
+        context->manager->audio->Command(context, MANAGER_REF_LIST_SIZE, &TrackCount);
+        if (Tracks && TrackCount)
+        {
+            int32_t i;
+            for (i=0; i < TrackCount; ++i)
+            {
+                ((AVStream*)Tracks[i].stream)->discard = Tracks[i].Id == *arg ? AVDISCARD_DEFAULT : AVDISCARD_ALL;
+            }
+        }
+    }
+    releaseMutex(__FILE__, __FUNCTION__,__LINE__);
     
     /* Hellmaster1024: nothing to do here!*/
-    int64_t sec = -5;
+    int64_t sec = -1;
     context->playback->Command(context, PLAYBACK_SEEK, (void*)&sec);
     return cERR_CONTAINER_FFMPEG_NO_ERROR;
@@ -3249 +3472 @@
      * but now we will not ignore subtitle frame
      */
-    int64_t sec = -5;
+    int64_t sec = -1;
     context->playback->Command(context, PLAYBACK_SEEK, (void*)&sec);
     //obi

titan/libeplayer3/container/flv2mpeg4_ffmpeg.c

@@ -39 +39 @@
     avOut.type       = "video";
 
-    if (ctx->out_ctx->output->video->Write(ctx->out_ctx, &avOut) < 0)
+    if (Write(ctx->out_ctx->output->video->Write, ctx->out_ctx, &avOut, avOut.pts) < 0)
     {
         ffmpeg_err("writing data to video device failed\n");

titan/libeplayer3/container/mpeg4p2_ffmpeg.c

@@ -112 +112 @@
     avOut.type       = "video";
 
-    if (ctx->output->video->Write(ctx, &avOut) < 0)
+    if (Write(ctx->output->video->Write, ctx, &avOut, avOut.pts) < 0)
     {
         ffmpeg_err("writing data to video device failed\n");

titan/libeplayer3/include/common.h

@@ -10 +10 @@
 #include <pthread.h>
 
-typedef char PlayFilesTab_t[2];
+//typedef char PlayFilesTab_t[2];
 
 typedef struct PlayFiles_t 
@@ -16 +16 @@
     char *szFirstFile;
     char *szSecondFile;
+    char *szFirstMoovAtomFile;
+    char *szSecondMoovAtomFile;
+    uint64_t iFirstFileSize;
+    uint64_t iSecondFileSize;
+    uint64_t iFirstMoovAtomOffset;
+    uint64_t iSecondMoovAtomOffset;
 } PlayFiles_t;
 

titan/libeplayer3/include/manager.h

@@ -18 +18 @@
     MANAGER_UPDATED_TRACK_INFO,
     MANAGER_REGISTER_UPDATED_TRACK_INFO,
+    MANAGER_REF_LIST,
+    MANAGER_REF_LIST_SIZE,
 } ManagerCmd_t;
 

titan/libeplayer3/include/output.h

@@ -27 +27 @@
     OUTPUT_GET_FRAME_COUNT,
     OUTPUT_GET_PROGRESSIVE,
+    OUTPUT_SET_BUFFER_SIZE,
 } OutputCmd_t;
 
@@ -68 +69 @@
     char * Name;
     int32_t (* Command) (/*Context_t*/void  *, OutputCmd_t, void *);
-    int32_t (* Write) (/*Context_t*/void  *, void* privateData);
+    int32_t (* Write) (/*Context_t*/void  *, void *);
     char ** Capabilities;
 

titan/libeplayer3/include/playback.h

@@ -3 +3 @@
 #include <sys/types.h>
 #include <stdint.h>
+#include <stdbool.h>
+
+typedef void( * PlaybackDieNowCallback )();
+bool PlaybackDieNowRegisterCallback(PlaybackDieNowCallback callback);
 
 typedef enum {PLAYBACK_OPEN, PLAYBACK_CLOSE, PLAYBACK_PLAY, PLAYBACK_STOP, PLAYBACK_PAUSE, PLAYBACK_CONTINUE, PLAYBACK_FLUSH, PLAYBACK_TERM, PLAYBACK_FASTFORWARD, PLAYBACK_SEEK, PLAYBACK_SEEK_ABS, PLAYBACK_PTS, PLAYBACK_LENGTH, PLAYBACK_SWITCH_AUDIO, PLAYBACK_SWITCH_SUBTITLE, PLAYBACK_INFO, PLAYBACK_SLOWMOTION, PLAYBACK_FASTBACKWARD, PLAYBACK_GET_FRAME_COUNT} PlaybackCmd_t;

titan/libeplayer3/include/writer.h

@@ -5 +5 @@
 #include <stdio.h>
 #include <stdint.h>
+#include "common.h"
 
 typedef enum { eNone, eAudio, eVideo} eWriterType_t;
@@ -22 +23 @@
     unsigned char          Version;
     unsigned int           InfoFlags;
+    ssize_t                (* WriteV) (int, const struct iovec *, size_t);
 } WriterAVCallData_t;
 
@@ -87 +89 @@
 ssize_t write_with_retry(int fd, const void *buf, size_t size);
 ssize_t writev_with_retry(int fd, const struct iovec *iov, size_t ic);
+
+ssize_t WriteWithRetry(Context_t *context, int pipefd, int fd, const void *buf, size_t size);
 #endif

titan/libeplayer3/main/exteplayer.c

@@ -85 +85 @@
 }
 
-static int g_pfd[2] = {-1, -1}; /* Used to wake terminate thread */
+static int g_pfd[2] = {-1, -1}; /* Used to wake terminate thread and kbhit */
 static int isPlaybackStarted = 0;
 static pthread_mutex_t playbackStartMtx;
+
+static void TerminateWakeUp()
+{
+    write(g_pfd[1], "x", 1);
+}
 
 static void *TermThreadFun(void *arg)
@@ -136 +141 @@
     if (FD_ISSET(fd, &readfds))
     {
-        /*
-        if ( (cl = accept(fd, NULL, NULL)) == -1)
-        {
-            perror("TermThreadFun accept error");
-            goto finish;
-        }
-        */
-        
         pthread_mutex_lock(&playbackStartMtx);
         PlaybackDieNow(1);
@@ -184 +181 @@
 {
     struct timeval tv;
-    fd_set read_fd;
-
-    tv.tv_sec=1;
-    tv.tv_usec=0;
-
-    FD_ZERO(&read_fd);
-    FD_SET(0,&read_fd);
-
-    if(-1 == select(1, &read_fd, NULL, NULL, &tv))
+    fd_set readfds;
+
+    tv.tv_sec = 1;
+    tv.tv_usec = 0;
+
+    FD_ZERO(&readfds);
+    FD_SET(0,&readfds);
+    FD_SET(g_pfd[0], &readfds);
+
+    if(-1 == select(g_pfd[0] + 1, &readfds, NULL, NULL, &tv))
     {
         return 0;
     }
 
-    if(FD_ISSET(0,&read_fd))
+    if(FD_ISSET(0, &readfds))
     {
         return 1;
@@ -369 +367 @@
 }
 
-static int ParseParams(int argc,char* argv[], char *file, char *audioFile, int *pAudioTrackIdx, int *subtitleTrackIdx)
+static int ParseParams(int argc,char* argv[], PlayFiles_t *playbackFiles, int *pAudioTrackIdx, int *subtitleTrackIdx, uint32_t *linuxDvbBufferSizeMB)
 {   
     int ret = 0;
@@ -376 +374 @@
     int aopt = 0, bopt = 0;
     char *copt = 0, *dopt = 0;
-    while ( (c = getopt(argc, argv, "we3dlsrimva:n:x:u:c:h:o:p:P:t:9:0:1:4:f:")) != -1) 
+    while ( (c = getopt(argc, argv, "we3dlsrimva:n:x:u:c:h:o:p:P:t:9:0:1:4:f:b:F:S:O:")) != -1) 
     {
         switch (c) 
@@ -437 +435 @@
             break;
         case 'x':
-            strncpy(audioFile, optarg, IPTV_MAX_FILE_PATH-1);
-            map_inter_file_path(audioFile);
+            if (optarg[0] != '\0')
+            {
+                playbackFiles->szSecondFile = malloc(IPTV_MAX_FILE_PATH);
+                playbackFiles->szSecondFile[0] = '\0';
+                strncpy(playbackFiles->szSecondFile, optarg, IPTV_MAX_FILE_PATH-1);
+                playbackFiles->szSecondFile[IPTV_MAX_FILE_PATH] = '\0';
+                map_inter_file_path(playbackFiles->szSecondFile);
+            }
             break;
         case 'h':
@@ -486 +490 @@
             break;
         }
+        case 'b':
+            *linuxDvbBufferSizeMB = 1024 * 1024 * atoi(optarg);
+            break;
+        case 'S':
+            playbackFiles->iFirstFileSize = (uint64_t) strtoull(optarg, (char **)NULL, 10);
+            break;
+        case 'O':
+            playbackFiles->iFirstMoovAtomOffset = (uint64_t) strtoull(optarg, (char **)NULL, 10);
+            break;
+        case 'F':
+            if (optarg[0] != '\0')
+            {
+                playbackFiles->szFirstMoovAtomFile = malloc(IPTV_MAX_FILE_PATH);
+                playbackFiles->szFirstMoovAtomFile[0] = '\0';
+                strncpy(playbackFiles->szFirstMoovAtomFile, optarg, IPTV_MAX_FILE_PATH-1);
+                playbackFiles->szFirstMoovAtomFile[IPTV_MAX_FILE_PATH] = '\0';
+                map_inter_file_path(playbackFiles->szFirstMoovAtomFile);
+            }
+            break;
         default:
             printf ("?? getopt returned character code 0%o ??\n", c);
@@ -495 +518 @@
     {
         ret = 0;
-        
+        playbackFiles->szFirstFile = malloc(IPTV_MAX_FILE_PATH);
+        playbackFiles->szFirstFile[0] = '\0';
         if(NULL == strstr(argv[optind], "://"))
         {
-            strcpy(file, "file://");
-        }
-        strcat(file, argv[optind]);
-        map_inter_file_path(file);
-        printf("file: [%s]\n", file);
+            strcpy(playbackFiles->szFirstFile, "file://");
+        }
+        strcat(playbackFiles->szFirstFile, argv[optind]);
+        playbackFiles->szFirstFile[IPTV_MAX_FILE_PATH] = '\0';
+        map_inter_file_path(playbackFiles->szFirstFile);
+        printf("file: [%s]\n", playbackFiles->szFirstFile);
         ++optind;
     }
@@ -516 +541 @@
     pthread_t termThread;
     int isTermThreadStarted = 0;
-    char file[IPTV_MAX_FILE_PATH];
-    memset(file, '\0', sizeof(file));
-    
-    char audioFile[IPTV_MAX_FILE_PATH];
-    memset(audioFile, '\0', sizeof(audioFile));
     
     int audioTrackIdx = -1;
     int subtitleTrackIdx = -1;
+    
+    uint32_t linuxDvbBufferSizeMB = 0; 
     
     char argvBuff[256];
@@ -529 +551 @@
     int commandRetVal = -1;
     /* inform client that we can handle additional commands */
-    fprintf(stderr, "{\"EPLAYER3_EXTENDED\":{\"version\":%d}}\n", 36);
-
-    if (0 != ParseParams(argc, argv, file, audioFile, &audioTrackIdx, &subtitleTrackIdx))
+    fprintf(stderr, "{\"EPLAYER3_EXTENDED\":{\"version\":%d}}\n", 47);
+
+    PlayFiles_t playbackFiles;
+    memset(&playbackFiles, 0x00, sizeof(playbackFiles));
+    if (0 != ParseParams(argc, argv, &playbackFiles, &audioTrackIdx, &subtitleTrackIdx, &linuxDvbBufferSizeMB))
     {
         printf("Usage: exteplayer3 filePath [-u user-agent] [-c cookies] [-h headers] [-p prio] [-a] [-d] [-w] [-l] [-s] [-i] [-t audioTrackId] [-9 subtitleTrackId] [-x separateAudioUri] plabackUri\n");
+        printf("[-b size] Linux DVB output buffer size in MB\n");
         printf("[-a 0|1|2|3] AAC software decoding - 1 bit - AAC ADTS, 2 - bit AAC LATM\n");
         printf("[-e] EAC3 software decoding\n");
@@ -560 +585 @@
         printf("[-1 idx] audio MPEG-DASH representation index\n");
         printf("[-f ffopt=ffval] any other ffmpeg option\n");
-        
+        printf("[-F path to additional file with moov atom data (used for mp4 playback in progressive download mode)\n");
+        printf("[-O moov atom offset in the original file (used for mp4 playback in progressive download mode)\n");
+        printf("[-S remote file size (used for mp4 playback in progressive download mode)\n");
         exit(1);
     }
@@ -599 +626 @@
             isTermThreadStarted = 1;
     } while(0);
-
+    
     g_player->playback    = &PlaybackHandler;
     g_player->output      = &OutputHandler;
@@ -614 +641 @@
     g_player->output->Command(g_player, OUTPUT_ADD, "video");
     g_player->output->Command(g_player, OUTPUT_ADD, "subtitle");
+    
+    //Set LINUX DVB additional write buffer size 
+    if (linuxDvbBufferSizeMB)
+        g_player->output->Command(g_player, OUTPUT_SET_BUFFER_SIZE, &linuxDvbBufferSizeMB);
+    
 
     g_player->manager->video->Command(g_player, MANAGER_REGISTER_UPDATED_TRACK_INFO, UpdateVideoTrack);
-    if (strncmp(file, "rtmp", 4) && strncmp(file, "ffrtmp", 4))
+    if (strncmp(playbackFiles.szFirstFile, "rtmp", 4) && strncmp(playbackFiles.szFirstFile, "ffrtmp", 4))
     {
         g_player->playback->noprobe = 1;
     }
 
-    PlayFiles_t playbackFiles = {file, NULL};
-    if('\0' != audioFile[0])
-    {
-        playbackFiles.szSecondFile = audioFile;
-    }
-    
     commandRetVal = g_player->playback->Command(g_player, PLAYBACK_OPEN, &playbackFiles);
-    fprintf(stderr, "{\"PLAYBACK_OPEN\":{\"OutputName\":\"%s\", \"file\":\"%s\", \"sts\":%d}}\n", g_player->output->Name, file, commandRetVal);
+    fprintf(stderr, "{\"PLAYBACK_OPEN\":{\"OutputName\":\"%s\", \"file\":\"%s\", \"sts\":%d}}\n", g_player->output->Name, playbackFiles.szFirstFile, commandRetVal);
     if(commandRetVal < 0)
     {
@@ -650 +676 @@
         if (g_player->playback->isPlaying)
         {
+            PlaybackDieNowRegisterCallback(TerminateWakeUp);
+            
             HandleTracks(g_player->manager->video, (PlaybackCmd_t)-1, "vc");
             HandleTracks(g_player->manager->audio, (PlaybackCmd_t)-1, "al");
@@ -670 +698 @@
         }
 
-        while(g_player->playback->isPlaying)
+        while(g_player->playback->isPlaying && 0 == PlaybackDieNow(0))
         {
             /* we made fgets non blocking */
@@ -848 +876 @@
                 if (0 == commandRetVal)
                 {
-                    fprintf(stderr, "{\"J\":{\"ms\":%lld}}\n", pts / 90, commandRetVal);
+                    int64_t lastPts = 0;
+                    commandRetVal = 1;
+                    if (g_player->container && g_player->container->selectedContainer)
+                    {
+                        commandRetVal = g_player->container->selectedContainer->Command(g_player->container, CONTAINER_LAST_PTS, &lastPts);
+                    }
+                    
+                    if (0 == commandRetVal && lastPts != INVALID_PTS_VALUE)
+                    {
+                        fprintf(stderr, "{\"J\":{\"ms\":%lld,\"lms\":%lld}}\n", pts / 90, lastPts / 90);
+                    }
+                    else
+                    {
+                        fprintf(stderr, "{\"J\":{\"ms\":%lld}}\n", pts / 90);
+                    }
                 }
                 break;
@@ -905 +947 @@
     close(g_pfd[0]);
     close(g_pfd[1]);
-
-    //printOutputCapabilities();
-
+    
     exit(0);
 }

titan/libeplayer3/output/linuxdvb_mipsel.c

@@ -26 +26 @@
 #include <stdlib.h>
 #include <unistd.h>
+#include <stdbool.h>
 #include <fcntl.h>
 #include <sys/types.h>
@@ -53 +54 @@
 #define LINUXDVB_SILENT
 
-static unsigned short debug_level = 0;
+static uint16_t debug_level = 0;
 
 static const char FILENAME[] = __FILE__;
@@ -73 +74 @@
 #define cERR_LINUXDVB_ERROR        -1
 
-static const char VIDEODEV[]    = "/dev/dvb/adapter0/video0";
-static const char AUDIODEV[]    = "/dev/dvb/adapter0/audio0";
+static const char VIDEODEV[] = "/dev/dvb/adapter0/video0";
+static const char AUDIODEV[] = "/dev/dvb/adapter0/audio0";
 
 static int videofd      = -1;
@@ -89 +90 @@
 
 unsigned long long int sCURRENT_PTS = 0;
+bool isBufferedOutput = false;
 
 pthread_mutex_t LinuxDVBmutex;
@@ -95 +97 @@
 /* Prototypes                    */
 /* ***************************** */
+int32_t LinuxDvbBuffOpen(Context_t *context, char *type, int outfd);
+int32_t LinuxDvbBuffClose(Context_t *context);
+int32_t LinuxDvbBuffFlush(Context_t *context);
+int32_t LinuxDvbBuffResume(Context_t *context);
+
+ssize_t BufferingWriteV(int fd, const struct iovec *iov, size_t ic);
+int32_t WriteSetBufferingSize(const uint32_t bufferSize);
+
 int LinuxDvbStop(Context_t  *context, char * type);
 
@@ -101 +111 @@
 /* ***************************** */
 
-void getLinuxDVBMutex(const char *filename __attribute__((unused)), const char *function __attribute__((unused)), int line __attribute__((unused))) {
-
-    linuxdvb_printf(250, "requesting mutex\n");
-
+void getLinuxDVBMutex(const char *filename __attribute__((unused)), const char *function __attribute__((unused)), int line __attribute__((unused)))
+{
     pthread_mutex_lock(&LinuxDVBmutex);
-
-    linuxdvb_printf(250, "received mutex\n");
 }
 
 void releaseLinuxDVBMutex(const char *filename __attribute__((unused)), const char *function __attribute__((unused)), int line __attribute__((unused))) {
     pthread_mutex_unlock(&LinuxDVBmutex);
-
-    linuxdvb_printf(250, "released mutex\n");
-
 }
 
 static int LinuxDvbMapBypassMode(int bypass)
 {
-    if( 0x30 == bypass && IsDreambox() )
+    if (0x30 == bypass && IsDreambox())
     {
         return 0x0f;
@@ -126 +129 @@
 }
 
-int LinuxDvbOpen(Context_t  *context __attribute__((unused)), char * type) {
-    unsigned char video = !strcmp("video", type);
-    unsigned char audio = !strcmp("audio", type);
+int LinuxDvbOpen(Context_t  *context __attribute__((unused)), char *type)
+{
+    uint8_t video = !strcmp("video", type);
+    uint8_t audio = !strcmp("audio", type);
 
     linuxdvb_printf(10, "v%d a%d\n", video, audio);
@@ -138 +142 @@
         if (videofd < 0)
         {
-            linuxdvb_err("failed to open %s - errno %d\n", VIDEODEV, errno);
-            linuxdvb_err("%s\n", strerror(errno));
+            linuxdvb_err("failed to open %s - errno %d, %s\n", VIDEODEV, errno, strerror(errno));
+            linuxdvb_err("%s\n", );
             return cERR_LINUXDVB_ERROR;
         }
@@ -145 +149 @@
         if (ioctl( videofd, VIDEO_CLEAR_BUFFER) == -1)
         {
-            linuxdvb_err("ioctl failed with errno %d\n", errno);
-            linuxdvb_err("VIDEO_CLEAR_BUFFER: %s\n", strerror(errno));
+            linuxdvb_err("VIDEO_CLEAR_BUFFER: ERROR %d, %s\n", errno, strerror(errno));
         }
 
         if (ioctl( videofd, VIDEO_SELECT_SOURCE, (void*)VIDEO_SOURCE_MEMORY) == -1)
         {
-            linuxdvb_err("ioctl failed with errno %d\n", errno);
-            linuxdvb_err("VIDEO_SELECT_SOURCE: %s\n", strerror(errno));
+            linuxdvb_err("VIDEO_SELECT_SOURCE: ERROR %d, %s\n", errno, strerror(errno));
         }
         
         if (ioctl(videofd, VIDEO_FREEZE) == -1)
         {
-            linuxdvb_err("ioctl failed with errno %d\n", errno);
-            linuxdvb_err("VIDEO_FREEZE: %s\n", strerror(errno));
-        }
-
+            linuxdvb_err("VIDEO_FREEZE: ERROR %d, %s\n", errno, strerror(errno));
+        }
+
+        if (isBufferedOutput)
+            LinuxDvbBuffOpen(context, type, videofd);
     }
     if (audio && audiofd < 0) 
@@ -168 +171 @@
         if (audiofd < 0)
         {
-            linuxdvb_err("failed to open %s - errno %d\n", AUDIODEV, errno);
-            linuxdvb_err("%s\n", strerror(errno));
-            
+            linuxdvb_err("failed to open %s - errno %d, %s\n", AUDIODEV, errno, strerror(errno));
             return cERR_LINUXDVB_ERROR;
         }
@@ -176 +177 @@
         if (ioctl( audiofd, AUDIO_CLEAR_BUFFER) == -1)
         {
-            linuxdvb_err("ioctl failed with errno %d\n", errno);
-            linuxdvb_err("AUDIO_CLEAR_BUFFER: %s\n", strerror(errno));
+            linuxdvb_err("AUDIO_CLEAR_BUFFER: ERROR %d, %s\n", errno, strerror(errno));
         }
 
         if (ioctl( audiofd, AUDIO_SELECT_SOURCE, AUDIO_SOURCE_MEMORY) == -1)
         {
-            linuxdvb_err("ioctl failed with errno %d\n", errno);
-            linuxdvb_err("AUDIO_SELECT_SOURCE: %s\n", strerror(errno));
+            linuxdvb_err("AUDIO_SELECT_SOURCE: ERROR %d, %s\n", errno, strerror(errno));
         }
         
         if (ioctl( audiofd, AUDIO_PAUSE) == -1)
         {
-            linuxdvb_err("ioctl failed with errno %d\n", errno);
-            linuxdvb_err("AUDIO_PAUSE: %s\n", strerror(errno));
+            linuxdvb_err("AUDIO_PAUSE: ERROR %d, %s\n", errno, strerror(errno));
         }
         
+        if (isBufferedOutput)
+            LinuxDvbBuffOpen(context, type, audiofd);
     }
 
@@ -197 +197 @@
 }
 
-int LinuxDvbClose(Context_t  *context, char * type)
-{
-    unsigned char video = !strcmp("video", type);
-    unsigned char audio = !strcmp("audio", type);
+int LinuxDvbClose(Context_t  *context, char *type)
+{
+    uint8_t video = !strcmp("video", type);
+    uint8_t audio = !strcmp("audio", type);
 
     linuxdvb_printf(10, "v%d a%d\n", video, audio);
@@ -211 +211 @@
 
     getLinuxDVBMutex(FILENAME, __FUNCTION__,__LINE__);
+    
+    if (isBufferedOutput)
+        LinuxDvbBuffClose(context);
 
     if (video && videofd != -1)
@@ -223 +226 @@
     }
 
-    releaseLinuxDVBMutex(FILENAME, __FUNCTION__,__LINE__);
+    releaseLinuxDVBMutex(FILENAME, __FUNCTION__, __LINE__);
     return cERR_LINUXDVB_NO_ERROR;
 }
 
-int LinuxDvbPlay(Context_t  *context, char * type) {
-    int ret = cERR_LINUXDVB_NO_ERROR;
-    Writer_t* writer;
-
-    unsigned char video = !strcmp("video", type);
-    unsigned char audio = !strcmp("audio", type);
+int LinuxDvbPlay(Context_t  *context, char *type) {
+    int32_t ret = cERR_LINUXDVB_NO_ERROR;
+    Writer_t *writer;
+
+    uint8_t video = !strcmp("video", type);
+    uint8_t audio = !strcmp("audio", type);
 
     linuxdvb_printf(10, "v%d a%d\n", video, audio);
 
     if (video && videofd != -1) {
-        char * Encoding = NULL;
+        char *Encoding = NULL;
         context->manager->video->Command(context, MANAGER_GETENCODING, &Encoding);
 
@@ -243 +246 @@
 
         writer = getWriter(Encoding);
-        
-        // SULGE VU 4K dont like this
-        /*
-        if (0 != ioctl(videofd, VIDEO_STOP))
-        {
-            linuxdvb_err("ioctl failed with errno %d\n", errno);
-            linuxdvb_err("VIDEO_STOP: %s\n", strerror(errno));
-            ret = cERR_LINUXDVB_ERROR;
-        }
-        */
-
         if (writer == NULL)
         {
@@ -264 +256 @@
             if (ioctl( videofd, VIDEO_SET_STREAMTYPE, (void*) writer->caps->dvbStreamType) == -1)
             {
-                linuxdvb_err("ioctl failed with errno %d\n", errno);
-                linuxdvb_err("VIDEO_SET_STREAMTYPE: %s\n", strerror(errno));
+                linuxdvb_err("VIDEO_SET_STREAMTYPE: ERROR %d, %s\n", errno, strerror(errno));
                 ret = cERR_LINUXDVB_ERROR;
             }
@@ -273 +264 @@
         if (0 != ioctl(videofd, VIDEO_PLAY))
         {
-            linuxdvb_err("ioctl failed with errno %d\n", errno);
-            linuxdvb_err("VIDEO_PLAY: %s\n", strerror(errno));
+            linuxdvb_err("VIDEO_PLAY: ERROR %d, %s\n", errno, strerror(errno));
             ret = cERR_LINUXDVB_ERROR;
         }
@@ -280 +270 @@
         if (ioctl(videofd, VIDEO_CONTINUE) == -1)
         {
-            linuxdvb_err("ioctl failed with errno %d\n", errno);
-            linuxdvb_err("VIDEO_CONTINUE: %s\n", strerror(errno));
+            linuxdvb_err("VIDEO_CONTINUE: ERROR %d, %s\n", errno, strerror(errno));
         }
         
         if (ioctl( videofd, VIDEO_CLEAR_BUFFER) == -1)
         {
-            linuxdvb_err("ioctl failed with errno %d\n", errno);
-            linuxdvb_err("VIDEO_CLEAR_BUFFER: %s\n", strerror(errno));
+            linuxdvb_err("VIDEO_CLEAR_BUFFER: ERROR %d, %s\n", errno, strerror(errno));
         }
     }
@@ -298 +286 @@
         writer = getWriter(Encoding);
         
-        // SULGE VU 4K dont like this
-        /*
-        if (0 != ioctl(audiofd, AUDIO_STOP))
-        {
-            linuxdvb_err("ioctl failed with errno %d\n", errno);
-            linuxdvb_err("AUDIO_STOP: %s\n", strerror(errno));
-            ret = cERR_LINUXDVB_ERROR;
-        }
-        */
-
         if (writer == NULL)
         {
@@ -318 +296 @@
             if (ioctl( audiofd, AUDIO_SET_BYPASS_MODE, (void*) LinuxDvbMapBypassMode(writer->caps->dvbStreamType)) < 0)
             {
-                linuxdvb_err("ioctl failed with errno %d\n", errno);
-                linuxdvb_err("AUDIO_SET_BYPASS_MODE: %s\n", strerror(errno));
+                linuxdvb_err("AUDIO_SET_BYPASS_MODE: ERROR %d, %s\n", errno, strerror(errno));
                 ret = cERR_LINUXDVB_ERROR;
             }
@@ -326 +303 @@
         if (ioctl(audiofd, AUDIO_PLAY) < 0)
         {
-            linuxdvb_err("ioctl failed with errno %d\n", errno);
-            linuxdvb_err("AUDIO_PLAY: %s\n", strerror(errno));
+            linuxdvb_err("AUDIO_PLAY: ERROR %d, %s\n", errno, strerror(errno));
             ret = cERR_LINUXDVB_ERROR;
         }
@@ -333 +309 @@
         if (ioctl(audiofd, AUDIO_CONTINUE) < 0)
         {
-            linuxdvb_err("ioctl failed with errno %d\n", errno);
-            linuxdvb_err("AUDIO_CONTINUE: %s\n", strerror(errno));
+            linuxdvb_err("AUDIO_CONTINUE: ERROR %d, %s\n", errno, strerror(errno));
             ret = cERR_LINUXDVB_ERROR;
         }
@@ -358 +333 @@
         if (ioctl(videofd, VIDEO_CLEAR_BUFFER) == -1)
         {
-            linuxdvb_err("ioctl failed with errno %d\n", errno);
-            linuxdvb_err("VIDEO_CLEAR_BUFFER: %s\n", strerror(errno));
+            linuxdvb_err("VIDEO_CLEAR_BUFFER: ERROR %d, %s\n", errno, strerror(errno));
         }
         
         if (ioctl(videofd, VIDEO_STOP) == -1)
         {
-            linuxdvb_err("ioctl failed with errno %d\n", errno);
-            linuxdvb_err("VIDEO_STOP: %s\n", strerror(errno));
+            linuxdvb_err("VIDEO_STOP: ERROR %d, %s\n", errno, strerror(errno));
             ret = cERR_LINUXDVB_ERROR;
         }
@@ -371 +344 @@
         ioctl(videofd, VIDEO_SLOWMOTION, 0);
         ioctl(videofd, VIDEO_FAST_FORWARD, 0);
-
         ioctl(videofd, VIDEO_SELECT_SOURCE, VIDEO_SOURCE_DEMUX);
     }
@@ -377 +349 @@
         if (ioctl(audiofd, AUDIO_CLEAR_BUFFER) == -1)
         {
-            linuxdvb_err("ioctl failed with errno %d\n", errno);
-            linuxdvb_err("AUDIO_CLEAR_BUFFER: %s\n", strerror(errno));
-        }
-
-        /* set back to normal speed (end trickmodes) */
-        // if (ioctl(audiofd, AUDIO_SET_SPEED, DVB_SPEED_NORMAL_PLAY) == -1)
-        // {
-            // linuxdvb_err("ioctl failed with errno %d\n", errno);
-            // linuxdvb_err("AUDIO_SET_SPEED: %s\n", strerror(errno));
-        // }
+            linuxdvb_err("AUDIO_CLEAR_BUFFER: ERROR %d, %s\n", errno, strerror(errno));
+        }
+
         if (ioctl(audiofd, AUDIO_STOP) == -1)
         {
-            linuxdvb_err("ioctl failed with errno %d\n", errno);
-            linuxdvb_err("AUDIO_STOP: %s\n", strerror(errno));
+            linuxdvb_err("AUDIO_STOP: ERROR %d, %s\n", errno, strerror(errno));
             ret = cERR_LINUXDVB_ERROR;
         }
@@ -401 +365 @@
 }
 
-int LinuxDvbPause(Context_t  *context __attribute__((unused)), char * type) {
-    int ret = cERR_LINUXDVB_NO_ERROR;
-    unsigned char video = !strcmp("video", type);
-    unsigned char audio = !strcmp("audio", type);
+int LinuxDvbPause(Context_t  *context __attribute__((unused)), char *type) {
+    int32_t ret = cERR_LINUXDVB_NO_ERROR;
+    uint8_t video = !strcmp("video", type);
+    uint8_t audio = !strcmp("audio", type);
 
     linuxdvb_printf(10, "v%d a%d\n", video, audio);
@@ -410 +374 @@
     getLinuxDVBMutex(FILENAME, __FUNCTION__,__LINE__);
 
-    if (video && videofd != -1) {
+    if (video && videofd != -1) 
+    {
         if (ioctl(videofd, VIDEO_FREEZE, NULL) == -1)
         {
-            linuxdvb_err("ioctl failed with errno %d\n", errno);
-            linuxdvb_err("VIDEO_FREEZE: %s\n", strerror(errno));
-            ret = cERR_LINUXDVB_ERROR;
-        }
-    }
-    if (audio && audiofd != -1) {
+            linuxdvb_err("VIDEO_FREEZE: ERROR %d, %s\n", errno, strerror(errno));
+            ret = cERR_LINUXDVB_ERROR;
+        }
+    }
+    
+    if (audio && audiofd != -1)
+    {
         if (ioctl(audiofd, AUDIO_PAUSE, NULL) == -1)
         {
-            linuxdvb_err("ioctl failed with errno %d\n", errno);
-            linuxdvb_err("AUDIO_PAUSE: %s\n", strerror(errno));
+            linuxdvb_err("AUDIO_PAUSE: ERROR %d, %s\n", errno, strerror(errno));
             ret = cERR_LINUXDVB_ERROR;
         }
@@ -433 +398 @@
 
 int LinuxDvbContinue(Context_t  *context __attribute__((unused)), char * type) {
-    int ret = cERR_LINUXDVB_NO_ERROR;
-    unsigned char video = !strcmp("video", type);
-    unsigned char audio = !strcmp("audio", type);
+    int32_t ret = cERR_LINUXDVB_NO_ERROR;
+    uint8_t video = !strcmp("video", type);
+    uint8_t audio = !strcmp("audio", type);
 
     linuxdvb_printf(10, "v%d a%d\n", video, audio);
 
-    if (video && videofd != -1) {
+    if (video && videofd != -1)
+    {
         if (ioctl(videofd, VIDEO_CONTINUE, NULL) == -1)
         {
-            linuxdvb_err("ioctl failed with errno %d\n", errno);
-            linuxdvb_err("VIDEO_CONTINUE: %s\n", strerror(errno));
-            ret = cERR_LINUXDVB_ERROR;
-        }
-    }
-    if (audio && audiofd != -1) {
+            linuxdvb_err("VIDEO_CONTINUE: ERROR %d, %s\n", errno, strerror(errno));
+            ret = cERR_LINUXDVB_ERROR;
+        }
+    }
+    
+    if (audio && audiofd != -1)
+    {
         if (ioctl(audiofd, AUDIO_CONTINUE, NULL) == -1)
         {
-            linuxdvb_err("ioctl failed with errno %d\n", errno);
-            linuxdvb_err("AUDIO_CONTINUE: %s\n", strerror(errno));
-            ret = cERR_LINUXDVB_ERROR;
-        }
-    }
+            linuxdvb_err("AUDIO_CONTINUE: ERROR %d, %s\n", errno, strerror(errno));
+            ret = cERR_LINUXDVB_ERROR;
+        }
+    }
+    
+    if (isBufferedOutput)
+        LinuxDvbBuffResume(context);
 
     linuxdvb_printf(10, "exiting\n");
-
-
-    return ret;
-}
-
-int LinuxDvbReverseDiscontinuity(Context_t  *context __attribute__((unused)), int* surplus) {
-    int ret = cERR_LINUXDVB_NO_ERROR;
-    // int dis_type = VIDEO_DISCONTINUITY_CONTINUOUS_REVERSE | *surplus;
     
-    // linuxdvb_printf(50, "\n");
-
-    // if (ioctl( videofd, VIDEO_DISCONTINUITY, (void*) dis_type) == -1)
-    // {
-        // linuxdvb_err("ioctl failed with errno %d\n", errno);
-        // linuxdvb_err("VIDEO_DISCONTINUITY: %s\n", strerror(errno));
-    // }
-
-    // linuxdvb_printf(50, "exiting\n");
-
     return ret;
 }
@@ -487 +438 @@
         if(*flag == '1')
         {
-            //AUDIO_SET_MUTE has no effect with new player
-            //if (ioctl(audiofd, AUDIO_SET_MUTE, 1) == -1)
             if (ioctl(audiofd, AUDIO_STOP, NULL) == -1)
             {
-                linuxdvb_err("ioctl failed with errno %d\n", errno);
-                //linuxdvb_err("AUDIO_SET_MUTE: %s\n", strerror(errno));
-                linuxdvb_err("AUDIO_STOP: %s\n", strerror(errno));
+                linuxdvb_err("AUDIO_STOP: ERROR %d, %s\n", errno, strerror(errno));
                 ret = cERR_LINUXDVB_ERROR;
             }
@@ -499 +446 @@
         else
         {
-            //AUDIO_SET_MUTE has no effect with new player
-            //if (ioctl(audiofd, AUDIO_SET_MUTE, 0) == -1)
             if (ioctl(audiofd, AUDIO_PLAY) == -1)
             {
-                linuxdvb_err("ioctl failed with errno %d\n", errno);
-                //linuxdvb_err("AUDIO_SET_MUTE: %s\n", strerror(errno));
-                linuxdvb_err("AUDIO_PLAY: %s\n", strerror(errno));
+                linuxdvb_err("AUDIO_PLAY: ERROR %d, %s\n", errno, strerror(errno));
                 ret = cERR_LINUXDVB_ERROR;
             }
@@ -516 +459 @@
 }
 
-
 int LinuxDvbFlush(Context_t  *context __attribute__((unused)), char * type) 
 {
-    // unsigned char video = !strcmp("video", type);
-    // unsigned char audio = !strcmp("audio", type);
-
-    // linuxdvb_printf(10, "v%d a%d\n", video, audio);
-
-    // if ( (video && videofd != -1) || (audio && audiofd != -1) ) {
-        // getLinuxDVBMutex(FILENAME, __FUNCTION__,__LINE__);
-
-        // if (video && videofd != -1) {
-            // if (ioctl(videofd, VIDEO_FLUSH, NULL) == -1)
-            // {
-                // linuxdvb_err("ioctl failed with errno %d\n", errno);
-                // linuxdvb_err("VIDEO_FLUSH: %s\n", strerror(errno));
-            // }
-        // }
-
-        // if (audio && audiofd != -1) {
-            // if (ioctl(audiofd, AUDIO_FLUSH, NULL) == -1)
-            // {
-                // linuxdvb_err("ioctl failed with errno %d\n", errno);
-                // linuxdvb_err("AUDIO_FLUSH: %s\n", strerror(errno));
-            // }
-        // }
-
-        // releaseLinuxDVBMutex(FILENAME, __FUNCTION__,__LINE__);
-    // }
-
-    // linuxdvb_printf(10, "exiting\n");
-
     return cERR_LINUXDVB_NO_ERROR;
 }
 
-#ifndef use_set_speed_instead_ff
-int LinuxDvbFastForward(Context_t  *context, char * type) {
-    int ret = cERR_LINUXDVB_NO_ERROR;
-
-    unsigned char video = !strcmp("video", type);
-    unsigned char audio = !strcmp("audio", type);
-
-    linuxdvb_printf(10, "v%d a%d speed %d\n", video, audio, context->playback->Speed);
-
-    if (video && videofd != -1) {
-
-        getLinuxDVBMutex(FILENAME, __FUNCTION__,__LINE__);
-
-        /* konfetti comment: speed is a value given in skipped frames */
-
-        if (ioctl(videofd, VIDEO_FAST_FORWARD, context->playback->Speed) == -1)
-        {
-            linuxdvb_err("ioctl failed with errno %d\n", errno);
-            linuxdvb_err("VIDEO_FAST_FORWARD: %s\n", strerror(errno));
-            ret = cERR_LINUXDVB_ERROR;
-        }
-
-        releaseLinuxDVBMutex(FILENAME, __FUNCTION__,__LINE__);
-    }
-
-    linuxdvb_printf(10, "exiting with value %d\n", ret);
-
-    return ret;
-}
-#else
-
-static unsigned int SpeedList[] =
-{
-    1000, 1100, 1200, 1300, 1500, 
-    2000, 3000, 4000, 5000, 8000, 
-    12000, 16000, 
-    125, 250, 500, 700, 800, 900
-};
-
-int LinuxDvbFastForward(Context_t  *context, char * type) {
-    int ret = cERR_LINUXDVB_NO_ERROR;
-    int speedIndex;
-    unsigned char video = !strcmp("video", type);
-    unsigned char audio = !strcmp("audio", type);
-
-    linuxdvb_printf(10, "v%d a%d\n", video, audio);
-
-    if (video && videofd != -1) {
-
-        getLinuxDVBMutex(FILENAME, __FUNCTION__,__LINE__);
-
-        speedIndex = context->playback->Speed % (sizeof (SpeedList) / sizeof (int));
-
-        linuxdvb_printf(1, "speedIndex %d\n", speedIndex);
-
-        // if (ioctl(videofd, VIDEO_SET_SPEED, SpeedList[speedIndex]) == -1)
-        // {
-            // linuxdvb_err("ioctl failed with errno %d\n", errno);
-            // linuxdvb_err("VIDEO_SET_SPEED: %s\n", strerror(errno));
-            // ret = cERR_LINUXDVB_ERROR;
-        // }
-
-        releaseLinuxDVBMutex(FILENAME, __FUNCTION__,__LINE__);
-    }
-
-    if (audio && audiofd != -1) {
-
-        getLinuxDVBMutex(FILENAME, __FUNCTION__,__LINE__);
-
-        speedIndex = context->playback->Speed % (sizeof (SpeedList) / sizeof (int));
-
-        linuxdvb_printf(1, "speedIndex %d\n", speedIndex);
-
-        // if (ioctl(audiofd, AUDIO_SET_SPEED, SpeedList[speedIndex]) == -1)
-        // {
-            // linuxdvb_err("ioctl failed with errno %d\n", errno);
-            // linuxdvb_err("AUDIO_SET_SPEED: %s\n", strerror(errno));
-            // ret = cERR_LINUXDVB_ERROR;
-        // }
-
-        releaseLinuxDVBMutex(FILENAME, __FUNCTION__,__LINE__);
-    }
-
-    linuxdvb_printf(10, "exiting with value %d\n", ret);
-
-    return ret;
-}
-#endif
-
-
-int LinuxDvbReverse(Context_t  *context __attribute__((unused)), char * type __attribute__((unused))) {
-    int ret = cERR_LINUXDVB_NO_ERROR;
-    return ret;
-}
-
 int LinuxDvbSlowMotion(Context_t  *context, char * type) {
-    int ret = cERR_LINUXDVB_NO_ERROR;
-
-    unsigned char video = !strcmp("video", type);
-    unsigned char audio = !strcmp("audio", type);
+    int32_t ret = cERR_LINUXDVB_NO_ERROR;
+
+    uint8_t video = !strcmp("video", type);
+    uint8_t audio = !strcmp("audio", type);
 
     linuxdvb_printf(10, "v%d a%d\n", video, audio);
@@ -660 +478 @@
             if (ioctl(videofd, VIDEO_SLOWMOTION, context->playback->SlowMotion) == -1)
             {
-                linuxdvb_err("ioctl failed with errno %d\n", errno);
-                linuxdvb_err("VIDEO_SLOWMOTION: %s\n", strerror(errno));
+                linuxdvb_err("VIDEO_SLOWMOTION: ERROR %d, %s\n", errno, strerror(errno));
                 ret = cERR_LINUXDVB_ERROR;
             }
@@ -674 +491 @@
 }
 
-int LinuxDvbAVSync(Context_t  *context, char * type __attribute__((unused))) {
-    int ret = cERR_LINUXDVB_NO_ERROR;
+int LinuxDvbAVSync(Context_t  *context, char *type __attribute__((unused))) {
+    int32_t ret = cERR_LINUXDVB_NO_ERROR;
     /* konfetti: this one is dedicated to audiofd so we
      * are ignoring what is given by type! I think we should
@@ -687 +504 @@
         if (ioctl(audiofd, AUDIO_SET_AV_SYNC, 0) == -1) //context->playback->AVSync) == -1)
         {
-            linuxdvb_err("ioctl failed with errno %d\n", errno);
-            linuxdvb_err("AUDIO_SET_AV_SYNC: %s\n", strerror(errno));
+            linuxdvb_err("AUDIO_SET_AV_SYNC: ERROR %d, %s\n", errno, strerror(errno));
             ret = cERR_LINUXDVB_ERROR;
         }
@@ -698 +514 @@
 }
 
-int LinuxDvbClear(Context_t  *context __attribute__((unused)), char * type) 
+int LinuxDvbClear(Context_t  *context __attribute__((unused)), char *type) 
 {
     int32_t ret = cERR_LINUXDVB_NO_ERROR;
@@ -704 +520 @@
     uint8_t audio = !strcmp("audio", type);
 
-    linuxdvb_printf(10, ">>>>>>>>>>LinuxDvbClear v%d a%d\n", video, audio);
+    linuxdvb_printf(10, "LinuxDvbClear v%d a%d\n", video, audio);
 
     if ( (video && videofd != -1) || (audio && audiofd != -1) ) 
@@ -714 +530 @@
             if (ioctl(videofd, VIDEO_CLEAR_BUFFER) == -1)
             {
-                linuxdvb_err("ioctl failed with errno %d\n", errno);
-                linuxdvb_err("VIDEO_CLEAR_BUFFER: %s\n", strerror(errno));
+                linuxdvb_err("VIDEO_CLEAR_BUFFER: ERROR %d, %s\n", errno, strerror(errno));
                 ret = cERR_LINUXDVB_ERROR;
             }
@@ -723 +538 @@
             if (ioctl(audiofd, AUDIO_CLEAR_BUFFER) == -1)
             {
-                linuxdvb_err("ioctl failed with errno %d\n", errno);
-                linuxdvb_err("AUDIO_CLEAR_BUFFER: %s\n", strerror(errno));
+                linuxdvb_err("AUDIO_CLEAR_BUFFER: ERROR %d, %s\n", errno, strerror(errno));
                 ret = cERR_LINUXDVB_ERROR;
             }
@@ -738 +552 @@
 
 int LinuxDvbPts(Context_t  *context __attribute__((unused)), unsigned long long int* pts) {
-    int ret = cERR_LINUXDVB_ERROR;
+    int32_t ret = cERR_LINUXDVB_ERROR;
     
     linuxdvb_printf(50, "\n");
 
-    // pts is a non writting requests and can be done in parallel to other requests
-    //getLinuxDVBMutex(FILENAME, __FUNCTION__,__LINE__);
-
+    // GET_PTS is immutable call, so it can be done in parallel to other requests
     if (videofd > -1 && !ioctl(videofd, VIDEO_GET_PTS, (void*)&sCURRENT_PTS))
     {
@@ -751 +563 @@
     else
     {
-        linuxdvb_err("VIDEO_GET_PTS: %d (%s)\n", errno, strerror(errno));
+        linuxdvb_err("VIDEO_GET_PTS: ERROR %d, %s\n", errno, strerror(errno));
     }
 
@@ -762 +574 @@
         else
         {
-            linuxdvb_err("AUDIO_GET_PTS: %d (%s)\n", errno, strerror(errno));
+            linuxdvb_err("AUDIO_GET_PTS: ERROR %d, %s\n", errno, strerror(errno));
         }
     }
@@ -772 +584 @@
 
     *((unsigned long long int *)pts)=(unsigned long long int)sCURRENT_PTS;
-
-    //releaseLinuxDVBMutex(FILENAME, __FUNCTION__,__LINE__);
-
     return ret;
 }
@@ -780 +589 @@
 int LinuxDvbGetFrameCount(Context_t  *context __attribute__((unused)), unsigned long long int* frameCount)
 {
-    int ret = cERR_LINUXDVB_NO_ERROR;
-    return ret;
-}
-
-int LinuxDvbSwitch(Context_t  *context, char * type) 
-{
-    unsigned char audio = !strcmp("audio", type);
-    unsigned char video = !strcmp("video", type);
-    Writer_t* writer;
+    return cERR_LINUXDVB_NO_ERROR;
+}
+
+int LinuxDvbSwitch(Context_t  *context, char *type) 
+{
+    uint8_t audio = !strcmp("audio", type);
+    uint8_t video = !strcmp("video", type);
+    Writer_t *writer;
 
     linuxdvb_printf(10, "v%d a%d\n", video, audio);
@@ -806 +614 @@
                 if (ioctl(audiofd, AUDIO_STOP ,NULL) == -1)
                 {
-                    linuxdvb_err("ioctl failed with errno %d\n", errno);
-                    linuxdvb_err("AUDIO_STOP: %s\n", strerror(errno));
-
+                    linuxdvb_err("AUDIO_STOP: ERROR %d, %s\n", errno, strerror(errno));
                 }
 
                 if (ioctl(audiofd, AUDIO_CLEAR_BUFFER) == -1)
                 {
-                    linuxdvb_err("ioctl failed with errno %d\n", errno);
-                    linuxdvb_err("AUDIO_CLEAR_BUFFER: %s\n", strerror(errno));
-
+                    linuxdvb_err("AUDIO_CLEAR_BUFFER: ERROR %d, %s\n", errno, strerror(errno));
                 }
 
@@ -821 +625 @@
                 {
                     linuxdvb_err("cannot found writer for encoding %s using default\n", Encoding);
-                    // if (ioctl( audiofd, AUDIO_SET_BYPASS_MODE, (void*) AUDIO_ENCODING_MP3) == -1)
-                    // {
-                        // linuxdvb_err("ioctl failed with errno %d\n", errno);
-                        // linuxdvb_err("AUDIO_SET_BYPASS_MODE: %s\n", strerror(errno));
-                    // }
-                } else
+                } 
+                else
                 {
                     linuxdvb_printf(10, "found writer %s for encoding %s\n", writer->caps->name, Encoding);
                     if (ioctl( audiofd, AUDIO_SET_BYPASS_MODE, (void*) LinuxDvbMapBypassMode(writer->caps->dvbStreamType)) == -1)
                     {
-                        linuxdvb_err("ioctl failed with errno %d\n", errno);
-                        linuxdvb_err("AUDIO_SET_BYPASS_MODE: %s\n", strerror(errno));
+                        linuxdvb_err("AUDIO_SET_BYPASS_MODE: ERROR %d, %s\n", errno, strerror(errno));
                     }
                 }
@@ -838 +637 @@
                 if (ioctl(audiofd, AUDIO_PLAY) == -1)
                 {
-                    linuxdvb_err("ioctl failed with errno %d\n", errno);
-                    linuxdvb_err("AUDIO_PLAY: %s\n", strerror(errno));
+                    linuxdvb_err("AUDIO_PLAY: ERROR %d, %s\n", errno, strerror(errno));
                 }
                 free(Encoding);
@@ -854 +652 @@
                 if (ioctl(videofd, VIDEO_STOP ,NULL) == -1)
                 {
-                    linuxdvb_err("ioctl failed with errno %d\n", errno);
-                    linuxdvb_err("VIDEO_STOP: %s\n", strerror(errno));
+                    linuxdvb_err("VIDEO_STOP: ERROR %d, %s\n", errno, strerror(errno));
                 }
 
                 if (ioctl(videofd, VIDEO_CLEAR_BUFFER) == -1)
                 {
-                    linuxdvb_err("ioctl failed with errno %d\n", errno);
-                    linuxdvb_err("VIDEO_CLEAR_BUFFER: %s\n", strerror(errno));
+                    linuxdvb_err("VIDEO_CLEAR_BUFFER: ERROR %d, %s\n", errno, strerror(errno));
                 }
 
@@ -871 +667 @@
                 {
                     linuxdvb_err("cannot found writer for encoding %s using default\n", Encoding);
-                    // if (ioctl( videofd, VIDEO_SET_STREAMTYPE, (void*) VIDEO_ENCODING_AUTO) == -1)
-                    // {
-                        // linuxdvb_err("ioctl failed with errno %d\n", errno);
-                        // linuxdvb_err("VIDEO_SET_STREAMTYPE: %s\n", strerror(errno));
-                    // }
-                } else
+                } 
+                else
                 {
                     linuxdvb_printf(10, "found writer %s for encoding %s\n", writer->caps->name, Encoding);
                     if (ioctl( videofd, VIDEO_SET_STREAMTYPE, (void*) writer->caps->dvbStreamType) == -1)
                     {
-                        linuxdvb_err("ioctl failed with errno %d\n", errno);
-                        linuxdvb_err("VIDEO_SET_STREAMTYPE: %s\n", strerror(errno));
+                        linuxdvb_err("VIDEO_SET_STREAMTYPE: ERROR %d, %s\n", errno, strerror(errno));
                     }
                 }
@@ -891 +682 @@
                      * return an error here and stop the playback mode
                      */
-                    linuxdvb_err("ioctl failed with errno %d\n", errno);
-                    linuxdvb_err("VIDEO_PLAY: %s\n", strerror(errno));
+                    linuxdvb_err("VIDEO_PLAY:ERROR %d, %s\n", errno, strerror(errno));
                 }
                 free(Encoding);
@@ -909 +699 @@
 }
 
-static int Write(void  *_context, void* _out)
+static int Write(void  *_context, void *_out)
 {
     Context_t          *context  = (Context_t  *) _context;
     AudioVideoOut_t    *out      = (AudioVideoOut_t*) _out;
-    int                ret       = cERR_LINUXDVB_NO_ERROR;
-    int                res       = 0;
-    unsigned char      video     = 0;
-    unsigned char      audio     = 0;
-    Writer_t*          writer;
+    int32_t            ret       = cERR_LINUXDVB_NO_ERROR;
+    int32_t            res       = 0;
+    uint8_t            video     = 0;
+    uint8_t            audio     = 0;
+    Writer_t           *writer   = NULL;
     WriterAVCallData_t call;
 
@@ -935 +725 @@
     if (video) 
     {
-        char * Encoding = NULL;
+        char *Encoding = NULL;
         context->manager->video->Command(context, MANAGER_GETENCODING, &Encoding);
 
@@ -1011 +801 @@
             call.Height       = out->height;
             call.InfoFlags    = out->infoFlags;
-            call.Version      = 0; // is unsingned char
+            call.Version      = 0;
+            call.WriteV       = isBufferedOutput ? BufferingWriteV : writev_with_retry;
 
             if (writer->writeData)
@@ -1030 +821 @@
     else if (audio)
     {
-        char * Encoding = NULL;
+        char *Encoding = NULL;
         context->manager->audio->Command(context, MANAGER_GETENCODING, &Encoding);
 
@@ -1060 +851 @@
             call.FrameScale     = out->timeScale;
             call.InfoFlags      = out->infoFlags;
-            call.Version        = 0; /* -1; unsigned char cannot be negative */
+            call.Version        = 0;
+            call.WriteV         = isBufferedOutput ? BufferingWriteV : writev_with_retry;
 
             if (writer->writeData)
@@ -1117 +909 @@
     free(Encoding);
 
+    if (isBufferedOutput)
+        LinuxDvbBuffFlush(context);
+    
     return ret;
 }
@@ -1211 +1006 @@
         ret = cERR_LINUXDVB_NO_ERROR;
         *((int*)argument) = videoInfo.progressive;
+        break;
+    }
+    case OUTPUT_SET_BUFFER_SIZE: {
+        ret = cERR_LINUXDVB_ERROR;
+        if (!isBufferedOutput)
+        {
+            uint32_t bufferSize = *((uint32_t*)argument);
+            ret = cERR_LINUXDVB_NO_ERROR;
+            if (bufferSize > 0)
+            {
+                WriteSetBufferingSize(bufferSize);
+                isBufferedOutput = true;
+            }
+        }
         break;
     }

titan/libeplayer3/output/output.c

@@ -530 +530 @@
         }
         break;
+    }
     case OUTPUT_GET_PROGRESSIVE:
     {
@@ -545 +546 @@
         break;
     }
+    case OUTPUT_SET_BUFFER_SIZE:
+    {
+        if (context && context->playback)
+        {
+            if (context->output->video)
+            {
+                return context->output->video->Command(context, OUTPUT_SET_BUFFER_SIZE, argument);
+            }
+            else if (context->output->audio)
+            {
+                return context->output->audio->Command(context, OUTPUT_SET_BUFFER_SIZE, argument);
+            }
+        }
+        else
+        {
+            ret = cERR_OUTPUT_INTERNAL_ERROR;
+        }
+        break;
     }
     default:

titan/libeplayer3/output/writer/mipsel/aac.c

@@ -182 +182 @@
             return 0;
         }
+        
+        // STB can handle only AAC LC profile
+        if (0 == (call->data[2] & 0xC0))
+        {
+            // change profile AAC Main -> AAC LC (Low Complexity)
+            aac_printf(1, "change profile AAC Main -> AAC LC (Low Complexity) in the ADTS header");
+            call->data[2] = (call->data[2] & 0x1F) | 0x40;
+        }
     }
     else // check LOAS header
@@ -204 +212 @@
     iov[1].iov_base = call->data;
     iov[1].iov_len = call->len;
-    return writev_with_retry(call->fd, iov, 2);
+    return call->WriteV(call->fd, iov, 2);
 }
 
@@ -234 +242 @@
         HasADTSHeader(call->data, call->len) )
     {
+        //printf("%hhx %hhx %hhx %hhx %hhx %hhx %hhx %hhx\n", call->data[0], call->data[1], call->data[2], call->data[3], call->data[4], call->data[5], call->data[6], call->data[7]);
         return _writeData(_call, 0);
     }
@@ -274 +283 @@
     iov[1].iov_len = call->len;
     
-    return writev_with_retry(call->fd, iov, 2);
+    return call->WriteV(call->fd, iov, 2);
 }
 
@@ -344 +353 @@
     iov[2].iov_len  = pLATMCtx->len;
     
-    return writev_with_retry(call->fd, iov, 3);
+    return call->WriteV(call->fd, iov, 3);
 }
 

titan/libeplayer3/output/writer/mipsel/h264.c

@@ -56 +56 @@
 /* Makros/Constants              */
 /* ***************************** */
+#define H264_SILENT
 //#define H264_DEBUG
 #ifdef H264_DEBUG
@@ -88 +89 @@
 static unsigned int            CodecDataLen   = 0;
 static int                     avc3 = 0;
+static int                     sps_pps_in_stream = 0;
 /* ***************************** */
 /* Prototypes                    */
@@ -299 +301 @@
     initialHeader = 1;
     avc3 = 0;
+    sps_pps_in_stream = 0;
     return 0;
 }
@@ -344 +347 @@
         (call->data[0] == 0xff && call->data[1] == 0xff && call->data[2] == 0xff && call->data[3] == 0xff))))
     {
+        uint32_t i = 0;
+        uint8_t InsertPrivData = !sps_pps_in_stream;
         uint32_t PacketLength = 0;
         uint32_t FakeStartCode = (call->Version << 8) | PES_VERSION_FAKE_START_CODE;
-        
         iov[ic++].iov_base = PesHeader;
-        initialHeader = 0;
-        if (initialHeader) 
+        
+        while (InsertPrivData && i < 36 && (call->len - i) > 5)
+        {
+            if ( (call->data[i] == 0x00 && call->data[i+1] == 0x00 && call->data[i+2] == 0x00 && call->data[i+3] == 0x01 && (call->data[i+4] == 0x67 || call->data[i+4] == 0x68)) )
+            {
+                InsertPrivData = 0;
+                sps_pps_in_stream = 1;
+            }
+            i += 1;
+        }
+        
+        if (InsertPrivData && call->private_size > 0 /*&& initialHeader*/) // some rtsp streams can update codec data at runtime
         {
             initialHeader = 0;
@@ -356 +370 @@
             PacketLength     += call->private_size;
         }
-
-        iov[ic].iov_base = "";
-        iov[ic++].iov_len = 1;
         
         iov[ic].iov_base  = call->data;
@@ -364 +375 @@
         PacketLength     += call->len;
         
-        /*Hellmaster1024: some packets will only be accepted by the player if we send one byte more than
-                          data is available. The content of this byte does not matter. It will be ignored
-                          by the player */
-//obi
-        iov[ic].iov_base = "\0";
-        iov[ic++].iov_len = 1;
-//obi (end)
         iov[0].iov_len = InsertPesHeader(PesHeader, -1, MPEG_VIDEO_PES_START_CODE, VideoPts, FakeStartCode);
         
-        return writev_with_retry(call->fd, iov, ic);
+        return call->WriteV(call->fd, iov, ic);
     }
     else if (!call->private_data || call->private_size < 7 || 1 != call->private_data[0])
@@ -386 +390 @@
     iov[ic++].iov_base = PesHeader;
     
-    if (initialHeader)
+    if (!avc3)
     {
         if (CodecData)
@@ -458 +462 @@
         iov[0].iov_len = InsertPesHeader(PesHeader, -1, MPEG_VIDEO_PES_START_CODE, VideoPts, 0);
         
-        len = writev_with_retry(call->fd, iov, ic);
+        len = call->WriteV(call->fd, iov, ic);
         PacketLength += iov[0].iov_len;
         if (PacketLength != len)

titan/libeplayer3/output/writer/mipsel/h265.c

@@ -56 +56 @@
 /* Makros/Constants              */
 /* ***************************** */
+#define H264_SILENT
 //#define H265_DEBUG
 #ifdef H265_DEBUG
@@ -234 +235 @@
         iov[0].iov_len = InsertPesHeader(PesHeader, -1, MPEG_VIDEO_PES_START_CODE, VideoPts, FakeStartCode);
         
-        return writev_with_retry(call->fd, iov, ic);
+        return call->WriteV(call->fd, iov, ic);
     }
 
@@ -303 +304 @@
         iov[0].iov_len = InsertPesHeader(PesHeader, -1, MPEG_VIDEO_PES_START_CODE, VideoPts, 0);
         
-        len = writev_with_retry(call->fd, iov, ic);
+        len = call->WriteV(call->fd, iov, ic);
         PacketLength += iov[0].iov_len;
         if (PacketLength != len)

titan/libeplayer3/output/writer/mipsel/lpcm.c

@@ -257 +257 @@
         iov[1].iov_base = frame;
         iov[1].iov_len  = i_frame_size;
-        i_ret_size += writev_with_retry(call->fd, iov, 2);
+        i_ret_size += call->WriteV(call->fd, iov, 2);
     }
     

titan/libeplayer3/output/writer/mipsel/mpeg4.c

@@ -134 +134 @@
     }
 
-    struct iovec iov[2];
+    struct iovec iov[3];
     int ic = 0;
     iov[ic].iov_base = PesHeader;
@@ -148 +148 @@
     iov[ic++].iov_len = call->len;
 
-    int len = writev_with_retry(call->fd, iov, ic);
+    int len = call->WriteV(call->fd, iov, ic);
 
     mpeg4_printf(10, "xvid_Write < len=%d\n", len);

titan/libeplayer3/output/writer/mipsel/vp.c

@@ -97 +97 @@
 }
 
-static int writeData(void* _call, int is_vp6)
+static int writeData(void *_call, int is_vp6)
 {
     WriterAVCallData_t* call = (WriterAVCallData_t*) _call;
@@ -145 +145 @@
     iov[1].iov_len = call->len;
     
-    return writev_with_retry(call->fd, iov, 2);
+    return call->WriteV(call->fd, iov, 2);
 }
 

titan/libeplayer3/output/writer/mipsel/wmv.c

@@ -197 +197 @@
     }
     
-    return writev_with_retry(call->fd, iov, ic);
+    return call->WriteV(call->fd, iov, ic);
 }
 

titan/libeplayer3/output/writer/mipsel/writer.c

@@ -29 +29 @@
 #include "misc.h"
 #include "writer.h"
+#include "common.h"
 
 /* ***************************** */
@@ -98 +99 @@
 /*  Functions                    */
 /* ***************************** */
+static void FlusPipe(int pipefd)
+{
+    char tmp;
+    while(1 == read(pipefd, &tmp, 1));
+}
+
+ssize_t WriteWithRetry(Context_t *context, int pipefd, int fd, const void *buf, size_t size)
+{
+    fd_set rfds;
+    fd_set wfds;
+    
+    ssize_t ret;
+    int retval = -1;
+    int maxFd = pipefd > fd ? pipefd : fd;
+    struct timeval tv;
+    
+    while(size > 0 && 0 == PlaybackDieNow(0) && !context->playback->isSeeking)
+    {
+        FD_ZERO(&rfds);
+        FD_ZERO(&wfds);
+
+        FD_SET(pipefd, &rfds);
+        FD_SET(fd, &wfds);
+
+        /* When we PAUSE LINUX DVB outputs buffers then audio/video buffers 
+         * will be filled to full unfortunately, in such case after resume 
+         * select never return with fd set - bug in DVB drivers?
+         * So, there will be to workarounds:
+         *   1. write to pipe pipe at resume to exit select immediately
+         *   2. even if fd is not set exit from select after 0,1s 
+         *      (it seems that second workaround is not needed)
+         */
+        //tv.tv_sec = 0;
+        //tv.tv_usec = 100000; // 100ms
+        
+        retval = select(maxFd + 1, &rfds, &wfds, NULL, NULL); //&tv);
+        if (retval < 0)
+        {
+            break;
+        }
+        
+        //if (retval == 0)
+        //{
+        //    //printf("RETURN FROM SELECT DUE TO TIMEOUT TIMEOUT\n");
+        //    continue;
+        //}
+        
+        if(FD_ISSET(pipefd, &rfds))
+        {
+            FlusPipe(pipefd);
+            //printf("RETURN FROM SELECT DUE TO pipefd SET\n");
+            continue;
+        }
+        
+        if(FD_ISSET(fd, &wfds))
+        {
+            ret = write(fd, buf, size);
+            if (ret < 0)
+            {
+                switch(errno)
+                {
+                    case EINTR:
+                    case EAGAIN:
+                        continue;
+                    default:
+                        retval = -3;
+                        break;
+                }
+                if (retval < 0)
+                {
+                    break;
+                }
+                
+                return ret;
+            }
+            else if (ret == 0)
+            {
+                //printf("This should not happen. Select return fd ready to write, but write return 0, errno [%d]\n", errno);
+                tv.tv_sec = 0;
+                tv.tv_usec = 10000; // 10ms
+                retval = select(pipefd + 1, &rfds, NULL, NULL, &tv);
+                if (retval)
+                    FlusPipe(pipefd);
+                continue;
+            }
+            
+            size -= ret;
+            buf += ret;
+        }
+    }
+    return 0;
+}
+
 ssize_t write_with_retry(int fd, const void *buf, size_t size)
 {

titan/libeplayer3/output/writer/sh4/aac.c

@@ -181 +181 @@
             return 0;
         }
+        
+        // STB can handle only AAC LC profile
+        if (0 == (call->data[2] & 0xC0))
+        {
+            // change profile AAC Main -> AAC LC (Low Complexity)
+            aac_printf(1, "change profile AAC Main -> AAC LC (Low Complexity) in the ADTS header");
+            call->data[2] = (call->data[2] & 0x1F) | 0x40;
+        }
     }
     else // check LOAS header

titan/libeplayer3/output/writer/sh4/h264.c

@@ -53 +53 @@
 /* Makros/Constants              */
 /* ***************************** */
-//#define H264_DEBUG
-
 #ifdef SAM_WITH_DEBUG
 #define H264_DEBUG
@@ -102 +100 @@
 static uint32_t  NalLengthBytes = 1;
 static int       avc3 = 0;
+static int       sps_pps_in_stream = 0;
 /* ***************************** */
 /* Prototypes                    */
@@ -260 +259 @@
         (call->data[0] == 0xff && call->data[1] == 0xff && call->data[2] == 0xff && call->data[3] == 0xff))))
     {
+        uint32_t i = 0;
+        uint8_t InsertPrivData = !sps_pps_in_stream;
         uint32_t PacketLength = 0;
-        uint32_t FakeStartCode = /*(call->Version << 8) | */PES_VERSION_FAKE_START_CODE;
-        
+        uint32_t FakeStartCode = PES_VERSION_FAKE_START_CODE;
         iov[ic++].iov_base = PesHeader;
-        initialHeader = 0;
-        if (initialHeader) 
+        
+        while (InsertPrivData && i < 36 && (call->len - i) > 5)
+        {
+            if ( (call->data[i] == 0x00 && call->data[i+1] == 0x00 && call->data[i+2] == 0x00 && call->data[i+3] == 0x01 && (call->data[i+4] == 0x67 || call->data[i+4] == 0x68)) )
+            {
+                InsertPrivData = 0;
+                sps_pps_in_stream = 1;
+            }
+            i += 1;
+        }
+        
+        if (InsertPrivData && call->private_size > 0 /*&& initialHeader*/) // some rtsp streams can update codec data at runtime
         {
             initialHeader = 0;
@@ -296 +306 @@
     }
 
-    if (initialHeader)
+    if (!avc3)
     {
         uint8_t  *private_data = call->private_data;

titan/libeplayer3/playback/playback.c

@@ -58 +58 @@
 #define cMaxSpeed_fr   -320 /* fixme: revise */
 
+#define MAX_PLAYBACK_DIE_NOW_CALLBACKS 10
+
 /* ***************************** */
 /* Varaibles                     */
@@ -68 +70 @@
 static int32_t PlaybackTerminate(Context_t  *context);
 
+static int8_t dieNow = 0;
+static PlaybackDieNowCallback playbackDieNowCallbacks[MAX_PLAYBACK_DIE_NOW_CALLBACKS] = {NULL};
+
 /* ***************************** */
 /* MISC Functions                */
@@ -73 +78 @@
 int8_t PlaybackDieNow(int8_t val)
 {
-    static int8_t dieNow = 0;
-    if(val)
-    {
+    if(val && dieNow == 0)
+    {
+        uint32_t i = 0;
         dieNow = 1;
+        while (i < MAX_PLAYBACK_DIE_NOW_CALLBACKS)
+        {
+            if (playbackDieNowCallbacks[i] == NULL)
+            {
+                break;
+            }
+            playbackDieNowCallbacks[i]();
+            i += 1;
+        }
     }
     return dieNow;
+}
+
+bool PlaybackDieNowRegisterCallback(PlaybackDieNowCallback callback)
+{
+    bool ret = false;
+    if (callback)
+    {
+        uint32_t i = 0;
+        while (i < MAX_PLAYBACK_DIE_NOW_CALLBACKS)
+        {
+            if (playbackDieNowCallbacks[i] == callback)
+            {
+                ret = true;
+                break;
+            }
+            
+            if (playbackDieNowCallbacks[i] == NULL)
+            {
+                playbackDieNowCallbacks[i] = callback;
+                ret = true;
+                break;
+            }
+            i += 1;
+        }
+    }
+    return ret;
 }