GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavfilter/framepool.c Lines: 108 144 75.0 %
Date: 2020-08-13 15:06:06 Branches: 64 95 67.4 %

Line Branch Exec Source
1
/*
2
 * This file is part of FFmpeg.
3
 *
4
 * Copyright (c) 2015 Matthieu Bouron <matthieu.bouron stupeflix.com>
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 "framepool.h"
22
#include "libavutil/avassert.h"
23
#include "libavutil/avutil.h"
24
#include "libavutil/buffer.h"
25
#include "libavutil/frame.h"
26
#include "libavutil/imgutils.h"
27
#include "libavutil/mem.h"
28
#include "libavutil/pixfmt.h"
29
30
struct FFFramePool {
31
32
    enum AVMediaType type;
33
34
    /* video */
35
    int width;
36
    int height;
37
38
    /* audio */
39
    int planes;
40
    int channels;
41
    int nb_samples;
42
43
    /* common */
44
    int format;
45
    int align;
46
    int linesize[4];
47
    AVBufferPool *pools[4];
48
49
};
50
51
4398
FFFramePool *ff_frame_pool_video_init(AVBufferRef* (*alloc)(int size),
52
                                      int width,
53
                                      int height,
54
                                      enum AVPixelFormat format,
55
                                      int align)
56
{
57
    int i, ret;
58
    FFFramePool *pool;
59
4398
    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(format);
60
61
4398
    if (!desc)
62
        return NULL;
63
64
4398
    pool = av_mallocz(sizeof(FFFramePool));
65
4398
    if (!pool)
66
        return NULL;
67
68
4398
    pool->type = AVMEDIA_TYPE_VIDEO;
69
4398
    pool->width = width;
70
4398
    pool->height = height;
71
4398
    pool->format = format;
72
4398
    pool->align = align;
73
74
4398
    if ((ret = av_image_check_size2(width, height, INT64_MAX, format, 0, NULL)) < 0) {
75
        goto fail;
76
    }
77
78
4398
    if (!pool->linesize[0]) {
79
6649
        for(i = 1; i <= align; i += i) {
80
6613
            ret = av_image_fill_linesizes(pool->linesize, pool->format,
81
6613
                                          FFALIGN(pool->width, i));
82
6613
            if (ret < 0) {
83
                goto fail;
84
            }
85
6613
            if (!(pool->linesize[0] & (pool->align - 1)))
86
4362
                break;
87
        }
88
89

15197
        for (i = 0; i < 4 && pool->linesize[i]; i++) {
90
10799
            pool->linesize[i] = FFALIGN(pool->linesize[i], pool->align);
91
        }
92
    }
93
94

15197
    for (i = 0; i < 4 && pool->linesize[i]; i++) {
95
10799
        int h = FFALIGN(pool->height, 32);
96

10799
        if (i == 1 || i == 2)
97
5686
            h = AV_CEIL_RSHIFT(h, desc->log2_chroma_h);
98
99
10799
        pool->pools[i] = av_buffer_pool_init(pool->linesize[i] * h + 16 + 16 - 1,
100
                                             alloc);
101
10799
        if (!pool->pools[i])
102
            goto fail;
103
    }
104
105
4398
    if (desc->flags & AV_PIX_FMT_FLAG_PAL ||
106
4384
        desc->flags & FF_PSEUDOPAL) {
107
137
        pool->pools[1] = av_buffer_pool_init(AVPALETTE_SIZE, alloc);
108
137
        if (!pool->pools[1])
109
            goto fail;
110
    }
111
112
4398
    return pool;
113
114
fail:
115
    ff_frame_pool_uninit(&pool);
116
    return NULL;
117
}
118
119
3306
FFFramePool *ff_frame_pool_audio_init(AVBufferRef* (*alloc)(int size),
120
                                      int channels,
121
                                      int nb_samples,
122
                                      enum AVSampleFormat format,
123
                                      int align)
124
{
125
    int ret, planar;
126
    FFFramePool *pool;
127
128
3306
    pool = av_mallocz(sizeof(FFFramePool));
129
3306
    if (!pool)
130
        return NULL;
131
132
3306
    planar = av_sample_fmt_is_planar(format);
133
134
3306
    pool->type = AVMEDIA_TYPE_AUDIO;
135
3306
    pool->planes = planar ? channels : 1;
136
3306
    pool->channels = channels;
137
3306
    pool->nb_samples = nb_samples;
138
3306
    pool->format = format;
139
3306
    pool->align = align;
140
141
3306
    ret = av_samples_get_buffer_size(&pool->linesize[0], channels,
142
                                     nb_samples, format, 0);
143
3306
    if (ret < 0)
144
        goto fail;
145
146
3306
    pool->pools[0] = av_buffer_pool_init(pool->linesize[0], NULL);
147
3306
    if (!pool->pools[0])
148
        goto fail;
149
150
3306
    return pool;
151
152
fail:
153
    ff_frame_pool_uninit(&pool);
154
    return NULL;
155
}
156
157
40065
int ff_frame_pool_get_video_config(FFFramePool *pool,
158
                                   int *width,
159
                                   int *height,
160
                                   enum AVPixelFormat *format,
161
                                   int *align)
162
{
163
40065
    if (!pool)
164
        return AVERROR(EINVAL);
165
166
40065
    av_assert0(pool->type == AVMEDIA_TYPE_VIDEO);
167
168
40065
    *width = pool->width;
169
40065
    *height = pool->height;
170
40065
    *format = pool->format;
171
40065
    *align = pool->align;
172
173
40065
    return 0;
174
}
175
176
354793
int ff_frame_pool_get_audio_config(FFFramePool *pool,
177
                                   int *channels,
178
                                   int *nb_samples,
179
                                   enum AVSampleFormat *format,
180
                                   int *align)
181
{
182
354793
    if (!pool)
183
        return AVERROR(EINVAL);
184
185
354793
    av_assert0(pool->type == AVMEDIA_TYPE_AUDIO);
186
187
354793
    *channels = pool->channels;
188
354793
    *nb_samples = pool->nb_samples;
189
354793
    *format = pool->format;
190
354793
    *align = pool->align;
191
192
354793
    return 0;
193
}
194
195
400618
AVFrame *ff_frame_pool_get(FFFramePool *pool)
196
{
197
    int i;
198
    AVFrame *frame;
199
    const AVPixFmtDescriptor *desc;
200
201
400618
    frame = av_frame_alloc();
202
400618
    if (!frame) {
203
        return NULL;
204
    }
205
206
400618
    switch(pool->type) {
207
44462
    case AVMEDIA_TYPE_VIDEO:
208
44462
        desc = av_pix_fmt_desc_get(pool->format);
209
44462
        if (!desc) {
210
            goto fail;
211
        }
212
213
44462
        frame->width = pool->width;
214
44462
        frame->height = pool->height;
215
44462
        frame->format = pool->format;
216
217
151144
        for (i = 0; i < 4; i++) {
218
148824
            frame->linesize[i] = pool->linesize[i];
219
148824
            if (!pool->pools[i])
220
42142
                break;
221
222
106682
            frame->buf[i] = av_buffer_pool_get(pool->pools[i]);
223
106682
            if (!frame->buf[i])
224
                goto fail;
225
226
106682
            frame->data[i] = frame->buf[i]->data;
227
        }
228
229
44462
        if (desc->flags & AV_PIX_FMT_FLAG_PAL ||
230
44066
            desc->flags & FF_PSEUDOPAL) {
231
2000
            enum AVPixelFormat format =
232
2000
                pool->format == AV_PIX_FMT_PAL8 ? AV_PIX_FMT_BGR8 : pool->format;
233
234
2000
            av_assert0(frame->data[1] != NULL);
235
2000
            if (avpriv_set_systematic_pal2((uint32_t *)frame->data[1], format) < 0)
236
                goto fail;
237
        }
238
239
44462
        frame->extended_data = frame->data;
240
44462
        break;
241
356156
    case AVMEDIA_TYPE_AUDIO:
242
356156
        frame->nb_samples = pool->nb_samples;
243
356156
        frame->channels = pool->channels;
244
356156
        frame->format = pool->format;
245
356156
        frame->linesize[0] = pool->linesize[0];
246
247
356156
        if (pool->planes > AV_NUM_DATA_POINTERS) {
248
            frame->extended_data = av_mallocz_array(pool->planes,
249
                                                    sizeof(*frame->extended_data));
250
            frame->nb_extended_buf = pool->planes - AV_NUM_DATA_POINTERS;
251
            frame->extended_buf = av_mallocz_array(frame->nb_extended_buf,
252
                                                   sizeof(*frame->extended_buf));
253
            if (!frame->extended_data || !frame->extended_buf)
254
                goto fail;
255
        } else {
256
356156
            frame->extended_data = frame->data;
257
356156
            av_assert0(frame->nb_extended_buf == 0);
258
        }
259
260
769339
        for (i = 0; i < FFMIN(pool->planes, AV_NUM_DATA_POINTERS); i++) {
261
413183
            frame->buf[i] = av_buffer_pool_get(pool->pools[0]);
262
413183
            if (!frame->buf[i])
263
                goto fail;
264
413183
            frame->extended_data[i] = frame->data[i] = frame->buf[i]->data;
265
        }
266
356156
        for (i = 0; i < frame->nb_extended_buf; i++) {
267
            frame->extended_buf[i] = av_buffer_pool_get(pool->pools[0]);
268
            if (!frame->extended_buf[i])
269
                goto fail;
270
            frame->extended_data[i + AV_NUM_DATA_POINTERS] = frame->extended_buf[i]->data;
271
        }
272
273
356156
        break;
274
    default:
275
        av_assert0(0);
276
    }
277
278
400618
    return frame;
279
fail:
280
    av_frame_free(&frame);
281
    return NULL;
282
}
283
284
26059
void ff_frame_pool_uninit(FFFramePool **pool)
285
{
286
    int i;
287
288

26059
    if (!pool || !*pool)
289
18355
        return;
290
291
38520
    for (i = 0; i < 4; i++) {
292
30816
        av_buffer_pool_uninit(&(*pool)->pools[i]);
293
    }
294
295
7704
    av_freep(pool);
296
}