Ticket #13186: 006_more_avstream_codec.patch

mythtv/libs/libmyth/audio/audiooutputdigitalencoder.cpp

@@ -63 +63 @@
 void AudioOutputDigitalEncoder::Reset(void)
 {
     if (av_context)
-    {
-        avcodec_close(av_context);
-        av_freep(&av_context);
-    }
+        avcodec_free_context(&av_context);
+
     av_frame_free(&m_frame);
 
     delete m_spdifenc;
@@ -125 +123 @@
     }
 
     av_context                 = avcodec_alloc_context3(codec);
-    avcodec_get_context_defaults3(av_context, codec);
 
     av_context->bit_rate       = bitrate;
     av_context->sample_rate    = samplerate;

mythtv/libs/libmythtv/AirPlay/mythraopconnection.cpp

@@ -1686 +1686 @@
 {
     if (m_codeccontext)
     {
-        avcodec_close(m_codeccontext);
-        av_free(m_codeccontext);
+        avcodec_free_context(&m_codeccontext);
     }
     m_codec = NULL;
-    m_codeccontext = NULL;
 }
 
 bool MythRAOPConnection::OpenAudioDevice(void)

mythtv/libs/libmythtv/avformatwriter.cpp

@@ -256 +256 @@
     av_init_packet(&pkt);
     pkt.data = NULL;
     pkt.size = 0;
+    AVCodecContext *avctx = gCodecMap->getCodecContext(m_videoStream);
     {
         QMutexLocker locker(avcodeclock);
-        ret = avcodec_encode_video2(m_videoStream->codec, &pkt,
+        ret = avcodec_encode_video2(avctx, &pkt,
                                     m_picture, &got_pkt);
     }
 
@@ -326 +327 @@
 
     bool got_packet = false;
     int ret = 0;
+    AVCodecContext *avctx = gCodecMap->getCodecContext(m_audioStream);
     int samples_per_avframe  = m_audioFrameSize * m_audioChannels;
     int sampleSizeIn   = AudioOutputSettings::SampleSize(FORMAT_S16);
     AudioFormat format =
-        AudioOutputSettings::AVSampleFormatToFormat(m_audioStream->codec->sample_fmt);
+        AudioOutputSettings::AVSampleFormatToFormat(avctx->sample_fmt);
     int sampleSizeOut  = AudioOutputSettings::SampleSize(format);
 
     AVPacket pkt;
@@ -337 +339 @@
     pkt.data          = NULL;
     pkt.size          = 0;
 
-    if (av_get_packed_sample_fmt(m_audioStream->codec->sample_fmt) == AV_SAMPLE_FMT_FLT)
+    if (av_get_packed_sample_fmt(avctx->sample_fmt) == AV_SAMPLE_FMT_FLT)
     {
         AudioOutputUtil::toFloat(FORMAT_S16, (void *)m_audioInBuf, (void *)buf,
                                  samples_per_avframe * sampleSizeIn);
         buf = m_audioInBuf;
     }
-    if (av_sample_fmt_is_planar(m_audioStream->codec->sample_fmt))
+    if (av_sample_fmt_is_planar(avctx->sample_fmt))
     {
         AudioOutputUtil::DeinterleaveSamples(format,
                                              m_audioChannels,
@@ -364 +366 @@
 
     m_audPicture->linesize[0] = m_audioFrameSize;
     m_audPicture->nb_samples = m_audioFrameSize;
-    m_audPicture->format = m_audioStream->codec->sample_fmt;
+    m_audPicture->format = avctx->sample_fmt;
     m_audPicture->extended_data = m_audPicture->data;
 
     m_bufferedAudioFrameTimes.push_back(timecode);
@@ -376 +378 @@
         //  by 2 calls, this could be optimized
         //  into separate routines or separate threads.
         got_packet = false;
-        ret = avcodec_receive_packet(m_audioStream->codec, &pkt);
+        ret = avcodec_receive_packet(avctx, &pkt);
         if (ret == 0)
             got_packet = true;
         if (ret == AVERROR(EAGAIN))
             ret = 0;
         if (ret == 0)
-            ret = avcodec_send_frame(m_audioStream->codec, m_audPicture);
+            ret = avcodec_send_frame(avctx, m_audPicture);
         // if ret from avcodec_send_frame is AVERROR(EAGAIN) then
         // there are 2 packets to be received while only 1 frame to be
         // sent. The code does not cater for this. Hopefully it will not happen.
@@ -466 +468 @@
     }
     st->id = 0;
 
-    c = st->codec;
 
     codec = avcodec_find_encoder(m_ctx->oformat->video_codec);
     if (!codec)
@@ -476 +477 @@
         return NULL;
     }
 
-    avcodec_get_context_defaults3(c, codec);
+    gCodecMap->freeCodecContext(st);
+    c = gCodecMap->getCodecContext(st, codec);
 
     c->codec                      = codec;
     c->codec_id                   = m_ctx->oformat->video_codec;
@@ -576 +578 @@
 {
     AVCodecContext *c;
 
-    c = m_videoStream->codec;
+    c = gCodecMap->getCodecContext(m_videoStream);
 
     if (!m_width || !m_height)
         return false;
@@ -620 +622 @@
     }
     st->id = 1;
 
-    c = st->codec;
+    c = gCodecMap->getCodecContext(st, NULL, true);
+
     c->codec_id     = m_ctx->oformat->audio_codec;
     c->codec_type   = AVMEDIA_TYPE_AUDIO;
     c->bit_rate     = m_audioBitrate;
@@ -664 +667 @@
     AVCodecContext *c;
     AVCodec *codec;
 
-    c = m_audioStream->codec;
+    c = gCodecMap->getCodecContext(m_audioStream);
 
     c->strict_std_compliance = FF_COMPLIANCE_EXPERIMENTAL;
 

mythtv/libs/libmythtv/mhi.cpp

@@ -1970 +1970 @@
 Close:
     pkt.data = buff;
     av_packet_unref(&pkt);
-    avcodec_close(c);
-    av_free(c);
+    avcodec_free_context(&c);
 }
 
 // Scale the bitmap.  Only used for image derived from MPEG I-frames.

mythtv/libs/libmythtv/mythavutil.cpp

@@ -389 +389 @@
     freeAllCodecContexts();
 }
 
-AVCodecContext *MythCodecMap::getCodecContext(const AVStream *stream, const AVCodec *pCodec)
+AVCodecContext *MythCodecMap::getCodecContext(const AVStream *stream,
+    const AVCodec *pCodec, bool nullCodec)
 {
     QMutexLocker lock(&mapLock);
     AVCodecContext *avctx = streamMap.value(stream, NULL);
@@ -397 +398 @@
     {
         if (stream == NULL || stream->codecpar == NULL)
             return NULL;
-        if (!pCodec)
-            pCodec = avcodec_find_decoder(stream->codecpar->codec_id);
-        if (!pCodec)
+        if (nullCodec)
+            pCodec = NULL;
+        else
         {
-            LOG(VB_GENERAL, LOG_WARNING,
-                QString("avcodec_find_decoder fail for %1").arg(stream->codecpar->codec_id));
-            return NULL;
+            if (!pCodec)
+                pCodec = avcodec_find_decoder(stream->codecpar->codec_id);
+            if (!pCodec)
+            {
+                LOG(VB_GENERAL, LOG_WARNING,
+                    QString("avcodec_find_decoder fail for %1").arg(stream->codecpar->codec_id));
+                return NULL;
+            }
         }
         avctx = avcodec_alloc_context3(pCodec);
-        if (avcodec_parameters_to_context(avctx, stream->codecpar) != NULL)
+        if (avcodec_parameters_to_context(avctx, stream->codecpar) < 0)
             avcodec_free_context(&avctx);
         if (avctx)
         {

mythtv/libs/libmythtv/mythavutil.h

@@ -92 +92 @@
     MythCodecMap();
     ~MythCodecMap();
     static MythCodecMap *getInstance();
-    AVCodecContext *getCodecContext(const AVStream*,  const AVCodec *pCodec = NULL);
+    AVCodecContext *getCodecContext(const AVStream*,
+        const AVCodec *pCodec = NULL, bool nullCodec = false);
     AVCodecContext *hasCodecContext(const AVStream*);
     void freeCodecContext(const AVStream*);
     void freeAllCodecContexts();

mythtv/libs/libmythtv/nuppeldecoder.cpp

@@ -702 +702 @@
         directrendering = true;
 
     if (mpa_vidctx)
-        av_free(mpa_vidctx);
+        avcodec_free_context(&mpa_vidctx);
 
     mpa_vidctx = avcodec_alloc_context3(NULL);
 
@@ -742 +742 @@
 {
     QMutexLocker locker(avcodeclock);
 
-    if (mpa_vidcodec)
-    {
-        avcodec_close(mpa_vidctx);
-
-        if (mpa_vidctx)
-        {
-            av_free(mpa_vidctx);
-            mpa_vidctx = NULL;
-        }
-    }
+    if (mpa_vidcodec && mpa_vidctx)
+        avcodec_free_context(&mpa_vidctx);
 }
 
 bool NuppelDecoder::InitAVCodecAudio(int codec)
@@ -781 +773 @@
     }
 
     if (mpa_audctx)
-        av_free(mpa_audctx);
+        avcodec_free_context(&mpa_audctx);
 
     mpa_audctx = avcodec_alloc_context3(NULL);
 
@@ -802 +794 @@
 {
     QMutexLocker locker(avcodeclock);
 
-    if (mpa_audcodec)
-    {
-        avcodec_close(mpa_audctx);
-
-        if (mpa_audctx)
-        {
-            av_free(mpa_audctx);
-            mpa_audctx = NULL;
-        }
-    }
+    if (mpa_audcodec && mpa_audctx)
+        avcodec_free_context(&mpa_audctx);
 }
 
 static void CopyToVideo(unsigned char *buf, int video_width,

mythtv/libs/libmythtv/privatedecoder_crystalhd.cpp

@@ -1 +1 @@
 #include "privatedecoder_crystalhd.h"
 #include "mythlogging.h"
+#include "mythavutil.h"
 #include "fourcc.h"
 #include "unistd.h"
 
@@ -424 +425 @@
 int PrivateDecoderCrystalHD::ProcessPacket(AVStream *stream, AVPacket *pkt)
 {
     int result = -1;
-    AVCodecContext *avctx = stream->codec;
+    AVCodecContext *avctx = gCodecMap->getCodecContext(stream);
     if (!avctx)
         return result;
 
@@ -516 +517 @@
     if (!stream || !m_device || !picture)
         return result;
 
-    AVCodecContext *avctx = stream->codec;
+    AVCodecContext *avctx = gCodecMap->getCodecContext(stream);
+
     if (!avctx || !StartFetcherThread())
         return result;
 

mythtv/libs/libmythtv/privatedecoder_vda.cpp

@@ -6 +6 @@
 #define ERR QString("VDADec error: ")
 
 #include "mythframe.h"
+#include "mythavutil.h"
 #include "util-osx-cocoa.h"
 #include "privatedecoder_vda.h"
 #include "util-osx.h"
@@ -550 +551 @@
     if (!m_lib || !stream)
         return result;
 
-    AVCodecContext *avctx = stream->codec;
+    AVCodecContext *avctx = gCodecMap->getCodecContext(stream);
     if (!avctx)
         return result;
 

mythtv/libs/libmythtv/recorders/NuppelVideoRecorder.cpp

@@ -270 +270 @@
     if (mpa_vidcodec)
     {
         QMutexLocker locker(avcodeclock);
-        avcodec_close(mpa_vidctx);
+        avcodec_free_context(&mpa_vidctx);
     }
 
-    if (mpa_vidctx)
-        av_free(mpa_vidctx);
-    mpa_vidctx = NULL;
-
     if (videoFilters)
         delete videoFilters;
     if (FiltMan)
@@ -525 +521 @@
     if (mpa_vidcodec)
     {
         QMutexLocker locker(avcodeclock);
-        avcodec_close(mpa_vidctx);
+        avcodec_free_context(&mpa_vidctx);
     }
 
-    if (mpa_vidctx)
-        av_free(mpa_vidctx);
-    mpa_vidctx = NULL;
-
     QByteArray vcodec = videocodec.toLatin1();
     mpa_vidcodec = avcodec_find_encoder_by_name(vcodec.constData());
 

mythtv/programs/mythtranscode/external/replex/replex.c

@@ -218 +218 @@
                     "frame size (%d) does not equal required size (%d)?",
                         out_size, bufsize);
                 free(samples);
-                avcodec_close(c);
-                av_free(c);
+                avcodec_free_context(&c);
                 return 1;
         }
 
         free(samples);
-        avcodec_close(c);
-        av_free(c);
+        avcodec_free_context(&c);
         
         return 0;
 }

mythtv/programs/mythtranscode/mpeg2fix.cpp

@@ -874 +874 @@
 
     for (unsigned int i = 0; i < inputFC->nb_streams; i++)
     {
-        switch (inputFC->streams[i]->codec->codec_type)
+        switch (inputFC->streams[i]->codecpar->codec_type)
         {
             case AVMEDIA_TYPE_VIDEO:
                 if (vid_id == -1)
@@ -883 +883 @@
 
             case AVMEDIA_TYPE_AUDIO:
                 if (!allaudio && ext_count > 0 &&
-                    inputFC->streams[i]->codec->channels < 2 &&
-                    inputFC->streams[i]->codec->sample_rate < 100000)
+                    inputFC->streams[i]->codecpar->channels < 2 &&
+                    inputFC->streams[i]->codecpar->sample_rate < 100000)
                 {
                     LOG(VB_GENERAL, LOG_ERR,
                         QString("Skipping audio stream: %1").arg(i));
                     break;
                 }
-                if (inputFC->streams[i]->codec->codec_id == AV_CODEC_ID_AC3 ||
-                    inputFC->streams[i]->codec->codec_id == AV_CODEC_ID_MP3 ||
-                    inputFC->streams[i]->codec->codec_id == AV_CODEC_ID_MP2)
+                if (inputFC->streams[i]->codecpar->codec_id == AV_CODEC_ID_AC3 ||
+                    inputFC->streams[i]->codecpar->codec_id == AV_CODEC_ID_MP3 ||
+                    inputFC->streams[i]->codecpar->codec_id == AV_CODEC_ID_MP2)
                 {
                     aud_map[i] = ext_count++;
                     aFrame[i] = new FrameList();
@@ -900 +900 @@
                 else
                     LOG(VB_GENERAL, LOG_ERR,
                         QString("Skipping unsupported audio stream: %1")
-                            .arg(inputFC->streams[i]->codec->codec_id));
+                            .arg(inputFC->streams[i]->codecpar->codec_id));
                 break;
             default:
                 LOG(VB_GENERAL, LOG_ERR,
                     QString("Skipping unsupported codec %1 on stream %2")
-                        .arg(inputFC->streams[i]->codec->codec_type).arg(i));
+                        .arg(inputFC->streams[i]->codecpar->codec_type).arg(i));
                 break;
         }
     }
@@ -1328 +1328 @@
     SetRepeat(pkt->data, pkt->size, info->display_picture->nb_fields,
               !!(info->display_picture->flags & PIC_FLAG_TOP_FIELD_FIRST));
 
-    avcodec_close(c);
-    av_freep(&c);
+    avcodec_free_context(&c);
 
     return false;
 }
@@ -1458 +1457 @@
             return 1;
         }
 
-        switch (inputFC->streams[pkt->stream_index]->codec->codec_type)
+        switch (inputFC->streams[pkt->stream_index]->codecpar->codec_type)
         {
             case AVMEDIA_TYPE_VIDEO:
                 vFrame.append(tmpFrame);

mythtv/programs/mythutil/musicmetautils.cpp

@@ -275 +275 @@
         AVStream *st = inputFC->streams[i];
         char buf[256];
 
-        avcodec_string(buf, sizeof(buf), st->codec, false);
+        const AVCodec *pCodec = avcodec_find_decoder(st->codecpar->codec_id);
+        if (!pCodec)
+        {
+            LOG(VB_GENERAL, LOG_WARNING,
+                QString("avcodec_find_decoder fail for %1").arg(st->codecpar->codec_id));
+            continue;
+        }
+        AVCodecContext *avctx = avcodec_alloc_context3(pCodec);
+        avcodec_parameters_to_context(avctx, st->codecpar);
+        av_codec_set_pkt_timebase(avctx, st->time_base);
+
+        avcodec_string(buf, sizeof(buf), avctx, false);
 
-        switch (inputFC->streams[i]->codec->codec_type)
+        switch (inputFC->streams[i]->codecpar->codec_type)
         {
             case AVMEDIA_TYPE_AUDIO:
             {
@@ -299 +310 @@
             default:
                 LOG(VB_GENERAL, LOG_ERR,
                     QString("Skipping unsupported codec %1 on stream %2")
-                        .arg(inputFC->streams[i]->codec->codec_type).arg(i));
+                        .arg(inputFC->streams[i]->codecpar->codec_type).arg(i));
                 break;
         }
+        avcodec_free_context(&avctx);
     }
 
     // Close input file