Details | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
4349 | Serge | 1 | /* |
2 | * |
||
3 | * This file is part of FFmpeg. |
||
4 | * |
||
5 | * FFmpeg is free software; you can redistribute it and/or |
||
6 | * modify it under the terms of the GNU Lesser General Public |
||
7 | * License as published by the Free Software Foundation; either |
||
8 | * version 2.1 of the License, or (at your option) any later version. |
||
9 | * |
||
10 | * FFmpeg is distributed in the hope that it will be useful, |
||
11 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
||
12 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
||
13 | * Lesser General Public License for more details. |
||
14 | * |
||
15 | * You should have received a copy of the GNU Lesser General Public |
||
16 | * License along with FFmpeg; if not, write to the Free Software |
||
17 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
||
18 | */ |
||
19 | |||
20 | #ifndef AVUTIL_FRAME_H |
||
21 | #define AVUTIL_FRAME_H |
||
22 | |||
23 | #include |
||
24 | |||
25 | #include "libavcodec/version.h" |
||
26 | |||
27 | #include "avutil.h" |
||
28 | #include "buffer.h" |
||
29 | #include "dict.h" |
||
30 | #include "rational.h" |
||
31 | #include "samplefmt.h" |
||
32 | |||
33 | enum AVColorSpace{ |
||
34 | AVCOL_SPC_RGB = 0, |
||
35 | AVCOL_SPC_BT709 = 1, ///< also ITU-R BT1361 / IEC 61966-2-4 xvYCC709 / SMPTE RP177 Annex B |
||
36 | AVCOL_SPC_UNSPECIFIED = 2, |
||
37 | AVCOL_SPC_FCC = 4, |
||
38 | AVCOL_SPC_BT470BG = 5, ///< also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM / IEC 61966-2-4 xvYCC601 |
||
39 | AVCOL_SPC_SMPTE170M = 6, ///< also ITU-R BT601-6 525 / ITU-R BT1358 525 / ITU-R BT1700 NTSC / functionally identical to above |
||
40 | AVCOL_SPC_SMPTE240M = 7, |
||
41 | AVCOL_SPC_YCOCG = 8, ///< Used by Dirac / VC-2 and H.264 FRext, see ITU-T SG16 |
||
42 | AVCOL_SPC_NB , ///< Not part of ABI |
||
43 | }; |
||
44 | #define AVCOL_SPC_YCGCO AVCOL_SPC_YCOCG |
||
45 | |||
46 | enum AVColorRange{ |
||
47 | AVCOL_RANGE_UNSPECIFIED = 0, |
||
48 | AVCOL_RANGE_MPEG = 1, ///< the normal 219*2^(n-8) "MPEG" YUV ranges |
||
49 | AVCOL_RANGE_JPEG = 2, ///< the normal 2^n-1 "JPEG" YUV ranges |
||
50 | AVCOL_RANGE_NB , ///< Not part of ABI |
||
51 | }; |
||
52 | |||
53 | enum AVFrameSideDataType { |
||
54 | /** |
||
55 | * The data is the AVPanScan struct defined in libavcodec. |
||
56 | */ |
||
57 | AV_FRAME_DATA_PANSCAN, |
||
58 | }; |
||
59 | |||
60 | typedef struct AVFrameSideData { |
||
61 | enum AVFrameSideDataType type; |
||
62 | uint8_t *data; |
||
63 | int size; |
||
64 | AVDictionary *metadata; |
||
65 | } AVFrameSideData; |
||
66 | |||
67 | /** |
||
68 | * This structure describes decoded (raw) audio or video data. |
||
69 | * |
||
70 | * AVFrame must be allocated using av_frame_alloc(). Note that this only |
||
71 | * allocates the AVFrame itself, the buffers for the data must be managed |
||
72 | * through other means (see below). |
||
73 | * AVFrame must be freed with av_frame_free(). |
||
74 | * |
||
75 | * AVFrame is typically allocated once and then reused multiple times to hold |
||
76 | * different data (e.g. a single AVFrame to hold frames received from a |
||
77 | * decoder). In such a case, av_frame_unref() will free any references held by |
||
78 | * the frame and reset it to its original clean state before it |
||
79 | * is reused again. |
||
80 | * |
||
81 | * The data described by an AVFrame is usually reference counted through the |
||
82 | * AVBuffer API. The underlying buffer references are stored in AVFrame.buf / |
||
83 | * AVFrame.extended_buf. An AVFrame is considered to be reference counted if at |
||
84 | * least one reference is set, i.e. if AVFrame.buf[0] != NULL. In such a case, |
||
85 | * every single data plane must be contained in one of the buffers in |
||
86 | * AVFrame.buf or AVFrame.extended_buf. |
||
87 | * There may be a single buffer for all the data, or one separate buffer for |
||
88 | * each plane, or anything in between. |
||
89 | * |
||
90 | * sizeof(AVFrame) is not a part of the public ABI, so new fields may be added |
||
91 | * to the end with a minor bump. |
||
92 | * Similarly fields that are marked as to be only accessed by |
||
93 | * av_opt_ptr() can be reordered. This allows 2 forks to add fields |
||
94 | * without breaking compatibility with each other. |
||
95 | */ |
||
96 | typedef struct AVFrame { |
||
97 | #define AV_NUM_DATA_POINTERS 8 |
||
98 | /** |
||
99 | * pointer to the picture/channel planes. |
||
100 | * This might be different from the first allocated byte |
||
101 | * |
||
102 | * Some decoders access areas outside 0,0 - width,height, please |
||
103 | * see avcodec_align_dimensions2(). Some filters and swscale can read |
||
104 | * up to 16 bytes beyond the planes, if these filters are to be used, |
||
105 | * then 16 extra bytes must be allocated. |
||
106 | */ |
||
107 | uint8_t *data[AV_NUM_DATA_POINTERS]; |
||
108 | |||
109 | /** |
||
110 | * For video, size in bytes of each picture line. |
||
111 | * For audio, size in bytes of each plane. |
||
112 | * |
||
113 | * For audio, only linesize[0] may be set. For planar audio, each channel |
||
114 | * plane must be the same size. |
||
115 | * |
||
116 | * For video the linesizes should be multiplies of the CPUs alignment |
||
117 | * preference, this is 16 or 32 for modern desktop CPUs. |
||
118 | * Some code requires such alignment other code can be slower without |
||
119 | * correct alignment, for yet other it makes no difference. |
||
120 | * |
||
121 | * @note The linesize may be larger than the size of usable data -- there |
||
122 | * may be extra padding present for performance reasons. |
||
123 | */ |
||
124 | int linesize[AV_NUM_DATA_POINTERS]; |
||
125 | |||
126 | /** |
||
127 | * pointers to the data planes/channels. |
||
128 | * |
||
129 | * For video, this should simply point to data[]. |
||
130 | * |
||
131 | * For planar audio, each channel has a separate data pointer, and |
||
132 | * linesize[0] contains the size of each channel buffer. |
||
133 | * For packed audio, there is just one data pointer, and linesize[0] |
||
134 | * contains the total size of the buffer for all channels. |
||
135 | * |
||
136 | * Note: Both data and extended_data should always be set in a valid frame, |
||
137 | * but for planar audio with more channels that can fit in data, |
||
138 | * extended_data must be used in order to access all channels. |
||
139 | */ |
||
140 | uint8_t **extended_data; |
||
141 | |||
142 | /** |
||
143 | * width and height of the video frame |
||
144 | */ |
||
145 | int width, height; |
||
146 | |||
147 | /** |
||
148 | * number of audio samples (per channel) described by this frame |
||
149 | */ |
||
150 | int nb_samples; |
||
151 | |||
152 | /** |
||
153 | * format of the frame, -1 if unknown or unset |
||
154 | * Values correspond to enum AVPixelFormat for video frames, |
||
155 | * enum AVSampleFormat for audio) |
||
156 | */ |
||
157 | int format; |
||
158 | |||
159 | /** |
||
160 | * 1 -> keyframe, 0-> not |
||
161 | */ |
||
162 | int key_frame; |
||
163 | |||
164 | /** |
||
165 | * Picture type of the frame. |
||
166 | */ |
||
167 | enum AVPictureType pict_type; |
||
168 | |||
169 | #if FF_API_AVFRAME_LAVC |
||
170 | attribute_deprecated |
||
171 | uint8_t *base[AV_NUM_DATA_POINTERS]; |
||
172 | #endif |
||
173 | |||
174 | /** |
||
175 | * Sample aspect ratio for the video frame, 0/1 if unknown/unspecified. |
||
176 | */ |
||
177 | AVRational sample_aspect_ratio; |
||
178 | |||
179 | /** |
||
180 | * Presentation timestamp in time_base units (time when frame should be shown to user). |
||
181 | */ |
||
182 | int64_t pts; |
||
183 | |||
184 | /** |
||
185 | * PTS copied from the AVPacket that was decoded to produce this frame. |
||
186 | */ |
||
187 | int64_t pkt_pts; |
||
188 | |||
189 | /** |
||
190 | * DTS copied from the AVPacket that triggered returning this frame. (if frame threading isnt used) |
||
191 | * This is also the Presentation time of this AVFrame calculated from |
||
192 | * only AVPacket.dts values without pts values. |
||
193 | */ |
||
194 | int64_t pkt_dts; |
||
195 | |||
196 | /** |
||
197 | * picture number in bitstream order |
||
198 | */ |
||
199 | int coded_picture_number; |
||
200 | /** |
||
201 | * picture number in display order |
||
202 | */ |
||
203 | int display_picture_number; |
||
204 | |||
205 | /** |
||
206 | * quality (between 1 (good) and FF_LAMBDA_MAX (bad)) |
||
207 | */ |
||
208 | int quality; |
||
209 | |||
210 | #if FF_API_AVFRAME_LAVC |
||
211 | attribute_deprecated |
||
212 | int reference; |
||
213 | |||
214 | /** |
||
215 | * QP table |
||
216 | */ |
||
217 | attribute_deprecated |
||
218 | int8_t *qscale_table; |
||
219 | /** |
||
220 | * QP store stride |
||
221 | */ |
||
222 | attribute_deprecated |
||
223 | int qstride; |
||
224 | |||
225 | attribute_deprecated |
||
226 | int qscale_type; |
||
227 | |||
228 | /** |
||
229 | * mbskip_table[mb]>=1 if MB didn't change |
||
230 | * stride= mb_width = (width+15)>>4 |
||
231 | */ |
||
232 | attribute_deprecated |
||
233 | uint8_t *mbskip_table; |
||
234 | |||
235 | /** |
||
236 | * motion vector table |
||
237 | * @code |
||
238 | * example: |
||
239 | * int mv_sample_log2= 4 - motion_subsample_log2; |
||
240 | * int mb_width= (width+15)>>4; |
||
241 | * int mv_stride= (mb_width << mv_sample_log2) + 1; |
||
242 | * motion_val[direction][x + y*mv_stride][0->mv_x, 1->mv_y]; |
||
243 | * @endcode |
||
244 | */ |
||
245 | attribute_deprecated |
||
246 | int16_t (*motion_val[2])[2]; |
||
247 | |||
248 | /** |
||
249 | * macroblock type table |
||
250 | * mb_type_base + mb_width + 2 |
||
251 | */ |
||
252 | attribute_deprecated |
||
253 | uint32_t *mb_type; |
||
254 | |||
255 | /** |
||
256 | * DCT coefficients |
||
257 | */ |
||
258 | attribute_deprecated |
||
259 | short *dct_coeff; |
||
260 | |||
261 | /** |
||
262 | * motion reference frame index |
||
263 | * the order in which these are stored can depend on the codec. |
||
264 | */ |
||
265 | attribute_deprecated |
||
266 | int8_t *ref_index[2]; |
||
267 | #endif |
||
268 | |||
269 | /** |
||
270 | * for some private data of the user |
||
271 | */ |
||
272 | void *opaque; |
||
273 | |||
274 | /** |
||
275 | * error |
||
276 | */ |
||
277 | uint64_t error[AV_NUM_DATA_POINTERS]; |
||
278 | |||
279 | #if FF_API_AVFRAME_LAVC |
||
280 | attribute_deprecated |
||
281 | int type; |
||
282 | #endif |
||
283 | |||
284 | /** |
||
285 | * When decoding, this signals how much the picture must be delayed. |
||
286 | * extra_delay = repeat_pict / (2*fps) |
||
287 | */ |
||
288 | int repeat_pict; |
||
289 | |||
290 | /** |
||
291 | * The content of the picture is interlaced. |
||
292 | */ |
||
293 | int interlaced_frame; |
||
294 | |||
295 | /** |
||
296 | * If the content is interlaced, is top field displayed first. |
||
297 | */ |
||
298 | int top_field_first; |
||
299 | |||
300 | /** |
||
301 | * Tell user application that palette has changed from previous frame. |
||
302 | */ |
||
303 | int palette_has_changed; |
||
304 | |||
305 | #if FF_API_AVFRAME_LAVC |
||
306 | attribute_deprecated |
||
307 | int buffer_hints; |
||
308 | |||
309 | /** |
||
310 | * Pan scan. |
||
311 | */ |
||
312 | attribute_deprecated |
||
313 | struct AVPanScan *pan_scan; |
||
314 | #endif |
||
315 | |||
316 | /** |
||
317 | * reordered opaque 64bit (generally an integer or a double precision float |
||
318 | * PTS but can be anything). |
||
319 | * The user sets AVCodecContext.reordered_opaque to represent the input at |
||
320 | * that time, |
||
321 | * the decoder reorders values as needed and sets AVFrame.reordered_opaque |
||
322 | * to exactly one of the values provided by the user through AVCodecContext.reordered_opaque |
||
323 | * @deprecated in favor of pkt_pts |
||
324 | */ |
||
325 | int64_t reordered_opaque; |
||
326 | |||
327 | #if FF_API_AVFRAME_LAVC |
||
328 | /** |
||
329 | * @deprecated this field is unused |
||
330 | */ |
||
331 | attribute_deprecated void *hwaccel_picture_private; |
||
332 | |||
333 | attribute_deprecated |
||
334 | struct AVCodecContext *owner; |
||
335 | attribute_deprecated |
||
336 | void *thread_opaque; |
||
337 | |||
338 | /** |
||
339 | * log2 of the size of the block which a single vector in motion_val represents: |
||
340 | * (4->16x16, 3->8x8, 2-> 4x4, 1-> 2x2) |
||
341 | */ |
||
342 | attribute_deprecated |
||
343 | uint8_t motion_subsample_log2; |
||
344 | #endif |
||
345 | |||
346 | /** |
||
347 | * Sample rate of the audio data. |
||
348 | */ |
||
349 | int sample_rate; |
||
350 | |||
351 | /** |
||
352 | * Channel layout of the audio data. |
||
353 | */ |
||
354 | uint64_t channel_layout; |
||
355 | |||
356 | /** |
||
357 | * AVBuffer references backing the data for this frame. If all elements of |
||
358 | * this array are NULL, then this frame is not reference counted. |
||
359 | * |
||
360 | * There may be at most one AVBuffer per data plane, so for video this array |
||
361 | * always contains all the references. For planar audio with more than |
||
362 | * AV_NUM_DATA_POINTERS channels, there may be more buffers than can fit in |
||
363 | * this array. Then the extra AVBufferRef pointers are stored in the |
||
364 | * extended_buf array. |
||
365 | */ |
||
366 | AVBufferRef *buf[AV_NUM_DATA_POINTERS]; |
||
367 | |||
368 | /** |
||
369 | * For planar audio which requires more than AV_NUM_DATA_POINTERS |
||
370 | * AVBufferRef pointers, this array will hold all the references which |
||
371 | * cannot fit into AVFrame.buf. |
||
372 | * |
||
373 | * Note that this is different from AVFrame.extended_data, which always |
||
374 | * contains all the pointers. This array only contains the extra pointers, |
||
375 | * which cannot fit into AVFrame.buf. |
||
376 | * |
||
377 | * This array is always allocated using av_malloc() by whoever constructs |
||
378 | * the frame. It is freed in av_frame_unref(). |
||
379 | */ |
||
380 | AVBufferRef **extended_buf; |
||
381 | /** |
||
382 | * Number of elements in extended_buf. |
||
383 | */ |
||
384 | int nb_extended_buf; |
||
385 | |||
386 | AVFrameSideData **side_data; |
||
387 | int nb_side_data; |
||
388 | |||
389 | /** |
||
390 | * frame timestamp estimated using various heuristics, in stream time base |
||
391 | * Code outside libavcodec should access this field using: |
||
392 | * av_frame_get_best_effort_timestamp(frame) |
||
393 | * - encoding: unused |
||
394 | * - decoding: set by libavcodec, read by user. |
||
395 | */ |
||
396 | int64_t best_effort_timestamp; |
||
397 | |||
398 | /** |
||
399 | * reordered pos from the last AVPacket that has been input into the decoder |
||
400 | * Code outside libavcodec should access this field using: |
||
401 | * av_frame_get_pkt_pos(frame) |
||
402 | * - encoding: unused |
||
403 | * - decoding: Read by user. |
||
404 | */ |
||
405 | int64_t pkt_pos; |
||
406 | |||
407 | /** |
||
408 | * duration of the corresponding packet, expressed in |
||
409 | * AVStream->time_base units, 0 if unknown. |
||
410 | * Code outside libavcodec should access this field using: |
||
411 | * av_frame_get_pkt_duration(frame) |
||
412 | * - encoding: unused |
||
413 | * - decoding: Read by user. |
||
414 | */ |
||
415 | int64_t pkt_duration; |
||
416 | |||
417 | /** |
||
418 | * metadata. |
||
419 | * Code outside libavcodec should access this field using: |
||
420 | * av_frame_get_metadata(frame) |
||
421 | * - encoding: Set by user. |
||
422 | * - decoding: Set by libavcodec. |
||
423 | */ |
||
424 | AVDictionary *metadata; |
||
425 | |||
426 | /** |
||
427 | * decode error flags of the frame, set to a combination of |
||
428 | * FF_DECODE_ERROR_xxx flags if the decoder produced a frame, but there |
||
429 | * were errors during the decoding. |
||
430 | * Code outside libavcodec should access this field using: |
||
431 | * av_frame_get_decode_error_flags(frame) |
||
432 | * - encoding: unused |
||
433 | * - decoding: set by libavcodec, read by user. |
||
434 | */ |
||
435 | int decode_error_flags; |
||
436 | #define FF_DECODE_ERROR_INVALID_BITSTREAM 1 |
||
437 | #define FF_DECODE_ERROR_MISSING_REFERENCE 2 |
||
438 | |||
439 | /** |
||
440 | * number of audio channels, only used for audio. |
||
441 | * Code outside libavcodec should access this field using: |
||
442 | * av_frame_get_channels(frame) |
||
443 | * - encoding: unused |
||
444 | * - decoding: Read by user. |
||
445 | */ |
||
446 | int channels; |
||
447 | |||
448 | /** |
||
449 | * size of the corresponding packet containing the compressed |
||
450 | * frame. It must be accessed using av_frame_get_pkt_size() and |
||
451 | * av_frame_set_pkt_size(). |
||
452 | * It is set to a negative value if unknown. |
||
453 | * - encoding: unused |
||
454 | * - decoding: set by libavcodec, read by user. |
||
455 | */ |
||
456 | int pkt_size; |
||
457 | |||
458 | /** |
||
459 | * YUV colorspace type. |
||
460 | * It must be accessed using av_frame_get_colorspace() and |
||
461 | * av_frame_set_colorspace(). |
||
462 | * - encoding: Set by user |
||
463 | * - decoding: Set by libavcodec |
||
464 | */ |
||
465 | enum AVColorSpace colorspace; |
||
466 | |||
467 | /** |
||
468 | * MPEG vs JPEG YUV range. |
||
469 | * It must be accessed using av_frame_get_color_range() and |
||
470 | * av_frame_set_color_range(). |
||
471 | * - encoding: Set by user |
||
472 | * - decoding: Set by libavcodec |
||
473 | */ |
||
474 | enum AVColorRange color_range; |
||
475 | |||
476 | |||
477 | /** |
||
478 | * Not to be accessed directly from outside libavutil |
||
479 | */ |
||
480 | AVBufferRef *qp_table_buf; |
||
481 | } AVFrame; |
||
482 | |||
483 | /** |
||
484 | * Accessors for some AVFrame fields. |
||
485 | * The position of these field in the structure is not part of the ABI, |
||
486 | * they should not be accessed directly outside libavcodec. |
||
487 | */ |
||
488 | int64_t av_frame_get_best_effort_timestamp(const AVFrame *frame); |
||
489 | void av_frame_set_best_effort_timestamp(AVFrame *frame, int64_t val); |
||
490 | int64_t av_frame_get_pkt_duration (const AVFrame *frame); |
||
491 | void av_frame_set_pkt_duration (AVFrame *frame, int64_t val); |
||
492 | int64_t av_frame_get_pkt_pos (const AVFrame *frame); |
||
493 | void av_frame_set_pkt_pos (AVFrame *frame, int64_t val); |
||
494 | int64_t av_frame_get_channel_layout (const AVFrame *frame); |
||
495 | void av_frame_set_channel_layout (AVFrame *frame, int64_t val); |
||
496 | int av_frame_get_channels (const AVFrame *frame); |
||
497 | void av_frame_set_channels (AVFrame *frame, int val); |
||
498 | int av_frame_get_sample_rate (const AVFrame *frame); |
||
499 | void av_frame_set_sample_rate (AVFrame *frame, int val); |
||
500 | AVDictionary *av_frame_get_metadata (const AVFrame *frame); |
||
501 | void av_frame_set_metadata (AVFrame *frame, AVDictionary *val); |
||
502 | int av_frame_get_decode_error_flags (const AVFrame *frame); |
||
503 | void av_frame_set_decode_error_flags (AVFrame *frame, int val); |
||
504 | int av_frame_get_pkt_size(const AVFrame *frame); |
||
505 | void av_frame_set_pkt_size(AVFrame *frame, int val); |
||
506 | AVDictionary **avpriv_frame_get_metadatap(AVFrame *frame); |
||
507 | int8_t *av_frame_get_qp_table(AVFrame *f, int *stride, int *type); |
||
508 | int av_frame_set_qp_table(AVFrame *f, AVBufferRef *buf, int stride, int type); |
||
509 | enum AVColorSpace av_frame_get_colorspace(const AVFrame *frame); |
||
510 | void av_frame_set_colorspace(AVFrame *frame, enum AVColorSpace val); |
||
511 | enum AVColorRange av_frame_get_color_range(const AVFrame *frame); |
||
512 | void av_frame_set_color_range(AVFrame *frame, enum AVColorRange val); |
||
513 | |||
514 | /** |
||
515 | * Get the name of a colorspace. |
||
516 | * @return a static string identifying the colorspace; can be NULL. |
||
517 | */ |
||
518 | const char *av_get_colorspace_name(enum AVColorSpace val); |
||
519 | |||
520 | /** |
||
521 | * Allocate an AVFrame and set its fields to default values. The resulting |
||
522 | * struct must be freed using av_frame_free(). |
||
523 | * |
||
524 | * @return An AVFrame filled with default values or NULL on failure. |
||
525 | * |
||
526 | * @note this only allocates the AVFrame itself, not the data buffers. Those |
||
527 | * must be allocated through other means, e.g. with av_frame_get_buffer() or |
||
528 | * manually. |
||
529 | */ |
||
530 | AVFrame *av_frame_alloc(void); |
||
531 | |||
532 | /** |
||
533 | * Free the frame and any dynamically allocated objects in it, |
||
534 | * e.g. extended_data. If the frame is reference counted, it will be |
||
535 | * unreferenced first. |
||
536 | * |
||
537 | * @param frame frame to be freed. The pointer will be set to NULL. |
||
538 | */ |
||
539 | void av_frame_free(AVFrame **frame); |
||
540 | |||
541 | /** |
||
542 | * Setup a new reference to the data described by a given frame. |
||
543 | * |
||
544 | * Copy frame properties from src to dst and create a new reference for each |
||
545 | * AVBufferRef from src. |
||
546 | * |
||
547 | * If src is not reference counted, new buffers are allocated and the data is |
||
548 | * copied. |
||
549 | * |
||
550 | * @return 0 on success, a negative AVERROR on error |
||
551 | */ |
||
552 | int av_frame_ref(AVFrame *dst, AVFrame *src); |
||
553 | |||
554 | /** |
||
555 | * Create a new frame that references the same data as src. |
||
556 | * |
||
557 | * This is a shortcut for av_frame_alloc()+av_frame_ref(). |
||
558 | * |
||
559 | * @return newly created AVFrame on success, NULL on error. |
||
560 | */ |
||
561 | AVFrame *av_frame_clone(AVFrame *src); |
||
562 | |||
563 | /** |
||
564 | * Unreference all the buffers referenced by frame and reset the frame fields. |
||
565 | */ |
||
566 | void av_frame_unref(AVFrame *frame); |
||
567 | |||
568 | /** |
||
569 | * Move everythnig contained in src to dst and reset src. |
||
570 | */ |
||
571 | void av_frame_move_ref(AVFrame *dst, AVFrame *src); |
||
572 | |||
573 | /** |
||
574 | * Allocate new buffer(s) for audio or video data. |
||
575 | * |
||
576 | * The following fields must be set on frame before calling this function: |
||
577 | * - format (pixel format for video, sample format for audio) |
||
578 | * - width and height for video |
||
579 | * - nb_samples and channel_layout for audio |
||
580 | * |
||
581 | * This function will fill AVFrame.data and AVFrame.buf arrays and, if |
||
582 | * necessary, allocate and fill AVFrame.extended_data and AVFrame.extended_buf. |
||
583 | * For planar formats, one buffer will be allocated for each plane. |
||
584 | * |
||
585 | * @param frame frame in which to store the new buffers. |
||
586 | * @param align required buffer size alignment |
||
587 | * |
||
588 | * @return 0 on success, a negative AVERROR on error. |
||
589 | */ |
||
590 | int av_frame_get_buffer(AVFrame *frame, int align); |
||
591 | |||
592 | /** |
||
593 | * Check if the frame data is writable. |
||
594 | * |
||
595 | * @return A positive value if the frame data is writable (which is true if and |
||
596 | * only if each of the underlying buffers has only one reference, namely the one |
||
597 | * stored in this frame). Return 0 otherwise. |
||
598 | * |
||
599 | * If 1 is returned the answer is valid until av_buffer_ref() is called on any |
||
600 | * of the underlying AVBufferRefs (e.g. through av_frame_ref() or directly). |
||
601 | * |
||
602 | * @see av_frame_make_writable(), av_buffer_is_writable() |
||
603 | */ |
||
604 | int av_frame_is_writable(AVFrame *frame); |
||
605 | |||
606 | /** |
||
607 | * Ensure that the frame data is writable, avoiding data copy if possible. |
||
608 | * |
||
609 | * Do nothing if the frame is writable, allocate new buffers and copy the data |
||
610 | * if it is not. |
||
611 | * |
||
612 | * @return 0 on success, a negative AVERROR on error. |
||
613 | * |
||
614 | * @see av_frame_is_writable(), av_buffer_is_writable(), |
||
615 | * av_buffer_make_writable() |
||
616 | */ |
||
617 | int av_frame_make_writable(AVFrame *frame); |
||
618 | |||
619 | /** |
||
620 | * Copy only "metadata" fields from src to dst. |
||
621 | * |
||
622 | * Metadata for the purpose of this function are those fields that do not affect |
||
623 | * the data layout in the buffers. E.g. pts, sample rate (for audio) or sample |
||
624 | * aspect ratio (for video), but not width/height or channel layout. |
||
625 | * Side data is also copied. |
||
626 | */ |
||
627 | int av_frame_copy_props(AVFrame *dst, const AVFrame *src); |
||
628 | |||
629 | /** |
||
630 | * Get the buffer reference a given data plane is stored in. |
||
631 | * |
||
632 | * @param plane index of the data plane of interest in frame->extended_data. |
||
633 | * |
||
634 | * @return the buffer reference that contains the plane or NULL if the input |
||
635 | * frame is not valid. |
||
636 | */ |
||
637 | AVBufferRef *av_frame_get_plane_buffer(AVFrame *frame, int plane); |
||
638 | |||
639 | /** |
||
640 | * Add a new side data to a frame. |
||
641 | * |
||
642 | * @param frame a frame to which the side data should be added |
||
643 | * @param type type of the added side data |
||
644 | * @param size size of the side data |
||
645 | * |
||
646 | * @return newly added side data on success, NULL on error |
||
647 | */ |
||
648 | AVFrameSideData *av_frame_new_side_data(AVFrame *frame, |
||
649 | enum AVFrameSideDataType type, |
||
650 | int size); |
||
651 | |||
652 | /** |
||
653 | * @return a pointer to the side data of a given type on success, NULL if there |
||
654 | * is no side data with such type in this frame. |
||
655 | */ |
||
656 | AVFrameSideData *av_frame_get_side_data(const AVFrame *frame, |
||
657 | enum AVFrameSideDataType type); |
||
658 | |||
659 | #endif /* AVUTIL_FRAME_H */><>>>>>>>>> |