Subversion Repositories Kolibri OS

Rev

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/internal.h"
  31. #include "libavutil/mem.h"
  32. #include "libavutil/opt.h"
  33. #include <float.h>              /* FLT_MIN, FLT_MAX */
  34. #include <string.h>
  35.  
  36. FF_DISABLE_DEPRECATION_WARNINGS
  37. #include "options_table.h"
  38. FF_ENABLE_DEPRECATION_WARNINGS
  39.  
  40. static const char* context_to_name(void* ptr) {
  41.     AVCodecContext *avc= ptr;
  42.  
  43.     if(avc && avc->codec && avc->codec->name)
  44.         return avc->codec->name;
  45.     else
  46.         return "NULL";
  47. }
  48.  
  49. static void *codec_child_next(void *obj, void *prev)
  50. {
  51.     AVCodecContext *s = obj;
  52.     if (!prev && s->codec && s->codec->priv_class && s->priv_data)
  53.         return s->priv_data;
  54.     return NULL;
  55. }
  56.  
  57. static const AVClass *codec_child_class_next(const AVClass *prev)
  58. {
  59.     AVCodec *c = NULL;
  60.  
  61.     /* find the codec that corresponds to prev */
  62.     while (prev && (c = av_codec_next(c)))
  63.         if (c->priv_class == prev)
  64.             break;
  65.  
  66.     /* find next codec with priv options */
  67.     while (c = av_codec_next(c))
  68.         if (c->priv_class)
  69.             return c->priv_class;
  70.     return NULL;
  71. }
  72.  
  73. static AVClassCategory get_category(void *ptr)
  74. {
  75.     AVCodecContext* avctx = ptr;
  76.     if(avctx->codec && avctx->codec->decode) return AV_CLASS_CATEGORY_DECODER;
  77.     else                                     return AV_CLASS_CATEGORY_ENCODER;
  78. }
  79.  
  80. static const AVClass av_codec_context_class = {
  81.     .class_name              = "AVCodecContext",
  82.     .item_name               = context_to_name,
  83.     .option                  = avcodec_options,
  84.     .version                 = LIBAVUTIL_VERSION_INT,
  85.     .log_level_offset_offset = offsetof(AVCodecContext, log_level_offset),
  86.     .child_next              = codec_child_next,
  87.     .child_class_next        = codec_child_class_next,
  88.     .category                = AV_CLASS_CATEGORY_ENCODER,
  89.     .get_category            = get_category,
  90. };
  91.  
  92. int avcodec_get_context_defaults3(AVCodecContext *s, const AVCodec *codec)
  93. {
  94.     int flags=0;
  95.     memset(s, 0, sizeof(AVCodecContext));
  96.  
  97.     s->av_class = &av_codec_context_class;
  98.  
  99.     s->codec_type = codec ? codec->type : AVMEDIA_TYPE_UNKNOWN;
  100.     if (codec) {
  101.         s->codec = codec;
  102.         s->codec_id = codec->id;
  103.     }
  104.  
  105.     if(s->codec_type == AVMEDIA_TYPE_AUDIO)
  106.         flags= AV_OPT_FLAG_AUDIO_PARAM;
  107.     else if(s->codec_type == AVMEDIA_TYPE_VIDEO)
  108.         flags= AV_OPT_FLAG_VIDEO_PARAM;
  109.     else if(s->codec_type == AVMEDIA_TYPE_SUBTITLE)
  110.         flags= AV_OPT_FLAG_SUBTITLE_PARAM;
  111.     av_opt_set_defaults2(s, flags, flags);
  112.  
  113.     s->time_base           = (AVRational){0,1};
  114.     s->framerate           = (AVRational){ 0, 1 };
  115.     s->pkt_timebase        = (AVRational){ 0, 1 };
  116.     s->get_buffer2         = avcodec_default_get_buffer2;
  117.     s->get_format          = avcodec_default_get_format;
  118.     s->execute             = avcodec_default_execute;
  119.     s->execute2            = avcodec_default_execute2;
  120.     s->sample_aspect_ratio = (AVRational){0,1};
  121.     s->pix_fmt             = AV_PIX_FMT_NONE;
  122.     s->sample_fmt          = AV_SAMPLE_FMT_NONE;
  123.  
  124.     s->reordered_opaque    = AV_NOPTS_VALUE;
  125.     if(codec && codec->priv_data_size){
  126.         if(!s->priv_data){
  127.             s->priv_data= av_mallocz(codec->priv_data_size);
  128.             if (!s->priv_data) {
  129.                 return AVERROR(ENOMEM);
  130.             }
  131.         }
  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 && codec->defaults) {
  138.         int ret;
  139.         const AVCodecDefault *d = codec->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(avcodec_get_context_defaults3(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.     avcodec_close(avctx);
  172.  
  173.     av_freep(&avctx->extradata);
  174.     av_freep(&avctx->subtitle_header);
  175.     av_freep(&avctx->intra_matrix);
  176.     av_freep(&avctx->inter_matrix);
  177.     av_freep(&avctx->rc_override);
  178.  
  179.     av_freep(pavctx);
  180. }
  181.  
  182. int avcodec_copy_context(AVCodecContext *dest, const AVCodecContext *src)
  183. {
  184.     const AVCodec *orig_codec = dest->codec;
  185.     uint8_t *orig_priv_data = dest->priv_data;
  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_freep(&dest->rc_override);
  196.     av_freep(&dest->intra_matrix);
  197.     av_freep(&dest->inter_matrix);
  198.     av_freep(&dest->extradata);
  199.     av_freep(&dest->subtitle_header);
  200.  
  201.     memcpy(dest, src, sizeof(*dest));
  202.     av_opt_copy(dest, src);
  203.  
  204.     dest->priv_data       = orig_priv_data;
  205.     dest->codec           = orig_codec;
  206.  
  207.     if (orig_priv_data && src->codec && src->codec->priv_class &&
  208.         dest->codec && dest->codec->priv_class)
  209.         av_opt_copy(orig_priv_data, src->priv_data);
  210.  
  211.  
  212.     /* set values specific to opened codecs back to their default state */
  213.     dest->slice_offset    = NULL;
  214.     dest->hwaccel         = NULL;
  215.     dest->internal        = NULL;
  216. #if FF_API_CODED_FRAME
  217. FF_DISABLE_DEPRECATION_WARNINGS
  218.     dest->coded_frame     = NULL;
  219. FF_ENABLE_DEPRECATION_WARNINGS
  220. #endif
  221.  
  222.     /* reallocate values that should be allocated separately */
  223.     dest->extradata       = NULL;
  224.     dest->intra_matrix    = NULL;
  225.     dest->inter_matrix    = NULL;
  226.     dest->rc_override     = NULL;
  227.     dest->subtitle_header = NULL;
  228.  
  229. #define alloc_and_copy_or_fail(obj, size, pad) \
  230.     if (src->obj && size > 0) { \
  231.         dest->obj = av_malloc(size + pad); \
  232.         if (!dest->obj) \
  233.             goto fail; \
  234.         memcpy(dest->obj, src->obj, size); \
  235.         if (pad) \
  236.             memset(((uint8_t *) dest->obj) + size, 0, pad); \
  237.     }
  238.     alloc_and_copy_or_fail(extradata,    src->extradata_size,
  239.                            AV_INPUT_BUFFER_PADDING_SIZE);
  240.     dest->extradata_size  = src->extradata_size;
  241.     alloc_and_copy_or_fail(intra_matrix, 64 * sizeof(int16_t), 0);
  242.     alloc_and_copy_or_fail(inter_matrix, 64 * sizeof(int16_t), 0);
  243.     alloc_and_copy_or_fail(rc_override,  src->rc_override_count * sizeof(*src->rc_override), 0);
  244.     alloc_and_copy_or_fail(subtitle_header, src->subtitle_header_size, 1);
  245.     av_assert0(dest->subtitle_header_size == src->subtitle_header_size);
  246. #undef alloc_and_copy_or_fail
  247.  
  248.     return 0;
  249.  
  250. fail:
  251.     av_freep(&dest->rc_override);
  252.     av_freep(&dest->intra_matrix);
  253.     av_freep(&dest->inter_matrix);
  254.     av_freep(&dest->extradata);
  255.     av_freep(&dest->subtitle_header);
  256.     dest->subtitle_header_size = 0;
  257.     dest->extradata_size = 0;
  258.     av_opt_free(dest);
  259.     return AVERROR(ENOMEM);
  260. }
  261.  
  262. const AVClass *avcodec_get_class(void)
  263. {
  264.     return &av_codec_context_class;
  265. }
  266.  
  267. #define FOFFSET(x) offsetof(AVFrame,x)
  268.  
  269. static const AVOption frame_options[]={
  270. {"best_effort_timestamp", "", FOFFSET(best_effort_timestamp), AV_OPT_TYPE_INT64, {.i64 = AV_NOPTS_VALUE }, INT64_MIN, INT64_MAX, 0},
  271. {"pkt_pos", "", FOFFSET(pkt_pos), AV_OPT_TYPE_INT64, {.i64 = -1 }, INT64_MIN, INT64_MAX, 0},
  272. {"pkt_size", "", FOFFSET(pkt_size), AV_OPT_TYPE_INT64, {.i64 = -1 }, INT64_MIN, INT64_MAX, 0},
  273. {"sample_aspect_ratio", "", FOFFSET(sample_aspect_ratio), AV_OPT_TYPE_RATIONAL, {.dbl = 0 }, 0, INT_MAX, 0},
  274. {"width", "", FOFFSET(width), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, INT_MAX, 0},
  275. {"height", "", FOFFSET(height), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, INT_MAX, 0},
  276. {"format", "", FOFFSET(format), AV_OPT_TYPE_INT, {.i64 = -1 }, 0, INT_MAX, 0},
  277. {"channel_layout", "", FOFFSET(channel_layout), AV_OPT_TYPE_INT64, {.i64 = 0 }, 0, INT64_MAX, 0},
  278. {"sample_rate", "", FOFFSET(sample_rate), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, INT_MAX, 0},
  279. {NULL},
  280. };
  281.  
  282. static const AVClass av_frame_class = {
  283.     .class_name              = "AVFrame",
  284.     .item_name               = NULL,
  285.     .option                  = frame_options,
  286.     .version                 = LIBAVUTIL_VERSION_INT,
  287. };
  288.  
  289. const AVClass *avcodec_get_frame_class(void)
  290. {
  291.     return &av_frame_class;
  292. }
  293.  
  294. #define SROFFSET(x) offsetof(AVSubtitleRect,x)
  295.  
  296. static const AVOption subtitle_rect_options[]={
  297. {"x", "", SROFFSET(x), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, INT_MAX, 0},
  298. {"y", "", SROFFSET(y), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, INT_MAX, 0},
  299. {"w", "", SROFFSET(w), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, INT_MAX, 0},
  300. {"h", "", SROFFSET(h), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, INT_MAX, 0},
  301. {"type", "", SROFFSET(type), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, INT_MAX, 0},
  302. {"flags", "", SROFFSET(flags), AV_OPT_TYPE_FLAGS, {.i64 = 0}, 0, 1, 0, "flags"},
  303. {"forced", "", SROFFSET(flags), AV_OPT_TYPE_FLAGS, {.i64 = 0}, 0, 1, 0},
  304. {NULL},
  305. };
  306.  
  307. static const AVClass av_subtitle_rect_class = {
  308.     .class_name             = "AVSubtitleRect",
  309.     .item_name              = NULL,
  310.     .option                 = subtitle_rect_options,
  311.     .version                = LIBAVUTIL_VERSION_INT,
  312. };
  313.  
  314. const AVClass *avcodec_get_subtitle_rect_class(void)
  315. {
  316.     return &av_subtitle_rect_class;
  317. }
  318.  
  319. #ifdef TEST
  320. static int dummy_init(AVCodecContext *ctx)
  321. {
  322.     //TODO: this code should set every possible pointer that could be set by codec and is not an option;
  323.     ctx->extradata_size = 8;
  324.     ctx->extradata = av_malloc(ctx->extradata_size);
  325.     return 0;
  326. }
  327.  
  328. static int dummy_close(AVCodecContext *ctx)
  329. {
  330.     av_freep(&ctx->extradata);
  331.     ctx->extradata_size = 0;
  332.     return 0;
  333. }
  334.  
  335. static int dummy_encode(AVCodecContext *ctx, AVPacket *pkt, const AVFrame *frame, int *got_packet)
  336. {
  337.     return AVERROR(ENOSYS);
  338. }
  339.  
  340. typedef struct Dummy12Context {
  341.     AVClass  *av_class;
  342.     int      num;
  343.     char*    str;
  344. } Dummy12Context;
  345.  
  346. typedef struct Dummy3Context {
  347.     void     *fake_av_class;
  348.     int      num;
  349.     char*    str;
  350. } Dummy3Context;
  351.  
  352. #define OFFSET(x) offsetof(Dummy12Context, x)
  353. #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
  354. static const AVOption dummy_options[] = {
  355.     { "str", "set str", OFFSET(str), AV_OPT_TYPE_STRING, { .str = "i'm src default value" }, 0, 0, VE},
  356.     { "num", "set num", OFFSET(num), AV_OPT_TYPE_INT,    { .i64 = 1500100900 },    0, INT_MAX, VE},
  357.     { NULL },
  358. };
  359.  
  360. static const AVClass dummy_v1_class = {
  361.     .class_name = "dummy_v1_class",
  362.     .item_name  = av_default_item_name,
  363.     .option     = dummy_options,
  364.     .version    = LIBAVUTIL_VERSION_INT,
  365. };
  366.  
  367. static const AVClass dummy_v2_class = {
  368.     .class_name = "dummy_v2_class",
  369.     .item_name  = av_default_item_name,
  370.     .option     = dummy_options,
  371.     .version    = LIBAVUTIL_VERSION_INT,
  372. };
  373.  
  374. /* codec with options */
  375. static AVCodec dummy_v1_encoder = {
  376.     .name             = "dummy_v1_codec",
  377.     .type             = AVMEDIA_TYPE_VIDEO,
  378.     .id               = AV_CODEC_ID_NONE - 1,
  379.     .encode2          = dummy_encode,
  380.     .init             = dummy_init,
  381.     .close            = dummy_close,
  382.     .priv_class       = &dummy_v1_class,
  383.     .priv_data_size   = sizeof(Dummy12Context),
  384. };
  385.  
  386. /* codec with options, different class */
  387. static AVCodec dummy_v2_encoder = {
  388.     .name             = "dummy_v2_codec",
  389.     .type             = AVMEDIA_TYPE_VIDEO,
  390.     .id               = AV_CODEC_ID_NONE - 2,
  391.     .encode2          = dummy_encode,
  392.     .init             = dummy_init,
  393.     .close            = dummy_close,
  394.     .priv_class       = &dummy_v2_class,
  395.     .priv_data_size   = sizeof(Dummy12Context),
  396. };
  397.  
  398. /* codec with priv data, but no class */
  399. static AVCodec dummy_v3_encoder = {
  400.     .name             = "dummy_v3_codec",
  401.     .type             = AVMEDIA_TYPE_VIDEO,
  402.     .id               = AV_CODEC_ID_NONE - 3,
  403.     .encode2          = dummy_encode,
  404.     .init             = dummy_init,
  405.     .close            = dummy_close,
  406.     .priv_data_size   = sizeof(Dummy3Context),
  407. };
  408.  
  409. /* codec without priv data */
  410. static AVCodec dummy_v4_encoder = {
  411.     .name             = "dummy_v4_codec",
  412.     .type             = AVMEDIA_TYPE_VIDEO,
  413.     .id               = AV_CODEC_ID_NONE - 4,
  414.     .encode2          = dummy_encode,
  415.     .init             = dummy_init,
  416.     .close            = dummy_close,
  417. };
  418.  
  419. static void test_copy_print_codec(const AVCodecContext *ctx)
  420. {
  421.     printf("%-14s: %dx%d prv: %s",
  422.            ctx->codec ? ctx->codec->name : "NULL",
  423.            ctx->width, ctx->height,
  424.            ctx->priv_data ? "set" : "null");
  425.     if (ctx->codec && ctx->codec->priv_class && ctx->codec->priv_data_size) {
  426.         int64_t i64;
  427.         char *str = NULL;
  428.         av_opt_get_int(ctx->priv_data, "num", 0, &i64);
  429.         av_opt_get(ctx->priv_data, "str", 0, (uint8_t**)&str);
  430.         printf(" opts: %"PRId64" %s", i64, str);
  431.         av_free(str);
  432.     }
  433.     printf("\n");
  434. }
  435.  
  436. static void test_copy(const AVCodec *c1, const AVCodec *c2)
  437. {
  438.     AVCodecContext *ctx1, *ctx2;
  439.     printf("%s -> %s\nclosed:\n", c1 ? c1->name : "NULL", c2 ? c2->name : "NULL");
  440.     ctx1 = avcodec_alloc_context3(c1);
  441.     ctx2 = avcodec_alloc_context3(c2);
  442.     ctx1->width = ctx1->height = 128;
  443.     if (ctx2->codec && ctx2->codec->priv_class && ctx2->codec->priv_data_size) {
  444.         av_opt_set(ctx2->priv_data, "num", "667", 0);
  445.         av_opt_set(ctx2->priv_data, "str", "i'm dest value before copy", 0);
  446.     }
  447.     avcodec_copy_context(ctx2, ctx1);
  448.     test_copy_print_codec(ctx1);
  449.     test_copy_print_codec(ctx2);
  450.     if (ctx1->codec) {
  451.         printf("opened:\n");
  452.         avcodec_open2(ctx1, ctx1->codec, NULL);
  453.         if (ctx2->codec && ctx2->codec->priv_class && ctx2->codec->priv_data_size) {
  454.             av_opt_set(ctx2->priv_data, "num", "667", 0);
  455.             av_opt_set(ctx2->priv_data, "str", "i'm dest value before copy", 0);
  456.         }
  457.         avcodec_copy_context(ctx2, ctx1);
  458.         test_copy_print_codec(ctx1);
  459.         test_copy_print_codec(ctx2);
  460.         avcodec_close(ctx1);
  461.     }
  462.     avcodec_free_context(&ctx1);
  463.     avcodec_free_context(&ctx2);
  464. }
  465.  
  466. int main(void)
  467. {
  468.     AVCodec *dummy_codec[] = {
  469.         &dummy_v1_encoder,
  470.         &dummy_v2_encoder,
  471.         &dummy_v3_encoder,
  472.         &dummy_v4_encoder,
  473.         NULL,
  474.     };
  475.     int i, j;
  476.  
  477.     for (i = 0; dummy_codec[i]; i++)
  478.         avcodec_register(dummy_codec[i]);
  479.  
  480.     printf("testing avcodec_copy_context()\n");
  481.     for (i = 0; i < FF_ARRAY_ELEMS(dummy_codec); i++)
  482.         for (j = 0; j < FF_ARRAY_ELEMS(dummy_codec); j++)
  483.             test_copy(dummy_codec[i], dummy_codec[j]);
  484.     return 0;
  485. }
  486. #endif
  487.