/src/ffmpeg/libavcodec/hwaccel_internal.h

Source
/*
 * 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
 */

/**
 * Header providing the internals of AVHWAccel.
 */

#ifndef AVCODEC_HWACCEL_INTERNAL_H
#define AVCODEC_HWACCEL_INTERNAL_H

#include <stdint.h>

#include "avcodec.h"
#include "libavutil/refstruct.h"

#define HWACCEL_CAP_ASYNC_SAFE      (1 << 0)
#define HWACCEL_CAP_THREAD_SAFE     (1 << 1)

typedef struct FFHWAccel {
    /**
     * The public AVHWAccel. See avcodec.h for it.
     */
    AVHWAccel p;

    /**
     * Allocate a custom buffer
     */
    int (*alloc_frame)(AVCodecContext *avctx, AVFrame *frame);

    /**
     * Called at the beginning of each frame or field picture.
     *
     * Meaningful frame information (codec specific) is guaranteed to
     * be parsed at this point. This function is mandatory.
     *
     * Note that buf can be NULL along with buf_size set to 0.
     * Otherwise, this means the whole frame is available at this point.
     *
     * @param avctx the codec context
     * @param buf_ref the frame data buffer reference (optional)
     * @param buf the frame data buffer base
     * @param buf_size the size of the frame in bytes
     * @return zero if successful, a negative value otherwise
     */
    int (*start_frame)(AVCodecContext *avctx, const AVBufferRef *buf_ref,
                       const uint8_t *buf, uint32_t buf_size);

    /**
     * Callback for parameter data (SPS/PPS/VPS etc).
     *
     * Useful for hardware decoders which keep persistent state about the
     * video parameters, and need to receive any changes to update that state.
     *
     * @param avctx the codec context
     * @param type the nal unit type
     * @param buf the nal unit data buffer
     * @param buf_size the size of the nal unit in bytes
     * @return zero if successful, a negative value otherwise
     */
    int (*decode_params)(AVCodecContext *avctx, int type, const uint8_t *buf, uint32_t buf_size);

    /**
     * Callback for each slice.
     *
     * Meaningful slice information (codec specific) is guaranteed to
     * be parsed at this point. This function is mandatory.
     *
     * @param avctx the codec context
     * @param buf the slice data buffer base
     * @param buf_size the size of the slice in bytes
     * @return zero if successful, a negative value otherwise
     */
    int (*decode_slice)(AVCodecContext *avctx, const uint8_t *buf, uint32_t buf_size);

    /**
     * Called at the end of each frame or field picture.
     *
     * The whole picture is parsed at this point and can now be sent
     * to the hardware accelerator. This function is mandatory.
     *
     * @param avctx the codec context
     * @return zero if successful, a negative value otherwise
     */
    int (*end_frame)(AVCodecContext *avctx);

    /**
     * Size of per-frame hardware accelerator private data.
     *
     * Private data is allocated with av_mallocz() before
     * AVCodecContext.get_buffer() and deallocated after
     * AVCodecContext.release_buffer().
     */
    int frame_priv_data_size;

    /**
     * Size of the private data to allocate in
     * AVCodecInternal.hwaccel_priv_data.
     */
    int priv_data_size;

    /**
     * Internal hwaccel capabilities.
     */
    int caps_internal;

    /**
     * Initialize the hwaccel private data.
     *
     * This will be called from ff_get_format(), after hwaccel and
     * hwaccel_context are set and the hwaccel private data in AVCodecInternal
     * is allocated.
     */
    int (*init)(AVCodecContext *avctx);

    /**
     * Uninitialize the hwaccel private data.
     *
     * This will be called from get_format() or ff_codec_close(), after hwaccel
     * and hwaccel_context are already uninitialized.
     */
    int (*uninit)(AVCodecContext *avctx);

    /**
     * Fill the given hw_frames context with current codec parameters. Called
     * from get_format. Refer to avcodec_get_hw_frames_parameters() for
     * details.
     *
     * This CAN be called before AVHWAccel.init is called, and you must assume
     * that avctx->hwaccel_priv_data is invalid.
     */
    int (*frame_params)(AVCodecContext *avctx, AVBufferRef *hw_frames_ctx);

    /**
     * Copy necessary context variables from a previous thread context to the current one.
     * For thread-safe hwaccels only.
     */
    int (*update_thread_context)(AVCodecContext *dst, const AVCodecContext *src);

    /**
     * Callback to free the hwaccel-specific frame data.
     *
     * @param hwctx a pointer to an AVHWDeviceContext.
     * @param data the per-frame hardware accelerator private data to be freed.
     */
    void (*free_frame_priv)(AVRefStructOpaque hwctx, void *data);

    /**
     * Callback to flush the hwaccel state.
     */
    void (*flush)(AVCodecContext *avctx);
} FFHWAccel;

static inline const FFHWAccel *ffhwaccel(const AVHWAccel *codec)
{
    return (const FFHWAccel*)codec;
}

#define FF_HW_CALL(avctx, function, ...) \
        (ffhwaccel((avctx)->hwaccel)->function((avctx), __VA_ARGS__))

#define FF_HW_SIMPLE_CALL(avctx, function) \
        (ffhwaccel((avctx)->hwaccel)->function(avctx))

#define FF_HW_HAS_CB(avctx, function) \
        ((avctx)->hwaccel && ffhwaccel((avctx)->hwaccel)->function)

#endif /* AVCODEC_HWACCEL_INTERNAL */

Line	Count	Source
1		/*
2		* This file is part of FFmpeg.
3		*
4		* FFmpeg is free software; you can redistribute it and/or
5		* modify it under the terms of the GNU Lesser General Public
6		* License as published by the Free Software Foundation; either
7		* version 2.1 of the License, or (at your option) any later version.
8		*
9		* FFmpeg is distributed in the hope that it will be useful,
10		* but WITHOUT ANY WARRANTY; without even the implied warranty of
11		* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12		* Lesser General Public License for more details.
13		*
14		* You should have received a copy of the GNU Lesser General Public
15		* License along with FFmpeg; if not, write to the Free Software
16		* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17		*/
18
19		/**
20		* Header providing the internals of AVHWAccel.
21		*/
22
23		#ifndef AVCODEC_HWACCEL_INTERNAL_H
24		#define AVCODEC_HWACCEL_INTERNAL_H
25
26		#include <stdint.h>
27
28		#include "avcodec.h"
29		#include "libavutil/refstruct.h"
30
31	0	#define HWACCEL_CAP_ASYNC_SAFE (1 << 0)
32	0	#define HWACCEL_CAP_THREAD_SAFE (1 << 1)
33
34		typedef struct FFHWAccel {
35		/**
36		* The public AVHWAccel. See avcodec.h for it.
37		*/
38		AVHWAccel p;
39
40		/**
41		* Allocate a custom buffer
42		*/
43		int (alloc_frame)(AVCodecContext avctx, AVFrame *frame);
44
45		/**
46		* Called at the beginning of each frame or field picture.
47		*
48		* Meaningful frame information (codec specific) is guaranteed to
49		* be parsed at this point. This function is mandatory.
50		*
51		* Note that buf can be NULL along with buf_size set to 0.
52		* Otherwise, this means the whole frame is available at this point.
53		*
54		* @param avctx the codec context
55		* @param buf_ref the frame data buffer reference (optional)
56		* @param buf the frame data buffer base
57		* @param buf_size the size of the frame in bytes
58		* @return zero if successful, a negative value otherwise
59		*/
60		int (start_frame)(AVCodecContext avctx, const AVBufferRef *buf_ref,
61		const uint8_t *buf, uint32_t buf_size);
62
63		/**
64		* Callback for parameter data (SPS/PPS/VPS etc).
65		*
66		* Useful for hardware decoders which keep persistent state about the
67		* video parameters, and need to receive any changes to update that state.
68		*
69		* @param avctx the codec context
70		* @param type the nal unit type
71		* @param buf the nal unit data buffer
72		* @param buf_size the size of the nal unit in bytes
73		* @return zero if successful, a negative value otherwise
74		*/
75		int (decode_params)(AVCodecContext avctx, int type, const uint8_t *buf, uint32_t buf_size);
76
77		/**
78		* Callback for each slice.
79		*
80		* Meaningful slice information (codec specific) is guaranteed to
81		* be parsed at this point. This function is mandatory.
82		*
83		* @param avctx the codec context
84		* @param buf the slice data buffer base
85		* @param buf_size the size of the slice in bytes
86		* @return zero if successful, a negative value otherwise
87		*/
88		int (decode_slice)(AVCodecContext avctx, const uint8_t *buf, uint32_t buf_size);
89
90		/**
91		* Called at the end of each frame or field picture.
92		*
93		* The whole picture is parsed at this point and can now be sent
94		* to the hardware accelerator. This function is mandatory.
95		*
96		* @param avctx the codec context
97		* @return zero if successful, a negative value otherwise
98		*/
99		int (end_frame)(AVCodecContext avctx);
100
101		/**
102		* Size of per-frame hardware accelerator private data.
103		*
104		* Private data is allocated with av_mallocz() before
105		* AVCodecContext.get_buffer() and deallocated after
106		* AVCodecContext.release_buffer().
107		*/
108		int frame_priv_data_size;
109
110		/**
111		* Size of the private data to allocate in
112		* AVCodecInternal.hwaccel_priv_data.
113		*/
114		int priv_data_size;
115
116		/**
117		* Internal hwaccel capabilities.
118		*/
119		int caps_internal;
120
121		/**
122		* Initialize the hwaccel private data.
123		*
124		* This will be called from ff_get_format(), after hwaccel and
125		* hwaccel_context are set and the hwaccel private data in AVCodecInternal
126		* is allocated.
127		*/
128		int (init)(AVCodecContext avctx);
129
130		/**
131		* Uninitialize the hwaccel private data.
132		*
133		* This will be called from get_format() or ff_codec_close(), after hwaccel
134		* and hwaccel_context are already uninitialized.
135		*/
136		int (uninit)(AVCodecContext avctx);
137
138		/**
139		* Fill the given hw_frames context with current codec parameters. Called
140		* from get_format. Refer to avcodec_get_hw_frames_parameters() for
141		* details.
142		*
143		* This CAN be called before AVHWAccel.init is called, and you must assume
144		* that avctx->hwaccel_priv_data is invalid.
145		*/
146		int (frame_params)(AVCodecContext avctx, AVBufferRef *hw_frames_ctx);
147
148		/**
149		* Copy necessary context variables from a previous thread context to the current one.
150		* For thread-safe hwaccels only.
151		*/
152		int (update_thread_context)(AVCodecContext dst, const AVCodecContext *src);
153
154		/**
155		* Callback to free the hwaccel-specific frame data.
156		*
157		* @param hwctx a pointer to an AVHWDeviceContext.
158		* @param data the per-frame hardware accelerator private data to be freed.
159		*/
160		void (free_frame_priv)(AVRefStructOpaque hwctx, void data);
161
162		/**
163		* Callback to flush the hwaccel state.
164		*/
165		void (flush)(AVCodecContext avctx);
166		} FFHWAccel;
167
168		static inline const FFHWAccel ffhwaccel(const AVHWAccel codec)
169	0	{
170	0	return (const FFHWAccel*)codec;
171	0	} Unexecuted instantiation: decode.c:ffhwaccel Unexecuted instantiation: pthread_frame.c:ffhwaccel
172
173		#define FF_HW_CALL(avctx, function, ...) \
174		(ffhwaccel((avctx)->hwaccel)->function((avctx), __VA_ARGS__))
175
176		#define FF_HW_SIMPLE_CALL(avctx, function) \
177	0	(ffhwaccel((avctx)->hwaccel)->function(avctx))
178
179		#define FF_HW_HAS_CB(avctx, function) \
180	0	((avctx)->hwaccel && ffhwaccel((avctx)->hwaccel)->function)
181
182		#endif /* AVCODEC_HWACCEL_INTERNAL */

Coverage Report

Created: 2026-01-25 07:18