Ticket #13186: 005_avstream_codec_avformatdecoder.patch

File 005_avstream_codec_avformatdecoder.patch, 37.9 KB (added by Peter Bennett, 3 years ago)

Updated Patch 005 - AVStream::codec in avformatdecoder

  • mythtv/libs/libmythtv/DVD/avformatdecoderdvd.cpp

    diff --git a/mythtv/libs/libmythtv/DVD/avformatdecoderdvd.cpp b/mythtv/libs/libmythtv/DVD/avformatdecoderdvd.cpp
    index 3d11076..f182bf2 100644
    a b int AvFormatDecoderDVD::ReadPacket(AVFormatContext *ctx, AVPacket* pkt, bool& st 
    196196
    197197                    AVStream *curstream = ic->streams[pkt->stream_index];
    198198
    199                     if ((curstream->codec->codec_type == AVMEDIA_TYPE_VIDEO) ||
    200                         (curstream->codec->codec_id == AV_CODEC_ID_DVD_NAV))
     199                    if ((curstream->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) ||
     200                        (curstream->codecpar->codec_id == AV_CODEC_ID_DVD_NAV))
    201201                    {
    202202                        // Allow video or NAV packets through
    203203                        gotPacket = true;
    bool AvFormatDecoderDVD::ProcessDataPacket(AVStream *curstream, AVPacket *pkt, 
    371371{
    372372    bool ret = true;
    373373
    374     if (curstream->codec->codec_id == AV_CODEC_ID_DVD_NAV)
     374    if (curstream->codecpar->codec_id == AV_CODEC_ID_DVD_NAV)
    375375    {
    376376        MythDVDContext* context = ringBuffer->DVD()->GetDVDContext();
    377377
  • mythtv/libs/libmythtv/avformatdecoder.cpp

    diff --git a/mythtv/libs/libmythtv/avformatdecoder.cpp b/mythtv/libs/libmythtv/avformatdecoder.cpp
    index baa6e88..e24be3e 100644
    a b static int determinable_frame_size(struct AVCodecContext *avctx) 
    184184
    185185static int has_codec_parameters(AVStream *st)
    186186{
    187     AVCodecContext *avctx = st->codec;
     187    AVCodecContext *avctx = NULL;
    188188
    189189#define FAIL(errmsg) do {                                     \
    190190    LOG(VB_PLAYBACK, LOG_DEBUG, LOC + errmsg);                \
    191191    return 0;                                                 \
    192192} while (0)
    193193
    194     switch (avctx->codec_type)
     194    switch (st->codecpar->codec_type)
    195195    {
    196196        case AVMEDIA_TYPE_AUDIO:
     197            avctx = gCodecMap->getCodecContext(st);
     198            if (!avctx)
     199                FAIL("No codec for audio stream");
    197200            if (!avctx->frame_size && determinable_frame_size(avctx))
    198201                FAIL("unspecified frame size");
    199202            if (avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
    static int has_codec_parameters(AVStream *st) 
    206209                FAIL("no decodable DTS frames");
    207210            break;
    208211        case AVMEDIA_TYPE_VIDEO:
     212            avctx = gCodecMap->getCodecContext(st);
     213            if (!avctx)
     214                FAIL("No codec for video stream");
    209215            if (!avctx->width)
    210216                FAIL("unspecified size");
    211217            if (avctx->pix_fmt == AV_PIX_FMT_NONE)
    212218                FAIL("unspecified pixel format");
    213             if (st->codec->codec_id == AV_CODEC_ID_RV30 || st->codec->codec_id == AV_CODEC_ID_RV40)
    214                 if (!st->sample_aspect_ratio.num && !st->codec->sample_aspect_ratio.num && !st->codec_info_nb_frames)
    215                     FAIL("no frame in rv30/40 and no sar");
     219            if (avctx->codec_id == AV_CODEC_ID_RV30 || avctx->codec_id == AV_CODEC_ID_RV40)
     220            if (!st->sample_aspect_ratio.num && !avctx->sample_aspect_ratio.num && !st->codec_info_nb_frames)
     221            FAIL("no frame in rv30/40 and no sar");
    216222            break;
    217223        case AVMEDIA_TYPE_SUBTITLE:
    218             if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
     224            if (st->codecpar->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !st->codecpar->width)
    219225                FAIL("unspecified size");
    220226            break;
    221227        case AVMEDIA_TYPE_DATA:
    222             if(avctx->codec_id == AV_CODEC_ID_NONE) return 1;
    223             [[clang::fallthrough]];
     228            if(st->codecpar->codec_id == AV_CODEC_ID_NONE) return 1;
     229            break;
    224230        default:
    225231            break;
    226232    }
    227233
    228     if (avctx->codec_id == AV_CODEC_ID_NONE)
     234    if (st->codecpar->codec_id == AV_CODEC_ID_NONE)
    229235        FAIL("unknown codec");
    230236    return 1;
    231237}
    void AvFormatDecoder::CloseCodecs() 
    479485        {
    480486            QMutexLocker locker(avcodeclock);
    481487            AVStream *st = ic->streams[i];
    482             if (st->codec->codec)
    483                 avcodec_close(st->codec);
     488            gCodecMap->freeCodecContext(st);
    484489        }
    485490    }
    486491}
    int64_t AvFormatDecoder::NormalizeVideoTimecode(int64_t timecode) 
    520525    for (uint i = 0; i < ic->nb_streams; i++)
    521526    {
    522527        AVStream *st1 = ic->streams[i];
    523         if (st1 && st1->codec->codec_type == AVMEDIA_TYPE_VIDEO)
     528        if (st1 && st1->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
    524529        {
    525530            st = st1;
    526531            break;
    bool AvFormatDecoder::DoFastForward(long long desiredFrame, bool discardFrames) 
    659664    for (uint i = 0; i < ic->nb_streams; i++)
    660665    {
    661666        AVStream *st1 = ic->streams[i];
    662         if (st1 && st1->codec->codec_type == AVMEDIA_TYPE_VIDEO)
     667        if (st1 && st1->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
    663668        {
    664669            st = st1;
    665670            break;
    void AvFormatDecoder::SeekReset(long long newKey, uint skipFrames, 
    802807        LOG(VB_PLAYBACK, LOG_INFO, LOC + "SeekReset() flushing");
    803808        for (uint i = 0; i < ic->nb_streams; i++)
    804809        {
    805             AVCodecContext *enc = ic->streams[i]->codec;
    806             if (enc->codec)
     810            AVCodecContext *enc = gCodecMap->hasCodecContext(ic->streams[i]);
     811            if (enc)
    807812                avcodec_flush_buffers(enc);
    808813        }
    809814        if (private_dec)
    int AvFormatDecoder::ScanStreams(bool novideo) 
    20502055
    20512056    for (uint i = 0; i < ic->nb_streams; i++)
    20522057    {
    2053         AVCodecContext *enc = ic->streams[i]->codec;
     2058        AVCodecParameters *par = ic->streams[i]->codecpar;
     2059        AVCodecContext *enc = NULL;
     2060
    20542061        LOG(VB_PLAYBACK, LOG_INFO, LOC +
    20552062            QString("Stream #%1, has id 0x%2 codec id %3, "
    20562063                    "type %4, bitrate %5 at 0x%6")
    20572064                .arg(i).arg((uint64_t)ic->streams[i]->id,0,16)
    2058                 .arg(ff_codec_id_string(enc->codec_id))
    2059                 .arg(ff_codec_type_string(enc->codec_type))
    2060                 .arg(enc->bit_rate).arg((uint64_t)ic->streams[i],0,16));
     2065                .arg(ff_codec_id_string(par->codec_id))
     2066                .arg(ff_codec_type_string(par->codec_type))
     2067                .arg(par->bit_rate).arg((uint64_t)ic->streams[i],0,16));
    20612068
    2062         switch (enc->codec_type)
     2069        switch (par->codec_type)
    20632070        {
    20642071            case AVMEDIA_TYPE_VIDEO:
    20652072            {
    2066                 //assert(enc->codec_id);
    2067                 if (!enc->codec_id)
     2073                if (!par->codec_id)
    20682074                {
    20692075                    LOG(VB_GENERAL, LOG_ERR, LOC +
    20702076                        QString("Stream #%1 has an unknown video "
    int AvFormatDecoder::ScanStreams(bool novideo) 
    20752081                // ffmpeg does not return a bitrate for several codecs and
    20762082                // formats. Forcing it to 500000 ensures the ringbuffer does not
    20772083                // use optimisations for low bitrate (audio and data) streams.
    2078                 if (enc->bit_rate == 0)
     2084                if (par->bit_rate == 0)
    20792085                {
    2080                     enc->bit_rate = 500000;
     2086                    par->bit_rate = 500000;
    20812087                    unknownbitrate = true;
    20822088                }
    2083                 bitrate += enc->bit_rate;
     2089                bitrate += par->bit_rate;
    20842090
    20852091                break;
    20862092            }
    20872093            case AVMEDIA_TYPE_AUDIO:
    20882094            {
    2089                 if (enc->codec)
     2095                enc = gCodecMap->hasCodecContext(ic->streams[i]);
     2096                if (enc)
    20902097                {
    20912098                    LOG(VB_GENERAL, LOG_WARNING, LOC +
    20922099                        QString("Warning, audio codec 0x%1 id(%2) "
    int AvFormatDecoder::ScanStreams(bool novideo) 
    20952102                            .arg(ff_codec_id_string(enc->codec_id))
    20962103                            .arg(ff_codec_type_string(enc->codec_type)));
    20972104                }
    2098                 //assert(enc->codec_id);
    20992105                LOG(VB_GENERAL, LOG_INFO, LOC +
    21002106                    QString("codec %1 has %2 channels")
    2101                         .arg(ff_codec_id_string(enc->codec_id))
    2102                         .arg(enc->channels));
     2107                        .arg(ff_codec_id_string(par->codec_id))
     2108                        .arg(par->channels));
    21032109
    2104                 bitrate += enc->bit_rate;
     2110                bitrate += par->bit_rate;
    21052111                break;
    21062112            }
    21072113            case AVMEDIA_TYPE_SUBTITLE:
    21082114            {
    2109                 if (enc->codec_id == AV_CODEC_ID_DVB_TELETEXT)
     2115                if (par->codec_id == AV_CODEC_ID_DVB_TELETEXT)
    21102116                    ScanTeletextCaptions(i);
    2111                 if (enc->codec_id == AV_CODEC_ID_TEXT)
     2117                if (par->codec_id == AV_CODEC_ID_TEXT)
    21122118                    ScanRawTextCaptions(i);
    2113                 bitrate += enc->bit_rate;
     2119                bitrate += par->bit_rate;
    21142120
    21152121                LOG(VB_PLAYBACK, LOG_INFO, LOC + QString("subtitle codec (%1)")
    2116                         .arg(ff_codec_type_string(enc->codec_type)));
     2122                        .arg(ff_codec_type_string(par->codec_type)));
    21172123                break;
    21182124            }
    21192125            case AVMEDIA_TYPE_DATA:
    21202126            {
    21212127                ScanTeletextCaptions(i);
    2122                 bitrate += enc->bit_rate;
     2128                bitrate += par->bit_rate;
    21232129                LOG(VB_PLAYBACK, LOG_INFO, LOC + QString("data codec (%1)")
    2124                         .arg(ff_codec_type_string(enc->codec_type)));
     2130                        .arg(ff_codec_type_string(par->codec_type)));
    21252131                break;
    21262132            }
    21272133            case AVMEDIA_TYPE_ATTACHMENT:
    21282134            {
    2129                 if (enc->codec_id == AV_CODEC_ID_TTF)
     2135                if (par->codec_id == AV_CODEC_ID_TTF)
    21302136                   tracks[kTrackTypeAttachment].push_back(
    21312137                       StreamInfo(i, 0, 0, ic->streams[i]->id, 0));
    2132                 bitrate += enc->bit_rate;
     2138                bitrate += par->bit_rate;
    21332139                LOG(VB_PLAYBACK, LOG_INFO, LOC +
    21342140                    QString("Attachment codec (%1)")
    2135                         .arg(ff_codec_type_string(enc->codec_type)));
     2141                        .arg(ff_codec_type_string(par->codec_type)));
    21362142                break;
    21372143            }
    21382144            default:
    21392145            {
    2140                 bitrate += enc->bit_rate;
     2146                bitrate += par->bit_rate;
    21412147                LOG(VB_PLAYBACK, LOG_ERR, LOC +
    21422148                    QString("Unknown codec type (%1)")
    2143                         .arg(ff_codec_type_string(enc->codec_type)));
     2149                        .arg(ff_codec_type_string(par->codec_type)));
    21442150                break;
    21452151            }
    21462152        }
    21472153
    2148         if (enc->codec_type != AVMEDIA_TYPE_AUDIO &&
    2149             enc->codec_type != AVMEDIA_TYPE_SUBTITLE)
     2154        if (par->codec_type != AVMEDIA_TYPE_AUDIO &&
     2155            par->codec_type != AVMEDIA_TYPE_SUBTITLE)
    21502156            continue;
    21512157
    21522158        // skip DVB teletext and text subs, there is no libavcodec decoder
    2153         if (enc->codec_type == AVMEDIA_TYPE_SUBTITLE &&
    2154            (enc->codec_id   == AV_CODEC_ID_DVB_TELETEXT ||
    2155             enc->codec_id   == AV_CODEC_ID_TEXT))
     2159        if (par->codec_type == AVMEDIA_TYPE_SUBTITLE &&
     2160           (par->codec_id   == AV_CODEC_ID_DVB_TELETEXT ||
     2161            par->codec_id   == AV_CODEC_ID_TEXT))
    21562162            continue;
    21572163
    21582164        LOG(VB_PLAYBACK, LOG_INFO, LOC + QString("Looking for decoder for %1")
    2159                 .arg(ff_codec_id_string(enc->codec_id)));
     2165                .arg(ff_codec_id_string(par->codec_id)));
    21602166
    2161         if (enc->codec_id == AV_CODEC_ID_PROBE)
     2167        if (par->codec_id == AV_CODEC_ID_PROBE)
    21622168        {
    21632169            LOG(VB_GENERAL, LOG_ERR, LOC +
    21642170                QString("Probing of stream #%1 unsuccesful, ignoring.").arg(i));
    21652171            continue;
    21662172        }
    21672173
    2168         AVCodec *codec = avcodec_find_decoder(enc->codec_id);
    2169         if (!codec)
     2174        if (!enc)
     2175            enc = gCodecMap->getCodecContext(ic->streams[i]);
     2176
     2177        const AVCodec *codec = NULL;
     2178        if (enc)
     2179            codec = enc->codec;
     2180        else
    21702181        {
    21712182            LOG(VB_GENERAL, LOG_ERR, LOC +
    21722183                QString("Could not find decoder for codec (%1), ignoring.")
    2173                     .arg(ff_codec_id_string(enc->codec_id)));
     2184                    .arg(ff_codec_id_string(par->codec_id)));
    21742185
    21752186            // Nigel's bogus codec-debug. Dump the list of codecs & decoders,
    21762187            // and have one last attempt to find a decoder. This is usually
    int AvFormatDecoder::ScanStreams(bool novideo) 
    21932204
    21942205                    LOG(VB_LIBAV, LOG_INFO, LOC + msg);
    21952206
    2196                     if (p->id == enc->codec_id)
     2207                    if (p->id == par->codec_id)
    21972208                    {
    21982209                        codec = p;
    21992210                        break;
    int AvFormatDecoder::ScanStreams(bool novideo) 
    22012212
    22022213                    LOG(VB_LIBAV, LOG_INFO, LOC +
    22032214                        QString("Codec 0x%1 != 0x%2") .arg(p->id, 0, 16)
    2204                             .arg(enc->codec_id, 0, 16));
     2215                            .arg(par->codec_id, 0, 16));
    22052216                    p = av_codec_next(p);
    22062217                    ++i;
    22072218                }
    22082219            }
    2209             if (!codec)
     2220            if (codec)
     2221                enc = gCodecMap->getCodecContext(ic->streams[i], codec);
     2222            else
    22102223                continue;
    22112224        }
     2225        if (!enc)
     2226            continue;
    22122227
    2213         if (enc->codec && enc->codec->id != enc->codec_id)
     2228        if (enc->codec && par->codec_id != enc->codec_id)
    22142229        {
    22152230            LOG(VB_PLAYBACK, LOG_INFO, LOC +
    22162231                QString("Already opened codec not matching (%1 vs %2). Reopening")
    22172232                .arg(ff_codec_id_string(enc->codec_id))
    22182233                .arg(ff_codec_id_string(enc->codec->id)));
    2219             avcodec_close(enc);
    2220         }
    2221 
    2222         if (!enc->codec)
    2223         {
    2224             if (!OpenAVCodec(enc, codec))
    2225                 continue;
     2234            gCodecMap->freeCodecContext(ic->streams[i]);
     2235            enc = gCodecMap->getCodecContext(ic->streams[i]);
    22262236        }
     2237        if (!OpenAVCodec(enc, codec))
     2238            continue;
     2239        if (!enc)
     2240            continue;
    22272241
    22282242        if (!IsValidStream(ic->streams[i]->id))
    22292243        {
    int AvFormatDecoder::ScanStreams(bool novideo) 
    22382252            continue;
    22392253        }
    22402254
    2241         if (enc->codec_type == AVMEDIA_TYPE_SUBTITLE)
     2255        if (par->codec_type == AVMEDIA_TYPE_SUBTITLE)
    22422256        {
    22432257            bool forced = ic->streams[i]->disposition & AV_DISPOSITION_FORCED;
    22442258            int lang = GetSubtitleLanguage(subtitleStreamCount, i);
    int AvFormatDecoder::ScanStreams(bool novideo) 
    22552269                    .arg(iso639_key_toName(lang)).arg(lang));
    22562270        }
    22572271
    2258         if (enc->codec_type == AVMEDIA_TYPE_AUDIO)
     2272        if (par->codec_type == AVMEDIA_TYPE_AUDIO)
    22592273        {
    22602274            int lang = GetAudioLanguage(audioStreamCount, i);
    22612275            AudioTrackType type = GetAudioTrackType(i);
    2262             int channels  = ic->streams[i]->codec->channels;
     2276            int channels  = par->channels;
    22632277            int lang_indx = lang_aud_cnt[lang]++;
    22642278            audioStreamCount++;
    22652279
    2266             if (ic->streams[i]->codec->avcodec_dual_language)
     2280            if (enc->avcodec_dual_language)
    22672281            {
    22682282                tracks[kTrackTypeAudio].push_back(
    22692283                    StreamInfo(i, lang, lang_indx, ic->streams[i]->id, channels,
    int AvFormatDecoder::ScanStreams(bool novideo) 
    23352349                break;
    23362350            }
    23372351
    2338             AVCodecContext *enc = ic->streams[selTrack]->codec;
     2352            AVCodecContext *enc = gCodecMap->getCodecContext(ic->streams[selTrack]);
    23392353            StreamInfo si(selTrack, 0, 0, 0, 0);
    23402354
    23412355            tracks[kTrackTypeVideo].push_back(si);
    int AvFormatDecoder::ScanStreams(bool novideo) 
    24732487                codec = avcodec_find_decoder(enc->codec_id);
    24742488            }
    24752489
    2476             if (enc->codec)
    2477             {
    2478                 LOG(VB_GENERAL, LOG_WARNING, LOC +
    2479                     QString("Warning, video codec 0x%1 id(%2) type (%3) "
    2480                             "already open.")
    2481                     .arg((uint64_t)enc,0,16)
    2482                     .arg(ff_codec_id_string(enc->codec_id))
    2483                     .arg(ff_codec_type_string(enc->codec_type)));
    2484             }
    2485 
    24862490            // Use a PrivateDecoder if allowed in playerFlags AND matched
    24872491            // via the decoder name
    24882492            private_dec = PrivateDecoder::Create(dec, playerFlags, enc);
    int AvFormatDecoder::ScanStreams(bool novideo) 
    25112515                QString("Using %1 for video decoding")
    25122516                .arg(GetCodecDecoderName()));
    25132517
    2514             if (!enc->codec)
    25152518            {
    25162519                QMutexLocker locker(avcodeclock);
    25172520
    void AvFormatDecoder::RemoveAudioStreams() 
    28052808    for (uint i = 0; i < ic->nb_streams;)
    28062809    {
    28072810        AVStream *st = ic->streams[i];
    2808         if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
     2811        AVCodecContext *avctx = gCodecMap->hasCodecContext(st);
     2812        if (avctx && avctx->codec_type == AVMEDIA_TYPE_AUDIO)
    28092813        {
     2814            gCodecMap->freeCodecContext(st);
    28102815            av_remove_stream(ic, st->id, 0);
    28112816            i--;
    28122817        }
    void AvFormatDecoder::HandleGopStart( 
    32683273
    32693274void AvFormatDecoder::MpegPreProcessPkt(AVStream *stream, AVPacket *pkt)
    32703275{
    3271     AVCodecContext *context = stream->codec;
     3276    AVCodecContext *context = gCodecMap->getCodecContext(stream);
    32723277    const uint8_t *bufptr = pkt->data;
    32733278    const uint8_t *bufend = pkt->data + pkt->size;
    32743279
    void AvFormatDecoder::MpegPreProcessPkt(AVStream *stream, AVPacket *pkt) 
    33553360// Returns the number of frame starts identified in the packet.
    33563361int AvFormatDecoder::H264PreProcessPkt(AVStream *stream, AVPacket *pkt)
    33573362{
    3358     AVCodecContext *context = stream->codec;
     3363    AVCodecContext *context = gCodecMap->getCodecContext(stream);
    33593364    const uint8_t  *buf     = pkt->data;
    33603365    const uint8_t  *buf_end = pkt->data + pkt->size;
    33613366    int num_frames = 0;
    int AvFormatDecoder::H264PreProcessPkt(AVStream *stream, AVPacket *pkt) 
    34523457            bool do_it = HAVE_THREADS && res_changed;
    34533458            for (uint i = 0; do_it && (i < ic->nb_streams); i++)
    34543459            {
    3455                 AVCodecContext *enc = ic->streams[i]->codec;
     3460                AVCodecContext *enc = gCodecMap->getCodecContext(ic->streams[i]);
    34563461                if ((AVMEDIA_TYPE_VIDEO == enc->codec_type) &&
    34573462                    (kCodec_H264 == video_codec_id) &&
    34583463                    (enc->codec) && (enc->thread_count>1))
    int AvFormatDecoder::H264PreProcessPkt(AVStream *stream, AVPacket *pkt) 
    34603465                    QMutexLocker locker(avcodeclock);
    34613466                    // flush all buffers
    34623467                    avcodec_flush_buffers(enc);
    3463                     const AVCodec *codec = enc->codec;
    3464                     avcodec_close(enc);
    3465                     int open_val = avcodec_open2(enc, codec, NULL);
     3468                    gCodecMap->freeCodecContext(ic->streams[i]);
     3469                    enc = gCodecMap->getCodecContext(ic->streams[i]);
     3470                    int open_val = avcodec_open2(enc, enc->codec, NULL);
    34663471                    if (open_val < 0)
    34673472                    {
    34683473                        LOG(VB_GENERAL, LOG_ERR, LOC +
    int AvFormatDecoder::H264PreProcessPkt(AVStream *stream, AVPacket *pkt) 
    34973502
    34983503bool AvFormatDecoder::PreProcessVideoPacket(AVStream *curstream, AVPacket *pkt)
    34993504{
    3500     AVCodecContext *context = curstream->codec;
     3505    AVCodecContext *context = gCodecMap->getCodecContext(curstream);
    35013506    int num_frames = 1;
    35023507
    35033508    if (CODEC_IS_FFMPEG_MPEG(context->codec_id))
    bool AvFormatDecoder::ProcessVideoPacket(AVStream *curstream, AVPacket *pkt) 
    35583563{
    35593564    int ret = 0, gotpicture = 0;
    35603565    int64_t pts = 0;
    3561     AVCodecContext *context = curstream->codec;
     3566    AVCodecContext *context = gCodecMap->getCodecContext(curstream);
    35623567    MythAVFrame mpa_pic;
    35633568    if (!mpa_pic)
    35643569    {
    bool AvFormatDecoder::ProcessVideoPacket(AVStream *curstream, AVPacket *pkt) 
    36823687
    36833688bool AvFormatDecoder::ProcessVideoFrame(AVStream *stream, AVFrame *mpa_pic)
    36843689{
    3685     AVCodecContext *context = stream->codec;
     3690    AVCodecContext *context = gCodecMap->getCodecContext(stream);
    36863691
    36873692    // We need to mediate between ATSC and SCTE data when both are present.  If
    36883693    // both are present, we generally want to prefer ATSC.  However, there may
    void AvFormatDecoder::ProcessDSMCCPacket( 
    39733978    {
    39743979        QMutexLocker locker(avcodeclock);
    39753980        componentTag    = str->component_tag;
     3981        // DEPRECATED need to get rid of str->codec
    39763982        dataBroadcastId = str->codec->flags;
    39773983        carouselId      = (unsigned) str->codec->sub_id;
    39783984    }
    bool AvFormatDecoder::ProcessSubtitlePacket(AVStream *curstream, AVPacket *pkt) 
    40304036    }
    40314037    else if (decodeAllSubtitles || pkt->stream_index == subIdx)
    40324038    {
     4039        AVCodecContext *ctx = gCodecMap->getCodecContext(curstream);
    40334040        QMutexLocker locker(avcodeclock);
    4034         avcodec_decode_subtitle2(curstream->codec, &subtitle, &gotSubtitles,
    4035                                  pkt);
     4041        avcodec_decode_subtitle2(ctx, &subtitle, &gotSubtitles,
     4042            pkt);
    40364043
    40374044        subtitle.start_display_time += pts;
    40384045        subtitle.end_display_time += pts;
    bool AvFormatDecoder::ProcessSubtitlePacket(AVStream *curstream, AVPacket *pkt) 
    40494056                .arg(subtitle.end_display_time));
    40504057
    40514058        bool forcedon = m_parent->GetSubReader(pkt->stream_index)->AddAVSubtitle(
    4052                subtitle, curstream->codec->codec_id == AV_CODEC_ID_XSUB,
    4053                m_parent->GetAllowForcedSubtitles());
    4054         m_parent->EnableForcedSubtitles(forcedon || isForcedTrack);
     4059                subtitle, curstream->codecpar->codec_id == AV_CODEC_ID_XSUB,
     4060                m_parent->GetAllowForcedSubtitles());
     4061         m_parent->EnableForcedSubtitles(forcedon || isForcedTrack);
    40554062    }
    40564063
    40574064    return true;
    bool AvFormatDecoder::ProcessRawTextPacket(AVPacket *pkt) 
    40834090bool AvFormatDecoder::ProcessDataPacket(AVStream *curstream, AVPacket *pkt,
    40844091                                        DecodeType decodetype)
    40854092{
    4086     enum AVCodecID codec_id = curstream->codec->codec_id;
     4093    enum AVCodecID codec_id = curstream->codecpar->codec_id;
    40874094
    40884095    switch (codec_id)
    40894096    {
    QString AvFormatDecoder::GetTrackDesc(uint type, uint trackNo) const 
    41454152
    41464153                if (s)
    41474154                {
    4148                     if (s->codec->codec_id == AV_CODEC_ID_MP3)
    4149                         msg += QString(" MP%1").arg(s->codec->sub_id);
    4150                     else if (s->codec->codec)
    4151                         msg += QString(" %1").arg(s->codec->codec->name).toUpper();
     4155                    AVCodecParameters *par = s->codecpar;
     4156                    AVCodecContext *ctx = gCodecMap->getCodecContext(s);
     4157                    if (par->codec_id == AV_CODEC_ID_MP3)
     4158                        msg += QString(" MP3");
     4159                    else if (ctx && ctx->codec)
     4160                        msg += QString(" %1").arg(ctx->codec->name).toUpper();
    41524161
    41534162                    int channels = 0;
    4154                     if (ringBuffer->IsDVD() || s->codec->channels)
     4163                    if (ringBuffer->IsDVD() || par->channels)
    41554164                        channels = tracks[kTrackTypeAudio][trackNo].orig_num_channels;
    41564165
    41574166                    if (channels == 0)
    QByteArray AvFormatDecoder::GetSubHeader(uint trackNo) const 
    42094218        return QByteArray();
    42104219
    42114220    int index = tracks[kTrackTypeSubtitle][trackNo].av_stream_index;
    4212     if (!ic->streams[index]->codec)
     4221    AVCodecContext *ctx = gCodecMap->getCodecContext(ic->streams[index]);
     4222    if (!ctx)
    42134223        return QByteArray();
    42144224
    4215     return QByteArray((char *)ic->streams[index]->codec->subtitle_header,
    4216                       ic->streams[index]->codec->subtitle_header_size);
     4225    return QByteArray((char *)ctx->subtitle_header,
     4226                      ctx->subtitle_header_size);
    42174227}
    42184228
    42194229void AvFormatDecoder::GetAttachmentData(uint trackNo, QByteArray &filename,
    void AvFormatDecoder::GetAttachmentData(uint trackNo, QByteArray &filename, 
    42274237                                         "filename", NULL, 0);
    42284238    if (tag)
    42294239        filename  = QByteArray(tag->value);
    4230     data      = QByteArray((char *)ic->streams[index]->codec->extradata,
    4231                            ic->streams[index]->codec->extradata_size);
     4240    AVCodecParameters *par = ic->streams[index]->codecpar;
     4241    data = QByteArray((char *)par->extradata, par->extradata_size);
    42324242}
    42334243
    42344244bool AvFormatDecoder::SetAudioByComponentTag(int tag)
    int AvFormatDecoder::filter_max_ch(const AVFormatContext *ic, 
    43184328    for (; it != fs.end(); ++it)
    43194329    {
    43204330        const int stream_index = tracks[*it].av_stream_index;
    4321         const AVCodecContext *ctx = ic->streams[stream_index]->codec;
    4322         if ((codecId == AV_CODEC_ID_NONE || codecId == ctx->codec_id) &&
    4323             (max_seen < ctx->channels))
     4331        AVCodecParameters *par = ic->streams[stream_index]->codecpar;
     4332        if ((codecId == AV_CODEC_ID_NONE || codecId == par->codec_id) &&
     4333            (max_seen < par->channels))
    43244334        {
    43254335            if (codecId == AV_CODEC_ID_DTS && profile > 0)
    43264336            {
    43274337                // we cannot decode dts-hd, so only select it if passthrough
    4328                 if (!DoPassThrough(ctx, true) || ctx->profile != profile)
     4338                if (!DoPassThrough(par, true) || par->profile != profile)
    43294339                    continue;
    43304340            }
    43314341            selectedTrack = *it;
    4332             max_seen = ctx->channels;
     4342            max_seen = par->channels;
    43334343        }
    43344344    }
    43354345
    static void extract_mono_channel(uint channel, AudioInfo *audioInfo, 
    46254635bool AvFormatDecoder::ProcessAudioPacket(AVStream *curstream, AVPacket *pkt,
    46264636                                         DecodeType decodetype)
    46274637{
    4628     AVCodecContext *ctx = curstream->codec;
     4638    AVCodecContext *ctx = gCodecMap->getCodecContext(curstream);
    46294639    int ret             = 0;
    46304640    int data_size       = 0;
    46314641    bool firstloop      = true;
    bool AvFormatDecoder::ProcessAudioPacket(AVStream *curstream, AVPacket *pkt, 
    46704680        {
    46714681            QMutexLocker locker(avcodeclock);
    46724682
    4673             if (DoPassThrough(ctx, false) || !DecoderWillDownmix(ctx))
     4683            if (DoPassThrough(curstream->codecpar, false) || !DecoderWillDownmix(ctx))
    46744684            {
    46754685                // for passthru or codecs for which the decoder won't downmix
    46764686                // let the decoder set the number of channels. For other codecs
    bool AvFormatDecoder::GetFrame(DecodeType decodetype) 
    50135023            continue;
    50145024        }
    50155025
    5016         enum AVMediaType codec_type = curstream->codec->codec_type;
     5026        enum AVMediaType codec_type = curstream->codecpar->codec_type;
    50175027
    50185028        if (storevideoframes && codec_type == AVMEDIA_TYPE_VIDEO)
    50195029        {
    bool AvFormatDecoder::GetFrame(DecodeType decodetype) 
    50405050        }
    50415051
    50425052        if (codec_type == AVMEDIA_TYPE_SUBTITLE &&
    5043             curstream->codec->codec_id == AV_CODEC_ID_TEXT)
     5053            curstream->codecpar->codec_id == AV_CODEC_ID_TEXT)
    50445054        {
    50455055            ProcessRawTextPacket(pkt);
    50465056            av_packet_unref(pkt);
    bool AvFormatDecoder::GetFrame(DecodeType decodetype) 
    50485058        }
    50495059
    50505060        if (codec_type == AVMEDIA_TYPE_SUBTITLE &&
    5051             curstream->codec->codec_id == AV_CODEC_ID_DVB_TELETEXT)
     5061            curstream->codecpar->codec_id == AV_CODEC_ID_DVB_TELETEXT)
    50525062        {
    50535063            ProcessDVBDataPacket(curstream, pkt);
    50545064            av_packet_unref(pkt);
    bool AvFormatDecoder::GetFrame(DecodeType decodetype) 
    50625072            continue;
    50635073        }
    50645074
    5065         if (!curstream->codec->codec)
     5075        AVCodecContext *ctx = gCodecMap->getCodecContext(curstream);
     5076        if (!ctx)
    50665077        {
    50675078            if (codec_type != AVMEDIA_TYPE_VIDEO)
    50685079            {
    bool AvFormatDecoder::GetFrame(DecodeType decodetype) 
    50705081                    QString("No codec for stream index %1, type(%2) id(%3:%4)")
    50715082                        .arg(pkt->stream_index)
    50725083                        .arg(ff_codec_type_string(codec_type))
    5073                         .arg(ff_codec_id_string(curstream->codec->codec_id))
    5074                         .arg(curstream->codec->codec_id));
     5084                        .arg(ff_codec_id_string(curstream->codecpar->codec_id))
     5085                        .arg(curstream->codecpar->codec_id));
    50755086                // Process Stream Change in case we have no audio
    50765087                if (codec_type == AVMEDIA_TYPE_AUDIO && !m_audio->HasAudioIn())
    50775088                    m_streams_changed = true;
    bool AvFormatDecoder::GetFrame(DecodeType decodetype) 
    51275138
    51285139            default:
    51295140            {
    5130                 AVCodecContext *enc = curstream->codec;
    51315141                LOG(VB_GENERAL, LOG_ERR, LOC +
    51325142                    QString("Decoding - id(%1) type(%2)")
    5133                         .arg(ff_codec_id_string(enc->codec_id))
    5134                         .arg(ff_codec_type_string(enc->codec_type)));
     5143                        .arg(ff_codec_id_string(ctx->codec_id))
     5144                        .arg(ff_codec_type_string(ctx->codec_type)));
    51355145                have_err = true;
    51365146                break;
    51375147            }
    QString AvFormatDecoder::GetRawEncodingType(void) 
    52305240    int stream = selectedTrack[kTrackTypeVideo].av_stream_index;
    52315241    if (stream < 0 || !ic)
    52325242        return QString();
    5233     return ff_codec_id_string(ic->streams[stream]->codec->codec_id);
     5243    return ff_codec_id_string(ic->streams[stream]->codecpar->codec_id);
    52345244}
    52355245
    52365246void *AvFormatDecoder::GetVideoCodecPrivate(void)
    inline bool AvFormatDecoder::DecoderWillDownmix(const AVCodecContext *ctx) 
    52845294    }
    52855295}
    52865296
    5287 bool AvFormatDecoder::DoPassThrough(const AVCodecContext *ctx, bool withProfile)
     5297bool AvFormatDecoder::DoPassThrough(const AVCodecParameters *par, bool withProfile)
    52885298{
    52895299    bool passthru;
    52905300
    52915301    // if withProfile == false, we will accept any DTS stream regardless
    52925302    // of its profile. We do so, so we can bitstream DTS-HD as DTS core
    5293     if (!withProfile && ctx->codec_id == AV_CODEC_ID_DTS && !m_audio->CanDTSHD())
    5294         passthru = m_audio->CanPassthrough(ctx->sample_rate, ctx->channels,
    5295                                            ctx->codec_id, FF_PROFILE_DTS);
     5303    if (!withProfile && par->codec_id == AV_CODEC_ID_DTS && !m_audio->CanDTSHD())
     5304        passthru = m_audio->CanPassthrough(par->sample_rate, par->channels,
     5305                                           par->codec_id, FF_PROFILE_DTS);
    52965306    else
    5297         passthru = m_audio->CanPassthrough(ctx->sample_rate, ctx->channels,
    5298                                            ctx->codec_id, ctx->profile);
     5307        passthru = m_audio->CanPassthrough(par->sample_rate, par->channels,
     5308                                           par->codec_id, par->profile);
    52995309
    53005310    passthru &= !disable_passthru;
    53015311
    bool AvFormatDecoder::SetupAudioStream(void) 
    53225332        (selectedTrack[kTrackTypeAudio].av_stream_index <=
    53235333         (int) ic->nb_streams) &&
    53245334        (curstream = ic->streams[selectedTrack[kTrackTypeAudio]
    5325                                  .av_stream_index]))
     5335                                 .av_stream_index]) &&
     5336        (ctx = gCodecMap->getCodecContext(curstream)))
    53265337    {
    5327         assert(curstream);
    5328         assert(curstream->codec);
    5329         ctx = curstream->codec;
    53305338        AudioFormat fmt =
    53315339            AudioOutputSettings::AVSampleFormatToFormat(ctx->sample_fmt,
    53325340                                                        ctx->bits_per_raw_sample);
    bool AvFormatDecoder::SetupAudioStream(void) 
    53475355            return false;
    53485356        }
    53495357
    5350         using_passthru = DoPassThrough(ctx, false);
     5358        using_passthru = DoPassThrough(curstream->codecpar, false);
    53515359
    53525360        requested_channels = ctx->channels;
    53535361        ctx->request_channel_layout =
    void AvFormatDecoder::av_update_stream_timings_video(AVFormatContext *ic) 
    54775485    for (uint i = 0; i < ic->nb_streams; i++)
    54785486    {
    54795487        AVStream *st1 = ic->streams[i];
    5480         if (st1 && st1->codec->codec_type == AVMEDIA_TYPE_VIDEO)
     5488        if (st1 && st1->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
    54815489        {
    54825490            st = st1;
    54835491            break;
  • mythtv/libs/libmythtv/avformatdecoder.h

    diff --git a/mythtv/libs/libmythtv/avformatdecoder.h b/mythtv/libs/libmythtv/avformatdecoder.h
    index 9573364..2576d79 100644
    a b class AvFormatDecoder : public DecoderBase 
    244244    void SeekReset(long long, uint skipFrames, bool doFlush, bool discardFrames);
    245245
    246246    inline bool DecoderWillDownmix(const AVCodecContext *ctx);
    247     bool DoPassThrough(const AVCodecContext *ctx, bool withProfile=true);
     247    bool DoPassThrough(const AVCodecParameters *ctx, bool withProfile=true);
    248248    bool SetupAudioStream(void);
    249249    void SetupAudioStreamSubIndexes(int streamIndex);
    250250    void RemoveAudioStreams();
  • mythtv/libs/libmythtv/mythavutil.cpp

    diff --git a/mythtv/libs/libmythtv/mythavutil.cpp b/mythtv/libs/libmythtv/mythavutil.cpp
    index 80a1777..7706bd1 100644
    a b extern "C" { 
    1717#include "libavfilter/buffersrc.h"
    1818#include "libavfilter/buffersink.h"
    1919#include "libavutil/imgutils.h"
     20#include "libavformat/avformat.h"
    2021}
     22#include <QMutexLocker>
    2123
    2224AVPixelFormat FrameTypeToPixelFormat(VideoFrameType type)
    2325{
    MythPictureDeinterlacer::~MythPictureDeinterlacer() 
    374376        avfilter_graph_free(&m_filter_graph);
    375377    }
    376378}
     379
     380
     381MythCodecMap *gCodecMap = new MythCodecMap();
     382
     383MythCodecMap::MythCodecMap() : mapLock(QMutex::Recursive)
     384{
     385}
     386
     387MythCodecMap::~MythCodecMap()
     388{
     389    freeAllCodecContexts();
     390}
     391
     392AVCodecContext *MythCodecMap::getCodecContext(const AVStream *stream, const AVCodec *pCodec)
     393{
     394    QMutexLocker lock(&mapLock);
     395    AVCodecContext *avctx = streamMap.value(stream, NULL);
     396    if (!avctx)
     397    {
     398        if (stream == NULL || stream->codecpar == NULL)
     399            return NULL;
     400        if (!pCodec)
     401            pCodec = avcodec_find_decoder(stream->codecpar->codec_id);
     402        if (!pCodec)
     403        {
     404            LOG(VB_GENERAL, LOG_WARNING,
     405                QString("avcodec_find_decoder fail for %1").arg(stream->codecpar->codec_id));
     406            return NULL;
     407        }
     408        avctx = avcodec_alloc_context3(pCodec);
     409        if (avcodec_parameters_to_context(avctx, stream->codecpar) != NULL)
     410            avcodec_free_context(&avctx);
     411        if (avctx)
     412        {
     413            av_codec_set_pkt_timebase(avctx, stream->time_base);
     414            streamMap.insert(stream, avctx);
     415        }
     416    }
     417    return avctx;
     418}
     419
     420AVCodecContext *MythCodecMap::hasCodecContext(const AVStream *stream)
     421{
     422    return streamMap.value(stream, NULL);
     423}
     424
     425void MythCodecMap::freeCodecContext(const AVStream *stream)
     426{
     427    QMutexLocker lock(&mapLock);
     428    AVCodecContext *avctx = streamMap.take(stream);
     429    if (avctx)
     430        avcodec_free_context(&avctx);
     431}
     432
     433void MythCodecMap::freeAllCodecContexts()
     434{
     435    QMutexLocker lock(&mapLock);
     436    QMap<const AVStream*, AVCodecContext*>::iterator i = streamMap.begin();
     437    while (i != streamMap.end()) {
     438        const AVStream *stream = i.key();
     439        ++i;
     440        freeCodecContext(stream);
     441    }
     442}
  • mythtv/libs/libmythtv/mythavutil.h

    diff --git a/mythtv/libs/libmythtv/mythavutil.h b/mythtv/libs/libmythtv/mythavutil.h
    index a59c246..cd57361 100644
    a b extern "C" { 
    1515#include "libavcodec/avcodec.h"
    1616}
    1717
     18#include <QMap>
     19#include <QMutex>
     20
    1821struct AVFilterGraph;
    1922struct AVFilterContext;
     23struct AVStream;
     24struct AVCodecContext;
    2025
    2126/** MythAVFrame
    2227 * little utility class that act as a safe way to allocate an AVFrame
    private: 
    7176    AVFrame *m_frame;
    7277};
    7378
     79/**
     80 * MythCodecMap
     81 * Utility class that keeps pointers to
     82 * an AVStream and its AVCodecContext. The codec member
     83 * of AVStream was previously used for this but is now
     84 * deprecated.
     85 *
     86 * This is a singeton class - only 1 instance gets created.
     87 */
     88
     89class MythCodecMap
     90{
     91  public:
     92    MythCodecMap();
     93    ~MythCodecMap();
     94    static MythCodecMap *getInstance();
     95    AVCodecContext *getCodecContext(const AVStream*,  const AVCodec *pCodec = NULL);
     96    AVCodecContext *hasCodecContext(const AVStream*);
     97    void freeCodecContext(const AVStream*);
     98    void freeAllCodecContexts();
     99  protected:
     100    QMap<const AVStream*, AVCodecContext*> streamMap;
     101    QMutex mapLock;
     102};
     103
     104/// This global variable contains the MythCodecMap instance for the app
     105extern MythCodecMap *gCodecMap;
     106
     107
    74108class MythAVCopyPrivate;
    75109
    76110/**
  • mythtv/libs/libmythtv/privatedecoder_omx.cpp

    diff --git a/mythtv/libs/libmythtv/privatedecoder_omx.cpp b/mythtv/libs/libmythtv/privatedecoder_omx.cpp
    index 7c4fbf7..7e1b39a 100644
    a b extern "C" { 
    2121#include "mythcorecontext.h"
    2222#include "mythlogging.h"
    2323#include "omxcontext.h"
     24#include "mythavutil.h"
     25
    2426using namespace omxcontext;
    2527
    2628
    int PrivateDecoderOMX::GetFrame( 
    782784        *got_picture_ptr = 1;
    783785
    784786    // Check for OMX_EventPortSettingsChanged notification
    785     if (SettingsChanged(stream->codec) != OMX_ErrorNone)
     787    AVCodecContext *avctx = gCodecMap->getCodecContext(stream);
     788    if (SettingsChanged(avctx) != OMX_ErrorNone)
    786789    {
    787790        // PGB If there was an error, discard this packet
    788791        *got_picture_ptr = 0;
    int PrivateDecoderOMX::ProcessPacket(AVStream *stream, AVPacket *pkt) 
    815818    // Convert h264_mp4toannexb
    816819    if (m_filter)
    817820    {
    818         AVCodecContext *avctx = stream->codec;
     821        AVCodecContext *avctx = gCodecMap->getCodecContext(stream);
    819822        int outbuf_size = 0;
    820823        uint8_t *outbuf = NULL;
    821824        int res = av_bitstream_filter_filter(m_filter, avctx, NULL, &outbuf,
    int PrivateDecoderOMX::GetBufferedFrame(AVStream *stream, AVFrame *picture) 
    906909    if (!picture)
    907910        return -1;
    908911
    909     AVCodecContext *avctx = stream->codec;
     912    AVCodecContext *avctx = gCodecMap->getCodecContext(stream);
    910913    if (!avctx)
    911914        return -1;
    912915