avfilter/af_afftdn: add alias for sample_noise end
[ffmpeg.git] / 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     fq->samples_skipped = 0;
111     check_consistency(fq);
112     return b->frame;
113 }
114
115 AVFrame *ff_framequeue_peek(FFFrameQueue *fq, size_t idx)
116 {
117     FFFrameBucket *b;
118
119     check_consistency(fq);
120     av_assert1(idx < fq->queued);
121     b = bucket(fq, idx);
122     check_consistency(fq);
123     return b->frame;
124 }
125
126 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     check_consistency(fq);
133     av_assert1(fq->queued);
134     b = bucket(fq, 0);
135     av_assert1(samples < b->frame->nb_samples);
136     planar = av_sample_fmt_is_planar(b->frame->format);
137     planes = planar ? b->frame->channels : 1;
138     bytes = samples * av_get_bytes_per_sample(b->frame->format);
139     if (!planar)
140         bytes *= b->frame->channels;
141     if (b->frame->pts != AV_NOPTS_VALUE)
142         b->frame->pts += av_rescale_q(samples, av_make_q(1, b->frame->sample_rate), time_base);
143     b->frame->nb_samples -= samples;
144     b->frame->linesize[0] -= bytes;
145     for (i = 0; i < planes; i++)
146         b->frame->extended_data[i] += bytes;
147     for (i = 0; i < planes && i < AV_NUM_DATA_POINTERS; i++)
148         b->frame->data[i] = b->frame->extended_data[i];
149     fq->total_samples_tail += samples;
150     fq->samples_skipped = 1;
151     ff_framequeue_update_peeked(fq, 0);
152 }