Changeset 42162 for titan/libeplayer3/container/container_ffmpeg.c

Timestamp:

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

Author:

obi

Message:

update libeplayer3 to v47

File:

• titan/libeplayer3/container/container_ffmpeg.c (modified) (33 diffs)

titan/libeplayer3/container/container_ffmpeg.c

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