options.c (6448B)
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 "config_components.h" 28 29 #include "avcodec.h" 30 #include "avcodec_internal.h" 31 #include "codec_internal.h" 32 #include "libavutil/avassert.h" 33 #include "libavutil/internal.h" 34 #include "libavutil/mem.h" 35 #include "libavutil/opt.h" 36 #include <string.h> 37 38 FF_DISABLE_DEPRECATION_WARNINGS 39 #include "options_table.h" 40 FF_ENABLE_DEPRECATION_WARNINGS 41 42 static const char* context_to_name(void* ptr) { 43 AVCodecContext *avc= ptr; 44 45 if (avc && avc->codec) 46 return avc->codec->name; 47 else 48 return "NULL"; 49 } 50 51 static void *codec_child_next(void *obj, void *prev) 52 { 53 AVCodecContext *s = obj; 54 if (!prev && s->codec && s->codec->priv_class && s->priv_data) 55 return s->priv_data; 56 return NULL; 57 } 58 59 static const AVClass *codec_child_class_iterate(void **iter) 60 { 61 const AVCodec *c; 62 /* find next codec with priv options */ 63 while (c = av_codec_iterate(iter)) 64 if (c->priv_class) 65 return c->priv_class; 66 return NULL; 67 } 68 69 static AVClassCategory get_category(void *ptr) 70 { 71 AVCodecContext* avctx = ptr; 72 if (avctx->codec && av_codec_is_decoder(avctx->codec)) 73 return AV_CLASS_CATEGORY_DECODER; 74 else 75 return AV_CLASS_CATEGORY_ENCODER; 76 } 77 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_iterate = codec_child_class_iterate, 86 .category = AV_CLASS_CATEGORY_ENCODER, 87 .get_category = get_category, 88 }; 89 90 static int init_context_defaults(AVCodecContext *s, const AVCodec *codec) 91 { 92 const FFCodec *const codec2 = ffcodec(codec); 93 int flags=0; 94 memset(s, 0, sizeof(AVCodecContext)); 95 96 s->av_class = &av_codec_context_class; 97 98 s->codec_type = codec ? codec->type : AVMEDIA_TYPE_UNKNOWN; 99 if (codec) { 100 s->codec = codec; 101 s->codec_id = codec->id; 102 } 103 104 if(s->codec_type == AVMEDIA_TYPE_AUDIO) 105 flags= AV_OPT_FLAG_AUDIO_PARAM; 106 else if(s->codec_type == AVMEDIA_TYPE_VIDEO) 107 flags= AV_OPT_FLAG_VIDEO_PARAM; 108 else if(s->codec_type == AVMEDIA_TYPE_SUBTITLE) 109 flags= AV_OPT_FLAG_SUBTITLE_PARAM; 110 av_opt_set_defaults2(s, flags, flags); 111 112 av_channel_layout_uninit(&s->ch_layout); 113 114 s->time_base = (AVRational){0,1}; 115 s->framerate = (AVRational){ 0, 1 }; 116 s->pkt_timebase = (AVRational){ 0, 1 }; 117 s->get_buffer2 = avcodec_default_get_buffer2; 118 s->get_format = avcodec_default_get_format; 119 s->get_encode_buffer = avcodec_default_get_encode_buffer; 120 s->execute = avcodec_default_execute; 121 s->execute2 = avcodec_default_execute2; 122 s->sample_aspect_ratio = (AVRational){0,1}; 123 s->ch_layout.order = AV_CHANNEL_ORDER_UNSPEC; 124 s->pix_fmt = AV_PIX_FMT_NONE; 125 s->sw_pix_fmt = AV_PIX_FMT_NONE; 126 s->sample_fmt = AV_SAMPLE_FMT_NONE; 127 128 if(codec && codec2->priv_data_size){ 129 s->priv_data = av_mallocz(codec2->priv_data_size); 130 if (!s->priv_data) 131 return AVERROR(ENOMEM); 132 if(codec->priv_class){ 133 *(const AVClass**)s->priv_data = codec->priv_class; 134 av_opt_set_defaults(s->priv_data); 135 } 136 } 137 if (codec && codec2->defaults) { 138 int ret; 139 const FFCodecDefault *d = codec2->defaults; 140 while (d->key) { 141 ret = av_opt_set(s, d->key, d->value, 0); 142 av_assert0(ret >= 0); 143 d++; 144 } 145 } 146 return 0; 147 } 148 149 AVCodecContext *avcodec_alloc_context3(const AVCodec *codec) 150 { 151 AVCodecContext *avctx= av_malloc(sizeof(AVCodecContext)); 152 153 if (!avctx) 154 return NULL; 155 156 if (init_context_defaults(avctx, codec) < 0) { 157 av_free(avctx); 158 return NULL; 159 } 160 161 return avctx; 162 } 163 164 void avcodec_free_context(AVCodecContext **pavctx) 165 { 166 AVCodecContext *avctx = *pavctx; 167 168 if (!avctx) 169 return; 170 171 ff_codec_close(avctx); 172 173 av_freep(&avctx->extradata); 174 av_freep(&avctx->subtitle_header); 175 av_freep(&avctx->intra_matrix); 176 av_freep(&avctx->chroma_intra_matrix); 177 av_freep(&avctx->inter_matrix); 178 av_freep(&avctx->rc_override); 179 av_channel_layout_uninit(&avctx->ch_layout); 180 181 av_freep(pavctx); 182 } 183 184 const AVClass *avcodec_get_class(void) 185 { 186 return &av_codec_context_class; 187 } 188 189 #define SROFFSET(x) offsetof(AVSubtitleRect,x) 190 191 static const AVOption subtitle_rect_options[]={ 192 {"x", "", SROFFSET(x), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, INT_MAX, 0}, 193 {"y", "", SROFFSET(y), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, INT_MAX, 0}, 194 {"w", "", SROFFSET(w), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, INT_MAX, 0}, 195 {"h", "", SROFFSET(h), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, INT_MAX, 0}, 196 {"type", "", SROFFSET(type), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, INT_MAX, 0}, 197 {"flags", "", SROFFSET(flags), AV_OPT_TYPE_FLAGS, {.i64 = 0}, 0, 1, 0, .unit = "flags"}, 198 {"forced", "", SROFFSET(flags), AV_OPT_TYPE_FLAGS, {.i64 = 0}, 0, 1, 0}, 199 {NULL}, 200 }; 201 202 static const AVClass av_subtitle_rect_class = { 203 .class_name = "AVSubtitleRect", 204 .item_name = NULL, 205 .option = subtitle_rect_options, 206 .version = LIBAVUTIL_VERSION_INT, 207 }; 208 209 const AVClass *avcodec_get_subtitle_rect_class(void) 210 { 211 return &av_subtitle_rect_class; 212 }