FFmpeg  2.1.1
options.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2001 Fabrice Bellard
3  * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
4  *
5  * This file is part of FFmpeg.
6  *
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.
11  *
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.
16  *
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
20  */
21 
22 /**
23  * @file
24  * Options definition for AVCodecContext.
25  */
26 
27 #include "avcodec.h"
28 #include "internal.h"
29 #include "libavutil/avassert.h"
30 #include "libavutil/mem.h"
31 #include "libavutil/opt.h"
32 #include <float.h> /* FLT_MIN, FLT_MAX */
33 #include <string.h>
34 
35 #include "options_table.h"
36 
37 static const char* context_to_name(void* ptr) {
38  AVCodecContext *avc= ptr;
39 
40  if(avc && avc->codec && avc->codec->name)
41  return avc->codec->name;
42  else
43  return "NULL";
44 }
45 
46 static void *codec_child_next(void *obj, void *prev)
47 {
48  AVCodecContext *s = obj;
49  if (!prev && s->codec && s->codec->priv_class && s->priv_data)
50  return s->priv_data;
51  return NULL;
52 }
53 
54 static const AVClass *codec_child_class_next(const AVClass *prev)
55 {
56  AVCodec *c = NULL;
57 
58  /* find the codec that corresponds to prev */
59  while (prev && (c = av_codec_next(c)))
60  if (c->priv_class == prev)
61  break;
62 
63  /* find next codec with priv options */
64  while (c = av_codec_next(c))
65  if (c->priv_class)
66  return c->priv_class;
67  return NULL;
68 }
69 
70 static AVClassCategory get_category(void *ptr)
71 {
72  AVCodecContext* avctx = ptr;
73  if(avctx->codec && avctx->codec->decode) return AV_CLASS_CATEGORY_DECODER;
74  else return AV_CLASS_CATEGORY_ENCODER;
75 }
76 
78  .class_name = "AVCodecContext",
79  .item_name = context_to_name,
80  .option = avcodec_options,
81  .version = LIBAVUTIL_VERSION_INT,
82  .log_level_offset_offset = offsetof(AVCodecContext, log_level_offset),
83  .child_next = codec_child_next,
84  .child_class_next = codec_child_class_next,
86  .get_category = get_category,
87 };
88 
89 #if FF_API_ALLOC_CONTEXT
90 void avcodec_get_context_defaults2(AVCodecContext *s, enum AVMediaType codec_type){
91  AVCodec c= {0};
92  c.type= codec_type;
94 }
95 #endif
96 
98 {
99  int flags=0;
100  memset(s, 0, sizeof(AVCodecContext));
101 
103 
104  s->codec_type = codec ? codec->type : AVMEDIA_TYPE_UNKNOWN;
105  if (codec)
106  s->codec_id = codec->id;
107 
110  else if(s->codec_type == AVMEDIA_TYPE_VIDEO)
112  else if(s->codec_type == AVMEDIA_TYPE_SUBTITLE)
114  av_opt_set_defaults2(s, flags, flags);
115 
116  s->time_base = (AVRational){0,1};
121  s->sample_aspect_ratio = (AVRational){0,1};
124  s->timecode_frame_start = -1;
125 
127  if(codec && codec->priv_data_size){
128  if(!s->priv_data){
129  s->priv_data= av_mallocz(codec->priv_data_size);
130  if (!s->priv_data) {
131  return AVERROR(ENOMEM);
132  }
133  }
134  if(codec->priv_class){
135  *(const AVClass**)s->priv_data = codec->priv_class;
137  }
138  }
139  if (codec && codec->defaults) {
140  int ret;
141  const AVCodecDefault *d = codec->defaults;
142  while (d->key) {
143  ret = av_opt_set(s, d->key, d->value, 0);
144  av_assert0(ret >= 0);
145  d++;
146  }
147  }
148  return 0;
149 }
150 
152 {
153  AVCodecContext *avctx= av_malloc(sizeof(AVCodecContext));
154 
155  if(avctx==NULL) return NULL;
156 
157  if(avcodec_get_context_defaults3(avctx, codec) < 0){
158  av_free(avctx);
159  return NULL;
160  }
161 
162  return avctx;
163 }
164 
165 #if FF_API_ALLOC_CONTEXT
166 AVCodecContext *avcodec_alloc_context2(enum AVMediaType codec_type){
167  AVCodecContext *avctx= av_malloc(sizeof(AVCodecContext));
168 
169  if(avctx==NULL) return NULL;
170 
171  avcodec_get_context_defaults2(avctx, codec_type);
172 
173  return avctx;
174 }
175 
176 void avcodec_get_context_defaults(AVCodecContext *s){
177  avcodec_get_context_defaults2(s, AVMEDIA_TYPE_UNKNOWN);
178 }
179 
180 AVCodecContext *avcodec_alloc_context(void){
181  return avcodec_alloc_context2(AVMEDIA_TYPE_UNKNOWN);
182 }
183 #endif
184 
186 {
187  if (avcodec_is_open(dest)) { // check that the dest context is uninitialized
188  av_log(dest, AV_LOG_ERROR,
189  "Tried to copy AVCodecContext %p into already-initialized %p\n",
190  src, dest);
191  return AVERROR(EINVAL);
192  }
193 
194  av_opt_free(dest);
195  av_free(dest->priv_data);
196 
197  memcpy(dest, src, sizeof(*dest));
198 
199  /* set values specific to opened codecs back to their default state */
200  dest->priv_data = NULL;
201  dest->codec = NULL;
202  dest->slice_offset = NULL;
203  dest->hwaccel = NULL;
204  dest->thread_opaque = NULL;
205  dest->internal = NULL;
206 
207  /* reallocate values that should be allocated separately */
208  dest->rc_eq = NULL;
209  dest->extradata = NULL;
210  dest->intra_matrix = NULL;
211  dest->inter_matrix = NULL;
212  dest->rc_override = NULL;
213  if (src->rc_eq) {
214  dest->rc_eq = av_strdup(src->rc_eq);
215  if (!dest->rc_eq)
216  return AVERROR(ENOMEM);
217  }
218 
219 #define alloc_and_copy_or_fail(obj, size, pad) \
220  if (src->obj && size > 0) { \
221  dest->obj = av_malloc(size + pad); \
222  if (!dest->obj) \
223  goto fail; \
224  memcpy(dest->obj, src->obj, size); \
225  if (pad) \
226  memset(((uint8_t *) dest->obj) + size, 0, pad); \
227  }
228  alloc_and_copy_or_fail(extradata, src->extradata_size,
230  alloc_and_copy_or_fail(intra_matrix, 64 * sizeof(int16_t), 0);
231  alloc_and_copy_or_fail(inter_matrix, 64 * sizeof(int16_t), 0);
232  alloc_and_copy_or_fail(rc_override, src->rc_override_count * sizeof(*src->rc_override), 0);
233  alloc_and_copy_or_fail(subtitle_header, src->subtitle_header_size, 1);
234 #undef alloc_and_copy_or_fail
235 
236  return 0;
237 
238 fail:
239  av_freep(&dest->rc_override);
240  av_freep(&dest->intra_matrix);
241  av_freep(&dest->inter_matrix);
242  av_freep(&dest->extradata);
243  av_freep(&dest->rc_eq);
244  return AVERROR(ENOMEM);
245 }
246 
248 {
249  return &av_codec_context_class;
250 }
251 
252 #define FOFFSET(x) offsetof(AVFrame,x)
253 
254 static const AVOption frame_options[]={
255 {"best_effort_timestamp", "", FOFFSET(best_effort_timestamp), AV_OPT_TYPE_INT64, {.i64 = AV_NOPTS_VALUE }, INT64_MIN, INT64_MAX, 0},
256 {"pkt_pos", "", FOFFSET(pkt_pos), AV_OPT_TYPE_INT64, {.i64 = -1 }, INT64_MIN, INT64_MAX, 0},
257 {"pkt_size", "", FOFFSET(pkt_size), AV_OPT_TYPE_INT64, {.i64 = -1 }, INT64_MIN, INT64_MAX, 0},
258 {"sample_aspect_ratio", "", FOFFSET(sample_aspect_ratio), AV_OPT_TYPE_RATIONAL, {.dbl = 0 }, 0, INT_MAX, 0},
259 {"width", "", FOFFSET(width), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, INT_MAX, 0},
260 {"height", "", FOFFSET(height), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, INT_MAX, 0},
261 {"format", "", FOFFSET(format), AV_OPT_TYPE_INT, {.i64 = -1 }, 0, INT_MAX, 0},
262 {"channel_layout", "", FOFFSET(channel_layout), AV_OPT_TYPE_INT64, {.i64 = 0 }, 0, INT64_MAX, 0},
263 {"sample_rate", "", FOFFSET(sample_rate), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, INT_MAX, 0},
264 {NULL},
265 };
266 
267 static const AVClass av_frame_class = {
268  .class_name = "AVFrame",
269  .item_name = NULL,
270  .option = frame_options,
271  .version = LIBAVUTIL_VERSION_INT,
272 };
273 
275 {
276  return &av_frame_class;
277 }
278 
279 #define SROFFSET(x) offsetof(AVSubtitleRect,x)
280 
282 {"x", "", SROFFSET(x), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, INT_MAX, 0},
283 {"y", "", SROFFSET(y), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, INT_MAX, 0},
284 {"w", "", SROFFSET(w), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, INT_MAX, 0},
285 {"h", "", SROFFSET(h), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, INT_MAX, 0},
286 {"type", "", SROFFSET(type), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, INT_MAX, 0},
287 {"flags", "", SROFFSET(flags), AV_OPT_TYPE_FLAGS, {.i64 = 0}, 0, 1, 0, "flags"},
288 {"forced", "", SROFFSET(flags), AV_OPT_TYPE_FLAGS, {.i64 = 0}, 0, 1, 0},
289 {NULL},
290 };
291 
293  .class_name = "AVSubtitleRect",
294  .item_name = NULL,
295  .option = subtitle_rect_options,
296  .version = LIBAVUTIL_VERSION_INT,
297 };
298 
300 {
301  return &av_subtitle_rect_class;
302 }
const char * s
Definition: avisynth_c.h:668
int avcodec_default_execute2(AVCodecContext *c, int(*func)(AVCodecContext *c2, void *arg2, int, int), void *arg, int *ret, int count)
AVOption.
Definition: opt.h:253
#define LIBAVUTIL_VERSION_INT
Definition: avcodec.h:820
char * av_strdup(const char *s) av_malloc_attrib
Duplicate the string s.
Definition: mem.c:256
void av_opt_set_defaults(void *s)
Set the values of all AVOption fields to their default values.
Definition: opt.c:1064
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel...
Definition: avcodec.h:1517
enum AVMediaType codec_type
Definition: rtp.c:37
static const AVOption avcodec_options[]
Definition: options_table.h:43
void av_log(void *avcl, int level, const char *fmt,...) av_printf_format(3
Send the specified message to the log if the level is less than or equal to the current av_log_level...
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1342
enum AVMediaType type
Definition: avcodec.h:2935
int(* decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt)
Definition: avcodec.h:3007
Pixel format.
Definition: avcodec.h:4533
int * slice_offset
slice offsets in the frame in bytes
Definition: avcodec.h:1508
AVCodec.
Definition: avcodec.h:2922
int avcodec_copy_context(AVCodecContext *dest, const AVCodecContext *src)
Copy the settings of the source AVCodecContext into the destination AVCodecContext.
Definition: options.c:185
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1254
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avcodec.h:1265
void av_freep(void *ptr)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc() and set the pointer ...
Definition: mem.c:234
static const AVClass av_codec_context_class
Definition: options.c:77
#define AV_OPT_FLAG_SUBTITLE_PARAM
Definition: opt.h:288
enum AVPixelFormat avcodec_default_get_format(struct AVCodecContext *s, const enum AVPixelFormat *fmt)
Definition: utils.c:1039
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1881
static const AVOption subtitle_rect_options[]
Definition: options.c:281
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:55
int subtitle_header_size
Definition: avcodec.h:2789
const AVCodecDefault * defaults
Private codec-specific defaults.
Definition: avcodec.h:2985
const AVClass * av_class
information on struct for av_log
Definition: avcodec.h:1151
const char * name
Name of the codec implementation.
Definition: avcodec.h:2929
static const AVClass av_subtitle_rect_class
Definition: options.c:292
#define AV_OPT_FLAG_VIDEO_PARAM
Definition: opt.h:287
struct AVCodecInternal * internal
Private context used for internal data.
Definition: avcodec.h:1190
AVCodecContext * avcodec_alloc_context3(const AVCodec *codec)
Allocate an AVCodecContext and set its fields to default values.
Definition: options.c:151
enum AVCodecID id
Definition: avcodec.h:2936
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: avcodec.h:4147
void av_free(void *ptr)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc(). ...
Definition: mem.c:219
#define AV_OPT_FLAG_AUDIO_PARAM
Definition: opt.h:286
int avcodec_is_open(AVCodecContext *s)
Definition: utils.c:3366
struct AVCodec * codec
Definition: avcodec.h:1155
static void * codec_child_next(void *obj, void *prev)
Definition: options.c:46
AVClassCategory category
Category used for visualization (like color) This is only set if the category is equal for all object...
Definition: log.h:113
Libavcodec external API header.
void * thread_opaque
thread opaque Can be used by execute() to store some per AVCodecContext stuff.
Definition: avcodec.h:2664
static const char * context_to_name(void *ptr)
Definition: options.c:37
const AVClass * avcodec_get_class(void)
Get the AVClass for AVCodecContext.
Definition: options.c:247
goto fail
Definition: avfilter.c:963
#define FF_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:580
int rc_override_count
ratecontrol override, see RcOverride
Definition: avcodec.h:2198
int64_t timecode_frame_start
GOP timecode frame start number.
Definition: avcodec.h:2337
float y
uint16_t * intra_matrix
custom intra quantization matrix
Definition: avcodec.h:1675
ret
Definition: avfilter.c:961
const char * rc_eq
rate control equation
Definition: avcodec.h:2206
int priv_data_size
Definition: avcodec.h:2960
void * av_malloc(size_t size) av_malloc_attrib 1(1)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
Definition: mem.c:73
static const AVClass * codec_child_class_next(const AVClass *prev)
Definition: options.c:54
int64_t reordered_opaque
opaque 64bit number (generally a PTS) that will be reordered and output in AVFrame.reordered_opaque
Definition: avcodec.h:2494
AVCodec * av_codec_next(const AVCodec *c)
If c is NULL, returns the first registered codec, if c is non-NULL, returns the next registered codec...
Definition: utils.c:185
static int width
Definition: utils.c:158
sample_rate
AVS_Value src
Definition: avisynth_c.h:523
int avcodec_default_get_buffer2(AVCodecContext *s, AVFrame *frame, int flags)
The default callback for AVCodecContext.get_buffer2().
Definition: utils.c:693
#define SROFFSET(x)
Definition: options.c:279
enum AVMediaType codec_type
Definition: avcodec.h:1154
enum AVCodecID codec_id
Definition: avcodec.h:1157
main external API structure.
Definition: avcodec.h:1146
int extradata_size
Definition: avcodec.h:1255
BYTE int const BYTE int int int height
Definition: avisynth_c.h:713
const AVClass * avcodec_get_subtitle_rect_class(void)
Get the AVClass for AVSubtitleRect.
Definition: options.c:299
Describe the class of an AVClass context structure.
Definition: log.h:50
enum AVPixelFormat(* get_format)(struct AVCodecContext *s, const enum AVPixelFormat *fmt)
callback to negotiate the pixelFormat
Definition: avcodec.h:1389
RcOverride * rc_override
Definition: avcodec.h:2199
rational number numerator/denominator
Definition: rational.h:43
AVMediaType
Definition: avutil.h:180
int(* get_buffer2)(struct AVCodecContext *s, AVFrame *frame, int flags)
This callback is called at the beginning of each frame to get data buffer(s) for it.
Definition: avcodec.h:2135
Usually treated as AVMEDIA_TYPE_DATA.
Definition: avcodec.h:2230
#define type
void * priv_data
Definition: avcodec.h:1182
static int flags
Definition: cpu.c:45
const uint8_t * key
Definition: internal.h:113
const uint8_t * value
Definition: internal.h:114
void av_opt_free(void *obj)
Free all string and binary options in obj.
Definition: opt.c:1318
static const AVOption frame_options[]
Definition: options.c:254
common internal api header.
static double c[64]
static AVClassCategory get_category(void *ptr)
Definition: options.c:70
static const AVClass av_frame_class
Definition: options.c:267
int avcodec_get_context_defaults3(AVCodecContext *s, const AVCodec *codec)
Set the fields of the given AVCodecContext to default values corresponding to the given codec (defaul...
Definition: options.c:97
int(* execute)(struct AVCodecContext *c, int(*func)(struct AVCodecContext *c2, void *arg), void *arg2, int *ret, int count, int size)
The codec may call this to execute several independent things.
Definition: avcodec.h:2636
#define alloc_and_copy_or_fail(obj, size, pad)
int(* execute2)(struct AVCodecContext *c, int(*func)(struct AVCodecContext *c2, void *arg, int jobnr, int threadnr), void *arg2, int *ret, int count)
The codec may call this to execute several independent things.
Definition: avcodec.h:2656
struct AVHWAccel * hwaccel
Hardware accelerator in use.
Definition: avcodec.h:2501
const AVClass * priv_class
AVClass for the private context.
Definition: avcodec.h:2950
uint16_t * inter_matrix
custom inter quantization matrix
Definition: avcodec.h:1682
#define AVERROR(e)
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
attribute_deprecated void av_opt_set_defaults2(void *s, int mask, int flags)
Definition: opt.c:1070
AVClassCategory
Definition: log.h:28
int av_opt_set(void *obj, const char *name, const char *val, int search_flags)
Definition: opt.c:255
const AVClass * avcodec_get_frame_class(void)
Get the AVClass for AVFrame.
Definition: options.c:274
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avcodec.h:2278
void * av_mallocz(size_t size) av_malloc_attrib 1(1)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
Definition: mem.c:241
#define FOFFSET(x)
Definition: options.c:252
int avcodec_default_execute(AVCodecContext *c, int(*func)(AVCodecContext *c2, void *arg2), void *arg, int *ret, int count, int size)
Definition: utils.c:1009