*/
#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/intreadwrite.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 "libavutil/pixfmt.h"
#include "avcodec.h"
-#include "decode.h"
+#include "codec.h"
#include "hwconfig.h"
-#include "libavutil/opt.h"
-#include "mpegvideo.h"
#include "thread.h"
-#include "frame_thread_encoder.h"
#include "internal.h"
-#include "packet_internal.h"
#include "put_bits.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)
{
}
}
-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)
{
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->compat_encode_packet = av_packet_alloc();
- avci->buffer_frame = av_frame_alloc();
- avci->buffer_pkt = av_packet_alloc();
- avci->es.in_frame = av_frame_alloc();
- avci->ds.in_pkt = av_packet_alloc();
- avci->last_pkt_props = av_packet_alloc();
- if (!avci->compat_decode_frame || !avci->compat_encode_packet ||
- !avci->buffer_frame || !avci->buffer_pkt ||
- !avci->es.in_frame || !avci->ds.in_pkt ||
- !avci->to_free || !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 free_and_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;
- }
-
-#if FF_API_THREAD_SAFE_CALLBACKS
-FF_DISABLE_DEPRECATION_WARNINGS
- if ((avctx->thread_type & FF_THREAD_FRAME) &&
- avctx->get_buffer2 != avcodec_default_get_buffer2 &&
- !avctx->thread_safe_callbacks) {
- av_log(avctx, AV_LOG_WARNING, "Requested frame threading with a "
- "custom get_buffer2() implementation which is not marked as "
- "thread safe. This is not supported anymore, make your "
- "callback thread-safe.\n");
- }
-FF_ENABLE_DEPRECATION_WARNINGS
-#endif
-
- 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";
- const 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) {
- codec_init_ok = -1;
- 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 > 0 || (codec_init_ok < 0 &&
- 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 && avctx->priv_data)
- av_opt_free(avctx->priv_data);
- av_opt_free(avctx);
-
- if (av_codec_is_encoder(avctx->codec)) {
-#if FF_API_CODED_FRAME
-FF_DISABLE_DEPRECATION_WARNINGS
- av_frame_free(&avctx->coded_frame);
-FF_ENABLE_DEPRECATION_WARNINGS
-#endif
- av_freep(&avctx->extradata);
- avctx->extradata_size = 0;
- }
-
- av_dict_free(&tmp);
- av_freep(&avctx->priv_data);
- av_freep(&avctx->subtitle_header);
-
- av_frame_free(&avci->to_free);
- av_frame_free(&avci->compat_decode_frame);
- av_frame_free(&avci->buffer_frame);
- av_packet_free(&avci->compat_encode_packet);
- av_packet_free(&avci->buffer_pkt);
- av_packet_free(&avci->last_pkt_props);
-
- av_packet_free(&avci->ds.in_pkt);
- av_frame_free(&avci->es.in_frame);
- av_bsf_free(&avci->bsf);
-
- av_buffer_unref(&avci->pool);
- av_freep(&avci);
- avctx->internal = NULL;
- avctx->codec = NULL;
- goto end;
-}
-
-void avcodec_flush_buffers(AVCodecContext *avctx)
-{
- AVCodecInternal *avci = avctx->internal;
-
- if (av_codec_is_encoder(avctx->codec)) {
- int caps = avctx->codec->capabilities;
-
- if (!(caps & AV_CODEC_CAP_ENCODER_FLUSH)) {
- // Only encoders that explicitly declare support for it can be
- // flushed. Otherwise, this is a no-op.
- av_log(avctx, AV_LOG_WARNING, "Ignoring attempt to flush encoder "
- "that doesn't support it\n");
- return;
- }
-
- // We haven't implemented flushing for frame-threaded encoders.
- av_assert0(!(caps & AV_CODEC_CAP_FRAME_THREADS));
- }
-
- avci->draining = 0;
- avci->draining_done = 0;
- avci->nb_draining_errors = 0;
- av_frame_unref(avci->buffer_frame);
- av_frame_unref(avci->compat_decode_frame);
- av_packet_unref(avci->compat_encode_packet);
- av_packet_unref(avci->buffer_pkt);
-
- av_packet_unref(avci->last_pkt_props);
- avpriv_packet_list_free(&avci->pkt_props,
- &avci->pkt_props_tail);
-
- av_frame_unref(avci->es.in_frame);
- av_packet_unref(avci->ds.in_pkt);
-
- if (HAVE_THREADS && avctx->active_thread_type & FF_THREAD_FRAME)
- ff_thread_flush(avctx);
- else if (avctx->codec->flush)
- avctx->codec->flush(avctx);
-
- avctx->pts_correction_last_pts =
- avctx->pts_correction_last_dts = INT64_MIN;
-
- if (av_codec_is_decoder(avctx->codec))
- av_bsf_flush(avci->bsf);
-
- if (!avctx->refcounted_frames)
- av_frame_unref(avci->to_free);
-}
-
-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->compat_encode_packet);
- av_packet_free(&avctx->internal->buffer_pkt);
- av_packet_free(&avctx->internal->last_pkt_props);
- avpriv_packet_list_free(&avctx->internal->pkt_props,
- &avctx->internal->pkt_props_tail);
-
- av_packet_free(&avctx->internal->ds.in_pkt);
- av_frame_free(&avctx->internal->es.in_frame);
-
- av_buffer_unref(&avctx->internal->pool);
-
- if (avctx->hwaccel && avctx->hwaccel->uninit)
- avctx->hwaccel->uninit(avctx);
- av_freep(&avctx->internal->hwaccel_priv_data);
-
- av_bsf_free(&avctx->internal->bsf);
-
- 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;
return "unknown_codec";
}
-#if FF_API_TAG_STRING
-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;
-}
-#endif
-
-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 + strlen(buf), buf_size - strlen(buf),
- ", %"PRId64" kb/s", bitrate / 1000);
- } else if (enc->rc_max_rate > 0) {
- snprintf(buf + strlen(buf), buf_size - strlen(buf),
- ", max. %"PRId64" kb/s", enc->rc_max_rate / 1000);
- }
-}
-
const char *av_get_profile_name(const AVCodec *codec, int profile)
{
const AVProfile *p;
return NULL;
}
-unsigned avcodec_version(void)
-{
- av_assert0(AV_CODEC_ID_PCM_S8_PLANAR==65563);
- av_assert0(AV_CODEC_ID_ADPCM_G722==69660);
- av_assert0(AV_CODEC_ID_SRT==94216);
- av_assert0(LIBAVCODEC_VERSION_MICRO >= 100);
-
- return LIBAVCODEC_VERSION_INT;
-}
-
-const char *avcodec_configuration(void)
-{
- return FFMPEG_CONFIGURATION;
-}
-
-const char *avcodec_license(void)
-{
-#define LICENSE_PREFIX "libavcodec license: "
- return &LICENSE_PREFIX FFMPEG_LICENSE[sizeof(LICENSE_PREFIX) - 1];
-}
-
int av_get_exact_bits_per_sample(enum AVCodecID codec_id)
{
switch (codec_id) {
case AV_CODEC_ID_PCM_VIDC:
case AV_CODEC_ID_PCM_S8:
case AV_CODEC_ID_PCM_S8_PLANAR:
+ case AV_CODEC_ID_PCM_SGA:
case AV_CODEC_ID_PCM_U8:
case AV_CODEC_ID_SDX2_DPCM:
case AV_CODEC_ID_DERF_DPCM:
return 256 * sr / 245;
else if (id == AV_CODEC_ID_DST)
return 588 * sr / 44100;
-
- if (ch > 0) {
- /* calc from sample rate and channels */
- if (id == AV_CODEC_ID_BINKAUDIO_DCT) {
- if (sr / 22050 > 22)
- return 0;
- return (480 << (sr / 22050)) / ch;
- }
+ else if (id == AV_CODEC_ID_BINKAUDIO_DCT) {
+ if (sr / 22050 > 22)
+ return 0;
+ return (480 << (sr / 22050));
}
if (id == AV_CODEC_ID_MP3)
return frame_bytes / (9 * ch) * 16;
case AV_CODEC_ID_ADPCM_PSX:
case AV_CODEC_ID_ADPCM_DTK:
- return frame_bytes / (16 * ch) * 28;
+ frame_bytes /= 16 * ch;
+ if (frame_bytes > INT_MAX / 28)
+ return 0;
+ return frame_bytes * 28;
case AV_CODEC_ID_ADPCM_4XM:
case AV_CODEC_ID_ADPCM_IMA_DAT4:
case AV_CODEC_ID_ADPCM_IMA_ISS:
if (ba > 0) {
/* calc from frame_bytes, channels, and block_align */
int blocks = frame_bytes / ba;
+ int64_t tmp;
switch (id) {
case AV_CODEC_ID_ADPCM_IMA_WAV:
if (bps < 2 || bps > 5)
return 0;
- return blocks * (1 + (ba - 4 * ch) / (bps * ch) * 8);
+ tmp = blocks * (1LL + (ba - 4 * ch) / (bps * ch) * 8);
+ if (tmp != (int)tmp)
+ return 0;
+ return tmp;
case AV_CODEC_ID_ADPCM_IMA_DK3:
return blocks * (((ba - 16) * 2 / 3 * 4) / ch);
case AV_CODEC_ID_ADPCM_IMA_DK4:
case AV_CODEC_ID_ADPCM_IMA_RAD:
return blocks * ((ba - 4 * ch) * 2 / ch);
case AV_CODEC_ID_ADPCM_MS:
- return blocks * (2 + (ba - 7 * ch) * 2 / ch);
+ return blocks * (2 + (ba - 7 * ch) * 2LL / ch);
case AV_CODEC_ID_ADPCM_MTAF:
return blocks * (ba - 16) * 2 / ch;
}
return &codec->hw_configs[index]->public;
}
-#if FF_API_USER_VISIBLE_AVHWACCEL
-AVHWAccel *av_hwaccel_next(const AVHWAccel *hwaccel)
-{
- return NULL;
-}
-
-void av_register_hwaccel(AVHWAccel *hwaccel)
-{
-}
-#endif
-
-#if FF_API_LOCKMGR
-int av_lockmgr_register(int (*cb)(void **mutex, enum AVLockOp op))
-{
- return 0;
-}
-#endif
-
unsigned int avpriv_toupper4(unsigned int x)
{
return av_toupper(x & 0xFF) +
#endif
-int avcodec_is_open(AVCodecContext *s)
-{
- return !!s->internal;
-}
-
const uint8_t *avpriv_find_start_code(const uint8_t *av_restrict p,
const uint8_t *end,
uint32_t *av_restrict state)
return props;
}
-static void codec_parameters_reset(AVCodecParameters *par)
-{
- av_freep(&par->extradata);
-
- memset(par, 0, sizeof(*par));
-
- par->codec_type = AVMEDIA_TYPE_UNKNOWN;
- par->codec_id = AV_CODEC_ID_NONE;
- par->format = -1;
- par->field_order = AV_FIELD_UNKNOWN;
- par->color_range = AVCOL_RANGE_UNSPECIFIED;
- par->color_primaries = AVCOL_PRI_UNSPECIFIED;
- par->color_trc = AVCOL_TRC_UNSPECIFIED;
- par->color_space = AVCOL_SPC_UNSPECIFIED;
- par->chroma_location = AVCHROMA_LOC_UNSPECIFIED;
- par->sample_aspect_ratio = (AVRational){ 0, 1 };
- par->profile = FF_PROFILE_UNKNOWN;
- par->level = FF_LEVEL_UNKNOWN;
-}
-
-AVCodecParameters *avcodec_parameters_alloc(void)
-{
- AVCodecParameters *par = av_mallocz(sizeof(*par));
-
- if (!par)
- return NULL;
- codec_parameters_reset(par);
- return par;
-}
-
-void avcodec_parameters_free(AVCodecParameters **ppar)
-{
- AVCodecParameters *par = *ppar;
-
- if (!par)
- return;
- codec_parameters_reset(par);
-
- av_freep(ppar);
-}
-
-int avcodec_parameters_copy(AVCodecParameters *dst, const AVCodecParameters *src)
-{
- codec_parameters_reset(dst);
- memcpy(dst, src, sizeof(*dst));
-
- dst->extradata = NULL;
- dst->extradata_size = 0;
- if (src->extradata) {
- dst->extradata = av_mallocz(src->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
- if (!dst->extradata)
- return AVERROR(ENOMEM);
- memcpy(dst->extradata, src->extradata, src->extradata_size);
- dst->extradata_size = src->extradata_size;
- }
-
- return 0;
-}
-
-int avcodec_parameters_from_context(AVCodecParameters *par,
- const AVCodecContext *codec)
-{
- codec_parameters_reset(par);
-
- par->codec_type = codec->codec_type;
- par->codec_id = codec->codec_id;
- par->codec_tag = codec->codec_tag;
-
- par->bit_rate = codec->bit_rate;
- par->bits_per_coded_sample = codec->bits_per_coded_sample;
- par->bits_per_raw_sample = codec->bits_per_raw_sample;
- par->profile = codec->profile;
- par->level = codec->level;
-
- switch (par->codec_type) {
- case AVMEDIA_TYPE_VIDEO:
- par->format = codec->pix_fmt;
- par->width = codec->width;
- par->height = codec->height;
- par->field_order = codec->field_order;
- par->color_range = codec->color_range;
- par->color_primaries = codec->color_primaries;
- par->color_trc = codec->color_trc;
- par->color_space = codec->colorspace;
- par->chroma_location = codec->chroma_sample_location;
- par->sample_aspect_ratio = codec->sample_aspect_ratio;
- par->video_delay = codec->has_b_frames;
- break;
- case AVMEDIA_TYPE_AUDIO:
- par->format = codec->sample_fmt;
- par->channel_layout = codec->channel_layout;
- par->channels = codec->channels;
- par->sample_rate = codec->sample_rate;
- par->block_align = codec->block_align;
- par->frame_size = codec->frame_size;
- par->initial_padding = codec->initial_padding;
- par->trailing_padding = codec->trailing_padding;
- par->seek_preroll = codec->seek_preroll;
- break;
- case AVMEDIA_TYPE_SUBTITLE:
- par->width = codec->width;
- par->height = codec->height;
- break;
- }
-
- if (codec->extradata) {
- par->extradata = av_mallocz(codec->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
- if (!par->extradata)
- return AVERROR(ENOMEM);
- memcpy(par->extradata, codec->extradata, codec->extradata_size);
- par->extradata_size = codec->extradata_size;
- }
-
- return 0;
-}
-
-int avcodec_parameters_to_context(AVCodecContext *codec,
- const AVCodecParameters *par)
-{
- codec->codec_type = par->codec_type;
- codec->codec_id = par->codec_id;
- codec->codec_tag = par->codec_tag;
-
- codec->bit_rate = par->bit_rate;
- codec->bits_per_coded_sample = par->bits_per_coded_sample;
- codec->bits_per_raw_sample = par->bits_per_raw_sample;
- codec->profile = par->profile;
- codec->level = par->level;
-
- switch (par->codec_type) {
- case AVMEDIA_TYPE_VIDEO:
- codec->pix_fmt = par->format;
- codec->width = par->width;
- codec->height = par->height;
- codec->field_order = par->field_order;
- codec->color_range = par->color_range;
- codec->color_primaries = par->color_primaries;
- codec->color_trc = par->color_trc;
- codec->colorspace = par->color_space;
- codec->chroma_sample_location = par->chroma_location;
- codec->sample_aspect_ratio = par->sample_aspect_ratio;
- codec->has_b_frames = par->video_delay;
- break;
- case AVMEDIA_TYPE_AUDIO:
- codec->sample_fmt = par->format;
- codec->channel_layout = par->channel_layout;
- codec->channels = par->channels;
- codec->sample_rate = par->sample_rate;
- codec->block_align = par->block_align;
- codec->frame_size = par->frame_size;
- codec->delay =
- codec->initial_padding = par->initial_padding;
- codec->trailing_padding = par->trailing_padding;
- codec->seek_preroll = par->seek_preroll;
- break;
- case AVMEDIA_TYPE_SUBTITLE:
- codec->width = par->width;
- codec->height = par->height;
- break;
- }
-
- if (par->extradata) {
- av_freep(&codec->extradata);
- codec->extradata = av_mallocz(par->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
- if (!codec->extradata)
- return AVERROR(ENOMEM);
- memcpy(codec->extradata, par->extradata, par->extradata_size);
- codec->extradata_size = par->extradata_size;
- }
-
- return 0;
-}
-
static unsigned bcd2uint(uint8_t bcd)
{
unsigned low = bcd & 0xf;
projects / ffmpeg / blobdiff