/libavcodec/utils.c
http://github.com/FFmpeg/FFmpeg · C · 2232 lines · 1905 code · 263 blank · 64 comment · 541 complexity · 893341df1c0bea69e93f31cb293fae31 MD5 · raw file
Large files are truncated click here to view the full file
- /*
- * utils for libavcodec
- * Copyright (c) 2001 Fabrice Bellard
- * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * FFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
- /**
- * @file
- * utils.
- */
- #include "config.h"
- #include "libavutil/attributes.h"
- #include "libavutil/avassert.h"
- #include "libavutil/avstring.h"
- #include "libavutil/bprint.h"
- #include "libavutil/channel_layout.h"
- #include "libavutil/crc.h"
- #include "libavutil/frame.h"
- #include "libavutil/hwcontext.h"
- #include "libavutil/internal.h"
- #include "libavutil/mathematics.h"
- #include "libavutil/mem_internal.h"
- #include "libavutil/pixdesc.h"
- #include "libavutil/imgutils.h"
- #include "libavutil/samplefmt.h"
- #include "libavutil/dict.h"
- #include "libavutil/thread.h"
- #include "avcodec.h"
- #include "decode.h"
- #include "hwconfig.h"
- #include "libavutil/opt.h"
- #include "mpegvideo.h"
- #include "thread.h"
- #include "frame_thread_encoder.h"
- #include "internal.h"
- #include "raw.h"
- #include "bytestream.h"
- #include "version.h"
- #include <stdlib.h>
- #include <stdarg.h>
- #include <stdatomic.h>
- #include <limits.h>
- #include <float.h>
- #if CONFIG_ICONV
- # include <iconv.h>
- #endif
- #include "libavutil/ffversion.h"
- const char av_codec_ffversion[] = "FFmpeg version " FFMPEG_VERSION;
- static AVMutex codec_mutex = AV_MUTEX_INITIALIZER;
- void av_fast_padded_malloc(void *ptr, unsigned int *size, size_t min_size)
- {
- uint8_t **p = ptr;
- if (min_size > SIZE_MAX - AV_INPUT_BUFFER_PADDING_SIZE) {
- av_freep(p);
- *size = 0;
- return;
- }
- if (!ff_fast_malloc(p, size, min_size + AV_INPUT_BUFFER_PADDING_SIZE, 1))
- memset(*p + min_size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
- }
- void av_fast_padded_mallocz(void *ptr, unsigned int *size, size_t min_size)
- {
- uint8_t **p = ptr;
- if (min_size > SIZE_MAX - AV_INPUT_BUFFER_PADDING_SIZE) {
- av_freep(p);
- *size = 0;
- return;
- }
- if (!ff_fast_malloc(p, size, min_size + AV_INPUT_BUFFER_PADDING_SIZE, 1))
- memset(*p, 0, min_size + AV_INPUT_BUFFER_PADDING_SIZE);
- }
- int av_codec_is_encoder(const AVCodec *codec)
- {
- return codec && (codec->encode_sub || codec->encode2 ||codec->send_frame);
- }
- int av_codec_is_decoder(const AVCodec *codec)
- {
- return codec && (codec->decode || codec->receive_frame);
- }
- int ff_set_dimensions(AVCodecContext *s, int width, int height)
- {
- int ret = av_image_check_size2(width, height, s->max_pixels, AV_PIX_FMT_NONE, 0, s);
- if (ret < 0)
- width = height = 0;
- s->coded_width = width;
- s->coded_height = height;
- s->width = AV_CEIL_RSHIFT(width, s->lowres);
- s->height = AV_CEIL_RSHIFT(height, s->lowres);
- return ret;
- }
- int ff_set_sar(AVCodecContext *avctx, AVRational sar)
- {
- int ret = av_image_check_sar(avctx->width, avctx->height, sar);
- if (ret < 0) {
- av_log(avctx, AV_LOG_WARNING, "ignoring invalid SAR: %d/%d\n",
- sar.num, sar.den);
- avctx->sample_aspect_ratio = (AVRational){ 0, 1 };
- return ret;
- } else {
- avctx->sample_aspect_ratio = sar;
- }
- return 0;
- }
- int ff_side_data_update_matrix_encoding(AVFrame *frame,
- enum AVMatrixEncoding matrix_encoding)
- {
- AVFrameSideData *side_data;
- enum AVMatrixEncoding *data;
- side_data = av_frame_get_side_data(frame, AV_FRAME_DATA_MATRIXENCODING);
- if (!side_data)
- side_data = av_frame_new_side_data(frame, AV_FRAME_DATA_MATRIXENCODING,
- sizeof(enum AVMatrixEncoding));
- if (!side_data)
- return AVERROR(ENOMEM);
- data = (enum AVMatrixEncoding*)side_data->data;
- *data = matrix_encoding;
- return 0;
- }
- void avcodec_align_dimensions2(AVCodecContext *s, int *width, int *height,
- int linesize_align[AV_NUM_DATA_POINTERS])
- {
- int i;
- int w_align = 1;
- int h_align = 1;
- AVPixFmtDescriptor const *desc = av_pix_fmt_desc_get(s->pix_fmt);
- if (desc) {
- w_align = 1 << desc->log2_chroma_w;
- h_align = 1 << desc->log2_chroma_h;
- }
- switch (s->pix_fmt) {
- case AV_PIX_FMT_YUV420P:
- case AV_PIX_FMT_YUYV422:
- case AV_PIX_FMT_YVYU422:
- case AV_PIX_FMT_UYVY422:
- case AV_PIX_FMT_YUV422P:
- case AV_PIX_FMT_YUV440P:
- case AV_PIX_FMT_YUV444P:
- case AV_PIX_FMT_GBRP:
- case AV_PIX_FMT_GBRAP:
- case AV_PIX_FMT_GRAY8:
- case AV_PIX_FMT_GRAY16BE:
- case AV_PIX_FMT_GRAY16LE:
- case AV_PIX_FMT_YUVJ420P:
- case AV_PIX_FMT_YUVJ422P:
- case AV_PIX_FMT_YUVJ440P:
- case AV_PIX_FMT_YUVJ444P:
- case AV_PIX_FMT_YUVA420P:
- case AV_PIX_FMT_YUVA422P:
- case AV_PIX_FMT_YUVA444P:
- case AV_PIX_FMT_YUV420P9LE:
- case AV_PIX_FMT_YUV420P9BE:
- case AV_PIX_FMT_YUV420P10LE:
- case AV_PIX_FMT_YUV420P10BE:
- case AV_PIX_FMT_YUV420P12LE:
- case AV_PIX_FMT_YUV420P12BE:
- case AV_PIX_FMT_YUV420P14LE:
- case AV_PIX_FMT_YUV420P14BE:
- case AV_PIX_FMT_YUV420P16LE:
- case AV_PIX_FMT_YUV420P16BE:
- case AV_PIX_FMT_YUVA420P9LE:
- case AV_PIX_FMT_YUVA420P9BE:
- case AV_PIX_FMT_YUVA420P10LE:
- case AV_PIX_FMT_YUVA420P10BE:
- case AV_PIX_FMT_YUVA420P16LE:
- case AV_PIX_FMT_YUVA420P16BE:
- case AV_PIX_FMT_YUV422P9LE:
- case AV_PIX_FMT_YUV422P9BE:
- case AV_PIX_FMT_YUV422P10LE:
- case AV_PIX_FMT_YUV422P10BE:
- case AV_PIX_FMT_YUV422P12LE:
- case AV_PIX_FMT_YUV422P12BE:
- case AV_PIX_FMT_YUV422P14LE:
- case AV_PIX_FMT_YUV422P14BE:
- case AV_PIX_FMT_YUV422P16LE:
- case AV_PIX_FMT_YUV422P16BE:
- case AV_PIX_FMT_YUVA422P9LE:
- case AV_PIX_FMT_YUVA422P9BE:
- case AV_PIX_FMT_YUVA422P10LE:
- case AV_PIX_FMT_YUVA422P10BE:
- case AV_PIX_FMT_YUVA422P12LE:
- case AV_PIX_FMT_YUVA422P12BE:
- case AV_PIX_FMT_YUVA422P16LE:
- case AV_PIX_FMT_YUVA422P16BE:
- case AV_PIX_FMT_YUV440P10LE:
- case AV_PIX_FMT_YUV440P10BE:
- case AV_PIX_FMT_YUV440P12LE:
- case AV_PIX_FMT_YUV440P12BE:
- case AV_PIX_FMT_YUV444P9LE:
- case AV_PIX_FMT_YUV444P9BE:
- case AV_PIX_FMT_YUV444P10LE:
- case AV_PIX_FMT_YUV444P10BE:
- case AV_PIX_FMT_YUV444P12LE:
- case AV_PIX_FMT_YUV444P12BE:
- case AV_PIX_FMT_YUV444P14LE:
- case AV_PIX_FMT_YUV444P14BE:
- case AV_PIX_FMT_YUV444P16LE:
- case AV_PIX_FMT_YUV444P16BE:
- case AV_PIX_FMT_YUVA444P9LE:
- case AV_PIX_FMT_YUVA444P9BE:
- case AV_PIX_FMT_YUVA444P10LE:
- case AV_PIX_FMT_YUVA444P10BE:
- case AV_PIX_FMT_YUVA444P12LE:
- case AV_PIX_FMT_YUVA444P12BE:
- case AV_PIX_FMT_YUVA444P16LE:
- case AV_PIX_FMT_YUVA444P16BE:
- case AV_PIX_FMT_GBRP9LE:
- case AV_PIX_FMT_GBRP9BE:
- case AV_PIX_FMT_GBRP10LE:
- case AV_PIX_FMT_GBRP10BE:
- case AV_PIX_FMT_GBRP12LE:
- case AV_PIX_FMT_GBRP12BE:
- case AV_PIX_FMT_GBRP14LE:
- case AV_PIX_FMT_GBRP14BE:
- case AV_PIX_FMT_GBRP16LE:
- case AV_PIX_FMT_GBRP16BE:
- case AV_PIX_FMT_GBRAP12LE:
- case AV_PIX_FMT_GBRAP12BE:
- case AV_PIX_FMT_GBRAP16LE:
- case AV_PIX_FMT_GBRAP16BE:
- w_align = 16; //FIXME assume 16 pixel per macroblock
- h_align = 16 * 2; // interlaced needs 2 macroblocks height
- break;
- case AV_PIX_FMT_YUV411P:
- case AV_PIX_FMT_YUVJ411P:
- case AV_PIX_FMT_UYYVYY411:
- w_align = 32;
- h_align = 16 * 2;
- break;
- case AV_PIX_FMT_YUV410P:
- if (s->codec_id == AV_CODEC_ID_SVQ1) {
- w_align = 64;
- h_align = 64;
- }
- break;
- case AV_PIX_FMT_RGB555:
- if (s->codec_id == AV_CODEC_ID_RPZA) {
- w_align = 4;
- h_align = 4;
- }
- if (s->codec_id == AV_CODEC_ID_INTERPLAY_VIDEO) {
- w_align = 8;
- h_align = 8;
- }
- break;
- case AV_PIX_FMT_PAL8:
- case AV_PIX_FMT_BGR8:
- case AV_PIX_FMT_RGB8:
- if (s->codec_id == AV_CODEC_ID_SMC ||
- s->codec_id == AV_CODEC_ID_CINEPAK) {
- w_align = 4;
- h_align = 4;
- }
- if (s->codec_id == AV_CODEC_ID_JV ||
- s->codec_id == AV_CODEC_ID_INTERPLAY_VIDEO) {
- w_align = 8;
- h_align = 8;
- }
- break;
- case AV_PIX_FMT_BGR24:
- if ((s->codec_id == AV_CODEC_ID_MSZH) ||
- (s->codec_id == AV_CODEC_ID_ZLIB)) {
- w_align = 4;
- h_align = 4;
- }
- break;
- case AV_PIX_FMT_RGB24:
- if (s->codec_id == AV_CODEC_ID_CINEPAK) {
- w_align = 4;
- h_align = 4;
- }
- break;
- default:
- break;
- }
- if (s->codec_id == AV_CODEC_ID_IFF_ILBM) {
- w_align = FFMAX(w_align, 8);
- }
- *width = FFALIGN(*width, w_align);
- *height = FFALIGN(*height, h_align);
- if (s->codec_id == AV_CODEC_ID_H264 || s->lowres ||
- s->codec_id == AV_CODEC_ID_VP5 || s->codec_id == AV_CODEC_ID_VP6 ||
- s->codec_id == AV_CODEC_ID_VP6F || s->codec_id == AV_CODEC_ID_VP6A
- ) {
- // some of the optimized chroma MC reads one line too much
- // which is also done in mpeg decoders with lowres > 0
- *height += 2;
- // H.264 uses edge emulation for out of frame motion vectors, for this
- // it requires a temporary area large enough to hold a 21x21 block,
- // increasing witdth ensure that the temporary area is large enough,
- // the next rounded up width is 32
- *width = FFMAX(*width, 32);
- }
- for (i = 0; i < 4; i++)
- linesize_align[i] = STRIDE_ALIGN;
- }
- void avcodec_align_dimensions(AVCodecContext *s, int *width, int *height)
- {
- const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(s->pix_fmt);
- int chroma_shift = desc->log2_chroma_w;
- int linesize_align[AV_NUM_DATA_POINTERS];
- int align;
- avcodec_align_dimensions2(s, width, height, linesize_align);
- align = FFMAX(linesize_align[0], linesize_align[3]);
- linesize_align[1] <<= chroma_shift;
- linesize_align[2] <<= chroma_shift;
- align = FFMAX3(align, linesize_align[1], linesize_align[2]);
- *width = FFALIGN(*width, align);
- }
- int avcodec_enum_to_chroma_pos(int *xpos, int *ypos, enum AVChromaLocation pos)
- {
- if (pos <= AVCHROMA_LOC_UNSPECIFIED || pos >= AVCHROMA_LOC_NB)
- return AVERROR(EINVAL);
- pos--;
- *xpos = (pos&1) * 128;
- *ypos = ((pos>>1)^(pos<4)) * 128;
- return 0;
- }
- enum AVChromaLocation avcodec_chroma_pos_to_enum(int xpos, int ypos)
- {
- int pos, xout, yout;
- for (pos = AVCHROMA_LOC_UNSPECIFIED + 1; pos < AVCHROMA_LOC_NB; pos++) {
- if (avcodec_enum_to_chroma_pos(&xout, &yout, pos) == 0 && xout == xpos && yout == ypos)
- return pos;
- }
- return AVCHROMA_LOC_UNSPECIFIED;
- }
- int avcodec_fill_audio_frame(AVFrame *frame, int nb_channels,
- enum AVSampleFormat sample_fmt, const uint8_t *buf,
- int buf_size, int align)
- {
- int ch, planar, needed_size, ret = 0;
- needed_size = av_samples_get_buffer_size(NULL, nb_channels,
- frame->nb_samples, sample_fmt,
- align);
- if (buf_size < needed_size)
- return AVERROR(EINVAL);
- planar = av_sample_fmt_is_planar(sample_fmt);
- if (planar && nb_channels > AV_NUM_DATA_POINTERS) {
- if (!(frame->extended_data = av_mallocz_array(nb_channels,
- sizeof(*frame->extended_data))))
- return AVERROR(ENOMEM);
- } else {
- frame->extended_data = frame->data;
- }
- if ((ret = av_samples_fill_arrays(frame->extended_data, &frame->linesize[0],
- (uint8_t *)(intptr_t)buf, nb_channels, frame->nb_samples,
- sample_fmt, align)) < 0) {
- if (frame->extended_data != frame->data)
- av_freep(&frame->extended_data);
- return ret;
- }
- if (frame->extended_data != frame->data) {
- for (ch = 0; ch < AV_NUM_DATA_POINTERS; ch++)
- frame->data[ch] = frame->extended_data[ch];
- }
- return ret;
- }
- void ff_color_frame(AVFrame *frame, const int c[4])
- {
- const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format);
- int p, y;
- av_assert0(desc->flags & AV_PIX_FMT_FLAG_PLANAR);
- for (p = 0; p<desc->nb_components; p++) {
- uint8_t *dst = frame->data[p];
- int is_chroma = p == 1 || p == 2;
- int bytes = is_chroma ? AV_CEIL_RSHIFT(frame->width, desc->log2_chroma_w) : frame->width;
- int height = is_chroma ? AV_CEIL_RSHIFT(frame->height, desc->log2_chroma_h) : frame->height;
- if (desc->comp[0].depth >= 9) {
- ((uint16_t*)dst)[0] = c[p];
- av_memcpy_backptr(dst + 2, 2, bytes - 2);
- dst += frame->linesize[p];
- for (y = 1; y < height; y++) {
- memcpy(dst, frame->data[p], 2*bytes);
- dst += frame->linesize[p];
- }
- } else {
- for (y = 0; y < height; y++) {
- memset(dst, c[p], bytes);
- dst += frame->linesize[p];
- }
- }
- }
- }
- int avcodec_default_execute(AVCodecContext *c, int (*func)(AVCodecContext *c2, void *arg2), void *arg, int *ret, int count, int size)
- {
- int i;
- for (i = 0; i < count; i++) {
- int r = func(c, (char *)arg + i * size);
- if (ret)
- ret[i] = r;
- }
- emms_c();
- return 0;
- }
- int avcodec_default_execute2(AVCodecContext *c, int (*func)(AVCodecContext *c2, void *arg2, int jobnr, int threadnr), void *arg, int *ret, int count)
- {
- int i;
- for (i = 0; i < count; i++) {
- int r = func(c, arg, i, 0);
- if (ret)
- ret[i] = r;
- }
- emms_c();
- return 0;
- }
- enum AVPixelFormat avpriv_find_pix_fmt(const PixelFormatTag *tags,
- unsigned int fourcc)
- {
- while (tags->pix_fmt >= 0) {
- if (tags->fourcc == fourcc)
- return tags->pix_fmt;
- tags++;
- }
- return AV_PIX_FMT_NONE;
- }
- #if FF_API_CODEC_GET_SET
- MAKE_ACCESSORS(AVCodecContext, codec, AVRational, pkt_timebase)
- MAKE_ACCESSORS(AVCodecContext, codec, const AVCodecDescriptor *, codec_descriptor)
- MAKE_ACCESSORS(AVCodecContext, codec, int, lowres)
- MAKE_ACCESSORS(AVCodecContext, codec, int, seek_preroll)
- MAKE_ACCESSORS(AVCodecContext, codec, uint16_t*, chroma_intra_matrix)
- unsigned av_codec_get_codec_properties(const AVCodecContext *codec)
- {
- return codec->properties;
- }
- int av_codec_get_max_lowres(const AVCodec *codec)
- {
- return codec->max_lowres;
- }
- #endif
- int avpriv_codec_get_cap_skip_frame_fill_param(const AVCodec *codec){
- return !!(codec->caps_internal & FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM);
- }
- static int64_t get_bit_rate(AVCodecContext *ctx)
- {
- int64_t bit_rate;
- int bits_per_sample;
- switch (ctx->codec_type) {
- case AVMEDIA_TYPE_VIDEO:
- case AVMEDIA_TYPE_DATA:
- case AVMEDIA_TYPE_SUBTITLE:
- case AVMEDIA_TYPE_ATTACHMENT:
- bit_rate = ctx->bit_rate;
- break;
- case AVMEDIA_TYPE_AUDIO:
- bits_per_sample = av_get_bits_per_sample(ctx->codec_id);
- bit_rate = bits_per_sample ? ctx->sample_rate * (int64_t)ctx->channels * bits_per_sample : ctx->bit_rate;
- break;
- default:
- bit_rate = 0;
- break;
- }
- return bit_rate;
- }
- static void ff_lock_avcodec(AVCodecContext *log_ctx, const AVCodec *codec)
- {
- if (!(codec->caps_internal & FF_CODEC_CAP_INIT_THREADSAFE) && codec->init)
- ff_mutex_lock(&codec_mutex);
- }
- static void ff_unlock_avcodec(const AVCodec *codec)
- {
- if (!(codec->caps_internal & FF_CODEC_CAP_INIT_THREADSAFE) && codec->init)
- ff_mutex_unlock(&codec_mutex);
- }
- int attribute_align_arg ff_codec_open2_recursive(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
- {
- int ret = 0;
- ff_unlock_avcodec(codec);
- ret = avcodec_open2(avctx, codec, options);
- ff_lock_avcodec(avctx, codec);
- return ret;
- }
- int attribute_align_arg avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
- {
- int ret = 0;
- int codec_init_ok = 0;
- AVDictionary *tmp = NULL;
- const AVPixFmtDescriptor *pixdesc;
- AVCodecInternal *avci;
- if (avcodec_is_open(avctx))
- return 0;
- if (!codec && !avctx->codec) {
- av_log(avctx, AV_LOG_ERROR, "No codec provided to avcodec_open2()\n");
- return AVERROR(EINVAL);
- }
- if (codec && avctx->codec && codec != avctx->codec) {
- av_log(avctx, AV_LOG_ERROR, "This AVCodecContext was allocated for %s, "
- "but %s passed to avcodec_open2()\n", avctx->codec->name, codec->name);
- return AVERROR(EINVAL);
- }
- if (!codec)
- codec = avctx->codec;
- if (avctx->extradata_size < 0 || avctx->extradata_size >= FF_MAX_EXTRADATA_SIZE)
- return AVERROR(EINVAL);
- if (options)
- av_dict_copy(&tmp, *options, 0);
- ff_lock_avcodec(avctx, codec);
- avci = av_mallocz(sizeof(*avci));
- if (!avci) {
- ret = AVERROR(ENOMEM);
- goto end;
- }
- avctx->internal = avci;
- avci->to_free = av_frame_alloc();
- avci->compat_decode_frame = av_frame_alloc();
- avci->buffer_frame = av_frame_alloc();
- avci->buffer_pkt = av_packet_alloc();
- avci->ds.in_pkt = av_packet_alloc();
- avci->last_pkt_props = av_packet_alloc();
- if (!avci->to_free || !avci->compat_decode_frame ||
- !avci->buffer_frame || !avci->buffer_pkt ||
- !avci->ds.in_pkt || !avci->last_pkt_props) {
- ret = AVERROR(ENOMEM);
- goto free_and_end;
- }
- avci->skip_samples_multiplier = 1;
- if (codec->priv_data_size > 0) {
- if (!avctx->priv_data) {
- avctx->priv_data = av_mallocz(codec->priv_data_size);
- if (!avctx->priv_data) {
- ret = AVERROR(ENOMEM);
- goto end;
- }
- if (codec->priv_class) {
- *(const AVClass **)avctx->priv_data = codec->priv_class;
- av_opt_set_defaults(avctx->priv_data);
- }
- }
- if (codec->priv_class && (ret = av_opt_set_dict(avctx->priv_data, &tmp)) < 0)
- goto free_and_end;
- } else {
- avctx->priv_data = NULL;
- }
- if ((ret = av_opt_set_dict(avctx, &tmp)) < 0)
- goto free_and_end;
- if (avctx->codec_whitelist && av_match_list(codec->name, avctx->codec_whitelist, ',') <= 0) {
- av_log(avctx, AV_LOG_ERROR, "Codec (%s) not on whitelist \'%s\'\n", codec->name, avctx->codec_whitelist);
- ret = AVERROR(EINVAL);
- goto free_and_end;
- }
- // only call ff_set_dimensions() for non H.264/VP6F/DXV codecs so as not to overwrite previously setup dimensions
- if (!(avctx->coded_width && avctx->coded_height && avctx->width && avctx->height &&
- (avctx->codec_id == AV_CODEC_ID_H264 || avctx->codec_id == AV_CODEC_ID_VP6F || avctx->codec_id == AV_CODEC_ID_DXV))) {
- if (avctx->coded_width && avctx->coded_height)
- ret = ff_set_dimensions(avctx, avctx->coded_width, avctx->coded_height);
- else if (avctx->width && avctx->height)
- ret = ff_set_dimensions(avctx, avctx->width, avctx->height);
- if (ret < 0)
- goto free_and_end;
- }
- if ((avctx->coded_width || avctx->coded_height || avctx->width || avctx->height)
- && ( av_image_check_size2(avctx->coded_width, avctx->coded_height, avctx->max_pixels, AV_PIX_FMT_NONE, 0, avctx) < 0
- || av_image_check_size2(avctx->width, avctx->height, avctx->max_pixels, AV_PIX_FMT_NONE, 0, avctx) < 0)) {
- av_log(avctx, AV_LOG_WARNING, "Ignoring invalid width/height values\n");
- ff_set_dimensions(avctx, 0, 0);
- }
- if (avctx->width > 0 && avctx->height > 0) {
- if (av_image_check_sar(avctx->width, avctx->height,
- avctx->sample_aspect_ratio) < 0) {
- av_log(avctx, AV_LOG_WARNING, "ignoring invalid SAR: %u/%u\n",
- avctx->sample_aspect_ratio.num,
- avctx->sample_aspect_ratio.den);
- avctx->sample_aspect_ratio = (AVRational){ 0, 1 };
- }
- }
- /* if the decoder init function was already called previously,
- * free the already allocated subtitle_header before overwriting it */
- if (av_codec_is_decoder(codec))
- av_freep(&avctx->subtitle_header);
- if (avctx->channels > FF_SANE_NB_CHANNELS || avctx->channels < 0) {
- av_log(avctx, AV_LOG_ERROR, "Too many or invalid channels: %d\n", avctx->channels);
- ret = AVERROR(EINVAL);
- goto free_and_end;
- }
- if (avctx->sample_rate < 0) {
- av_log(avctx, AV_LOG_ERROR, "Invalid sample rate: %d\n", avctx->sample_rate);
- ret = AVERROR(EINVAL);
- goto free_and_end;
- }
- if (avctx->block_align < 0) {
- av_log(avctx, AV_LOG_ERROR, "Invalid block align: %d\n", avctx->block_align);
- ret = AVERROR(EINVAL);
- goto free_and_end;
- }
- avctx->codec = codec;
- if ((avctx->codec_type == AVMEDIA_TYPE_UNKNOWN || avctx->codec_type == codec->type) &&
- avctx->codec_id == AV_CODEC_ID_NONE) {
- avctx->codec_type = codec->type;
- avctx->codec_id = codec->id;
- }
- if (avctx->codec_id != codec->id || (avctx->codec_type != codec->type
- && avctx->codec_type != AVMEDIA_TYPE_ATTACHMENT)) {
- av_log(avctx, AV_LOG_ERROR, "Codec type or id mismatches\n");
- ret = AVERROR(EINVAL);
- goto free_and_end;
- }
- avctx->frame_number = 0;
- avctx->codec_descriptor = avcodec_descriptor_get(avctx->codec_id);
- if ((avctx->codec->capabilities & AV_CODEC_CAP_EXPERIMENTAL) &&
- avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
- const char *codec_string = av_codec_is_encoder(codec) ? "encoder" : "decoder";
- AVCodec *codec2;
- av_log(avctx, AV_LOG_ERROR,
- "The %s '%s' is experimental but experimental codecs are not enabled, "
- "add '-strict %d' if you want to use it.\n",
- codec_string, codec->name, FF_COMPLIANCE_EXPERIMENTAL);
- codec2 = av_codec_is_encoder(codec) ? avcodec_find_encoder(codec->id) : avcodec_find_decoder(codec->id);
- if (!(codec2->capabilities & AV_CODEC_CAP_EXPERIMENTAL))
- av_log(avctx, AV_LOG_ERROR, "Alternatively use the non experimental %s '%s'.\n",
- codec_string, codec2->name);
- ret = AVERROR_EXPERIMENTAL;
- goto free_and_end;
- }
- if (avctx->codec_type == AVMEDIA_TYPE_AUDIO &&
- (!avctx->time_base.num || !avctx->time_base.den)) {
- avctx->time_base.num = 1;
- avctx->time_base.den = avctx->sample_rate;
- }
- if (!HAVE_THREADS)
- av_log(avctx, AV_LOG_WARNING, "Warning: not compiled with thread support, using thread emulation\n");
- if (CONFIG_FRAME_THREAD_ENCODER && av_codec_is_encoder(avctx->codec)) {
- ff_unlock_avcodec(codec); //we will instantiate a few encoders thus kick the counter to prevent false detection of a problem
- ret = ff_frame_thread_encoder_init(avctx, options ? *options : NULL);
- ff_lock_avcodec(avctx, codec);
- if (ret < 0)
- goto free_and_end;
- }
- if (av_codec_is_decoder(avctx->codec)) {
- ret = ff_decode_bsfs_init(avctx);
- if (ret < 0)
- goto free_and_end;
- }
- if (HAVE_THREADS
- && !(avci->frame_thread_encoder && (avctx->active_thread_type&FF_THREAD_FRAME))) {
- ret = ff_thread_init(avctx);
- if (ret < 0) {
- goto free_and_end;
- }
- }
- if (!HAVE_THREADS && !(codec->capabilities & AV_CODEC_CAP_AUTO_THREADS))
- avctx->thread_count = 1;
- if (avctx->codec->max_lowres < avctx->lowres || avctx->lowres < 0) {
- av_log(avctx, AV_LOG_WARNING, "The maximum value for lowres supported by the decoder is %d\n",
- avctx->codec->max_lowres);
- avctx->lowres = avctx->codec->max_lowres;
- }
- if (av_codec_is_encoder(avctx->codec)) {
- int i;
- #if FF_API_CODED_FRAME
- FF_DISABLE_DEPRECATION_WARNINGS
- avctx->coded_frame = av_frame_alloc();
- if (!avctx->coded_frame) {
- ret = AVERROR(ENOMEM);
- goto free_and_end;
- }
- FF_ENABLE_DEPRECATION_WARNINGS
- #endif
- if (avctx->time_base.num <= 0 || avctx->time_base.den <= 0) {
- av_log(avctx, AV_LOG_ERROR, "The encoder timebase is not set.\n");
- ret = AVERROR(EINVAL);
- goto free_and_end;
- }
- if (avctx->codec->sample_fmts) {
- for (i = 0; avctx->codec->sample_fmts[i] != AV_SAMPLE_FMT_NONE; i++) {
- if (avctx->sample_fmt == avctx->codec->sample_fmts[i])
- break;
- if (avctx->channels == 1 &&
- av_get_planar_sample_fmt(avctx->sample_fmt) ==
- av_get_planar_sample_fmt(avctx->codec->sample_fmts[i])) {
- avctx->sample_fmt = avctx->codec->sample_fmts[i];
- break;
- }
- }
- if (avctx->codec->sample_fmts[i] == AV_SAMPLE_FMT_NONE) {
- char buf[128];
- snprintf(buf, sizeof(buf), "%d", avctx->sample_fmt);
- av_log(avctx, AV_LOG_ERROR, "Specified sample format %s is invalid or not supported\n",
- (char *)av_x_if_null(av_get_sample_fmt_name(avctx->sample_fmt), buf));
- ret = AVERROR(EINVAL);
- goto free_and_end;
- }
- }
- if (avctx->codec->pix_fmts) {
- for (i = 0; avctx->codec->pix_fmts[i] != AV_PIX_FMT_NONE; i++)
- if (avctx->pix_fmt == avctx->codec->pix_fmts[i])
- break;
- if (avctx->codec->pix_fmts[i] == AV_PIX_FMT_NONE
- && !((avctx->codec_id == AV_CODEC_ID_MJPEG || avctx->codec_id == AV_CODEC_ID_LJPEG)
- && avctx->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL)) {
- char buf[128];
- snprintf(buf, sizeof(buf), "%d", avctx->pix_fmt);
- av_log(avctx, AV_LOG_ERROR, "Specified pixel format %s is invalid or not supported\n",
- (char *)av_x_if_null(av_get_pix_fmt_name(avctx->pix_fmt), buf));
- ret = AVERROR(EINVAL);
- goto free_and_end;
- }
- if (avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ420P ||
- avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ411P ||
- avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ422P ||
- avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ440P ||
- avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ444P)
- avctx->color_range = AVCOL_RANGE_JPEG;
- }
- if (avctx->codec->supported_samplerates) {
- for (i = 0; avctx->codec->supported_samplerates[i] != 0; i++)
- if (avctx->sample_rate == avctx->codec->supported_samplerates[i])
- break;
- if (avctx->codec->supported_samplerates[i] == 0) {
- av_log(avctx, AV_LOG_ERROR, "Specified sample rate %d is not supported\n",
- avctx->sample_rate);
- ret = AVERROR(EINVAL);
- goto free_and_end;
- }
- }
- if (avctx->sample_rate < 0) {
- av_log(avctx, AV_LOG_ERROR, "Specified sample rate %d is not supported\n",
- avctx->sample_rate);
- ret = AVERROR(EINVAL);
- goto free_and_end;
- }
- if (avctx->codec->channel_layouts) {
- if (!avctx->channel_layout) {
- av_log(avctx, AV_LOG_WARNING, "Channel layout not specified\n");
- } else {
- for (i = 0; avctx->codec->channel_layouts[i] != 0; i++)
- if (avctx->channel_layout == avctx->codec->channel_layouts[i])
- break;
- if (avctx->codec->channel_layouts[i] == 0) {
- char buf[512];
- av_get_channel_layout_string(buf, sizeof(buf), -1, avctx->channel_layout);
- av_log(avctx, AV_LOG_ERROR, "Specified channel layout '%s' is not supported\n", buf);
- ret = AVERROR(EINVAL);
- goto free_and_end;
- }
- }
- }
- if (avctx->channel_layout && avctx->channels) {
- int channels = av_get_channel_layout_nb_channels(avctx->channel_layout);
- if (channels != avctx->channels) {
- char buf[512];
- av_get_channel_layout_string(buf, sizeof(buf), -1, avctx->channel_layout);
- av_log(avctx, AV_LOG_ERROR,
- "Channel layout '%s' with %d channels does not match number of specified channels %d\n",
- buf, channels, avctx->channels);
- ret = AVERROR(EINVAL);
- goto free_and_end;
- }
- } else if (avctx->channel_layout) {
- avctx->channels = av_get_channel_layout_nb_channels(avctx->channel_layout);
- }
- if (avctx->channels < 0) {
- av_log(avctx, AV_LOG_ERROR, "Specified number of channels %d is not supported\n",
- avctx->channels);
- ret = AVERROR(EINVAL);
- goto free_and_end;
- }
- if(avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
- pixdesc = av_pix_fmt_desc_get(avctx->pix_fmt);
- if ( avctx->bits_per_raw_sample < 0
- || (avctx->bits_per_raw_sample > 8 && pixdesc->comp[0].depth <= 8)) {
- av_log(avctx, AV_LOG_WARNING, "Specified bit depth %d not possible with the specified pixel formats depth %d\n",
- avctx->bits_per_raw_sample, pixdesc->comp[0].depth);
- avctx->bits_per_raw_sample = pixdesc->comp[0].depth;
- }
- if (avctx->width <= 0 || avctx->height <= 0) {
- av_log(avctx, AV_LOG_ERROR, "dimensions not set\n");
- ret = AVERROR(EINVAL);
- goto free_and_end;
- }
- }
- if ( (avctx->codec_type == AVMEDIA_TYPE_VIDEO || avctx->codec_type == AVMEDIA_TYPE_AUDIO)
- && avctx->bit_rate>0 && avctx->bit_rate<1000) {
- av_log(avctx, AV_LOG_WARNING, "Bitrate %"PRId64" is extremely low, maybe you mean %"PRId64"k\n", avctx->bit_rate, avctx->bit_rate);
- }
- if (!avctx->rc_initial_buffer_occupancy)
- avctx->rc_initial_buffer_occupancy = avctx->rc_buffer_size * 3LL / 4;
- if (avctx->ticks_per_frame && avctx->time_base.num &&
- avctx->ticks_per_frame > INT_MAX / avctx->time_base.num) {
- av_log(avctx, AV_LOG_ERROR,
- "ticks_per_frame %d too large for the timebase %d/%d.",
- avctx->ticks_per_frame,
- avctx->time_base.num,
- avctx->time_base.den);
- goto free_and_end;
- }
- if (avctx->hw_frames_ctx) {
- AVHWFramesContext *frames_ctx = (AVHWFramesContext*)avctx->hw_frames_ctx->data;
- if (frames_ctx->format != avctx->pix_fmt) {
- av_log(avctx, AV_LOG_ERROR,
- "Mismatching AVCodecContext.pix_fmt and AVHWFramesContext.format\n");
- ret = AVERROR(EINVAL);
- goto free_and_end;
- }
- if (avctx->sw_pix_fmt != AV_PIX_FMT_NONE &&
- avctx->sw_pix_fmt != frames_ctx->sw_format) {
- av_log(avctx, AV_LOG_ERROR,
- "Mismatching AVCodecContext.sw_pix_fmt (%s) "
- "and AVHWFramesContext.sw_format (%s)\n",
- av_get_pix_fmt_name(avctx->sw_pix_fmt),
- av_get_pix_fmt_name(frames_ctx->sw_format));
- ret = AVERROR(EINVAL);
- goto free_and_end;
- }
- avctx->sw_pix_fmt = frames_ctx->sw_format;
- }
- }
- avctx->pts_correction_num_faulty_pts =
- avctx->pts_correction_num_faulty_dts = 0;
- avctx->pts_correction_last_pts =
- avctx->pts_correction_last_dts = INT64_MIN;
- if ( !CONFIG_GRAY && avctx->flags & AV_CODEC_FLAG_GRAY
- && avctx->codec_descriptor->type == AVMEDIA_TYPE_VIDEO)
- av_log(avctx, AV_LOG_WARNING,
- "gray decoding requested but not enabled at configuration time\n");
- if (avctx->flags2 & AV_CODEC_FLAG2_EXPORT_MVS) {
- avctx->export_side_data |= AV_CODEC_EXPORT_DATA_MVS;
- }
- if ( avctx->codec->init && (!(avctx->active_thread_type&FF_THREAD_FRAME)
- || avci->frame_thread_encoder)) {
- ret = avctx->codec->init(avctx);
- if (ret < 0) {
- goto free_and_end;
- }
- codec_init_ok = 1;
- }
- ret=0;
- if (av_codec_is_decoder(avctx->codec)) {
- if (!avctx->bit_rate)
- avctx->bit_rate = get_bit_rate(avctx);
- /* validate channel layout from the decoder */
- if (avctx->channel_layout) {
- int channels = av_get_channel_layout_nb_channels(avctx->channel_layout);
- if (!avctx->channels)
- avctx->channels = channels;
- else if (channels != avctx->channels) {
- char buf[512];
- av_get_channel_layout_string(buf, sizeof(buf), -1, avctx->channel_layout);
- av_log(avctx, AV_LOG_WARNING,
- "Channel layout '%s' with %d channels does not match specified number of channels %d: "
- "ignoring specified channel layout\n",
- buf, channels, avctx->channels);
- avctx->channel_layout = 0;
- }
- }
- if (avctx->channels && avctx->channels < 0 ||
- avctx->channels > FF_SANE_NB_CHANNELS) {
- ret = AVERROR(EINVAL);
- goto free_and_end;
- }
- if (avctx->bits_per_coded_sample < 0) {
- ret = AVERROR(EINVAL);
- goto free_and_end;
- }
- if (avctx->sub_charenc) {
- if (avctx->codec_type != AVMEDIA_TYPE_SUBTITLE) {
- av_log(avctx, AV_LOG_ERROR, "Character encoding is only "
- "supported with subtitles codecs\n");
- ret = AVERROR(EINVAL);
- goto free_and_end;
- } else if (avctx->codec_descriptor->props & AV_CODEC_PROP_BITMAP_SUB) {
- av_log(avctx, AV_LOG_WARNING, "Codec '%s' is bitmap-based, "
- "subtitles character encoding will be ignored\n",
- avctx->codec_descriptor->name);
- avctx->sub_charenc_mode = FF_SUB_CHARENC_MODE_DO_NOTHING;
- } else {
- /* input character encoding is set for a text based subtitle
- * codec at this point */
- if (avctx->sub_charenc_mode == FF_SUB_CHARENC_MODE_AUTOMATIC)
- avctx->sub_charenc_mode = FF_SUB_CHARENC_MODE_PRE_DECODER;
- if (avctx->sub_charenc_mode == FF_SUB_CHARENC_MODE_PRE_DECODER) {
- #if CONFIG_ICONV
- iconv_t cd = iconv_open("UTF-8", avctx->sub_charenc);
- if (cd == (iconv_t)-1) {
- ret = AVERROR(errno);
- av_log(avctx, AV_LOG_ERROR, "Unable to open iconv context "
- "with input character encoding \"%s\"\n", avctx->sub_charenc);
- goto free_and_end;
- }
- iconv_close(cd);
- #else
- av_log(avctx, AV_LOG_ERROR, "Character encoding subtitles "
- "conversion needs a libavcodec built with iconv support "
- "for this codec\n");
- ret = AVERROR(ENOSYS);
- goto free_and_end;
- #endif
- }
- }
- }
- #if FF_API_AVCTX_TIMEBASE
- if (avctx->framerate.num > 0 && avctx->framerate.den > 0)
- avctx->time_base = av_inv_q(av_mul_q(avctx->framerate, (AVRational){avctx->ticks_per_frame, 1}));
- #endif
- }
- if (codec->priv_data_size > 0 && avctx->priv_data && codec->priv_class) {
- av_assert0(*(const AVClass **)avctx->priv_data == codec->priv_class);
- }
- end:
- ff_unlock_avcodec(codec);
- if (options) {
- av_dict_free(options);
- *options = tmp;
- }
- return ret;
- free_and_end:
- if (avctx->codec && avctx->codec->close &&
- (codec_init_ok ||
- (avctx->codec->caps_internal & FF_CODEC_CAP_INIT_CLEANUP)))
- avctx->codec->close(avctx);
- if (HAVE_THREADS && avci->thread_ctx)
- ff_thread_free(avctx);
- if (codec->priv_class && codec->priv_data_size)
- av_opt_free(avctx->priv_data);
- av_opt_free(avctx);
- #if FF_API_CODED_FRAME
- FF_DISABLE_DEPRECATION_WARNINGS
- av_frame_free(&avctx->coded_frame);
- FF_ENABLE_DEPRECATION_WARNINGS
- #endif
- av_dict_free(&tmp);
- av_freep(&avctx->priv_data);
- av_freep(&avctx->subtitle_header);
- if (avci) {
- av_frame_free(&avci->to_free);
- av_frame_free(&avci->compat_decode_frame);
- av_frame_free(&avci->buffer_frame);
- av_packet_free(&avci->buffer_pkt);
- av_packet_free(&avci->last_pkt_props);
- av_packet_free(&avci->ds.in_pkt);
- ff_decode_bsfs_uninit(avctx);
- av_buffer_unref(&avci->pool);
- }
- av_freep(&avci);
- avctx->internal = NULL;
- avctx->codec = NULL;
- goto end;
- }
- void avsubtitle_free(AVSubtitle *sub)
- {
- int i;
- for (i = 0; i < sub->num_rects; i++) {
- av_freep(&sub->rects[i]->data[0]);
- av_freep(&sub->rects[i]->data[1]);
- av_freep(&sub->rects[i]->data[2]);
- av_freep(&sub->rects[i]->data[3]);
- av_freep(&sub->rects[i]->text);
- av_freep(&sub->rects[i]->ass);
- av_freep(&sub->rects[i]);
- }
- av_freep(&sub->rects);
- memset(sub, 0, sizeof(*sub));
- }
- av_cold int avcodec_close(AVCodecContext *avctx)
- {
- int i;
- if (!avctx)
- return 0;
- if (avcodec_is_open(avctx)) {
- if (CONFIG_FRAME_THREAD_ENCODER &&
- avctx->internal->frame_thread_encoder && avctx->thread_count > 1) {
- ff_frame_thread_encoder_free(avctx);
- }
- if (HAVE_THREADS && avctx->internal->thread_ctx)
- ff_thread_free(avctx);
- if (avctx->codec && avctx->codec->close)
- avctx->codec->close(avctx);
- avctx->internal->byte_buffer_size = 0;
- av_freep(&avctx->internal->byte_buffer);
- av_frame_free(&avctx->internal->to_free);
- av_frame_free(&avctx->internal->compat_decode_frame);
- av_frame_free(&avctx->internal->buffer_frame);
- av_packet_free(&avctx->internal->buffer_pkt);
- av_packet_free(&avctx->internal->last_pkt_props);
- av_packet_free(&avctx->internal->ds.in_pkt);
- av_buffer_unref(&avctx->internal->pool);
- if (avctx->hwaccel && avctx->hwaccel->uninit)
- avctx->hwaccel->uninit(avctx);
- av_freep(&avctx->internal->hwaccel_priv_data);
- ff_decode_bsfs_uninit(avctx);
- av_freep(&avctx->internal);
- }
- for (i = 0; i < avctx->nb_coded_side_data; i++)
- av_freep(&avctx->coded_side_data[i].data);
- av_freep(&avctx->coded_side_data);
- avctx->nb_coded_side_data = 0;
- av_buffer_unref(&avctx->hw_frames_ctx);
- av_buffer_unref(&avctx->hw_device_ctx);
- if (avctx->priv_data && avctx->codec && avctx->codec->priv_class)
- av_opt_free(avctx->priv_data);
- av_opt_free(avctx);
- av_freep(&avctx->priv_data);
- if (av_codec_is_encoder(avctx->codec)) {
- av_freep(&avctx->extradata);
- #if FF_API_CODED_FRAME
- FF_DISABLE_DEPRECATION_WARNINGS
- av_frame_free(&avctx->coded_frame);
- FF_ENABLE_DEPRECATION_WARNINGS
- #endif
- }
- avctx->codec = NULL;
- avctx->active_thread_type = 0;
- return 0;
- }
- const char *avcodec_get_name(enum AVCodecID id)
- {
- const AVCodecDescriptor *cd;
- AVCodec *codec;
- if (id == AV_CODEC_ID_NONE)
- return "none";
- cd = avcodec_descriptor_get(id);
- if (cd)
- return cd->name;
- av_log(NULL, AV_LOG_WARNING, "Codec 0x%x is not in the full list.\n", id);
- codec = avcodec_find_decoder(id);
- if (codec)
- return codec->name;
- codec = avcodec_find_encoder(id);
- if (codec)
- return codec->name;
- return "unknown_codec";
- }
- size_t av_get_codec_tag_string(char *buf, size_t buf_size, unsigned int codec_tag)
- {
- int i, len, ret = 0;
- #define TAG_PRINT(x) \
- (((x) >= '0' && (x) <= '9') || \
- ((x) >= 'a' && (x) <= 'z') || ((x) >= 'A' && (x) <= 'Z') || \
- ((x) == '.' || (x) == ' ' || (x) == '-' || (x) == '_'))
- for (i = 0; i < 4; i++) {
- len = snprintf(buf, buf_size,
- TAG_PRINT(codec_tag & 0xFF) ? "%c" : "[%d]", codec_tag & 0xFF);
- buf += len;
- buf_size = buf_size > len ? buf_size - len : 0;
- ret += len;
- codec_tag >>= 8;
- }
- return ret;
- }
- void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode)
- {
- const char *codec_type;
- const char *codec_name;
- const char *profile = NULL;
- int64_t bitrate;
- int new_line = 0;
- AVRational display_aspect_ratio;
- const char *separator = enc->dump_separator ? (const char *)enc->dump_separator : ", ";
- if (!buf || buf_size <= 0)
- return;
- codec_type = av_get_media_type_string(enc->codec_type);
- codec_name = avcodec_get_name(enc->codec_id);
- profile = avcodec_profile_name(enc->codec_id, enc->profile);
- snprintf(buf, buf_size, "%s: %s", codec_type ? codec_type : "unknown",
- codec_name);
- buf[0] ^= 'a' ^ 'A'; /* first letter in uppercase */
- if (enc->codec && strcmp(enc->codec->name, codec_name))
- snprintf(buf + strlen(buf), buf_size - strlen(buf), " (%s)", enc->codec->name);
- if (profile)
- snprintf(buf + strlen(buf), buf_size - strlen(buf), " (%s)", profile);
- if ( enc->codec_type == AVMEDIA_TYPE_VIDEO
- && av_log_get_level() >= AV_LOG_VERBOSE
- && enc->refs)
- snprintf(buf + strlen(buf), buf_size - strlen(buf),
- ", %d reference frame%s",
- enc->refs, enc->refs > 1 ? "s" : "");
- if (enc->codec_tag)
- snprintf(buf + strlen(buf), buf_size - strlen(buf), " (%s / 0x%04X)",
- av_fourcc2str(enc->codec_tag), enc->codec_tag);
- switch (enc->codec_type) {
- case AVMEDIA_TYPE_VIDEO:
- {
- char detail[256] = "(";
- av_strlcat(buf, separator, buf_size);
- snprintf(buf + strlen(buf), buf_size - strlen(buf),
- "%s", enc->pix_fmt == AV_PIX_FMT_NONE ? "none" :
- av_get_pix_fmt_name(enc->pix_fmt));
- if (enc->bits_per_raw_sample && enc->pix_fmt != AV_PIX_FMT_NONE &&
- enc->bits_per_raw_sample < av_pix_fmt_desc_get(enc->pix_fmt)->comp[0].depth)
- av_strlcatf(detail, sizeof(detail), "%d bpc, ", enc->bits_per_raw_sample);
- if (enc->color_range != AVCOL_RANGE_UNSPECIFIED)
- av_strlcatf(detail, sizeof(detail), "%s, ",
- av_color_range_name(enc->color_range));
- if (enc->colorspace != AVCOL_SPC_UNSPECIFIED ||
- enc->color_primaries != AVCOL_PRI_UNSPECIFIED ||
- enc->color_trc != AVCOL_TRC_UNSPECIFIED) {
- if (enc->colorspace != (int)enc->color_primaries ||
- enc->colorspace != (int)enc->color_trc) {
- new_line = 1;
- av_strlcatf(detail, sizeof(detail), "%s/%s/%s, ",
- av_color_space_name(enc->colorspace),
- av_color_primaries_name(enc->color_primaries),
- av_color_transfer_name(enc->color_trc));
- } else
- av_strlcatf(detail, sizeof(detail), "%s, ",
- av_get_colorspace_name(enc->colorspace));
- }
- if (enc->field_order != AV_FIELD_UNKNOWN) {
- const char *field_order = "progressive";
- if (enc->field_order == AV_FIELD_TT)
- field_order = "top first";
- else if (enc->field_order == AV_FIELD_BB)
- field_order = "bottom first";
- else if (enc->field_order == AV_FIELD_TB)
- field_order = "top coded first (swapped)";
- else if (enc->field_order == AV_FIELD_BT)
- field_order = "bottom coded first (swapped)";
- av_strlcatf(detail, sizeof(detail), "%s, ", field_order);
- }
- if (av_log_get_level() >= AV_LOG_VERBOSE &&
- enc->chroma_sample_location != AVCHROMA_LOC_UNSPECIFIED)
- av_strlcatf(detail, sizeof(detail), "%s, ",
- av_chroma_location_name(enc->chroma_sample_location));
- if (strlen(detail) > 1) {
- detail[strlen(detail) - 2] = 0;
- av_strlcatf(buf, buf_size, "%s)", detail);
- }
- }
- if (enc->width) {
- av_strlcat(buf, new_line ? separator : ", ", buf_size);
- snprintf(buf + strlen(buf), buf_size - strlen(buf),
- "%dx%d",
- enc->width, enc->height);
- if (av_log_get_level() >= AV_LOG_VERBOSE &&
- (enc->width != enc->coded_width ||
- enc->height != enc->coded_height))
- snprintf(buf + strlen(buf), buf_size - strlen(buf),
- " (%dx%d)", enc->coded_width, enc->coded_height);
- if (enc->sample_aspect_ratio.num) {
- av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
- enc->width * (int64_t)enc->sample_aspect_ratio.num,
- enc->height * (int64_t)enc->sample_aspect_ratio.den,
- 1024 * 1024);
- snprintf(buf + strlen(buf), buf_size - strlen(buf),
- " [SAR %d:%d DAR %d:%d]",
- enc->sample_aspect_ratio.num, enc->sample_aspect_ratio.den,
- display_aspect_ratio.num, display_aspect_ratio.den);
- }
- if (av_log_get_level() >= AV_LOG_DEBUG) {
- int g = av_gcd(enc->time_base.num, enc->time_base.den);
- snprintf(buf + strlen(buf), buf_size - strlen(buf),
- ", %d/%d",
- enc->time_base.num / g, enc->time_base.den / g);
- }
- }
- if (encode) {
- snprintf(buf + strlen(buf), buf_size - strlen(buf),
- ", q=%d-%d", enc->qmin, enc->qmax);
- } else {
- if (enc->properties & FF_CODEC_PROPERTY_CLOSED_CAPTIONS)
- snprintf(buf + strlen(buf), buf_size - strlen(buf),
- ", Closed Captions");
- if (enc->properties & FF_CODEC_PROPERTY_LOSSLESS)
- snprintf(buf + strlen(buf), buf_size - strlen(buf),
- ", lossless");
- }
- break;
- case AVMEDIA_TYPE_AUDIO:
- av_strlcat(buf, separator, buf_size);
- if (enc->sample_rate) {
- snprintf(buf + strlen(buf), buf_size - strlen(buf),
- "%d Hz, ", enc->sample_rate);
- }
- av_get_channel_layout_string(buf + strlen(buf), buf_size - strlen(buf), enc->channels, enc->channel_layout);
- if (enc->sample_fmt != AV_SAMPLE_FMT_NONE) {
- snprintf(buf + strlen(buf), buf_size - strlen(buf),
- ", %s", av_get_sample_fmt_name(enc->sample_fmt));
- }
- if ( enc->bits_per_raw_sample > 0
- && enc->bits_per_raw_sample != av_get_bytes_per_sample(enc->sample_fmt) * 8)
- snprintf(buf + strlen(buf), buf_size - strlen(buf),
- " (%d bit)", enc->bits_per_raw_sample);
- if (av_log_get_level() >= AV_LOG_VERBOSE) {
- if (enc->initial_padding)
- snprintf(buf + strlen(buf), buf_size - strlen(buf),
- ", delay %d", enc->initial_padding);
- if (enc->trailing_padding)
- snprintf(buf + strlen(buf), buf_size - strlen(buf),
- ", padding %d", enc->trailing_padding);
- }
- break;
- case AVMEDIA_TYPE_DATA:
- if (av_log_get_level() >= AV_LOG_DEBUG) {
- int g = av_gcd(enc->time_base.num, enc->time_base.den);
- if (g)
- snprintf(buf + strlen(buf), buf_size - strlen(buf),
- ", %d/%d",
- enc->time_base.num / g, enc->time_base.den / g);
- }
- break;
- case AVMEDIA_TYPE_SUBTITLE:
- if (enc->width)
- snprintf(buf + strlen(buf), buf_size - strlen(buf),
- ", %dx%d", enc->width, enc->height);
- break;
- default:
- return;
- }
- if (encode) {
- if (enc->flags & AV_CODEC_FLAG_PASS1)
- snprintf(buf + strlen(buf), buf_size - strlen(buf),
- ", pass 1");
- if (enc->flags & AV_CODEC_FLAG_PASS2)
- snprintf(buf + strlen(buf), buf_size - strlen(buf),
- ", pass 2");
- }
- bitrate = get_bit_rate(enc);
- if (bitrate != 0) {
- snprintf(buf + st…