Changeset 44970

Timestamp:

12/08/20 20:33:22 (19 months ago)

Author:

obi

Message:

update player

Location:

titan/libeplayer3

Files:

• container/container_ffmpeg.c (modified) (6 diffs)
• include/output.h (modified) (1 diff)
• output/linuxdvb_buffering.c (modified) (3 diffs)
• output/linuxdvb_mipsel.c (modified) (1 diff)
• output/output.c (modified) (2 diffs)
• output/writer/common/writer.c (modified) (3 diffs)
• playback/playback.c (modified) (1 diff)

titan/libeplayer3/container/container_ffmpeg.c

@@ -69 +69 @@
  * std library.
  */
-#define USE_CUSTOM_IO
+//#define USE_CUSTOM_IO
 
 /* Error Constants */
@@ -860 +860 @@
     uint32_t bufferSize = 0;
     context->output->Command(context, OUTPUT_GET_BUFFER_SIZE, &bufferSize);
-    ffmpeg_printf(10, "bufferSize [%u]\n", bufferSize);
+    ffmpeg_printf(10, "2bufferSize [%u]\n", bufferSize);
 
     int8_t isWaitingForFinish = 0;
@@ -1656 +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)
 }
@@ -2071 +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;
@@ -2224 +2224 @@
                         context->playback->isTSLiveMode = 1;
                 }
-                */
 //obi (end)
 
@@ -2302 +2301 @@
                     if(ffmpeg_buf != NULL)
                     {
-                        ffmpeg_printf(10, "buffer size=%d\n", ffmpeg_buf_size);
+                        ffmpeg_printf(10, "1buffer size=%d\n", ffmpeg_buf_size);
                         
                         ffmpeg_read_org = avContextTab[AVIdx]->pb->read_packet;

titan/libeplayer3/include/output.h

@@ -29 +29 @@
     OUTPUT_SET_BUFFER_SIZE,
     OUTPUT_GET_BUFFER_SIZE,
+    //obi
+    OUTPUT_GET_BUFFER_STATUS,
+        //obi
 } OutputCmd_t;
 

titan/libeplayer3/output/linuxdvb_buffering.c

@@ -78 +78 @@
 static uint32_t maxBufferingDataSize = 0;
 static uint32_t bufferingDataSize = 0;
-
+//obi
+static uint32_t chunkSize = 0;
+//obi
 static int videofd = -1;
 static int audiofd = -1;
@@ -229 +231 @@
     return maxBufferingDataSize;
 }
-
+//obi
+uint32_t LinuxDvbBuffGetStatus()
+{
+    return chunkSize;
+}
+//obi
 int32_t LinuxDvbBuffOpen(Context_t *context, char *type, int outfd, void *mtx)
 {
@@ -395 +402 @@
     BufferingNode_t *nodePtr = NULL;
     uint8_t *dataPtr = NULL;
-    uint32_t chunkSize = 0;
+//obi
+//    uint32_t chunkSize = 0;
     uint32_t i = 0;
     

titan/libeplayer3/output/linuxdvb_mipsel.c

@@ -1175 +1175 @@
         break;
     }
+    //obi
+    case OUTPUT_GET_BUFFER_STATUS: {
+        ret = cERR_LINUXDVB_NO_ERROR;
+        *((uint32_t*)argument) = LinuxDvbBuffGetStatus();
+        break;
+    }
+//obi
     default:
         linuxdvb_err("ContainerCmd %d not supported!\n", command);

titan/libeplayer3/output/output.c

@@ -544 +544 @@
         break;
     }
-    case OUTPUT_GET_BUFFER_SIZE:
+    //obi
+    case OUTPUT_GET_BUFFER_STATUS:
     {
         if (context && context->playback)
@@ -550 +551 @@
             if (context->output->video)
             {
-                return context->output->video->Command(context, OUTPUT_GET_BUFFER_SIZE, argument);
+                return context->output->video->Command(context, OUTPUT_GET_BUFFER_STATUS, argument);
             }
             else if (context->output->audio)
             {
-                return context->output->audio->Command(context, OUTPUT_GET_BUFFER_SIZE, argument);
-            }
-        }
-        else
-        {
-            ret = cERR_OUTPUT_INTERNAL_ERROR;
-        }
-        break;
-    }
+                return context->output->audio->Command(context, OUTPUT_GET_BUFFER_STATUS, argument);
+            }
+        }
+        else
+        {
+            ret = cERR_OUTPUT_INTERNAL_ERROR;
+        }
+        break;
+    }
+    //obi
     default:
         output_err("%s::%s OutputCmd %d not supported!\n", FILENAME, __FUNCTION__, command);

titan/libeplayer3/output/writer/common/writer.c

@@ -26 +26 @@
 #include <string.h>
 #include <errno.h>
+#include <pthread.h>
 
 #include "misc.h"
 #include "writer.h"
+#include "common.h"
 #include "debug.h"
-#include "common.h"
 
 /* ***************************** */
 /* Makros/Constants              */
 /* ***************************** */
+#define getDVBMutex(pmtx) do { if (pmtx) pthread_mutex_lock(pmtx);} while(false);
+#define releaseDVBMutex(pmtx) do { if (pmtx) pthread_mutex_unlock(pmtx);} while(false);
 
 /* ***************************** */
 /* Types                         */
 /* ***************************** */
+typedef enum {
+    DVB_STS_UNKNOWN, 
+    DVB_STS_SEEK, 
+    DVB_STS_PAUSE, 
+    DVB_STS_EXIT
+} DVBState_t; 
 
 /* ***************************** */
@@ -44 +53 @@
 /* ***************************** */
 
+static Writer_t * AvailableWriter[] = {
+    &WriterAudioAAC,
+    &WriterAudioAACLATM,
+    &WriterAudioAACPLUS,
+    &WriterAudioAC3,
+    &WriterAudioEAC3,
+    &WriterAudioMP3,
+    &WriterAudioMPEGL3,
+    &WriterAudioPCM,
+    &WriterAudioIPCM,
+    &WriterAudioLPCM,
+    &WriterAudioDTS,
+    &WriterAudioWMA,
+    &WriterAudioWMAPRO,
+    &WriterAudioOPUS,
+    &WriterAudioVORBIS,
+
+    &WriterVideoH264,
+    &WriterVideoH265,
+    &WriterVideoH263,
+    &WriterVideoMPEG4,
+    &WriterVideoMPEG2,
+    &WriterVideoMPEG1,
+    &WriterVideoVC1,
+    &WriterVideoDIVX3,
+    &WriterVideoVP6,
+    &WriterVideoVP8,
+    &WriterVideoVP9,
+    &WriterVideoFLV,
+    &WriterVideoWMV,
+    &WriterVideoMJPEG,
+    &WriterVideoRV40,
+    &WriterVideoRV30,
+    &WriterVideoAVS2,
+    NULL
+};
+
 /* ***************************** */
 /* Prototypes                    */
@@ -51 +97 @@
 /*  Functions                    */
 /* ***************************** */
-void FlushPipe(int pipefd)
-{
-    char tmp;
-    while(1 == read(pipefd, &tmp, 1));
-}
-
-ssize_t WriteExt(WriteV_t _call, int fd, void *data, size_t size)
-{
-    struct iovec iov[1];
-    iov[0].iov_base = data;
-    iov[0].iov_len = size;
-    return _call(fd, iov, 1);
-}
+ssize_t WriteWithRetry(Context_t *context, int pipefd, int fd, void *pDVBMtx, const void *buf, int size)
+{
+    fd_set rfds;
+    fd_set wfds;
+
+    ssize_t ret;
+    int retval = -1;
+    int maxFd = pipefd > fd ? pipefd : fd;
+    struct timeval tv;
+
+//    while(size > 0 && !context->playback->isSeeking)
+    while(size > 0 && 0 == PlaybackDieNow(0) && !context->playback->isSeeking)
+    {
+        FD_ZERO(&rfds);
+        FD_ZERO(&wfds);
+
+        FD_SET(pipefd, &rfds);
+        FD_SET(fd, &wfds);
+
+        /* When we PAUSE LINUX DVB outputs buffers, then audio/video buffers 
+         * will continue to be filled. Unfortunately, in such case after resume 
+         * select() will never return with fd set - bug in DVB drivers?
+         * There are to workarounds possible:
+         *   1. write to pipe at resume to return from select() immediately
+         *   2. make timeout select(), limit max time spend in the select()
+         *      to for example 0,1s 
+         *   (at now first workaround is used)
+         */
+        //tv.tv_sec = 0;
+        //tv.tv_usec = 100000; // 100ms
+        
+        retval = select(maxFd + 1, &rfds, &wfds, NULL, NULL); //&tv);
+        if (retval < 0)
+        {
+            break;
+        }
+        
+        //if (retval == 0)
+        //{
+        //    //printf("RETURN FROM SELECT DUE TO TIMEOUT\n");
+        //    continue;
+        //}
+        
+        if(FD_ISSET(pipefd, &rfds))
+        {
+            FlushPipe(pipefd);
+            //printf("RETURN FROM SELECT DUE TO pipefd SET\n");
+            continue;
+        }
+        
+        if(FD_ISSET(fd, &wfds))
+        {
+            ret = write(fd, buf, size);
+            if (ret < 0)
+            {
+                switch(errno)
+                {
+                    case EINTR:
+                    case EAGAIN:
+                        continue;
+                    default:
+                        retval = -3;
+                        break;
+                }
+                if (retval < 0)
+                {
+                    break;
+                }
+                
+                return ret;
+            }
+            else if (ret == 0)
+            {
+                // printf("This should not happen. Select return fd ready to write, but write return 0, errno [%d]\n", errno);
+                // wait 10ms before next try
+                tv.tv_sec = 0;
+                tv.tv_usec = 10000; // 10ms
+                retval = select(pipefd + 1, &rfds, NULL, NULL, &tv);
+                if (retval)
+                    FlushPipe(pipefd);
+                continue;
+            }
+            
+            size -= ret;
+            buf += ret;
+        }
+    }
+    return 0;
+}
+
+ssize_t write_with_retry(int fd, const void *buf, int size)
+{
+    ssize_t ret;
+    int retval = 0;
+//    while(size > 0 && 0 == PlaybackDieNow(0))
+    while(size > 0)
+    {
+        ret = write(fd, buf, size);
+        if (ret < 0)
+        {
+            switch(errno)
+            {
+                case EINTR:
+                case EAGAIN:
+                    usleep(1000);
+                    continue;
+                default:
+                    retval = -3;
+                    break;
+            }
+            if (retval < 0)
+            {
+                break;
+            }
+        }
+            
+        if (ret < 0)
+        {
+            return ret;
+        }
+        
+        size -= ret;
+        buf += ret;
+        
+        if(size > 0)
+        {
+            if( usleep(1000) )
+            {
+                writer_err("usleep error \n");
+            }
+        }
+    }
+    return 0;
+}
+
+ssize_t writev_with_retry(int fd, const struct iovec *iov, int ic) 
+{
+    ssize_t len = 0;
+    int i = 0;
+    for(i=0; i<ic; ++i)
+    {
+        write_with_retry(fd, iov[i].iov_base, iov[i].iov_len); 
+        len += iov[i].iov_len;
+        if(PlaybackDieNow(0))
+        {
+//            return -1;
+        }
+    }
+    return len;
+}
+
+Writer_t* getWriter(char* encoding)
+{
+    int i;
+
+    for (i = 0; AvailableWriter[i] != NULL; i++)
+    {
+        if (strcmp(AvailableWriter[i]->caps->textEncoding, encoding) == 0)
+        {
+            writer_printf(50, "%s: found writer \"%s\" for \"%s\"\n", __func__, AvailableWriter[i]->caps->name, encoding);
+            return AvailableWriter[i];
+        }
+    }
+
+    writer_printf(1, "%s: no writer found for \"%s\"\n", __func__, encoding);
+
+    return NULL;
+}
+
+Writer_t* getDefaultVideoWriter()
+{
+    int i;
+
+    for (i = 0; AvailableWriter[i] != NULL; i++)
+    {
+        if (strcmp(AvailableWriter[i]->caps->textEncoding, "V_MPEG2") == 0)
+        {
+            writer_printf(50, "%s: found writer \"%s\"\n", __func__, AvailableWriter[i]->caps->name);
+            return AvailableWriter[i];
+        }
+    }
+
+    writer_printf(1, "%s: no writer found\n", __func__);
+
+    return NULL;
+}
+
+Writer_t* getDefaultAudioWriter()
+{
+    int i;
+
+    for (i = 0; AvailableWriter[i] != NULL; i++)
+    {
+        if (strcmp(AvailableWriter[i]->caps->textEncoding, "A_MP3") == 0)
+        {
+            writer_printf(50, "%s: found writer \"%s\"\n", __func__, AvailableWriter[i]->caps->name);
+            return AvailableWriter[i];
+        }
+    }
+
+    writer_printf(1, "%s: no writer found\n", __func__);
+
+    return NULL;
+}
+

titan/libeplayer3/playback/playback.c

@@ -70 +70 @@
         }
     }
-    return 0;
+//    return 0;
     return dieNow;
 }