Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | RSS feed

  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.  
  77. static const AVClass av_codec_context_class = {
  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,
  85.     .category                = AV_CLASS_CATEGORY_ENCODER,
  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;
  93.     avcodec_get_context_defaults3(s, &c);
  94. }
  95. #endif
  96.  
  97. int avcodec_get_context_defaults3(AVCodecContext *s, const AVCodec *codec)
  98. {
  99.     int flags=0;
  100.     memset(s, 0, sizeof(AVCodecContext));
  101.  
  102.     s->av_class = &av_codec_context_class;
  103.  
  104.     s->codec_type = codec ? codec->type : AVMEDIA_TYPE_UNKNOWN;
  105.     if (codec)
  106.         s->codec_id = codec->id;
  107.  
  108.     if(s->codec_type == AVMEDIA_TYPE_AUDIO)
  109.         flags= AV_OPT_FLAG_AUDIO_PARAM;
  110.     else if(s->codec_type == AVMEDIA_TYPE_VIDEO)
  111.         flags= AV_OPT_FLAG_VIDEO_PARAM;
  112.     else if(s->codec_type == AVMEDIA_TYPE_SUBTITLE)
  113.         flags= AV_OPT_FLAG_SUBTITLE_PARAM;
  114.     av_opt_set_defaults2(s, flags, flags);
  115.  
  116.     s->time_base           = (AVRational){0,1};
  117.     s->get_buffer2         = avcodec_default_get_buffer2;
  118.     s->get_format          = avcodec_default_get_format;
  119.     s->execute             = avcodec_default_execute;
  120.     s->execute2            = avcodec_default_execute2;
  121.     s->sample_aspect_ratio = (AVRational){0,1};
  122.     s->pix_fmt             = AV_PIX_FMT_NONE;
  123.     s->sample_fmt          = AV_SAMPLE_FMT_NONE;
  124.     s->timecode_frame_start = -1;
  125.  
  126.     s->reordered_opaque    = AV_NOPTS_VALUE;
  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;
  136.             av_opt_set_defaults(s->priv_data);
  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.  
  151. AVCodecContext *avcodec_alloc_context3(const AVCodec *codec)
  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.  
  185. int avcodec_copy_context(AVCodecContext *dest, const AVCodecContext *src)
  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,
  229.                            FF_INPUT_BUFFER_PADDING_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.  
  247. const AVClass *avcodec_get_class(void)
  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.  
  274. const AVClass *avcodec_get_frame_class(void)
  275. {
  276.     return &av_frame_class;
  277. }
  278.  
  279. #define SROFFSET(x) offsetof(AVSubtitleRect,x)
  280.  
  281. static const AVOption subtitle_rect_options[]={
  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.  
  292. static const AVClass av_subtitle_rect_class = {
  293.     .class_name             = "AVSubtitleRect",
  294.     .item_name              = NULL,
  295.     .option                 = subtitle_rect_options,
  296.     .version                = LIBAVUTIL_VERSION_INT,
  297. };
  298.  
  299. const AVClass *avcodec_get_subtitle_rect_class(void)
  300. {
  301.     return &av_subtitle_rect_class;
  302. }
  303.