git.sesse.net Git - ffmpeg/blob - libavfilter/framequeue.c

   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 static inline FFFrameBucket *bucket(FFFrameQueue *fq, size_t idx)
  26 {
  27     return &fq->queue[(fq->tail + idx) & (fq->allocated - 1)];
  28 }
  29
  30 void ff_framequeue_global_init(FFFrameQueueGlobal *fqg)
  31 {
  32 }
  33
  34 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 }
  46
  47 void ff_framequeue_init(FFFrameQueue *fq, FFFrameQueueGlobal *fqg)
  48 {
  49     fq->queue = &fq->first_bucket;
  50     fq->allocated = 1;
  51 }
  52
  53 void ff_framequeue_free(FFFrameQueue *fq)
  54 {
  55     while (fq->queued) {
  56         AVFrame *frame = ff_framequeue_take(fq);
  57         av_frame_free(&frame);
  58     }
  59     if (fq->queue != &fq->first_bucket)
  60         av_freep(&fq->queue);
  61 }
  62
  63 int ff_framequeue_add(FFFrameQueue *fq, AVFrame *frame)
  64 {
  65     FFFrameBucket *b;
  66
  67     check_consistency(fq);
  68     if (fq->queued == fq->allocated) {
  69         if (fq->allocated == 1) {
  70             size_t na = 8;
  71             FFFrameBucket *nq = av_realloc_array(NULL, na, sizeof(*nq));
  72             if (!nq)
  73                 return AVERROR(ENOMEM);
  74             nq[0] = fq->queue[0];
  75             fq->queue = nq;
  76             fq->allocated = na;
  77         } else {
  78             size_t na = fq->allocated << 1;
  79             FFFrameBucket *nq = av_realloc_array(fq->queue, na, sizeof(*nq));
  80             if (!nq)
  81                 return AVERROR(ENOMEM);
  82             if (fq->tail + fq->queued > fq->allocated)
  83                 memmove(nq + fq->allocated, nq,
  84                         (fq->tail + fq->queued - fq->allocated) * sizeof(*nq));
  85             fq->queue = nq;
  86             fq->allocated = na;
  87         }
  88     }
  89     b = bucket(fq, fq->queued);
  90     b->frame = frame;
  91     fq->queued++;
  92     fq->total_frames_head++;
  93     fq->total_samples_head += frame->nb_samples;
  94     check_consistency(fq);
  95     return 0;
  96 }
  97
  98 AVFrame *ff_framequeue_take(FFFrameQueue *fq)
  99 {
 100     FFFrameBucket *b;
 101
 102     check_consistency(fq);
 103     av_assert1(fq->queued);
 104     b = bucket(fq, 0);
 105     fq->queued--;
 106     fq->tail++;
 107     fq->tail &= fq->allocated - 1;
 108     fq->total_frames_tail++;
 109     fq->total_samples_tail += b->frame->nb_samples;
 110     check_consistency(fq);
 111     return b->frame;
 112 }
 113
 114 AVFrame *ff_framequeue_peek(FFFrameQueue *fq, size_t idx)
 115 {
 116     FFFrameBucket *b;
 117
 118     check_consistency(fq);
 119     av_assert1(idx < fq->queued);
 120     b = bucket(fq, idx);
 121     check_consistency(fq);
 122     return b->frame;
 123 }
 124
 125 void ff_framequeue_skip_samples(FFFrameQueue *fq, size_t samples, AVRational time_base)
 126 {
 127     FFFrameBucket *b;
 128     size_t bytes;
 129     int planar, planes, i;
 130
 131     check_consistency(fq);
 132     av_assert1(fq->queued);
 133     b = bucket(fq, 0);
 134     av_assert1(samples < b->frame->nb_samples);
 135     planar = av_sample_fmt_is_planar(b->frame->format);
 136     planes = planar ? b->frame->channels : 1;
 137     bytes = samples * av_get_bytes_per_sample(b->frame->format);
 138     if (!planar)
 139         bytes *= b->frame->channels;
 140     if (b->frame->pts != AV_NOPTS_VALUE)
 141         b->frame->pts += av_rescale_q(samples, av_make_q(1, b->frame->sample_rate), time_base);
 142     b->frame->nb_samples -= samples;
 143     b->frame->linesize[0] -= bytes;
 144     for (i = 0; i < planes; i++)
 145         b->frame->extended_data[i] += bytes;
 146     for (i = 0; i < planes && i < AV_NUM_DATA_POINTERS; i++)
 147         b->frame->data[i] = b->frame->extended_data[i];
 148     fq->total_samples_tail += samples;
 149     ff_framequeue_update_peeked(fq, 0);
 150 }