369 lines
9.8 KiB
C
369 lines
9.8 KiB
C
/*
|
|
* 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/atomic.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/internal.h"
|
|
#include "libavutil/mathematics.h"
|
|
#include "libavutil/pixdesc.h"
|
|
#include "libavutil/imgutils.h"
|
|
#include "libavutil/samplefmt.h"
|
|
#include "libavutil/dict.h"
|
|
#include "avcodec.h"
|
|
#include "libavutil/opt.h"
|
|
#include "thread.h"
|
|
#include "internal.h"
|
|
#include "bytestream.h"
|
|
#include "version.h"
|
|
#include <stdlib.h>
|
|
#include <stdarg.h>
|
|
#include <limits.h>
|
|
#include <float.h>
|
|
#if CONFIG_ICONV
|
|
# include <iconv.h>
|
|
#endif
|
|
|
|
void avcodec_register_all(void)
|
|
{
|
|
}
|
|
|
|
int attribute_align_arg avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
|
|
{
|
|
int ret = 0;
|
|
|
|
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;
|
|
}
|
|
}
|
|
} else {
|
|
avctx->priv_data = NULL;
|
|
}
|
|
avctx->codec = codec;
|
|
avctx->frame_number = 0;
|
|
// avctx->codec_descriptor = avcodec_descriptor_get(avctx->codec_id);
|
|
|
|
avctx->thread_count = 1;
|
|
|
|
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;
|
|
|
|
ret = avctx->codec->init(avctx);
|
|
if (ret < 0) {
|
|
goto free_and_end;
|
|
}
|
|
|
|
return 0;
|
|
free_and_end:
|
|
av_freep(&avctx->priv_data);
|
|
avctx->codec = NULL;
|
|
end:
|
|
return ret;
|
|
}
|
|
|
|
av_cold int avcodec_close(AVCodecContext *avctx)
|
|
{
|
|
if (!avctx)
|
|
return 0;
|
|
|
|
if (avctx->codec && avctx->codec->close)
|
|
avctx->codec->close(avctx);
|
|
avctx->coded_frame = NULL;
|
|
|
|
av_freep(&avctx->priv_data);
|
|
avctx->codec = NULL;
|
|
avctx->active_thread_type = 0;
|
|
|
|
return 0;
|
|
}
|
|
|
|
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;
|
|
}
|
|
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;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int avcodec_default_get_buffer2(AVCodecContext *avctx, AVFrame *frame, int flags)
|
|
{
|
|
const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format);
|
|
int i, h, linesize, bpp;
|
|
|
|
for (i = 0; i < desc->nb_components; i++) {
|
|
bpp = (desc->comp[i].depth_minus1 + 8) >> 3;
|
|
linesize = FFALIGN(frame->width * bpp, 32);
|
|
if (i == 1 || i == 2)
|
|
linesize = FF_CEIL_RSHIFT(linesize, desc->log2_chroma_w);
|
|
|
|
frame->linesize[i] = linesize;
|
|
|
|
h = FFALIGN(frame->height, 32);
|
|
if (i == 1 || i == 2)
|
|
h = FF_CEIL_RSHIFT(h, desc->log2_chroma_h);
|
|
|
|
frame->buf[i] = av_buffer_alloc(frame->linesize[i] * h + 32);
|
|
if (!frame->buf[i])
|
|
goto fail;
|
|
|
|
frame->data[i] = frame->buf[i]->data;
|
|
}
|
|
return 0;
|
|
fail:
|
|
return -1;
|
|
}
|
|
|
|
int avcodec_get_context_defaults3(AVCodecContext *s, const AVCodec *codec)
|
|
{
|
|
memset(s, 0, sizeof(AVCodecContext));
|
|
|
|
s->codec_type = codec ? codec->type : AVMEDIA_TYPE_UNKNOWN;
|
|
if (codec)
|
|
s->codec_id = codec->id;
|
|
|
|
s->time_base = (AVRational){0,1};
|
|
s->framerate = (AVRational){ 0, 1 };
|
|
s->pkt_timebase = (AVRational){ 0, 1 };
|
|
s->get_buffer2 = avcodec_default_get_buffer2;
|
|
// s->get_format = avcodec_default_get_format;
|
|
s->execute = avcodec_default_execute;
|
|
s->execute2 = avcodec_default_execute2;
|
|
s->sample_aspect_ratio = (AVRational){0,1};
|
|
s->pix_fmt = AV_PIX_FMT_NONE;
|
|
s->sample_fmt = AV_SAMPLE_FMT_NONE;
|
|
|
|
s->reordered_opaque = AV_NOPTS_VALUE;
|
|
if(codec && codec->priv_data_size){
|
|
if(!s->priv_data){
|
|
s->priv_data= av_mallocz(codec->priv_data_size);
|
|
if (!s->priv_data) {
|
|
return AVERROR(ENOMEM);
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int ff_thread_ref_frame(ThreadFrame *dst, ThreadFrame *src)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
AVCodecContext *avcodec_alloc_context3(const AVCodec *codec)
|
|
{
|
|
AVCodecContext *avctx= av_malloc(sizeof(AVCodecContext));
|
|
|
|
if (!avctx)
|
|
return NULL;
|
|
|
|
if(avcodec_get_context_defaults3(avctx, codec) < 0){
|
|
av_free(avctx);
|
|
return NULL;
|
|
}
|
|
|
|
return avctx;
|
|
}
|
|
|
|
int attribute_align_arg avcodec_decode_video2(AVCodecContext *avctx, AVFrame *picture,
|
|
int *got_picture_ptr,
|
|
const AVPacket *avpkt)
|
|
{
|
|
int ret;
|
|
// copy to ensure we do not change avpkt
|
|
AVPacket tmp = *avpkt;
|
|
|
|
if (!avctx->codec)
|
|
return AVERROR(EINVAL);
|
|
if (avctx->codec->type != AVMEDIA_TYPE_VIDEO) {
|
|
av_log(avctx, AV_LOG_ERROR, "Invalid media type for video\n");
|
|
return AVERROR(EINVAL);
|
|
}
|
|
|
|
*got_picture_ptr = 0;
|
|
if ((avctx->coded_width || avctx->coded_height) && av_image_check_size(avctx->coded_width, avctx->coded_height, 0, avctx))
|
|
return AVERROR(EINVAL);
|
|
|
|
av_frame_unref(picture);
|
|
|
|
if ((avctx->codec->capabilities & CODEC_CAP_DELAY) || avpkt->size || (avctx->active_thread_type & FF_THREAD_FRAME)) {
|
|
|
|
ret = avctx->codec->decode(avctx, picture, got_picture_ptr,
|
|
&tmp);
|
|
|
|
if (*got_picture_ptr) {
|
|
avctx->frame_number++;
|
|
} else {
|
|
av_frame_unref(picture);
|
|
}
|
|
} else {
|
|
ret = 0;
|
|
}
|
|
|
|
/* many decoders assign whole AVFrames, thus overwriting extended_data;
|
|
* make sure it's set correctly */
|
|
// av_assert0(!picture->extended_data || picture->extended_data == picture->data);
|
|
|
|
return ret;
|
|
}
|
|
|
|
int av_image_check_size(unsigned int w, unsigned int h, int log_offset, void *log_ctx)
|
|
{
|
|
if ((int)w>0 && (int)h>0 && (w+128) < (INT_MAX/8) / (h + 128))
|
|
return 0;
|
|
else
|
|
return AVERROR(EINVAL);
|
|
}
|
|
|
|
int ff_set_sar(AVCodecContext *avctx, AVRational sar)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
static int get_buffer_internal(AVCodecContext *avctx, AVFrame *frame, int flags)
|
|
{
|
|
int override_dimensions = 1;
|
|
int ret;
|
|
|
|
if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
|
|
if ((ret = av_image_check_size(avctx->width, avctx->height, 0, avctx)) < 0 || avctx->pix_fmt<0) {
|
|
av_log(avctx, AV_LOG_ERROR, "video_get_buffer: image parameters invalid\n");
|
|
return AVERROR(EINVAL);
|
|
}
|
|
}
|
|
if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
|
|
if (frame->width <= 0 || frame->height <= 0) {
|
|
frame->width = FFMAX(avctx->width, FF_CEIL_RSHIFT(avctx->coded_width, avctx->lowres));
|
|
frame->height = FFMAX(avctx->height, FF_CEIL_RSHIFT(avctx->coded_height, avctx->lowres));
|
|
override_dimensions = 0;
|
|
}
|
|
frame->format = avctx->pix_fmt;
|
|
}
|
|
ret = avctx->get_buffer2(avctx, frame, flags);
|
|
|
|
if (avctx->codec_type == AVMEDIA_TYPE_VIDEO && !override_dimensions) {
|
|
frame->width = avctx->width;
|
|
frame->height = avctx->height;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
|
|
{
|
|
int ret = get_buffer_internal(avctx, frame, flags);
|
|
if (ret < 0)
|
|
av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
|
|
return ret;
|
|
}
|
|
|
|
int ff_thread_get_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags)
|
|
{
|
|
f->owner = avctx;
|
|
return ff_get_buffer(avctx, f->f, flags);
|
|
}
|
|
|
|
void ff_thread_release_buffer(AVCodecContext *avctx, ThreadFrame *f)
|
|
{
|
|
if (f->f)
|
|
av_frame_unref(f->f);
|
|
}
|
|
|
|
void ff_thread_finish_setup(AVCodecContext *avctx)
|
|
{
|
|
}
|
|
|
|
void ff_thread_report_progress(ThreadFrame *f, int progress, int field)
|
|
{
|
|
}
|
|
|
|
void ff_thread_await_progress(ThreadFrame *f, int progress, int field)
|
|
{
|
|
}
|
|
|
|
int ff_thread_can_start_frame(AVCodecContext *avctx)
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
int ff_alloc_entries(AVCodecContext *avctx, int count)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
void ff_reset_entries(AVCodecContext *avctx)
|
|
{
|
|
}
|
|
|
|
void ff_thread_await_progress2(AVCodecContext *avctx, int field, int thread, int shift)
|
|
{
|
|
}
|
|
|
|
void ff_thread_report_progress2(AVCodecContext *avctx, int field, int thread, int n)
|
|
{
|
|
}
|
|
|
|
void av_init_packet(AVPacket *pkt)
|
|
{
|
|
pkt->pts = AV_NOPTS_VALUE;
|
|
pkt->dts = AV_NOPTS_VALUE;
|
|
pkt->pos = -1;
|
|
pkt->duration = 0;
|
|
pkt->convergence_duration = 0;
|
|
pkt->flags = 0;
|
|
pkt->stream_index = 0;
|
|
pkt->buf = NULL;
|
|
pkt->side_data = NULL;
|
|
pkt->side_data_elems = 0;
|
|
}
|