Ticket #13233: 20180705_1535_segfault_fix.patch

mythtv/configure

@@ -135 +135 @@
   --disable-vaapi          disable VAAPI hardware accelerated video decoding
   --disable-openmax        disable OpenMAX hardware accelerated video decoding
   --disable-dxva2          disable hardware accelerated decoding on windows
+  --disable-mediacodec     disable hardware accelerated decoding on android
   --disable-opengl-video   disable OpenGL based video display
   --disable-opengl-themepainter disable OpenGL based theme painting
   --disable-libass         disable libass SSA/ASS subtitle support
@@ -2038 +2039 @@
     vaapi
     vdpau
     openmax
+    mediacodec
 '
 
 CMDLINE_SELECT="
@@ -2763 +2765 @@
 enable libdns_sd
 enable libxml2
 enable lirc
+enable mediacodec
 enable mheg
 enable mythtranscode
 enable opengl
@@ -6971 +6974 @@
 ffmpeg_optset pkg_config prefix libdir as objcc dep_cc host_cc
 ffmpeg_optset host_ld
 ffmpeg_optenable cross_compile libmp3lame libx264 libx265 libvpx libxvid
-ffmpeg_optenable vdpau vaapi libxml2 libass dxva2 mediacodec
-ffmpeg_optenable jni libbluray libfontconfig libfreetype libiec61883
+ffmpeg_optenable vdpau vaapi libxml2 libass dxva2
+ffmpeg_optenable libbluray libfontconfig libfreetype libiec61883
 ffmpeg_optenable crystalhd sdl2 ffplay
+if test $target_os = "android"; then
+    enabled mediacodec && enable jni
+    ffmpeg_optenable mediacodec jni
+else
+    disable mediacodec
+fi
+
 ffmpeg_extra_cflags="$extra_cflags -w"
 
 ## Call FFmpeg configure here

mythtv/external/FFmpeg/libavcodec/mediacodec_sw_buffer.c

@@ -150 +150 @@
         } else if (i == 1) {
             height = avctx->height / 2;
 
-            src += s->slice_height * s->stride;
+            // src += s->slice_height * s->stride;
+            src += s->height * s->stride;
             src += s->crop_top * s->stride;
             src += s->crop_left;
         }

mythtv/libs/libmythtv/avformatdecoder.cpp

@@ -62 +62 @@
 #include "vaapicontext.h"
 #endif
 
+#ifdef USING_MEDIACODEC
+#include "mediacodeccontext.h"
+extern "C" {
+#include "libavcodec/jni.h"
+}
+#include <QtAndroidExtras>
+#endif
+
 extern "C" {
 #include "libavutil/avutil.h"
 #include "libavutil/error.h"
@@ -276 +284 @@
     static QString full_line("");
     static const int msg_len = 255;
     static QMutex string_lock;
-    uint64_t   verbose_mask  = VB_GENERAL;
-    LogLevel_t verbose_level = LOG_DEBUG;
+    uint64_t   verbose_mask  = VB_LIBAV;
+    LogLevel_t verbose_level = LOG_EMERG;
 
     // determine mythtv debug level from av log level
     switch (level)
     {
         case AV_LOG_PANIC:
             verbose_level = LOG_EMERG;
+            verbose_mask |= VB_GENERAL;
             break;
         case AV_LOG_FATAL:
             verbose_level = LOG_CRIT;
+            verbose_mask |= VB_GENERAL;
             break;
         case AV_LOG_ERROR:
             verbose_level = LOG_ERR;
-            verbose_mask |= VB_LIBAV;
             break;
-        case AV_LOG_DEBUG:
-        case AV_LOG_VERBOSE:
+        case AV_LOG_WARNING:
+            verbose_level = LOG_WARNING;
+            break;
         case AV_LOG_INFO:
-            verbose_level = LOG_DEBUG;
-            verbose_mask |= VB_LIBAV;
+            verbose_level = LOG_INFO;
             break;
-        case AV_LOG_WARNING:
-            verbose_mask |= VB_LIBAV;
+        case AV_LOG_VERBOSE:
+        case AV_LOG_DEBUG:
+        case AV_LOG_TRACE:
+            verbose_level = LOG_DEBUG;
             break;
         default:
             return;
@@ -374 +385 @@
     opts.decoders->append("vaapi");
     (*opts.equiv_decoders)["vaapi"].append("dummy");
 #endif
+#ifdef USING_MEDIACODEC
+    opts.decoders->append("mediacodec");
+    (*opts.equiv_decoders)["mediacodec"].append("dummy");
+#endif
 
     PrivateDecoder::GetDecoders(opts);
 }
@@ -405 +420 @@
       pts_detected(false),
       reordered_pts_detected(false),
       pts_selected(true),
+      use_frame_timing(false),
       force_dts_timestamps(false),
       playerFlags(flags),
       video_codec_id(kCodec_NONE),
@@ -433 +449 @@
     audioSamples = (uint8_t *)av_mallocz(AudioOutput::MAX_SIZE_BUFFER);
     ccd608->SetIgnoreTimecode(true);
 
-    bool debug = VERBOSE_LEVEL_CHECK(VB_LIBAV, LOG_ANY);
-    av_log_set_level((debug) ? AV_LOG_DEBUG : AV_LOG_ERROR);
+    // bool debug = VERBOSE_LEVEL_CHECK(VB_LIBAV, LOG_ANY);
+    // This is useless code - only applies to ffmpeg default logger,
+    // which we do not use
+    // av_log_set_level((debug) ? AV_LOG_DEBUG : AV_LOG_ERROR);
     av_log_set_callback(myth_av_log);
 
     audioIn.sample_size = -32; // force SetupAudioStream to run once
@@ -742 +760 @@
 
         lastKey = (long long)((newts*(long double)fps)/AV_TIME_BASE);
         framesPlayed = lastKey;
+        fpsSkip = 0;
         framesRead = lastKey;
 
         normalframes = (exactseeks) ? desiredFrame - framesPlayed : 0;
@@ -753 +772 @@
         LOG(VB_GENERAL, LOG_INFO, LOC + "No DTS Seeking Hack!");
         no_dts_hack = true;
         framesPlayed = desiredFrame;
+        fpsSkip = 0;
         framesRead = desiredFrame;
         normalframes = 0;
     }
@@ -844 +864 @@
             if (!no_dts_hack)
             {
                 framesPlayed = lastKey;
+                fpsSkip = 0;
                 framesRead = lastKey;
             }
 
@@ -1005 +1026 @@
 {
     QMutexLocker lock(avcodeclock);
     // Suppress ffmpeg logging unless "-v libav --loglevel debug"
-    if (!VERBOSE_LEVEL_CHECK(VB_LIBAV, LOG_DEBUG))
-        silence_ffmpeg_logging = true;
+    // if (!VERBOSE_LEVEL_CHECK(VB_LIBAV, LOG_DEBUG))
+    //     silence_ffmpeg_logging = true;
     int retval = avformat_find_stream_info(ic, NULL);
     silence_ffmpeg_logging = false;
     // ffmpeg 3.0 is returning -1 code when there is a channel
@@ -1540 +1561 @@
 }
 #endif
 
+#ifdef USING_MEDIACODEC
+static enum AVPixelFormat get_format_mediacodec(struct AVCodecContext *avctx,
+                                           const enum AVPixelFormat *valid_fmts)
+{
+    enum AVPixelFormat ret = *valid_fmts; // default to first
+    while (*valid_fmts != AV_PIX_FMT_NONE) {
+        if (*valid_fmts == AV_PIX_FMT_YUV420P)
+            ret = AV_PIX_FMT_YUV420P;
+        valid_fmts++;
+    }
+    return ret;
+}
+#endif
+
+
 static bool IS_DR1_PIX_FMT(const enum AVPixelFormat fmt)
 {
     switch (fmt)
@@ -1575 +1611 @@
     enc->debug = 0;
     // enc->error_rate = 0;
 
-    AVCodec *codec = avcodec_find_decoder(enc->codec_id);
+    const AVCodec *codec = enc->codec;
 
     if (selectedStream)
     {
@@ -1612 +1648 @@
         enc->slice_flags     = SLICE_FLAG_CODED_ORDER | SLICE_FLAG_ALLOW_FIELD;
     }
     else
+#endif
+#ifdef USING_MEDIACODEC
+    if (CODEC_IS_MEDIACODEC(codec))
+    {
+        enc->get_format      = get_format_mediacodec;
+        enc->slice_flags     = SLICE_FLAG_CODED_ORDER | SLICE_FLAG_ALLOW_FIELD;
+    }
+    else
 #endif
     if (codec && codec->capabilities & AV_CODEC_CAP_DR1)
     {
@@ -1679 +1723 @@
         }
 
         m_parent->SetKeyframeDistance(keyframedist);
-        AVCodec *codec = avcodec_find_decoder(enc->codec_id);
+        const AVCodec *codec = enc->codec;
         QString codecName;
         if (codec)
             codecName = codec->name;
@@ -2368 +2412 @@
 
             if (averror_count > SEQ_PKT_ERR_MAX)
                 gCodecMap->freeCodecContext(ic->streams[selTrack]);
-            AVCodecContext *enc = gCodecMap->getCodecContext(ic->streams[selTrack]);
+            AVCodecContext *enc = gCodecMap->getCodecContext(ic->streams[selTrack], codec);
             StreamInfo si(selTrack, 0, 0, 0, 0);
 
             tracks[kTrackTypeVideo].push_back(si);
@@ -2393 +2437 @@
             uint height = max(dim.height(), 16);
             QString dec = "ffmpeg";
             uint thread_count = 1;
-            AVCodec *codec1 = avcodec_find_decoder(enc->codec_id);
             QString codecName;
-            if (codec1)
-                codecName = codec1->name;
+            if (enc->codec)
+                codecName = enc->codec->name;
             if (enc->framerate.den && enc->framerate.num)
                 fps = float(enc->framerate.num) / float(enc->framerate.den);
             else
@@ -2473 +2516 @@
                 }
 #endif // USING_GLVAAPI
 #ifdef USING_DXVA2
-                if (!foundgpudecode)
+                if (!foundgpudecoder)
                 {
                     MythCodecID dxva2_mcid;
                     AVPixelFormat pix_fmt = AV_PIX_FMT_YUV420P;
@@ -2489 +2532 @@
                     }
                 }
 #endif // USING_DXVA2
-                if (foundgpudecoder)
+#ifdef USING_MEDIACODEC
+                if (!foundgpudecoder)
                 {
-                    enc->codec_id = (AVCodecID) myth2av_codecid(video_codec_id);
+                    MythCodecID mediacodec_mcid;
+                    AVPixelFormat pix_fmt = AV_PIX_FMT_YUV420P;
+                    mediacodec_mcid = MediaCodecContext::GetBestSupportedCodec(
+                        &codec, dec, mpeg_version(enc->codec_id),
+                        pix_fmt);
+
+                    if (codec_is_mediacodec(mediacodec_mcid))
+                    {
+                        gCodecMap->freeCodecContext(ic->streams[selTrack]);
+                        enc = gCodecMap->getCodecContext(ic->streams[selTrack], codec);
+                        video_codec_id = mediacodec_mcid;
+                        foundgpudecoder = true;
+                    }
                 }
+#endif // USING_MEDIACODEC
             }
-
             // default to mpeg2
             if (video_codec_id == kCodec_NONE)
             {
@@ -2502 +2558 @@
                     "Unknown video codec - defaulting to MPEG2");
                 video_codec_id = kCodec_MPEG2;
             }
-            else
-            {
-                codec = avcodec_find_decoder(enc->codec_id);
-            }
 
             // Use a PrivateDecoder if allowed in playerFlags AND matched
             // via the decoder name
@@ -2516 +2568 @@
             if (!codec_is_std(video_codec_id))
                 thread_count = 1;
 
+            use_frame_timing = false;
+            if (! private_dec
+                && (codec_is_std(video_codec_id) || codec_is_mediacodec(video_codec_id)))
+                use_frame_timing = true;
+
             if (FlagIsSet(kDecodeSingleThreaded))
                 thread_count = 1;
 
@@ -2531 +2588 @@
             ScanATSCCaptionStreams(selTrack);
             UpdateATSCCaptionTracks();
 
-            LOG(VB_PLAYBACK, LOG_INFO, LOC +
+            LOG(VB_GENERAL, LOG_INFO, LOC +
                 QString("Using %1 for video decoding")
                 .arg(GetCodecDecoderName()));
 
@@ -2611 +2668 @@
 {
     QMutexLocker locker(avcodeclock);
 
+#ifdef USING_MEDIACODEC
+    if (QString("mediacodec") == codec->wrapper_name)
+        av_jni_set_java_vm(QAndroidJniEnvironment::javaVM(), NULL);
+#endif
     int ret = avcodec_open2(avctx, codec, NULL);
     if (ret < 0)
     {
@@ -3536 +3597 @@
     return true;
 }
 
+// Maximum retries - 500 = 5 seconds
+#define PACKET_MAX_RETRIES 5000
+#define RETRY_WAIT_TIME 10000   // microseconds
 bool AvFormatDecoder::ProcessVideoPacket(AVStream *curstream, AVPacket *pkt)
 {
+    int retryCount = 0;
     int ret = 0, gotpicture = 0;
     int64_t pts = 0;
     AVCodecContext *context = gCodecMap->getCodecContext(curstream);
@@ -3551 +3616 @@
     if (pkt->pts != (int64_t)AV_NOPTS_VALUE)
         pts_detected = true;
 
-    avcodeclock->lock();
-    if (private_dec)
-    {
-        if (QString(ic->iformat->name).contains("avi") || !pts_detected)
-            pkt->pts = pkt->dts;
-        // TODO disallow private decoders for dvd playback
-        // N.B. we do not reparse the frame as it breaks playback for
-        // everything but libmpeg2
-        ret = private_dec->GetFrame(curstream, mpa_pic, &gotpicture, pkt);
-    }
-    else
+    bool tryAgain = true;
+    bool sentPacket = false;
+    int ret2 = 0;
+    while (tryAgain)
     {
-        context->reordered_opaque = pkt->pts;
-        //  SUGGESTION
-        //  Now that avcodec_decode_video2 is deprecated and replaced
-        //  by 2 calls (receive frame and send packet), this could be optimized
-        //  into separate routines or separate threads.
-        //  Also now that it always consumes a whole buffer some code
-        //  in the caller may be able to be optimized.
-        ret = avcodec_receive_frame(context, mpa_pic);
-        if (ret == 0)
-            gotpicture = 1;
-        if (ret == AVERROR(EAGAIN))
-            ret = 0;
+        tryAgain = false;
+        gotpicture = 0;
+        avcodeclock->lock();
+        if (private_dec)
+        {
+            if (QString(ic->iformat->name).contains("avi") || !pts_detected)
+                pkt->pts = pkt->dts;
+            // TODO disallow private decoders for dvd playback
+            // N.B. we do not reparse the frame as it breaks playback for
+            // everything but libmpeg2
+            ret = private_dec->GetFrame(curstream, mpa_pic, &gotpicture, pkt);
+            sentPacket = true;
+        }
+        else
+        {
+            if (!use_frame_timing)
+                context->reordered_opaque = pkt->pts;
+
+            //  SUGGESTION
+            //  Now that avcodec_decode_video2 is deprecated and replaced
+            //  by 2 calls (receive frame and send packet), this could be optimized
+            //  into separate routines or separate threads.
+            //  Also now that it always consumes a whole buffer some code
+            //  in the caller may be able to be optimized.
+            ret = avcodec_receive_frame(context, mpa_pic);
+
+            if (ret == 0)
+                gotpicture = 1;
+            else
+                gotpicture = 0;
+            if (ret == AVERROR(EAGAIN))
+                ret = 0;
+            // If we got a picture do not send the packet until we have
+            // all available pictures
+            // if (ret == 0 && !gotpicture)
+            if (!gotpicture)
+            {
+                ret2 = avcodec_send_packet(context, pkt);
+                if (ret2 == AVERROR(EAGAIN))
+                {
+                    tryAgain = true;
+                    ret2 = 0;
+                }
+                else
+                    sentPacket = true;
+            }
+        }
+        avcodeclock->unlock();
+
         if (ret == 0)
-            ret = avcodec_send_packet(context, pkt);
-        // The code assumes that there is always space to add a new
-        // packet. This seems risky but has always worked.
-        // It should actually check if (ret == AVERROR(EAGAIN)) and then keep
-        // the packet around and try it again after processing the frame
-        // received here.
-    }
-    avcodeclock->unlock();
+            ret = ret2;
+        if (ret < 0)
+        {
+            char error[AV_ERROR_MAX_STRING_SIZE];
+            LOG(VB_GENERAL, LOG_ERR, LOC +
+                QString("video decode error: %1 (%2) gotpicture:%3")
+                .arg(av_make_error_string(error, sizeof(error), ret))
+                .arg(ret).arg(gotpicture));
+            if (ret == AVERROR_INVALIDDATA)
+            {
+                if (++averror_count > SEQ_PKT_ERR_MAX)
+                {
+                    // If erroring on GPU assist, try switching to software decode
+                    if (codec_is_std(video_codec_id))
+                        m_parent->SetErrored(QObject::tr("Video Decode Error"));
+                    else
+                        m_streams_changed = true;
+                }
+            }
+            return false;
+        }
 
-    if (ret < 0)
-    {
-        char error[AV_ERROR_MAX_STRING_SIZE];
-        LOG(VB_GENERAL, LOG_ERR, LOC +
-            QString("video decode error: %1 (%2)")
-            .arg(av_make_error_string(error, sizeof(error), ret))
-            .arg(gotpicture));
-        if (ret == AVERROR_INVALIDDATA)
+        if (tryAgain)
         {
-            if (++averror_count > SEQ_PKT_ERR_MAX)
+            if (++retryCount > PACKET_MAX_RETRIES)
             {
-                // If erroring on GPU assist, try switching to software decode
-                if (codec_is_std(video_codec_id))
-                    m_parent->SetErrored(QObject::tr("Video Decode Error"));
-                else
-                    m_streams_changed = true;
+                LOG(VB_GENERAL, LOG_ERR, LOC +
+                    QString("ERROR: Video decode buffering retries exceeded maximum"));
+                return false;
             }
+            LOG(VB_PLAYBACK, LOG_INFO, LOC +
+                QString("Video decode buffering retry"));
+            usleep(RETRY_WAIT_TIME);
         }
-        return false;
     }
     // averror_count counts sequential errors, so if you have a successful
     // packet then reset it
     averror_count = 0;
-
-    if (!gotpicture)
+    if (gotpicture)
     {
-        return true;
-    }
+        LOG(VB_PLAYBACK | VB_TIMESTAMP, LOG_INFO, LOC +
+            QString("video timecodes packet-pts:%1 frame-pts:%2 packet-dts: %3 frame-dts:%4")
+                .arg(pkt->pts).arg(mpa_pic->pts).arg(pkt->pts)
+                .arg(mpa_pic->pkt_dts));
 
-    // Detect faulty video timestamps using logic from ffplay.
-    if (pkt->dts != (int64_t)AV_NOPTS_VALUE)
-    {
-        faulty_dts += (pkt->dts <= last_dts_for_fault_detection);
-        last_dts_for_fault_detection = pkt->dts;
-    }
-    if (mpa_pic->reordered_opaque != (int64_t)AV_NOPTS_VALUE)
-    {
-        faulty_pts += (mpa_pic->reordered_opaque <= last_pts_for_fault_detection);
-        last_pts_for_fault_detection = mpa_pic->reordered_opaque;
-        reordered_pts_detected = true;
-    }
+        if (!use_frame_timing)
+        {
+            // Detect faulty video timestamps using logic from ffplay.
+            if (pkt->dts != (int64_t)AV_NOPTS_VALUE)
+            {
+                faulty_dts += (pkt->dts <= last_dts_for_fault_detection);
+                last_dts_for_fault_detection = pkt->dts;
+            }
+            if (mpa_pic->reordered_opaque != (int64_t)AV_NOPTS_VALUE)
+            {
+                faulty_pts += (mpa_pic->reordered_opaque <= last_pts_for_fault_detection);
+                last_pts_for_fault_detection = mpa_pic->reordered_opaque;
+                reordered_pts_detected = true;
+            }
 
-    // Explicity use DTS for DVD since they should always be valid for every
-    // frame and fixups aren't enabled for DVD.
-    // Select reordered_opaque (PTS) timestamps if they are less faulty or the
-    // the DTS timestamp is missing. Also use fixups for missing PTS instead of
-    // DTS to avoid oscillating between PTS and DTS. Only select DTS if PTS is
-    // more faulty or never detected.
-    if (force_dts_timestamps)
-    {
-        if (pkt->dts != (int64_t)AV_NOPTS_VALUE)
-            pts = pkt->dts;
-        pts_selected = false;
-    }
-    else if (ringBuffer->IsDVD())
-    {
-        if (pkt->dts != (int64_t)AV_NOPTS_VALUE)
-            pts = pkt->dts;
-        pts_selected = false;
-    }
-    else if (private_dec && private_dec->NeedsReorderedPTS() &&
-             mpa_pic->reordered_opaque != (int64_t)AV_NOPTS_VALUE)
-    {
-        pts = mpa_pic->reordered_opaque;
-        pts_selected = true;
-    }
-    else if (faulty_pts <= faulty_dts && reordered_pts_detected)
-    {
-        if (mpa_pic->reordered_opaque != (int64_t)AV_NOPTS_VALUE)
-            pts = mpa_pic->reordered_opaque;
-        pts_selected = true;
+            // Explicity use DTS for DVD since they should always be valid for every
+            // frame and fixups aren't enabled for DVD.
+            // Select reordered_opaque (PTS) timestamps if they are less faulty or the
+            // the DTS timestamp is missing. Also use fixups for missing PTS instead of
+            // DTS to avoid oscillating between PTS and DTS. Only select DTS if PTS is
+            // more faulty or never detected.
+            if (force_dts_timestamps)
+            {
+                if (pkt->dts != (int64_t)AV_NOPTS_VALUE)
+                    pts = pkt->dts;
+                pts_selected = false;
+            }
+            else if (ringBuffer->IsDVD())
+            {
+                if (pkt->dts != (int64_t)AV_NOPTS_VALUE)
+                    pts = pkt->dts;
+                pts_selected = false;
+            }
+            else if (private_dec && private_dec->NeedsReorderedPTS() &&
+                    mpa_pic->reordered_opaque != (int64_t)AV_NOPTS_VALUE)
+            {
+                pts = mpa_pic->reordered_opaque;
+                pts_selected = true;
+            }
+            else if (faulty_pts <= faulty_dts && reordered_pts_detected)
+            {
+                if (mpa_pic->reordered_opaque != (int64_t)AV_NOPTS_VALUE)
+                    pts = mpa_pic->reordered_opaque;
+                pts_selected = true;
+            }
+            else if (pkt->dts != (int64_t)AV_NOPTS_VALUE)
+            {
+                pts = pkt->dts;
+                pts_selected = false;
+            }
+
+            LOG(VB_PLAYBACK | VB_TIMESTAMP, LOG_DEBUG, LOC +
+                QString("video packet timestamps reordered %1 pts %2 dts %3 (%4)")
+                    .arg(mpa_pic->reordered_opaque).arg(pkt->pts).arg(pkt->dts)
+                    .arg((force_dts_timestamps) ? "dts forced" :
+                        (pts_selected) ? "reordered" : "dts"));
+
+            mpa_pic->reordered_opaque = pts;
+        }
+        ProcessVideoFrame(curstream, mpa_pic);
     }
-    else if (pkt->dts != (int64_t)AV_NOPTS_VALUE)
+    if (!sentPacket)
     {
-        pts = pkt->dts;
-        pts_selected = false;
+        // MythTV logic expects that only one frame is processed
+        // Save the packet for later and return.
+        AVPacket *newPkt = new AVPacket;
+        memset(newPkt, 0, sizeof(AVPacket));
+        av_init_packet(newPkt);
+        av_packet_ref(newPkt, pkt);
+        storedPackets.prepend(newPkt);
     }
-
-    LOG(VB_PLAYBACK | VB_TIMESTAMP, LOG_DEBUG, LOC +
-        QString("video packet timestamps reordered %1 pts %2 dts %3 (%4)")
-            .arg(mpa_pic->reordered_opaque).arg(pkt->pts).arg(pkt->dts)
-            .arg((force_dts_timestamps) ? "dts forced" :
-                 (pts_selected) ? "reordered" : "dts"));
-
-    mpa_pic->reordered_opaque = pts;
-
-    ProcessVideoFrame(curstream, mpa_pic);
-
     return true;
 }
 
@@ -3777 +3891 @@
         return false;
     }
 
-    long long pts = (long long)(av_q2d(stream->time_base) *
+    long long pts;
+    if (use_frame_timing)
+    {
+        pts = mpa_pic->pts;
+        if (pts == AV_NOPTS_VALUE)
+            pts = mpa_pic->pkt_dts;
+        if (pts == AV_NOPTS_VALUE)
+        {
+            LOG(VB_GENERAL, LOG_ERR, LOC + "No PTS found - unable to process video.");
+            return false;
+        }
+        pts = (long long)(av_q2d(stream->time_base) *
+                                pts * 1000);
+    }
+    else
+        pts = (long long)(av_q2d(stream->time_base) *
                                 mpa_pic->reordered_opaque * 1000);
 
     long long temppts = pts;
@@ -3794 +3923 @@
         temppts += (long long)(mpa_pic->repeat_pict * 500 / fps);
     }
 
+    // Calculate actual fps from the pts values.
+    long long ptsdiff = temppts - lastvpts;
+    double calcfps = 1000.0 / ptsdiff;
+    if (calcfps < 121.0 && calcfps > 3.0)
+    {
+        // If fps has doubled due to frame-doubling deinterlace
+        // Set fps to double value.
+        double fpschange = calcfps / fps;
+        if (fpschange > 1.9 && fpschange < 2.1 && fpsMultiplier == 1)
+            fpsMultiplier = 2;
+        if (fpschange > 0.5 && fpschange < 0.6 && fpsMultiplier == 2)
+            fpsMultiplier = 1;
+    }
+
+
     LOG(VB_PLAYBACK | VB_TIMESTAMP, LOG_INFO, LOC +
         QString("video timecode %1 %2 %3 %4%5")
-            .arg(mpa_pic->reordered_opaque).arg(pts).arg(temppts).arg(lastvpts)
+            .arg(use_frame_timing ? mpa_pic->pts : mpa_pic->reordered_opaque).arg(pts)
+            .arg(temppts).arg(lastvpts)
             .arg((pts != temppts) ? " fixup" : ""));
 
     if (picframe)
@@ -3815 +3960 @@
 
     decoded_video_frame = picframe;
     gotVideoFrame = 1;
-    ++framesPlayed;
+    if (++fpsSkip >= fpsMultiplier)
+    {
+        ++framesPlayed;
+        fpsSkip = 0;
+    }
 
     lastvpts = temppts;
     if (!firstvpts && firstvptsinuse)

mythtv/libs/libmythtv/avformatdecoder.h

@@ -322 +322 @@
     bool pts_detected;
     bool reordered_pts_detected;
     bool pts_selected;
+    // set use_frame_timing true to utilize the pts values in returned
+    // frames. Set fale to use deprecated method.
+    bool use_frame_timing;
 
     bool force_dts_timestamps;
 

mythtv/libs/libmythtv/decoderbase.cpp

@@ -20 +20 @@
 
       current_width(640), current_height(480),
       current_aspect(1.33333), fps(29.97),
+      fpsMultiplier(1), fpsSkip(0),
       bitrate(4000),
 
       framesPlayed(0), framesRead(0),
@@ -80 +81 @@
     {
         ResetPosMap();
         framesPlayed = 0;
+        fpsSkip = 0;
         framesRead = 0;
         totalDuration = AVRationalInit(0);
         dontSyncPositionMap = false;
@@ -581 +583 @@
         return false;
 
     framesPlayed = lastKey;
+    fpsSkip = 0;
     framesRead = lastKey;
 
     // Do any Extra frame-by-frame seeking for exactseeks mode
@@ -880 +883 @@
         ringBuffer->Seek(e.pos, SEEK_SET);
         needflush    = true;
         framesPlayed = lastKey;
+        fpsSkip = 0;
         framesRead = lastKey;
     }
 }

mythtv/libs/libmythtv/decoderbase.h

@@ -269 +269 @@
     void SaveTotalFrames(void);
     bool GetVideoInverted(void) const { return video_inverted; }
     void TrackTotalDuration(bool track) { trackTotalDuration = track; }
+    int GetfpsMultiplier(void) { return fpsMultiplier; }
 
   protected:
     virtual int  AutoSelectTrack(uint type);
@@ -301 +302 @@
     int current_height;
     float current_aspect;
     double fps;
+    int fpsMultiplier;
+    int fpsSkip;
     uint bitrate;
 
     long long framesPlayed;

mythtv/libs/libmythtv/libmythtv.pro

@@ -1 +1 @@
 include ( ../../settings.pro )
 
 QT += network xml sql widgets
+android: QT += androidextras
 
 TEMPLATE = lib
 TARGET = mythtv-$$LIBVERSION
@@ -501 +502 @@
         using_opengl_video:DEFINES += USING_GLVAAPI
     }
 
+    using_mediacodec {
+        DEFINES += USING_MEDIACODEC
+        HEADERS += mediacodeccontext.h
+        SOURCES += mediacodeccontext.cpp
+    }
+
     # Misc. frontend
     HEADERS += DetectLetterbox.h
     SOURCES += DetectLetterbox.cpp

new file mythtv/libs/libmythtv/mediacodeccontext.cpp

@@ +1 @@
+//////////////////////////////////////////////////////////////////////////////
+// Copyright (c) 2017 MythTV Developers <mythtv-dev@mythtv.org>
+//
+// This is part of MythTV (https://www.mythtv.org)
+//
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#include "mediacodeccontext.h"
+
+#include "mythlogging.h"
+
+extern "C" {
+    #include "libavutil/pixfmt.h"
+    #include "libavutil/hwcontext.h"
+    #include "libavcodec/avcodec.h"
+}
+
+#define LOC QString("MEDIACODEC: ")
+
+MythCodecID MediaCodecContext::GetBestSupportedCodec(
+    AVCodec **ppCodec,
+    const QString &decoder,
+    uint stream_type,
+    AVPixelFormat &pix_fmt)
+{
+    enum AVHWDeviceType type = AV_HWDEVICE_TYPE_MEDIACODEC;
+
+    AVPixelFormat fmt = AV_PIX_FMT_NONE;
+    if (decoder == "mediacodec")
+    {
+        QString decodername = QString((*ppCodec)->name) + "_mediacodec";
+        if (decodername == "mpeg2video_mediacodec")
+            decodername = "mpeg2_mediacodec";
+        AVCodec *newCodec = avcodec_find_decoder_by_name (decodername.toLocal8Bit());
+        if (newCodec)
+        {
+            *ppCodec = newCodec;
+            fmt = AV_PIX_FMT_MEDIACODEC;
+        }
+        else
+            LOG(VB_PLAYBACK, LOG_INFO, LOC +
+                QString("Decoder %1 does not support device type %2.")
+                    .arg((*ppCodec)->name).arg(av_hwdevice_get_type_name(type)));
+    }
+
+    if (fmt == AV_PIX_FMT_NONE)
+        return (MythCodecID)(kCodec_MPEG1 + (stream_type - 1));
+    else
+    {
+        LOG(VB_PLAYBACK, LOG_INFO, LOC +
+            QString("Decoder %1 supports device type %2.")
+                .arg((*ppCodec)->name).arg(av_hwdevice_get_type_name(type)));
+        pix_fmt = fmt;
+        return (MythCodecID)(kCodec_MPEG1_MEDIACODEC + (stream_type - 1));
+    }
+}

new file mythtv/libs/libmythtv/mediacodeccontext.h

@@ +1 @@
+//////////////////////////////////////////////////////////////////////////////
+// Copyright (c) 2017 MythTV Developers <mythtv-dev@mythtv.org>
+//
+// This is part of MythTV (https://www.mythtv.org)
+//
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+
+#ifndef VIDEOOUTOPENGLMEDIACODEC_H
+#define VIDEOOUTOPENGLMEDIACODEC_H
+
+#include "videoout_opengl.h"
+
+
+class MediaCodecContext
+{
+  public:
+    static MythCodecID GetBestSupportedCodec(AVCodec **ppCodec,
+                                             const QString &decoder,
+                                             uint stream_type,
+                                             AVPixelFormat &pix_fmt);
+};
+
+#endif // VIDEOOUTOPENGLMEDIACODEC_H
+ No newline at end of file

mythtv/libs/libmythtv/mythcodecid.cpp

@@ -102 +102 @@
         case kCodec_HEVC_DXVA2:
             return "HEVC DXVA2";
 
+        case kCodec_MPEG1_MEDIACODEC:
+            return "MPEG1 MEDIACODEC";
+        case kCodec_MPEG2_MEDIACODEC:
+            return "MPEG2 MEDIACODEC";
+        case kCodec_H263_MEDIACODEC:
+            return "H.263 MEDIACODEC";
+        case kCodec_MPEG4_MEDIACODEC:
+            return "MPEG4 MEDIACODEC";
+        case kCodec_H264_MEDIACODEC:
+            return "H.264 MEDIACODEC";
+        case kCodec_VC1_MEDIACODEC:
+            return "VC1 MEDIACODEC";
+        case kCodec_WMV3_MEDIACODEC:
+            return "WMV3 MEDIACODEC";
+        case kCodec_VP8_MEDIACODEC:
+            return "VP8 MEDIACODEC";
+        case kCodec_VP9_MEDIACODEC:
+            return "VP9 MEDIACODEC";
+        case kCodec_HEVC_MEDIACODEC:
+            return "HEVC MEDIACODEC";
+
         default:
             break;
     }
@@ -253 +274 @@
             ret = AV_CODEC_ID_HEVC;
             break;
 
+        case kCodec_MPEG1_MEDIACODEC:
+            ret = AV_CODEC_ID_MPEG1VIDEO;
+            break;
+        case kCodec_MPEG2_MEDIACODEC:
+            ret = AV_CODEC_ID_MPEG2VIDEO;
+            break;
+        case kCodec_H263_MEDIACODEC:
+            ret = AV_CODEC_ID_H263;
+            break;
+        case kCodec_MPEG4_MEDIACODEC:
+            ret = AV_CODEC_ID_MPEG4;
+            break;
+        case kCodec_H264_MEDIACODEC:
+            ret = AV_CODEC_ID_H264;
+            break;
+        case kCodec_VC1_MEDIACODEC:
+            ret = AV_CODEC_ID_VC1;
+            break;
+        case kCodec_WMV3_MEDIACODEC:
+            ret = AV_CODEC_ID_WMV3;
+            break;
+        case kCodec_VP8_MEDIACODEC:
+            ret = AV_CODEC_ID_VP8;
+            break;
+        case kCodec_VP9_MEDIACODEC:
+            ret = AV_CODEC_ID_VP9;
+            break;
+        case kCodec_HEVC_MEDIACODEC:
+            ret = AV_CODEC_ID_HEVC;
+            break;
+
         default:
             LOG(VB_GENERAL, LOG_ERR,
                 QString("Error: MythCodecID %1 has not been "
@@ -303 +355 @@
         case kCodec_MPEG1_VDPAU:
         case kCodec_MPEG1_VAAPI:
         case kCodec_MPEG1_DXVA2:
+        case kCodec_MPEG1_MEDIACODEC:
         case kCodec_MPEG2:
         case kCodec_MPEG2_VDPAU:
         case kCodec_MPEG2_VAAPI:
         case kCodec_MPEG2_DXVA2:
+        case kCodec_MPEG2_MEDIACODEC:
             return "MPEG-2";
 
         case kCodec_H263:
         case kCodec_H263_VDPAU:
         case kCodec_H263_VAAPI:
         case kCodec_H263_DXVA2:
+        case kCodec_H263_MEDIACODEC:
             return "H.263";
 
         case kCodec_NUV_MPEG4:
@@ -320 +375 @@
         case kCodec_MPEG4_VDPAU:
         case kCodec_MPEG4_VAAPI:
         case kCodec_MPEG4_DXVA2:
+        case kCodec_MPEG4_MEDIACODEC:
             return "MPEG-4";
 
         case kCodec_H264:
         case kCodec_H264_VDPAU:
         case kCodec_H264_VAAPI:
         case kCodec_H264_DXVA2:
+        case kCodec_H264_MEDIACODEC:
             return "H.264";
 
         case kCodec_VC1:
         case kCodec_VC1_VDPAU:
         case kCodec_VC1_VAAPI:
         case kCodec_VC1_DXVA2:
+        case kCodec_VC1_MEDIACODEC:
             return "VC-1";
 
         case kCodec_WMV3:
         case kCodec_WMV3_VDPAU:
         case kCodec_WMV3_VAAPI:
         case kCodec_WMV3_DXVA2:
+        case kCodec_WMV3_MEDIACODEC:
             return "WMV3";
 
         case kCodec_VP8:
         case kCodec_VP8_VDPAU:
         case kCodec_VP8_VAAPI:
         case kCodec_VP8_DXVA2:
+        case kCodec_VP8_MEDIACODEC:
             return "VP8";
 
         case kCodec_VP9:
         case kCodec_VP9_VDPAU:
         case kCodec_VP9_VAAPI:
         case kCodec_VP9_DXVA2:
+        case kCodec_VP9_MEDIACODEC:
             return "VP8";
 
         case kCodec_HEVC:
         case kCodec_HEVC_VDPAU:
         case kCodec_HEVC_VAAPI:
         case kCodec_HEVC_DXVA2:
+        case kCodec_HEVC_MEDIACODEC:
             return "HEVC";
 
         case kCodec_NONE:
@@ -363 +425 @@
         case kCodec_VDPAU_END:
         case kCodec_VAAPI_END:
         case kCodec_DXVA2_END:
+        case kCodec_MEDIACODEC_END:
             return QString();
     }
 
@@ -380 +443 @@
     if (codec_is_dxva2(codec_id))
         return "dxva2";
 
+    if (codec_is_mediacodec(codec_id))
+        return "mediacodec";
+
     return "ffmpeg";
 }

mythtv/libs/libmythtv/mythcodecid.h

@@ -75 +75 @@
     kCodec_HEVC_DXVA2,
 
     kCodec_DXVA2_END,
+
+    kCodec_MEDIACODEC_BEGIN = kCodec_DXVA2_END,
+
+    kCodec_MPEG1_MEDIACODEC,
+    kCodec_MPEG2_MEDIACODEC,
+    kCodec_H263_MEDIACODEC,
+    kCodec_MPEG4_MEDIACODEC,
+    kCodec_H264_MEDIACODEC,
+    kCodec_VC1_MEDIACODEC,
+    kCodec_WMV3_MEDIACODEC,
+    kCodec_VP8_MEDIACODEC,
+    kCodec_VP9_MEDIACODEC,
+    kCodec_HEVC_MEDIACODEC,
+
+    kCodec_MEDIACODEC_END,
+
 } MythCodecID;
 
 // MythCodecID convenience functions
 #define codec_is_std(id)      (id < kCodec_NORMAL_END)
+// temporary test
 #define codec_is_std_mpeg(id) (id == kCodec_MPEG1 || id == kCodec_MPEG2)
 #define codec_is_vdpau(id)    ((id > kCodec_VDPAU_BEGIN) &&     \
                                (id < kCodec_VDPAU_END))
@@ -95 +112 @@
                                ((id == kCodec_H264_DXVA2)  ||   \
                                 (id == kCodec_MPEG2_DXVA2) ||   \
                                 (id == kCodec_VC1_DXVA2)))
+#define codec_is_mediacodec(id) ((id > kCodec_MEDIACODEC_BEGIN) &&     \
+                               (id < kCodec_MEDIACODEC_END))
+
+#define codec_sw_copy(id) (codec_is_std(id) || codec_is_mediacodec(id))
 
 QString get_encoding_type(MythCodecID codecid);
 QString get_decoder_name(MythCodecID codec_id);
@@ -130 +151 @@
 #define CODEC_IS_DXVA2(codec, enc) (0)
 #endif
 
+#ifdef USING_MEDIACODEC
+#define CODEC_IS_MEDIACODEC(codec) (codec && (QString("mediacodec") == codec->wrapper_name))
+#else
+#define CODEC_IS_MEDIACODEC(codec) (0)
+#endif
+
 #define CODEC_IS_HWACCEL(codec, enc) (CODEC_IS_VDPAU(codec)      ||     \
                                       CODEC_IS_VAAPI(codec, enc) ||     \
-                                      CODEC_IS_DXVA2(codec, enc))
+                                      CODEC_IS_DXVA2(codec, enc) ||    \
+                                      CODEC_IS_MEDIACODEC(codec))
 
 #endif // _MYTH_CODEC_ID_H_

mythtv/libs/libmythtv/videobuffers.cpp

@@ -15 +15 @@
 #include "compat.h"
 #include "mythlogging.h"
 
-#define TRY_LOCK_SPINS                 100
-#define TRY_LOCK_SPINS_BEFORE_WARNING   10
-#define TRY_LOCK_SPIN_WAIT             100 /* usec */
+#define TRY_LOCK_SPINS                 2000
+#define TRY_LOCK_SPINS_BEFORE_WARNING  9999
+#define TRY_LOCK_SPIN_WAIT             1000 /* usec */
 
 int next_dbg_str = 0;
 
@@ -289 +289 @@
 
         if (tries >= TRY_LOCK_SPINS)
         {
+            LOG(VB_GENERAL, LOG_ERR, QString("GetNextFreeFrame: "
+            "available:%1 used:%2 limbo:%3 pause:%4 displayed:%5 decode:%6 finished:%7")
+            .arg(available.size()).arg(used.size()).arg(limbo.size()).arg(pause.size()).arg(displayed.size()).arg(decode.size()).arg(finished.size()));
             LOG(VB_GENERAL, LOG_ERR,
                 QString("GetNextFreeFrame() unable to "
                         "lock frame %1 times. Discarding Frames.")

mythtv/libs/libmythtv/videodisplayprofile.cpp

@@ -851 +851 @@
         dec_name["vaapi"]    = QObject::tr("VAAPI acceleration");
         dec_name["dxva2"]    = QObject::tr("Windows hardware acceleration");
         dec_name["vda"]      = QObject::tr("Mac VDA hardware acceleration");
+        dec_name["mediacodec"] = QObject::tr("Android MediaCodec decoder");
     }
 
     QString ret = decoder;
@@ -907 +908 @@
             "Openmax will use the graphics hardware to "
             "accelerate video decoding on Raspberry Pi. ");
 
+    if (decoder == "mediacodec")
+        msg += QObject::tr(
+            "Mediacodec will use the graphics hardware to "
+            "accelerate video decoding on Android. ");
+
     return msg;
 }
 
@@ -1453 +1459 @@
                       "");
     }
 #endif
+
+#ifdef USING_MEDIACODEC
+    if (!profiles.contains("MediaCodec Normal")) {
+        (void) QObject::tr("MediaCodec Normal",
+                           "Sample: MediaCodec Normal");
+        groupid = CreateProfileGroup("MediaCodec Normal", hostname);
+        CreateProfile(groupid, 1, "", "", "",
+                      "mediacodec", 4, true, "opengl",
+                      "opengl2", true,
+                      "none", "none",
+                      "");
+    }
+#endif
+
 }
 
 QStringList VideoDisplayProfile::GetVideoRenderers(const QString &decoder)

mythtv/libs/libmythtv/videoout_opengl.cpp

@@ -38 +38 @@
         (*opts.safe_renderers)["crystalhd"].append("opengl");
     if (opts.decoders->contains("openmax"))
         (*opts.safe_renderers)["openmax"].append("opengl");
+    if (opts.decoders->contains("mediacodec"))
+        (*opts.safe_renderers)["mediacodec"].append("opengl");
     opts.priorities->insert("opengl", 65);
 
     // lite profile - no colourspace control, GPU deinterlacing
@@ -268 +270 @@
         StopEmbedding();
     }
 
-    if (!codec_is_std(av_codec_id))
+    if (!codec_is_std(av_codec_id) && !codec_is_mediacodec(av_codec_id))
     {
         LOG(VB_GENERAL, LOG_ERR, LOC + "New video codec is not supported.");
         errorState = kError_Unknown;
@@ -417 +419 @@
                                   window.GetVideoDispDim(), dvr,
                                   window.GetDisplayVideoRect(),
                                   window.GetVideoRect(), true,
-                                  options, !codec_is_std(video_codec_id));
+                                  options, !codec_sw_copy(video_codec_id));
     if (success)
     {
         bool temp_deinterlacing = m_deinterlacing;
@@ -473 +475 @@
 bool VideoOutputOpenGL::CreateBuffers(void)
 {
     QMutexLocker locker(&gl_context_lock);
-    vbuffers.Init(31, true, 1, 12, 4, 2);
+    // vbuffers.Init(31, true, 1, 12, 4, 2);
+    vbuffers.Init(4, true, 1, 2, 2, 1);
     return vbuffers.CreateBuffers(FMT_YV12,
                                   window.GetVideoDim().width(),
                                   window.GetVideoDim().height());
@@ -525 +528 @@
         gl_valid = true;
     }
 
-    bool sw_frame = codec_is_std(video_codec_id) &&
+    bool sw_frame = codec_sw_copy(video_codec_id) &&
                     video_codec_id != kCodec_NONE;
     bool deint_proc = m_deinterlacing && (m_deintFilter != NULL);
     OpenGLLocker ctx_lock(gl_context);
@@ -735 +738 @@
     {
         list << "opengl" << "opengl-lite";
     }
+    else if (codec_is_mediacodec(myth_codec_id) && !getenv("NO_OPENGL"))
+    {
+        list << "opengl";
+    }
 
     return list;
 }