2 * Copyright (c) 2001 Fabrice Bellard
3 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
24 * Options definition for AVCodecContext.
29 #include "libavutil/avassert.h"
30 #include "libavutil/internal.h"
31 #include "libavutil/mem.h"
32 #include "libavutil/opt.h"
33 #include <float.h> /* FLT_MIN, FLT_MAX */
36 #include "options_table.h"
38 static const char* context_to_name(void* ptr
) {
39 AVCodecContext
*avc
= ptr
;
41 if(avc
&& avc
->codec
&& avc
->codec
->name
)
42 return avc
->codec
->name
;
47 static void *codec_child_next(void *obj
, void *prev
)
49 AVCodecContext
*s
= obj
;
50 if (!prev
&& s
->codec
&& s
->codec
->priv_class
&& s
->priv_data
)
55 static const AVClass
*codec_child_class_next(const AVClass
*prev
)
59 /* find the codec that corresponds to prev */
60 while (prev
&& (c
= av_codec_next(c
)))
61 if (c
->priv_class
== prev
)
64 /* find next codec with priv options */
65 while (c
= av_codec_next(c
))
71 static AVClassCategory
get_category(void *ptr
)
73 AVCodecContext
* avctx
= ptr
;
74 if(avctx
->codec
&& avctx
->codec
->decode
) return AV_CLASS_CATEGORY_DECODER
;
75 else return AV_CLASS_CATEGORY_ENCODER
;
78 static const AVClass av_codec_context_class
= {
79 .class_name
= "AVCodecContext",
80 .item_name
= context_to_name
,
81 .option
= avcodec_options
,
82 .version
= LIBAVUTIL_VERSION_INT
,
83 .log_level_offset_offset
= offsetof(AVCodecContext
, log_level_offset
),
84 .child_next
= codec_child_next
,
85 .child_class_next
= codec_child_class_next
,
86 .category
= AV_CLASS_CATEGORY_ENCODER
,
87 .get_category
= get_category
,
90 int avcodec_get_context_defaults3(AVCodecContext
*s
, const AVCodec
*codec
)
93 memset(s
, 0, sizeof(AVCodecContext
));
95 s
->av_class
= &av_codec_context_class
;
97 s
->codec_type
= codec
? codec
->type
: AVMEDIA_TYPE_UNKNOWN
;
100 s
->codec_id
= codec
->id
;
103 if(s
->codec_type
== AVMEDIA_TYPE_AUDIO
)
104 flags
= AV_OPT_FLAG_AUDIO_PARAM
;
105 else if(s
->codec_type
== AVMEDIA_TYPE_VIDEO
)
106 flags
= AV_OPT_FLAG_VIDEO_PARAM
;
107 else if(s
->codec_type
== AVMEDIA_TYPE_SUBTITLE
)
108 flags
= AV_OPT_FLAG_SUBTITLE_PARAM
;
109 av_opt_set_defaults2(s
, flags
, flags
);
111 s
->time_base
= (AVRational
){0,1};
112 s
->framerate
= (AVRational
){ 0, 1 };
113 s
->pkt_timebase
= (AVRational
){ 0, 1 };
114 s
->get_buffer2
= avcodec_default_get_buffer2
;
115 s
->get_format
= avcodec_default_get_format
;
116 s
->execute
= avcodec_default_execute
;
117 s
->execute2
= avcodec_default_execute2
;
118 s
->sample_aspect_ratio
= (AVRational
){0,1};
119 s
->pix_fmt
= AV_PIX_FMT_NONE
;
120 s
->sample_fmt
= AV_SAMPLE_FMT_NONE
;
122 s
->reordered_opaque
= AV_NOPTS_VALUE
;
123 if(codec
&& codec
->priv_data_size
){
125 s
->priv_data
= av_mallocz(codec
->priv_data_size
);
127 return AVERROR(ENOMEM
);
130 if(codec
->priv_class
){
131 *(const AVClass
**)s
->priv_data
= codec
->priv_class
;
132 av_opt_set_defaults(s
->priv_data
);
135 if (codec
&& codec
->defaults
) {
137 const AVCodecDefault
*d
= codec
->defaults
;
139 ret
= av_opt_set(s
, d
->key
, d
->value
, 0);
140 av_assert0(ret
>= 0);
147 AVCodecContext
*avcodec_alloc_context3(const AVCodec
*codec
)
149 AVCodecContext
*avctx
= av_malloc(sizeof(AVCodecContext
));
154 if(avcodec_get_context_defaults3(avctx
, codec
) < 0){
162 void avcodec_free_context(AVCodecContext
**pavctx
)
164 AVCodecContext
*avctx
= *pavctx
;
169 avcodec_close(avctx
);
171 av_freep(&avctx
->extradata
);
172 av_freep(&avctx
->subtitle_header
);
173 av_freep(&avctx
->intra_matrix
);
174 av_freep(&avctx
->inter_matrix
);
175 av_freep(&avctx
->rc_override
);
180 int avcodec_copy_context(AVCodecContext
*dest
, const AVCodecContext
*src
)
182 const AVCodec
*orig_codec
= dest
->codec
;
183 uint8_t *orig_priv_data
= dest
->priv_data
;
185 if (avcodec_is_open(dest
)) { // check that the dest context is uninitialized
186 av_log(dest
, AV_LOG_ERROR
,
187 "Tried to copy AVCodecContext %p into already-initialized %p\n",
189 return AVERROR(EINVAL
);
194 memcpy(dest
, src
, sizeof(*dest
));
195 av_opt_copy(dest
, src
);
197 dest
->priv_data
= orig_priv_data
;
200 av_opt_copy(orig_priv_data
, src
->priv_data
);
202 dest
->codec
= orig_codec
;
204 /* set values specific to opened codecs back to their default state */
205 dest
->slice_offset
= NULL
;
206 dest
->hwaccel
= NULL
;
207 dest
->internal
= NULL
;
209 /* reallocate values that should be allocated separately */
210 dest
->extradata
= NULL
;
211 dest
->intra_matrix
= NULL
;
212 dest
->inter_matrix
= NULL
;
213 dest
->rc_override
= NULL
;
214 dest
->subtitle_header
= NULL
;
216 #define alloc_and_copy_or_fail(obj, size, pad) \
217 if (src->obj && size > 0) { \
218 dest->obj = av_malloc(size + pad); \
221 memcpy(dest->obj, src->obj, size); \
223 memset(((uint8_t *) dest->obj) + size, 0, pad); \
225 alloc_and_copy_or_fail(extradata
, src
->extradata_size
,
226 FF_INPUT_BUFFER_PADDING_SIZE
);
227 alloc_and_copy_or_fail(intra_matrix
, 64 * sizeof(int16_t), 0);
228 alloc_and_copy_or_fail(inter_matrix
, 64 * sizeof(int16_t), 0);
229 alloc_and_copy_or_fail(rc_override
, src
->rc_override_count
* sizeof(*src
->rc_override
), 0);
230 alloc_and_copy_or_fail(subtitle_header
, src
->subtitle_header_size
, 1);
231 av_assert0(dest
->subtitle_header_size
== src
->subtitle_header_size
);
232 #undef alloc_and_copy_or_fail
237 av_freep(&dest
->rc_override
);
238 av_freep(&dest
->intra_matrix
);
239 av_freep(&dest
->inter_matrix
);
240 av_freep(&dest
->extradata
);
242 FF_DISABLE_DEPRECATION_WARNINGS
243 av_freep(&dest
->rc_eq
);
244 FF_ENABLE_DEPRECATION_WARNINGS
246 return AVERROR(ENOMEM
);
249 const AVClass
*avcodec_get_class(void)
251 return &av_codec_context_class
;
254 #define FOFFSET(x) offsetof(AVFrame,x)
256 static const AVOption frame_options
[]={
257 {"best_effort_timestamp", "", FOFFSET(best_effort_timestamp
), AV_OPT_TYPE_INT64
, {.i64
= AV_NOPTS_VALUE
}, INT64_MIN
, INT64_MAX
, 0},
258 {"pkt_pos", "", FOFFSET(pkt_pos
), AV_OPT_TYPE_INT64
, {.i64
= -1 }, INT64_MIN
, INT64_MAX
, 0},
259 {"pkt_size", "", FOFFSET(pkt_size
), AV_OPT_TYPE_INT64
, {.i64
= -1 }, INT64_MIN
, INT64_MAX
, 0},
260 {"sample_aspect_ratio", "", FOFFSET(sample_aspect_ratio
), AV_OPT_TYPE_RATIONAL
, {.dbl
= 0 }, 0, INT_MAX
, 0},
261 {"width", "", FOFFSET(width
), AV_OPT_TYPE_INT
, {.i64
= 0 }, 0, INT_MAX
, 0},
262 {"height", "", FOFFSET(height
), AV_OPT_TYPE_INT
, {.i64
= 0 }, 0, INT_MAX
, 0},
263 {"format", "", FOFFSET(format
), AV_OPT_TYPE_INT
, {.i64
= -1 }, 0, INT_MAX
, 0},
264 {"channel_layout", "", FOFFSET(channel_layout
), AV_OPT_TYPE_INT64
, {.i64
= 0 }, 0, INT64_MAX
, 0},
265 {"sample_rate", "", FOFFSET(sample_rate
), AV_OPT_TYPE_INT
, {.i64
= 0 }, 0, INT_MAX
, 0},
269 static const AVClass av_frame_class
= {
270 .class_name
= "AVFrame",
272 .option
= frame_options
,
273 .version
= LIBAVUTIL_VERSION_INT
,
276 const AVClass
*avcodec_get_frame_class(void)
278 return &av_frame_class
;
281 #define SROFFSET(x) offsetof(AVSubtitleRect,x)
283 static const AVOption subtitle_rect_options
[]={
284 {"x", "", SROFFSET(x
), AV_OPT_TYPE_INT
, {.i64
= 0 }, 0, INT_MAX
, 0},
285 {"y", "", SROFFSET(y
), AV_OPT_TYPE_INT
, {.i64
= 0 }, 0, INT_MAX
, 0},
286 {"w", "", SROFFSET(w
), AV_OPT_TYPE_INT
, {.i64
= 0 }, 0, INT_MAX
, 0},
287 {"h", "", SROFFSET(h
), AV_OPT_TYPE_INT
, {.i64
= 0 }, 0, INT_MAX
, 0},
288 {"type", "", SROFFSET(type
), AV_OPT_TYPE_INT
, {.i64
= 0 }, 0, INT_MAX
, 0},
289 {"flags", "", SROFFSET(flags
), AV_OPT_TYPE_FLAGS
, {.i64
= 0}, 0, 1, 0, "flags"},
290 {"forced", "", SROFFSET(flags
), AV_OPT_TYPE_FLAGS
, {.i64
= 0}, 0, 1, 0},
294 static const AVClass av_subtitle_rect_class
= {
295 .class_name
= "AVSubtitleRect",
297 .option
= subtitle_rect_options
,
298 .version
= LIBAVUTIL_VERSION_INT
,
301 const AVClass
*avcodec_get_subtitle_rect_class(void)
303 return &av_subtitle_rect_class
;