LCOV - code coverage report
Current view: top level - libavfilter - framequeue.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 78 80 97.5 %
Date: 2017-12-14 08:27:08 Functions: 9 9 100.0 %

          Line data    Source code
       1             : /*
       2             :  * Generic frame queue
       3             :  * Copyright (c) 2016 Nicolas George
       4             :  *
       5             :  * This file is part of FFmpeg.
       6             :  *
       7             :  * FFmpeg is free software; you can redistribute it and/or
       8             :  * modify it under the terms of the GNU Lesser General Public License
       9             :  * as published by the Free Software Foundation; either
      10             :  * version 2.1 of the License, or (at your option) any later version.
      11             :  *
      12             :  * FFmpeg is distributed in the hope that it will be useful,
      13             :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      14             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      15             :  * GNU Lesser General Public License for more details.
      16             :  *
      17             :  * You should have received a copy of the GNU Lesser General Public License
      18             :  * along with FFmpeg; if not, write to the Free Software Foundation, Inc.,
      19             :  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
      20             :  */
      21             : 
      22             : #include "libavutil/avassert.h"
      23             : #include "framequeue.h"
      24             : 
      25     2982054 : static inline FFFrameBucket *bucket(FFFrameQueue *fq, size_t idx)
      26             : {
      27     2982054 :     return &fq->queue[(fq->tail + idx) & (fq->allocated - 1)];
      28             : }
      29             : 
      30        5474 : void ff_framequeue_global_init(FFFrameQueueGlobal *fqg)
      31             : {
      32        5474 : }
      33             : 
      34     5924540 : static void check_consistency(FFFrameQueue *fq)
      35             : {
      36             : #if defined(ASSERT_LEVEL) && ASSERT_LEVEL >= 2
      37             :     uint64_t nb_samples = 0;
      38             :     size_t i;
      39             : 
      40             :     av_assert0(fq->queued == fq->total_frames_head - fq->total_frames_tail);
      41             :     for (i = 0; i < fq->queued; i++)
      42             :         nb_samples += bucket(fq, i)->frame->nb_samples;
      43             :     av_assert0(nb_samples == fq->total_samples_head - fq->total_samples_tail);
      44             : #endif
      45     5924540 : }
      46             : 
      47       21707 : void ff_framequeue_init(FFFrameQueue *fq, FFFrameQueueGlobal *fqg)
      48             : {
      49       21707 :     fq->queue = &fq->first_bucket;
      50       21707 :     fq->allocated = 1;
      51       21707 : }
      52             : 
      53       21833 : void ff_framequeue_free(FFFrameQueue *fq)
      54             : {
      55       43701 :     while (fq->queued) {
      56          35 :         AVFrame *frame = ff_framequeue_take(fq);
      57          35 :         av_frame_free(&frame);
      58             :     }
      59       21833 :     if (fq->queue != &fq->first_bucket)
      60         286 :         av_freep(&fq->queue);
      61       21833 : }
      62             : 
      63     1413663 : int ff_framequeue_add(FFFrameQueue *fq, AVFrame *frame)
      64             : {
      65             :     FFFrameBucket *b;
      66             : 
      67     1413663 :     check_consistency(fq);
      68     1413663 :     if (fq->queued == fq->allocated) {
      69         264 :         if (fq->allocated == 1) {
      70         160 :             size_t na = 8;
      71         160 :             FFFrameBucket *nq = av_realloc_array(NULL, na, sizeof(*nq));
      72         160 :             if (!nq)
      73           0 :                 return AVERROR(ENOMEM);
      74         160 :             nq[0] = fq->queue[0];
      75         160 :             fq->queue = nq;
      76         160 :             fq->allocated = na;
      77             :         } else {
      78         104 :             size_t na = fq->allocated << 1;
      79         104 :             FFFrameBucket *nq = av_realloc_array(fq->queue, na, sizeof(*nq));
      80         104 :             if (!nq)
      81           0 :                 return AVERROR(ENOMEM);
      82         104 :             if (fq->tail + fq->queued > fq->allocated)
      83          16 :                 memmove(nq + fq->allocated, nq,
      84          16 :                         (fq->tail + fq->queued - fq->allocated) * sizeof(*nq));
      85         104 :             fq->queue = nq;
      86         104 :             fq->allocated = na;
      87             :         }
      88             :     }
      89     1413663 :     b = bucket(fq, fq->queued);
      90     1413663 :     b->frame = frame;
      91     1413663 :     fq->queued++;
      92     1413663 :     fq->total_frames_head++;
      93     1413663 :     fq->total_samples_head += frame->nb_samples;
      94     1413663 :     check_consistency(fq);
      95     1413663 :     return 0;
      96             : }
      97             : 
      98     1413663 : AVFrame *ff_framequeue_take(FFFrameQueue *fq)
      99             : {
     100             :     FFFrameBucket *b;
     101             : 
     102     1413663 :     check_consistency(fq);
     103             :     av_assert1(fq->queued);
     104     1413663 :     b = bucket(fq, 0);
     105     1413663 :     fq->queued--;
     106     1413663 :     fq->tail++;
     107     1413663 :     fq->tail &= fq->allocated - 1;
     108     1413663 :     fq->total_frames_tail++;
     109     1413663 :     fq->total_samples_tail += b->frame->nb_samples;
     110     1413663 :     fq->samples_skipped = 0;
     111     1413663 :     check_consistency(fq);
     112     1413663 :     return b->frame;
     113             : }
     114             : 
     115      115160 : AVFrame *ff_framequeue_peek(FFFrameQueue *fq, size_t idx)
     116             : {
     117             :     FFFrameBucket *b;
     118             : 
     119      115160 :     check_consistency(fq);
     120             :     av_assert1(idx < fq->queued);
     121      115160 :     b = bucket(fq, idx);
     122      115160 :     check_consistency(fq);
     123      115160 :     return b->frame;
     124             : }
     125             : 
     126       39568 : void ff_framequeue_skip_samples(FFFrameQueue *fq, size_t samples, AVRational time_base)
     127             : {
     128             :     FFFrameBucket *b;
     129             :     size_t bytes;
     130             :     int planar, planes, i;
     131             : 
     132       39568 :     check_consistency(fq);
     133             :     av_assert1(fq->queued);
     134       39568 :     b = bucket(fq, 0);
     135             :     av_assert1(samples < b->frame->nb_samples);
     136       39568 :     planar = av_sample_fmt_is_planar(b->frame->format);
     137       39568 :     planes = planar ? b->frame->channels : 1;
     138       39568 :     bytes = samples * av_get_bytes_per_sample(b->frame->format);
     139       39568 :     if (!planar)
     140       22294 :         bytes *= b->frame->channels;
     141       39568 :     if (b->frame->pts != AV_NOPTS_VALUE)
     142       39568 :         b->frame->pts += av_rescale_q(samples, av_make_q(1, b->frame->sample_rate), time_base);
     143       39568 :     b->frame->nb_samples -= samples;
     144       39568 :     b->frame->linesize[0] -= bytes;
     145       96663 :     for (i = 0; i < planes; i++)
     146       57095 :         b->frame->extended_data[i] += bytes;
     147       96663 :     for (i = 0; i < planes && i < AV_NUM_DATA_POINTERS; i++)
     148       57095 :         b->frame->data[i] = b->frame->extended_data[i];
     149       39568 :     fq->total_samples_tail += samples;
     150       39568 :     fq->samples_skipped = 1;
     151       39568 :     ff_framequeue_update_peeked(fq, 0);
     152       39568 : }

Generated by: LCOV version 1.13