Changeset 44958

Timestamp:

12/08/20 01:35:11 (2 years ago)

Author:

obi

Message:

[libeplayer3] update to v68

Location:

titan/libeplayer3

Files:

• Makefile.am.arm (modified) (5 diffs)
• container/buff_ffmpeg.c (modified) (9 diffs)
• container/container.c (modified) (1 diff)
• container/container_ffmpeg.c (modified) (95 diffs)
• container/flv2mpeg4_ffmpeg.c (modified) (1 diff)
• container/mpeg4p2_ffmpeg.c (modified) (3 diffs)
• container/wrapped_ffmpeg.c (modified) (4 diffs)
• external/ffmpeg/mpeg4audio.h (modified) (1 diff)
• external/ffmpeg/src/latmenc.c (modified) (1 diff)
• external/ffmpeg/src/mpeg4audio.c (modified) (1 diff)
• external/flv2mpeg4/src/bitwriter.h (modified) (1 diff)
• external/flv2mpeg4/src/flvdecoder.c (modified) (4 diffs)
• external/plugins (added)
• external/plugins/png.h (added)
• external/plugins/src (added)
• external/plugins/src/png.c (added)
• include/bcm_ioctls.h (modified) (2 diffs)
• include/common.h (modified) (2 diffs)
• include/container.h (modified) (1 diff)
• include/manager.h (modified) (2 diffs)
• include/misc.h (modified) (5 diffs)
• include/output.h (modified) (3 diffs)
• include/playback.h (modified) (2 diffs)
• include/writer.h (modified) (5 diffs)
• main/exteplayer.c (modified) (42 diffs)
• manager/audio.c (modified) (3 diffs)
• manager/subtitle.c (modified) (7 diffs)
• manager/video.c (modified) (17 diffs)
• output/graphic_subtitle.c (added)
• output/linuxdvb_buffering.c (added)
• output/linuxdvb_fake.c (added)
• output/linuxdvb_mipsel.c (modified) (67 diffs)
• output/linuxdvb_sh4.c (modified) (48 diffs)
• output/output.c (modified) (4 diffs)
• output/output_subtitle.c (modified) (7 diffs)
• output/writer/mipsel/aac.c (modified) (11 diffs)
• output/writer/mipsel/ac3.c (modified) (3 diffs)
• output/writer/mipsel/amr.c (modified) (4 diffs)
• output/writer/mipsel/divx3.c (modified) (6 diffs)
• output/writer/mipsel/dts.c (modified) (3 diffs)
• output/writer/mipsel/h264.c (modified) (9 diffs)
• output/writer/mipsel/h265.c (modified) (14 diffs)
• output/writer/mipsel/lpcm.c (modified) (2 diffs)
• output/writer/mipsel/mp3.c (modified) (4 diffs)
• output/writer/mipsel/mpeg2.c (modified) (7 diffs)
• output/writer/mipsel/mpeg4.c (modified) (4 diffs)
• output/writer/mipsel/pcm.c (modified) (10 diffs)
• output/writer/mipsel/vc1.c (modified) (4 diffs)
• output/writer/mipsel/vp.c (modified) (8 diffs)
• output/writer/mipsel/wmv.c (modified) (3 diffs)
• output/writer/mipsel/writer.c (modified) (6 diffs)
• output/writer/sh4/aac.c (modified) (11 diffs)
• output/writer/sh4/h264.c (modified) (7 diffs)
• output/writer/sh4/writer.c (modified) (2 diffs)
• playback/playback.c (modified) (12 diffs)

titan/libeplayer3/Makefile.am.arm

@@ -1 +1 @@
 AUTOMAKE_OPTIONS = subdir-objects
-AM_CFLAGS = -Wall -D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=64 -D_LARGEFILE64_SOURCE
+AM_CFLAGS = -Wall -D_FILE_OFFSET_BITS=64 -D_LARGEFILE64_SOURCE -D_LARGEFILE_SOURCE -DHAVE_FLV2MPEG4_CONVERTER
+#AM_CFLAGS = -Wall -D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=64 -D_LARGEFILE64_SOURCE
 
 CXXFLAGS = -Wall
@@ -6 +7 @@
 AM_CPPFLAGS = \
         -Iinclude \
-        -Iexternal
+        -Iexternal \
+        -Iexternal/flv2mpeg4    
 
 lib_LTLIBRARIES = libeplayer3.la
@@ -20 +22 @@
 output/writer/common/pes.c \
 output/writer/common/misc.c \
+output/writer/common/writer.c \
+output/linuxdvb_buffering.c \
+output/graphic_subtitle.c \
 output/linuxdvb_mipsel.c \
 output/writer/mipsel/writer.c \
 output/writer/mipsel/aac.c \
 output/writer/mipsel/ac3.c \
+output/writer/mipsel/bcma.c \
 output/writer/mipsel/mp3.c \
 output/writer/mipsel/pcm.c \
@@ -29 +35 @@
 output/writer/mipsel/dts.c \
 output/writer/mipsel/amr.c \
-output/writer/mipsel/wma.c \
 output/writer/mipsel/h265.c \
 output/writer/mipsel/h264.c \
-output/writer/mipsel/h263.c \
+output/writer/mipsel/mjpeg.c \
 output/writer/mipsel/mpeg2.c \
 output/writer/mipsel/mpeg4.c \
@@ -42 +47 @@
 external/ffmpeg/src/bitstream.c \
 external/ffmpeg/src/latmenc.c \
-external/ffmpeg/src/mpeg4audio.c
-
+external/ffmpeg/src/mpeg4audio.c \
+external/ffmpeg/src/xiph.c \
+external/flv2mpeg4/src/m4vencode.c \
+external/flv2mpeg4/src/flvdecoder.c \
+external/flv2mpeg4/src/dcprediction.c \
+external/flv2mpeg4/src/flv2mpeg4.c \
+external/plugins/src/png.c
 
 #libeplayer3_la_LIBADD = -lpthread -lavformat -lavcodec -lavutil -lswresample -lz -lass -lm -lpng
-libeplayer3_la_LIBADD = -lpthread -lavformat -lavcodec -lavutil -lswresample
-
+libeplayer3_la_LIBADD = -lswscale -ldl -lpthread -lavformat -lavcodec -lavutil -lswresample
 
 bin_PROGRAMS = eplayer3
 eplayer3_SOURCES = main/exteplayer.c
 #eplayer3_LDADD = -leplayer3 -lpthread
-eplayer3_LDADD = -leplayer3 -lpthread -lass -lm -lpng
+#eplayer3_LDADD = -leplayer3 -lpthread -lass -lm -lpng
+eplayer3_LDADD = -leplayer3 -lswscale -ldl -lpthread -lavformat -lavcodec -lavutil -lswresample
 eplayer3_DEPENDENCIES = libeplayer3.la
 

titan/libeplayer3/container/buff_ffmpeg.c

@@ -102 +102 @@
         }
         
-        //printf("ret[%d] playPts[%lld] currPts[%lld] maxInjectedPts[%lld]\n", ret, playPts, currPts, maxInjectedPts);
+        //printf("ret[%d] playPts[%"PRId64"] currPts[%"PRId64"] maxInjectedPts[%"PRId64"]\n", ret, playPts, currPts, maxInjectedPts);
         
         /* On some STBs PTS readed from decoder is invalid after seek or at start 
@@ -126 +126 @@
     int32_t len = 0;
 //obi
-//    if(0 == PlaybackDieNow(0))
-//    {
+  if(0 == PlaybackDieNow(0))
+  {
 //obi (end)
         len = ffmpeg_real_read_org(opaque, buf, buf_size);
 //obi
-//        while(len < buf_size && g_context && 0 == PlaybackDieNow(0))
-        while(len < buf_size && g_context)
+      while(len < buf_size && g_context && 0 == PlaybackDieNow(0))
+//        while(len < buf_size && g_context)
 //obi (end)
         {
@@ -159 +159 @@
         }
 //obi
-//    }
+  }
 //obi (end)
     //printf("len [%d] finishTimeout[%d]\n", len, finishTimeout);
@@ -194 +194 @@
 }
 
-void releasefillerMutex(const char *filename, const char *function, int line) 
+void releasefillerMutex(const char *filename, const const char *function, int line) 
 {
     pthread_mutex_unlock(&fillermutex);
@@ -278 +278 @@
          {
 //obi
-//            break;
+           break;
 //obi (end)
          }
@@ -532 +532 @@
     int32_t len = 0;
     int32_t count = 2000;
+
 //obi
-//    while(sumlen < buf_size && (--count) > 0 && 0 == PlaybackDieNow(0))
-    while(sumlen < buf_size && (--count) > 0)
+    while(sumlen < buf_size && (--count) > 0 && 0 == PlaybackDieNow(0))
+//    while(sumlen < buf_size && (--count) > 0)
 //obi (end)
     {
@@ -602 +603 @@
     {
         /* can do the seek inside the buffer */
-        ffmpeg_printf(20, "buffer-seek diff=%lld\n", diff);
+        ffmpeg_printf(20, "buffer-seek diff=%"PRId64"\n", diff);
         if(diff > (ffmpeg_buf + ffmpeg_buf_size) - ffmpeg_buf_read)
         {
@@ -615 +616 @@
     {
         /* can do the seek inside the buffer */
-        ffmpeg_printf(20, "buffer-seek diff=%lld\n", diff);
+        ffmpeg_printf(20, "buffer-seek diff=%"PRId64"\n", diff);
         int32_t tmpdiff = diff * -1;
         if(tmpdiff > ffmpeg_buf_read - ffmpeg_buf)
@@ -629 +630 @@
     {
         releasefillerMutex(__FILE__, __FUNCTION__,__LINE__);
-        ffmpeg_printf(20, "real-seek diff=%lld\n", diff);
+        ffmpeg_printf(20, "real-seek diff=%"PRId64"\n", diff);
 
         ffmpeg_do_seek_ret = 0;

titan/libeplayer3/container/container.c

@@ -24 +24 @@
 
 #include "common.h"
-
-#ifdef SAM_WITH_DEBUG
-#define CONTAINER_DEBUG
-#else
-#define CONTAINER_SILENT
-#endif
-
-#ifdef CONTAINER_DEBUG
-
-static short debug_level = 0;
-
-#define container_printf(level, x...) do { \
-if (debug_level >= level) printf(x); } while (0)
-#else
-#define container_printf(level, x...)
-#endif
-
-#ifndef CONTAINER_SILENT
-#define container_err(x...) do { printf(x); } while (0)
-#else
-#define container_err(x...)
-#endif
+#include "debug.h"
 
 static Container_t * AvailableContainer[] = {

titan/libeplayer3/container/container_ffmpeg.c

@@ -26 +26 @@
 /* Includes                      */
 /* ***************************** */
+#include "debug.h"
 
 #include <stdio.h>
@@ -57 +58 @@
 #include "pcm.h"
 #include "ffmpeg_metadata.h"
+
 /* ***************************** */
 /* Makros/Constants              */
 /* ***************************** */
-#if (LIBAVFORMAT_VERSION_MAJOR > 57) 
-#define TS_BYTES_SEEKING 0
-#else
-#define TS_BYTES_SEEKING 1
-#endif
+
 
 /* Some STB with old kernels have problem with default 
@@ -71 +69 @@
  * std library.
  */
-#define SAM_CUSTOM_IO
-//obi
-#define SAM_WITH_DEBUG
-//obi (end)
-#ifdef SAM_WITH_DEBUG
-#define FFMPEG_DEBUG
-#else
-#define FFMPEG_SILENT
-#endif
-
-#ifdef FFMPEG_DEBUG
-
-//obi
-static short debug_level = 10;
-//obi (end)
-
-#define ffmpeg_printf(level, fmt, x...) do { \
-if (debug_level >= level) printf("[%s:%s] " fmt, __FILE__, __FUNCTION__, ## x); } while (0)
-#else
-#define ffmpeg_printf(level, fmt, x...)
-#endif
-
-#ifndef FFMPEG_SILENT
-#define ffmpeg_err(fmt, x...) do { printf("[%s:%s] " fmt, __FILE__, __FUNCTION__, ## x); } while (0)
-#else
-#define ffmpeg_err(fmt, x...)
-#endif
+#define USE_CUSTOM_IO
 
 /* Error Constants */
@@ -123 +95 @@
 
 static pthread_mutex_t mutex;
+static pthread_mutex_t seek_mutex;
 
 static pthread_t PlayThread;
@@ -129 +102 @@
 static AVFormatContext *avContextTab[IPTV_AV_CONTEXT_MAX_NUM] = {NULL, NULL};
 static int32_t use_custom_io[IPTV_AV_CONTEXT_MAX_NUM] = {0, 0};
-static AVDictionary *avio_opts = NULL;
+static AVDictionary *g_avio_opts = NULL;
 
 static uint8_t isContainerRunning = 0;
@@ -137 +110 @@
 static int32_t restart_audio_resampling = 0;
 
-static off_t seek_target_bytes = 0;
-static int32_t do_seek_target_bytes = 0;
-
-static int64_t seek_target_seconds = 0;
-static int8_t do_seek_target_seconds = 0;
-static int64_t prev_seek_time_sec = -1;
-
-static int32_t seek_target_flag = 0;
+static int64_t g_seek_target_seconds = 0;
+static bool g_do_seek_target_seconds = false;
+static void *g_stamp;
 
 /* ***************************** */
@@ -151 +119 @@
 static int32_t container_ffmpeg_seek_bytes(off_t pos);
 static int32_t container_ffmpeg_seek(Context_t *context, int64_t sec, uint8_t absolute);
-static int32_t container_ffmpeg_seek_rel(Context_t *context, off_t pos, int64_t pts, int64_t sec);
 static int32_t container_ffmpeg_get_length(Context_t *context, int64_t *length);
 static int64_t calcPts(uint32_t avContextIdx, AVStream *stream, int64_t pts);
+static int64_t doCalcPts(int64_t start_time, const AVRational time_base, int64_t pts);
+void LinuxDvbBuffSetStamp(void *stamp);
 
 /* Progressive playback means that we play local file
@@ -164 +133 @@
     progressive_playback = val;
 }
+
+static void getMutex(const char *filename __attribute__((unused)), const char *function __attribute__((unused)), int32_t line)
+{
+    ffmpeg_printf(100, "::%d requesting mutex\n", line);
+    static bool mutexInitialized = false;
+
+    if (!mutexInitialized)
+    {
+        pthread_mutex_init(&mutex, NULL);
+        mutexInitialized = true;
+    }
+
+    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);
+}
+
+static void getSeekMutex()
+{
+    static bool mutexInitialized = false;
+    /* This is not perfect solution because 
+     * there could be race conditions and theoretically pthread_mutex_init
+     * could be called twice, but anyway
+     */
+    if (!mutexInitialized)
+    {
+        pthread_mutex_init(&seek_mutex, NULL);
+        mutexInitialized = true;
+    }
+
+    pthread_mutex_lock(&seek_mutex);
+}
+
+static void releaseSeekMutex() 
+{
+    pthread_mutex_unlock(&seek_mutex);
+}
+
+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"
@@ -193 +221 @@
 static int32_t eac3_software_decode = 0;
 static int32_t dts_software_decode = 0;
+static int32_t amr_software_decode = 1;
+static int32_t vorbis_software_decode = 1;
+static int32_t opus_software_decode = 1;
+
 static int32_t pcm_resampling = 1;
 static int32_t stereo_software_decoder = 0;
@@ -421 +453 @@
 //obi (end)
 
-static void ffmpeg_silen_callback(void * avcl, int level, const char * fmt, va_list vl)
+static void ffmpeg_silen_callback(void *avcl, int level, const char *fmt, va_list vl)
 {
     return;
 }
 
-static int32_t mutexInitialized = 0;
-
 void sel_program_id_set(const int32_t val)
 {
@@ -463 +493 @@
 }
 
+void amr_software_decoder_set(const int32_t val)
+{
+    amr_software_decode = val;
+}
+
+void vorbis_software_decoder_set(const int32_t val)
+{
+    vorbis_software_decode = val;
+}
+
+void opus_software_decoder_set(const int32_t val)
+{
+    opus_software_decode = val;
+}
+
 void stereo_software_decoder_set(const int32_t val)
 {
@@ -495 +540 @@
 int32_t ffmpeg_av_dict_set(const char *key, const char *value, int32_t flags)
 {
-    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 char *function __attribute__((unused)), int32_t line) 
-{
-    pthread_mutex_unlock(&mutex);
-
-    ffmpeg_printf(100, "::%d released mutex\n", line);
+    return av_dict_set(&g_avio_opts, key, value, flags);
 }
 
 static char* Codec2Encoding(int32_t codec_id, int32_t media_type, uint8_t *extradata, int extradata_size, int profile, int32_t *version)
 {
-    ffmpeg_printf(10, "Codec ID: %d (%.8lx)\n", codec_id, codec_id);
+    ffmpeg_printf(10, "Codec ID: %d (%.8x)\n", codec_id, codec_id);
     switch (codec_id)
     {
@@ -533 +551 @@
         return "V_MPEG1";
     case AV_CODEC_ID_MPEG2VIDEO:
-        return "V_MPEG1";
+        return "V_MPEG2";
+    case AV_CODEC_ID_MJPEG:
+        return "V_MJPEG";
     case AV_CODEC_ID_H263:
     case AV_CODEC_ID_H263P:
@@ -552 +572 @@
     case AV_CODEC_ID_RV10:
     case AV_CODEC_ID_RV20:
-        return "V_RMV";
+        return "V_RV20";
+    case AV_CODEC_ID_RV30:
+        return "V_RV30";
+    case AV_CODEC_ID_RV40:
+        return "V_RV40";
+#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(58, 21, 100)
+    case AV_CODEC_ID_AVS2:
+        return "V_AVS2";
+#endif
     case AV_CODEC_ID_MPEG4:
         return "V_MPEG4";
@@ -561 +589 @@
     case AV_CODEC_ID_MSMPEG4V2:
     case AV_CODEC_ID_MSMPEG4V3:
-        return "V_DIVX3";
+        return "V_MPEG4"; //"V_DIVX3";
     case AV_CODEC_ID_WMV1:
         *version = 1;
@@ -590 +618 @@
         return (mp3_software_decode) ? "A_IPCM" : "A_MP3";
     case AV_CODEC_ID_AAC:
-        if (extradata_size >= 2)
-        {
+        if (extradata_size >= 2) {
             MPEG4AudioConfig m4ac;
             int off = avpriv_mpeg4audio_get_config(&m4ac, extradata, extradata_size * 8, 1);
             ffmpeg_printf(1,"aac [%d] off[%d]\n", m4ac.object_type, off);
-            if (off < 0 || 2 != m4ac.object_type)
-            {
+            if (off < 0) {
                 return "A_IPCM";
             }
-        }
-        return (aac_software_decode) ? "A_IPCM" : "A_AAC";  
+            else if (0 == m4ac.chan_config && STB_HISILICON != GetSTBType()) {
+                // according to https://wiki.multimedia.cx/index.php/ADTS
+                // "MPEG-4 Channel Configuration  - in the case of 0, the channel configuration is sent via an inband PCE"      
+                // we already have AAC_LATM formatter which will include PCE
+                return (aac_latm_software_decode) ? "A_IPCM" : "A_AAC_LATM";
+            }
+        }
+        return (aac_software_decode) ? "A_IPCM" : "A_AAC";
     case AV_CODEC_ID_AAC_LATM:
         return (aac_latm_software_decode) ? "A_IPCM" : "A_AAC_LATM";
@@ -610 +642 @@
         return (dts_software_decode) ? "A_IPCM" : "A_DTS";
     case AV_CODEC_ID_WMAV1:
+        return "A_IPCM";
     case AV_CODEC_ID_WMAV2:
             return (wma_software_decode) ? "A_IPCM" : "A_WMA";
@@ -621 +654 @@
         return "A_IPCM";
     case AV_CODEC_ID_RA_288:
-        return "A_IPCM";
-    case AV_CODEC_ID_VORBIS:
         return "A_IPCM";
     case AV_CODEC_ID_FLAC:
@@ -642 +673 @@
         return pcm_resampling ? "A_IPCM" : "A_PCM";
     case AV_CODEC_ID_AMR_NB:
-        return "A_IPCM";//return "A_AMR";
+    case AV_CODEC_ID_AMR_WB:
+        return amr_software_decode ? "A_IPCM" : "A_AMR";
+    case AV_CODEC_ID_VORBIS:
+        return vorbis_software_decode ? "A_IPCM" : "A_VORBIS";
+    case AV_CODEC_ID_OPUS :
+        return opus_software_decode ? "A_IPCM" : "A_OPUS";
 
 /* In exteplayer3 embedded text subtitle simple printed
@@ -656 +692 @@
         return "S_TEXT/ASS"; /* Hellmaster1024: seems to be ASS instead of SSA */
     case AV_CODEC_ID_DVD_SUBTITLE:
-    case AV_CODEC_ID_DVB_SUBTITLE:
-    case AV_CODEC_ID_XSUB:
     case AV_CODEC_ID_MOV_TEXT:
-    case AV_CODEC_ID_HDMV_PGS_SUBTITLE:
     case AV_CODEC_ID_DVB_TELETEXT:
 //    case CODEC_ID_DVB_TELETEXT:
@@ -669 +702 @@
     case AV_CODEC_ID_SUBRIP:
         return "S_TEXT/SUBRIP"; 
+    case AV_CODEC_ID_WEBVTT:
+        return "S_TEXT/WEBVTT";
+    case AV_CODEC_ID_HDMV_PGS_SUBTITLE:
+        return "S_GRAPHIC/PGS";
+    case AV_CODEC_ID_DVB_SUBTITLE:
+        return "S_GRAPHIC/DVB";
+    case AV_CODEC_ID_XSUB:
+        return "S_GRAPHIC/XSUB";
     default:
-        ffmpeg_err("Codec ID %d (%.8lx) not found\n", codec_id, codec_id);
+        ffmpeg_err("Codec ID %d (%.8x) not found\n", codec_id, codec_id);
         // Default to injected-pcm for unhandled audio types.
         if (media_type == AVMEDIA_TYPE_AUDIO)
@@ -676 +717 @@
             return "A_IPCM";
         }
-        ffmpeg_err("Codec ID %d (%.8lx) not found\n", codec_id, codec_id);
+        ffmpeg_err("Codec ID %d (%.8x) not found\n", codec_id, codec_id);
     }
     return NULL;
+}
+
+static int64_t doCalcPts(int64_t start_time, const AVRational time_base, int64_t pts)
+{
+    if (time_base.den > 0)
+    {
+        pts = av_rescale(pts, (int64_t)time_base.num * 90000, time_base.den);
+    }
+    
+    if (start_time != AV_NOPTS_VALUE)
+    {
+        pts -= 90000 * start_time / AV_TIME_BASE;
+    }
+
+    if (pts & 0x8000000000000000ull)
+    {
+        pts = INVALID_PTS_VALUE;
+    }
+    else
+    {
+        pts &= 0x01FFFFFFFFull; // PES header can handle only 33 bit PTS
+    }
+
+    return pts;
 }
 
@@ -688 +753 @@
         return INVALID_PTS_VALUE;
     }
-    else if (stream->time_base.den > 0)
-    {
-        pts = av_rescale(pts, (int64_t)stream->time_base.num * 90000, stream->time_base.den);
-    }
-    
-    if (avContextTab[avContextIdx]->start_time != AV_NOPTS_VALUE)
-    {
-        pts -= 90000 * avContextTab[avContextIdx]->start_time / AV_TIME_BASE;
-    }
-
-    if (pts & 0x8000000000000000ull)
-    {
-        pts = INVALID_PTS_VALUE;
-    }
-
-    return pts;
+    
+    return doCalcPts(avContextTab[avContextIdx]->start_time, stream->time_base, pts);
 }
 
@@ -763 +814 @@
     int64_t lastAudioDts = -1;
     
+    int64_t multiContextLastPts[IPTV_AV_CONTEXT_MAX_NUM] = {INVALID_PTS_VALUE, INVALID_PTS_VALUE};
+    
     int64_t showtime = 0;
     int64_t bofcount = 0;
@@ -777 +830 @@
     uint32_t cAVIdx = 0;
 
+    // for seek
+    int64_t seek_target_seconds = 0;
+    bool do_seek_target_seconds = false;
+
+    int64_t seek_target_bytes = 0;
+    bool do_seek_target_bytes = false;
+    int64_t prev_seek_time_sec = -1;
+    void *stamp;
+
 #if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(56, 34, 100)
-    Mpeg4P2Context mpeg4p2_context;
-    memset(&mpeg4p2_context, 0, sizeof(Mpeg4P2Context));
-    AVBitStreamFilterContext *mpeg4p2_bsf_context = av_bitstream_filter_init("mpeg4_unpack_bframes");
+#ifdef __sh__
+    Mpeg4P2Context *mpeg4p2_context = NULL;
+#else
+    Mpeg4P2Context *mpeg4p2_context = mpeg4p2_context_open();
+#endif
 #endif
 #ifdef HAVE_FLV2MPEG4_CONVERTER
@@ -789 +853 @@
     while ( context->playback->isCreationPhase )
     {
-        ffmpeg_err("Thread waiting for end of init phase...\n");
+        ffmpeg_printf(10, "Thread waiting for end of init phase...\n");
         usleep(1000);
     }
     ffmpeg_printf(10, "Running!\n");
+
+    uint32_t bufferSize = 0;
+    context->output->Command(context, OUTPUT_GET_BUFFER_SIZE, &bufferSize);
+    ffmpeg_printf(10, "bufferSize [%u]\n", bufferSize);
 
     int8_t isWaitingForFinish = 0;
     while ( context && context->playback && context->playback->isPlaying ) 
     {
-        //IF MOVIE IS PAUSED, WAIT
-        if (context->playback->isPaused) 
+        /* 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
+         * 
+         */
+#ifdef __sh__
+        /* ST DVB drivers skip data if they are written during pause 
+         * so, we must wait here if there is not buffering queue
+         */
+        if (0 == bufferSize && context->playback->isPaused) 
         {
             ffmpeg_printf(20, "paused\n");
@@ -805 +881 @@
             continue;
         }
+#endif
 
         if (context->playback->isSeeking) 
@@ -826 +903 @@
         }
 
+        getSeekMutex();
+        if (g_do_seek_target_seconds) 
+        {
+            do_seek_target_seconds = g_do_seek_target_seconds;
+            seek_target_seconds = g_seek_target_seconds;
+            stamp = g_stamp;
+            g_do_seek_target_seconds = false;
+        }
+        releaseSeekMutex();
+
         if (do_seek_target_seconds || do_seek_target_bytes) 
         {
@@ -831 +918 @@
             if (do_seek_target_seconds)
             {
-                ffmpeg_printf(10, "seek_target_seconds[%lld]\n", seek_target_seconds);
+                ffmpeg_printf(10, "seek_target_seconds[%"PRId64"]\n", seek_target_seconds);
                 uint32_t i = 0;
                 for(; i<IPTV_AV_CONTEXT_MAX_NUM; i+=1)
                 {
+                    multiContextLastPts[i] = INVALID_PTS_VALUE;
                     if(NULL != avContextTab[i])
                     {
@@ -844 +932 @@
                         {
                             seek_target_seconds += avContextTab[i]->start_time;
-                            printf("SEEK SECONDS [%lld]\n", seek_target_seconds);
                         }
                         //av_seek_frame(avContextTab[i], -1, seek_target_seconds, 0);
@@ -855 +942 @@
                 }
                 reset_finish_timeout();
+                /*
+                if (bufferSize > 0)
+                {
+                    context->output->Command(context, OUTPUT_CLEAR, NULL);
+                }
+                */
             } 
             else
@@ -860 +953 @@
                 container_ffmpeg_seek_bytes(seek_target_bytes);
             }
-            do_seek_target_seconds = 0;
-            do_seek_target_bytes = 0;
+            do_seek_target_seconds = false;
+            do_seek_target_bytes = false;
             
             restart_audio_resampling = 1;
@@ -867 +960 @@
             currentAudioPts = -1;
             latestPts = 0;
-            seek_target_flag = 0;
 
             // flush streams
@@ -886 +978 @@
             }
 #if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(56, 34, 100)
-            mpeg4p2_context_reset(&mpeg4p2_context);
-            if (NULL != mpeg4p2_bsf_context)
-            {
-                av_bitstream_filter_close(mpeg4p2_bsf_context);
-                mpeg4p2_bsf_context = av_bitstream_filter_init("mpeg4_unpack_bframes");
-            }
+            mpeg4p2_context_reset(mpeg4p2_context);
 #endif
 #ifdef HAVE_FLV2MPEG4_CONVERTER
@@ -903 +990 @@
             if(NULL != avContextTab[1])
             {
-                cAVIdx = currentVideoPts <= currentAudioPts ? 0 : 1;
-                if (1 == cAVIdx && prev_seek_time_sec >= 0 )
-                {
-                    avformat_seek_file(avContextTab[1], -1, (currentVideoPts / 90000) * AV_TIME_BASE - AV_TIME_BASE, (currentVideoPts / 90000) * AV_TIME_BASE, (currentVideoPts / 90000) * AV_TIME_BASE + AV_TIME_BASE, 0);
-                    prev_seek_time_sec = -1;
-                    wrapped_avcodec_flush_buffers(1);
+                if (prev_seek_time_sec >= 0)
+                {
+                    if (multiContextLastPts[0] != INVALID_PTS_VALUE) {
+                        int64_t target = av_rescale(multiContextLastPts[0], AV_TIME_BASE, 90000);
+                        avformat_seek_file(avContextTab[1], -1, INT64_MIN, target, INT64_MAX, 0);
+                        prev_seek_time_sec = -1;
+                        wrapped_avcodec_flush_buffers(1);
+                        cAVIdx = 1;
+                    } else {
+                        cAVIdx = 0;
+                    }
+                } else {
+                    if (multiContextLastPts[0] != INVALID_PTS_VALUE && multiContextLastPts[1] != INVALID_PTS_VALUE) {
+                        cAVIdx = multiContextLastPts[0] < multiContextLastPts[1] ? 0 : 1;
+                    } else {
+                        cAVIdx = !cAVIdx;
+                    }
                 }
             }
@@ -916 +1014 @@
             }
         }
-        
+
+        if (bufferSize > 0)
+        {
+            LinuxDvbBuffSetStamp(stamp);
+        }
         if (!isWaitingForFinish && (ffmpegStatus = av_read_frame(avContextTab[cAVIdx], &packet)) == 0 )
         {
@@ -927 +1029 @@
             int32_t pid = avContextTab[cAVIdx]->streams[packet.stream_index]->id;
             
+            multiContextLastPts[cAVIdx] = calcPts(cAVIdx, avContextTab[cAVIdx]->streams[packet.stream_index], packet.pts);
+            ffmpeg_printf(200, "Ctx %d PTS: %"PRId64" PTS[1] %"PRId64"\n", cAVIdx, multiContextLastPts[cAVIdx], multiContextLastPts[1]);
+            
             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 packed_size[%d] 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);
 
@@ -950 +1061 @@
 #if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(56, 34, 100)
                 AVCodecContext *codec_context = videoTrack->avCodecCtx;
-                if (codec_context && codec_context->codec_id == AV_CODEC_ID_MPEG4 && NULL != mpeg4p2_bsf_context)
-                {
-                    // should never happen, if it does print error and exit immediately, so we can easily spot it
-                    if (filter_packet(mpeg4p2_bsf_context, codec_context, &packet) < 0)
-                    {
-                        ffmpeg_err("cannot filter mpegp2 packet\n");
-                        exit(1);
-                    }
-                    if (mpeg4p2_write_packet(context, &mpeg4p2_context, videoTrack, cAVIdx, &currentVideoPts, &latestPts, &packet) < 0)
-                    {
-                        ffmpeg_err("cannot write mpeg4p2 packet\n");
-                        exit(1);
-                    }
+                if (codec_context && codec_context->codec_id == AV_CODEC_ID_MPEG4 && NULL != mpeg4p2_context)
+                {
+                    mpeg4p2_write_packet(context, mpeg4p2_context, videoTrack, cAVIdx, &currentVideoPts, &latestPts, &packet);
                     update_max_injected_pts(latestPts);
                 }
@@ -977 +1078 @@
 #endif
                 {
-                    uint8_t skipPacket = 0;
+                    bool skipPacket = false;
                     currentVideoPts = videoTrack->pts = pts = calcPts(cAVIdx, videoTrack->stream, packet.pts);
                     videoTrack->dts = dts = calcPts(cAVIdx, videoTrack->stream, packet.dts);
@@ -999 +1100 @@
                                 // skip already injected VIDEO packet
                                 ffmpeg_printf(200, "skip already injected VIDEO packet\n");
-                                skipPacket = 1;
+                                skipPacket = true;
                             }
                         }
@@ -1006 +1107 @@
                             // skip VIDEO packet with unknown DTS
                             ffmpeg_printf(200, "skip VIDEO packet with unknown DTS\n");
-                            skipPacket = 1;
+                            skipPacket = true;
                         }
                     }
@@ -1017 +1118 @@
                     }
                     
-                    ffmpeg_printf(200, "VideoTrack index = %d %lld\n",pid, currentVideoPts);
+                    ffmpeg_printf(200, "VideoTrack index = %d %"PRId64"\n",pid, currentVideoPts);
 
                     avOut.data       = packet.data;
@@ -1036 +1137 @@
                     }
 
-                    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");
@@ -1089 +1190 @@
                 pcmExtradata.sample_rate           = get_codecpar(audioTrack->stream)->sample_rate;
                 pcmExtradata.bit_rate              = get_codecpar(audioTrack->stream)->bit_rate;
-                pcmExtradata.ffmpeg_codec_id       = get_codecpar(audioTrack->stream)->codec_id;
+                pcmExtradata.block_align           = get_codecpar(audioTrack->stream)->block_align;
+                pcmExtradata.frame_size            = get_codecpar(audioTrack->stream)->frame_size;
+
+                pcmExtradata.codec_id              = get_codecpar(audioTrack->stream)->codec_id;
                 pcmExtradata.bResampling           = restart_audio_resampling;
                 
@@ -1112 +1216 @@
                     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");
@@ -1220 +1324 @@
                                 out_sample_rate = *rate ? *rate : 44100;
                             }
-                            
+
                             swr = swr_alloc();
                             out_channels = c->channels;
-                            
+
                             if (c->channel_layout == 0)
                             {
@@ -1271 +1375 @@
                             continue;
                         }
-                        int64_t next_in_pts = av_rescale(av_frame_get_best_effort_timestamp(decoded_frame),
+                        int64_t next_in_pts = av_rescale(wrapped_frame_get_best_effort_timestamp(decoded_frame),
                                          ((AVStream*) audioTrack->stream)->time_base.num * (int64_t)out_sample_rate * c->sample_rate,
                                          ((AVStream*) audioTrack->stream)->time_base.den);
@@ -1288 +1392 @@
                         // The data described by the sample format is always in native-endian order
 #ifdef WORDS_BIGENDIAN
-                        pcmExtradata.ffmpeg_codec_id       = AV_CODEC_ID_PCM_S16BE;
+                        pcmExtradata.codec_id       = AV_CODEC_ID_PCM_S16BE;
 #else
-                        pcmExtradata.ffmpeg_codec_id       = AV_CODEC_ID_PCM_S16LE;
+                        pcmExtradata.codec_id       = AV_CODEC_ID_PCM_S16LE;
 #endif
 
@@ -1307 +1411 @@
                         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");
@@ -1317 +1421 @@
                 {
                     ffmpeg_printf(200, "write audio aac\n");
-                    ffmpeg_printf(200, ">>>>>>> %x %x %x %x %x %x\n", packet.data[0], packet.data[1], packet.data[2], packet.data[3], packet.data[4], packet.data[5], packet.data[6]);
+                    ffmpeg_printf(200, "> %hhx %hhx %hhx %hhx %x %hhx %hhx\n", packet.data[0], packet.data[1], packet.data[2], packet.data[3], packet.data[4], packet.data[5], packet.data[6]);
 
                     avOut.data       = packet.data;
@@ -1330 +1434 @@
                     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");
+                    }
+                } 
+                else if (pcmExtradata.codec_id == AV_CODEC_ID_VORBIS || pcmExtradata.codec_id == AV_CODEC_ID_OPUS ||
+                         pcmExtradata.codec_id == AV_CODEC_ID_WMAV1 || pcmExtradata.codec_id == AV_CODEC_ID_WMAV2 ||
+                         pcmExtradata.codec_id == AV_CODEC_ID_WMAPRO || pcmExtradata.codec_id == AV_CODEC_ID_WMALOSSLESS) {
+                    avOut.data       = packet.data;
+                    avOut.len        = packet.size;
+                    avOut.pts        = pts;
+                    avOut.extradata  = (uint8_t *) &pcmExtradata;
+                    avOut.extralen   = sizeof(pcmExtradata);
+                    avOut.frameRate  = 0;
+                    avOut.timeScale  = 0;
+                    avOut.width      = 0;
+                    avOut.height     = 0;
+                    avOut.type       = "audio";
+
+                    pcmExtradata.private_data = pAudioExtradata;
+                    pcmExtradata.private_size = audioExtradataSize;
+
+                    if (!context->playback->BackWard && Write(context->output->audio->Write, context, &avOut, pts) < 0) {
+                        ffmpeg_err("writing data to audio device failed\n");
                     }
                 }
@@ -1348 +1473 @@
                     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");
@@ -1371 +1496 @@
                 }
 
-                if (duration > 0)
-                {
-//                  printf("[LIBEPLAYER3/FFMPEGThread] start\n");
-
+                if (duration > 0 || duration == -1)
+                {
                     SubtitleOut_t subOut;
                     memset(&subOut, 0, sizeof(subOut));
                     subOut.trackId = pid;
                     subOut.data = (uint8_t *)packet.data;
+                    subOut.len = packet.size;
                     subOut.pts = pts;
                     subOut.durationMS = duration;
-                    //obi
-                    tmptrackId = pid;
-                    tmpdata = (uint8_t *)packet.data;
-//                  tmpdata = (uint8_t *)&packet.data;
-                    //tmplen;
-                    tmppts = pts;
-                    tmpduration = duration;
-                    tmpdata = ostrcat(subOut.data, NULL, 0, 0);
-
-                    //*tmptype;
-//                  printf("[LIBEPLAYER3/FFMPEGThread] set tmpdata=%s\n", tmpdata);
-//                  printf("[LIBEPLAYER3/FFMPEGThread] set tmppts=%lld\n", tmppts);
-//                  printf("[LIBEPLAYER3/FFMPEGThread] set tmpduration=%lld\n", tmpduration);
-                    //obi (end)
-
-                    if (context->output->subtitle->Write(context, &subOut) < 0)
+                    subOut.extradata = get_codecpar(stream)->extradata;
+                    subOut.extralen  = get_codecpar(stream)->extradata_size;
+                    subOut.width     = get_codecpar(stream)->width;;
+                    subOut.height    = get_codecpar(stream)->height;;
+                    
+                                        //obi
+//                                  printf("[LIBEPLAYER3/FFMPEGThread] start\n");
+                                        tmptrackId = pid;
+                                        tmpdata = (uint8_t *)packet.data;
+                                        //                  tmpdata = (uint8_t *)&packet.data;
+                                        //tmplen;
+                                        tmppts = pts;
+                                        tmpduration = duration;
+                                        tmpdata = ostrcat(subOut.data, NULL, 0, 0);
+
+                                        //*tmptype;
+                                        //                  printf("[LIBEPLAYER3/FFMPEGThread] set tmpdata=%s\n", tmpdata);
+                                        //                  printf("[LIBEPLAYER3/FFMPEGThread] set tmppts=%lld\n", tmppts);
+                                        //                  printf("[LIBEPLAYER3/FFMPEGThread] set tmpduration=%lld\n", tmpduration);
+                                        //obi (end)
+                    
+                    if (Write(context->output->subtitle->Write, context, &subOut, pts) < 0)
                     {
                         ffmpeg_err("writing data to teletext fifo failed\n");
                     }
-                    //obi
-                    char* tmpstr = NULL;
-                    tmpstr = ostrcat(tmpstr, "duration=", 1, 0);
-                    tmpstr = ostrcat(tmpstr, ollutoa(tmpduration), 1, 1);
-                    tmpstr = ostrcat(tmpstr, ";pts=", 1, 0);;
-                    tmpstr = ostrcat(tmpstr, ollutoa(tmppts), 1, 0);;
-                    tmpstr = ostrcat(tmpstr, ";trackid=", 1, 0);;
-                    tmpstr = ostrcat(tmpstr, oitoa(tmptrackId), 1, 0);
-                    tmpstr = ostrcat(tmpstr, ";subtext=", 1, 0);;
-                    tmpstr = ostrcat(tmpstr, tmpdata, 1, 0);;
-
-                    free(subtext), subtext = NULL;
-                    subtext = ostrcat(subtext, tmpstr, 1, 0);
-                    free(tmpstr), tmpstr = NULL;
-
-//                  tmpduration = 0;
-                    tmppts = 0;
-                    tmptrackId = 0;
-
-//                    printf("[LIBEPLAYER3/FFMPEGThread] set subtext: %s\n", subtext);
-                    //obi (end)
+                                        //obi
+                                        char* tmpstr = NULL;
+                                        tmpstr = ostrcat(tmpstr, "duration=", 1, 0);
+                                        tmpstr = ostrcat(tmpstr, ollutoa(tmpduration), 1, 1);
+                                        tmpstr = ostrcat(tmpstr, ";pts=", 1, 0);;
+                                        tmpstr = ostrcat(tmpstr, ollutoa(tmppts), 1, 0);;
+                                        tmpstr = ostrcat(tmpstr, ";trackid=", 1, 0);;
+                                        tmpstr = ostrcat(tmpstr, oitoa(tmptrackId), 1, 0);
+                                        tmpstr = ostrcat(tmpstr, ";subtext=", 1, 0);;
+                                        tmpstr = ostrcat(tmpstr, tmpdata, 1, 0);;
+
+                                        free(subtext), subtext = NULL;
+                                        subtext = ostrcat(subtext, tmpstr, 1, 0);
+                                        free(tmpstr), tmpstr = NULL;
+
+                                        //                  tmpduration = 0;
+                                        tmppts = 0;
+                                        tmptrackId = 0;
+
+                                        //                    printf("[LIBEPLAYER3/FFMPEGThread] set subtext: %s\n", subtext);
+                                                        //obi (end)
+
                 }
             }
@@ -1460 +1591 @@
                 {
                     seek_target_bytes = 0;
-                    do_seek_target_bytes = 1;
+                    do_seek_target_bytes = true;
                     bEndProcess = 0;
                 }
@@ -1468 +1599 @@
                     if( 0 == container_ffmpeg_get_length(context, &tmpLength) && tmpLength > 0 && get_play_pts() > 0)
                     {
-#if defined(TS_BYTES_SEEKING) && TS_BYTES_SEEKING
-                        if (avContextTab[0]->iformat->flags & AVFMT_TS_DISCONT)
-                        {
-                            seek_target_bytes = 0;
-                            do_seek_target_bytes = 1;
-                        }
-                        else
-#endif
-                        {
-                            seek_target_seconds = 0;
-                            do_seek_target_seconds = 1;
-                        }
+                        seek_target_seconds = 0;
+                        do_seek_target_seconds = 1;
+
                         bEndProcess = 0;
                         context->output->Command(context, OUTPUT_CLEAR, NULL);
@@ -1516 +1638 @@
     
 #if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(56, 34, 100)
-    mpeg4p2_context_reset(&mpeg4p2_context);
-    if (NULL != mpeg4p2_bsf_context)
-    {
-        av_bitstream_filter_close(mpeg4p2_bsf_context);
-    }
+    mpeg4p2_context_close(mpeg4p2_context);
 #endif
 
@@ -1538 +1656 @@
     PlaybackHandler_t *p = (PlaybackHandler_t *)ctx;
 //obi
-//    return p->abortRequested || PlaybackDieNow(0);
-    return p->abortRequested;
+    return p->abortRequested || PlaybackDieNow(0);
+//    return p->abortRequested;
 //obi (end)
 }
 
-#ifdef SAM_CUSTOM_IO
+#ifdef USE_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;
@@ -1603 +1823 @@
     avContextTab[AVIdx]->interrupt_callback.opaque = context->playback;
 
-#ifdef SAM_CUSTOM_IO
+#ifdef USE_CUSTOM_IO
     if(0 == strstr(filename, "://") || 
        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)
         {
@@ -1615 +1844 @@
         else
         {
+            free(custom_io_tab[AVIdx]);
+            custom_io_tab[AVIdx] = NULL;
             return cERR_CONTAINER_FFMPEG_OPEN;
         }
@@ -1620 +1851 @@
 #endif
 
+    AVDictionary *avio_opts = NULL;
     AVDictionary **pavio_opts = NULL;
+    av_dict_copy(&avio_opts, g_avio_opts, 0);
+
     eRTMPProtoImplType rtmpProtoImplType = RTMP_NONE;
     uint8_t numOfRTMPImpl = 0;
@@ -1837 +2071 @@
         av_dict_set(&avio_opts, "timeout", "20000000", 0); //20sec
 //obi
+/*
                 char* cookie = NULL, *tmpstr1 = NULL, *tmpstr2 = NULL, *tmpstr3 = NULL, *tmpstr4 = NULL, *headers = NULL, *useragent = NULL;
                 int count = 0, count1 = 0, count2 = 0, count3 = 0, i = 0, i1 = 0, i2 = 0, i3 = 0, usetslivemode = 0;
@@ -1989 +2224 @@
                         context->playback->isTSLiveMode = 1;
                 }
+                */
 //obi (end)
 
@@ -1999 +2235 @@
         }
     }
-
+    
     pavio_opts = &avio_opts;
     
@@ -2019 +2255 @@
             ffmpeg_err("avformat_open_input failed %d (%s)\n", err, filename);
             av_strerror(err, error, 512);
-            fprintf(stderr, "{\"FF_ERROR\":{\"msg\":\"%s\",\"code\":%i}}\n", error, err);
+            E2iSendMsg("{\"FF_ERROR\":{\"msg\":\"%s\",\"code\":%i}}\n", error, err);
 
             if(avio_opts != NULL)
@@ -2134 +2370 @@
 
     /* initialize ffmpeg */
-    avcodec_register_all();
-    av_register_all();
+    wrapped_register_all();
     avformat_network_init();
 
+#if FFMPEG_DEBUG_LEVEL >= 10
+    av_log_set_level( AV_LOG_DEBUG );
+#else
+    av_log_set_callback( ffmpeg_silen_callback );
+#endif
+
 //obi
+/*
     char* tmpstr = NULL;
     tmpstr = readfiletomem("/mnt/config/titan.cfg", 1);
@@ -2146 +2388 @@
         av_log_set_callback(ffmpeg_silen_callback);
     free(tmpstr), tmpstr = NULL;
-//obi (end) 
-    // SULGE DEBUG ENABLED
-    // make ffmpeg silen
-    //av_log_set_level( AV_LOG_DEBUG );
-    //av_log_set_callback(ffmpeg_silen_callback);
- 
+*/
+//obi (end)
+
     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)
     {
@@ -2159 +2399 @@
     }
 
-    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);
     }
     
@@ -2173 +2414 @@
     isContainerRunning = 1;
     res = container_ffmpeg_update_tracks(context, playFilesNames->szFirstFile, 1);
-
     //obi
-    //ReadSubtitles(context, playFilesNames->szFirstFile);
+//    ReadSubtitles(context, playFilesNames->szFirstFile);
     //obi (end)
     return res;
@@ -2182 +2422 @@
 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)
@@ -2190 +2431 @@
     }
     
+    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);
     }
 
@@ -2216 +2459 @@
     }
 #endif
-
 
     ffmpeg_printf(20, "dump format\n");
@@ -2294 +2536 @@
                 }
                 
-                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
+                }
             }
 
@@ -2328 +2573 @@
             case AVMEDIA_TYPE_VIDEO:
                 ffmpeg_printf(10, "CODEC_TYPE_VIDEO %d\n", get_codecpar(stream)->codec_type);
-
+                // do not discard any stream from second context
+                stream->discard = 0 == cAVIdx ? AVDISCARD_ALL : AVDISCARD_DEFAULT; /* by default we discard all video streams */
                 if (encoding != NULL) 
                 {
@@ -2373 +2619 @@
                     }
                     
-                    ffmpeg_printf(10, "bit_rate       [%d]\n", get_codecpar(stream)->bit_rate);
+                    ffmpeg_printf(10, "bit_rate       [%"PRId64"]\n", get_codecpar(stream)->bit_rate);
                     ffmpeg_printf(10, "time_base.den  [%d]\n", stream->time_base.den);
                     ffmpeg_printf(10, "time_base.num  [%d]\n", stream->time_base.num);
@@ -2402 +2648 @@
                             track.avCodecCtx = wrapped_avcodec_get_context(cAVIdx, stream);
                         }
-                        ffmpeg_printf(1, "cAVIdx[%d]: MANAGER_ADD track VIDEO\n");
+                        ffmpeg_printf(1, "cAVIdx[%d]: MANAGER_ADD track VIDEO\n", cAVIdx);
                         if( context->manager->video->Command(context, MANAGER_ADD, &track) < 0) 
                         {
                             /* konfetti: fixme: is this a reason to return with error? */
                             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;
                         }
                     }
@@ -2417 +2671 @@
             case AVMEDIA_TYPE_AUDIO:
                 ffmpeg_printf(10, "CODEC_TYPE_AUDIO %d\n",get_codecpar(stream)->codec_type);
-
+                // do not discard any stream from second context
+                stream->discard = 0 == cAVIdx ? AVDISCARD_ALL : AVDISCARD_DEFAULT;
                 if (encoding != NULL)
                 {
@@ -2517 +2772 @@
                             int32_t object_type = 2; // LC
                             int32_t sample_index = aac_get_sample_rate_index(get_codecpar(stream)->sample_rate);
-                            int32_t chan_config = get_codecpar(stream)->channels - 1;
+                            int32_t chan_config = get_chan_config(get_codecpar(stream)->channels);
                             ffmpeg_printf(1,"aac object_type %d\n", object_type);
                             ffmpeg_printf(1,"aac sample_index %d\n", sample_index);
                             ffmpeg_printf(1,"aac chan_config %d\n", chan_config);
                             
+                            int off = -1;
                             if (get_codecpar(stream)->extradata_size >= 2)
                             {
                                 MPEG4AudioConfig m4ac;
-                                int off = avpriv_mpeg4audio_get_config(&m4ac, get_codecpar(stream)->extradata, get_codecpar(stream)->extradata_size * 8, 1);
+                                off = avpriv_mpeg4audio_get_config(&m4ac, get_codecpar(stream)->extradata, get_codecpar(stream)->extradata_size * 8, 1);
                                 if (off >= 0)
                                 {
@@ -2542 +2798 @@
                             ffmpeg_printf(1,"aac chan_config %d\n", chan_config);
 
-                            
+                            if (off >= 0 && chan_config == 0) { // channel config must be send in the inband PCE
+                                track.aacbuf = malloc(AAC_HEADER_LENGTH + MAX_PCE_SIZE);
+
+                                GetBitContext gb;
+                                PutBitContext pb;
+                                init_put_bits(&pb, track.aacbuf + AAC_HEADER_LENGTH, MAX_PCE_SIZE);
+                                init_get_bits8(&gb, get_codecpar(stream)->extradata, get_codecpar(stream)->extradata_size);
+                                skip_bits_long(&gb, off + 3);
+
+                                put_bits(&pb, 3, 5); //ID_PCE
+                                track.aacbuflen = AAC_HEADER_LENGTH + (avpriv_copy_pce_data(&pb, &gb) + 3) / 8;
+                                flush_put_bits(&pb);
+                            }
+                            else {
+                                track.aacbuflen = AAC_HEADER_LENGTH;
+                                track.aacbuf = malloc(AAC_HEADER_LENGTH+1);
+                            }
+
                             // https://wiki.multimedia.cx/index.php/ADTS
                             object_type -= 1; //ADTS - profile, the MPEG-4 Audio Object Type minus 1
-                            
-                            track.aacbuflen = AAC_HEADER_LENGTH;
-                            track.aacbuf = malloc(8);
+
                             track.aacbuf[0] = 0xFF;
                             track.aacbuf[1] = 0xF1;
@@ -2570 +2841 @@
 
                     }
+#ifdef __sh__
                     else if(get_codecpar(stream)->codec_id == AV_CODEC_ID_WMAV1
                         || get_codecpar(stream)->codec_id == AV_CODEC_ID_WMAV2
@@ -2576 +2848 @@
                     {
                         ffmpeg_printf(10,"Create WMA ExtraData\n");
-                        uint16_t channels = get_codecpar(stream)->channels;
-                        uint32_t rate = get_codecpar(stream)->sample_rate;
-                        uint32_t bitrate = get_codecpar(stream)->bit_rate;
-                        uint16_t block_align = get_codecpar(stream)->block_align;
-                        uint16_t depth = get_codecpar(stream)->bits_per_coded_sample;
-                        uint32_t codec_data_size = get_codecpar(stream)->extradata_size;
-                        uint8_t *codec_data_pointer = get_codecpar(stream)->extradata;
-                        
+
                         // type_specific_data
-                        #define WMA_VERSION_1           0x160
-                        #define WMA_VERSION_2_9         0x161
-                        #define WMA_VERSION_9_PRO       0x162
-                        #define WMA_LOSSLESS            0x163
                         uint16_t codec_id = 0;
                         switch(get_codecpar(stream)->codec_id)
@@ -2594 +2855 @@
                             //TODO: What code for lossless ?
                             case AV_CODEC_ID_WMALOSSLESS:
-                                codec_id = WMA_LOSSLESS;
+                                codec_id = 0x163; // WMA_LOSSLESS
                                 break;
                             case AV_CODEC_ID_WMAPRO:
-                                codec_id = WMA_VERSION_9_PRO;
+                                codec_id = 0x162; // WMA_VERSION_9_PRO
                                 break;
                             case AV_CODEC_ID_WMAV2:
-                                codec_id = WMA_VERSION_2_9 ;
+                                codec_id = 0x161; // WMA_VERSION_2_9
                                 break;
                             case AV_CODEC_ID_WMAV1:
                             default:
-                                codec_id = WMA_VERSION_1;
+                                codec_id = 0x160; // WMA_VERSION_1
                                 break;
                         }
-#ifdef __sh__
+                        
                         track.aacbuflen = 104 + get_codecpar(stream)->extradata_size;
                         track.aacbuf = malloc(track.aacbuflen);
@@ -2675 +2936 @@
 
                         memcpy(track.aacbuf + 96, get_codecpar(stream)->extradata, get_codecpar(stream)->extradata_size);
-#else
-                        track.aacbuflen = 18 + get_codecpar(stream)->extradata_size;
-                        track.aacbuf = malloc(track.aacbuflen);
-                        memset (track.aacbuf, 0, track.aacbuflen);
-                        
-                        uint8_t *data = track.aacbuf;
-                        /* codec tag */
-                        *(data++) = codec_id & 0xff;
-                        *(data++) = (codec_id >> 8) & 0xff;
-                        /* channels */
-                        *(data++) = channels & 0xff;
-                        *(data++) = (channels >> 8) & 0xff;
-                        /* sample rate */
-                        *(data++) = rate & 0xff;
-                        *(data++) = (rate >> 8) & 0xff;
-                        *(data++) = (rate >> 16) & 0xff;
-                        *(data++) = (rate >> 24) & 0xff;
-                        /* byte rate */
-                        bitrate /= 8;
-                        *(data++) = bitrate & 0xff;
-                        *(data++) = (bitrate >> 8) & 0xff;
-                        *(data++) = (bitrate >> 16) & 0xff;
-                        *(data++) = (bitrate >> 24) & 0xff;
-                        /* block align */
-                        *(data++) = block_align & 0xff;
-                        *(data++) = (block_align >> 8) & 0xff;
-                        /* word size */
-                        *(data++) = depth & 0xff;
-                        *(data++) = (depth >> 8) & 0xff;
-                        /* codec data size */
-                        *(data++) = codec_data_size & 0xff;
-                        *(data++) = (codec_data_size >> 8) & 0xff;
-                        memcpy(data, codec_data_pointer, codec_data_size);
+
+                        ffmpeg_printf(1, "aacbuf:\n");
+                        track.have_aacheader = 1;
+                    }
 #endif
-                        ffmpeg_printf(1, "aacbuf:\n");
-                        //Hexdump(track.aacbuf, track.aacbuflen);
-
-                        //ffmpeg_printf(1, "priv_data:\n");
-                        //Hexdump(get_codecpar(stream)->priv_data, track.aacbuflen);
-
-                        track.have_aacheader = 1;
-                    }
-                    
                     if (context->manager->audio)
                     {
-                        ffmpeg_printf(1, "cAVIdx[%d]: MANAGER_ADD track AUDIO\n");
+                        ffmpeg_printf(1, "cAVIdx[%d]: MANAGER_ADD track AUDIO\n", cAVIdx);
                         if (context->manager->audio->Command(context, MANAGER_ADD, &track) < 0) 
                         {
@@ -2741 +2964 @@
                     get_codecpar(stream)->codec_id != AV_CODEC_ID_SUBRIP && 
                     get_codecpar(stream)->codec_id != AV_CODEC_ID_TEXT &&
-                    get_codecpar(stream)->codec_id != AV_CODEC_ID_SRT)
+                    get_codecpar(stream)->codec_id != AV_CODEC_ID_SRT &&
+                    get_codecpar(stream)->codec_id != AV_CODEC_ID_WEBVTT &&
+                    ((get_codecpar(stream)->codec_id != AV_CODEC_ID_HDMV_PGS_SUBTITLE &&
+                      get_codecpar(stream)->codec_id != AV_CODEC_ID_DVB_SUBTITLE &&
+                      get_codecpar(stream)->codec_id != AV_CODEC_ID_XSUB) ||
+                     !GetGraphicSubPath() || !GetGraphicSubPath()[0]))
                 {
                     ffmpeg_printf(10, "subtitle with not supported codec codec_id[%u]\n", (uint32_t)get_codecpar(stream)->codec_id);
@@ -2767 +2995 @@
                     }
 
-                    track.extraData      = get_codecpar(stream)->extradata;
-                    track.extraSize      = get_codecpar(stream)->extradata_size;
-
                     ffmpeg_printf(1, "subtitle codec %d\n", get_codecpar(stream)->codec_id);
                     ffmpeg_printf(1, "subtitle width %d\n", get_codecpar(stream)->width);
@@ -2789 +3014 @@
             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;
@@ -2795 +3021 @@
     
     }
-
+    
+    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;
 }
@@ -2931 +3195 @@
     }
 
-    if(avio_opts != NULL)
-    {
-        av_dict_free(&avio_opts);
+    if(g_avio_opts != NULL)
+    {
+        av_dict_free(&g_avio_opts);
     }
 
@@ -2951 +3215 @@
     off_t current_pos = avio_tell(avContextTab[0]->pb);
 
-    ffmpeg_printf(20, "seeking to position %lld (bytes)\n", pos);
+    ffmpeg_printf(20, "seeking to position %"PRId64" (bytes)\n", pos);
 
     if (current_pos > pos)
@@ -2964 +3228 @@
     }
 
-    ffmpeg_printf(30, "current_pos after seek %lld\n", avio_tell(avContextTab[0]->pb));
+    ffmpeg_printf(30, "current_pos after seek %"PRId64"\n", avio_tell(avContextTab[0]->pb));
 
     return cERR_CONTAINER_FFMPEG_NO_ERROR;
 }
 
-/* seeking relative to a given byteposition N seconds ->for reverse playback needed */
-static int32_t container_ffmpeg_seek_rel(Context_t *context, off_t pos, int64_t pts, int64_t sec) 
+static int32_t container_ffmpeg_seek(Context_t *context, int64_t sec, uint8_t absolute)
 {
     Track_t *videoTrack = NULL;
     Track_t *audioTrack = NULL;
     Track_t *current = NULL;
-    seek_target_flag = 0;
-
-    ffmpeg_printf(10, "seeking %f sec relativ to %lld\n", sec, pos);
-
-    context->manager->video->Command(context, MANAGER_GET_TRACK, &videoTrack);
-    context->manager->audio->Command(context, MANAGER_GET_TRACK, &audioTrack);
-
-    if (videoTrack != NULL)
-    {
-        current = videoTrack;
-    }
-    else if (audioTrack != NULL)
-    {
-        current = audioTrack;
-    }
-    
-    if (current == NULL) 
-    {
-        ffmpeg_err( "no track avaibale to seek\n");
-        return cERR_CONTAINER_FFMPEG_ERR;
-    }
-
-    if (pos == -1)
-    {
-        pos = avio_tell(avContextTab[0]->pb);
-    }
-
-    if (pts == -1)
-    {
-        pts = current->pts;
-    }
-    
-    if (sec < 0)
-    {
-        seek_target_flag |= AVSEEK_FLAG_BACKWARD;
-    }
-
-    ffmpeg_printf(10, "iformat->flags %d\n", avContextTab[0]->iformat->flags);
-#if defined(TS_BYTES_SEEKING) && TS_BYTES_SEEKING
-    if (avContextTab[0]->iformat->flags & AVFMT_TS_DISCONT)
-    {
-        if (avContextTab[0]->bit_rate)
-        {
-            sec *= avContextTab[0]->bit_rate / 8;
-            ffmpeg_printf(10, "bit_rate %d\n", avContextTab[0]->bit_rate);
-        }
-        else
-        {
-            sec *= 180000;
-        }
-
-        pos += sec;
-
-        if (pos < 0)
-        {
-           ffmpeg_err("end of file reached\n");
-           releaseMutex(__FILE__, __FUNCTION__,__LINE__);
-           return cERR_CONTAINER_FFMPEG_END_OF_FILE;
-        }
-
-        ffmpeg_printf(10, "1. seeking to position %lld bytes ->sec %f\n", pos, sec);
-
-        seek_target_bytes = pos;
-        do_seek_target_bytes = 1;
-
-        return pos;
-    }
-    else
-#endif
-    {
-        sec += pts / 90000;
-
-        if (sec < 0)
-        {
-            sec = 0;
-        }
-
-        ffmpeg_printf(10, "2. seeking to position %f sec ->time base %f %d\n", sec, av_q2d(((AVStream*) current->stream)->time_base), AV_TIME_BASE);
-
-        seek_target_seconds = sec * AV_TIME_BASE;
-        do_seek_target_seconds = 1;
-    }
-
-    releaseMutex(__FILE__, __FUNCTION__,__LINE__);
-    return cERR_CONTAINER_FFMPEG_NO_ERROR;
-}
-
-static int32_t container_ffmpeg_seek(Context_t *context, int64_t sec, uint8_t absolute)
-{
-    Track_t *videoTrack = NULL;
-    Track_t *audioTrack = NULL;
-    Track_t *current = NULL;
-    seek_target_flag = 0;
 
     if (!absolute) 
     {
-        ffmpeg_printf(10, "seeking %f sec\n", sec);
+        ffmpeg_printf(10, "seeking %"PRId64" sec\n", sec);
         if (sec == 0)
         {
@@ -3090 +3260 @@
     }
     
-    ffmpeg_printf(10, "goto %d sec\n", sec);
+    ffmpeg_printf(10, "goto %"PRId64" sec\n", sec);
     if (sec < 0)
     {
@@ -3113 +3283 @@
     }
 
-    if (sec < 0)
-    {
-        seek_target_flag |= AVSEEK_FLAG_BACKWARD;
-    }
-
-    getMutex(__FILE__, __FUNCTION__,__LINE__);
-
     if (!context->playback || !context->playback->isPlaying)
     {
-        releaseMutex(__FILE__, __FUNCTION__,__LINE__);
         return cERR_CONTAINER_FFMPEG_NO_ERROR;
     }
 
-    ffmpeg_printf(10, "iformat->flags %d\n", avContextTab[0]->iformat->flags);
-#if defined(TS_BYTES_SEEKING) && TS_BYTES_SEEKING
-    if (avContextTab[0]->iformat->flags & AVFMT_TS_DISCONT)
-    {
-        /* konfetti: for ts streams seeking frame per seconds does not work (why?).
-        * I take this algo partly from ffplay.c.
-        *
-        * seeking per HTTP does still not work very good. forward seeks everytime
-        * about 10 seconds, backward does not work.
-        */
-
-        off_t pos = avio_tell(avContextTab[0]->pb);
-
-        ffmpeg_printf(10, "pos %lld %d\n", pos, avContextTab[0]->bit_rate);
-
-        if (avContextTab[0]->bit_rate)
-        {
-            sec *= avContextTab[0]->bit_rate / 8;
-            ffmpeg_printf(10, "bit_rate %d\n", avContextTab[0]->bit_rate);
-        }
-        else
-        {
-            sec *= 180000;
-        }
-        
-        pos = sec;
-        
-        if (pos < 0)
-        {
-           pos = 0;
-        }
-        
-        ffmpeg_printf(10, "1. seeking to position %lld bytes ->sec %d\n", pos, sec);
-
-        seek_target_bytes = pos;
-        do_seek_target_bytes = 1;
-
-    } 
-    else
-#endif
-    {
-        seek_target_seconds = sec * AV_TIME_BASE;
-        do_seek_target_seconds = 1;
-    }
-
-    releaseMutex(__FILE__, __FUNCTION__,__LINE__);
+    getSeekMutex();
+    g_seek_target_seconds = sec * AV_TIME_BASE;
+    g_do_seek_target_seconds = true;
+    g_stamp = context->playback->stamp;
+    releaseSeekMutex();
+
     return cERR_CONTAINER_FFMPEG_NO_ERROR;
 }
@@ -3232 +3354 @@
 {
     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)
+            {
+                // do not discard any stream from second context
+                if (Tracks[i].AVIdx == 0) {
+                    ((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;
@@ -3248 +3391 @@
      * 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
@@ -3466 +3609 @@
         break;
     }
-    //obi (end)
+    //obi (end) 
     default:
         ffmpeg_err("ContainerCmd %d not supported!\n", command);
@@ -3477 +3620 @@
 }
 
-static char *FFMPEG_Capabilities[] = {"aac", "avi", "mkv", "mp4", "ts", "mov", "flv", "flac", "mp3", "mpg", "m2ts", "vob", "evo", "wmv","wma", "asf", "mp2", "m4v", "m4a", "fla", "divx", "dat", "mpeg", "trp", "mts", "vdr", "ogg", "wav", "wtv", "asx", "mvi", "png", "jpg", "ra", "ram", "rm", "3gp", "amr", "webm", "m3u8", "mpd", NULL };
+static char *FFMPEG_Capabilities[] = {"aac", "avi", "mkv", "mp4", "ts", "mov", "flv", "flac", "mp3", "mpg", "m2ts", "vob", "evo", "wmv","wma", "asf", "mp2", "m4v", "m4a", "fla", "divx", "dat", "mpeg", "trp", "mts", "vdr", "ogg", "wav", "wtv", "asx", "mvi", "png", "jpg", "jpeg", "ra", "ram", "rm", "3gp", "amr", "rmvb", "rm", "webm", "opus", "m3u8", "mpd", NULL };
 
 Container_t FFMPEGContainer = {

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

@@ -4 +4 @@
 //
 
-#define MPEG4P2_MAX_B_FRAMES_COUNT 5
-
+// mpeg4_unpack_bframes
 typedef struct
 {
-    int b_frames_count;
-    int first_ip_frame_written;
-    int64_t packet_duration;
-    AVPacket *b_frames[MPEG4P2_MAX_B_FRAMES_COUNT];
-    AVPacket *second_ip_frame;
+    const AVBitStreamFilter *bsf;
+    AVBSFContext *ctx;
 } Mpeg4P2Context;
 
-
-static void set_packet(AVPacket **pkt_dest, AVPacket *pkt_src)
+static Mpeg4P2Context * mpeg4p2_context_open()
 {
-    if (pkt_dest == NULL)
-        return;
-    if (*pkt_dest != NULL)
-    {
-        wrapped_packet_unref(*pkt_dest);
-        av_free(*pkt_dest);
+    Mpeg4P2Context *context = NULL;
+    const AVBitStreamFilter *bsf = av_bsf_get_by_name("mpeg4_unpack_bframes");
+    if (bsf) {
+        context = malloc(sizeof(Mpeg4P2Context));
+        if (context) {
+            memset(context, 0x00, sizeof(Mpeg4P2Context));
+            context->bsf = bsf;
+        }
     }
-    *pkt_dest = av_malloc(sizeof(AVPacket));
-    av_copy_packet(*pkt_dest, pkt_src);
+    return context;
 }
 
-static int filter_packet(AVBitStreamFilterContext *bsf_ctx, AVCodecContext *enc_ctx, AVPacket *pkt)
+static void mpeg4p2_write(Context_t *ctx, Mpeg4P2Context *mpeg4p2_ctx, Track_t *track, int64_t start_time, int64_t *currentVideoPts, int64_t *latestPts, AVPacket *pkt)
 {
-    int ret;
-    AVPacket new_pkt = *pkt;
-    ret = av_bitstream_filter_filter(bsf_ctx, enc_ctx, NULL,
-            &new_pkt.data, &new_pkt.size,
-            pkt->data, pkt->size,
-            pkt->flags & AV_PKT_FLAG_KEY);
-    if (ret == 0 && new_pkt.data != pkt->data)
-    {
-        if ((ret = av_copy_packet(&new_pkt, pkt)) < 0)
-            return -1;
-        ret = 1;
-    }
-    if (ret > 0)
-    {
-        pkt->side_data = NULL;
-        pkt->side_data_elems = 0;
-        wrapped_packet_unref(pkt);
-        new_pkt.buf = av_buffer_create(new_pkt.data, new_pkt.size,
-                av_buffer_default_free, NULL, 0);
-        if (!new_pkt.buf)
-            return -1;
-    }
-    if (ret < 0)
-    {
-        ffmpeg_err("Failed to filter bitstream with filter %s for stream %d with codec %s\n",
-                bsf_ctx->filter->name, pkt->stream_index,
-                avcodec_get_name(enc_ctx->codec_id));
-        return -1;
-    }
-    *pkt = new_pkt;
-    return 0;
-}
-
-static void mpeg4p2_context_reset(Mpeg4P2Context *context)
-{
-    if (context == NULL)
-        return;
-    int i;
-    for (i=0; i < MPEG4P2_MAX_B_FRAMES_COUNT; i++)
-    {
-        if (context->b_frames[i] != NULL)
-        {
-            wrapped_packet_unref(context->b_frames[i]);
-            av_free(context->b_frames[i]);
-        }
-        context->b_frames[i] = NULL;
-    }
-    if (context->second_ip_frame != NULL)
-    {
-        wrapped_packet_unref(context->second_ip_frame);
-        av_free(context->second_ip_frame);
-    }
-    context->second_ip_frame = NULL;
-
-    context->b_frames_count = 0;
-    context->first_ip_frame_written = 0;
-    context->packet_duration = 0;
-}
-
-static void mpeg4p2_write(Context_t *ctx, Track_t *track, int avContextIdx, int64_t *currentVideoPts, int64_t *latestPts, AVPacket *pkt)
-{
-    *currentVideoPts = track->pts = calcPts(avContextIdx, track->stream, pkt->pts);
-    if ((*currentVideoPts > *latestPts) && (*currentVideoPts != INVALID_PTS_VALUE))
-    {
+    *currentVideoPts = track->pts = doCalcPts(start_time, mpeg4p2_ctx->ctx->time_base_out, pkt->pts);
+    if ((*currentVideoPts > *latestPts) && (*currentVideoPts != INVALID_PTS_VALUE)) {
         *latestPts = *currentVideoPts;
     }
-    track->dts = calcPts(avContextIdx, track->stream, pkt->dts);
+
+    track->dts = doCalcPts(start_time, mpeg4p2_ctx->ctx->time_base_out, pkt->dts);
 
     AudioVideoOut_t avOut;
@@ -104 +39 @@
     avOut.pts        = track->pts;
     avOut.dts        = track->dts;
-    avOut.extradata  = track->extraData;
-    avOut.extralen   = track->extraSize;
+    avOut.extradata  = mpeg4p2_ctx->ctx->par_out->extradata;
+    avOut.extralen   = mpeg4p2_ctx->ctx->par_out->extradata_size;
     avOut.frameRate  = track->frame_rate;
     avOut.timeScale  = track->TimeScale;
@@ -112 +47 @@
     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");
     }
 }
 
+static int mpeg4p2_context_reset(Mpeg4P2Context *context)
+{
+    int ret = 0;
+    if (context && context->ctx) {
+        // Flush
+        ret = av_bsf_send_packet(context->ctx, NULL);
+        if (ret == 0) {
+            AVPacket *pkt = NULL;
+            while ((ret = av_bsf_receive_packet(context->ctx, pkt)) == 0) {
+                wrapped_frame_unref(pkt);
+            }
+        }
+        av_bsf_free(&context->ctx);
+    }
+
+    return ret;
+}
+
 static int mpeg4p2_write_packet(Context_t *ctx, Mpeg4P2Context *mpeg4p2_ctx, Track_t *track, int cAVIdx, int64_t *pts_current, int64_t *pts_latest, AVPacket *pkt)
 {
-    uint8_t *data = pkt->data;
-    int data_len = pkt->size;
-    int pos = 0;
-    if (mpeg4p2_ctx->packet_duration == 0)
-    {
-        mpeg4p2_ctx->packet_duration = pkt->duration;
-    }
-    while (pos < data_len)
-    {
-        if (memcmp(&data[pos], "\x00\x00\x01\xb6", 4))
-        {
-            pos++;
-            continue;
+    int ret = 0;
+    if (mpeg4p2_ctx) {
+        // Setup is needed
+        if (!mpeg4p2_ctx->ctx) {
+            ret = av_bsf_alloc(mpeg4p2_ctx->bsf, &mpeg4p2_ctx->ctx);
+            if (ret == 0) {
+                AVStream *in = track->stream;
+                ret = avcodec_parameters_copy(mpeg4p2_ctx->ctx->par_in, in->codecpar);
+                if (ret == 0) {
+                    mpeg4p2_ctx->ctx->time_base_in = in->time_base;
+                    ret = av_bsf_init(mpeg4p2_ctx->ctx);
+                }
+            }
         }
-        pos += 4;
-        switch ((data[pos] & 0xC0) >> 6)
-        {
-            case 0: // I-Frame
-            case 1: // P-Frame
-                if (!mpeg4p2_ctx->first_ip_frame_written)
-                {
-                    mpeg4p2_ctx->first_ip_frame_written = 1;
-                    pkt->pts = pkt->dts + mpeg4p2_ctx->packet_duration;
-                    ffmpeg_printf(100, "Writing first I/P packet\n");
-                    mpeg4p2_write(ctx, track, cAVIdx, pts_current, pts_latest, pkt);
+
+        if (ret == 0) {
+            ret = av_bsf_send_packet(mpeg4p2_ctx->ctx, pkt);
+            if (ret == 0) {
+                while ((ret = av_bsf_receive_packet(mpeg4p2_ctx->ctx, pkt)) == 0) {
+                    mpeg4p2_write(ctx, mpeg4p2_ctx, track, avContextTab[cAVIdx]->start_time, pts_current, pts_latest, pkt);
+                }
+
+                if (ret == AVERROR(EAGAIN)) {
                     return 0;
                 }
-                else if (!mpeg4p2_ctx->second_ip_frame)
-                {
-                    set_packet(&mpeg4p2_ctx->second_ip_frame, pkt);
-                    return 0;
+
+                if (ret < 0) {
+                    ffmpeg_err("av_bsf_receive_packet failed error 0x%x\n", ret);
+                    mpeg4p2_context_reset(mpeg4p2_ctx);
                 }
-                else
-                {
-                    if (!mpeg4p2_ctx->b_frames_count)
-                    {
-                        mpeg4p2_ctx->second_ip_frame->pts = mpeg4p2_ctx->second_ip_frame->dts + mpeg4p2_ctx->packet_duration;
-                        ffmpeg_printf(100,"Writing second I/P packet(1)\n");
-                        mpeg4p2_write(ctx, track, cAVIdx, pts_current, pts_latest, mpeg4p2_ctx->second_ip_frame);
-                        set_packet(&mpeg4p2_ctx->second_ip_frame, pkt);
-                        return 0;
-                    }
-                    else
-                    {
-                        mpeg4p2_ctx->second_ip_frame->pts = mpeg4p2_ctx->b_frames[mpeg4p2_ctx->b_frames_count -1]->dts + mpeg4p2_ctx->packet_duration;
-                        mpeg4p2_ctx->b_frames[0]->pts = mpeg4p2_ctx->second_ip_frame->dts + mpeg4p2_ctx->packet_duration;
-                        int i;
-                        for (i =1; i < mpeg4p2_ctx->b_frames_count; i++)
-                        {
-                            mpeg4p2_ctx->b_frames[i]->pts = mpeg4p2_ctx->b_frames[i-1]->dts + mpeg4p2_ctx->packet_duration;
-                        }
-                        ffmpeg_printf(100, "Writing second I/P packet(2)\n");
-                        mpeg4p2_write(ctx, track, cAVIdx, pts_current, pts_latest, mpeg4p2_ctx->second_ip_frame);
-                        set_packet(&mpeg4p2_ctx->second_ip_frame, pkt);
-                        for (i =0; i< mpeg4p2_ctx->b_frames_count; i++)
-                        {
-                            ffmpeg_printf(100, "Writing B-frame[%d]\n", i);
-                            mpeg4p2_write(ctx, track, cAVIdx, pts_current, pts_latest, mpeg4p2_ctx->b_frames[i]);
-                        }
-                        mpeg4p2_ctx->b_frames_count = 0;
-                        return 0;
-                    }
-                }
-                break;
-            case 3: // S-Frame
-                break;
-            case 2: // B-Frame
-                if (!mpeg4p2_ctx->second_ip_frame)
-                {
-                    ffmpeg_err("Cannot predict B-Frame without surrounding I/P-Frames, dropping...");
-                    return 0;
-                }
-                if (mpeg4p2_ctx->b_frames_count == MPEG4P2_MAX_B_FRAMES_COUNT)
-                {
-                    ffmpeg_err("Oops max B-Frames count = %d, reached", MPEG4P2_MAX_B_FRAMES_COUNT);
-                    // not recoverable, to fix just increase MPEG4P2_MAX_B_FRAMES_COUNT
-                    return -1;
-                }
-                else
-                {
-                    ffmpeg_printf(100, "Storing B-Frame\n");
-                    set_packet(&mpeg4p2_ctx->b_frames[mpeg4p2_ctx->b_frames_count++], pkt);
-                    return 0;
-                }
-            case 4:
-            default:
-                break;
+            }
+        } else {
+            ffmpeg_err("bsf setup failed error 0x%x\n", ret);
         }
+        
+    } else {
+        ret = -1;
     }
-    return 0;
+    return ret;
 }
 
+static void mpeg4p2_context_close(Mpeg4P2Context *context)
+{
+    if (context) {
+        mpeg4p2_context_reset(context);
+        free(context);
+        return;
+    }
+}
+

titan/libeplayer3/container/wrapped_ffmpeg.c

@@ -143 +143 @@
         if (!avCodecCtx) 
         {
-            fprintf(stderr, "context3 alloc for stream %d failed\n", (int)stream->id);
+            ffmpeg_err("context3 alloc for stream %d failed\n", (int)stream->id);
             return NULL;
         }
@@ -149 +149 @@
         if (avcodec_parameters_to_context(avCodecCtx, stream->codecpar) < 0)
         {
-            fprintf(stderr, "parameters to context for stream %d failed\n", (int)stream->id);
+            ffmpeg_err("parameters to context for stream %d failed\n", (int)stream->id);
             avcodec_free_context(&avCodecCtx);
             return NULL;
@@ -159 +159 @@
 #endif
         store_avcodec_context(avCodecCtx, cAVIdx, stream->id);
-        
+
         return avCodecCtx;
     }
@@ -188 +188 @@
         }
     }
-#endif    
-}
+#endif
+}
+
+static void wrapped_register_all(void)
+{
+#if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(58, 9, 100)
+    avcodec_register_all();
+    av_register_all();
+#endif
+}
+
+static int64_t wrapped_frame_get_best_effort_timestamp(const AVFrame *frame)
+{
+#if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(58, 9, 100)
+    return av_frame_get_best_effort_timestamp(frame);
+#else
+    return frame->best_effort_timestamp;
+#endif
+}
+
+

titan/libeplayer3/external/ffmpeg/mpeg4audio.h

@@ -107 +107 @@
 
 int avpriv_copy_pce_data(PutBitContext *pb, GetBitContext *gb);
+uint8_t get_chan_config(int channels);
 
 #endif /* AVCODEC_MPEG4AUDIO_H */

titan/libeplayer3/external/ffmpeg/src/latmenc.c

@@ -27 +27 @@
 #include <ffmpeg/mpeg4audio.h>
 #include <ffmpeg/latmenc.h>
+#include "debug.h"
 
 /* ***************************** */
 /* Makros/Constants              */
 /* ***************************** */
-//#define LATMENC_SILENT
-
-#ifndef LATMENC_SILENT
-#define latmenc_err(fmt, x...) do { printf("[%s:%s] " fmt, __FILE__, __FUNCTION__, ## x); } while (0)
-#else
-#define latmenc_err(fmt, x...)
-#endif
-
 
 int latmenc_decode_extradata(LATMContext *ctx, uint8_t *buf, int size)

titan/libeplayer3/external/ffmpeg/src/mpeg4audio.c

@@ -77 +77 @@
     return *index == 0x0f ? get_bits(gb, 24) :
         avpriv_mpeg4audio_sample_rates[*index];
+}
+
+uint8_t get_chan_config(int channels)
+{
+    uint8_t chan_config = 0;
+    int i;
+    for (i=0; i<FF_ARRAY_ELEMS(ff_mpeg4audio_channels); i++) {
+        if (channels == ff_mpeg4audio_channels[i]) {
+            chan_config = i;
+            break;
+        }
+    }
+    return chan_config;
 }
 

titan/libeplayer3/external/flv2mpeg4/src/bitwriter.h

@@ -121 +121 @@
                 break;
         default:
-//              fprintf(stderr, "flash_bw error!(%d)\n", p->bitoffset);
                 break;
         }

titan/libeplayer3/external/flv2mpeg4/src/flvdecoder.c

@@ -465 +465 @@
         if (get_bits(p, 17) != 1)
         {
-                fprintf(stderr, "start code error\n");
                 return -1;
         }
@@ -472 +471 @@
         if (tmp !=0 && tmp != 1)
         {
-                fprintf(stderr, "picture format error\n");
                 return -1;
         }
@@ -479 +477 @@
         picture->frame_number = get_bits(p, 8);
         
-//      printf("picture_format: %d\n", tmp);
-//      printf("picture_number: %d\n", get_bits(p, 8));
-                
         tmp = get_bits(p, 3);
         switch (tmp)
@@ -499 +494 @@
         case 6: width = 160, height = 120; break;
         default:
-                fprintf(stderr, "size error\n");
                 return -1;
         }

titan/libeplayer3/include/bcm_ioctls.h

@@ -52 +52 @@
         STREAMTYPE_DIVX4 = 14,
         STREAMTYPE_DIVX5 = 15,
-        STREAMTYPE_VB6 = 18,
+        STREAMTYPE_VB6 = 18, /* 17 is also valid for ZGEMMA STBs*/
         STREAMTYPE_SPARK = 21,
+        STREAMTYPE_MJPEG = 30,
+        STREAMTYPE_RV30 = 31,  /* rv30: RealVideo 8, suspected to based largely on an early draft of H.264 (included with RealPlayer 8)*/
+        STREAMTYPE_RV40 = 32, /* RealVideo 9, RealVideo 10*/
+        STREAMTYPE_AVS2 = 40,
 } video_stream_type_t;
-
-
 
 typedef enum {
@@ -73 +75 @@
         AUDIOTYPE_AC3_PLUS = 0x22,
         AUDIOTYPE_AMR = 0x23,
-        AUDIOTYPE_RAW = 0xf
+        AUDIOTYPE_OPUS = 0x24,
+        AUDIOTYPE_VORBIS = 0x25,
+        AUDIOTYPE_RAW = 0x30
 } audio_stream_type_t;
 

titan/libeplayer3/include/common.h

@@ -10 +10 @@
 #include <pthread.h>
 
-typedef char PlayFilesTab_t[2];
-
 typedef struct PlayFiles_t 
 { 
     char *szFirstFile;
     char *szSecondFile;
+    char *szFirstMoovAtomFile;
+    char *szSecondMoovAtomFile;
+    uint64_t iFirstFileSize;
+    uint64_t iSecondFileSize;
+    uint64_t iFirstMoovAtomOffset;
+    uint64_t iSecondMoovAtomOffset;
 } PlayFiles_t;
 
@@ -25 +29 @@
     ManagerHandler_t    *manager;
 } Context_t;
+// obi
+char* subtext;
+// obi
+int container_ffmpeg_update_tracks(Context_t *context, char *filename, int initial);
 
-char* subtext;
+const char* GetGraphicSubPath();
+int32_t GetGraphicWindowWidth();
+int32_t GetGraphicWindowHeight();
 
-int container_ffmpeg_update_tracks(Context_t *context, char *filename, int initial);
+void E2iSendMsg(const char * format, ...);
+void E2iStartMsg(void);
+void E2iEndMsg(void);
+
 #endif

titan/libeplayer3/include/container.h

@@ -25 +25 @@
 CONTAINER_GET_BUFFER_STATUS,
 CONTAINER_STOP_BUFFER,
+//obi
 CONTAINER_GET_SUBTEXT
+//obi
 } ContainerCmd_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;
 
@@ -28 +30 @@
     char *                Name;
     char *                Encoding;
+// obi
     char *                File;
+// obi
     int32_t               Id;
     int32_t               AVIdx;

titan/libeplayer3/include/misc.h

@@ -1 @@
-#ifndef misc_123
-#define misc_123
+#ifndef _exteplayer3_misc_
+#define _exteplayer3_misc_
 
 #include <dirent.h>
@@ -21 +21 @@
 } BitPacker_t;
 
+typedef enum {
+    STB_UNKNOWN,
+    STB_DREAMBOX,
+    STB_VUPLUS,
+    STB_HISILICON,
+    STB_OTHER=999,
+} stb_type_t;
+
 /* ***************************** */
 /* Makros/Constants              */
 /* ***************************** */
-
 #define INVALID_PTS_VALUE                       0x200000000ull
 
@@ -30 +37 @@
 /* Prototypes                    */
 /* ***************************** */
-
 void PutBits(BitPacker_t * ld, uint32_t code, uint32_t length);
 void FlushBits(BitPacker_t * ld);
 int8_t PlaybackDieNow(int8_t val); 
+stb_type_t GetSTBType();
 
 /* ***************************** */
@@ -52 +59 @@
 }
 
-/* the function returns the base name */
-static inline char * basename(char * name)
-{
-  int i = 0;
-  int pos = 0;
-
-  while(name[i] != 0)
-  {
-    if(name[i] == '/')
-      pos = i;
-    i++;
-  }
-
-  if(name[pos] == '/')
-    pos++;
-
-  return name + pos;
-}
-
-/* the function returns the directry name */
-static inline char * dirname(char * name)
-{
-  static char path[100];
-  uint32_t i = 0;
-  int32_t pos = 0;
-
-  while((name[i] != 0) && (i < sizeof(path)))
-  {
-    if(name[i] == '/')
-    {
-        pos = i;
-    }
-    path[i] = name[i];
-    i++;
-  }
-
-  path[i] = 0;
-  path[pos] = 0;
-
-  return path;
-}
-
-static inline int32_t IsDreambox()
-{
-    struct stat buffer;   
-    return (stat("/proc/stb/tpm/0/serial", &buffer) == 0);
-}
-
 static inline uint32_t ReadUint32(uint8_t *buffer)
 {
@@ -116 +75 @@
 }
 
-#endif
+#endif // _exteplayer3_misc_

titan/libeplayer3/include/output.h

@@ -27 +27 @@
     OUTPUT_GET_FRAME_COUNT,
     OUTPUT_GET_PROGRESSIVE,
+    OUTPUT_SET_BUFFER_SIZE,
+    OUTPUT_GET_BUFFER_SIZE,
 } OutputCmd_t;
 
@@ -53 +55 @@
 typedef struct
 {
-    uint32_t         trackId;
-    uint8_t         *data;
-    uint32_t         len;
-    
-    int64_t          pts;
-    int64_t          durationMS; // duration in miliseconds
-    
-    char            *type;
+    uint32_t          trackId;
+    uint8_t          *data;
+    uint32_t          len;
+
+    uint8_t          *extradata;
+    uint32_t          extralen;
+
+    int64_t           pts;
+    int64_t           dts;
+    int64_t           durationMS; // duration in miliseconds
+
+    uint32_t         width;
+    uint32_t         height;
+
+    char             *type;
 } SubtitleOut_t;
 
@@ -68 +77 @@
     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;
@@ -37 +41 @@
     uint8_t isLoopMode;
     uint8_t isTSLiveMode;
+
+    void *stamp;
 } PlaybackHandler_t;
 

titan/libeplayer3/include/writer.h

@@ -5 +5 @@
 #include <stdio.h>
 #include <stdint.h>
+#include "common.h"
 
 typedef enum { eNone, eAudio, eVideo} eWriterType_t;
+typedef ssize_t (* WriteV_t) (int, const struct iovec *, int);
 
 typedef struct {
@@ -22 +24 @@
     unsigned char          Version;
     unsigned int           InfoFlags;
+    WriteV_t               WriteV;
 } WriterAVCallData_t;
-
-
 
 typedef struct WriterCaps_s {
@@ -57 +58 @@
 extern Writer_t WriterAudioWMAPRO;
 extern Writer_t WriterAudioFLAC;
+extern Writer_t WriterAudioAMR;
 extern Writer_t WriterAudioVORBIS;
-extern Writer_t WriterAudioAMR;
+extern Writer_t WriterAudioOPUS;
 
 extern Writer_t WriterVideoMPEG1;
@@ -77 +79 @@
 extern Writer_t WriterVideoVP8;
 extern Writer_t WriterVideoVP9;
-extern Writer_t WriterVideoSPARK;
+extern Writer_t WriterVideoMJPEG;
 extern Writer_t WriterFramebuffer;
 extern Writer_t WriterPipe;
+extern Writer_t WriterVideoRV30;
+extern Writer_t WriterVideoRV40;
+extern Writer_t WriterVideoAVS2;
 
 Writer_t* getWriter(char* encoding);
@@ -85 +90 @@
 Writer_t* getDefaultVideoWriter();
 Writer_t* getDefaultAudioWriter();
-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 write_with_retry(int fd, const void *buf, int size);
+ssize_t writev_with_retry(int fd, const struct iovec *iov, int ic);
+
+ssize_t WriteWithRetry(Context_t *context, int pipefd, int fd, void *pDVBMtx, const void *buf, int size);
+void FlushPipe(int pipefd);
+
+ssize_t WriteExt(WriteV_t _call, int fd, void *data, size_t size);
+
+// Subtitles
+
+typedef enum {
+    SUBTITLE_CODEC_ID_UNKNOWN,
+    SUBTITLE_CODEC_ID_SUBRIP,
+    SUBTITLE_CODEC_ID_ASS,
+    SUBTITLE_CODEC_ID_WEBVTT,
+    SUBTITLE_CODEC_ID_PGS,
+    SUBTITLE_CODEC_ID_DVB,
+    SUBTITLE_CODEC_ID_XSUB
+} SubtitleCodecId_t;
+
+typedef struct {
+    SubtitleCodecId_t codecId;
+    uint32_t          trackId;
+    uint8_t           *data;
+    uint32_t          len;
+    int64_t           pts;
+    int64_t           dts;
+    uint8_t           *private_data;
+    uint32_t          private_size;
+
+    int64_t           durationMS; // duration in miliseconds
+
+    uint32_t         width;
+    uint32_t         height;
+} WriterSubCallData_t;
+
+typedef struct SubWriter_s {
+    int32_t           (* open) (SubtitleCodecId_t codecId, uint8_t *extradata, int extradata_size);
+    int32_t           (* close) ();
+    int32_t           (* reset) ();
+    int32_t           (* write) (WriterSubCallData_t *);
+} SubWriter_t;
+
+extern SubWriter_t WriterSubPGS;
+
 #endif

titan/libeplayer3/main/exteplayer.c

@@ -24 +24 @@
 #include <sched.h>
 #include <signal.h>
+#include <inttypes.h>
+#include <stdarg.h>
 
 #include <sys/ioctl.h>
@@ -41 +43 @@
 #include "misc.h"
 
+#include "debug.h"
+
 #define DUMP_BOOL(x) 0 == x ? "false"  : "true"
 #define IPTV_MAX_FILE_PATH 1024
@@ -52 +56 @@
 extern void      eac3_software_decoder_set(const int32_t val);
 extern void       mp3_software_decoder_set(const int32_t val);
+extern void       amr_software_decoder_set(const int32_t val);
+extern void    vorbis_software_decoder_set(const int32_t val);
+extern void      opus_software_decoder_set(const int32_t val);
+
 extern void            rtmp_proto_impl_set(const int32_t val);
 extern void        flv2mpeg4_converter_set(const int32_t val);
@@ -85 +93 @@
 }
 
-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 int32_t g_windows_width = 1280;
+static int32_t g_windows_height = 720;
+static char *g_graphic_sub_path;
+
+const char* GetGraphicSubPath()
+{
+    return g_graphic_sub_path;
+}
+
+int32_t GetGraphicWindowWidth()
+{
+    return g_windows_width;
+}
+
+int32_t GetGraphicWindowHeight()
+{
+    return g_windows_height;
+}
+
+void E2iSendMsg(const char *format, ...)
+{
+    va_list args;
+    va_start(args, format);
+    vfprintf(stderr, format, args);
+    va_end(args);
+}
+
+void E2iStartMsg(void)
+{
+    flockfile(stderr);
+}
+
+void E2iEndMsg(void)
+{
+    funlockfile(stderr);
+}
+
+
+static void TerminateWakeUp()
+{
+    int ret = write(g_pfd[1], "x", 1);
+    if (ret != 1) {
+        printf("TerminateWakeUp write return %d\n", ret);
+    }
+}
+
 static void *TermThreadFun(void *arg)
 {
-    const char *socket_path = "/tmp/iptvplayer_extplayer_term_fd";
+    const char *socket_path = "/tmp/.exteplayerterm.socket";
     struct sockaddr_un addr;
     int fd = -1;
@@ -136 +190 @@
     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 +230 @@
 {
     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;
@@ -256 +303 @@
             {
                 int i = 0;
-                fprintf(stderr, "{\"%c_%c\": [", argvBuff[0], argvBuff[1]);
+                E2iStartMsg();
+                E2iSendMsg("{\"%c_%c\": [", argvBuff[0], argvBuff[1]);
                 for (i = 0; TrackList[i].Id >= 0; ++i) 
                 {
                     if(0 < i)
                     {
-                        fprintf(stderr, ", ");
+                        E2iSendMsg(", ");
                     }
-                    fprintf(stderr, "{\"id\":%d,\"e\":\"%s\",\"n\":\"%s\"}", TrackList[i].Id , TrackList[i].Encoding, TrackList[i].Name);
+                    E2iSendMsg("{\"id\":%d,\"e\":\"%s\",\"n\":\"%s\"}", TrackList[i].Id , TrackList[i].Encoding, TrackList[i].Name);
                     free(TrackList[i].Encoding);
                     free(TrackList[i].Name);
                 }
-                fprintf(stderr, "]}\n");
+                E2iSendMsg("]}\n");
+                E2iEndMsg();
                 free(TrackList);
             }
@@ -273 +322 @@
             {
                 // not tracks 
-                fprintf(stderr, "{\"%c_%c\": []}\n", argvBuff[0], argvBuff[1]);
+                E2iSendMsg("{\"%c_%c\": []}\n", argvBuff[0], argvBuff[1]);
             }
             break;
@@ -286 +335 @@
                 if ('a' == argvBuff[0] || 's' == argvBuff[0])
                 {
-                    fprintf(stderr, "{\"%c_%c\":{\"id\":%d,\"e\":\"%s\",\"n\":\"%s\"}}\n", argvBuff[0], argvBuff[1], track->Id , track->Encoding, track->Name);
+                    E2iSendMsg("{\"%c_%c\":{\"id\":%d,\"e\":\"%s\",\"n\":\"%s\"}}\n", argvBuff[0], argvBuff[1], track->Id , track->Encoding, track->Name);
                 }
                 else // video
                 {
-                    fprintf(stderr, "{\"%c_%c\":{\"id\":%d,\"e\":\"%s\",\"n\":\"%s\",\"w\":%d,\"h\":%d,\"f\":%u,\"p\":%d,\"an\":%d,\"ad\":%d}}\n", \
+                    E2iSendMsg("{\"%c_%c\":{\"id\":%d,\"e\":\"%s\",\"n\":\"%s\",\"w\":%d,\"h\":%d,\"f\":%u,\"p\":%d,\"an\":%d,\"ad\":%d}}\n", \
                     argvBuff[0], argvBuff[1], track->Id , track->Encoding, track->Name, track->width, track->height, track->frame_rate, track->progressive, track->aspect_ratio_num, track->aspect_ratio_den);
                 }
@@ -302 +351 @@
                 if ('a' == argvBuff[0] || 's' == argvBuff[0])
                 {
-                    fprintf(stderr, "{\"%c_%c\":{\"id\":%d,\"e\":\"%s\",\"n\":\"%s\"}}\n", argvBuff[0], argvBuff[1], -1, "", "");
+                    E2iSendMsg("{\"%c_%c\":{\"id\":%d,\"e\":\"%s\",\"n\":\"%s\"}}\n", argvBuff[0], argvBuff[1], -1, "", "");
                 }
                 else // video
                 {
-                    fprintf(stderr, "{\"%c_%c\":{\"id\":%d,\"e\":\"%s\",\"n\":\"%s\",\"w\":%d,\"h\":%d,\"f\":%u,\"p\":%d}}\n", argvBuff[0], argvBuff[1], -1, "", "", -1, -1, 0, -1);
+                    E2iSendMsg("{\"%c_%c\":{\"id\":%d,\"e\":\"%s\",\"n\":\"%s\",\"w\":%d,\"h\":%d,\"f\":%u,\"p\":%d}}\n", argvBuff[0], argvBuff[1], -1, "", "", -1, -1, 0, -1);
                 }
             }
@@ -354 +403 @@
                 {
                     commandRetVal = g_player->playback->Command(g_player, playbackSwitchCmd, (void*)&id);
-                    fprintf(stderr, "{\"%c_%c\":{\"id\":%d,\"sts\":%d}}\n", argvBuff[0], 's', id, commandRetVal);
+                    E2iSendMsg("{\"%c_%c\":{\"id\":%d,\"sts\":%d}}\n", argvBuff[0], 's', id, commandRetVal);
                 }
             }
@@ -369 +418 @@
 }
 
-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 +425 @@
     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, "G:W:H:A:V:U:we3dlsrimva:n:x:u:c:h:o:p:P:t:9:0:1:4:f:b:F:S:O:")) != -1) 
     {
         switch (c) 
         {
+        case 'G':
+            g_graphic_sub_path = optarg;
+        case 'W':
+        {
+            int val = atoi(optarg);
+            if (val) g_windows_width = val;
+            break;
+        }
+        case 'H':
+        {
+            int val = atoi(optarg);
+            if (val) g_windows_height = val;
+            break;
+        }
         case 'a':
         {
@@ -392 +455 @@
             eac3_software_decoder_set(1);
             break;
+        case 'A':
+            printf("Software decoder will be used for AMR codec\n");
+            amr_software_decoder_set(atoi(optarg));
+            break;
+        case 'V':
+            printf("Software decoder will be used for VORBIS codec\n");
+            vorbis_software_decoder_set(atoi(optarg));
+            break;
+        case 'U':
+            printf("Software decoder will be used for OPUS codec\n");
+            vorbis_software_decoder_set(atoi(optarg));
+            break;
         case '3':
             printf("Software decoder will be used for AC3 codec\n");
@@ -437 +512 @@
             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 +567 @@
             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 +595 @@
     {
         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 +618 @@
     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];
     memset(argvBuff, '\0', sizeof(argvBuff));
     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))
+    E2iSendMsg("{\"EPLAYER3_EXTENDED\":{\"version\":%d}}\n", 68);
+
+    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");
@@ -539 +643 @@
         printf("[-d] DTS software decoding\n");
         printf("[-m] MP3 software decoding\n");
-        printf("[-w] WMA1, WMA2, WMA/PRO software decoding\n");
+        printf("[-A 0|1] disable|enable AMR software decoding\n");
+        printf("[-V 0|1] disable|enable VORBIS software decoding\n");
+        printf("[-U 0|1] disable|enable AMR software decoding\n");
+        printf("[-w] WMA2, WMA/PRO software decoding\n");
         printf("[-l] software decoder use LPCM for injection (otherwise wav PCM will be used)\n");
         printf("[-s] software decoding as stereo [downmix]\n");
@@ -547 +654 @@
         printf("[-i] play in infinity loop\n");
         printf("[-v] switch to live TS stream mode\n");
-        printf("[-n 0|1|2] rtmp force protocol implementation auto(0) native/ffmpeg(1) or librtmp(2)\n");        
+        printf("[-n 0|1|2] rtmp force protocol implementation auto(0) native/ffmpeg(1) or librtmp(2)\n");
         printf("[-o 0|1] set progressive download\n");
         printf("[-p value] nice value\n");
@@ -560 +667 @@
         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");
+        printf("[-G path (directory where graphic subtitles frames will be saved)\n");
+        printf("[-W osd window width (width of the window used to scale graphic subtitle frame)\n");
+        printf("[-H osd window height (height of the window used to scale graphic subtitle frame)\n");
         exit(1);
     }
@@ -599 +711 @@
             isTermThreadStarted = 1;
     } while(0);
-
+    
     g_player->playback    = &PlaybackHandler;
     g_player->output      = &OutputHandler;
@@ -609 +721 @@
 
     SetBuffering();
-    
+
     //Registrating output devices
     g_player->output->Command(g_player, OUTPUT_ADD, "audio");
     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);
+    E2iSendMsg("{\"PLAYBACK_OPEN\":{\"OutputName\":\"%s\", \"file\":\"%s\", \"sts\":%d}}\n", g_player->output->Name, playbackFiles.szFirstFile, commandRetVal);
     if(commandRetVal < 0)
     {
@@ -644 +754 @@
         
         commandRetVal = g_player->output->Command(g_player, OUTPUT_OPEN, NULL);
-        fprintf(stderr, "{\"OUTPUT_OPEN\":{\"sts\":%d}}\n", commandRetVal);
+        E2iSendMsg("{\"OUTPUT_OPEN\":{\"sts\":%d}}\n", commandRetVal);
         commandRetVal = g_player->playback->Command(g_player, PLAYBACK_PLAY, NULL);
-        fprintf(stderr, "{\"PLAYBACK_PLAY\":{\"sts\":%d}}\n", commandRetVal);
+        E2iSendMsg("{\"PLAYBACK_PLAY\":{\"sts\":%d}}\n", commandRetVal);
         
         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");
@@ -660 +772 @@
             HandleTracks(g_player->manager->audio, (PlaybackCmd_t)-1, "ac");
             
+            
             HandleTracks(g_player->manager->subtitle, (PlaybackCmd_t)-1, "sl");
             if (subtitleTrackIdx >= 0)
@@ -670 +783 @@
         }
 
-        while(g_player->playback->isPlaying)
+        while(g_player->playback->isPlaying && 0 == PlaybackDieNow(0))
         {
             /* we made fgets non blocking */
@@ -705 +818 @@
             {
                 commandRetVal = g_player->playback->Command(g_player, PLAYBACK_STOP, NULL);
-                fprintf(stderr, "{\"PLAYBACK_STOP\":{\"sts\":%d}}\n", commandRetVal);
+                E2iSendMsg("{\"PLAYBACK_STOP\":{\"sts\":%d}}\n", commandRetVal);
                 break;
             }
@@ -711 +824 @@
             {
                 commandRetVal = g_player->playback->Command(g_player, PLAYBACK_CONTINUE, NULL);
-                fprintf(stderr, "{\"PLAYBACK_CONTINUE\":{\"sts\":%d}}\n", commandRetVal);
+                E2iSendMsg("{\"PLAYBACK_CONTINUE\":{\"sts\":%d}}\n", commandRetVal);
                 break;
             }
@@ -717 +830 @@
             {
                 commandRetVal = g_player->playback->Command(g_player, PLAYBACK_PAUSE, NULL);
-                fprintf(stderr, "{\"PLAYBACK_PAUSE\":{\"sts\":%d}}\n", commandRetVal);
+                E2iSendMsg("{\"PLAYBACK_PAUSE\":{\"sts\":%d}}\n", commandRetVal);
                 break;
             }
@@ -726 +839 @@
 
                 commandRetVal = g_player->playback->Command(g_player, PLAYBACK_SLOWMOTION, &speed);
-                fprintf(stderr, "{\"PLAYBACK_SLOWMOTION\":{\"speed\":%d, \"sts\":%d}}\n", speed, commandRetVal);
+                E2iSendMsg("{\"PLAYBACK_SLOWMOTION\":{\"speed\":%d, \"sts\":%d}}\n", speed, commandRetVal);
                 break;
             }
@@ -735 +848 @@
                 {
                     progressive_playback_set(flags);
-                    fprintf(stderr, "{\"PROGRESSIVE_DOWNLOAD\":{\"flags\":%d, \"sts\":0}}\n", flags);
+                    E2iSendMsg("{\"PROGRESSIVE_DOWNLOAD\":{\"flags\":%d, \"sts\":0}}\n", flags);
                 }
                 break;
@@ -745 +858 @@
 
                 commandRetVal = g_player->playback->Command(g_player, PLAYBACK_FASTFORWARD, &speed);
-                fprintf(stderr, "{\"PLAYBACK_FASTFORWARD\":{\"speed\":%d, \"sts\":%d}}\n", speed, commandRetVal);
+                E2iSendMsg("{\"PLAYBACK_FASTFORWARD\":{\"speed\":%d, \"sts\":%d}}\n", speed, commandRetVal);
                 break;
             }
@@ -754 +867 @@
 
                 commandRetVal = g_player->playback->Command(g_player, PLAYBACK_FASTBACKWARD, &speed);
-                fprintf(stderr, "{\"PLAYBACK_FASTBACKWARD\":{\"speed\":%d, \"sts\":%d}}\n", speed, commandRetVal);
+                E2iSendMsg("{\"PLAYBACK_FASTBACKWARD\":{\"speed\":%d, \"sts\":%d}}\n", speed, commandRetVal);
                 break;
             }
@@ -769 +882 @@
                 {
                     commandRetVal = g_player->playback->Command(g_player, PLAYBACK_LENGTH, (void*)&length);
-                    fprintf(stderr, "{\"PLAYBACK_LENGTH\":{\"length\":%lld, \"sts\":%d}}\n", length, commandRetVal);
+                    E2iSendMsg("{\"PLAYBACK_LENGTH\":{\"length\":%"PRId64", \"sts\":%d}}\n", length, commandRetVal);
 
                     lengthInt = (int32_t)length;
@@ -781 +894 @@
                         
                         commandRetVal = g_player->playback->Command(g_player, PLAYBACK_SEEK_ABS, (void*)&sec);
-                        fprintf(stderr, "{\"PLAYBACK_SEEK_ABS\":{\"sec\":%lld, \"sts\":%d}}\n", sec, commandRetVal);
+                        E2iSendMsg("{\"PLAYBACK_SEEK_ABS\":{\"sec\":%"PRId64", \"sts\":%d}}\n", sec, commandRetVal);
                     }
                 }
@@ -802 +915 @@
                 if (0 == commandRetVal)
                 {
-                    fprintf(stderr, "{\"J\":{\"ms\":%lld}}\n", pts / 90, commandRetVal);
+                    E2iSendMsg("{\"J\":{\"ms\":%"PRId64"}}\n", pts / 90);
                 }
                 if(0 == commandRetVal || force)
                 {                    
                     commandRetVal = g_player->playback->Command(g_player, PLAYBACK_LENGTH, (void*)&length);
-                    fprintf(stderr, "{\"PLAYBACK_LENGTH\":{\"length\":%lld, \"sts\":%d}}\n", length, commandRetVal);
+                    E2iSendMsg("{\"PLAYBACK_LENGTH\":{\"length\":%"PRId64", \"sts\":%d}}\n", length, commandRetVal);
                     
                     lengthInt = (int32_t)length;
@@ -831 +944 @@
                     }
                     commandRetVal = g_player->playback->Command(g_player, PLAYBACK_SEEK, (void*)&sec);
-                    fprintf(stderr, "{\"PLAYBACK_SEEK\":{\"sec\":%lld, \"sts\":%d}}\n", sec, commandRetVal);
+                    E2iSendMsg("{\"PLAYBACK_SEEK\":{\"sec\":%"PRId64", \"sts\":%d}}\n", sec, commandRetVal);
                 }
                 break;
@@ -839 +952 @@
                 int64_t length = 0;
                 commandRetVal = g_player->playback->Command(g_player, PLAYBACK_LENGTH, (void*)&length);
-                fprintf(stderr, "{\"PLAYBACK_LENGTH\":{\"length\":%lld, \"sts\":%d}}\n", length, commandRetVal);
+                E2iSendMsg("{\"PLAYBACK_LENGTH\":{\"length\":%"PRId64", \"sts\":%d}}\n", length, commandRetVal);
                 break;
             }
@@ -848 +961 @@
                 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)
+                    {
+                        E2iSendMsg("{\"J\":{\"ms\":%"PRId64",\"lms\":%"PRId64"}}\n", pts / 90, lastPts / 90);
+                    }
+                    else
+                    {
+                        E2iSendMsg("{\"J\":{\"ms\":%"PRId64"}}\n", pts / 90);
+                    }
                 }
                 break;
@@ -857 +984 @@
                 if(ptrP)
                 {
-                    fprintf(stderr, "{\"PLAYBACK_INFO\":{ \"isPlaying\":%s, \"isPaused\":%s, \"isForwarding\":%s, \"isSeeking\":%s, \"isCreationPhase\":%s,", \
+                    E2iSendMsg("{\"PLAYBACK_INFO\":{ \"isPlaying\":%s, \"isPaused\":%s, \"isForwarding\":%s, \"isSeeking\":%s, \"isCreationPhase\":%s,", \
                     DUMP_BOOL(ptrP->isPlaying), DUMP_BOOL(ptrP->isPaused), DUMP_BOOL(ptrP->isForwarding), DUMP_BOOL(ptrP->isSeeking), DUMP_BOOL(ptrP->isCreationPhase) );
-                    fprintf(stderr, "\"BackWard\":%d, \"SlowMotion\":%d, \"Speed\":%d, \"AVSync\":%d,", ptrP->BackWard, ptrP->SlowMotion, ptrP->Speed, ptrP->AVSync);
-                    fprintf(stderr, " \"isVideo\":%s, \"isAudio\":%s, \"isSubtitle\":%s, \"isDvbSubtitle\":%s, \"isTeletext\":%s, \"mayWriteToFramebuffer\":%s, \"abortRequested\":%s }}\n", \
+                    E2iSendMsg("\"BackWard\":%d, \"SlowMotion\":%d, \"Speed\":%d, \"AVSync\":%d,", ptrP->BackWard, ptrP->SlowMotion, ptrP->Speed, ptrP->AVSync);
+                    E2iSendMsg(" \"isVideo\":%s, \"isAudio\":%s, \"isSubtitle\":%s, \"isDvbSubtitle\":%s, \"isTeletext\":%s, \"mayWriteToFramebuffer\":%s, \"abortRequested\":%s }}\n", \
                     DUMP_BOOL(ptrP->isVideo), DUMP_BOOL(ptrP->isAudio), DUMP_BOOL(0), DUMP_BOOL(0), DUMP_BOOL(0), DUMP_BOOL(0), DUMP_BOOL(ptrP->abortRequested) );
                 }
@@ -875 +1002 @@
                     {
                         ptrP->isLoopMode = '1' == argvBuff[1] ? 1 : 0;
-                        fprintf(stderr, "{\"N\":{ \"isLoop\":%s }}\n", DUMP_BOOL(ptrP->isLoopMode));
+                        E2iSendMsg("{\"N\":{ \"isLoop\":%s }}\n", DUMP_BOOL(ptrP->isLoopMode));
                     }
                 }
@@ -905 +1032 @@
     close(g_pfd[0]);
     close(g_pfd[1]);
-
-    //printOutputCapabilities();
-
+    
     exit(0);
 }

titan/libeplayer3/manager/audio.c

@@ -28 +28 @@
 #include "manager.h"
 #include "common.h"
+#include "debug.h"
 
 /* ***************************** */
@@ -33 +34 @@
 /* ***************************** */
 #define TRACKWRAP 20
-
-//#define SAM_WITH_DEBUG
-#ifdef SAM_WITH_DEBUG
-#define AUDIO_MGR_DEBUG
-#else
-#define AUDIO_MGR_SILENT
-#endif
-
-#ifdef AUDIO_MGR_DEBUG
-
-static short debug_level = 40;
-
-#define audio_mgr_printf(level, fmt, x...) do { \
-if (debug_level >= level) printf("[%s:%s] \n" fmt, __FILE__, __FUNCTION__, ## x); } while (0)
-#else
-#define audio_mgr_printf(level, x...)
-#endif
-
-#ifndef AUDIO_MGR_SILENT
-#define audio_mgr_err(x...) do { printf(x); } while (0)
-#else
-#define audio_mgr_err(x...)
-#endif
 
 /* Error Constants */
@@ -220 +198 @@
         break;
     }
+    case MANAGER_REF_LIST:
+    {
+        *((Track_t **)argument) = Tracks;
+        break;
+    }
+    case MANAGER_REF_LIST_SIZE:
+    {
+        *((int*)argument) = TrackCount;
+        break;
+    }
+    
     case MANAGER_GET: 
     {

titan/libeplayer3/manager/subtitle.c

@@ -24 +24 @@
 #include <stdlib.h>
 #include <string.h>
+#include <assert.h>
 
 #include "manager.h"
 #include "common.h"
+#include "debug.h"
 
 /* ***************************** */
 /* Makros/Constants              */
 /* ***************************** */
-#define TRACKWRAP 20
-
-//#define SAM_WITH_DEBUG
-#ifdef SAM_WITH_DEBUG
-#define SUBTITLE_MGR_DEBUG
-#else
-#define SUBTITLE_MGR_SILENT
-#endif
-
-
-#ifdef SUBTITLE_MGR_DEBUG
-
-static short debug_level = 10;
-
-#define subtitle_mgr_printf(level, x...) do { \
-if (debug_level >= level) printf(x); } while (0)
-#else
-#define subtitle_mgr_printf(level, x...)
-#endif
-
-#ifndef SUBTITLE_MGR_SILENT
-#define subtitle_mgr_err(x...) do { printf(x); } while (0)
-#else
-#define subtitle_mgr_err(x...)
-#endif
+#define TRACKWRAP 10
 
 /* Error Constants */
@@ -72 +50 @@
 
 static Track_t * Tracks = NULL;
+static int TrackSlotCount = 0;
 static int TrackCount = 0;
 static int CurrentTrack = -1; //no as default.
@@ -88 +67 @@
     subtitle_mgr_printf(10, "%s::%s %s %s %d\n", FILENAME, __FUNCTION__, track.Name, track.Encoding, track.Id);
 
-    if (Tracks == NULL) 
-    {
-        Tracks = malloc(sizeof(Track_t) * TRACKWRAP);
-        for (i = 0; i < TRACKWRAP; ++i)
-        {
-            Tracks[i].Id = -1;
+    if (TrackCount == TrackSlotCount)
+    {
+        static Track_t *t;
+        t = realloc(Tracks, (TrackSlotCount + TRACKWRAP) * sizeof(Track_t));
+        if (t)
+        {
+            Tracks = t;
+            TrackSlotCount += TRACKWRAP;
+            for (i = TrackCount; i < TrackSlotCount; ++i)
+            {
+                Tracks[i].Id = -1;
+            }
+        }
+        else
+        {
+            subtitle_mgr_err("%s:%s realloc failed\n", FILENAME, __FUNCTION__);
+            return cERR_SUBTITLE_MGR_ERROR;
         }
     }
@@ -104 +94 @@
 
     
-    for (i = 0; i < TRACKWRAP; ++i) 
+    for (i = 0; i < TrackSlotCount; ++i) 
     {
         if (Tracks[i].Id == track.Id)
@@ -113 +103 @@
     }
 
-    if (TrackCount < TRACKWRAP) 
+    if (TrackCount < TrackSlotCount) 
     {
         copyTrack(&Tracks[TrackCount], &track);
@@ -120 +110 @@
     else
     {
-        subtitle_mgr_err("%s:%s TrackCount out if range %d - %d\n", FILENAME, __FUNCTION__, TrackCount, TRACKWRAP);
+        subtitle_mgr_err("%s:%s TrackCount out if range %d - %d\n", FILENAME, __FUNCTION__, TrackCount, TrackSlotCount);
         return cERR_SUBTITLE_MGR_ERROR;
     }
@@ -189 +179 @@
         }
         TrackCount = 0;
+        TrackSlotCount = 0;
         context->playback->isSubtitle = 0;
     }

titan/libeplayer3/manager/video.c

@@ -27 +27 @@
 #include "manager.h"
 #include "common.h"
+#include "debug.h"
 
 /* ***************************** */
@@ -32 +33 @@
 /* ***************************** */
 #define TRACKWRAP 4
-
-#ifdef SAM_WITH_DEBUG
-#define VIDEO_MGR_DEBUG
-#else
-#define VIDEO_MGR_SILENT
-#endif
-
-#ifdef VIDEO_MGR_DEBUG
-
-static short debug_level = 0;
-
-#define video_mgr_printf(level, x...) do { \
-if (debug_level >= level) printf(x); } while (0)
-#else
-#define video_mgr_printf(level, x...)
-#endif
-
-#ifndef VIDEO_MGR_SILENT
-#define video_mgr_err(x...) do { printf(x); } while (0)
-#else
-#define video_mgr_err(x...)
-#endif
-
 /* Error Constants */
 #define cERR_VIDEO_MGR_NO_ERROR        0
 #define cERR_VIDEO_MGR_ERROR          -1
 
-static const char FILENAME[] = __FILE__;
-
 /* ***************************** */
 /* Types                         */
@@ -68 +44 @@
 /* Varaibles                     */
 /* ***************************** */
-
-static Track_t * Tracks = NULL;
+static Track_t *Tracks = NULL;
 static int TrackCount = 0;
 static int CurrentTrack = 0; //TRACK[0] as default.
 
 static void (* updatedTrackInfoFnc)(void) = NULL;
+
 /* ***************************** */
 /* Prototypes                    */
@@ -83 +59 @@
 
 static int ManagerAdd(Context_t  *context, Track_t track) {
-    video_mgr_printf(10, "%s::%s\n", FILENAME, __FUNCTION__);
+    video_mgr_printf(10, "\n");
 
     if (Tracks == NULL) 
@@ -97 +73 @@
     if (Tracks == NULL)
     {
-        video_mgr_err("%s:%s malloc failed\n", FILENAME, __FUNCTION__);
+        video_mgr_err("malloc failed\n");
         return cERR_VIDEO_MGR_ERROR;
     }
@@ -118 +94 @@
     else 
     {
-        video_mgr_err("%s:%s TrackCount out if range %d - %d\n", FILENAME, __FUNCTION__, TrackCount, TRACKWRAP);
+        video_mgr_err("TrackCount out if range %d - %d\n", TrackCount, TRACKWRAP);
         return cERR_VIDEO_MGR_ERROR;
     }
@@ -127 +103 @@
     }
 
-    video_mgr_printf(10, "%s::%s\n", FILENAME, __FUNCTION__);
+    video_mgr_printf(10, "\n");
     return cERR_VIDEO_MGR_NO_ERROR;
 }
@@ -136 +112 @@
     char ** tracklist = NULL;
 
-    video_mgr_printf(10, "%s::%s\n", FILENAME, __FUNCTION__);
+    video_mgr_printf(10, "\n");
 
     if (Tracks != NULL) 
@@ -145 +121 @@
         if (tracklist == NULL)
         {
-            video_mgr_err("%s:%s malloc failed\n", FILENAME, __FUNCTION__);
+            video_mgr_err("malloc failed\n");
             return NULL;
         }
@@ -164 +140 @@
     }
 
-    video_mgr_printf(10, "%s::%s return %p (%d - %d)\n", FILENAME, __FUNCTION__, tracklist, j, TrackCount);
+    video_mgr_printf(10, "return %p (%d - %d)\n", tracklist, j, TrackCount);
     return tracklist;
 }
@@ -172 +148 @@
     int i = 0;
 
-    video_mgr_printf(10, "%s::%s\n", FILENAME, __FUNCTION__);
+    video_mgr_printf(10, "\n");
 
     if(Tracks != NULL) 
@@ -185 +161 @@
     else
     {
-        video_mgr_err("%s::%s nothing to delete!\n", FILENAME, __FUNCTION__);
+        video_mgr_err("nothing to delete!\n");
         return cERR_VIDEO_MGR_ERROR;
     }
@@ -193 +169 @@
     context->playback->isVideo = 0;
 
-    video_mgr_printf(10, "%s::%s return no error\n", FILENAME, __FUNCTION__);
+    video_mgr_printf(10, "return no error\n");
     return cERR_VIDEO_MGR_NO_ERROR;
 }
@@ -201 +177 @@
     int ret = cERR_VIDEO_MGR_NO_ERROR;
 
-    video_mgr_printf(10, "%s::%s\n", FILENAME, __FUNCTION__);
+    video_mgr_printf(10, "\n");
 
     switch(command) 
@@ -257 +233 @@
     case MANAGER_GET_TRACK: 
     {
-        video_mgr_printf(20, "%s::%s MANAGER_GET_TRACK\n", FILENAME, __FUNCTION__);
+        video_mgr_printf(20, "MANAGER_GET_TRACK\n");
 
         if ((TrackCount > 0) && (CurrentTrack >=0))
@@ -307 +283 @@
         if (i == TrackCount)
         {
-            video_mgr_err("%s::%s track id %d unknown\n", FILENAME, __FUNCTION__, *((int*)argument));
+            video_mgr_err("track id %d unknown\n", *((int*)argument));
             ret = cERR_VIDEO_MGR_ERROR;
         }
@@ -338 +314 @@
     }
     default:
-        video_mgr_err("%s::%s ContainerCmd %d not supported!\n", FILENAME, __FUNCTION__, command);
+        video_mgr_err("ContainerCmd %d not supported!\n", command);
         ret = cERR_VIDEO_MGR_ERROR;
         break;
     }
 
-    video_mgr_printf(10, "%s:%s: returning %d\n", FILENAME, __FUNCTION__,ret);
+    video_mgr_printf(10, "returning %d\n", ret);
     return ret;
 }

titan/libeplayer3/output/linuxdvb_mipsel.c

@@ -23 +23 @@
 
 #include <stdio.h>
+#include <inttypes.h>
 #include <string.h>
 #include <stdlib.h>
 #include <unistd.h>
+#include <stdbool.h>
 #include <fcntl.h>
 #include <sys/types.h>
@@ -41 +43 @@
 
 #include "common.h"
+#include "debug.h"
 #include "output.h"
 #include "writer.h"
@@ -50 +53 @@
 /* ***************************** */
 
-//#define LINUXDVB_DEBUG
-#define LINUXDVB_SILENT
-
-static unsigned short debug_level = 0;
-
-static const char FILENAME[] = __FILE__;
-
-#ifdef LINUXDVB_DEBUG
-#define linuxdvb_printf(level, fmt, x...) do { \
-if (debug_level >= level) printf("[%s:%s] " fmt, __FILE__, __FUNCTION__, ## x ); } while (0)
-#else
-#define linuxdvb_printf(x...)
-#endif
-
-#ifndef LINUXDVB_SILENT
-#define linuxdvb_err(fmt, x...) do { printf("[%s:%s] " fmt, __FILE__, __FUNCTION__, ## x); } while (0)
-#else
-#define linuxdvb_err(x...)
-#endif
-
 #define cERR_LINUXDVB_NO_ERROR      0
 #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 +72 @@
 
 unsigned long long int sCURRENT_PTS = 0;
+bool isBufferedOutput = false;
 
 pthread_mutex_t LinuxDVBmutex;
@@ -95 +79 @@
 /* Prototypes                    */
 /* ***************************** */
+int32_t LinuxDvbBuffOpen(Context_t *context, char *type, int outfd, void *mtx);
+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, int ic);
+int32_t LinuxDvbBuffSetSize(const uint32_t bufferSize);
+uint32_t LinuxDvbBuffGetSize();
+
 int LinuxDvbStop(Context_t  *context, char * type);
 
@@ -101 +94 @@
 /* ***************************** */
 
-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() )
-    {
-        return 0x0f;
-    }
+#define getLinuxDVBMutex() pthread_mutex_lock(&LinuxDVBmutex)
+#define releaseLinuxDVBMutex() pthread_mutex_unlock(&LinuxDVBmutex)
+
+static int LinuxDvbMapBypassMode(int bypass, bool primary)
+{
+    if (STB_DREAMBOX == GetSTBType()) {
+        primary = !primary;
+    }
+
+    switch(bypass) {
+        case AUDIOTYPE_RAW:
+            bypass = primary ? 0x30 : 0xf;
+            break;
+        case AUDIOTYPE_AC3_PLUS:
+            bypass = primary ? 0x22 : 7;
+            break;
+        case AUDIOTYPE_WMA:
+            bypass = primary ? 0x20 : 0xd;
+            break;
+        case AUDIOTYPE_WMA_PRO:
+            bypass = primary ? 0x21 : 0xe;
+            break;
+        default:
+            break;
+    };
+
     return bypass;
 }
 
-int LinuxDvbOpen(Context_t  *context __attribute__((unused)), char * type) {
-    unsigned char video = !strcmp("video", type);
-    unsigned char audio = !strcmp("audio", type);
+static int LinuxDvbMapStreamType(int streamtype, bool primary)
+{
+    if (STB_DREAMBOX == GetSTBType()) {
+        primary = !primary;
+    }
+
+    switch(streamtype) {
+        case STREAMTYPE_MPEG4_H265:
+            streamtype = primary ? 7 : 22;
+            break;
+        case STREAMTYPE_VC1:
+            streamtype = primary ? 3 : 16;
+            break;
+        case STREAMTYPE_VC1_SM:
+            streamtype = primary ? 5 : 17;
+            break;
+        case STREAMTYPE_VB8:
+            streamtype = primary ? 8 : 20;
+            break;
+        case STREAMTYPE_VB9:
+            streamtype = primary ? 9 : 23;
+            break;
+        default:
+            break;
+    };
+
+    return streamtype;
+}
+
+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 +165 @@
         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));
             return cERR_LINUXDVB_ERROR;
         }
@@ -145 +171 @@
         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, &LinuxDVBmutex);
     }
     if (audio && audiofd < 0) 
@@ -168 +193 @@
         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 +199 @@
         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, &LinuxDVBmutex);
     }
 
@@ -197 +219 @@
 }
 
-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);
@@ -210 +232 @@
     LinuxDvbStop(context, type);
 
-    getLinuxDVBMutex(FILENAME, __FUNCTION__,__LINE__);
+    getLinuxDVBMutex();
+    
+    if (isBufferedOutput)
+        LinuxDvbBuffClose(context);
 
     if (video && videofd != -1)
@@ -223 +248 @@
     }
 
-    releaseLinuxDVBMutex(FILENAME, __FUNCTION__,__LINE__);
+    releaseLinuxDVBMutex();
     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 +268 @@
 
         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)
         {
@@ -262 +276 @@
         {
             linuxdvb_printf(20, "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));
+            ret = ioctl( videofd, VIDEO_SET_STREAMTYPE, LinuxDvbMapStreamType(writer->caps->dvbStreamType, true));
+            if (ret < 0) ret = ioctl( videofd, VIDEO_SET_STREAMTYPE, LinuxDvbMapStreamType(writer->caps->dvbStreamType, false));
+            if (ret < 0)
+            {
+                linuxdvb_err("VIDEO_SET_STREAMTYPE: ERROR %d, %s\n", errno, strerror(errno));
                 ret = cERR_LINUXDVB_ERROR;
             }
@@ -273 +288 @@
         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 +294 @@
         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 +310 @@
         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)
         {
@@ -316 +318 @@
         {
             linuxdvb_printf(20, "found writer %s for encoding %s\n", writer->caps->name, Encoding);
-            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));
+            ret = ioctl( audiofd, AUDIO_SET_BYPASS_MODE, LinuxDvbMapBypassMode(writer->caps->dvbStreamType, true));
+            if (ret < 0) ret = ioctl( audiofd, AUDIO_SET_BYPASS_MODE, LinuxDvbMapBypassMode(writer->caps->dvbStreamType, false));
+            if (ret < 0)
+            {
+                linuxdvb_err("AUDIO_SET_BYPASS_MODE: ERROR %d, %s\n", errno, strerror(errno));
                 ret = cERR_LINUXDVB_ERROR;
             }
@@ -326 +329 @@
         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 +335 @@
         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;
         }
@@ -352 +353 @@
     linuxdvb_printf(10, "v%d a%d\n", video, audio);
 
-    getLinuxDVBMutex(FILENAME, __FUNCTION__,__LINE__);
+    getLinuxDVBMutex();
 
     if (video && videofd != -1) 
@@ -358 +359 @@
         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 +370 @@
         ioctl(videofd, VIDEO_SLOWMOTION, 0);
         ioctl(videofd, VIDEO_FAST_FORWARD, 0);
-
         ioctl(videofd, VIDEO_SELECT_SOURCE, VIDEO_SOURCE_DEMUX);
     }
@@ -377 +375 @@
         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;
         }
@@ -396 +386 @@
     }
 
-    releaseLinuxDVBMutex(FILENAME, __FUNCTION__,__LINE__);
-
-    return ret;
-}
-
-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);
+    releaseLinuxDVBMutex();
+
+    return ret;
+}
+
+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);
 
-    getLinuxDVBMutex(FILENAME, __FUNCTION__,__LINE__);
-
-    if (video && videofd != -1) {
+    getLinuxDVBMutex();
+
+    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));
-            ret = cERR_LINUXDVB_ERROR;
-        }
-    }
-
-    releaseLinuxDVBMutex(FILENAME, __FUNCTION__,__LINE__);
+            linuxdvb_err("AUDIO_PAUSE: ERROR %d, %s\n", errno, strerror(errno));
+            ret = cERR_LINUXDVB_ERROR;
+        }
+    }
+
+    releaseLinuxDVBMutex();
 
     return ret;
@@ -433 +424 @@
 
 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 +464 @@
         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 +472 @@
         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 +485 @@
 }
 
-
 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;
 }
 
+//obi
 #ifndef use_set_speed_instead_ff
 int LinuxDvbFastForward(Context_t  *context, char * type) {
@@ -562 +502 @@
     if (video && videofd != -1) {
 
-        getLinuxDVBMutex(FILENAME, __FUNCTION__,__LINE__);
+//        getLinuxDVBMutex(FILENAME, __FUNCTION__,__LINE__);
+        getLinuxDVBMutex();
 
         /* konfetti comment: speed is a value given in skipped frames */
@@ -573 +514 @@
         }
 
-        releaseLinuxDVBMutex(FILENAME, __FUNCTION__,__LINE__);
+//        releaseLinuxDVBMutex(FILENAME, __FUNCTION__,__LINE__);
+                releaseLinuxDVBMutex();
     }
 
@@ -600 +542 @@
     if (video && videofd != -1) {
 
-        getLinuxDVBMutex(FILENAME, __FUNCTION__,__LINE__);
+//        getLinuxDVBMutex(FILENAME, __FUNCTION__,__LINE__);
+                getLinuxDVBMutex();
 
         speedIndex = context->playback->Speed % (sizeof (SpeedList) / sizeof (int));
@@ -613 +556 @@
         // }
 
-        releaseLinuxDVBMutex(FILENAME, __FUNCTION__,__LINE__);
+//        releaseLinuxDVBMutex(FILENAME, __FUNCTION__,__LINE__);
+                releaseLinuxDVBMutex();
     }
 
     if (audio && audiofd != -1) {
 
-        getLinuxDVBMutex(FILENAME, __FUNCTION__,__LINE__);
+//        getLinuxDVBMutex(FILENAME, __FUNCTION__,__LINE__);
+                getLinuxDVBMutex();
 
         speedIndex = context->playback->Speed % (sizeof (SpeedList) / sizeof (int));
@@ -631 +576 @@
         // }
 
-        releaseLinuxDVBMutex(FILENAME, __FUNCTION__,__LINE__);
+//        releaseLinuxDVBMutex(FILENAME, __FUNCTION__,__LINE__);
+        releaseLinuxDVBMutex();
     }
 
@@ -645 +591 @@
     return ret;
 }
+//obi
 
 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);
 
     if ( (video && videofd != -1) || (audio && audiofd != -1) ) {
-        getLinuxDVBMutex(FILENAME, __FUNCTION__,__LINE__);
+        getLinuxDVBMutex();
 
         if (video && videofd != -1) {
             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;
             }
         }
 
-        releaseLinuxDVBMutex(FILENAME, __FUNCTION__,__LINE__);
+        releaseLinuxDVBMutex();
     }
 
@@ -674 +620 @@
 }
 
-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
@@ -683 +629 @@
      */
     if (audiofd != -1) {
-        getLinuxDVBMutex(FILENAME, __FUNCTION__,__LINE__);
+        getLinuxDVBMutex();
 
         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));
-            ret = cERR_LINUXDVB_ERROR;
-        }
-
-        releaseLinuxDVBMutex(FILENAME, __FUNCTION__,__LINE__);
-    }
-
-    return ret;
-}
-
-int LinuxDvbClear(Context_t  *context __attribute__((unused)), char * type) 
+            linuxdvb_err("AUDIO_SET_AV_SYNC: ERROR %d, %s\n", errno, strerror(errno));
+            ret = cERR_LINUXDVB_ERROR;
+        }
+
+        releaseLinuxDVBMutex();
+    }
+
+    return ret;
+}
+
+int LinuxDvbClear(Context_t  *context __attribute__((unused)), char *type) 
 {
     int32_t ret = cERR_LINUXDVB_NO_ERROR;
@@ -704 +649 @@
     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) ) 
     {
-        getLinuxDVBMutex(FILENAME, __FUNCTION__,__LINE__);
+        getLinuxDVBMutex();
 
         if (video && videofd != -1) 
@@ -714 +659 @@
             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 +667 @@
             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;
             }
         }
 
-        releaseLinuxDVBMutex(FILENAME, __FUNCTION__,__LINE__);
+        releaseLinuxDVBMutex();
     }
 
@@ -738 +681 @@
 
 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 +692 @@
     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 +703 @@
         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 +713 @@
 
     *((unsigned long long int *)pts)=(unsigned long long int)sCURRENT_PTS;
-
-    //releaseLinuxDVBMutex(FILENAME, __FUNCTION__,__LINE__);
-
     return ret;
 }
@@ -780 +718 @@
 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;
+    int ret = 0;
 
     linuxdvb_printf(10, "v%d a%d\n", video, audio);
 
     if ( (video && videofd != -1) || (audio && audiofd != -1) ) {
-        getLinuxDVBMutex(FILENAME, __FUNCTION__,__LINE__);
+        getLinuxDVBMutex();
 
         if (audio && audiofd != -1) {
@@ -806 +744 @@
                 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 +755 @@
                 {
                     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)
+                    ret = ioctl( audiofd, AUDIO_SET_BYPASS_MODE, LinuxDvbMapBypassMode(writer->caps->dvbStreamType, true));
+                    if (ret < 0) ret = ioctl( audiofd, AUDIO_SET_BYPASS_MODE, LinuxDvbMapBypassMode(writer->caps->dvbStreamType, false));
+                    if (ret < 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));
                     }
                 }
@@ -838 +769 @@
                 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 +784 @@
                 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 +799 @@
                 {
                     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)
+                    ret = ioctl( videofd, VIDEO_SET_STREAMTYPE, LinuxDvbMapStreamType(writer->caps->dvbStreamType, true));
+                    if (ret < 0) ret = ioctl( videofd, VIDEO_SET_STREAMTYPE, LinuxDvbMapStreamType(writer->caps->dvbStreamType, false));
+                    if (ret < 0)
                     {
-                        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 +816 @@
                      * 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);
@@ -900 +824 @@
         }
 
-        releaseLinuxDVBMutex(FILENAME, __FUNCTION__,__LINE__);
+        releaseLinuxDVBMutex();
 
     }
@@ -909 +833 @@
 }
 
-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;
 
@@ -929 +853 @@
     audio = !strcmp("audio", out->type);
   
-    linuxdvb_printf(20, "DataLength=%u PrivateLength=%u Pts=%llu FrameRate=%f\n", 
+    linuxdvb_printf(20, "DataLength=%u PrivateLength=%u Pts=%"PRIu64" FrameRate=%d\n", 
                                                     out->len, out->extralen, out->pts, out->frameRate);
     linuxdvb_printf(20, "v%d a%d\n", video, audio);
@@ -935 +859 @@
     if (video) 
     {
-        char * Encoding = NULL;
+        char *Encoding = NULL;
         context->manager->video->Command(context, MANAGER_GETENCODING, &Encoding);
 
@@ -969 +893 @@
                 else
                 {
+                    bool changed = false;
                     if (evt.type == VIDEO_EVENT_SIZE_CHANGED)
                     {
-                        linuxdvb_printf(10, "VIDEO_EVENT_SIZE_CHANGED\n", evt.type);
+                        linuxdvb_printf(10, "VIDEO_EVENT_SIZE_CHANGED type: 0x%x\n", evt.type);
                         linuxdvb_printf(10, "width  : %d\n", evt.u.size.w);
                         linuxdvb_printf(10, "height : %d\n", evt.u.size.h);
@@ -978 +903 @@
                         videoInfo.height = evt.u.size.h;
                         videoInfo.aspect_ratio = evt.u.size.aspect_ratio;
+                        changed = true;
                     }
                     else if (evt.type == VIDEO_EVENT_FRAME_RATE_CHANGED)
                     {
-                        linuxdvb_printf(10, "VIDEO_EVENT_FRAME_RATE_CHANGED\n", evt.type);
+                        linuxdvb_printf(10, "VIDEO_EVENT_FRAME_RATE_CHANGED type: 0x%x\n", evt.type);
                         linuxdvb_printf(10, "framerate : %d\n", evt.u.frame_rate);
                         videoInfo.frame_rate = evt.u.frame_rate;
+                        changed = true;
                     }
                     else if (evt.type == 16 /*VIDEO_EVENT_PROGRESSIVE_CHANGED*/)
                     {
-                        linuxdvb_printf(10, "VIDEO_EVENT_PROGRESSIVE_CHANGED\n", evt.type);
+                        linuxdvb_printf(10, "VIDEO_EVENT_PROGRESSIVE_CHANGED type: 0x%x\n", evt.type);
                         linuxdvb_printf(10, "progressive : %d\n", evt.u.frame_rate);
                         videoInfo.progressive = evt.u.frame_rate;
                         context->manager->video->Command(context, MANAGER_UPDATED_TRACK_INFO, NULL);
+                        changed = true;
                     }
                     else
                     {
                         linuxdvb_err("unhandled DVBAPI Video Event %d\n", evt.type);
+                    }
+                    
+                    if (changed && 
+                        videoInfo.width != -1 &&
+                        videoInfo.height != -1 &&
+                        videoInfo.aspect_ratio != -1 &&
+                        videoInfo.frame_rate != -1 &&
+                        videoInfo.progressive != -1)
+                    {
+                        E2iSendMsg("{\"v_e\":{\"w\":%d,\"h\":%d,\"a\":%d,\"f\":%d,\"p\":%d}}\n", 
+                            videoInfo.width, videoInfo.height, videoInfo.aspect_ratio, videoInfo.frame_rate, videoInfo.progressive);
                     }
                 }
@@ -1011 +950 @@
             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 +970 @@
     else if (audio)
     {
-        char * Encoding = NULL;
+        char *Encoding = NULL;
         context->manager->audio->Command(context, MANAGER_GETENCODING, &Encoding);
 
-        linuxdvb_printf(20, "%s::%s Encoding = %s\n", FILENAME, __FUNCTION__, Encoding);
+        linuxdvb_printf(20, "Encoding = %s\n", Encoding);
 
         writer = getWriter(Encoding);
@@ -1060 +1000 @@
             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 +1058 @@
     free(Encoding);
 
+    if (isBufferedOutput)
+        LinuxDvbBuffFlush(context);
+    
     return ret;
 }
@@ -1162 +1106 @@
         break;
     }
+//obi
     case OUTPUT_FASTFORWARD: {
         return LinuxDvbFastForward(context, (char*)argument);
@@ -1170 +1115 @@
         break;
     }
+//obi
     case OUTPUT_AVSYNC: {
         ret = LinuxDvbAVSync(context, (char*)argument);
@@ -1175 +1121 @@
     }
     case OUTPUT_CLEAR: {
+        reset(context);
         ret = LinuxDvbClear(context, (char*)argument);
         reset(context);
@@ -1198 +1145 @@
         break;
     }
-    case OUTPUT_DISCONTINUITY_REVERSE: {
-        return LinuxDvbReverseDiscontinuity(context, (int*)argument);
-        break;
-    }
     case OUTPUT_GET_FRAME_COUNT: {
         unsigned long long int frameCount = 0;
@@ -1211 +1154 @@
         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)
+            {
+                LinuxDvbBuffSetSize(bufferSize);
+                isBufferedOutput = true;
+            }
+        }
+        break;
+    }
+    case OUTPUT_GET_BUFFER_SIZE: {
+        ret = cERR_LINUXDVB_NO_ERROR;
+        *((uint32_t*)argument) = LinuxDvbBuffGetSize();
         break;
     }

titan/libeplayer3/output/linuxdvb_sh4.c

@@ -32 +32 @@
 #include <linux/dvb/video.h>
 #include <linux/dvb/audio.h>
-#include <linux/dvb/stm_ioctls.h>
 #include <memory.h>
 #include <asm/types.h>
@@ -38 +37 @@
 #include <errno.h>
 #include <poll.h>
+#include <sys/uio.h>
 
 #include "bcm_ioctls.h"
+#include "stm_ioctls.h"
 
 #include "common.h"
+#include "debug.h"
 #include "output.h"
 #include "writer.h"
@@ -50 +52 @@
 /* Makros/Constants              */
 /* ***************************** */
-
-//#define LINUXDVB_DEBUG
-#define LINUXDVB_SILENT
-
-static unsigned short debug_level = 0;
-
-static const char FILENAME[] = __FILE__;
-
-#ifdef LINUXDVB_DEBUG
-#define linuxdvb_printf(level, fmt, x...) do { \
-if (debug_level >= level) printf("[%s:%s] " fmt, __FILE__, __FUNCTION__, ## x ); } while (0)
-#else
-#define linuxdvb_printf(x...)
-#endif
-
-#ifndef LINUXDVB_SILENT
-#define linuxdvb_err(fmt, x...) do { printf("[%s:%s] " fmt, __FILE__, __FUNCTION__, ## x); } while (0)
-#else
-#define linuxdvb_err(x...)
-#endif
-
-
 #define cERR_LINUXDVB_NO_ERROR      0
 #define cERR_LINUXDVB_ERROR        -1
@@ -90 +70 @@
 
 unsigned long long int sCURRENT_PTS = 0;
+bool isBufferedOutput = false;
 
 pthread_mutex_t LinuxDVBmutex;
@@ -96 +77 @@
 /* Prototypes                    */
 /* ***************************** */
+int32_t LinuxDvbBuffOpen(Context_t *context, char *type, int outfd, void *mtx);
+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, int ic);
+int32_t LinuxDvbBuffSetSize(const uint32_t bufferSize);
+uint32_t LinuxDvbBuffGetSize();
+
 int LinuxDvbStop(Context_t  *context, char * type);
 
@@ -102 +92 @@
 /* ***************************** */
 
-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");
-
-}
+#define getLinuxDVBMutex() pthread_mutex_lock(&LinuxDVBmutex)
+#define releaseLinuxDVBMutex() pthread_mutex_unlock(&LinuxDVBmutex)
 
 int LinuxDvbOpen(Context_t  *context __attribute__((unused)), char * type) {
@@ -124 +101 @@
     linuxdvb_printf(10, "v%d a%d\n", video, audio);
 
-    if (video && videofd < 0) {
+    if (video && videofd < 0)
+    {
+    
         videofd = open(VIDEODEV, O_RDWR);
-
         if (videofd < 0)
         {
@@ -158 +136 @@
         }
 
-    }
-    if (audio && audiofd < 0) {
+        if (isBufferedOutput)
+            LinuxDvbBuffOpen(context, type, videofd, &LinuxDVBmutex);
+    }
+    if (audio && audiofd < 0)
+    {
         audiofd = open(AUDIODEV, O_RDWR);
-
         if (audiofd < 0)
         {
@@ -189 +169 @@
             linuxdvb_err("AUDIO_SET_STREAMTYPE: %s\n", strerror(errno));
         }
+        
+        if (isBufferedOutput)
+            LinuxDvbBuffOpen(context, type, audiofd, &LinuxDVBmutex);
     }
 
@@ -194 +177 @@
 }
 
-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);
@@ -206 +190 @@
     LinuxDvbStop(context, type);
 
-    getLinuxDVBMutex(FILENAME, __FUNCTION__,__LINE__);
+    getLinuxDVBMutex();
+
+    if (isBufferedOutput)
+        LinuxDvbBuffClose(context);
 
     if (video && videofd != -1)
@@ -219 +206 @@
     }
 
-    releaseLinuxDVBMutex(FILENAME, __FUNCTION__,__LINE__);
+    releaseLinuxDVBMutex();
     return cERR_LINUXDVB_NO_ERROR;
 }
@@ -243 +230 @@
         {
             linuxdvb_err("cannot found writer for encoding %s using default\n", Encoding);
-            if (ioctl( videofd, VIDEO_SET_ENCODING, (void*) VIDEO_ENCODING_AUTO) == -1)
+            if (ioctl( videofd, VIDEO_SET_ENCODING, VIDEO_ENCODING_AUTO) == -1)
             {
                 linuxdvb_err("ioctl failed with errno %d\n", errno);
@@ -252 +239 @@
         {
             linuxdvb_printf(20, "found writer %s for encoding %s\n", writer->caps->name, Encoding);
-            if (ioctl( videofd, VIDEO_SET_ENCODING, (void*) writer->caps->dvbEncoding) == -1)
+            if (ioctl( videofd, VIDEO_SET_ENCODING, writer->caps->dvbEncoding) == -1)
             {
                 linuxdvb_err("ioctl failed with errno %d\n", errno);
@@ -288 +275 @@
         {
             linuxdvb_printf(20, "found writer %s for encoding %s\n", writer->caps->name, Encoding);
-            if (ioctl( audiofd, AUDIO_SET_ENCODING, (void*) writer->caps->dvbEncoding) == -1)
+            if (ioctl( audiofd, AUDIO_SET_ENCODING, writer->caps->dvbEncoding) == -1)
             {
                 linuxdvb_err("ioctl failed with errno %d\n", errno);
@@ -315 +302 @@
     linuxdvb_printf(10, "v%d a%d\n", video, audio);
 
-    getLinuxDVBMutex(FILENAME, __FUNCTION__,__LINE__);
+    getLinuxDVBMutex();
 
     if (video && videofd != -1) {
@@ -358 +345 @@
     }
 
-    releaseLinuxDVBMutex(FILENAME, __FUNCTION__,__LINE__);
+    releaseLinuxDVBMutex();
 
     return ret;
@@ -370 +357 @@
     linuxdvb_printf(10, "v%d a%d\n", video, audio);
 
-    getLinuxDVBMutex(FILENAME, __FUNCTION__,__LINE__);
+    getLinuxDVBMutex();
 
     if (video && videofd != -1) {
@@ -389 +376 @@
     }
 
-    releaseLinuxDVBMutex(FILENAME, __FUNCTION__,__LINE__);
+    releaseLinuxDVBMutex();
 
     return ret;
@@ -417 +404 @@
         }
     }
+    
+    if (isBufferedOutput)
+        LinuxDvbBuffResume(context);
 
     linuxdvb_printf(10, "exiting\n");
@@ -430 +420 @@
     linuxdvb_printf(50, "\n");
 
-    if (ioctl( videofd, VIDEO_DISCONTINUITY, (void*) dis_type) == -1)
+    if (ioctl( videofd, VIDEO_DISCONTINUITY, dis_type) == -1)
     {
         linuxdvb_err("ioctl failed with errno %d\n", errno);
@@ -486 +476 @@
 
     if ( (video && videofd != -1) || (audio && audiofd != -1) ) {
-        getLinuxDVBMutex(FILENAME, __FUNCTION__,__LINE__);
+        getLinuxDVBMutex();
 
         if (video && videofd != -1) {
@@ -504 +494 @@
         }
 
-        releaseLinuxDVBMutex(FILENAME, __FUNCTION__,__LINE__);
+        releaseLinuxDVBMutex();
     }
 
@@ -523 +513 @@
     if (video && videofd != -1) {
 
-        getLinuxDVBMutex(FILENAME, __FUNCTION__,__LINE__);
+        getLinuxDVBMutex();
 
         /* konfetti comment: speed is a value given in skipped frames */
@@ -534 +524 @@
         }
 
-        releaseLinuxDVBMutex(FILENAME, __FUNCTION__,__LINE__);
+        releaseLinuxDVBMutex();
     }
 
@@ -561 +551 @@
     if (video && videofd != -1) {
 
-        getLinuxDVBMutex(FILENAME, __FUNCTION__,__LINE__);
+        getLinuxDVBMutex();
 
         speedIndex = context->playback->Speed % (sizeof (SpeedList) / sizeof (int));
@@ -574 +564 @@
         }
 
-        releaseLinuxDVBMutex(FILENAME, __FUNCTION__,__LINE__);
+        releaseLinuxDVBMutex();
     }
 
     if (audio && audiofd != -1) {