Changeset 42177 for titan/libeplayer3

Timestamp:

04/14/18 13:20:15 (6 years ago)

Author:

obi

Message:

reset libeplayer3 to v36

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)
• manager/audio.c (modified) (1 diff)
• output/linuxdvb_mipsel.c (modified) (55 diffs)
• output/output.c (modified) (2 diffs)
• output/writer/mipsel/aac.c (modified) (5 diffs)
• output/writer/mipsel/ac3.c (modified) (1 diff)
• output/writer/mipsel/amr.c (modified) (1 diff)
• output/writer/mipsel/divx3.c (modified) (1 diff)
• output/writer/mipsel/dts.c (modified) (1 diff)
• output/writer/mipsel/h263.c (modified) (1 diff)
• 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/mp3.c (modified) (1 diff)
• output/writer/mipsel/mpeg2.c (modified) (1 diff)
• output/writer/mipsel/mpeg4.c (modified) (2 diffs)
• output/writer/mipsel/pcm.c (modified) (1 diff)
• output/writer/mipsel/vc1.c (modified) (1 diff)
• output/writer/mipsel/vp.c (modified) (2 diffs)
• output/writer/mipsel/wma.c (modified) (1 diff)
• 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                    */
@@ -166 +164 @@
     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"
@@ -470 +426 @@
 }
 
-//static int32_t mutexInitialized = 0;
+static int32_t mutexInitialized = 0;
 
 void sel_program_id_set(const int32_t val)
@@ -540 +496 @@
 {
     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);
 }
 
@@ -720 +703 @@
         pts = INVALID_PTS_VALUE;
     }
-    else
-    {
-        pts &= 0x01FFFFFFFF; // PES header can handle only 33 bit PTS
-    }
 
     return pts;
@@ -819 +798 @@
     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) 
@@ -835 +806 @@
             continue;
         }
-#endif
 
         if (context->playback->isSeeking) 
@@ -959 +929 @@
             
             reset_finish_timeout();
-            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->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");
+            }
+
             ffmpeg_printf(200, "packet.size %d - index %d\n", packet.size, pid);
 
@@ -1073 +1037 @@
                     }
 
-                    if (Write(context->output->video->Write, context, &avOut, pts) < 0)
+                    if (context->output->video->Write(context, &avOut) < 0)
                     {
                         ffmpeg_err("writing data to video device failed\n");
@@ -1149 +1113 @@
                     avOut.type       = "audio";
 
-                    if (Write(context->output->audio->Write, context, &avOut, pts) < 0)
+                    if (context->output->audio->Write(context, &avOut) < 0)
                     {
                         ffmpeg_err("(raw pcm) writing data to audio device failed\n");
@@ -1344 +1308 @@
                         avOut.type       = "audio";
 
-                        if (!context->playback->BackWard && Write(context->output->audio->Write, context, &avOut, pts) < 0)
+                        if (!context->playback->BackWard && context->output->audio->Write(context, &avOut) < 0)
                         {
                             ffmpeg_err("writing data to audio device failed\n");
@@ -1367 +1331 @@
                     avOut.type       = "audio";
 
-                    if (!context->playback->BackWard && Write(context->output->audio->Write, context, &avOut, pts) < 0)
+                    if (!context->playback->BackWard && context->output->audio->Write(context, &avOut) < 0)
                     {
                         ffmpeg_err("(aac) writing data to audio device failed\n");
@@ -1385 +1349 @@
                     avOut.type       = "audio";
 
-                    if (!context->playback->BackWard && Write(context->output->audio->Write, context, &avOut, pts) < 0)
+                    if (!context->playback->BackWard && context->output->audio->Write(context, &avOut) < 0)
                     {
                         ffmpeg_err("writing data to audio device failed\n");
@@ -1433 +1397 @@
                     //obi (end)
 
-                    if (Write(context->output->subtitle->Write, context, &subOut, pts) < 0)
+                    if (context->output->subtitle->Write(context, &subOut) < 0)
                     {
                         ffmpeg_err("writing data to teletext fifo failed\n");
@@ -1581 +1545 @@
 
 #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)
 {
-    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;
+    size_t ret = fread ( (void *) buffer, (size_t) 1, (size_t) lSize, (FILE *)ptr );
+    return (int)ret;
+}
+
+// whence: SEEK_SET, SEEK_CUR, SEEK_END (like fseek) and AVSEEK_SIZE
+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);
+    }
+    return ret;
+}
+
+AVIOContext* container_ffmpeg_get_avio_context(char *filename, size_t avio_ctx_buffer_size)
+{
+        if(strstr(filename, "file://") == filename)
+        {
+            filename += 7;
         }
         
-        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 );
+        FILE *pFile = fopen(filename, "rb");
+        if(NULL == pFile)
+        {
+            return NULL;
         }
         
-        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)
-{   
-    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;
-        }
+        AVIOContext *avio_ctx = NULL;
+        uint8_t *avio_ctx_buffer = NULL;
         
-        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(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;
-        
-        custom_io->pMoovFile = fopen(custom_io->szMoovAtomFile, "rb");
-        if(NULL == custom_io->pMoovFile)
-        {
-            fclose(custom_io->pFile);
+        avio_ctx_buffer = av_malloc(avio_ctx_buffer_size);
+        if (!avio_ctx_buffer) 
+        {
             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, custom_io, &SAM_ReadFunc, NULL, &SAM_SeekFunc);
-    if (!avio_ctx) 
-    {
-        return NULL;
-    }
-    return avio_ctx;
+        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;
 }
 #endif
 
-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 container_ffmpeg_init_av_context(Context_t *context, char *filename, int32_t AVIdx)
 {
     int32_t err = 0;
@@ -1746 +1608 @@
        0 == strncmp(filename, "file://", 7))
     {
-        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);
+        AVIOContext *avio_ctx = container_ffmpeg_get_avio_context(filename, 4096);
         if(avio_ctx)
         {
@@ -1763 +1616 @@
         else
         {
-            free(custom_io_tab[AVIdx]);
-            custom_io_tab[AVIdx] = NULL;
             return cERR_CONTAINER_FFMPEG_OPEN;
         }
@@ -2303 +2154 @@
  
     context->playback->abortRequested = 0;
-    int32_t res = container_ffmpeg_init_av_context(context, playFilesNames->szFirstFile, playFilesNames->iFirstFileSize, \
-                                                   playFilesNames->szFirstMoovAtomFile, playFilesNames->iFirstMoovAtomOffset, 0);
+    int32_t res = container_ffmpeg_init_av_context(context, playFilesNames->szFirstFile, 0);
     if(0 != res)
     {
@@ -2310 +2160 @@
     }
 
-    if(playFilesNames->szSecondFile && playFilesNames->szSecondFile[0] != '\0')
-    {
-        res = container_ffmpeg_init_av_context(context, playFilesNames->szSecondFile, playFilesNames->iSecondFileSize, \
-                                               playFilesNames->szSecondMoovAtomFile, playFilesNames->iSecondMoovAtomOffset, 1);
+    if(playFilesNames->szSecondFile)
+    {
+        res = container_ffmpeg_init_av_context(context, playFilesNames->szSecondFile, 1);
     }
     
@@ -2334 +2183 @@
 int32_t container_ffmpeg_update_tracks(Context_t *context, char *filename, int32_t initial)
 {
-    Track_t *currAudioTrack = NULL;
-    Track_t *currSubtitleTrack = NULL;
-    uint32_t addedVideoTracksCount = 0;
+    Track_t *audioTrack = NULL;
+    Track_t *subtitleTrack = NULL;
     
     if (terminating)
@@ -2343 +2191 @@
     }
     
-    getMutex(__FILE__, __FUNCTION__,__LINE__);
-    
     if (initial && context->manager->subtitle)
     {
-        context->manager->subtitle->Command(context, MANAGER_GET_TRACK, &currSubtitleTrack);
+        context->manager->subtitle->Command(context, MANAGER_GET_TRACK, &subtitleTrack);
     }
 
     if (context->manager->audio)
     {
-        context->manager->audio->Command(context, MANAGER_GET_TRACK, &currAudioTrack);
+        context->manager->audio->Command(context, MANAGER_GET_TRACK, &audioTrack);
     }
 
@@ -2371 +2217 @@
     }
 #endif
+
 
     ffmpeg_printf(20, "dump format\n");
@@ -2448 +2295 @@
                 }
                 
-                if (!isStreamFromSelProg) {
-                    stream->discard = AVDISCARD_ALL;
-                    ffmpeg_printf(1, "cAVIdx[%d]: add DISCARD flag to  stream index[%d]\n", cAVIdx, stream->index);
+                if (!isStreamFromSelProg)
                     continue; // skip this stream
-                }
             }
 
@@ -2485 +2329 @@
             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) 
                 {
@@ -2565 +2409 @@
                             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;
-                        }
                     }
                 }
@@ -2582 +2418 @@
             case AVMEDIA_TYPE_AUDIO:
                 ffmpeg_printf(10, "CODEC_TYPE_AUDIO %d\n",get_codecpar(stream)->codec_type);
-                stream->discard = AVDISCARD_ALL;
+
                 if (encoding != NULL)
                 {
@@ -2954 +2790 @@
             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;
@@ -2961 +2796 @@
     
     }
-    
-    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;
 }
@@ -3322 +3119 @@
     }
 
-//    getMutex(__FILE__, __FUNCTION__,__LINE__);
+    getMutex(__FILE__, __FUNCTION__,__LINE__);
 
     if (!context->playback || !context->playback->isPlaying)
@@ -3341 +3138 @@
         */
 
-        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);
@@ -3377 +3172 @@
     }
 
-//    releaseMutex(__FILE__, __FUNCTION__,__LINE__);
+    releaseMutex(__FILE__, __FUNCTION__,__LINE__);
     return cERR_CONTAINER_FFMPEG_NO_ERROR;
 }
@@ -3438 +3233 @@
 {
     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 = -1;
+    int64_t sec = -5;
     context->playback->Command(context, PLAYBACK_SEEK, (void*)&sec);
     return cERR_CONTAINER_FFMPEG_NO_ERROR;
@@ -3472 +3249 @@
      * but now we will not ignore subtitle frame
      */
-    int64_t sec = -1;
+    int64_t sec = -5;
     context->playback->Command(context, PLAYBACK_SEEK, (void*)&sec);
     //obi

titan/libeplayer3/container/flv2mpeg4_ffmpeg.c

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

titan/libeplayer3/container/mpeg4p2_ffmpeg.c

@@ -112 +112 @@
     avOut.type       = "video";
 
-    if (Write(ctx->output->video->Write, ctx, &avOut, avOut.pts) < 0)
+    if (ctx->output->video->Write(ctx, &avOut) < 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;
 
@@ -69 +68 @@
     char * Name;
     int32_t (* Command) (/*Context_t*/void  *, OutputCmd_t, void *);
-    int32_t (* Write) (/*Context_t*/void  *, void *);
+    int32_t (* Write) (/*Context_t*/void  *, void* privateData);
     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;
@@ -23 +22 @@
     unsigned char          Version;
     unsigned int           InfoFlags;
-    ssize_t                (* WriteV) (int, const struct iovec *, size_t);
 } WriterAVCallData_t;
 
@@ -89 +87 @@
 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 and kbhit */
+static int g_pfd[2] = {-1, -1}; /* Used to wake terminate thread */
 static int isPlaybackStarted = 0;
 static pthread_mutex_t playbackStartMtx;
-
-static void TerminateWakeUp()
-{
-    write(g_pfd[1], "x", 1);
-}
 
 static void *TermThreadFun(void *arg)
@@ -141 +136 @@
     if (FD_ISSET(fd, &readfds))
     {
+        /*
+        if ( (cl = accept(fd, NULL, NULL)) == -1)
+        {
+            perror("TermThreadFun accept error");
+            goto finish;
+        }
+        */
+        
         pthread_mutex_lock(&playbackStartMtx);
         PlaybackDieNow(1);
@@ -181 +184 @@
 {
     struct timeval 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))
+    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))
     {
         return 0;
     }
 
-    if(FD_ISSET(0, &readfds))
+    if(FD_ISSET(0,&read_fd))
     {
         return 1;
@@ -367 +369 @@
 }
 
-static int ParseParams(int argc,char* argv[], PlayFiles_t *playbackFiles, int *pAudioTrackIdx, int *subtitleTrackIdx, uint32_t *linuxDvbBufferSizeMB)
+static int ParseParams(int argc,char* argv[], char *file, char *audioFile, int *pAudioTrackIdx, int *subtitleTrackIdx)
 {   
     int ret = 0;
@@ -374 +376 @@
     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:b:F:S:O:")) != -1) 
+    while ( (c = getopt(argc, argv, "we3dlsrimva:n:x:u:c:h:o:p:P:t:9:0:1:4:f:")) != -1) 
     {
         switch (c) 
@@ -435 +437 @@
             break;
         case 'x':
-            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);
-            }
+            strncpy(audioFile, optarg, IPTV_MAX_FILE_PATH-1);
+            map_inter_file_path(audioFile);
             break;
         case 'h':
@@ -490 +486 @@
             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);
@@ -518 +495 @@
     {
         ret = 0;
-        playbackFiles->szFirstFile = malloc(IPTV_MAX_FILE_PATH);
-        playbackFiles->szFirstFile[0] = '\0';
+        
         if(NULL == strstr(argv[optind], "://"))
         {
-            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);
+            strcpy(file, "file://");
+        }
+        strcat(file, argv[optind]);
+        map_inter_file_path(file);
+        printf("file: [%s]\n", file);
         ++optind;
     }
@@ -541 +516 @@
     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];
@@ -551 +529 @@
     int commandRetVal = -1;
     /* inform client that we can handle additional commands */
-    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))
+    fprintf(stderr, "{\"EPLAYER3_EXTENDED\":{\"version\":%d}}\n", 36);
+
+    if (0 != ParseParams(argc, argv, file, audioFile, &audioTrackIdx, &subtitleTrackIdx))
     {
         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");
@@ -585 +560 @@
         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);
     }
@@ -626 +599 @@
             isTermThreadStarted = 1;
     } while(0);
-    
+
     g_player->playback    = &PlaybackHandler;
     g_player->output      = &OutputHandler;
@@ -641 +614 @@
     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(playbackFiles.szFirstFile, "rtmp", 4) && strncmp(playbackFiles.szFirstFile, "ffrtmp", 4))
+    if (strncmp(file, "rtmp", 4) && strncmp(file, "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, playbackFiles.szFirstFile, commandRetVal);
+    fprintf(stderr, "{\"PLAYBACK_OPEN\":{\"OutputName\":\"%s\", \"file\":\"%s\", \"sts\":%d}}\n", g_player->output->Name, file, commandRetVal);
     if(commandRetVal < 0)
     {
@@ -676 +650 @@
         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");
@@ -698 +670 @@
         }
 
-        while(g_player->playback->isPlaying && 0 == PlaybackDieNow(0))
+        while(g_player->playback->isPlaying)
         {
             /* we made fgets non blocking */
@@ -876 +848 @@
                 if (0 == 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);
-                    }
+                    fprintf(stderr, "{\"J\":{\"ms\":%lld}}\n", pts / 90, commandRetVal);
                 }
                 break;
@@ -947 +905 @@
     close(g_pfd[0]);
     close(g_pfd[1]);
-    
+
+    //printOutputCapabilities();
+
     exit(0);
 }

titan/libeplayer3/manager/audio.c

@@ -220 +220 @@
         break;
     }
-    case MANAGER_REF_LIST:
-    {
-        *((Track_t **)argument) = Tracks;
-        break;
-    }
-    case MANAGER_REF_LIST_SIZE:
-    {
-        *((int*)argument) = TrackCount;
-        break;
-    }
-    
     case MANAGER_GET: 
     {

titan/libeplayer3/output/linuxdvb_mipsel.c

@@ -26 +26 @@
 #include <stdlib.h>
 #include <unistd.h>
-#include <stdbool.h>
 #include <fcntl.h>
 #include <sys/types.h>
@@ -54 +53 @@
 #define LINUXDVB_SILENT
 
-static uint16_t debug_level = 0;
+static unsigned short debug_level = 0;
 
 static const char FILENAME[] = __FILE__;
@@ -74 +73 @@
 #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;
@@ -90 +89 @@
 
 unsigned long long int sCURRENT_PTS = 0;
-bool isBufferedOutput = false;
 
 pthread_mutex_t LinuxDVBmutex;
@@ -97 +95 @@
 /* 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);
 
@@ -111 +101 @@
 /* ***************************** */
 
-void getLinuxDVBMutex(const char *filename __attribute__((unused)), const char *function __attribute__((unused)), int line __attribute__((unused)))
-{
+void getLinuxDVBMutex(const char *filename __attribute__((unused)), const char *function __attribute__((unused)), int line __attribute__((unused))) {
+
+    linuxdvb_printf(250, "requesting mutex\n");
+
     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;
@@ -129 +126 @@
 }
 
-int LinuxDvbOpen(Context_t  *context __attribute__((unused)), char *type)
-{
-    uint8_t video = !strcmp("video", type);
-    uint8_t audio = !strcmp("audio", type);
+int LinuxDvbOpen(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);
@@ -142 +138 @@
         if (videofd < 0)
         {
-            linuxdvb_err("failed to open %s - errno %d, %s\n", VIDEODEV, errno, strerror(errno));
-            linuxdvb_err("%s\n", );
+            linuxdvb_err("failed to open %s - errno %d\n", VIDEODEV, errno);
+            linuxdvb_err("%s\n", strerror(errno));
             return cERR_LINUXDVB_ERROR;
         }
@@ -149 +145 @@
         if (ioctl( videofd, VIDEO_CLEAR_BUFFER) == -1)
         {
-            linuxdvb_err("VIDEO_CLEAR_BUFFER: ERROR %d, %s\n", errno, strerror(errno));
+            linuxdvb_err("ioctl failed with errno %d\n", errno);
+            linuxdvb_err("VIDEO_CLEAR_BUFFER: %s\n", strerror(errno));
         }
 
         if (ioctl( videofd, VIDEO_SELECT_SOURCE, (void*)VIDEO_SOURCE_MEMORY) == -1)
         {
-            linuxdvb_err("VIDEO_SELECT_SOURCE: ERROR %d, %s\n", errno, strerror(errno));
+            linuxdvb_err("ioctl failed with errno %d\n", errno);
+            linuxdvb_err("VIDEO_SELECT_SOURCE: %s\n", strerror(errno));
         }
         
         if (ioctl(videofd, VIDEO_FREEZE) == -1)
         {
-            linuxdvb_err("VIDEO_FREEZE: ERROR %d, %s\n", errno, strerror(errno));
-        }
-
-        if (isBufferedOutput)
-            LinuxDvbBuffOpen(context, type, videofd);
+            linuxdvb_err("ioctl failed with errno %d\n", errno);
+            linuxdvb_err("VIDEO_FREEZE: %s\n", strerror(errno));
+        }
+
     }
     if (audio && audiofd < 0) 
@@ -171 +168 @@
         if (audiofd < 0)
         {
-            linuxdvb_err("failed to open %s - errno %d, %s\n", AUDIODEV, errno, strerror(errno));
+            linuxdvb_err("failed to open %s - errno %d\n", AUDIODEV, errno);
+            linuxdvb_err("%s\n", strerror(errno));
+            
             return cERR_LINUXDVB_ERROR;
         }
@@ -177 +176 @@
         if (ioctl( audiofd, AUDIO_CLEAR_BUFFER) == -1)
         {
-            linuxdvb_err("AUDIO_CLEAR_BUFFER: ERROR %d, %s\n", errno, strerror(errno));
+            linuxdvb_err("ioctl failed with errno %d\n", errno);
+            linuxdvb_err("AUDIO_CLEAR_BUFFER: %s\n", strerror(errno));
         }
 
         if (ioctl( audiofd, AUDIO_SELECT_SOURCE, AUDIO_SOURCE_MEMORY) == -1)
         {
-            linuxdvb_err("AUDIO_SELECT_SOURCE: ERROR %d, %s\n", errno, strerror(errno));
+            linuxdvb_err("ioctl failed with errno %d\n", errno);
+            linuxdvb_err("AUDIO_SELECT_SOURCE: %s\n", strerror(errno));
         }
         
         if (ioctl( audiofd, AUDIO_PAUSE) == -1)
         {
-            linuxdvb_err("AUDIO_PAUSE: ERROR %d, %s\n", errno, strerror(errno));
+            linuxdvb_err("ioctl failed with errno %d\n", errno);
+            linuxdvb_err("AUDIO_PAUSE: %s\n", strerror(errno));
         }
         
-        if (isBufferedOutput)
-            LinuxDvbBuffOpen(context, type, audiofd);
     }
 
@@ -197 +197 @@
 }
 
-int LinuxDvbClose(Context_t  *context, char *type)
+int LinuxDvbClose(Context_t  *context, char * type)
 {
-    uint8_t video = !strcmp("video", type);
-    uint8_t audio = !strcmp("audio", type);
+    unsigned char video = !strcmp("video", type);
+    unsigned char 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)
@@ -226 +223 @@
     }
 
-    releaseLinuxDVBMutex(FILENAME, __FUNCTION__, __LINE__);
+    releaseLinuxDVBMutex(FILENAME, __FUNCTION__,__LINE__);
     return cERR_LINUXDVB_NO_ERROR;
 }
 
-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);
+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);
 
     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);
 
@@ -246 +243 @@
 
         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)
         {
@@ -256 +264 @@
             if (ioctl( videofd, VIDEO_SET_STREAMTYPE, (void*) writer->caps->dvbStreamType) == -1)
             {
-                linuxdvb_err("VIDEO_SET_STREAMTYPE: ERROR %d, %s\n", errno, strerror(errno));
+                linuxdvb_err("ioctl failed with errno %d\n", errno);
+                linuxdvb_err("VIDEO_SET_STREAMTYPE: %s\n", strerror(errno));
                 ret = cERR_LINUXDVB_ERROR;
             }
@@ -264 +273 @@
         if (0 != ioctl(videofd, VIDEO_PLAY))
         {
-            linuxdvb_err("VIDEO_PLAY: ERROR %d, %s\n", errno, strerror(errno));
+            linuxdvb_err("ioctl failed with errno %d\n", errno);
+            linuxdvb_err("VIDEO_PLAY: %s\n", strerror(errno));
             ret = cERR_LINUXDVB_ERROR;
         }
@@ -270 +280 @@
         if (ioctl(videofd, VIDEO_CONTINUE) == -1)
         {
-            linuxdvb_err("VIDEO_CONTINUE: ERROR %d, %s\n", errno, strerror(errno));
+            linuxdvb_err("ioctl failed with errno %d\n", errno);
+            linuxdvb_err("VIDEO_CONTINUE: %s\n", strerror(errno));
         }
         
         if (ioctl( videofd, VIDEO_CLEAR_BUFFER) == -1)
         {
-            linuxdvb_err("VIDEO_CLEAR_BUFFER: ERROR %d, %s\n", errno, strerror(errno));
+            linuxdvb_err("ioctl failed with errno %d\n", errno);
+            linuxdvb_err("VIDEO_CLEAR_BUFFER: %s\n", strerror(errno));
         }
     }
@@ -286 +298 @@
         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)
         {
@@ -296 +318 @@
             if (ioctl( audiofd, AUDIO_SET_BYPASS_MODE, (void*) LinuxDvbMapBypassMode(writer->caps->dvbStreamType)) < 0)
             {
-                linuxdvb_err("AUDIO_SET_BYPASS_MODE: ERROR %d, %s\n", errno, strerror(errno));
+                linuxdvb_err("ioctl failed with errno %d\n", errno);
+                linuxdvb_err("AUDIO_SET_BYPASS_MODE: %s\n", strerror(errno));
                 ret = cERR_LINUXDVB_ERROR;
             }
@@ -303 +326 @@
         if (ioctl(audiofd, AUDIO_PLAY) < 0)
         {
-            linuxdvb_err("AUDIO_PLAY: ERROR %d, %s\n", errno, strerror(errno));
+            linuxdvb_err("ioctl failed with errno %d\n", errno);
+            linuxdvb_err("AUDIO_PLAY: %s\n", strerror(errno));
             ret = cERR_LINUXDVB_ERROR;
         }
@@ -309 +333 @@
         if (ioctl(audiofd, AUDIO_CONTINUE) < 0)
         {
-            linuxdvb_err("AUDIO_CONTINUE: ERROR %d, %s\n", errno, strerror(errno));
+            linuxdvb_err("ioctl failed with errno %d\n", errno);
+            linuxdvb_err("AUDIO_CONTINUE: %s\n", strerror(errno));
             ret = cERR_LINUXDVB_ERROR;
         }
@@ -333 +358 @@
         if (ioctl(videofd, VIDEO_CLEAR_BUFFER) == -1)
         {
-            linuxdvb_err("VIDEO_CLEAR_BUFFER: ERROR %d, %s\n", errno, strerror(errno));
+            linuxdvb_err("ioctl failed with errno %d\n", errno);
+            linuxdvb_err("VIDEO_CLEAR_BUFFER: %s\n", strerror(errno));
         }
         
         if (ioctl(videofd, VIDEO_STOP) == -1)
         {
-            linuxdvb_err("VIDEO_STOP: ERROR %d, %s\n", errno, strerror(errno));
+            linuxdvb_err("ioctl failed with errno %d\n", errno);
+            linuxdvb_err("VIDEO_STOP: %s\n", strerror(errno));
             ret = cERR_LINUXDVB_ERROR;
         }
@@ -344 +371 @@
         ioctl(videofd, VIDEO_SLOWMOTION, 0);
         ioctl(videofd, VIDEO_FAST_FORWARD, 0);
+
         ioctl(videofd, VIDEO_SELECT_SOURCE, VIDEO_SOURCE_DEMUX);
     }
@@ -349 +377 @@
         if (ioctl(audiofd, AUDIO_CLEAR_BUFFER) == -1)
         {
-            linuxdvb_err("AUDIO_CLEAR_BUFFER: ERROR %d, %s\n", errno, strerror(errno));
-        }
-
+            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));
+        // }
         if (ioctl(audiofd, AUDIO_STOP) == -1)
         {
-            linuxdvb_err("AUDIO_STOP: ERROR %d, %s\n", errno, strerror(errno));
+            linuxdvb_err("ioctl failed with errno %d\n", errno);
+            linuxdvb_err("AUDIO_STOP: %s\n", strerror(errno));
             ret = cERR_LINUXDVB_ERROR;
         }
@@ -365 +401 @@
 }
 
-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);
+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);
 
     linuxdvb_printf(10, "v%d a%d\n", video, audio);
@@ -374 +410 @@
     getLinuxDVBMutex(FILENAME, __FUNCTION__,__LINE__);
 
-    if (video && videofd != -1) 
-    {
+    if (video && videofd != -1) {
         if (ioctl(videofd, VIDEO_FREEZE, NULL) == -1)
         {
-            linuxdvb_err("VIDEO_FREEZE: ERROR %d, %s\n", errno, strerror(errno));
-            ret = cERR_LINUXDVB_ERROR;
-        }
-    }
+            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) {
+        if (ioctl(audiofd, AUDIO_PAUSE, NULL) == -1)
+        {
+            linuxdvb_err("ioctl failed with errno %d\n", errno);
+            linuxdvb_err("AUDIO_PAUSE: %s\n", strerror(errno));
+            ret = cERR_LINUXDVB_ERROR;
+        }
+    }
+
+    releaseLinuxDVBMutex(FILENAME, __FUNCTION__,__LINE__);
+
+    return ret;
+}
+
+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);
+
+    linuxdvb_printf(10, "v%d a%d\n", video, audio);
+
+    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) {
+        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_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;
     
-    if (audio && audiofd != -1)
-    {
-        if (ioctl(audiofd, AUDIO_PAUSE, NULL) == -1)
-        {
-            linuxdvb_err("AUDIO_PAUSE: ERROR %d, %s\n", errno, strerror(errno));
-            ret = cERR_LINUXDVB_ERROR;
-        }
-    }
-
-    releaseLinuxDVBMutex(FILENAME, __FUNCTION__,__LINE__);
-
-    return ret;
-}
-
-int LinuxDvbContinue(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);
-
-    if (video && videofd != -1)
-    {
-        if (ioctl(videofd, VIDEO_CONTINUE, NULL) == -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("AUDIO_CONTINUE: ERROR %d, %s\n", errno, strerror(errno));
-            ret = cERR_LINUXDVB_ERROR;
-        }
-    }
-    
-    if (isBufferedOutput)
-        LinuxDvbBuffResume(context);
-
-    linuxdvb_printf(10, "exiting\n");
-    
+    // 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;
 }
@@ -438 +487 @@
         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("AUDIO_STOP: ERROR %d, %s\n", errno, strerror(errno));
+                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));
                 ret = cERR_LINUXDVB_ERROR;
             }
@@ -446 +499 @@
         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("AUDIO_PLAY: ERROR %d, %s\n", errno, strerror(errno));
+                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));
                 ret = cERR_LINUXDVB_ERROR;
             }
@@ -458 +515 @@
     return ret;
 }
+
 
 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) {
-    int32_t ret = cERR_LINUXDVB_NO_ERROR;
-
-    uint8_t video = !strcmp("video", type);
-    uint8_t audio = !strcmp("audio", 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\n", video, audio);
@@ -478 +660 @@
             if (ioctl(videofd, VIDEO_SLOWMOTION, context->playback->SlowMotion) == -1)
             {
-                linuxdvb_err("VIDEO_SLOWMOTION: ERROR %d, %s\n", errno, strerror(errno));
+                linuxdvb_err("ioctl failed with errno %d\n", errno);
+                linuxdvb_err("VIDEO_SLOWMOTION: %s\n", strerror(errno));
                 ret = cERR_LINUXDVB_ERROR;
             }
@@ -491 +674 @@
 }
 
-int LinuxDvbAVSync(Context_t  *context, char *type __attribute__((unused))) {
-    int32_t ret = cERR_LINUXDVB_NO_ERROR;
+int LinuxDvbAVSync(Context_t  *context, char * type __attribute__((unused))) {
+    int 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
@@ -504 +687 @@
         if (ioctl(audiofd, AUDIO_SET_AV_SYNC, 0) == -1) //context->playback->AVSync) == -1)
         {
-            linuxdvb_err("AUDIO_SET_AV_SYNC: ERROR %d, %s\n", errno, strerror(errno));
+            linuxdvb_err("ioctl failed with errno %d\n", errno);
+            linuxdvb_err("AUDIO_SET_AV_SYNC: %s\n", strerror(errno));
             ret = cERR_LINUXDVB_ERROR;
         }
@@ -514 +698 @@
 }
 
-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;
@@ -520 +704 @@
     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) ) 
@@ -530 +714 @@
             if (ioctl(videofd, VIDEO_CLEAR_BUFFER) == -1)
             {
-                linuxdvb_err("VIDEO_CLEAR_BUFFER: ERROR %d, %s\n", errno, strerror(errno));
+                linuxdvb_err("ioctl failed with errno %d\n", errno);
+                linuxdvb_err("VIDEO_CLEAR_BUFFER: %s\n", strerror(errno));
                 ret = cERR_LINUXDVB_ERROR;
             }
@@ -538 +723 @@
             if (ioctl(audiofd, AUDIO_CLEAR_BUFFER) == -1)
             {
-                linuxdvb_err("AUDIO_CLEAR_BUFFER: ERROR %d, %s\n", errno, strerror(errno));
+                linuxdvb_err("ioctl failed with errno %d\n", errno);
+                linuxdvb_err("AUDIO_CLEAR_BUFFER: %s\n", strerror(errno));
                 ret = cERR_LINUXDVB_ERROR;
             }
@@ -552 +738 @@
 
 int LinuxDvbPts(Context_t  *context __attribute__((unused)), unsigned long long int* pts) {
-    int32_t ret = cERR_LINUXDVB_ERROR;
+    int ret = cERR_LINUXDVB_ERROR;
     
     linuxdvb_printf(50, "\n");
 
-    // GET_PTS is immutable call, so it can be done in parallel to other requests
+    // pts is a non writting requests and can be done in parallel to other requests
+    //getLinuxDVBMutex(FILENAME, __FUNCTION__,__LINE__);
+
     if (videofd > -1 && !ioctl(videofd, VIDEO_GET_PTS, (void*)&sCURRENT_PTS))
     {
@@ -563 +751 @@
     else
     {
-        linuxdvb_err("VIDEO_GET_PTS: ERROR %d, %s\n", errno, strerror(errno));
+        linuxdvb_err("VIDEO_GET_PTS: %d (%s)\n", errno, strerror(errno));
     }
 
@@ -574 +762 @@
         else
         {
-            linuxdvb_err("AUDIO_GET_PTS: ERROR %d, %s\n", errno, strerror(errno));
+            linuxdvb_err("AUDIO_GET_PTS: %d (%s)\n", errno, strerror(errno));
         }
     }
@@ -584 +772 @@
 
     *((unsigned long long int *)pts)=(unsigned long long int)sCURRENT_PTS;
+
+    //releaseLinuxDVBMutex(FILENAME, __FUNCTION__,__LINE__);
+
     return ret;
 }
@@ -589 +780 @@
 int LinuxDvbGetFrameCount(Context_t  *context __attribute__((unused)), unsigned long long int* frameCount)
 {
-    return cERR_LINUXDVB_NO_ERROR;
-}
-
-int LinuxDvbSwitch(Context_t  *context, char *type) 
+    int ret = cERR_LINUXDVB_NO_ERROR;
+    return ret;
+}
+
+int LinuxDvbSwitch(Context_t  *context, char * type) 
 {
-    uint8_t audio = !strcmp("audio", type);
-    uint8_t video = !strcmp("video", type);
-    Writer_t *writer;
+    unsigned char audio = !strcmp("audio", type);
+    unsigned char video = !strcmp("video", type);
+    Writer_t* writer;
 
     linuxdvb_printf(10, "v%d a%d\n", video, audio);
@@ -614 +806 @@
                 if (ioctl(audiofd, AUDIO_STOP ,NULL) == -1)
                 {
-                    linuxdvb_err("AUDIO_STOP: ERROR %d, %s\n", errno, strerror(errno));
+                    linuxdvb_err("ioctl failed with errno %d\n", errno);
+                    linuxdvb_err("AUDIO_STOP: %s\n", strerror(errno));
+
                 }
 
                 if (ioctl(audiofd, AUDIO_CLEAR_BUFFER) == -1)
                 {
-                    linuxdvb_err("AUDIO_CLEAR_BUFFER: ERROR %d, %s\n", errno, strerror(errno));
+                    linuxdvb_err("ioctl failed with errno %d\n", errno);
+                    linuxdvb_err("AUDIO_CLEAR_BUFFER: %s\n", strerror(errno));
+
                 }
 
@@ -625 +821 @@
                 {
                     linuxdvb_err("cannot found writer for encoding %s using default\n", Encoding);
-                } 
-                else
+                    // 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
                 {
                     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("AUDIO_SET_BYPASS_MODE: ERROR %d, %s\n", errno, strerror(errno));
+                        linuxdvb_err("ioctl failed with errno %d\n", errno);
+                        linuxdvb_err("AUDIO_SET_BYPASS_MODE: %s\n", strerror(errno));
                     }
                 }
@@ -637 +838 @@
                 if (ioctl(audiofd, AUDIO_PLAY) == -1)
                 {
-                    linuxdvb_err("AUDIO_PLAY: ERROR %d, %s\n", errno, strerror(errno));
+                    linuxdvb_err("ioctl failed with errno %d\n", errno);
+                    linuxdvb_err("AUDIO_PLAY: %s\n", strerror(errno));
                 }
                 free(Encoding);
@@ -652 +854 @@
                 if (ioctl(videofd, VIDEO_STOP ,NULL) == -1)
                 {
-                    linuxdvb_err("VIDEO_STOP: ERROR %d, %s\n", errno, strerror(errno));
+                    linuxdvb_err("ioctl failed with errno %d\n", errno);
+                    linuxdvb_err("VIDEO_STOP: %s\n", strerror(errno));
                 }
 
                 if (ioctl(videofd, VIDEO_CLEAR_BUFFER) == -1)
                 {
-                    linuxdvb_err("VIDEO_CLEAR_BUFFER: ERROR %d, %s\n", errno, strerror(errno));
+                    linuxdvb_err("ioctl failed with errno %d\n", errno);
+                    linuxdvb_err("VIDEO_CLEAR_BUFFER: %s\n", strerror(errno));
                 }
 
@@ -667 +871 @@
                 {
                     linuxdvb_err("cannot found writer for encoding %s using default\n", Encoding);
-                } 
-                else
+                    // 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
                 {
                     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("VIDEO_SET_STREAMTYPE: ERROR %d, %s\n", errno, strerror(errno));
+                        linuxdvb_err("ioctl failed with errno %d\n", errno);
+                        linuxdvb_err("VIDEO_SET_STREAMTYPE: %s\n", strerror(errno));
                     }
                 }
@@ -682 +891 @@
                      * return an error here and stop the playback mode
                      */
-                    linuxdvb_err("VIDEO_PLAY:ERROR %d, %s\n", errno, strerror(errno));
+                    linuxdvb_err("ioctl failed with errno %d\n", errno);
+                    linuxdvb_err("VIDEO_PLAY: %s\n", strerror(errno));
                 }
                 free(Encoding);
@@ -699 +909 @@
 }
 
-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;
-    int32_t            ret       = cERR_LINUXDVB_NO_ERROR;
-    int32_t            res       = 0;
-    uint8_t            video     = 0;
-    uint8_t            audio     = 0;
-    Writer_t           *writer   = NULL;
+    int                ret       = cERR_LINUXDVB_NO_ERROR;
+    int                res       = 0;
+    unsigned char      video     = 0;
+    unsigned char      audio     = 0;
+    Writer_t*          writer;
     WriterAVCallData_t call;
 
@@ -725 +935 @@
     if (video) 
     {
-        char *Encoding = NULL;
+        char * Encoding = NULL;
         context->manager->video->Command(context, MANAGER_GETENCODING, &Encoding);
 
@@ -801 +1011 @@
             call.Height       = out->height;
             call.InfoFlags    = out->infoFlags;
-            call.Version      = 0;
-            call.WriteV       = isBufferedOutput ? BufferingWriteV : writev_with_retry;
+            call.Version      = 0; // is unsingned char
 
             if (writer->writeData)
@@ -821 +1030 @@
     else if (audio)
     {
-        char *Encoding = NULL;
+        char * Encoding = NULL;
         context->manager->audio->Command(context, MANAGER_GETENCODING, &Encoding);
 
@@ -851 +1060 @@
             call.FrameScale     = out->timeScale;
             call.InfoFlags      = out->infoFlags;
-            call.Version        = 0;
-            call.WriteV         = isBufferedOutput ? BufferingWriteV : writev_with_retry;
+            call.Version        = 0; /* -1; unsigned char cannot be negative */
 
             if (writer->writeData)
@@ -909 +1117 @@
     free(Encoding);
 
-    if (isBufferedOutput)
-        LinuxDvbBuffFlush(context);
-    
     return ret;
 }
@@ -1006 +1211 @@
         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:
     {
@@ -546 +545 @@
         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
@@ -212 +204 @@
     iov[1].iov_base = call->data;
     iov[1].iov_len = call->len;
-    return call->WriteV(call->fd, iov, 2);
+    return writev_with_retry(call->fd, iov, 2);
 }
 
@@ -242 +234 @@
         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);
     }
@@ -283 +274 @@
     iov[1].iov_len = call->len;
     
-    return call->WriteV(call->fd, iov, 2);
+    return writev_with_retry(call->fd, iov, 2);
 }
 
@@ -353 +344 @@
     iov[2].iov_len  = pLATMCtx->len;
     
-    return call->WriteV(call->fd, iov, 3);
+    return writev_with_retry(call->fd, iov, 3);
 }
 

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

@@ -139 +139 @@
     ac3_printf(40, "PES HEADER LEN %d\n", iov[0].iov_len);
 
-    return call->WriteV(call->fd, iov, 2);
+    return writev_with_retry(call->fd, iov, 2);
 }
 

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

@@ -158 +158 @@
     iov[1].iov_len = call->len;
     
-    int len = call->WriteV(call->fd, iov, 2);
+    int len = writev_with_retry(call->fd, iov, 2);
 
     amr_printf(10, "amr_Write-< len=%d\n", len);

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

@@ -183 +183 @@
     iov[ic++].iov_len = call->len;
 
-    int len = call->WriteV(call->fd, iov, ic);
+    int len = writev_with_retry(call->fd, iov, ic);
 
     divx_printf(10, "xvid_Write < len=%d\n", len);

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

@@ -162 +162 @@
     iov[1].iov_len = Size;
 
-    int32_t len = call->WriteV(call->fd, iov, 2);
+    int32_t len = writev_with_retry(call->fd, iov, 2);
     dts_printf(10, "< len %d\n", len);
     return len;

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

@@ -135 +135 @@
     iov[1].iov_base = call->data;
     iov[1].iov_len = call->len;
-    len = call->WriteV(call->fd, iov, 2);
+    len = writev_with_retry(call->fd, iov, 2);
 
     h263_printf(10, "< len %d\n", len);

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

@@ -56 +56 @@
 /* Makros/Constants              */
 /* ***************************** */
-#define H264_SILENT
 //#define H264_DEBUG
 #ifdef H264_DEBUG
@@ -89 +88 @@
 static unsigned int            CodecDataLen   = 0;
 static int                     avc3 = 0;
-static int                     sps_pps_in_stream = 0;
 /* ***************************** */
 /* Prototypes                    */
@@ -301 +299 @@
     initialHeader = 1;
     avc3 = 0;
-    sps_pps_in_stream = 0;
     return 0;
 }
@@ -347 +344 @@
         (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;
-        
-        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;
+        if (initialHeader) 
         {
             initialHeader = 0;
@@ -370 +356 @@
             PacketLength     += call->private_size;
         }
+
+        iov[ic].iov_base = "";
+        iov[ic++].iov_len = 1;
         
         iov[ic].iov_base  = call->data;
@@ -375 +364 @@
         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 call->WriteV(call->fd, iov, ic);
+        return writev_with_retry(call->fd, iov, ic);
     }
     else if (!call->private_data || call->private_size < 7 || 1 != call->private_data[0])
@@ -390 +386 @@
     iov[ic++].iov_base = PesHeader;
     
-    if (!avc3)
+    if (initialHeader)
     {
         if (CodecData)
@@ -462 +458 @@
         iov[0].iov_len = InsertPesHeader(PesHeader, -1, MPEG_VIDEO_PES_START_CODE, VideoPts, 0);
         
-        len = call->WriteV(call->fd, iov, ic);
+        len = writev_with_retry(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
@@ -235 +234 @@
         iov[0].iov_len = InsertPesHeader(PesHeader, -1, MPEG_VIDEO_PES_START_CODE, VideoPts, FakeStartCode);
         
-        return call->WriteV(call->fd, iov, ic);
+        return writev_with_retry(call->fd, iov, ic);
     }
 
@@ -304 +303 @@
         iov[0].iov_len = InsertPesHeader(PesHeader, -1, MPEG_VIDEO_PES_START_CODE, VideoPts, 0);
         
-        len = call->WriteV(call->fd, iov, ic);
+        len = writev_with_retry(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 += call->WriteV(call->fd, iov, 2);
+        i_ret_size += writev_with_retry(call->fd, iov, 2);
     }
     

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

@@ -134 +134 @@
     iov[1].iov_len = call->len;
 
-    int len = call->WriteV(call->fd, iov, 2);
+    int len = writev_with_retry(call->fd, iov, 2);
 
     mp3_printf(10, "mp3_Write-< len=%d\n", len);

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

@@ -138 +138 @@
         iov[1].iov_len = PacketLength;
 
-        ssize_t l = call->WriteV(call->fd, iov, 2);
+        ssize_t l = writev_with_retry(call->fd, iov, 2);
         if (l < 0) {
             len = l;

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

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

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

@@ -284 +284 @@
         iov[1].iov_base = fixed_buffer;
         iov[1].iov_len  = fixed_buffersize;
-        call->WriteV(call->fd, iov, 2);
+        writev_with_retry(call->fd, iov, 2);
         fixed_buffertimestamp += fixed_bufferduration;
         
         int g_fd_dump = open("/hdd/lpcm/ffmpeg.pes", O_CREAT |
         O_RDWR | O_APPEND, S_IRUSR | S_IWUSR);
-        call->WriteV(g_fd_dump, iov, 2);
+        writev_with_retry(g_fd_dump, iov, 2);
         close(g_fd_dump);
     }

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

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

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 call->WriteV(call->fd, iov, 2);
+    return writev_with_retry(call->fd, iov, 2);
 }
 

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

@@ -173 +173 @@
     iov[1].iov_len  = call->len;
 
-    return call->WriteV(call->fd, iov, 2);
+    return writev_with_retry(call->fd, iov, 2);
 }
 

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

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

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

@@ -29 +29 @@
 #include "misc.h"
 #include "writer.h"
-#include "common.h"
 
 /* ***************************** */
@@ -99 +98 @@
 /*  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
@@ -100 +102 @@
 static uint32_t  NalLengthBytes = 1;
 static int       avc3 = 0;
-static int       sps_pps_in_stream = 0;
 /* ***************************** */
 /* Prototypes                    */
@@ -259 +260 @@
         (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 = PES_VERSION_FAKE_START_CODE;
+        uint32_t FakeStartCode = /*(call->Version << 8) | */PES_VERSION_FAKE_START_CODE;
+        
         iov[ic++].iov_base = PesHeader;
-        
-        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;
+        if (initialHeader) 
         {
             initialHeader = 0;
@@ -306 +296 @@
     }
 
-    if (!avc3)
+    if (initialHeader)
     {
         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                     */
@@ -70 +68 @@
 static int32_t PlaybackTerminate(Context_t  *context);
 
-static int8_t dieNow = 0;
-static PlaybackDieNowCallback playbackDieNowCallbacks[MAX_PLAYBACK_DIE_NOW_CALLBACKS] = {NULL};
-
 /* ***************************** */
 /* MISC Functions                */
@@ -78 +73 @@
 int8_t PlaybackDieNow(int8_t val)
 {
-    if(val && dieNow == 0)
-    {
-        uint32_t i = 0;
+    static int8_t dieNow = 0;
+    if(val)
+    {
         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;
 }