/src/ffmpeg/libavcodec/encode.h

Source
/*
 * generic encoding-related code
 *
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * FFmpeg is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

#ifndef AVCODEC_ENCODE_H
#define AVCODEC_ENCODE_H

#include "libavutil/dict.h"
#include "libavutil/frame.h"

#include "avcodec.h"
#include "packet.h"

/**
 * Used by some encoders as upper bound for the length of headers.
 * TODO: Use proper codec-specific upper bounds.
 */
#define FF_INPUT_BUFFER_MIN_SIZE 16384

/**
 * Called by encoders to get the next frame for encoding.
 *
 * @param frame An empty frame to be filled with data.
 * @return 0 if a new reference has been successfully written to frame
 *         AVERROR(EAGAIN) if no data is currently available
 *         AVERROR_EOF if end of stream has been reached, so no more data
 *                     will be available
 */
int ff_encode_get_frame(AVCodecContext *avctx, AVFrame *frame);

/**
 * Get a buffer for a packet. This is a wrapper around
 * AVCodecContext.get_encode_buffer() and should be used instead calling get_encode_buffer()
 * directly.
 */
int ff_get_encode_buffer(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int flags);

/**
 * Allocate buffers for a frame. Encoder equivalent to ff_get_buffer().
 */
int ff_encode_alloc_frame(AVCodecContext *avctx, AVFrame *frame);

/**
 * Check AVPacket size and allocate data.
 *
 * Encoders of type FF_CODEC_CB_TYPE_ENCODE can use this as a convenience to
 * obtain a big enough buffer for the encoded bitstream.
 *
 * @param avctx   the AVCodecContext of the encoder
 * @param avpkt   The AVPacket: on success, avpkt->data will point to a buffer
 *                of size at least `size`; the packet will not be refcounted.
 *                This packet must be initially blank.
 * @param size    an upper bound of the size of the packet to encode
 * @return        non negative on success, negative error code on failure
 */
int ff_alloc_packet(AVCodecContext *avctx, AVPacket *avpkt, int64_t size);

/**
 * Propagate user opaque values from the frame to avctx/pkt as needed.
 */
int ff_encode_reordered_opaque(AVCodecContext *avctx,
                               AVPacket *pkt, const AVFrame *frame);

int ff_encode_encode_cb(AVCodecContext *avctx, AVPacket *avpkt,
                        AVFrame *frame, int *got_packet);

int ff_encode_reconf_parse_dict(AVCodecContext *avctx, AVDictionary **dict);

/**
 * Add a CPB properties side data to an encoding context.
 */
AVCPBProperties *ff_encode_add_cpb_side_data(AVCodecContext *avctx);

int ff_encode_add_stats_side_data(AVPacket *pkt, int quality, const int64_t error[],
                                  int error_count, enum AVPictureType pict_type);

/**
 * Rescale from sample rate to AVCodecContext.time_base.
 */
static av_always_inline int64_t ff_samples_to_time_base(const AVCodecContext *avctx,
                                                        int64_t samples)
{
    if (samples == AV_NOPTS_VALUE)
        return AV_NOPTS_VALUE;
    return av_rescale_q(samples, (AVRational){ 1, avctx->sample_rate },
                        avctx->time_base);
}

/**
 * Rescale from time base to AVCodecContext.sample_rate.
 */
static av_always_inline int64_t ff_samples_from_time_base(const AVCodecContext *avctx,
                                                          int64_t duration)
{
    if (!duration)
        return duration;
    return av_rescale_q(duration, avctx->time_base,
                        (AVRational){ 1, avctx->sample_rate });
}

/**
 * Check if the elements of codec context matrices (intra_matrix, inter_matrix or
 * chroma_intra_matrix) are within the specified range.
 */
#define FF_MATRIX_TYPE_INTRA        (1U << 0)
#define FF_MATRIX_TYPE_INTER        (1U << 1)
#define FF_MATRIX_TYPE_CHROMA_INTRA (1U << 2)
int ff_check_codec_matrices(AVCodecContext *avctx, unsigned types, uint16_t min, uint16_t max);

#endif /* AVCODEC_ENCODE_H */

Coverage Report

Created: 2026-08-25 06:40

Line	Count	Source
1		/*
2		* generic encoding-related code
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		#ifndef AVCODEC_ENCODE_H
22		#define AVCODEC_ENCODE_H
23
24		#include "libavutil/dict.h"
25		#include "libavutil/frame.h"
26
27		#include "avcodec.h"
28		#include "packet.h"
29
30		/**
31		* Used by some encoders as upper bound for the length of headers.
32		* TODO: Use proper codec-specific upper bounds.
33		*/
34		#define FF_INPUT_BUFFER_MIN_SIZE 16384
35
36		/**
37		* Called by encoders to get the next frame for encoding.
38		*
39		* @param frame An empty frame to be filled with data.
40		* @return 0 if a new reference has been successfully written to frame
41		* AVERROR(EAGAIN) if no data is currently available
42		* AVERROR_EOF if end of stream has been reached, so no more data
43		* will be available
44		*/
45		int ff_encode_get_frame(AVCodecContext avctx, AVFrame frame);
46
47		/**
48		* Get a buffer for a packet. This is a wrapper around
49		* AVCodecContext.get_encode_buffer() and should be used instead calling get_encode_buffer()
50		* directly.
51		*/
52		int ff_get_encode_buffer(AVCodecContext avctx, AVPacket avpkt, int64_t size, int flags);
53
54		/**
55		* Allocate buffers for a frame. Encoder equivalent to ff_get_buffer().
56		*/
57		int ff_encode_alloc_frame(AVCodecContext avctx, AVFrame frame);
58
59		/**
60		* Check AVPacket size and allocate data.
61		*
62		* Encoders of type FF_CODEC_CB_TYPE_ENCODE can use this as a convenience to
63		* obtain a big enough buffer for the encoded bitstream.
64		*
65		* @param avctx the AVCodecContext of the encoder
66		* @param avpkt The AVPacket: on success, avpkt->data will point to a buffer
67		* of size at least `size`; the packet will not be refcounted.
68		* This packet must be initially blank.
69		* @param size an upper bound of the size of the packet to encode
70		* @return non negative on success, negative error code on failure
71		*/
72		int ff_alloc_packet(AVCodecContext avctx, AVPacket avpkt, int64_t size);
73
74		/**
75		* Propagate user opaque values from the frame to avctx/pkt as needed.
76		*/
77		int ff_encode_reordered_opaque(AVCodecContext *avctx,
78		AVPacket pkt, const AVFrame frame);
79
80		int ff_encode_encode_cb(AVCodecContext avctx, AVPacket avpkt,
81		AVFrame frame, int got_packet);
82
83		int ff_encode_reconf_parse_dict(AVCodecContext avctx, AVDictionary *dict);
84
85		/**
86		* Add a CPB properties side data to an encoding context.
87		*/
88		AVCPBProperties ff_encode_add_cpb_side_data(AVCodecContext avctx);
89
90		int ff_encode_add_stats_side_data(AVPacket *pkt, int quality, const int64_t error[],
91		int error_count, enum AVPictureType pict_type);
92
93		/**
94		* Rescale from sample rate to AVCodecContext.time_base.
95		*/
96		static av_always_inline int64_t ff_samples_to_time_base(const AVCodecContext *avctx,
97		int64_t samples)
98	0	{
99	0	if (samples == AV_NOPTS_VALUE)
100	0	return AV_NOPTS_VALUE;
101	0	return av_rescale_q(samples, (AVRational){ 1, avctx->sample_rate },
102	0	avctx->time_base);
103	0	}
104
105		/**
106		* Rescale from time base to AVCodecContext.sample_rate.
107		*/
108		static av_always_inline int64_t ff_samples_from_time_base(const AVCodecContext *avctx,
109		int64_t duration)
110	0	{
111	0	if (!duration)
112	0	return duration;
113	0	return av_rescale_q(duration, avctx->time_base,
114	0	(AVRational){ 1, avctx->sample_rate });
115	0	}
116
117		/**
118		* Check if the elements of codec context matrices (intra_matrix, inter_matrix or
119		* chroma_intra_matrix) are within the specified range.
120		*/
121		#define FF_MATRIX_TYPE_INTRA (1U << 0)
122		#define FF_MATRIX_TYPE_INTER (1U << 1)
123		#define FF_MATRIX_TYPE_CHROMA_INTRA (1U << 2)
124		int ff_check_codec_matrices(AVCodecContext *avctx, unsigned types, uint16_t min, uint16_t max);
125
126		#endif /* AVCODEC_ENCODE_H */