LCOV - code coverage report
Current view: top level - libavcodec - decode.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 710 1128 62.9 %
Date: 2018-05-20 11:54:08 Functions: 38 43 88.4 %

          Line data    Source code
       1             : /*
       2             :  * generic decoding-related code
       3             :  *
       4             :  * This file is part of FFmpeg.
       5             :  *
       6             :  * FFmpeg is free software; you can redistribute it and/or
       7             :  * modify it under the terms of the GNU Lesser General Public
       8             :  * License as published by the Free Software Foundation; either
       9             :  * version 2.1 of the License, or (at your option) any later version.
      10             :  *
      11             :  * FFmpeg is distributed in the hope that it will be useful,
      12             :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      13             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      14             :  * Lesser General Public License for more details.
      15             :  *
      16             :  * You should have received a copy of the GNU Lesser General Public
      17             :  * License along with FFmpeg; if not, write to the Free Software
      18             :  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
      19             :  */
      20             : 
      21             : #include <stdint.h>
      22             : #include <string.h>
      23             : 
      24             : #include "config.h"
      25             : 
      26             : #if CONFIG_ICONV
      27             : # include <iconv.h>
      28             : #endif
      29             : 
      30             : #include "libavutil/avassert.h"
      31             : #include "libavutil/avstring.h"
      32             : #include "libavutil/bprint.h"
      33             : #include "libavutil/common.h"
      34             : #include "libavutil/frame.h"
      35             : #include "libavutil/hwcontext.h"
      36             : #include "libavutil/imgutils.h"
      37             : #include "libavutil/internal.h"
      38             : #include "libavutil/intmath.h"
      39             : 
      40             : #include "avcodec.h"
      41             : #include "bytestream.h"
      42             : #include "decode.h"
      43             : #include "hwaccel.h"
      44             : #include "internal.h"
      45             : #include "thread.h"
      46             : 
      47      372231 : static int apply_param_change(AVCodecContext *avctx, const AVPacket *avpkt)
      48             : {
      49      372231 :     int size = 0, ret;
      50             :     const uint8_t *data;
      51             :     uint32_t flags;
      52             :     int64_t val;
      53             : 
      54      372231 :     data = av_packet_get_side_data(avpkt, AV_PKT_DATA_PARAM_CHANGE, &size);
      55      372231 :     if (!data)
      56      372229 :         return 0;
      57             : 
      58           2 :     if (!(avctx->codec->capabilities & AV_CODEC_CAP_PARAM_CHANGE)) {
      59           0 :         av_log(avctx, AV_LOG_ERROR, "This decoder does not support parameter "
      60             :                "changes, but PARAM_CHANGE side data was sent to it.\n");
      61           0 :         ret = AVERROR(EINVAL);
      62           0 :         goto fail2;
      63             :     }
      64             : 
      65           2 :     if (size < 4)
      66           0 :         goto fail;
      67             : 
      68           2 :     flags = bytestream_get_le32(&data);
      69           2 :     size -= 4;
      70             : 
      71           2 :     if (flags & AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT) {
      72           0 :         if (size < 4)
      73           0 :             goto fail;
      74           0 :         val = bytestream_get_le32(&data);
      75           0 :         if (val <= 0 || val > INT_MAX) {
      76           0 :             av_log(avctx, AV_LOG_ERROR, "Invalid channel count");
      77           0 :             ret = AVERROR_INVALIDDATA;
      78           0 :             goto fail2;
      79             :         }
      80           0 :         avctx->channels = val;
      81           0 :         size -= 4;
      82             :     }
      83           2 :     if (flags & AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT) {
      84           0 :         if (size < 8)
      85           0 :             goto fail;
      86           0 :         avctx->channel_layout = bytestream_get_le64(&data);
      87           0 :         size -= 8;
      88             :     }
      89           2 :     if (flags & AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE) {
      90           0 :         if (size < 4)
      91           0 :             goto fail;
      92           0 :         val = bytestream_get_le32(&data);
      93           0 :         if (val <= 0 || val > INT_MAX) {
      94           0 :             av_log(avctx, AV_LOG_ERROR, "Invalid sample rate");
      95           0 :             ret = AVERROR_INVALIDDATA;
      96           0 :             goto fail2;
      97             :         }
      98           0 :         avctx->sample_rate = val;
      99           0 :         size -= 4;
     100             :     }
     101           2 :     if (flags & AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS) {
     102           2 :         if (size < 8)
     103           0 :             goto fail;
     104           2 :         avctx->width  = bytestream_get_le32(&data);
     105           2 :         avctx->height = bytestream_get_le32(&data);
     106           2 :         size -= 8;
     107           2 :         ret = ff_set_dimensions(avctx, avctx->width, avctx->height);
     108           2 :         if (ret < 0)
     109           0 :             goto fail2;
     110             :     }
     111             : 
     112           2 :     return 0;
     113           0 : fail:
     114           0 :     av_log(avctx, AV_LOG_ERROR, "PARAM_CHANGE side data too small.\n");
     115           0 :     ret = AVERROR_INVALIDDATA;
     116           0 : fail2:
     117           0 :     if (ret < 0) {
     118           0 :         av_log(avctx, AV_LOG_ERROR, "Error applying parameter changes.\n");
     119           0 :         if (avctx->err_recognition & AV_EF_EXPLODE)
     120           0 :             return ret;
     121             :     }
     122           0 :     return 0;
     123             : }
     124             : 
     125      373367 : static int extract_packet_props(AVCodecInternal *avci, const AVPacket *pkt)
     126             : {
     127      373367 :     int ret = 0;
     128             : 
     129      373367 :     av_packet_unref(avci->last_pkt_props);
     130      373367 :     if (pkt) {
     131      373367 :         ret = av_packet_copy_props(avci->last_pkt_props, pkt);
     132      373367 :         if (!ret)
     133      373367 :             avci->last_pkt_props->size = pkt->size; // HACK: Needed for ff_decode_frame_props().
     134             :     }
     135      373367 :     return ret;
     136             : }
     137             : 
     138        3522 : static int unrefcount_frame(AVCodecInternal *avci, AVFrame *frame)
     139             : {
     140             :     int ret;
     141             : 
     142             :     /* move the original frame to our backup */
     143        3522 :     av_frame_unref(avci->to_free);
     144        3522 :     av_frame_move_ref(avci->to_free, frame);
     145             : 
     146             :     /* now copy everything except the AVBufferRefs back
     147             :      * note that we make a COPY of the side data, so calling av_frame_free() on
     148             :      * the caller's frame will work properly */
     149        3522 :     ret = av_frame_copy_props(frame, avci->to_free);
     150        3522 :     if (ret < 0)
     151           0 :         return ret;
     152             : 
     153        3522 :     memcpy(frame->data,     avci->to_free->data,     sizeof(frame->data));
     154        3522 :     memcpy(frame->linesize, avci->to_free->linesize, sizeof(frame->linesize));
     155        3522 :     if (avci->to_free->extended_data != avci->to_free->data) {
     156           0 :         int planes = avci->to_free->channels;
     157           0 :         int size   = planes * sizeof(*frame->extended_data);
     158             : 
     159           0 :         if (!size) {
     160           0 :             av_frame_unref(frame);
     161           0 :             return AVERROR_BUG;
     162             :         }
     163             : 
     164           0 :         frame->extended_data = av_malloc(size);
     165           0 :         if (!frame->extended_data) {
     166           0 :             av_frame_unref(frame);
     167           0 :             return AVERROR(ENOMEM);
     168             :         }
     169           0 :         memcpy(frame->extended_data, avci->to_free->extended_data,
     170             :                size);
     171             :     } else
     172        3522 :         frame->extended_data = frame->data;
     173             : 
     174        3522 :     frame->format         = avci->to_free->format;
     175        3522 :     frame->width          = avci->to_free->width;
     176        3522 :     frame->height         = avci->to_free->height;
     177        3522 :     frame->channel_layout = avci->to_free->channel_layout;
     178        3522 :     frame->nb_samples     = avci->to_free->nb_samples;
     179        3522 :     frame->channels       = avci->to_free->channels;
     180             : 
     181        3522 :     return 0;
     182             : }
     183             : 
     184     1143516 : static int bsfs_init(AVCodecContext *avctx)
     185             : {
     186     1143516 :     AVCodecInternal *avci = avctx->internal;
     187     1143516 :     DecodeFilterContext *s = &avci->filter;
     188             :     const char *bsfs_str;
     189             :     int ret;
     190             : 
     191     1143516 :     if (s->nb_bsfs)
     192     1133846 :         return 0;
     193             : 
     194        9670 :     bsfs_str = avctx->codec->bsfs ? avctx->codec->bsfs : "null";
     195       29010 :     while (bsfs_str && *bsfs_str) {
     196             :         AVBSFContext **tmp;
     197             :         const AVBitStreamFilter *filter;
     198             :         char *bsf;
     199             : 
     200        9670 :         bsf = av_get_token(&bsfs_str, ",");
     201        9670 :         if (!bsf) {
     202           0 :             ret = AVERROR(ENOMEM);
     203           0 :             goto fail;
     204             :         }
     205             : 
     206        9670 :         filter = av_bsf_get_by_name(bsf);
     207        9670 :         if (!filter) {
     208           0 :             av_log(avctx, AV_LOG_ERROR, "A non-existing bitstream filter %s "
     209             :                    "requested by a decoder. This is a bug, please report it.\n",
     210             :                    bsf);
     211           0 :             ret = AVERROR_BUG;
     212           0 :             av_freep(&bsf);
     213           0 :             goto fail;
     214             :         }
     215        9670 :         av_freep(&bsf);
     216             : 
     217        9670 :         tmp = av_realloc_array(s->bsfs, s->nb_bsfs + 1, sizeof(*s->bsfs));
     218        9670 :         if (!tmp) {
     219           0 :             ret = AVERROR(ENOMEM);
     220           0 :             goto fail;
     221             :         }
     222        9670 :         s->bsfs = tmp;
     223        9670 :         s->nb_bsfs++;
     224             : 
     225        9670 :         ret = av_bsf_alloc(filter, &s->bsfs[s->nb_bsfs - 1]);
     226        9670 :         if (ret < 0)
     227           0 :             goto fail;
     228             : 
     229        9670 :         if (s->nb_bsfs == 1) {
     230             :             /* We do not currently have an API for passing the input timebase into decoders,
     231             :              * but no filters used here should actually need it.
     232             :              * So we make up some plausible-looking number (the MPEG 90kHz timebase) */
     233        9670 :             s->bsfs[s->nb_bsfs - 1]->time_base_in = (AVRational){ 1, 90000 };
     234        9670 :             ret = avcodec_parameters_from_context(s->bsfs[s->nb_bsfs - 1]->par_in,
     235             :                                                   avctx);
     236             :         } else {
     237           0 :             s->bsfs[s->nb_bsfs - 1]->time_base_in = s->bsfs[s->nb_bsfs - 2]->time_base_out;
     238           0 :             ret = avcodec_parameters_copy(s->bsfs[s->nb_bsfs - 1]->par_in,
     239           0 :                                           s->bsfs[s->nb_bsfs - 2]->par_out);
     240             :         }
     241        9670 :         if (ret < 0)
     242           0 :             goto fail;
     243             : 
     244        9670 :         ret = av_bsf_init(s->bsfs[s->nb_bsfs - 1]);
     245        9670 :         if (ret < 0)
     246           0 :             goto fail;
     247             :     }
     248             : 
     249        9670 :     return 0;
     250           0 : fail:
     251           0 :     ff_decode_bsfs_uninit(avctx);
     252           0 :     return ret;
     253             : }
     254             : 
     255             : /* try to get one output packet from the filter chain */
     256      749830 : static int bsfs_poll(AVCodecContext *avctx, AVPacket *pkt)
     257             : {
     258      749830 :     DecodeFilterContext *s = &avctx->internal->filter;
     259             :     int idx, ret;
     260             : 
     261             :     /* start with the last filter in the chain */
     262      749830 :     idx = s->nb_bsfs - 1;
     263     1871729 :     while (idx >= 0) {
     264             :         /* request a packet from the currently selected filter */
     265      749830 :         ret = av_bsf_receive_packet(s->bsfs[idx], pkt);
     266      749830 :         if (ret == AVERROR(EAGAIN)) {
     267             :             /* no packets available, try the next filter up the chain */
     268      372069 :             ret = 0;
     269      372069 :             idx--;
     270      372069 :             continue;
     271      377761 :         } else if (ret < 0 && ret != AVERROR_EOF) {
     272           0 :             return ret;
     273             :         }
     274             : 
     275             :         /* got a packet or EOF -- pass it to the caller or to the next filter
     276             :          * down the chain */
     277      377761 :         if (idx == s->nb_bsfs - 1) {
     278      377761 :             return ret;
     279             :         } else {
     280           0 :             idx++;
     281           0 :             ret = av_bsf_send_packet(s->bsfs[idx], ret < 0 ? NULL : pkt);
     282           0 :             if (ret < 0) {
     283           0 :                 av_log(avctx, AV_LOG_ERROR,
     284             :                        "Error pre-processing a packet before decoding\n");
     285           0 :                 av_packet_unref(pkt);
     286           0 :                 return ret;
     287             :             }
     288             :         }
     289             :     }
     290             : 
     291      372069 :     return AVERROR(EAGAIN);
     292             : }
     293             : 
     294      749832 : int ff_decode_get_packet(AVCodecContext *avctx, AVPacket *pkt)
     295             : {
     296      749832 :     AVCodecInternal *avci = avctx->internal;
     297             :     int ret;
     298             : 
     299      749832 :     if (avci->draining)
     300           2 :         return AVERROR_EOF;
     301             : 
     302      749830 :     ret = bsfs_poll(avctx, pkt);
     303      749830 :     if (ret == AVERROR_EOF)
     304        5530 :         avci->draining = 1;
     305      749830 :     if (ret < 0)
     306      377599 :         return ret;
     307             : 
     308      372231 :     ret = extract_packet_props(avctx->internal, pkt);
     309      372231 :     if (ret < 0)
     310           0 :         goto finish;
     311             : 
     312      372231 :     ret = apply_param_change(avctx, pkt);
     313      372231 :     if (ret < 0)
     314           0 :         goto finish;
     315             : 
     316      372231 :     if (avctx->codec->receive_frame)
     317          92 :         avci->compat_decode_consumed += pkt->size;
     318             : 
     319      372231 :     return 0;
     320           0 : finish:
     321           0 :     av_packet_unref(pkt);
     322           0 :     return ret;
     323             : }
     324             : 
     325             : /**
     326             :  * Attempt to guess proper monotonic timestamps for decoded video frames
     327             :  * which might have incorrect times. Input timestamps may wrap around, in
     328             :  * which case the output will as well.
     329             :  *
     330             :  * @param pts the pts field of the decoded AVPacket, as passed through
     331             :  * AVFrame.pts
     332             :  * @param dts the dts field of the decoded AVPacket
     333             :  * @return one of the input values, may be AV_NOPTS_VALUE
     334             :  */
     335      393747 : static int64_t guess_correct_pts(AVCodecContext *ctx,
     336             :                                  int64_t reordered_pts, int64_t dts)
     337             : {
     338      393747 :     int64_t pts = AV_NOPTS_VALUE;
     339             : 
     340      393747 :     if (dts != AV_NOPTS_VALUE) {
     341      359926 :         ctx->pts_correction_num_faulty_dts += dts <= ctx->pts_correction_last_dts;
     342      359926 :         ctx->pts_correction_last_dts = dts;
     343       33821 :     } else if (reordered_pts != AV_NOPTS_VALUE)
     344         199 :         ctx->pts_correction_last_dts = reordered_pts;
     345             : 
     346      393747 :     if (reordered_pts != AV_NOPTS_VALUE) {
     347      331558 :         ctx->pts_correction_num_faulty_pts += reordered_pts <= ctx->pts_correction_last_pts;
     348      331558 :         ctx->pts_correction_last_pts = reordered_pts;
     349       62189 :     } else if(dts != AV_NOPTS_VALUE)
     350       28567 :         ctx->pts_correction_last_pts = dts;
     351             : 
     352      393747 :     if ((ctx->pts_correction_num_faulty_pts<=ctx->pts_correction_num_faulty_dts || dts == AV_NOPTS_VALUE)
     353      392931 :        && reordered_pts != AV_NOPTS_VALUE)
     354      330743 :         pts = reordered_pts;
     355             :     else
     356       63004 :         pts = dts;
     357             : 
     358      393747 :     return pts;
     359             : }
     360             : 
     361             : /*
     362             :  * The core of the receive_frame_wrapper for the decoders implementing
     363             :  * the simple API. Certain decoders might consume partial packets without
     364             :  * returning any output, so this function needs to be called in a loop until it
     365             :  * returns EAGAIN.
     366             :  **/
     367      784381 : static int decode_simple_internal(AVCodecContext *avctx, AVFrame *frame)
     368             : {
     369      784381 :     AVCodecInternal   *avci = avctx->internal;
     370      784381 :     DecodeSimpleContext *ds = &avci->ds;
     371      784381 :     AVPacket           *pkt = ds->in_pkt;
     372             :     // copy to ensure we do not change pkt
     373             :     int got_frame, actual_got_frame;
     374             :     int ret;
     375             : 
     376      784381 :     if (!pkt->data && !avci->draining) {
     377      749644 :         av_packet_unref(pkt);
     378      749644 :         ret = ff_decode_get_packet(avctx, pkt);
     379      749644 :         if (ret < 0 && ret != AVERROR_EOF)
     380      371977 :             return ret;
     381             :     }
     382             : 
     383             :     // Some codecs (at least wma lossless) will crash when feeding drain packets
     384             :     // after EOF was signaled.
     385      412404 :     if (avci->draining_done)
     386        5816 :         return AVERROR_EOF;
     387             : 
     388      412802 :     if (!pkt->data &&
     389       11101 :         !(avctx->codec->capabilities & AV_CODEC_CAP_DELAY ||
     390        4887 :           avctx->active_thread_type & FF_THREAD_FRAME))
     391        4877 :         return AVERROR_EOF;
     392             : 
     393      401711 :     got_frame = 0;
     394             : 
     395      401711 :     if (HAVE_THREADS && avctx->active_thread_type & FF_THREAD_FRAME) {
     396         142 :         ret = ff_thread_decode_frame(avctx, frame, &got_frame, pkt);
     397             :     } else {
     398      401569 :         ret = avctx->codec->decode(avctx, frame, &got_frame, pkt);
     399             : 
     400      401569 :         if (!(avctx->codec->caps_internal & FF_CODEC_CAP_SETS_PKT_DTS))
     401      401569 :             frame->pkt_dts = pkt->dts;
     402      401569 :         if (avctx->codec->type == AVMEDIA_TYPE_VIDEO) {
     403      110420 :             if(!avctx->has_b_frames)
     404       79399 :                 frame->pkt_pos = pkt->pos;
     405             :             //FIXME these should be under if(!avctx->has_b_frames)
     406             :             /* get_buffer is supposed to set frame parameters */
     407      110420 :             if (!(avctx->codec->capabilities & AV_CODEC_CAP_DR1)) {
     408       20289 :                 if (!frame->sample_aspect_ratio.num)  frame->sample_aspect_ratio = avctx->sample_aspect_ratio;
     409       20289 :                 if (!frame->width)                    frame->width               = avctx->width;
     410       20289 :                 if (!frame->height)                   frame->height              = avctx->height;
     411       20289 :                 if (frame->format == AV_PIX_FMT_NONE) frame->format              = avctx->pix_fmt;
     412             :             }
     413             :         }
     414             :     }
     415      401711 :     emms_c();
     416      401711 :     actual_got_frame = got_frame;
     417             : 
     418      401711 :     if (avctx->codec->type == AVMEDIA_TYPE_VIDEO) {
     419      110432 :         if (frame->flags & AV_FRAME_FLAG_DISCARD)
     420         154 :             got_frame = 0;
     421      110432 :         if (got_frame)
     422      103844 :             frame->best_effort_timestamp = guess_correct_pts(avctx,
     423             :                                                              frame->pts,
     424             :                                                              frame->pkt_dts);
     425      291279 :     } else if (avctx->codec->type == AVMEDIA_TYPE_AUDIO) {
     426             :         uint8_t *side;
     427             :         int side_size;
     428      291279 :         uint32_t discard_padding = 0;
     429      291279 :         uint8_t skip_reason = 0;
     430      291279 :         uint8_t discard_reason = 0;
     431             : 
     432      291279 :         if (ret >= 0 && got_frame) {
     433      289903 :             frame->best_effort_timestamp = guess_correct_pts(avctx,
     434             :                                                              frame->pts,
     435             :                                                              frame->pkt_dts);
     436      289903 :             if (frame->format == AV_SAMPLE_FMT_NONE)
     437           0 :                 frame->format = avctx->sample_fmt;
     438      289903 :             if (!frame->channel_layout)
     439        1275 :                 frame->channel_layout = avctx->channel_layout;
     440      289903 :             if (!frame->channels)
     441           0 :                 frame->channels = avctx->channels;
     442      289903 :             if (!frame->sample_rate)
     443           2 :                 frame->sample_rate = avctx->sample_rate;
     444             :         }
     445             : 
     446      291279 :         side= av_packet_get_side_data(avci->last_pkt_props, AV_PKT_DATA_SKIP_SAMPLES, &side_size);
     447      291279 :         if(side && side_size>=10) {
     448          91 :             avctx->internal->skip_samples = AV_RL32(side) * avctx->internal->skip_samples_multiplier;
     449          91 :             discard_padding = AV_RL32(side + 4);
     450         182 :             av_log(avctx, AV_LOG_DEBUG, "skip %d / discard %d samples due to side data\n",
     451          91 :                    avctx->internal->skip_samples, (int)discard_padding);
     452          91 :             skip_reason = AV_RL8(side + 8);
     453          91 :             discard_reason = AV_RL8(side + 9);
     454             :         }
     455             : 
     456      291293 :         if ((frame->flags & AV_FRAME_FLAG_DISCARD) && got_frame &&
     457          14 :             !(avctx->flags2 & AV_CODEC_FLAG2_SKIP_MANUAL)) {
     458          14 :             avctx->internal->skip_samples = FFMAX(0, avctx->internal->skip_samples - frame->nb_samples);
     459          14 :             got_frame = 0;
     460             :         }
     461             : 
     462      291421 :         if (avctx->internal->skip_samples > 0 && got_frame &&
     463         142 :             !(avctx->flags2 & AV_CODEC_FLAG2_SKIP_MANUAL)) {
     464         142 :             if(frame->nb_samples <= avctx->internal->skip_samples){
     465         100 :                 got_frame = 0;
     466         100 :                 avctx->internal->skip_samples -= frame->nb_samples;
     467         100 :                 av_log(avctx, AV_LOG_DEBUG, "skip whole frame, skip left: %d\n",
     468         100 :                        avctx->internal->skip_samples);
     469             :             } else {
     470          84 :                 av_samples_copy(frame->extended_data, frame->extended_data, 0, avctx->internal->skip_samples,
     471          84 :                                 frame->nb_samples - avctx->internal->skip_samples, avctx->channels, frame->format);
     472          84 :                 if(avctx->pkt_timebase.num && avctx->sample_rate) {
     473          42 :                     int64_t diff_ts = av_rescale_q(avctx->internal->skip_samples,
     474          42 :                                                    (AVRational){1, avctx->sample_rate},
     475             :                                                    avctx->pkt_timebase);
     476          42 :                     if(frame->pts!=AV_NOPTS_VALUE)
     477          42 :                         frame->pts += diff_ts;
     478             : #if FF_API_PKT_PTS
     479             : FF_DISABLE_DEPRECATION_WARNINGS
     480          42 :                     if(frame->pkt_pts!=AV_NOPTS_VALUE)
     481          42 :                         frame->pkt_pts += diff_ts;
     482             : FF_ENABLE_DEPRECATION_WARNINGS
     483             : #endif
     484          42 :                     if(frame->pkt_dts!=AV_NOPTS_VALUE)
     485          42 :                         frame->pkt_dts += diff_ts;
     486          42 :                     if (frame->pkt_duration >= diff_ts)
     487          42 :                         frame->pkt_duration -= diff_ts;
     488             :                 } else {
     489           0 :                     av_log(avctx, AV_LOG_WARNING, "Could not update timestamps for skipped samples.\n");
     490             :                 }
     491          84 :                 av_log(avctx, AV_LOG_DEBUG, "skip %d/%d samples\n",
     492          42 :                        avctx->internal->skip_samples, frame->nb_samples);
     493          42 :                 frame->nb_samples -= avctx->internal->skip_samples;
     494          42 :                 avctx->internal->skip_samples = 0;
     495             :             }
     496             :         }
     497             : 
     498      291284 :         if (discard_padding > 0 && discard_padding <= frame->nb_samples && got_frame &&
     499           5 :             !(avctx->flags2 & AV_CODEC_FLAG2_SKIP_MANUAL)) {
     500           5 :             if (discard_padding == frame->nb_samples) {
     501           2 :                 got_frame = 0;
     502             :             } else {
     503           6 :                 if(avctx->pkt_timebase.num && avctx->sample_rate) {
     504           3 :                     int64_t diff_ts = av_rescale_q(frame->nb_samples - discard_padding,
     505           3 :                                                    (AVRational){1, avctx->sample_rate},
     506             :                                                    avctx->pkt_timebase);
     507           3 :                     frame->pkt_duration = diff_ts;
     508             :                 } else {
     509           0 :                     av_log(avctx, AV_LOG_WARNING, "Could not update timestamps for discarded samples.\n");
     510             :                 }
     511           3 :                 av_log(avctx, AV_LOG_DEBUG, "discard %d/%d samples\n",
     512             :                        (int)discard_padding, frame->nb_samples);
     513           3 :                 frame->nb_samples -= discard_padding;
     514             :             }
     515             :         }
     516             : 
     517      291279 :         if ((avctx->flags2 & AV_CODEC_FLAG2_SKIP_MANUAL) && got_frame) {
     518           0 :             AVFrameSideData *fside = av_frame_new_side_data(frame, AV_FRAME_DATA_SKIP_SAMPLES, 10);
     519           0 :             if (fside) {
     520           0 :                 AV_WL32(fside->data, avctx->internal->skip_samples);
     521           0 :                 AV_WL32(fside->data + 4, discard_padding);
     522           0 :                 AV_WL8(fside->data + 8, skip_reason);
     523           0 :                 AV_WL8(fside->data + 9, discard_reason);
     524           0 :                 avctx->internal->skip_samples = 0;
     525             :             }
     526             :         }
     527             :     }
     528             : 
     529      692990 :     if (avctx->codec->type == AVMEDIA_TYPE_AUDIO &&
     530      557693 :         !avci->showed_multi_packet_warning &&
     531      266401 :         ret >= 0 && ret != pkt->size && !(avctx->codec->capabilities & AV_CODEC_CAP_SUBFRAMES)) {
     532          11 :         av_log(avctx, AV_LOG_WARNING, "Multiple frames in a packet.\n");
     533          11 :         avci->showed_multi_packet_warning = 1;
     534             :     }
     535             : 
     536      401711 :     if (!got_frame)
     537        8080 :         av_frame_unref(frame);
     538             : 
     539      401711 :     if (ret >= 0 && avctx->codec->type == AVMEDIA_TYPE_VIDEO && !(avctx->flags & AV_CODEC_FLAG_TRUNCATED))
     540      109858 :         ret = pkt->size;
     541             : 
     542             : #if FF_API_AVCTX_TIMEBASE
     543      401711 :     if (avctx->framerate.num > 0 && avctx->framerate.den > 0)
     544       82281 :         avctx->time_base = av_inv_q(av_mul_q(avctx->framerate, (AVRational){avctx->ticks_per_frame, 1}));
     545             : #endif
     546             : 
     547             :     /* do not stop draining when actual_got_frame != 0 or ret < 0 */
     548             :     /* got_frame == 0 but actual_got_frame != 0 when frame is discarded */
     549      401711 :     if (avctx->internal->draining && !actual_got_frame) {
     550         641 :         if (ret < 0) {
     551             :             /* prevent infinite loop if a decoder wrongly always return error on draining */
     552             :             /* reasonable nb_errors_max = maximum b frames + thread count */
     553           1 :             int nb_errors_max = 20 + (HAVE_THREADS && avctx->active_thread_type & FF_THREAD_FRAME ?
     554           0 :                                 avctx->thread_count : 1);
     555             : 
     556           1 :             if (avci->nb_draining_errors++ >= nb_errors_max) {
     557           0 :                 av_log(avctx, AV_LOG_ERROR, "Too many errors when draining, this is a bug. "
     558             :                        "Stop draining and force EOF.\n");
     559           0 :                 avci->draining_done = 1;
     560           0 :                 ret = AVERROR_BUG;
     561             :             }
     562             :         } else {
     563         640 :             avci->draining_done = 1;
     564             :         }
     565             :     }
     566             : 
     567      401711 :     avci->compat_decode_consumed += ret;
     568             : 
     569      401711 :     if (ret >= pkt->size || ret < 0) {
     570      373476 :         av_packet_unref(pkt);
     571             :     } else {
     572       28235 :         int consumed = ret;
     573             : 
     574       28235 :         pkt->data                += consumed;
     575       28235 :         pkt->size                -= consumed;
     576       28235 :         avci->last_pkt_props->size -= consumed; // See extract_packet_props() comment.
     577       28235 :         pkt->pts                  = AV_NOPTS_VALUE;
     578       28235 :         pkt->dts                  = AV_NOPTS_VALUE;
     579       28235 :         avci->last_pkt_props->pts = AV_NOPTS_VALUE;
     580       28235 :         avci->last_pkt_props->dts = AV_NOPTS_VALUE;
     581             :     }
     582             : 
     583      401711 :     if (got_frame)
     584      393631 :         av_assert0(frame->buf[0]);
     585             : 
     586      401711 :     return ret < 0 ? ret : 0;
     587             : }
     588             : 
     589      776839 : static int decode_simple_receive_frame(AVCodecContext *avctx, AVFrame *frame)
     590             : {
     591             :     int ret;
     592             : 
     593     1954851 :     while (!frame->buf[0]) {
     594      784381 :         ret = decode_simple_internal(avctx, frame);
     595      784381 :         if (ret < 0)
     596      383208 :             return ret;
     597             :     }
     598             : 
     599      393631 :     return 0;
     600             : }
     601             : 
     602      777107 : static int decode_receive_frame_internal(AVCodecContext *avctx, AVFrame *frame)
     603             : {
     604      777107 :     AVCodecInternal *avci = avctx->internal;
     605             :     int ret;
     606             : 
     607      777107 :     av_assert0(!frame->buf[0]);
     608             : 
     609      777107 :     if (avctx->codec->receive_frame)
     610         268 :         ret = avctx->codec->receive_frame(avctx, frame);
     611             :     else
     612      776839 :         ret = decode_simple_receive_frame(avctx, frame);
     613             : 
     614      777107 :     if (ret == AVERROR_EOF)
     615       10697 :         avci->draining_done = 1;
     616             : 
     617      777107 :     if (!ret) {
     618             :         /* the only case where decode data is not set should be decoders
     619             :          * that do not call ff_get_buffer() */
     620      393803 :         av_assert0((frame->private_ref && frame->private_ref->size == sizeof(FrameDecodeData)) ||
     621             :                    !(avctx->codec->capabilities & AV_CODEC_CAP_DR1));
     622             : 
     623      393803 :         if (frame->private_ref) {
     624      373723 :             FrameDecodeData *fdd = (FrameDecodeData*)frame->private_ref->data;
     625             : 
     626      373723 :             if (fdd->post_process) {
     627           0 :                 ret = fdd->post_process(avctx, frame);
     628           0 :                 if (ret < 0) {
     629           0 :                     av_frame_unref(frame);
     630           0 :                     return ret;
     631             :                 }
     632             :             }
     633             :         }
     634             :     }
     635             : 
     636             :     /* free the per-frame decode data */
     637      777107 :     av_buffer_unref(&frame->private_ref);
     638             : 
     639      777107 :     return ret;
     640             : }
     641             : 
     642      378383 : int attribute_align_arg avcodec_send_packet(AVCodecContext *avctx, const AVPacket *avpkt)
     643             : {
     644      378383 :     AVCodecInternal *avci = avctx->internal;
     645             :     int ret;
     646             : 
     647      378383 :     if (!avcodec_is_open(avctx) || !av_codec_is_decoder(avctx->codec))
     648           0 :         return AVERROR(EINVAL);
     649             : 
     650      378383 :     if (avctx->internal->draining)
     651         684 :         return AVERROR_EOF;
     652             : 
     653      377699 :     if (avpkt && !avpkt->size && avpkt->data)
     654           0 :         return AVERROR(EINVAL);
     655             : 
     656      377699 :     ret = bsfs_init(avctx);
     657      377699 :     if (ret < 0)
     658           0 :         return ret;
     659             : 
     660      377699 :     av_packet_unref(avci->buffer_pkt);
     661      377699 :     if (avpkt && (avpkt->data || avpkt->side_data_elems)) {
     662      372169 :         ret = av_packet_ref(avci->buffer_pkt, avpkt);
     663      372169 :         if (ret < 0)
     664           0 :             return ret;
     665             :     }
     666             : 
     667      377699 :     ret = av_bsf_send_packet(avci->filter.bsfs[0], avci->buffer_pkt);
     668      377699 :     if (ret < 0) {
     669           0 :         av_packet_unref(avci->buffer_pkt);
     670           0 :         return ret;
     671             :     }
     672             : 
     673      377699 :     if (!avci->buffer_frame->buf[0]) {
     674      377699 :         ret = decode_receive_frame_internal(avctx, avci->buffer_frame);
     675      377699 :         if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
     676         533 :             return ret;
     677             :     }
     678             : 
     679      377166 :     return 0;
     680             : }
     681             : 
     682      103844 : static int apply_cropping(AVCodecContext *avctx, AVFrame *frame)
     683             : {
     684             :     /* make sure we are noisy about decoders returning invalid cropping data */
     685      207688 :     if (frame->crop_left >= INT_MAX - frame->crop_right        ||
     686      207688 :         frame->crop_top  >= INT_MAX - frame->crop_bottom       ||
     687      207688 :         (frame->crop_left + frame->crop_right) >= frame->width ||
     688      103844 :         (frame->crop_top + frame->crop_bottom) >= frame->height) {
     689           0 :         av_log(avctx, AV_LOG_WARNING,
     690             :                "Invalid cropping information set by a decoder: "
     691             :                "%"SIZE_SPECIFIER"/%"SIZE_SPECIFIER"/%"SIZE_SPECIFIER"/%"SIZE_SPECIFIER" "
     692             :                "(frame size %dx%d). This is a bug, please report it\n",
     693             :                frame->crop_left, frame->crop_right, frame->crop_top, frame->crop_bottom,
     694             :                frame->width, frame->height);
     695           0 :         frame->crop_left   = 0;
     696           0 :         frame->crop_right  = 0;
     697           0 :         frame->crop_top    = 0;
     698           0 :         frame->crop_bottom = 0;
     699           0 :         return 0;
     700             :     }
     701             : 
     702      103844 :     if (!avctx->apply_cropping)
     703           0 :         return 0;
     704             : 
     705      103844 :     return av_frame_apply_cropping(frame, avctx->flags & AV_CODEC_FLAG_UNALIGNED ?
     706             :                                           AV_FRAME_CROP_UNALIGNED : 0);
     707             : }
     708             : 
     709      765817 : int attribute_align_arg avcodec_receive_frame(AVCodecContext *avctx, AVFrame *frame)
     710             : {
     711      765817 :     AVCodecInternal *avci = avctx->internal;
     712             :     int ret;
     713             : 
     714      765817 :     av_frame_unref(frame);
     715             : 
     716      765817 :     if (!avcodec_is_open(avctx) || !av_codec_is_decoder(avctx->codec))
     717           0 :         return AVERROR(EINVAL);
     718             : 
     719      765817 :     ret = bsfs_init(avctx);
     720      765817 :     if (ret < 0)
     721           0 :         return ret;
     722             : 
     723      765817 :     if (avci->buffer_frame->buf[0]) {
     724      366409 :         av_frame_move_ref(frame, avci->buffer_frame);
     725             :     } else {
     726      399408 :         ret = decode_receive_frame_internal(avctx, frame);
     727      399408 :         if (ret < 0)
     728      372014 :             return ret;
     729             :     }
     730             : 
     731      393803 :     if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
     732      103844 :         ret = apply_cropping(avctx, frame);
     733      103844 :         if (ret < 0) {
     734           0 :             av_frame_unref(frame);
     735           0 :             return ret;
     736             :         }
     737             :     }
     738             : 
     739      393803 :     avctx->frame_number++;
     740             : 
     741      393803 :     return 0;
     742             : }
     743             : 
     744        5689 : static int compat_decode(AVCodecContext *avctx, AVFrame *frame,
     745             :                          int *got_frame, const AVPacket *pkt)
     746             : {
     747        5689 :     AVCodecInternal *avci = avctx->internal;
     748        5689 :     int ret = 0;
     749             : 
     750        5689 :     av_assert0(avci->compat_decode_consumed == 0);
     751             : 
     752        5689 :     if (avci->draining_done && pkt && pkt->size != 0) {
     753           0 :         av_log(avctx, AV_LOG_WARNING, "Got unexpected packet after EOF\n");
     754           0 :         avcodec_flush_buffers(avctx);
     755             :     }
     756             : 
     757        5689 :     *got_frame = 0;
     758        5689 :     avci->compat_decode = 1;
     759             : 
     760        5689 :     if (avci->compat_decode_partial_size > 0 &&
     761           0 :         avci->compat_decode_partial_size != pkt->size) {
     762           0 :         av_log(avctx, AV_LOG_ERROR,
     763             :                "Got unexpected packet size after a partial decode\n");
     764           0 :         ret = AVERROR(EINVAL);
     765           0 :         goto finish;
     766             :     }
     767             : 
     768        5689 :     if (!avci->compat_decode_partial_size) {
     769        5689 :         ret = avcodec_send_packet(avctx, pkt);
     770        5689 :         if (ret == AVERROR_EOF)
     771           6 :             ret = 0;
     772        5683 :         else if (ret == AVERROR(EAGAIN)) {
     773             :             /* we fully drain all the output in each decode call, so this should not
     774             :              * ever happen */
     775           0 :             ret = AVERROR_BUG;
     776           0 :             goto finish;
     777        5683 :         } else if (ret < 0)
     778           0 :             goto finish;
     779             :     }
     780             : 
     781       17034 :     while (ret >= 0) {
     782       11345 :         ret = avcodec_receive_frame(avctx, frame);
     783       11345 :         if (ret < 0) {
     784        5683 :             if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
     785        5683 :                 ret = 0;
     786        5683 :             goto finish;
     787             :         }
     788             : 
     789        5662 :         if (frame != avci->compat_decode_frame) {
     790        5662 :             if (!avctx->refcounted_frames) {
     791        3522 :                 ret = unrefcount_frame(avci, frame);
     792        3522 :                 if (ret < 0)
     793           0 :                     goto finish;
     794             :             }
     795             : 
     796        5662 :             *got_frame = 1;
     797        5662 :             frame = avci->compat_decode_frame;
     798             :         } else {
     799           0 :             if (!avci->compat_decode_warned) {
     800           0 :                 av_log(avctx, AV_LOG_WARNING, "The deprecated avcodec_decode_* "
     801             :                        "API cannot return all the frames for this decoder. "
     802             :                        "Some frames will be dropped. Update your code to the "
     803             :                        "new decoding API to fix this.\n");
     804           0 :                 avci->compat_decode_warned = 1;
     805             :             }
     806             :         }
     807             : 
     808       11318 :         if (avci->draining || (!avctx->codec->bsfs && avci->compat_decode_consumed < pkt->size))
     809             :             break;
     810             :     }
     811             : 
     812           6 : finish:
     813        5689 :     if (ret == 0) {
     814             :         /* if there are any bsfs then assume full packet is always consumed */
     815        5689 :         if (avctx->codec->bsfs)
     816           0 :             ret = pkt->size;
     817             :         else
     818        5689 :             ret = FFMIN(avci->compat_decode_consumed, pkt->size);
     819             :     }
     820        5689 :     avci->compat_decode_consumed = 0;
     821        5689 :     avci->compat_decode_partial_size = (ret >= 0) ? pkt->size - ret : 0;
     822             : 
     823        5689 :     return ret;
     824             : }
     825             : 
     826        2171 : int attribute_align_arg avcodec_decode_video2(AVCodecContext *avctx, AVFrame *picture,
     827             :                                               int *got_picture_ptr,
     828             :                                               const AVPacket *avpkt)
     829             : {
     830        2171 :     return compat_decode(avctx, picture, got_picture_ptr, avpkt);
     831             : }
     832             : 
     833        3518 : int attribute_align_arg avcodec_decode_audio4(AVCodecContext *avctx,
     834             :                                               AVFrame *frame,
     835             :                                               int *got_frame_ptr,
     836             :                                               const AVPacket *avpkt)
     837             : {
     838        3518 :     return compat_decode(avctx, frame, got_frame_ptr, avpkt);
     839             : }
     840             : 
     841        1167 : static void get_subtitle_defaults(AVSubtitle *sub)
     842             : {
     843        1167 :     memset(sub, 0, sizeof(*sub));
     844        1167 :     sub->pts = AV_NOPTS_VALUE;
     845        1167 : }
     846             : 
     847             : #define UTF8_MAX_BYTES 4 /* 5 and 6 bytes sequences should not be used */
     848        1136 : static int recode_subtitle(AVCodecContext *avctx,
     849             :                            AVPacket *outpkt, const AVPacket *inpkt)
     850             : {
     851             : #if CONFIG_ICONV
     852        1136 :     iconv_t cd = (iconv_t)-1;
     853        1136 :     int ret = 0;
     854             :     char *inb, *outb;
     855             :     size_t inl, outl;
     856             :     AVPacket tmp;
     857             : #endif
     858             : 
     859        1136 :     if (avctx->sub_charenc_mode != FF_SUB_CHARENC_MODE_PRE_DECODER || inpkt->size == 0)
     860        1043 :         return 0;
     861             : 
     862             : #if CONFIG_ICONV
     863          93 :     cd = iconv_open("UTF-8", avctx->sub_charenc);
     864          93 :     av_assert0(cd != (iconv_t)-1);
     865             : 
     866          93 :     inb = inpkt->data;
     867          93 :     inl = inpkt->size;
     868             : 
     869          93 :     if (inl >= INT_MAX / UTF8_MAX_BYTES - AV_INPUT_BUFFER_PADDING_SIZE) {
     870           0 :         av_log(avctx, AV_LOG_ERROR, "Subtitles packet is too big for recoding\n");
     871           0 :         ret = AVERROR(ENOMEM);
     872           0 :         goto end;
     873             :     }
     874             : 
     875          93 :     ret = av_new_packet(&tmp, inl * UTF8_MAX_BYTES);
     876          93 :     if (ret < 0)
     877           0 :         goto end;
     878          93 :     outpkt->buf  = tmp.buf;
     879          93 :     outpkt->data = tmp.data;
     880          93 :     outpkt->size = tmp.size;
     881          93 :     outb = outpkt->data;
     882          93 :     outl = outpkt->size;
     883             : 
     884         186 :     if (iconv(cd, &inb, &inl, &outb, &outl) == (size_t)-1 ||
     885         186 :         iconv(cd, NULL, NULL, &outb, &outl) == (size_t)-1 ||
     886         186 :         outl >= outpkt->size || inl != 0) {
     887           0 :         ret = FFMIN(AVERROR(errno), -1);
     888           0 :         av_log(avctx, AV_LOG_ERROR, "Unable to recode subtitle event \"%s\" "
     889             :                "from %s to UTF-8\n", inpkt->data, avctx->sub_charenc);
     890           0 :         av_packet_unref(&tmp);
     891           0 :         goto end;
     892             :     }
     893          93 :     outpkt->size -= outl;
     894          93 :     memset(outpkt->data + outpkt->size, 0, outl);
     895             : 
     896          93 : end:
     897          93 :     if (cd != (iconv_t)-1)
     898          93 :         iconv_close(cd);
     899          93 :     return ret;
     900             : #else
     901             :     av_log(avctx, AV_LOG_ERROR, "requesting subtitles recoding without iconv");
     902             :     return AVERROR(EINVAL);
     903             : #endif
     904             : }
     905             : 
     906         552 : static int utf8_check(const uint8_t *str)
     907             : {
     908             :     const uint8_t *byte;
     909             :     uint32_t codepoint, min;
     910             : 
     911       46797 :     while (*str) {
     912       45693 :         byte = str;
     913       45693 :         GET_UTF8(codepoint, *(byte++), return 0;);
     914       46389 :         min = byte - str == 1 ? 0 : byte - str == 2 ? 0x80 :
     915         696 :               1 << (5 * (byte - str) - 4);
     916       45693 :         if (codepoint < min || codepoint >= 0x110000 ||
     917       45693 :             codepoint == 0xFFFE /* BOM */ ||
     918           0 :             codepoint >= 0xD800 && codepoint <= 0xDFFF /* surrogates */)
     919           0 :             return 0;
     920       45693 :         str = byte;
     921             :     }
     922         552 :     return 1;
     923             : }
     924             : 
     925             : #if FF_API_ASS_TIMING
     926           0 : static void insert_ts(AVBPrint *buf, int ts)
     927             : {
     928           0 :     if (ts == -1) {
     929           0 :         av_bprintf(buf, "9:59:59.99,");
     930             :     } else {
     931             :         int h, m, s;
     932             : 
     933           0 :         h = ts/360000;  ts -= 360000*h;
     934           0 :         m = ts/  6000;  ts -=   6000*m;
     935           0 :         s = ts/   100;  ts -=    100*s;
     936           0 :         av_bprintf(buf, "%d:%02d:%02d.%02d,", h, m, s, ts);
     937             :     }
     938           0 : }
     939             : 
     940           0 : static int convert_sub_to_old_ass_form(AVSubtitle *sub, const AVPacket *pkt, AVRational tb)
     941             : {
     942             :     int i;
     943             :     AVBPrint buf;
     944             : 
     945           0 :     av_bprint_init(&buf, 0, AV_BPRINT_SIZE_UNLIMITED);
     946             : 
     947           0 :     for (i = 0; i < sub->num_rects; i++) {
     948             :         char *final_dialog;
     949             :         const char *dialog;
     950           0 :         AVSubtitleRect *rect = sub->rects[i];
     951           0 :         int ts_start, ts_duration = -1;
     952             :         long int layer;
     953             : 
     954           0 :         if (rect->type != SUBTITLE_ASS || !strncmp(rect->ass, "Dialogue: ", 10))
     955           0 :             continue;
     956             : 
     957           0 :         av_bprint_clear(&buf);
     958             : 
     959             :         /* skip ReadOrder */
     960           0 :         dialog = strchr(rect->ass, ',');
     961           0 :         if (!dialog)
     962           0 :             continue;
     963           0 :         dialog++;
     964             : 
     965             :         /* extract Layer or Marked */
     966           0 :         layer = strtol(dialog, (char**)&dialog, 10);
     967           0 :         if (*dialog != ',')
     968           0 :             continue;
     969           0 :         dialog++;
     970             : 
     971             :         /* rescale timing to ASS time base (ms) */
     972           0 :         ts_start = av_rescale_q(pkt->pts, tb, av_make_q(1, 100));
     973           0 :         if (pkt->duration != -1)
     974           0 :             ts_duration = av_rescale_q(pkt->duration, tb, av_make_q(1, 100));
     975           0 :         sub->end_display_time = FFMAX(sub->end_display_time, 10 * ts_duration);
     976             : 
     977             :         /* construct ASS (standalone file form with timestamps) string */
     978           0 :         av_bprintf(&buf, "Dialogue: %ld,", layer);
     979           0 :         insert_ts(&buf, ts_start);
     980           0 :         insert_ts(&buf, ts_duration == -1 ? -1 : ts_start + ts_duration);
     981           0 :         av_bprintf(&buf, "%s\r\n", dialog);
     982             : 
     983           0 :         final_dialog = av_strdup(buf.str);
     984           0 :         if (!av_bprint_is_complete(&buf) || !final_dialog) {
     985           0 :             av_freep(&final_dialog);
     986           0 :             av_bprint_finalize(&buf, NULL);
     987           0 :             return AVERROR(ENOMEM);
     988             :         }
     989           0 :         av_freep(&rect->ass);
     990           0 :         rect->ass = final_dialog;
     991             :     }
     992             : 
     993           0 :     av_bprint_finalize(&buf, NULL);
     994           0 :     return 0;
     995             : }
     996             : #endif
     997             : 
     998        1167 : int avcodec_decode_subtitle2(AVCodecContext *avctx, AVSubtitle *sub,
     999             :                              int *got_sub_ptr,
    1000             :                              AVPacket *avpkt)
    1001             : {
    1002        1167 :     int i, ret = 0;
    1003             : 
    1004        1167 :     if (!avpkt->data && avpkt->size) {
    1005           0 :         av_log(avctx, AV_LOG_ERROR, "invalid packet: NULL data, size != 0\n");
    1006           0 :         return AVERROR(EINVAL);
    1007             :     }
    1008        1167 :     if (!avctx->codec)
    1009           0 :         return AVERROR(EINVAL);
    1010        1167 :     if (avctx->codec->type != AVMEDIA_TYPE_SUBTITLE) {
    1011           0 :         av_log(avctx, AV_LOG_ERROR, "Invalid media type for subtitles\n");
    1012           0 :         return AVERROR(EINVAL);
    1013             :     }
    1014             : 
    1015        1167 :     *got_sub_ptr = 0;
    1016        1167 :     get_subtitle_defaults(sub);
    1017             : 
    1018        1167 :     if ((avctx->codec->capabilities & AV_CODEC_CAP_DELAY) || avpkt->size) {
    1019        1136 :         AVPacket pkt_recoded = *avpkt;
    1020             : 
    1021        1136 :         ret = recode_subtitle(avctx, &pkt_recoded, avpkt);
    1022        1136 :         if (ret < 0) {
    1023           0 :             *got_sub_ptr = 0;
    1024             :         } else {
    1025        1136 :              ret = extract_packet_props(avctx->internal, &pkt_recoded);
    1026        1136 :              if (ret < 0)
    1027           0 :                 return ret;
    1028             : 
    1029        1136 :             if (avctx->pkt_timebase.num && avpkt->pts != AV_NOPTS_VALUE)
    1030        1134 :                 sub->pts = av_rescale_q(avpkt->pts,
    1031        1134 :                                         avctx->pkt_timebase, AV_TIME_BASE_Q);
    1032        1136 :             ret = avctx->codec->decode(avctx, sub, got_sub_ptr, &pkt_recoded);
    1033             :             av_assert1((ret >= 0) >= !!*got_sub_ptr &&
    1034             :                        !!*got_sub_ptr >= !!sub->num_rects);
    1035             : 
    1036             : #if FF_API_ASS_TIMING
    1037        1136 :             if (avctx->sub_text_format == FF_SUB_TEXT_FMT_ASS_WITH_TIMINGS
    1038           0 :                 && *got_sub_ptr && sub->num_rects) {
    1039           0 :                 const AVRational tb = avctx->pkt_timebase.num ? avctx->pkt_timebase
    1040             :                                                               : avctx->time_base;
    1041           0 :                 int err = convert_sub_to_old_ass_form(sub, avpkt, tb);
    1042           0 :                 if (err < 0)
    1043           0 :                     ret = err;
    1044             :             }
    1045             : #endif
    1046             : 
    1047        1516 :             if (sub->num_rects && !sub->end_display_time && avpkt->duration &&
    1048         380 :                 avctx->pkt_timebase.num) {
    1049         380 :                 AVRational ms = { 1, 1000 };
    1050         380 :                 sub->end_display_time = av_rescale_q(avpkt->duration,
    1051             :                                                      avctx->pkt_timebase, ms);
    1052             :             }
    1053             : 
    1054        1136 :             if (avctx->codec_descriptor->props & AV_CODEC_PROP_BITMAP_SUB)
    1055          47 :                 sub->format = 0;
    1056        1089 :             else if (avctx->codec_descriptor->props & AV_CODEC_PROP_TEXT_SUB)
    1057        1089 :                 sub->format = 1;
    1058             : 
    1059        1732 :             for (i = 0; i < sub->num_rects; i++) {
    1060        1192 :                 if (avctx->sub_charenc_mode != FF_SUB_CHARENC_MODE_IGNORE &&
    1061        1148 :                     sub->rects[i]->ass && !utf8_check(sub->rects[i]->ass)) {
    1062           0 :                     av_log(avctx, AV_LOG_ERROR,
    1063             :                            "Invalid UTF-8 in decoded subtitles text; "
    1064             :                            "maybe missing -sub_charenc option\n");
    1065           0 :                     avsubtitle_free(sub);
    1066           0 :                     ret = AVERROR_INVALIDDATA;
    1067           0 :                     break;
    1068             :                 }
    1069             :             }
    1070             : 
    1071        1136 :             if (avpkt->data != pkt_recoded.data) { // did we recode?
    1072             :                 /* prevent from destroying side data from original packet */
    1073          93 :                 pkt_recoded.side_data = NULL;
    1074          93 :                 pkt_recoded.side_data_elems = 0;
    1075             : 
    1076          93 :                 av_packet_unref(&pkt_recoded);
    1077             :             }
    1078             :         }
    1079             : 
    1080        1136 :         if (*got_sub_ptr)
    1081         596 :             avctx->frame_number++;
    1082             :     }
    1083             : 
    1084        1167 :     return ret;
    1085             : }
    1086             : 
    1087        1349 : enum AVPixelFormat avcodec_default_get_format(struct AVCodecContext *avctx,
    1088             :                                               const enum AVPixelFormat *fmt)
    1089             : {
    1090             :     const AVPixFmtDescriptor *desc;
    1091             :     const AVCodecHWConfig *config;
    1092             :     int i, n;
    1093             : 
    1094             :     // If a device was supplied when the codec was opened, assume that the
    1095             :     // user wants to use it.
    1096        1349 :     if (avctx->hw_device_ctx && avctx->codec->hw_configs) {
    1097           0 :         AVHWDeviceContext *device_ctx =
    1098           0 :             (AVHWDeviceContext*)avctx->hw_device_ctx->data;
    1099           0 :         for (i = 0;; i++) {
    1100           0 :             config = &avctx->codec->hw_configs[i]->public;
    1101           0 :             if (!config)
    1102           0 :                 break;
    1103           0 :             if (!(config->methods &
    1104             :                   AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX))
    1105           0 :                 continue;
    1106           0 :             if (device_ctx->type != config->device_type)
    1107           0 :                 continue;
    1108           0 :             for (n = 0; fmt[n] != AV_PIX_FMT_NONE; n++) {
    1109           0 :                 if (config->pix_fmt == fmt[n])
    1110           0 :                     return fmt[n];
    1111             :             }
    1112             :         }
    1113             :     }
    1114             :     // No device or other setup, so we have to choose from things which
    1115             :     // don't any other external information.
    1116             : 
    1117             :     // If the last element of the list is a software format, choose it
    1118             :     // (this should be best software format if any exist).
    1119        1349 :     for (n = 0; fmt[n] != AV_PIX_FMT_NONE; n++);
    1120        1349 :     desc = av_pix_fmt_desc_get(fmt[n - 1]);
    1121        1349 :     if (!(desc->flags & AV_PIX_FMT_FLAG_HWACCEL))
    1122        1349 :         return fmt[n - 1];
    1123             : 
    1124             :     // Finally, traverse the list in order and choose the first entry
    1125             :     // with no external dependencies (if there is no hardware configuration
    1126             :     // information available then this just picks the first entry).
    1127           0 :     for (n = 0; fmt[n] != AV_PIX_FMT_NONE; n++) {
    1128           0 :         for (i = 0;; i++) {
    1129           0 :             config = avcodec_get_hw_config(avctx->codec, i);
    1130           0 :             if (!config)
    1131           0 :                 break;
    1132           0 :             if (config->pix_fmt == fmt[n])
    1133           0 :                 break;
    1134             :         }
    1135           0 :         if (!config) {
    1136             :             // No specific config available, so the decoder must be able
    1137             :             // to handle this format without any additional setup.
    1138           0 :             return fmt[n];
    1139             :         }
    1140           0 :         if (config->methods & AV_CODEC_HW_CONFIG_METHOD_INTERNAL) {
    1141             :             // Usable with only internal setup.
    1142           0 :             return fmt[n];
    1143             :         }
    1144             :     }
    1145             : 
    1146             :     // Nothing is usable, give up.
    1147           0 :     return AV_PIX_FMT_NONE;
    1148             : }
    1149             : 
    1150           0 : int ff_decode_get_hw_frames_ctx(AVCodecContext *avctx,
    1151             :                                 enum AVHWDeviceType dev_type)
    1152             : {
    1153             :     AVHWDeviceContext *device_ctx;
    1154             :     AVHWFramesContext *frames_ctx;
    1155             :     int ret;
    1156             : 
    1157           0 :     if (!avctx->hwaccel)
    1158           0 :         return AVERROR(ENOSYS);
    1159             : 
    1160           0 :     if (avctx->hw_frames_ctx)
    1161           0 :         return 0;
    1162           0 :     if (!avctx->hw_device_ctx) {
    1163           0 :         av_log(avctx, AV_LOG_ERROR, "A hardware frames or device context is "
    1164             :                 "required for hardware accelerated decoding.\n");
    1165           0 :         return AVERROR(EINVAL);
    1166             :     }
    1167             : 
    1168           0 :     device_ctx = (AVHWDeviceContext *)avctx->hw_device_ctx->data;
    1169           0 :     if (device_ctx->type != dev_type) {
    1170           0 :         av_log(avctx, AV_LOG_ERROR, "Device type %s expected for hardware "
    1171             :                "decoding, but got %s.\n", av_hwdevice_get_type_name(dev_type),
    1172             :                av_hwdevice_get_type_name(device_ctx->type));
    1173           0 :         return AVERROR(EINVAL);
    1174             :     }
    1175             : 
    1176           0 :     ret = avcodec_get_hw_frames_parameters(avctx,
    1177             :                                            avctx->hw_device_ctx,
    1178           0 :                                            avctx->hwaccel->pix_fmt,
    1179             :                                            &avctx->hw_frames_ctx);
    1180           0 :     if (ret < 0)
    1181           0 :         return ret;
    1182             : 
    1183           0 :     frames_ctx = (AVHWFramesContext*)avctx->hw_frames_ctx->data;
    1184             : 
    1185             : 
    1186           0 :     if (frames_ctx->initial_pool_size) {
    1187             :         // We guarantee 4 base work surfaces. The function above guarantees 1
    1188             :         // (the absolute minimum), so add the missing count.
    1189           0 :         frames_ctx->initial_pool_size += 3;
    1190             :     }
    1191             : 
    1192           0 :     ret = av_hwframe_ctx_init(avctx->hw_frames_ctx);
    1193           0 :     if (ret < 0) {
    1194           0 :         av_buffer_unref(&avctx->hw_frames_ctx);
    1195           0 :         return ret;
    1196             :     }
    1197             : 
    1198           0 :     return 0;
    1199             : }
    1200             : 
    1201           0 : int avcodec_get_hw_frames_parameters(AVCodecContext *avctx,
    1202             :                                      AVBufferRef *device_ref,
    1203             :                                      enum AVPixelFormat hw_pix_fmt,
    1204             :                                      AVBufferRef **out_frames_ref)
    1205             : {
    1206           0 :     AVBufferRef *frames_ref = NULL;
    1207             :     const AVCodecHWConfigInternal *hw_config;
    1208             :     const AVHWAccel *hwa;
    1209             :     int i, ret;
    1210             : 
    1211           0 :     for (i = 0;; i++) {
    1212           0 :         hw_config = avctx->codec->hw_configs[i];
    1213           0 :         if (!hw_config)
    1214           0 :             return AVERROR(ENOENT);
    1215           0 :         if (hw_config->public.pix_fmt == hw_pix_fmt)
    1216           0 :             break;
    1217             :     }
    1218             : 
    1219           0 :     hwa = hw_config->hwaccel;
    1220           0 :     if (!hwa || !hwa->frame_params)
    1221           0 :         return AVERROR(ENOENT);
    1222             : 
    1223           0 :     frames_ref = av_hwframe_ctx_alloc(device_ref);
    1224           0 :     if (!frames_ref)
    1225           0 :         return AVERROR(ENOMEM);
    1226             : 
    1227           0 :     ret = hwa->frame_params(avctx, frames_ref);
    1228           0 :     if (ret >= 0) {
    1229           0 :         AVHWFramesContext *frames_ctx = (AVHWFramesContext*)frames_ref->data;
    1230             : 
    1231           0 :         if (frames_ctx->initial_pool_size) {
    1232             :             // If the user has requested that extra output surfaces be
    1233             :             // available then add them here.
    1234           0 :             if (avctx->extra_hw_frames > 0)
    1235           0 :                 frames_ctx->initial_pool_size += avctx->extra_hw_frames;
    1236             : 
    1237             :             // If frame threading is enabled then an extra surface per thread
    1238             :             // is also required.
    1239           0 :             if (avctx->active_thread_type & FF_THREAD_FRAME)
    1240           0 :                 frames_ctx->initial_pool_size += avctx->thread_count;
    1241             :         }
    1242             : 
    1243           0 :         *out_frames_ref = frames_ref;
    1244             :     } else {
    1245           0 :         av_buffer_unref(&frames_ref);
    1246             :     }
    1247           0 :     return ret;
    1248             : }
    1249             : 
    1250           0 : static int hwaccel_init(AVCodecContext *avctx,
    1251             :                         const AVCodecHWConfigInternal *hw_config)
    1252             : {
    1253             :     const AVHWAccel *hwaccel;
    1254             :     int err;
    1255             : 
    1256           0 :     hwaccel = hw_config->hwaccel;
    1257           0 :     if (hwaccel->capabilities & AV_HWACCEL_CODEC_CAP_EXPERIMENTAL &&
    1258           0 :         avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
    1259           0 :         av_log(avctx, AV_LOG_WARNING, "Ignoring experimental hwaccel: %s\n",
    1260             :                hwaccel->name);
    1261           0 :         return AVERROR_PATCHWELCOME;
    1262             :     }
    1263             : 
    1264           0 :     if (hwaccel->priv_data_size) {
    1265           0 :         avctx->internal->hwaccel_priv_data =
    1266           0 :             av_mallocz(hwaccel->priv_data_size);
    1267           0 :         if (!avctx->internal->hwaccel_priv_data)
    1268           0 :             return AVERROR(ENOMEM);
    1269             :     }
    1270             : 
    1271           0 :     avctx->hwaccel = hwaccel;
    1272           0 :     if (hwaccel->init) {
    1273           0 :         err = hwaccel->init(avctx);
    1274           0 :         if (err < 0) {
    1275           0 :             av_log(avctx, AV_LOG_ERROR, "Failed setup for format %s: "
    1276             :                    "hwaccel initialisation returned error.\n",
    1277             :                    av_get_pix_fmt_name(hw_config->public.pix_fmt));
    1278           0 :             av_freep(&avctx->internal->hwaccel_priv_data);
    1279           0 :             avctx->hwaccel = NULL;
    1280           0 :             return err;
    1281             :         }
    1282             :     }
    1283             : 
    1284           0 :     return 0;
    1285             : }
    1286             : 
    1287        2264 : static void hwaccel_uninit(AVCodecContext *avctx)
    1288             : {
    1289        2264 :     if (avctx->hwaccel && avctx->hwaccel->uninit)
    1290           0 :         avctx->hwaccel->uninit(avctx);
    1291             : 
    1292        2264 :     av_freep(&avctx->internal->hwaccel_priv_data);
    1293             : 
    1294        2264 :     avctx->hwaccel = NULL;
    1295             : 
    1296        2264 :     av_buffer_unref(&avctx->hw_frames_ctx);
    1297        2264 : }
    1298             : 
    1299        2264 : int ff_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
    1300             : {
    1301             :     const AVPixFmtDescriptor *desc;
    1302             :     enum AVPixelFormat *choices;
    1303             :     enum AVPixelFormat ret, user_choice;
    1304             :     const AVCodecHWConfigInternal *hw_config;
    1305             :     const AVCodecHWConfig *config;
    1306             :     int i, n, err;
    1307             : 
    1308             :     // Find end of list.
    1309        2264 :     for (n = 0; fmt[n] != AV_PIX_FMT_NONE; n++);
    1310             :     // Must contain at least one entry.
    1311        2264 :     av_assert0(n >= 1);
    1312             :     // If a software format is available, it must be the last entry.
    1313        2264 :     desc = av_pix_fmt_desc_get(fmt[n - 1]);
    1314        2264 :     if (desc->flags & AV_PIX_FMT_FLAG_HWACCEL) {
    1315             :         // No software format is available.
    1316             :     } else {
    1317        2264 :         avctx->sw_pix_fmt = fmt[n - 1];
    1318             :     }
    1319             : 
    1320        2264 :     choices = av_malloc_array(n + 1, sizeof(*choices));
    1321        2264 :     if (!choices)
    1322           0 :         return AV_PIX_FMT_NONE;
    1323             : 
    1324        2264 :     memcpy(choices, fmt, (n + 1) * sizeof(*choices));
    1325             : 
    1326             :     for (;;) {
    1327             :         // Remove the previous hwaccel, if there was one.
    1328        2264 :         hwaccel_uninit(avctx);
    1329             : 
    1330        2264 :         user_choice = avctx->get_format(avctx, choices);
    1331        2264 :         if (user_choice == AV_PIX_FMT_NONE) {
    1332             :             // Explicitly chose nothing, give up.
    1333           0 :             ret = AV_PIX_FMT_NONE;
    1334           0 :             break;
    1335             :         }
    1336             : 
    1337        2264 :         desc = av_pix_fmt_desc_get(user_choice);
    1338        2264 :         if (!desc) {
    1339           0 :             av_log(avctx, AV_LOG_ERROR, "Invalid format returned by "
    1340             :                    "get_format() callback.\n");
    1341           0 :             ret = AV_PIX_FMT_NONE;
    1342           0 :             break;
    1343             :         }
    1344        2264 :         av_log(avctx, AV_LOG_DEBUG, "Format %s chosen by get_format().\n",
    1345             :                desc->name);
    1346             : 
    1347        2264 :         for (i = 0; i < n; i++) {
    1348        2264 :             if (choices[i] == user_choice)
    1349        2264 :                 break;
    1350             :         }
    1351        2264 :         if (i == n) {
    1352           0 :             av_log(avctx, AV_LOG_ERROR, "Invalid return from get_format(): "
    1353             :                    "%s not in possible list.\n", desc->name);
    1354           0 :             break;
    1355             :         }
    1356             : 
    1357        2264 :         if (avctx->codec->hw_configs) {
    1358        2141 :             for (i = 0;; i++) {
    1359        2141 :                 hw_config = avctx->codec->hw_configs[i];
    1360        2141 :                 if (!hw_config)
    1361        2141 :                     break;
    1362           0 :                 if (hw_config->public.pix_fmt == user_choice)
    1363           0 :                     break;
    1364             :             }
    1365             :         } else {
    1366         123 :             hw_config = NULL;
    1367             :         }
    1368             : 
    1369        2264 :         if (!hw_config) {
    1370             :             // No config available, so no extra setup required.
    1371        2264 :             ret = user_choice;
    1372        2264 :             break;
    1373             :         }
    1374           0 :         config = &hw_config->public;
    1375             : 
    1376           0 :         if (config->methods &
    1377           0 :             AV_CODEC_HW_CONFIG_METHOD_HW_FRAMES_CTX &&
    1378           0 :             avctx->hw_frames_ctx) {
    1379           0 :             const AVHWFramesContext *frames_ctx =
    1380           0 :                 (AVHWFramesContext*)avctx->hw_frames_ctx->data;
    1381           0 :             if (frames_ctx->format != user_choice) {
    1382           0 :                 av_log(avctx, AV_LOG_ERROR, "Invalid setup for format %s: "
    1383             :                        "does not match the format of the provided frames "
    1384             :                        "context.\n", desc->name);
    1385           0 :                 goto try_again;
    1386             :             }
    1387           0 :         } else if (config->methods &
    1388           0 :                    AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX &&
    1389           0 :                    avctx->hw_device_ctx) {
    1390           0 :             const AVHWDeviceContext *device_ctx =
    1391           0 :                 (AVHWDeviceContext*)avctx->hw_device_ctx->data;
    1392           0 :             if (device_ctx->type != config->device_type) {
    1393           0 :                 av_log(avctx, AV_LOG_ERROR, "Invalid setup for format %s: "
    1394             :                        "does not match the type of the provided device "
    1395             :                        "context.\n", desc->name);
    1396           0 :                 goto try_again;
    1397             :             }
    1398           0 :         } else if (config->methods &
    1399             :                    AV_CODEC_HW_CONFIG_METHOD_INTERNAL) {
    1400             :             // Internal-only setup, no additional configuration.
    1401           0 :         } else if (config->methods &
    1402             :                    AV_CODEC_HW_CONFIG_METHOD_AD_HOC) {
    1403             :             // Some ad-hoc configuration we can't see and can't check.
    1404             :         } else {
    1405           0 :             av_log(avctx, AV_LOG_ERROR, "Invalid setup for format %s: "
    1406             :                    "missing configuration.\n", desc->name);
    1407           0 :             goto try_again;
    1408             :         }
    1409           0 :         if (hw_config->hwaccel) {
    1410           0 :             av_log(avctx, AV_LOG_DEBUG, "Format %s requires hwaccel "
    1411             :                    "initialisation.\n", desc->name);
    1412           0 :             err = hwaccel_init(avctx, hw_config);
    1413           0 :             if (err < 0)
    1414           0 :                 goto try_again;
    1415             :         }
    1416           0 :         ret = user_choice;
    1417           0 :         break;
    1418             : 
    1419           0 :     try_again:
    1420           0 :         av_log(avctx, AV_LOG_DEBUG, "Format %s not usable, retrying "
    1421             :                "get_format() without it.\n", desc->name);
    1422           0 :         for (i = 0; i < n; i++) {
    1423           0 :             if (choices[i] == user_choice)
    1424           0 :                 break;
    1425             :         }
    1426           0 :         for (; i + 1 < n; i++)
    1427           0 :             choices[i] = choices[i + 1];
    1428           0 :         --n;
    1429             :     }
    1430             : 
    1431        2264 :     av_freep(&choices);
    1432        2264 :     return ret;
    1433             : }
    1434             : 
    1435      379088 : static int update_frame_pool(AVCodecContext *avctx, AVFrame *frame)
    1436             : {
    1437      379088 :     FramePool *pool = avctx->internal->pool;
    1438             :     int i, ret;
    1439             : 
    1440      379088 :     switch (avctx->codec_type) {
    1441       88949 :     case AVMEDIA_TYPE_VIDEO: {
    1442             :         uint8_t *data[4];
    1443             :         int linesize[4];
    1444       88949 :         int size[4] = { 0 };
    1445       88949 :         int w = frame->width;
    1446       88949 :         int h = frame->height;
    1447             :         int tmpsize, unaligned;
    1448             : 
    1449      176161 :         if (pool->format == frame->format &&
    1450      168181 :             pool->width == frame->width && pool->height == frame->height)
    1451      161916 :             return 0;
    1452             : 
    1453        7991 :         avcodec_align_dimensions2(avctx, &w, &h, pool->stride_align);
    1454             : 
    1455             :         do {
    1456             :             // NOTE: do not align linesizes individually, this breaks e.g. assumptions
    1457             :             // that linesize[0] == 2*linesize[1] in the MPEG-encoder for 4:2:2
    1458       16085 :             ret = av_image_fill_linesizes(linesize, avctx->pix_fmt, w);
    1459       16085 :             if (ret < 0)
    1460           0 :                 return ret;
    1461             :             // increase alignment of w for next try (rhs gives the lowest bit set in w)
    1462       16085 :             w += w & ~(w - 1);
    1463             : 
    1464       16085 :             unaligned = 0;
    1465       80425 :             for (i = 0; i < 4; i++)
    1466       64340 :                 unaligned |= linesize[i] % pool->stride_align[i];
    1467       16085 :         } while (unaligned);
    1468             : 
    1469        7991 :         tmpsize = av_image_fill_pointers(data, avctx->pix_fmt, h,
    1470             :                                          NULL, linesize);
    1471        7991 :         if (tmpsize < 0)
    1472           0 :             return -1;
    1473             : 
    1474       22307 :         for (i = 0; i < 3 && data[i + 1]; i++)
    1475       14316 :             size[i] = data[i + 1] - data[i];
    1476        7991 :         size[i] = tmpsize - (data[i] - data[0]);
    1477             : 
    1478       39955 :         for (i = 0; i < 4; i++) {
    1479       31964 :             av_buffer_pool_uninit(&pool->pools[i]);
    1480       31964 :             pool->linesize[i] = linesize[i];
    1481       31964 :             if (size[i]) {
    1482       22307 :                 pool->pools[i] = av_buffer_pool_init(size[i] + 16 + STRIDE_ALIGN - 1,
    1483             :                                                      CONFIG_MEMORY_POISONING ?
    1484             :                                                         NULL :
    1485             :                                                         av_buffer_allocz);
    1486       22307 :                 if (!pool->pools[i]) {
    1487           0 :                     ret = AVERROR(ENOMEM);
    1488           0 :                     goto fail;
    1489             :                 }
    1490             :             }
    1491             :         }
    1492        7991 :         pool->format = frame->format;
    1493        7991 :         pool->width  = frame->width;
    1494        7991 :         pool->height = frame->height;
    1495             : 
    1496        7991 :         break;
    1497             :         }
    1498      290139 :     case AVMEDIA_TYPE_AUDIO: {
    1499      290139 :         int ch     = frame->channels; //av_get_channel_layout_nb_channels(frame->channel_layout);
    1500      290139 :         int planar = av_sample_fmt_is_planar(frame->format);
    1501      290139 :         int planes = planar ? ch : 1;
    1502             : 
    1503      578847 :         if (pool->format == frame->format && pool->planes == planes &&
    1504      577416 :             pool->channels == ch && frame->nb_samples == pool->samples)
    1505      282389 :             return 0;
    1506             : 
    1507        7750 :         av_buffer_pool_uninit(&pool->pools[0]);
    1508        7750 :         ret = av_samples_get_buffer_size(&pool->linesize[0], ch,
    1509        7750 :                                          frame->nb_samples, frame->format, 0);
    1510        7750 :         if (ret < 0)
    1511           0 :             goto fail;
    1512             : 
    1513        7750 :         pool->pools[0] = av_buffer_pool_init(pool->linesize[0], NULL);
    1514        7750 :         if (!pool->pools[0]) {
    1515           0 :             ret = AVERROR(ENOMEM);
    1516           0 :             goto fail;
    1517             :         }
    1518             : 
    1519        7750 :         pool->format     = frame->format;
    1520        7750 :         pool->planes     = planes;
    1521        7750 :         pool->channels   = ch;
    1522        7750 :         pool->samples = frame->nb_samples;
    1523        7750 :         break;
    1524             :         }
    1525           0 :     default: av_assert0(0);
    1526             :     }
    1527       15741 :     return 0;
    1528           0 : fail:
    1529           0 :     for (i = 0; i < 4; i++)
    1530           0 :         av_buffer_pool_uninit(&pool->pools[i]);
    1531           0 :     pool->format = -1;
    1532           0 :     pool->planes = pool->channels = pool->samples = 0;
    1533           0 :     pool->width  = pool->height = 0;
    1534           0 :     return ret;
    1535             : }
    1536             : 
    1537      290139 : static int audio_get_buffer(AVCodecContext *avctx, AVFrame *frame)
    1538             : {
    1539      290139 :     FramePool *pool = avctx->internal->pool;
    1540      290139 :     int planes = pool->planes;
    1541             :     int i;
    1542             : 
    1543      290139 :     frame->linesize[0] = pool->linesize[0];
    1544             : 
    1545      290139 :     if (planes > AV_NUM_DATA_POINTERS) {
    1546           0 :         frame->extended_data = av_mallocz_array(planes, sizeof(*frame->extended_data));
    1547           0 :         frame->nb_extended_buf = planes - AV_NUM_DATA_POINTERS;
    1548           0 :         frame->extended_buf  = av_mallocz_array(frame->nb_extended_buf,
    1549             :                                           sizeof(*frame->extended_buf));
    1550           0 :         if (!frame->extended_data || !frame->extended_buf) {
    1551           0 :             av_freep(&frame->extended_data);
    1552           0 :             av_freep(&frame->extended_buf);
    1553           0 :             return AVERROR(ENOMEM);
    1554             :         }
    1555             :     } else {
    1556      290139 :         frame->extended_data = frame->data;
    1557      290139 :         av_assert0(frame->nb_extended_buf == 0);
    1558             :     }
    1559             : 
    1560      736525 :     for (i = 0; i < FFMIN(planes, AV_NUM_DATA_POINTERS); i++) {
    1561      446386 :         frame->buf[i] = av_buffer_pool_get(pool->pools[0]);
    1562      446386 :         if (!frame->buf[i])
    1563           0 :             goto fail;
    1564      446386 :         frame->extended_data[i] = frame->data[i] = frame->buf[i]->data;
    1565             :     }
    1566      290139 :     for (i = 0; i < frame->nb_extended_buf; i++) {
    1567           0 :         frame->extended_buf[i] = av_buffer_pool_get(pool->pools[0]);
    1568           0 :         if (!frame->extended_buf[i])
    1569           0 :             goto fail;
    1570           0 :         frame->extended_data[i + AV_NUM_DATA_POINTERS] = frame->extended_buf[i]->data;
    1571             :     }
    1572             : 
    1573      290139 :     if (avctx->debug & FF_DEBUG_BUFFERS)
    1574           0 :         av_log(avctx, AV_LOG_DEBUG, "default_get_buffer called on frame %p", frame);
    1575             : 
    1576      290139 :     return 0;
    1577           0 : fail:
    1578           0 :     av_frame_unref(frame);
    1579           0 :     return AVERROR(ENOMEM);
    1580             : }
    1581             : 
    1582       88949 : static int video_get_buffer(AVCodecContext *s, AVFrame *pic)
    1583             : {
    1584       88949 :     FramePool *pool = s->internal->pool;
    1585       88949 :     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pic->format);
    1586             :     int i;
    1587             : 
    1588       88949 :     if (pic->data[0] || pic->data[1] || pic->data[2] || pic->data[3]) {
    1589           0 :         av_log(s, AV_LOG_ERROR, "pic->data[*]!=NULL in avcodec_default_get_buffer\n");
    1590           0 :         return -1;
    1591             :     }
    1592             : 
    1593       88949 :     if (!desc) {
    1594           0 :         av_log(s, AV_LOG_ERROR,
    1595             :             "Unable to get pixel format descriptor for format %s\n",
    1596           0 :             av_get_pix_fmt_name(pic->format));
    1597           0 :         return AVERROR(EINVAL);
    1598             :     }
    1599             : 
    1600       88949 :     memset(pic->data, 0, sizeof(pic->data));
    1601       88949 :     pic->extended_data = pic->data;
    1602             : 
    1603      342497 :     for (i = 0; i < 4 && pool->pools[i]; i++) {
    1604      253548 :         pic->linesize[i] = pool->linesize[i];
    1605             : 
    1606      253548 :         pic->buf[i] = av_buffer_pool_get(pool->pools[i]);
    1607      253548 :         if (!pic->buf[i])
    1608           0 :             goto fail;
    1609             : 
    1610      253548 :         pic->data[i] = pic->buf[i]->data;
    1611             :     }
    1612      546993 :     for (; i < AV_NUM_DATA_POINTERS; i++) {
    1613      458044 :         pic->data[i] = NULL;
    1614      458044 :         pic->linesize[i] = 0;
    1615             :     }
    1616      175765 :     if (desc->flags & AV_PIX_FMT_FLAG_PAL ||
    1617       87115 :         ((desc->flags & FF_PSEUDOPAL) && pic->data[1]))
    1618        2432 :         avpriv_set_systematic_pal2((uint32_t *)pic->data[1], pic->format);
    1619             : 
    1620       88949 :     if (s->debug & FF_DEBUG_BUFFERS)
    1621           0 :         av_log(s, AV_LOG_DEBUG, "default_get_buffer called on pic %p\n", pic);
    1622             : 
    1623       88949 :     return 0;
    1624           0 : fail:
    1625           0 :     av_frame_unref(pic);
    1626           0 :     return AVERROR(ENOMEM);
    1627             : }
    1628             : 
    1629      379088 : int avcodec_default_get_buffer2(AVCodecContext *avctx, AVFrame *frame, int flags)
    1630             : {
    1631             :     int ret;
    1632             : 
    1633      379088 :     if (avctx->hw_frames_ctx) {
    1634           0 :         ret = av_hwframe_get_buffer(avctx->hw_frames_ctx, frame, 0);
    1635           0 :         frame->width  = avctx->coded_width;
    1636           0 :         frame->height = avctx->coded_height;
    1637           0 :         return ret;
    1638             :     }
    1639             : 
    1640      379088 :     if ((ret = update_frame_pool(avctx, frame)) < 0)
    1641           0 :         return ret;
    1642             : 
    1643      379088 :     switch (avctx->codec_type) {
    1644       88949 :     case AVMEDIA_TYPE_VIDEO:
    1645       88949 :         return video_get_buffer(avctx, frame);
    1646      290139 :     case AVMEDIA_TYPE_AUDIO:
    1647      290139 :         return audio_get_buffer(avctx, frame);
    1648           0 :     default:
    1649           0 :         return -1;
    1650             :     }
    1651             : }
    1652             : 
    1653      404656 : static int add_metadata_from_side_data(const AVPacket *avpkt, AVFrame *frame)
    1654             : {
    1655             :     int size;
    1656             :     const uint8_t *side_metadata;
    1657             : 
    1658      404656 :     AVDictionary **frame_md = &frame->metadata;
    1659             : 
    1660      404656 :     side_metadata = av_packet_get_side_data(avpkt,
    1661             :                                             AV_PKT_DATA_STRINGS_METADATA, &size);
    1662      404656 :     return av_packet_unpack_dictionary(side_metadata, size, frame_md);
    1663             : }
    1664             : 
    1665      404656 : int ff_decode_frame_props(AVCodecContext *avctx, AVFrame *frame)
    1666             : {
    1667      404656 :     const AVPacket *pkt = avctx->internal->last_pkt_props;
    1668             :     int i;
    1669             :     static const struct {
    1670             :         enum AVPacketSideDataType packet;
    1671             :         enum AVFrameSideDataType frame;
    1672             :     } sd[] = {
    1673             :         { AV_PKT_DATA_REPLAYGAIN ,                AV_FRAME_DATA_REPLAYGAIN },
    1674             :         { AV_PKT_DATA_DISPLAYMATRIX,              AV_FRAME_DATA_DISPLAYMATRIX },
    1675             :         { AV_PKT_DATA_SPHERICAL,                  AV_FRAME_DATA_SPHERICAL },
    1676             :         { AV_PKT_DATA_STEREO3D,                   AV_FRAME_DATA_STEREO3D },
    1677             :         { AV_PKT_DATA_AUDIO_SERVICE_TYPE,         AV_FRAME_DATA_AUDIO_SERVICE_TYPE },
    1678             :         { AV_PKT_DATA_MASTERING_DISPLAY_METADATA, AV_FRAME_DATA_MASTERING_DISPLAY_METADATA },
    1679             :         { AV_PKT_DATA_CONTENT_LIGHT_LEVEL,        AV_FRAME_DATA_CONTENT_LIGHT_LEVEL },
    1680             :         { AV_PKT_DATA_A53_CC,                     AV_FRAME_DATA_A53_CC },
    1681             :     };
    1682             : 
    1683      404656 :     if (pkt) {
    1684      404656 :         frame->pts = pkt->pts;
    1685             : #if FF_API_PKT_PTS
    1686             : FF_DISABLE_DEPRECATION_WARNINGS
    1687      404656 :         frame->pkt_pts = pkt->pts;
    1688             : FF_ENABLE_DEPRECATION_WARNINGS
    1689             : #endif
    1690      404656 :         frame->pkt_pos      = pkt->pos;
    1691      404656 :         frame->pkt_duration = pkt->duration;
    1692      404656 :         frame->pkt_size     = pkt->size;
    1693             : 
    1694     3641904 :         for (i = 0; i < FF_ARRAY_ELEMS(sd); i++) {
    1695             :             int size;
    1696     3237248 :             uint8_t *packet_sd = av_packet_get_side_data(pkt, sd[i].packet, &size);
    1697     3237248 :             if (packet_sd) {
    1698         209 :                 AVFrameSideData *frame_sd = av_frame_new_side_data(frame,
    1699             :                                                                    sd[i].frame,
    1700             :                                                                    size);
    1701         209 :                 if (!frame_sd)
    1702           0 :                     return AVERROR(ENOMEM);
    1703             : 
    1704         209 :                 memcpy(frame_sd->data, packet_sd, size);
    1705             :             }
    1706             :         }
    1707      404656 :         add_metadata_from_side_data(pkt, frame);
    1708             : 
    1709      404656 :         if (pkt->flags & AV_PKT_FLAG_DISCARD) {
    1710         170 :             frame->flags |= AV_FRAME_FLAG_DISCARD;
    1711             :         } else {
    1712      404486 :             frame->flags = (frame->flags & ~AV_FRAME_FLAG_DISCARD);
    1713             :         }
    1714             :     }
    1715      404656 :     frame->reordered_opaque = avctx->reordered_opaque;
    1716             : 
    1717      404656 :     if (frame->color_primaries == AVCOL_PRI_UNSPECIFIED)
    1718      404656 :         frame->color_primaries = avctx->color_primaries;
    1719      404656 :     if (frame->color_trc == AVCOL_TRC_UNSPECIFIED)
    1720      404656 :         frame->color_trc = avctx->color_trc;
    1721      404656 :     if (frame->colorspace == AVCOL_SPC_UNSPECIFIED)
    1722      404656 :         frame->colorspace = avctx->colorspace;
    1723      404656 :     if (frame->color_range == AVCOL_RANGE_UNSPECIFIED)
    1724      404438 :         frame->color_range = avctx->color_range;
    1725      404656 :     if (frame->chroma_location == AVCHROMA_LOC_UNSPECIFIED)
    1726      404656 :         frame->chroma_location = avctx->chroma_sample_location;
    1727             : 
    1728      404656 :     switch (avctx->codec->type) {
    1729      114517 :     case AVMEDIA_TYPE_VIDEO:
    1730      114517 :         frame->format              = avctx->pix_fmt;
    1731      114517 :         if (!frame->sample_aspect_ratio.num)
    1732      114398 :             frame->sample_aspect_ratio = avctx->sample_aspect_ratio;
    1733             : 
    1734      208967 :         if (frame->width && frame->height &&
    1735       94450 :             av_image_check_sar(frame->width, frame->height,
    1736             :                                frame->sample_aspect_ratio) < 0) {
    1737           0 :             av_log(avctx, AV_LOG_WARNING, "ignoring invalid SAR: %u/%u\n",
    1738             :                    frame->sample_aspect_ratio.num,
    1739             :                    frame->sample_aspect_ratio.den);
    1740           0 :             frame->sample_aspect_ratio = (AVRational){ 0, 1 };
    1741             :         }
    1742             : 
    1743      114517 :         break;
    1744      290139 :     case AVMEDIA_TYPE_AUDIO:
    1745      290139 :         if (!frame->sample_rate)
    1746      290139 :             frame->sample_rate    = avctx->sample_rate;
    1747      290139 :         if (frame->format < 0)
    1748      290139 :             frame->format         = avctx->sample_fmt;
    1749      290139 :         if (!frame->channel_layout) {
    1750      290139 :             if (avctx->channel_layout) {
    1751      577728 :                  if (av_get_channel_layout_nb_channels(avctx->channel_layout) !=
    1752      288864 :                      avctx->channels) {
    1753           0 :                      av_log(avctx, AV_LOG_ERROR, "Inconsistent channel "
    1754             :                             "configuration.\n");
    1755           0 :                      return AVERROR(EINVAL);
    1756             :                  }
    1757             : 
    1758      288864 :                 frame->channel_layout = avctx->channel_layout;
    1759             :             } else {
    1760        1275 :                 if (avctx->channels > FF_SANE_NB_CHANNELS) {
    1761           0 :                     av_log(avctx, AV_LOG_ERROR, "Too many channels: %d.\n",
    1762             :                            avctx->channels);
    1763           0 :                     return AVERROR(ENOSYS);
    1764             :                 }
    1765             :             }
    1766             :         }
    1767      290139 :         frame->channels = avctx->channels;
    1768      290139 :         break;
    1769             :     }
    1770      404656 :     return 0;
    1771             : }
    1772             : 
    1773      379009 : static void validate_avframe_allocation(AVCodecContext *avctx, AVFrame *frame)
    1774             : {
    1775      379009 :     if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
    1776             :         int i;
    1777       88870 :         int num_planes = av_pix_fmt_count_planes(frame->format);
    1778       88870 :         const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format);
    1779       88870 :         int flags = desc ? desc->flags : 0;
    1780       88870 :         if (num_planes == 1 && (flags & AV_PIX_FMT_FLAG_PAL))
    1781        2133 :             num_planes = 2;
    1782       88870 :         if ((flags & FF_PSEUDOPAL) && frame->data[1])
    1783         299 :             num_planes = 2;
    1784      342181 :         for (i = 0; i < num_planes; i++) {
    1785      253311 :             av_assert0(frame->data[i]);
    1786             :         }
    1787             :         // For formats without data like hwaccel allow unused pointers to be non-NULL.
    1788      546519 :         for (i = num_planes; num_planes > 0 && i < FF_ARRAY_ELEMS(frame->data); i++) {
    1789      457649 :             if (frame->data[i])
    1790           0 :                 av_log(avctx, AV_LOG_ERROR, "Buffer returned by get_buffer2() did not zero unused plane pointers\n");
    1791      457649 :             frame->data[i] = NULL;
    1792             :         }
    1793             :     }
    1794      379009 : }
    1795             : 
    1796      379009 : static void decode_data_free(void *opaque, uint8_t *data)
    1797             : {
    1798      379009 :     FrameDecodeData *fdd = (FrameDecodeData*)data;
    1799             : 
    1800      379009 :     if (fdd->post_process_opaque_free)
    1801           0 :         fdd->post_process_opaque_free(fdd->post_process_opaque);
    1802             : 
    1803      379009 :     if (fdd->hwaccel_priv_free)
    1804           0 :         fdd->hwaccel_priv_free(fdd->hwaccel_priv);
    1805             : 
    1806      379009 :     av_freep(&fdd);
    1807      379009 : }
    1808             : 
    1809      379009 : int ff_attach_decode_data(AVFrame *frame)
    1810             : {
    1811             :     AVBufferRef *fdd_buf;
    1812             :     FrameDecodeData *fdd;
    1813             : 
    1814             :     av_assert1(!frame->private_ref);
    1815      379009 :     av_buffer_unref(&frame->private_ref);
    1816             : 
    1817      379009 :     fdd = av_mallocz(sizeof(*fdd));
    1818      379009 :     if (!fdd)
    1819           0 :         return AVERROR(ENOMEM);
    1820             : 
    1821      379009 :     fdd_buf = av_buffer_create((uint8_t*)fdd, sizeof(*fdd), decode_data_free,
    1822             :                                NULL, AV_BUFFER_FLAG_READONLY);
    1823      379009 :     if (!fdd_buf) {
    1824           0 :         av_freep(&fdd);
    1825           0 :         return AVERROR(ENOMEM);
    1826             :     }
    1827             : 
    1828      379009 :     frame->private_ref = fdd_buf;
    1829             : 
    1830      379009 :     return 0;
    1831             : }
    1832             : 
    1833      379009 : static int get_buffer_internal(AVCodecContext *avctx, AVFrame *frame, int flags)
    1834             : {
    1835      379009 :     const AVHWAccel *hwaccel = avctx->hwaccel;
    1836      379009 :     int override_dimensions = 1;
    1837             :     int ret;
    1838             : 
    1839      379009 :     if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
    1840       88870 :         if ((ret = av_image_check_size2(avctx->width, avctx->height, avctx->max_pixels, AV_PIX_FMT_NONE, 0, avctx)) < 0 || avctx->pix_fmt<0) {
    1841           0 :             av_log(avctx, AV_LOG_ERROR, "video_get_buffer: image parameters invalid\n");
    1842           0 :             return AVERROR(EINVAL);
    1843             :         }
    1844             : 
    1845       88870 :         if (frame->width <= 0 || frame->height <= 0) {
    1846       79288 :             frame->width  = FFMAX(avctx->width,  AV_CEIL_RSHIFT(avctx->coded_width,  avctx->lowres));
    1847       79288 :             frame->height = FFMAX(avctx->height, AV_CEIL_RSHIFT(avctx->coded_height, avctx->lowres));
    1848       79288 :             override_dimensions = 0;
    1849             :         }
    1850             : 
    1851       88870 :         if (frame->data[0] || frame->data[1] || frame->data[2] || frame->data[3]) {
    1852           0 :             av_log(avctx, AV_LOG_ERROR, "pic->data[*]!=NULL in get_buffer_internal\n");
    1853           0 :             return AVERROR(EINVAL);
    1854             :         }
    1855             :     }
    1856      379009 :     ret = ff_decode_frame_props(avctx, frame);
    1857      379009 :     if (ret < 0)
    1858           0 :         return ret;
    1859             : 
    1860      379009 :     if (hwaccel) {
    1861           0 :         if (hwaccel->alloc_frame) {
    1862           0 :             ret = hwaccel->alloc_frame(avctx, frame);
    1863           0 :             goto end;
    1864             :         }
    1865             :     } else
    1866      379009 :         avctx->sw_pix_fmt = avctx->pix_fmt;
    1867             : 
    1868      379009 :     ret = avctx->get_buffer2(avctx, frame, flags);
    1869      379009 :     if (ret < 0)
    1870           0 :         goto end;
    1871             : 
    1872      379009 :     validate_avframe_allocation(avctx, frame);
    1873             : 
    1874      379009 :     ret = ff_attach_decode_data(frame);
    1875      379009 :     if (ret < 0)
    1876           0 :         goto end;
    1877             : 
    1878      758018 : end:
    1879      458297 :     if (avctx->codec_type == AVMEDIA_TYPE_VIDEO && !override_dimensions &&
    1880       79288 :         !(avctx->codec->caps_internal & FF_CODEC_CAP_EXPORTS_CROPPING)) {
    1881       47142 :         frame->width  = avctx->width;
    1882       47142 :         frame->height = avctx->height;
    1883             :     }
    1884             : 
    1885      379009 :     if (ret < 0)
    1886           0 :         av_frame_unref(frame);
    1887             : 
    1888      379009 :     return ret;
    1889             : }
    1890             : 
    1891      379009 : int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
    1892             : {
    1893      379009 :     int ret = get_buffer_internal(avctx, frame, flags);
    1894      379009 :     if (ret < 0) {
    1895           0 :         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
    1896           0 :         frame->width = frame->height = 0;
    1897             :     }
    1898      379009 :     return ret;
    1899             : }
    1900             : 
    1901        7238 : static int reget_buffer_internal(AVCodecContext *avctx, AVFrame *frame)
    1902             : {
    1903             :     AVFrame *tmp;
    1904             :     int ret;
    1905             : 
    1906        7238 :     av_assert0(avctx->codec_type == AVMEDIA_TYPE_VIDEO);
    1907             : 
    1908        7238 :     if (frame->data[0] && (frame->width != avctx->width || frame->height != avctx->height || frame->format != avctx->pix_fmt)) {
    1909           0 :         av_log(avctx, AV_LOG_WARNING, "Picture changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s in reget buffer()\n",
    1910           0 :                frame->width, frame->height, av_get_pix_fmt_name(frame->format), avctx->width, avctx->height, av_get_pix_fmt_name(avctx->pix_fmt));
    1911           0 :         av_frame_unref(frame);
    1912             :     }
    1913             : 
    1914        7238 :     if (!frame->data[0])
    1915         121 :         return ff_get_buffer(avctx, frame, AV_GET_BUFFER_FLAG_REF);
    1916             : 
    1917        7117 :     if (av_frame_is_writable(frame))
    1918        5580 :         return ff_decode_frame_props(avctx, frame);
    1919             : 
    1920        1537 :     tmp = av_frame_alloc();
    1921        1537 :     if (!tmp)
    1922           0 :         return AVERROR(ENOMEM);
    1923             : 
    1924        1537 :     av_frame_move_ref(tmp, frame);
    1925             : 
    1926        1537 :     ret = ff_get_buffer(avctx, frame, AV_GET_BUFFER_FLAG_REF);
    1927        1537 :     if (ret < 0) {
    1928           0 :         av_frame_free(&tmp);
    1929           0 :         return ret;
    1930             :     }
    1931             : 
    1932        1537 :     av_frame_copy(frame, tmp);
    1933        1537 :     av_frame_free(&tmp);
    1934             : 
    1935        1537 :     return 0;
    1936             : }
    1937             : 
    1938        7238 : int ff_reget_buffer(AVCodecContext *avctx, AVFrame *frame)
    1939             : {
    1940        7238 :     int ret = reget_buffer_internal(avctx, frame);
    1941        7238 :     if (ret < 0)
    1942           0 :         av_log(avctx, AV_LOG_ERROR, "reget_buffer() failed\n");
    1943        7238 :     return ret;
    1944             : }
    1945             : 
    1946          28 : void avcodec_flush_buffers(AVCodecContext *avctx)
    1947             : {
    1948          28 :     avctx->internal->draining      = 0;
    1949          28 :     avctx->internal->draining_done = 0;
    1950          28 :     avctx->internal->nb_draining_errors = 0;
    1951          28 :     av_frame_unref(avctx->internal->buffer_frame);
    1952          28 :     av_frame_unref(avctx->internal->compat_decode_frame);
    1953          28 :     av_packet_unref(avctx->internal->buffer_pkt);
    1954          28 :     avctx->internal->buffer_pkt_valid = 0;
    1955             : 
    1956          28 :     av_packet_unref(avctx->internal->ds.in_pkt);
    1957             : 
    1958          28 :     if (HAVE_THREADS && avctx->active_thread_type & FF_THREAD_FRAME)
    1959           0 :         ff_thread_flush(avctx);
    1960          28 :     else if (avctx->codec->flush)
    1961           0 :         avctx->codec->flush(avctx);
    1962             : 
    1963          28 :     avctx->pts_correction_last_pts =
    1964          28 :     avctx->pts_correction_last_dts = INT64_MIN;
    1965             : 
    1966          28 :     ff_decode_bsfs_uninit(avctx);
    1967             : 
    1968          28 :     if (!avctx->refcounted_frames)
    1969          28 :         av_frame_unref(avctx->internal->to_free);
    1970          28 : }
    1971             : 
    1972       17624 : void ff_decode_bsfs_uninit(AVCodecContext *avctx)
    1973             : {
    1974       17624 :     DecodeFilterContext *s = &avctx->internal->filter;
    1975             :     int i;
    1976             : 
    1977       27294 :     for (i = 0; i < s->nb_bsfs; i++)
    1978        9670 :         av_bsf_free(&s->bsfs[i]);
    1979       17624 :     av_freep(&s->bsfs);
    1980       17624 :     s->nb_bsfs = 0;
    1981       17624 : }

Generated by: LCOV version 1.13