LCOV - code coverage report
Current view: top level - src/libavfilter - framequeue.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 57 59 96.6 %
Date: 2017-01-28 02:43:52 Functions: 8 8 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     2877039 : static inline FFFrameBucket *bucket(FFFrameQueue *fq, size_t idx)
      26             : {
      27     2877039 :     return &fq->queue[(fq->tail + idx) & (fq->allocated - 1)];
      28             : }
      29             : 
      30        5167 : void ff_framequeue_global_init(FFFrameQueueGlobal *fqg)
      31             : {
      32        5167 : }
      33             : 
      34     5754078 : 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     5754078 : }
      46             : 
      47       20297 : void ff_framequeue_init(FFFrameQueue *fq, FFFrameQueueGlobal *fqg)
      48             : {
      49       20297 :     fq->queue = &fq->first_bucket;
      50       20297 :     fq->allocated = 1;
      51       20297 : }
      52             : 
      53       20411 : void ff_framequeue_free(FFFrameQueue *fq)
      54             : {
      55       40831 :     while (fq->queued) {
      56           9 :         AVFrame *frame = ff_framequeue_take(fq);
      57           9 :         av_frame_free(&frame);
      58             :     }
      59       20411 :     if (fq->queue != &fq->first_bucket)
      60         268 :         av_freep(&fq->queue);
      61       20411 : }
      62             : 
      63     1387552 : int ff_framequeue_add(FFFrameQueue *fq, AVFrame *frame)
      64             : {
      65             :     FFFrameBucket *b;
      66             : 
      67     1387552 :     check_consistency(fq);
      68     1387552 :     if (fq->queued == fq->allocated) {
      69         255 :         if (fq->allocated == 1) {
      70         154 :             size_t na = 8;
      71         154 :             FFFrameBucket *nq = av_realloc_array(NULL, na, sizeof(*nq));
      72         154 :             if (!nq)
      73           0 :                 return AVERROR(ENOMEM);
      74         154 :             nq[0] = fq->queue[0];
      75         154 :             fq->queue = nq;
      76         154 :             fq->allocated = na;
      77             :         } else {
      78         101 :             size_t na = fq->allocated << 1;
      79         101 :             FFFrameBucket *nq = av_realloc_array(fq->queue, na, sizeof(*nq));
      80         101 :             if (!nq)
      81           0 :                 return AVERROR(ENOMEM);
      82         101 :             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         101 :             fq->queue = nq;
      86         101 :             fq->allocated = na;
      87             :         }
      88             :     }
      89     1387552 :     b = bucket(fq, fq->queued);
      90     1387552 :     b->frame = frame;
      91     1387552 :     fq->queued++;
      92     1387552 :     fq->total_frames_head++;
      93     1387552 :     fq->total_samples_head += frame->nb_samples;
      94     1387552 :     check_consistency(fq);
      95     1387552 :     return 0;
      96             : }
      97             : 
      98     1387552 : AVFrame *ff_framequeue_take(FFFrameQueue *fq)
      99             : {
     100             :     FFFrameBucket *b;
     101             : 
     102     1387552 :     check_consistency(fq);
     103             :     av_assert1(fq->queued);
     104     1387552 :     b = bucket(fq, 0);
     105     1387552 :     fq->queued--;
     106     1387552 :     fq->tail++;
     107     1387552 :     fq->tail &= fq->allocated - 1;
     108     1387552 :     fq->total_frames_tail++;
     109     1387552 :     fq->total_samples_tail += b->frame->nb_samples;
     110     1387552 :     check_consistency(fq);
     111     1387552 :     return b->frame;
     112             : }
     113             : 
     114      101935 : AVFrame *ff_framequeue_peek(FFFrameQueue *fq, size_t idx)
     115             : {
     116             :     FFFrameBucket *b;
     117             : 
     118      101935 :     check_consistency(fq);
     119             :     av_assert1(idx < fq->queued);
     120      101935 :     b = bucket(fq, idx);
     121      101935 :     check_consistency(fq);
     122      101935 :     return b->frame;
     123             : }

Generated by: LCOV version 1.12