FFmpeg
get_buffer.c
Go to the documentation of this file.
1 /*
2  * The default get_buffer2() implementation
3  *
4  * This file is part of FFmpeg.
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 <stdint.h>
22 
23 #include "libavutil/avassert.h"
24 #include "libavutil/avutil.h"
25 #include "libavutil/buffer.h"
26 #include "libavutil/frame.h"
27 #include "libavutil/hwcontext.h"
28 #include "libavutil/imgutils.h"
29 #include "libavutil/mem.h"
30 #include "libavutil/samplefmt.h"
31 #include "libavutil/version.h"
32 
33 #include "avcodec.h"
34 #include "internal.h"
35 
36 typedef struct FramePool {
37  /**
38  * Pools for each data plane. For audio all the planes have the same size,
39  * so only pools[0] is used.
40  */
42 
43  /*
44  * Pool parameters
45  */
46  int format;
47  int width, height;
49  int linesize[4];
50  int planes;
51  int channels;
52  int samples;
53 } FramePool;
54 
55 static void frame_pool_free(void *opaque, uint8_t *data)
56 {
57  FramePool *pool = (FramePool*)data;
58  int i;
59 
60  for (i = 0; i < FF_ARRAY_ELEMS(pool->pools); i++)
61  av_buffer_pool_uninit(&pool->pools[i]);
62 
63  av_freep(&data);
64 }
65 
67 {
68  FramePool *pool = av_mallocz(sizeof(*pool));
69  AVBufferRef *buf;
70 
71  if (!pool)
72  return NULL;
73 
74  buf = av_buffer_create((uint8_t*)pool, sizeof(*pool),
75  frame_pool_free, NULL, 0);
76  if (!buf) {
77  av_freep(&pool);
78  return NULL;
79  }
80 
81  return buf;
82 }
83 
85 {
86  FramePool *pool = avctx->internal->pool ?
87  (FramePool*)avctx->internal->pool->data : NULL;
88  AVBufferRef *pool_buf;
89  int i, ret, ch, planes;
90 
91  if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
92  int planar = av_sample_fmt_is_planar(frame->format);
93  ch = frame->ch_layout.nb_channels;
94 #if FF_API_OLD_CHANNEL_LAYOUT
96  if (!ch)
97  ch = frame->channels;
99 #endif
100  planes = planar ? ch : 1;
101  }
102 
103  if (pool && pool->format == frame->format) {
104  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO &&
105  pool->width == frame->width && pool->height == frame->height)
106  return 0;
107  if (avctx->codec_type == AVMEDIA_TYPE_AUDIO && pool->planes == planes &&
108  pool->channels == ch && frame->nb_samples == pool->samples)
109  return 0;
110  }
111 
112  pool_buf = frame_pool_alloc();
113  if (!pool_buf)
114  return AVERROR(ENOMEM);
115  pool = (FramePool*)pool_buf->data;
116 
117  switch (avctx->codec_type) {
118  case AVMEDIA_TYPE_VIDEO: {
119  int linesize[4];
120  int w = frame->width;
121  int h = frame->height;
122  int unaligned;
123  ptrdiff_t linesize1[4];
124  size_t size[4];
125 
126  avcodec_align_dimensions2(avctx, &w, &h, pool->stride_align);
127 
128  do {
129  // NOTE: do not align linesizes individually, this breaks e.g. assumptions
130  // that linesize[0] == 2*linesize[1] in the MPEG-encoder for 4:2:2
131  ret = av_image_fill_linesizes(linesize, avctx->pix_fmt, w);
132  if (ret < 0)
133  goto fail;
134  // increase alignment of w for next try (rhs gives the lowest bit set in w)
135  w += w & ~(w - 1);
136 
137  unaligned = 0;
138  for (i = 0; i < 4; i++)
139  unaligned |= linesize[i] % pool->stride_align[i];
140  } while (unaligned);
141 
142  for (i = 0; i < 4; i++)
143  linesize1[i] = linesize[i];
144  ret = av_image_fill_plane_sizes(size, avctx->pix_fmt, h, linesize1);
145  if (ret < 0)
146  goto fail;
147 
148  for (i = 0; i < 4; i++) {
149  pool->linesize[i] = linesize[i];
150  if (size[i]) {
151  if (size[i] > INT_MAX - (16 + STRIDE_ALIGN - 1)) {
152  ret = AVERROR(EINVAL);
153  goto fail;
154  }
155  pool->pools[i] = av_buffer_pool_init(size[i] + 16 + STRIDE_ALIGN - 1,
156  CONFIG_MEMORY_POISONING ?
157  NULL :
159  if (!pool->pools[i]) {
160  ret = AVERROR(ENOMEM);
161  goto fail;
162  }
163  }
164  }
165  pool->format = frame->format;
166  pool->width = frame->width;
167  pool->height = frame->height;
168 
169  break;
170  }
171  case AVMEDIA_TYPE_AUDIO: {
172  ret = av_samples_get_buffer_size(&pool->linesize[0], ch,
173  frame->nb_samples, frame->format, 0);
174  if (ret < 0)
175  goto fail;
176 
177  pool->pools[0] = av_buffer_pool_init(pool->linesize[0], NULL);
178  if (!pool->pools[0]) {
179  ret = AVERROR(ENOMEM);
180  goto fail;
181  }
182 
183  pool->format = frame->format;
184  pool->planes = planes;
185  pool->channels = ch;
186  pool->samples = frame->nb_samples;
187  break;
188  }
189  default: av_assert0(0);
190  }
191 
192  av_buffer_unref(&avctx->internal->pool);
193  avctx->internal->pool = pool_buf;
194 
195  return 0;
196 fail:
197  av_buffer_unref(&pool_buf);
198  return ret;
199 }
200 
202 {
203  FramePool *pool = (FramePool*)avctx->internal->pool->data;
204  int planes = pool->planes;
205  int i;
206 
207  frame->linesize[0] = pool->linesize[0];
208 
210  frame->extended_data = av_calloc(planes, sizeof(*frame->extended_data));
211  frame->nb_extended_buf = planes - AV_NUM_DATA_POINTERS;
212  frame->extended_buf = av_calloc(frame->nb_extended_buf,
213  sizeof(*frame->extended_buf));
214  if (!frame->extended_data || !frame->extended_buf) {
215  av_freep(&frame->extended_data);
216  av_freep(&frame->extended_buf);
217  return AVERROR(ENOMEM);
218  }
219  } else {
220  frame->extended_data = frame->data;
221  av_assert0(frame->nb_extended_buf == 0);
222  }
223 
224  for (i = 0; i < FFMIN(planes, AV_NUM_DATA_POINTERS); i++) {
225  frame->buf[i] = av_buffer_pool_get(pool->pools[0]);
226  if (!frame->buf[i])
227  goto fail;
228  frame->extended_data[i] = frame->data[i] = frame->buf[i]->data;
229  }
230  for (i = 0; i < frame->nb_extended_buf; i++) {
231  frame->extended_buf[i] = av_buffer_pool_get(pool->pools[0]);
232  if (!frame->extended_buf[i])
233  goto fail;
234  frame->extended_data[i + AV_NUM_DATA_POINTERS] = frame->extended_buf[i]->data;
235  }
236 
237  if (avctx->debug & FF_DEBUG_BUFFERS)
238  av_log(avctx, AV_LOG_DEBUG, "default_get_buffer called on frame %p", frame);
239 
240  return 0;
241 fail:
243  return AVERROR(ENOMEM);
244 }
245 
247 {
248  FramePool *pool = (FramePool*)s->internal->pool->data;
249  int i;
250 
251  if (pic->data[0] || pic->data[1] || pic->data[2] || pic->data[3]) {
252  av_log(s, AV_LOG_ERROR, "pic->data[*]!=NULL in avcodec_default_get_buffer\n");
253  return -1;
254  }
255 
256  memset(pic->data, 0, sizeof(pic->data));
257  pic->extended_data = pic->data;
258 
259  for (i = 0; i < 4 && pool->pools[i]; i++) {
260  pic->linesize[i] = pool->linesize[i];
261 
262  pic->buf[i] = av_buffer_pool_get(pool->pools[i]);
263  if (!pic->buf[i])
264  goto fail;
265 
266  pic->data[i] = pic->buf[i]->data;
267  }
268  for (; i < AV_NUM_DATA_POINTERS; i++) {
269  pic->data[i] = NULL;
270  pic->linesize[i] = 0;
271  }
272 
273  if (s->debug & FF_DEBUG_BUFFERS)
274  av_log(s, AV_LOG_DEBUG, "default_get_buffer called on pic %p\n", pic);
275 
276  return 0;
277 fail:
278  av_frame_unref(pic);
279  return AVERROR(ENOMEM);
280 }
281 
283 {
284  int ret;
285 
286  if (avctx->hw_frames_ctx) {
288  frame->width = avctx->coded_width;
289  frame->height = avctx->coded_height;
290  return ret;
291  }
292 
293  if ((ret = update_frame_pool(avctx, frame)) < 0)
294  return ret;
295 
296  switch (avctx->codec_type) {
297  case AVMEDIA_TYPE_VIDEO:
298  return video_get_buffer(avctx, frame);
299  case AVMEDIA_TYPE_AUDIO:
300  return audio_get_buffer(avctx, frame);
301  default:
302  return -1;
303  }
304 }
FF_ENABLE_DEPRECATION_WARNINGS
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:82
av_buffer_pool_init
AVBufferPool * av_buffer_pool_init(size_t size, AVBufferRef *(*alloc)(size_t size))
Allocate and initialize a buffer pool.
Definition: buffer.c:280
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
AVBufferPool
The buffer pool.
Definition: buffer_internal.h:88
FramePool::planes
int planes
Definition: get_buffer.c:50
AVBufferRef::data
uint8_t * data
The data buffer.
Definition: buffer.h:90
video_get_buffer
static int video_get_buffer(AVCodecContext *s, AVFrame *pic)
Definition: get_buffer.c:246
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:325
FramePool::pools
AVBufferPool * pools[4]
Pools for each data plane.
Definition: get_buffer.c:41
w
uint8_t w
Definition: llviddspenc.c:38
internal.h
data
const char data[16]
Definition: mxf.c:146
FramePool::channels
int channels
Definition: get_buffer.c:51
FramePool::height
int height
Definition: get_buffer.c:47
FramePool::stride_align
int stride_align[AV_NUM_DATA_POINTERS]
Definition: get_buffer.c:48
AVFrame::buf
AVBufferRef * buf[AV_NUM_DATA_POINTERS]
AVBuffer references backing the data for this frame.
Definition: frame.h:525
AVCodecInternal::pool
AVBufferRef * pool
Definition: internal.h:71
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:346
STRIDE_ALIGN
#define STRIDE_ALIGN
Definition: internal.h:49
fail
#define fail()
Definition: checkasm.h:134
samplefmt.h
AVCodecContext::coded_height
int coded_height
Definition: avcodec.h:586
planar
uint8_t pi<< 24) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_U8,(uint64_t)((*(const uint8_t *) pi - 0x80U))<< 56) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi - 0x80) *(1.0f/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi - 0x80) *(1.0/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16,(*(const int16_t *) pi >>8)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_S16, *(const int16_t *) pi *(1<< 16)) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S16,(uint64_t)(*(const int16_t *) pi)<< 48) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, *(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, *(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32,(*(const int32_t *) pi >>24)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S32,(uint64_t)(*(const int32_t *) pi)<< 32) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, *(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, *(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S64,(*(const int64_t *) pi >>56)+0x80) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S64, *(const int64_t *) pi *(1.0f/(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S64, *(const int64_t *) pi *(1.0/(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_FLT, llrintf(*(const float *) pi *(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_DBL, llrint(*(const double *) pi *(UINT64_C(1)<< 63))) #define FMT_PAIR_FUNC(out, in) static conv_func_type *const fmt_pair_to_conv_functions[AV_SAMPLE_FMT_NB *AV_SAMPLE_FMT_NB]={ FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S64), };static void cpy1(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, len);} static void cpy2(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, 2 *len);} static void cpy4(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, 4 *len);} static void cpy8(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, 8 *len);} AudioConvert *swri_audio_convert_alloc(enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, const int *ch_map, int flags) { AudioConvert *ctx;conv_func_type *f=fmt_pair_to_conv_functions[av_get_packed_sample_fmt(out_fmt)+AV_SAMPLE_FMT_NB *av_get_packed_sample_fmt(in_fmt)];if(!f) return NULL;ctx=av_mallocz(sizeof(*ctx));if(!ctx) return NULL;if(channels==1){ in_fmt=av_get_planar_sample_fmt(in_fmt);out_fmt=av_get_planar_sample_fmt(out_fmt);} ctx->channels=channels;ctx->conv_f=f;ctx->ch_map=ch_map;if(in_fmt==AV_SAMPLE_FMT_U8||in_fmt==AV_SAMPLE_FMT_U8P) memset(ctx->silence, 0x80, sizeof(ctx->silence));if(out_fmt==in_fmt &&!ch_map) { switch(av_get_bytes_per_sample(in_fmt)){ case 1:ctx->simd_f=cpy1;break;case 2:ctx->simd_f=cpy2;break;case 4:ctx->simd_f=cpy4;break;case 8:ctx->simd_f=cpy8;break;} } return ctx;} void swri_audio_convert_free(AudioConvert **ctx) { av_freep(ctx);} int swri_audio_convert(AudioConvert *ctx, AudioData *out, AudioData *in, int len) { int ch;int off=0;const int os=(out->planar ? 1 :out->ch_count) *out->bps;unsigned misaligned=0;av_assert0(ctx->channels==out->ch_count);if(ctx->in_simd_align_mask) { int planes=in->planar ? in->ch_count :1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) in->ch[ch];misaligned|=m &ctx->in_simd_align_mask;} if(ctx->out_simd_align_mask) { int planes=out->planar ? out->ch_count :1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) out->ch[ch];misaligned|=m &ctx->out_simd_align_mask;} if(ctx->simd_f &&!ctx->ch_map &&!misaligned){ off=len &~15;av_assert1(off >=0);av_assert1(off<=len);av_assert2(ctx->channels==SWR_CH_MAX||!in->ch[ctx->channels]);if(off >0){ if(out->planar==in->planar){ int planes=out->planar ? out->ch_count :1;for(ch=0;ch< planes;ch++){ ctx->simd_f(out->ch+ch,(const uint8_t **) in->ch+ch, off *(out-> planar
Definition: audioconvert.c:56
avassert.h
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_buffer_pool_get
AVBufferRef * av_buffer_pool_get(AVBufferPool *pool)
Allocate a new AVBuffer, reusing an old buffer from the pool when available.
Definition: buffer.c:384
av_image_fill_linesizes
int av_image_fill_linesizes(int linesizes[4], enum AVPixelFormat pix_fmt, int width)
Fill plane linesizes for an image with pixel format pix_fmt and width width.
Definition: imgutils.c:89
s
#define s(width, name)
Definition: cbs_vp9.c:256
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
av_sample_fmt_is_planar
int av_sample_fmt_is_planar(enum AVSampleFormat sample_fmt)
Check if the sample format is planar.
Definition: samplefmt.c:114
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
avcodec_align_dimensions2
void avcodec_align_dimensions2(AVCodecContext *s, int *width, int *height, int linesize_align[AV_NUM_DATA_POINTERS])
Modify width and height values so that they will result in a memory buffer that is acceptable for the...
Definition: utils.c:141
FramePool::format
int format
Definition: get_buffer.c:46
frame_pool_alloc
static AVBufferRef * frame_pool_alloc(void)
Definition: get_buffer.c:66
planes
static const struct @345 planes[]
if
if(ret)
Definition: filter_design.txt:179
FramePool::width
int width
Definition: get_buffer.c:47
NULL
#define NULL
Definition: coverity.c:32
av_buffer_unref
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it.
Definition: buffer.c:139
av_image_fill_plane_sizes
int av_image_fill_plane_sizes(size_t sizes[4], enum AVPixelFormat pix_fmt, int height, const ptrdiff_t linesizes[4])
Fill plane sizes for an image with pixel format pix_fmt and height height.
Definition: imgutils.c:111
AVCodecContext::internal
struct AVCodecInternal * internal
Private context used for internal data.
Definition: avcodec.h:433
av_buffer_pool_uninit
void av_buffer_pool_uninit(AVBufferPool **ppool)
Mark the pool as being available for freeing.
Definition: buffer.c:322
FramePool::linesize
int linesize[4]
Definition: get_buffer.c:49
FF_DEBUG_BUFFERS
#define FF_DEBUG_BUFFERS
Definition: avcodec.h:1339
av_buffer_create
AVBufferRef * av_buffer_create(uint8_t *data, size_t size, void(*free)(void *opaque, uint8_t *data), void *opaque, int flags)
Create an AVBuffer from an existing array.
Definition: buffer.c:55
audio_get_buffer
static int audio_get_buffer(AVCodecContext *avctx, AVFrame *frame)
Definition: get_buffer.c:201
size
int size
Definition: twinvq_data.h:10344
AV_NUM_DATA_POINTERS
#define AV_NUM_DATA_POINTERS
Definition: frame.h:326
frame.h
buffer.h
avcodec_default_get_buffer2
int avcodec_default_get_buffer2(AVCodecContext *avctx, AVFrame *frame, int flags)
The default callback for AVCodecContext.get_buffer2().
Definition: get_buffer.c:282
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
AVFrame::extended_data
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:386
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:487
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:264
av_samples_get_buffer_size
int av_samples_get_buffer_size(int *linesize, int nb_channels, int nb_samples, enum AVSampleFormat sample_fmt, int align)
Get the required buffer size for the given audio parameters.
Definition: samplefmt.c:121
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:608
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:272
AVCodecContext::hw_frames_ctx
AVBufferRef * hw_frames_ctx
A reference to the AVHWFramesContext describing the input (for encoding) or output (decoding) frames.
Definition: avcodec.h:1883
avcodec.h
version.h
av_buffer_allocz
AVBufferRef * av_buffer_allocz(size_t size)
Same as av_buffer_alloc(), except the returned buffer will be initialized to zero.
Definition: buffer.c:93
ret
ret
Definition: filter_design.txt:187
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
FramePool
Definition: get_buffer.c:36
AVCodecContext
main external API structure.
Definition: avcodec.h:398
update_frame_pool
static int update_frame_pool(AVCodecContext *avctx, AVFrame *frame)
Definition: get_buffer.c:84
frame_pool_free
static void frame_pool_free(void *opaque, uint8_t *data)
Definition: get_buffer.c:55
AVCodecContext::debug
int debug
debug
Definition: avcodec.h:1327
FF_DISABLE_DEPRECATION_WARNINGS
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:81
AVCodecContext::coded_width
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:586
AVCodecContext::codec_type
enum AVMediaType codec_type
Definition: avcodec.h:406
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
avutil.h
mem.h
AVBufferRef
A reference to a data buffer.
Definition: buffer.h:82
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
imgutils.h
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:561
hwcontext.h
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, a positive or negative value, which is typically indicating the size in bytes of each pict...
Definition: frame.h:370
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
h
h
Definition: vp9dsp_template.c:2038
av_hwframe_get_buffer
int av_hwframe_get_buffer(AVBufferRef *hwframe_ref, AVFrame *frame, int flags)
Allocate a new frame attached to the given AVHWFramesContext.
Definition: hwcontext.c:507
FramePool::samples
int samples
Definition: get_buffer.c:52