2010-01-30 16:57:40 +00:00
|
|
|
/*
|
|
|
|
* This file is part of MPlayer.
|
|
|
|
*
|
|
|
|
* MPlayer is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* MPlayer 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 General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License along
|
|
|
|
* with MPlayer; if not, write to the Free Software Foundation, Inc.,
|
|
|
|
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
|
|
*/
|
|
|
|
|
2002-03-06 20:54:43 +00:00
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <assert.h>
|
2002-07-28 15:54:26 +00:00
|
|
|
#include <time.h>
|
2010-01-20 14:31:13 +00:00
|
|
|
#include <stdbool.h>
|
2012-07-31 21:37:56 +00:00
|
|
|
#include <sys/types.h>
|
2002-03-06 20:54:43 +00:00
|
|
|
|
2012-01-28 11:41:36 +00:00
|
|
|
#include <libavutil/common.h>
|
|
|
|
#include <libavutil/opt.h>
|
2012-02-01 18:01:16 +00:00
|
|
|
#include <libavutil/intreadwrite.h>
|
2012-01-28 11:41:36 +00:00
|
|
|
|
2010-10-16 01:33:38 +00:00
|
|
|
#include "talloc.h"
|
2002-03-06 20:54:43 +00:00
|
|
|
#include "config.h"
|
|
|
|
#include "mp_msg.h"
|
2008-04-24 00:59:21 +00:00
|
|
|
#include "options.h"
|
2008-05-10 18:55:31 +00:00
|
|
|
#include "av_opts.h"
|
2002-03-06 20:54:43 +00:00
|
|
|
|
2006-12-07 11:58:07 +00:00
|
|
|
#include "mpbswap.h"
|
2009-02-14 17:58:33 +00:00
|
|
|
#include "fmt-conversion.h"
|
2002-03-06 20:54:43 +00:00
|
|
|
|
2009-11-21 18:53:10 +00:00
|
|
|
#include "vd.h"
|
|
|
|
#include "img_format.h"
|
|
|
|
#include "libmpdemux/stheader.h"
|
2011-08-20 17:25:43 +00:00
|
|
|
#include "libmpdemux/demux_packet.h"
|
2009-11-21 18:53:10 +00:00
|
|
|
#include "codec-cfg.h"
|
2010-12-20 03:53:28 +00:00
|
|
|
#include "osdep/numcores.h"
|
2002-03-06 20:54:43 +00:00
|
|
|
|
2008-04-24 05:43:56 +00:00
|
|
|
static const vd_info_t info = {
|
2012-07-24 06:01:47 +00:00
|
|
|
"libavcodec video codecs",
|
2009-02-14 17:29:59 +00:00
|
|
|
"ffmpeg",
|
2012-07-24 06:01:47 +00:00
|
|
|
"",
|
|
|
|
"",
|
|
|
|
"native codecs",
|
|
|
|
.print_name = "libavcodec",
|
2002-03-06 20:54:43 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
#include "libavcodec/avcodec.h"
|
|
|
|
|
2009-12-26 11:51:19 +00:00
|
|
|
#if AVPALETTE_SIZE > 1024
|
|
|
|
#error palette too large, adapt libmpcodecs/vf.c:vf_get_image
|
|
|
|
#endif
|
|
|
|
|
2002-03-23 17:29:35 +00:00
|
|
|
typedef struct {
|
|
|
|
AVCodecContext *avctx;
|
2002-12-09 12:36:04 +00:00
|
|
|
AVFrame *pic;
|
2006-03-27 10:32:52 +00:00
|
|
|
enum PixelFormat pix_fmt;
|
2002-04-03 23:59:54 +00:00
|
|
|
int do_slices;
|
2002-07-14 21:30:54 +00:00
|
|
|
int do_dr1;
|
2008-02-14 14:23:55 +00:00
|
|
|
int vo_initialized;
|
2002-08-02 19:38:59 +00:00
|
|
|
int best_csp;
|
2002-12-09 09:12:23 +00:00
|
|
|
int qp_stat[32];
|
|
|
|
double qp_sum;
|
|
|
|
double inv_qp_sum;
|
2003-04-25 00:57:04 +00:00
|
|
|
int ip_count;
|
|
|
|
int b_count;
|
2007-02-20 20:09:29 +00:00
|
|
|
AVRational last_sample_aspect_ratio;
|
2011-07-09 10:50:16 +00:00
|
|
|
enum AVDiscard skip_frame;
|
2002-03-23 17:29:35 +00:00
|
|
|
} vd_ffmpeg_ctx;
|
|
|
|
|
2003-08-13 16:29:32 +00:00
|
|
|
#include "m_option.h"
|
2002-06-02 12:48:55 +00:00
|
|
|
|
2002-12-09 12:36:04 +00:00
|
|
|
static int get_buffer(AVCodecContext *avctx, AVFrame *pic);
|
|
|
|
static void release_buffer(AVCodecContext *avctx, AVFrame *pic);
|
2009-02-16 00:39:58 +00:00
|
|
|
static void draw_slice(struct AVCodecContext *s, const AVFrame *src,
|
|
|
|
int offset[4], int y, int type, int height);
|
2002-07-16 00:56:12 +00:00
|
|
|
|
2009-02-14 17:43:06 +00:00
|
|
|
static enum PixelFormat get_format(struct AVCodecContext *avctx,
|
|
|
|
const enum PixelFormat *pix_fmt);
|
2009-11-21 18:53:10 +00:00
|
|
|
static void uninit(struct sh_video *sh);
|
2003-07-01 22:05:46 +00:00
|
|
|
|
2011-10-22 00:51:37 +00:00
|
|
|
const m_option_t lavc_decode_opts_conf[] = {
|
2008-04-24 00:59:21 +00:00
|
|
|
OPT_INTRANGE("bug", lavc_param.workaround_bugs, 0, -1, 999999),
|
|
|
|
OPT_FLAG_ON("gray", lavc_param.gray, 0),
|
|
|
|
OPT_INTRANGE("idct", lavc_param.idct_algo, 0, 0, 99),
|
|
|
|
OPT_INTRANGE("ec", lavc_param.error_concealment, 0, 0, 99),
|
|
|
|
OPT_FLAG_ON("vstats", lavc_param.vstats, 0),
|
|
|
|
OPT_INTRANGE("debug", lavc_param.debug, 0, 0, 9999999),
|
|
|
|
OPT_INTRANGE("vismv", lavc_param.vismv, 0, 0, 9999999),
|
|
|
|
OPT_INTRANGE("st", lavc_param.skip_top, 0, 0, 999),
|
|
|
|
OPT_INTRANGE("sb", lavc_param.skip_bottom, 0, 0, 999),
|
|
|
|
OPT_FLAG_CONSTANTS("fast", lavc_param.fast, 0, 0, CODEC_FLAG2_FAST),
|
|
|
|
OPT_STRING("lowres", lavc_param.lowres_str, 0),
|
|
|
|
OPT_STRING("skiploopfilter", lavc_param.skip_loop_filter_str, 0),
|
|
|
|
OPT_STRING("skipidct", lavc_param.skip_idct_str, 0),
|
|
|
|
OPT_STRING("skipframe", lavc_param.skip_frame_str, 0),
|
2010-12-20 03:53:28 +00:00
|
|
|
OPT_INTRANGE("threads", lavc_param.threads, 0, 0, 16),
|
2008-04-24 00:59:21 +00:00
|
|
|
OPT_FLAG_CONSTANTS("bitexact", lavc_param.bitexact, 0, 0, CODEC_FLAG_BITEXACT),
|
2008-05-15 18:19:35 +00:00
|
|
|
OPT_STRING("o", lavc_param.avopt, 0),
|
2008-04-24 00:59:21 +00:00
|
|
|
{NULL, NULL, 0, 0, 0, 0, NULL}
|
2002-06-02 12:48:55 +00:00
|
|
|
};
|
|
|
|
|
2011-10-22 00:51:37 +00:00
|
|
|
static enum AVDiscard str2AVDiscard(char *str)
|
|
|
|
{
|
2008-05-10 19:15:57 +00:00
|
|
|
if (!str) return AVDISCARD_DEFAULT;
|
|
|
|
if (strcasecmp(str, "none" ) == 0) return AVDISCARD_NONE;
|
|
|
|
if (strcasecmp(str, "default") == 0) return AVDISCARD_DEFAULT;
|
|
|
|
if (strcasecmp(str, "nonref" ) == 0) return AVDISCARD_NONREF;
|
|
|
|
if (strcasecmp(str, "bidir" ) == 0) return AVDISCARD_BIDIR;
|
|
|
|
if (strcasecmp(str, "nonkey" ) == 0) return AVDISCARD_NONKEY;
|
|
|
|
if (strcasecmp(str, "all" ) == 0) return AVDISCARD_ALL;
|
|
|
|
mp_msg(MSGT_DECVIDEO, MSGL_ERR, "Unknown discard value %s\n", str);
|
2005-07-17 00:18:42 +00:00
|
|
|
return AVDISCARD_DEFAULT;
|
|
|
|
}
|
|
|
|
|
2011-10-22 00:51:37 +00:00
|
|
|
static int init(sh_video_t *sh)
|
|
|
|
{
|
2008-04-24 00:59:21 +00:00
|
|
|
struct lavc_param *lavc_param = &sh->opts->lavc_param;
|
2002-03-23 17:29:35 +00:00
|
|
|
AVCodecContext *avctx;
|
|
|
|
vd_ffmpeg_ctx *ctx;
|
2002-04-01 17:12:10 +00:00
|
|
|
AVCodec *lavc_codec;
|
2011-10-22 00:51:37 +00:00
|
|
|
int do_vis_debug = lavc_param->vismv ||
|
|
|
|
(lavc_param->debug & (FF_DEBUG_VIS_MB_TYPE | FF_DEBUG_VIS_QP));
|
2002-03-06 20:54:43 +00:00
|
|
|
|
2010-10-16 01:33:38 +00:00
|
|
|
ctx = sh->context = talloc_zero(NULL, vd_ffmpeg_ctx);
|
2009-02-12 15:41:59 +00:00
|
|
|
|
2012-07-24 06:01:47 +00:00
|
|
|
if (sh->codec->dll) {
|
|
|
|
lavc_codec = avcodec_find_decoder_by_name(sh->codec->dll);
|
|
|
|
if (!lavc_codec) {
|
|
|
|
mp_tmsg(MSGT_DECVIDEO, MSGL_ERR,
|
|
|
|
"Cannot find codec '%s' in libavcodec...\n",
|
|
|
|
sh->codec->dll);
|
|
|
|
uninit(sh);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
} else if (!sh->libav_codec_id) {
|
|
|
|
mp_tmsg(MSGT_DECVIDEO, MSGL_INFO, "No Libav codec ID known. "
|
|
|
|
"Generic lavc decoder is not applicable.\n");
|
2009-02-12 15:39:32 +00:00
|
|
|
return 0;
|
2012-07-24 06:01:47 +00:00
|
|
|
} else {
|
|
|
|
lavc_codec = avcodec_find_decoder(sh->libav_codec_id);
|
|
|
|
if (!lavc_codec) {
|
|
|
|
mp_tmsg(MSGT_DECVIDEO, MSGL_INFO, "Libavcodec has no decoder "
|
|
|
|
"for this codec\n");
|
|
|
|
return 0;
|
|
|
|
}
|
2002-03-06 20:54:43 +00:00
|
|
|
}
|
2002-04-03 23:59:54 +00:00
|
|
|
|
2012-07-24 06:01:47 +00:00
|
|
|
sh->codecname = lavc_codec->long_name;
|
|
|
|
if (!sh->codecname)
|
|
|
|
sh->codecname = lavc_codec->name;
|
|
|
|
|
2011-10-22 00:51:37 +00:00
|
|
|
if (sh->opts->vd_use_slices
|
|
|
|
&& (lavc_codec->capabilities & CODEC_CAP_DRAW_HORIZ_BAND)
|
|
|
|
&& !do_vis_debug)
|
|
|
|
ctx->do_slices = 1;
|
2009-02-12 15:41:59 +00:00
|
|
|
|
2011-10-22 00:51:37 +00:00
|
|
|
if (lavc_codec->capabilities & CODEC_CAP_DR1 && !do_vis_debug
|
|
|
|
&& lavc_codec->id != CODEC_ID_H264
|
|
|
|
&& lavc_codec->id != CODEC_ID_INTERPLAY_VIDEO
|
|
|
|
&& lavc_codec->id != CODEC_ID_ROQ && lavc_codec->id != CODEC_ID_VP8
|
2011-12-21 23:07:12 +00:00
|
|
|
&& lavc_codec->id != CODEC_ID_LAGARITH)
|
2011-10-22 00:51:37 +00:00
|
|
|
ctx->do_dr1 = 1;
|
|
|
|
ctx->ip_count = ctx->b_count = 0;
|
2002-09-19 09:47:37 +00:00
|
|
|
|
2002-12-09 12:36:04 +00:00
|
|
|
ctx->pic = avcodec_alloc_frame();
|
2012-01-28 11:41:36 +00:00
|
|
|
ctx->avctx = avcodec_alloc_context3(lavc_codec);
|
2002-03-23 17:29:35 +00:00
|
|
|
avctx = ctx->avctx;
|
2009-02-17 16:40:50 +00:00
|
|
|
avctx->opaque = sh;
|
2011-04-19 23:59:45 +00:00
|
|
|
avctx->codec_type = AVMEDIA_TYPE_VIDEO;
|
2009-09-23 19:21:38 +00:00
|
|
|
avctx->codec_id = lavc_codec->id;
|
2002-07-16 00:56:12 +00:00
|
|
|
|
2010-01-20 14:31:13 +00:00
|
|
|
if (lavc_codec->capabilities & CODEC_CAP_HWACCEL // XvMC
|
|
|
|
|| lavc_codec->capabilities & CODEC_CAP_HWACCEL_VDPAU) {
|
|
|
|
ctx->do_dr1 = true;
|
|
|
|
ctx->do_slices = true;
|
|
|
|
lavc_param->threads = 1;
|
|
|
|
avctx->get_format = get_format;
|
|
|
|
avctx->get_buffer = get_buffer;
|
|
|
|
avctx->release_buffer = release_buffer;
|
|
|
|
avctx->reget_buffer = get_buffer;
|
|
|
|
avctx->draw_horiz_band = draw_slice;
|
2010-01-20 15:21:39 +00:00
|
|
|
if (lavc_codec->capabilities & CODEC_CAP_HWACCEL)
|
|
|
|
mp_msg(MSGT_DECVIDEO, MSGL_V, "[VD_FFMPEG] XVMC-accelerated "
|
|
|
|
"MPEG-2.\n");
|
|
|
|
if (lavc_codec->capabilities & CODEC_CAP_HWACCEL_VDPAU)
|
|
|
|
mp_msg(MSGT_DECVIDEO, MSGL_V, "[VD_FFMPEG] VDPAU hardware "
|
|
|
|
"decoding.\n");
|
2011-10-22 00:51:37 +00:00
|
|
|
avctx->slice_flags = SLICE_FLAG_CODED_ORDER | SLICE_FLAG_ALLOW_FIELD;
|
2009-02-16 20:58:13 +00:00
|
|
|
}
|
2010-01-20 14:31:13 +00:00
|
|
|
|
2010-12-20 03:53:28 +00:00
|
|
|
if (lavc_param->threads == 0) {
|
|
|
|
int threads = default_thread_count();
|
|
|
|
if (threads < 1) {
|
|
|
|
mp_msg(MSGT_DECVIDEO, MSGL_WARN, "[VD_FFMPEG] Could not determine "
|
|
|
|
"thread count to use, defaulting to 1.\n");
|
|
|
|
threads = 1;
|
|
|
|
}
|
|
|
|
threads = FFMIN(threads, 16);
|
|
|
|
lavc_param->threads = threads;
|
|
|
|
}
|
2010-01-20 14:31:13 +00:00
|
|
|
/* Our get_buffer and draw_horiz_band callbacks are not safe to call
|
|
|
|
* from other threads. */
|
|
|
|
if (lavc_param->threads > 1) {
|
|
|
|
ctx->do_dr1 = false;
|
|
|
|
ctx->do_slices = false;
|
2012-07-24 06:01:47 +00:00
|
|
|
mp_tmsg(MSGT_DECVIDEO, MSGL_V, "Asking decoder to use "
|
2010-12-20 03:53:28 +00:00
|
|
|
"%d threads if supported.\n", lavc_param->threads);
|
2009-02-15 16:57:08 +00:00
|
|
|
}
|
2010-01-20 14:31:13 +00:00
|
|
|
|
2011-10-22 00:51:37 +00:00
|
|
|
if (ctx->do_dr1) {
|
|
|
|
avctx->flags |= CODEC_FLAG_EMU_EDGE;
|
|
|
|
avctx->get_buffer = get_buffer;
|
|
|
|
avctx->release_buffer = release_buffer;
|
|
|
|
avctx->reget_buffer = get_buffer;
|
2002-07-16 00:56:12 +00:00
|
|
|
}
|
2002-09-06 22:53:26 +00:00
|
|
|
|
2011-10-22 00:51:37 +00:00
|
|
|
avctx->flags |= lavc_param->bitexact;
|
2009-02-12 15:41:59 +00:00
|
|
|
|
2010-08-31 19:39:17 +00:00
|
|
|
avctx->coded_width = sh->disp_w;
|
2011-10-22 00:51:37 +00:00
|
|
|
avctx->coded_height = sh->disp_h;
|
|
|
|
avctx->workaround_bugs = lavc_param->workaround_bugs;
|
|
|
|
if (lavc_param->gray)
|
|
|
|
avctx->flags |= CODEC_FLAG_GRAY;
|
|
|
|
avctx->flags2 |= lavc_param->fast;
|
|
|
|
avctx->codec_tag = sh->format;
|
|
|
|
avctx->stream_codec_tag = sh->video.fccHandler;
|
|
|
|
avctx->idct_algo = lavc_param->idct_algo;
|
|
|
|
avctx->error_concealment = lavc_param->error_concealment;
|
|
|
|
avctx->debug = lavc_param->debug;
|
2008-04-24 00:59:21 +00:00
|
|
|
if (lavc_param->debug)
|
2007-02-07 12:31:37 +00:00
|
|
|
av_log_set_level(AV_LOG_DEBUG);
|
2011-10-22 00:51:37 +00:00
|
|
|
avctx->debug_mv = lavc_param->vismv;
|
2008-04-24 00:59:21 +00:00
|
|
|
avctx->skip_top = lavc_param->skip_top;
|
2011-10-22 00:51:37 +00:00
|
|
|
avctx->skip_bottom = lavc_param->skip_bottom;
|
|
|
|
if (lavc_param->lowres_str != NULL) {
|
2011-07-09 11:14:38 +00:00
|
|
|
int lowres, lowres_w;
|
|
|
|
sscanf(lavc_param->lowres_str, "%d,%d", &lowres, &lowres_w);
|
|
|
|
if (lowres < 1 || lowres > 16 ||
|
|
|
|
lowres_w > 0 && avctx->width < lowres_w)
|
|
|
|
lowres = 0;
|
|
|
|
avctx->lowres = lowres;
|
2004-12-17 07:34:23 +00:00
|
|
|
}
|
2008-04-24 00:59:21 +00:00
|
|
|
avctx->skip_loop_filter = str2AVDiscard(lavc_param->skip_loop_filter_str);
|
|
|
|
avctx->skip_idct = str2AVDiscard(lavc_param->skip_idct_str);
|
|
|
|
avctx->skip_frame = str2AVDiscard(lavc_param->skip_frame_str);
|
2008-05-10 18:55:31 +00:00
|
|
|
|
2011-10-22 00:51:37 +00:00
|
|
|
if (lavc_param->avopt) {
|
|
|
|
if (parse_avopts(avctx, lavc_param->avopt) < 0) {
|
|
|
|
mp_msg(MSGT_DECVIDEO, MSGL_ERR,
|
|
|
|
"Your options /%s/ look like gibberish to me pal\n",
|
|
|
|
lavc_param->avopt);
|
2008-05-10 18:55:31 +00:00
|
|
|
uninit(sh);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-07-09 10:50:16 +00:00
|
|
|
// Do this after the above avopt handling in case it changes values
|
|
|
|
ctx->skip_frame = avctx->skip_frame;
|
|
|
|
|
2011-10-22 00:51:37 +00:00
|
|
|
mp_dbg(MSGT_DECVIDEO, MSGL_DBG2,
|
|
|
|
"libavcodec.size: %d x %d\n", avctx->width, avctx->height);
|
2006-04-02 18:35:00 +00:00
|
|
|
switch (sh->format) {
|
2006-07-31 22:26:25 +00:00
|
|
|
case mmioFOURCC('S','V','Q','3'):
|
2011-10-22 00:51:37 +00:00
|
|
|
/* SVQ3 extradata can show up as sh->ImageDesc if demux_mov is used, or
|
|
|
|
* in the phony AVI header if demux_lavf is used. The first case is
|
|
|
|
* handled here; the second case falls through to the next section. */
|
2009-02-12 15:39:32 +00:00
|
|
|
if (sh->ImageDesc) {
|
2009-02-14 17:43:06 +00:00
|
|
|
avctx->extradata_size = (*(int *)sh->ImageDesc) - sizeof(int);
|
2011-10-22 00:51:37 +00:00
|
|
|
avctx->extradata = av_mallocz(avctx->extradata_size +
|
|
|
|
FF_INPUT_BUFFER_PADDING_SIZE);
|
|
|
|
memcpy(avctx->extradata, ((int *)sh->ImageDesc) + 1,
|
|
|
|
avctx->extradata_size);
|
2009-02-12 15:39:32 +00:00
|
|
|
break;
|
|
|
|
}
|
2011-10-22 00:51:37 +00:00
|
|
|
/* fallthrough */
|
2006-07-31 22:26:25 +00:00
|
|
|
|
2006-04-02 18:35:00 +00:00
|
|
|
case mmioFOURCC('A','V','R','n'):
|
|
|
|
case mmioFOURCC('M','J','P','G'):
|
2011-10-22 00:51:37 +00:00
|
|
|
/* AVRn stores huffman table in AVI header */
|
|
|
|
/* Pegasus MJPEG stores it also in AVI header, but it uses the common
|
|
|
|
* MJPG fourcc :( */
|
2010-09-12 11:44:42 +00:00
|
|
|
if (!sh->bih || sh->bih->biSize <= sizeof(*sh->bih))
|
2009-02-12 15:39:32 +00:00
|
|
|
break;
|
2012-01-28 11:41:36 +00:00
|
|
|
av_opt_set_int(avctx, "extern_huff", 1, AV_OPT_SEARCH_CHILDREN);
|
2011-10-22 00:51:37 +00:00
|
|
|
avctx->extradata_size = sh->bih->biSize - sizeof(*sh->bih);
|
|
|
|
avctx->extradata = av_mallocz(avctx->extradata_size +
|
|
|
|
FF_INPUT_BUFFER_PADDING_SIZE);
|
|
|
|
memcpy(avctx->extradata, sh->bih + 1, avctx->extradata_size);
|
2009-02-12 15:39:32 +00:00
|
|
|
break;
|
2006-04-02 18:35:00 +00:00
|
|
|
|
2011-10-22 00:51:37 +00:00
|
|
|
case mmioFOURCC('R','V','1','0'):
|
|
|
|
case mmioFOURCC('R','V','1','3'):
|
|
|
|
case mmioFOURCC('R','V','2','0'):
|
|
|
|
case mmioFOURCC('R','V','3','0'):
|
|
|
|
case mmioFOURCC('R','V','4','0'):
|
|
|
|
if (sh->bih->biSize < sizeof(*sh->bih) + 8) {
|
|
|
|
// only 1 packet per frame & sub_id from fourcc
|
|
|
|
avctx->extradata_size = 8;
|
|
|
|
avctx->extradata = av_mallocz(avctx->extradata_size +
|
|
|
|
FF_INPUT_BUFFER_PADDING_SIZE);
|
2009-02-14 17:43:06 +00:00
|
|
|
((uint32_t *)avctx->extradata)[0] = 0;
|
|
|
|
((uint32_t *)avctx->extradata)[1] =
|
2011-10-22 00:51:37 +00:00
|
|
|
sh->format == mmioFOURCC('R','V','1','3') ?
|
|
|
|
0x10003001 : 0x10000000;
|
2002-10-01 21:30:10 +00:00
|
|
|
} else {
|
2011-10-22 00:51:37 +00:00
|
|
|
// has extra slice header (demux_rm or rm->avi streamcopy)
|
|
|
|
avctx->extradata_size = sh->bih->biSize - sizeof(*sh->bih);
|
|
|
|
avctx->extradata = av_mallocz(avctx->extradata_size +
|
|
|
|
FF_INPUT_BUFFER_PADDING_SIZE);
|
|
|
|
memcpy(avctx->extradata, sh->bih + 1, avctx->extradata_size);
|
2009-02-12 15:39:32 +00:00
|
|
|
}
|
2006-04-02 18:35:00 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
2010-09-12 11:44:42 +00:00
|
|
|
if (!sh->bih || sh->bih->biSize <= sizeof(*sh->bih))
|
2009-02-12 15:39:32 +00:00
|
|
|
break;
|
2011-10-22 00:51:37 +00:00
|
|
|
avctx->extradata_size = sh->bih->biSize - sizeof(*sh->bih);
|
|
|
|
avctx->extradata = av_mallocz(avctx->extradata_size +
|
|
|
|
FF_INPUT_BUFFER_PADDING_SIZE);
|
|
|
|
memcpy(avctx->extradata, sh->bih + 1, avctx->extradata_size);
|
2009-02-12 15:39:32 +00:00
|
|
|
break;
|
2002-10-14 12:51:55 +00:00
|
|
|
}
|
2006-07-13 23:02:03 +00:00
|
|
|
|
2011-10-22 00:51:37 +00:00
|
|
|
if (sh->bih)
|
|
|
|
avctx->bits_per_coded_sample = sh->bih->biBitCount;
|
2002-08-28 22:02:38 +00:00
|
|
|
|
2012-01-16 21:34:03 +00:00
|
|
|
avctx->thread_count = lavc_param->threads;
|
2011-12-22 00:06:52 +00:00
|
|
|
|
2002-03-06 20:54:43 +00:00
|
|
|
/* open it */
|
2012-01-28 11:41:36 +00:00
|
|
|
if (avcodec_open2(avctx, lavc_codec, NULL) < 0) {
|
2009-07-06 22:15:02 +00:00
|
|
|
mp_tmsg(MSGT_DECVIDEO, MSGL_ERR, "Could not open codec.\n");
|
2006-12-06 10:41:34 +00:00
|
|
|
uninit(sh);
|
2002-03-06 20:54:43 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2012-07-24 06:01:47 +00:00
|
|
|
return 1;
|
2002-03-06 20:54:43 +00:00
|
|
|
}
|
|
|
|
|
2011-10-22 00:51:37 +00:00
|
|
|
static void uninit(sh_video_t *sh)
|
|
|
|
{
|
2002-03-23 17:29:35 +00:00
|
|
|
vd_ffmpeg_ctx *ctx = sh->context;
|
|
|
|
AVCodecContext *avctx = ctx->avctx;
|
2009-02-12 15:41:59 +00:00
|
|
|
|
2012-07-24 06:01:47 +00:00
|
|
|
sh->codecname = NULL;
|
2011-05-01 20:21:00 +00:00
|
|
|
if (sh->opts->lavc_param.vstats && avctx->coded_frame) {
|
2011-10-22 00:51:37 +00:00
|
|
|
for (int i = 1; i < 32; i++)
|
|
|
|
mp_msg(MSGT_DECVIDEO, MSGL_INFO,
|
|
|
|
"QP: %d, count: %d\n", i, ctx->qp_stat[i]);
|
|
|
|
mp_tmsg(MSGT_DECVIDEO, MSGL_INFO, "[VD_FFMPEG] Arithmetic mean of QP: "
|
|
|
|
"%2.4f, Harmonic mean of QP: %2.4f\n",
|
2002-12-09 12:36:04 +00:00
|
|
|
ctx->qp_sum / avctx->coded_frame->coded_picture_number,
|
2011-10-22 00:51:37 +00:00
|
|
|
1.0 / (ctx->inv_qp_sum / avctx->coded_frame->coded_picture_number));
|
2002-12-09 09:12:23 +00:00
|
|
|
}
|
2002-03-23 17:29:35 +00:00
|
|
|
|
2007-02-03 13:19:21 +00:00
|
|
|
if (avctx) {
|
2007-02-03 13:20:31 +00:00
|
|
|
if (avctx->codec && avcodec_close(avctx) < 0)
|
2009-07-06 22:15:02 +00:00
|
|
|
mp_tmsg(MSGT_DECVIDEO, MSGL_ERR, "Could not close codec.\n");
|
2002-05-02 12:24:53 +00:00
|
|
|
|
2007-02-03 13:20:31 +00:00
|
|
|
av_freep(&avctx->extradata);
|
|
|
|
av_freep(&avctx->slice_offset);
|
2007-02-03 13:19:21 +00:00
|
|
|
}
|
2005-01-08 19:16:21 +00:00
|
|
|
|
|
|
|
av_freep(&avctx);
|
|
|
|
av_freep(&ctx->pic);
|
2010-10-16 01:33:38 +00:00
|
|
|
talloc_free(ctx);
|
2002-03-06 20:54:43 +00:00
|
|
|
}
|
|
|
|
|
2002-04-03 23:59:54 +00:00
|
|
|
static void draw_slice(struct AVCodecContext *s,
|
2008-04-24 00:22:37 +00:00
|
|
|
const AVFrame *src, int offset[4],
|
2011-10-22 00:51:37 +00:00
|
|
|
int y, int type, int height)
|
|
|
|
{
|
2009-02-14 17:43:06 +00:00
|
|
|
sh_video_t *sh = s->opaque;
|
2011-10-22 00:51:37 +00:00
|
|
|
uint8_t *source[MP_MAX_PLANES] = {
|
|
|
|
src->data[0] + offset[0], src->data[1] + offset[1],
|
|
|
|
src->data[2] + offset[2]
|
|
|
|
};
|
|
|
|
int strides[MP_MAX_PLANES] = {
|
|
|
|
src->linesize[0], src->linesize[1], src->linesize[2]
|
|
|
|
};
|
|
|
|
if (height < 0) {
|
2010-02-17 23:46:57 +00:00
|
|
|
int i;
|
|
|
|
height = -height;
|
|
|
|
y -= height;
|
2011-10-22 00:51:37 +00:00
|
|
|
for (i = 0; i < MP_MAX_PLANES; i++) {
|
2010-02-17 23:46:57 +00:00
|
|
|
strides[i] = -strides[i];
|
|
|
|
source[i] -= strides[i];
|
|
|
|
}
|
|
|
|
}
|
2005-06-07 10:04:22 +00:00
|
|
|
if (y < sh->disp_h) {
|
2011-10-22 00:51:37 +00:00
|
|
|
height = FFMIN(height, sh->disp_h - y);
|
|
|
|
mpcodecs_draw_slice(sh, source, strides, sh->disp_w, height, 0, y);
|
2005-06-07 10:04:22 +00:00
|
|
|
}
|
2002-04-03 23:59:54 +00:00
|
|
|
}
|
2002-03-06 20:54:43 +00:00
|
|
|
|
2003-07-17 12:51:44 +00:00
|
|
|
|
2011-10-22 00:51:37 +00:00
|
|
|
static int init_vo(sh_video_t *sh, enum PixelFormat pix_fmt)
|
|
|
|
{
|
2002-03-23 17:29:35 +00:00
|
|
|
vd_ffmpeg_ctx *ctx = sh->context;
|
|
|
|
AVCodecContext *avctx = ctx->avctx;
|
2011-10-22 00:51:37 +00:00
|
|
|
float aspect = av_q2d(avctx->sample_aspect_ratio) *
|
|
|
|
avctx->width / avctx->height;
|
2005-05-25 09:20:50 +00:00
|
|
|
int width, height;
|
2002-04-27 23:45:00 +00:00
|
|
|
|
2005-05-25 09:20:50 +00:00
|
|
|
width = avctx->width;
|
|
|
|
height = avctx->height;
|
2005-05-25 16:29:53 +00:00
|
|
|
|
|
|
|
// HACK!
|
|
|
|
// if sh->ImageDesc is non-NULL, it means we decode QuickTime(tm) video.
|
|
|
|
// use dimensions from BIH to avoid black borders at the right and bottom.
|
|
|
|
if (sh->bih && sh->ImageDesc) {
|
2011-07-09 11:14:38 +00:00
|
|
|
width = sh->bih->biWidth >> avctx->lowres;
|
|
|
|
height = sh->bih->biHeight >> avctx->lowres;
|
2005-05-25 09:20:50 +00:00
|
|
|
}
|
2009-02-12 15:41:59 +00:00
|
|
|
|
2011-10-22 00:51:37 +00:00
|
|
|
/* Reconfiguring filter/VO chain may invalidate direct rendering buffers
|
|
|
|
* we have allocated for libavcodec (including the VDPAU HW decoding
|
|
|
|
* case). Is it guaranteed that the code below only triggers in a situation
|
|
|
|
* with no busy direct rendering buffers for reference frames?
|
|
|
|
*/
|
2007-02-20 20:09:29 +00:00
|
|
|
if (av_cmp_q(avctx->sample_aspect_ratio, ctx->last_sample_aspect_ratio) ||
|
2011-10-22 00:51:37 +00:00
|
|
|
width != sh->disp_w || height != sh->disp_h ||
|
|
|
|
pix_fmt != ctx->pix_fmt || !ctx->vo_initialized) {
|
2010-12-11 18:37:00 +00:00
|
|
|
ctx->vo_initialized = 0;
|
2009-02-12 15:39:32 +00:00
|
|
|
mp_msg(MSGT_DECVIDEO, MSGL_V, "[ffmpeg] aspect_ratio: %f\n", aspect);
|
2010-10-22 17:36:11 +00:00
|
|
|
|
|
|
|
// Do not overwrite s->aspect on the first call, so that a container
|
|
|
|
// aspect if available is preferred.
|
|
|
|
// But set it even if the sample aspect did not change, since a
|
|
|
|
// resolution change can cause an aspect change even if the
|
|
|
|
// _sample_ aspect is unchanged.
|
|
|
|
if (sh->aspect == 0 || ctx->last_sample_aspect_ratio.den)
|
2009-02-12 15:39:32 +00:00
|
|
|
sh->aspect = aspect;
|
|
|
|
ctx->last_sample_aspect_ratio = avctx->sample_aspect_ratio;
|
|
|
|
sh->disp_w = width;
|
|
|
|
sh->disp_h = height;
|
|
|
|
ctx->pix_fmt = pix_fmt;
|
2009-02-14 17:58:33 +00:00
|
|
|
ctx->best_csp = pixfmt2imgfmt(pix_fmt);
|
2011-06-25 21:46:40 +00:00
|
|
|
const unsigned int *supported_fmts;
|
|
|
|
if (ctx->best_csp == IMGFMT_YV12)
|
2011-10-22 00:51:37 +00:00
|
|
|
supported_fmts = (const unsigned int[]){
|
|
|
|
IMGFMT_YV12, IMGFMT_I420, IMGFMT_IYUV, 0xffffffff
|
|
|
|
};
|
2011-06-25 21:46:40 +00:00
|
|
|
else if (ctx->best_csp == IMGFMT_422P)
|
2011-10-22 00:51:37 +00:00
|
|
|
supported_fmts = (const unsigned int[]){
|
|
|
|
IMGFMT_422P, IMGFMT_YV12, IMGFMT_I420, IMGFMT_IYUV, 0xffffffff
|
|
|
|
};
|
2011-06-25 21:46:40 +00:00
|
|
|
else
|
|
|
|
supported_fmts = (const unsigned int[]){ctx->best_csp, 0xffffffff};
|
|
|
|
if (!mpcodecs_config_vo2(sh, sh->disp_w, sh->disp_h, supported_fmts,
|
|
|
|
ctx->best_csp))
|
2009-02-14 17:29:59 +00:00
|
|
|
return -1;
|
2009-02-12 15:39:32 +00:00
|
|
|
ctx->vo_initialized = 1;
|
2002-04-13 13:40:26 +00:00
|
|
|
}
|
2002-07-14 19:44:40 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-10-22 00:51:37 +00:00
|
|
|
static int get_buffer(AVCodecContext *avctx, AVFrame *pic)
|
|
|
|
{
|
2009-02-14 17:43:06 +00:00
|
|
|
sh_video_t *sh = avctx->opaque;
|
2002-07-14 21:30:54 +00:00
|
|
|
vd_ffmpeg_ctx *ctx = sh->context;
|
2011-10-22 00:51:37 +00:00
|
|
|
mp_image_t *mpi = NULL;
|
|
|
|
int flags = MP_IMGFLAG_ACCEPT_ALIGNED_STRIDE |
|
|
|
|
MP_IMGFLAG_PREFER_ALIGNED_STRIDE;
|
|
|
|
int type = MP_IMGTYPE_IPB;
|
|
|
|
int width = avctx->width;
|
|
|
|
int height = avctx->height;
|
2011-04-22 08:05:56 +00:00
|
|
|
// special case to handle reget_buffer without buffer hints
|
|
|
|
if (pic->opaque && pic->data[0] && !pic->buffer_hints)
|
|
|
|
return 0;
|
2009-11-17 13:56:34 +00:00
|
|
|
avcodec_align_dimensions(avctx, &width, &height);
|
2002-07-15 21:33:46 +00:00
|
|
|
|
2009-02-14 17:29:59 +00:00
|
|
|
if (pic->buffer_hints) {
|
2011-10-22 00:51:37 +00:00
|
|
|
mp_msg(MSGT_DECVIDEO, MSGL_DBG2, "Buffer hints: %u\n",
|
|
|
|
pic->buffer_hints);
|
2009-02-14 17:29:59 +00:00
|
|
|
type = MP_IMGTYPE_TEMP;
|
|
|
|
if (pic->buffer_hints & FF_BUFFER_HINTS_READABLE)
|
|
|
|
flags |= MP_IMGFLAG_READABLE;
|
|
|
|
if (pic->buffer_hints & FF_BUFFER_HINTS_PRESERVE) {
|
|
|
|
type = MP_IMGTYPE_STATIC;
|
|
|
|
flags |= MP_IMGFLAG_PRESERVE;
|
|
|
|
}
|
|
|
|
if (pic->buffer_hints & FF_BUFFER_HINTS_REUSABLE) {
|
|
|
|
type = MP_IMGTYPE_STATIC;
|
|
|
|
flags |= MP_IMGFLAG_PRESERVE;
|
|
|
|
}
|
2011-04-19 23:59:45 +00:00
|
|
|
flags |= ctx->do_slices ? MP_IMGFLAG_DRAW_CALLBACK : 0;
|
2011-10-22 00:51:37 +00:00
|
|
|
mp_msg(MSGT_DECVIDEO, MSGL_DBG2,
|
|
|
|
type == MP_IMGTYPE_STATIC ? "using STATIC\n" : "using TEMP\n");
|
2009-02-14 17:29:59 +00:00
|
|
|
} else {
|
2011-10-22 00:51:37 +00:00
|
|
|
if (!pic->reference) {
|
2009-02-14 17:29:59 +00:00
|
|
|
ctx->b_count++;
|
2011-10-22 00:51:37 +00:00
|
|
|
flags |= ctx->do_slices ? MP_IMGFLAG_DRAW_CALLBACK : 0;
|
|
|
|
} else {
|
2009-02-14 17:29:59 +00:00
|
|
|
ctx->ip_count++;
|
2011-10-22 00:51:37 +00:00
|
|
|
flags |= MP_IMGFLAG_PRESERVE | MP_IMGFLAG_READABLE
|
|
|
|
| (ctx->do_slices ? MP_IMGFLAG_DRAW_CALLBACK : 0);
|
2009-02-14 17:29:59 +00:00
|
|
|
}
|
2003-04-25 00:57:04 +00:00
|
|
|
}
|
|
|
|
|
2011-10-22 00:51:37 +00:00
|
|
|
if (init_vo(sh, avctx->pix_fmt) < 0) {
|
|
|
|
avctx->release_buffer = avcodec_default_release_buffer;
|
|
|
|
avctx->get_buffer = avcodec_default_get_buffer;
|
|
|
|
avctx->reget_buffer = avcodec_default_reget_buffer;
|
2011-04-22 07:58:06 +00:00
|
|
|
if (pic->data[0])
|
|
|
|
release_buffer(avctx, pic);
|
2003-04-26 10:32:45 +00:00
|
|
|
return avctx->get_buffer(avctx, pic);
|
|
|
|
}
|
2006-07-13 23:02:03 +00:00
|
|
|
|
2011-10-22 00:51:37 +00:00
|
|
|
if (IMGFMT_IS_HWACCEL(ctx->best_csp))
|
2009-02-15 14:10:47 +00:00
|
|
|
type = MP_IMGTYPE_NUMBERED | (0xffff << 16);
|
2011-10-22 00:51:37 +00:00
|
|
|
else if (!pic->buffer_hints) {
|
|
|
|
if (ctx->b_count > 1 || ctx->ip_count > 2) {
|
2009-07-06 22:15:02 +00:00
|
|
|
mp_tmsg(MSGT_DECVIDEO, MSGL_WARN, "[VD_FFMPEG] DRI failure.\n");
|
2003-04-25 00:57:04 +00:00
|
|
|
|
2011-10-22 00:51:37 +00:00
|
|
|
ctx->do_dr1 = 0; //FIXME
|
|
|
|
avctx->get_buffer = avcodec_default_get_buffer;
|
|
|
|
avctx->reget_buffer = avcodec_default_reget_buffer;
|
2011-04-22 07:58:06 +00:00
|
|
|
if (pic->data[0])
|
|
|
|
release_buffer(avctx, pic);
|
2009-02-14 17:29:59 +00:00
|
|
|
return avctx->get_buffer(avctx, pic);
|
|
|
|
}
|
2002-07-14 19:44:40 +00:00
|
|
|
|
2011-10-22 00:51:37 +00:00
|
|
|
if (avctx->has_b_frames || ctx->b_count)
|
|
|
|
type = MP_IMGTYPE_IPB;
|
|
|
|
else
|
|
|
|
type = MP_IMGTYPE_IP;
|
|
|
|
mp_msg(MSGT_DECVIDEO, MSGL_DBG2,
|
|
|
|
type == MP_IMGTYPE_IPB ? "using IPB\n" : "using IP\n");
|
2002-07-15 14:30:12 +00:00
|
|
|
}
|
|
|
|
|
2009-12-26 11:51:19 +00:00
|
|
|
if (ctx->best_csp == IMGFMT_RGB8 || ctx->best_csp == IMGFMT_BGR8)
|
|
|
|
flags |= MP_IMGFLAG_RGB_PALETTE;
|
2011-10-22 00:51:37 +00:00
|
|
|
mpi = mpcodecs_get_image(sh, type, flags, width, height);
|
|
|
|
if (!mpi)
|
|
|
|
return -1;
|
2002-07-14 19:44:40 +00:00
|
|
|
|
2003-10-04 17:29:08 +00:00
|
|
|
// ok, let's see what did we get:
|
2011-10-22 00:51:37 +00:00
|
|
|
if (mpi->flags & MP_IMGFLAG_DRAW_CALLBACK &&
|
|
|
|
!(mpi->flags & MP_IMGFLAG_DIRECT)) {
|
2009-02-12 15:39:32 +00:00
|
|
|
// nice, filter/vo likes draw_callback :)
|
2011-10-22 00:51:37 +00:00
|
|
|
avctx->draw_horiz_band = draw_slice;
|
2002-07-14 19:44:40 +00:00
|
|
|
} else
|
2011-10-22 00:51:37 +00:00
|
|
|
avctx->draw_horiz_band = NULL;
|
|
|
|
if (IMGFMT_IS_HWACCEL(mpi->imgfmt))
|
|
|
|
avctx->draw_horiz_band = draw_slice;
|
|
|
|
|
|
|
|
pic->data[0] = mpi->planes[0];
|
|
|
|
pic->data[1] = mpi->planes[1];
|
|
|
|
pic->data[2] = mpi->planes[2];
|
|
|
|
pic->data[3] = mpi->planes[3];
|
2002-07-14 21:30:54 +00:00
|
|
|
|
2011-10-22 00:51:37 +00:00
|
|
|
/* Note: some (many) codecs in libavcodec require
|
|
|
|
* linesize[1] == linesize[2] and no changes between frames.
|
|
|
|
* Lavc will check that and die with an error message if it's not true.
|
2002-12-04 10:49:03 +00:00
|
|
|
*/
|
2011-10-22 00:51:37 +00:00
|
|
|
pic->linesize[0] = mpi->stride[0];
|
|
|
|
pic->linesize[1] = mpi->stride[1];
|
|
|
|
pic->linesize[2] = mpi->stride[2];
|
|
|
|
pic->linesize[3] = mpi->stride[3];
|
2002-07-14 21:30:54 +00:00
|
|
|
|
2002-12-04 10:49:03 +00:00
|
|
|
pic->opaque = mpi;
|
2009-02-12 15:41:59 +00:00
|
|
|
|
2011-10-22 00:51:37 +00:00
|
|
|
pic->type = FF_BUFFER_TYPE_USER;
|
2009-11-21 18:53:10 +00:00
|
|
|
|
|
|
|
/* The libavcodec reordered_opaque functionality is implemented by
|
|
|
|
* a similar copy in avcodec_default_get_buffer() and without a
|
|
|
|
* workaround like this it'd stop working when a custom buffer
|
|
|
|
* callback is used.
|
|
|
|
*/
|
|
|
|
pic->reordered_opaque = avctx->reordered_opaque;
|
2002-10-27 00:37:51 +00:00
|
|
|
return 0;
|
2002-12-04 10:49:03 +00:00
|
|
|
}
|
|
|
|
|
2011-10-22 00:51:37 +00:00
|
|
|
static void release_buffer(struct AVCodecContext *avctx, AVFrame *pic)
|
|
|
|
{
|
|
|
|
mp_image_t *mpi = pic->opaque;
|
2009-02-14 17:43:06 +00:00
|
|
|
sh_video_t *sh = avctx->opaque;
|
2003-04-25 00:57:04 +00:00
|
|
|
vd_ffmpeg_ctx *ctx = sh->context;
|
|
|
|
|
2011-10-22 00:51:37 +00:00
|
|
|
if (ctx->ip_count <= 2 && ctx->b_count <= 1) {
|
|
|
|
if (mpi->flags & MP_IMGFLAG_PRESERVE)
|
2009-02-14 17:29:59 +00:00
|
|
|
ctx->ip_count--;
|
|
|
|
else
|
|
|
|
ctx->b_count--;
|
|
|
|
}
|
2003-11-09 23:55:28 +00:00
|
|
|
|
2009-02-15 13:14:17 +00:00
|
|
|
if (mpi) {
|
2009-02-12 15:39:32 +00:00
|
|
|
// Palette support: free palette buffer allocated in get_buffer
|
2009-02-15 13:17:04 +00:00
|
|
|
if (mpi->bpp == 8)
|
|
|
|
av_freep(&mpi->planes[1]);
|
2009-02-15 13:24:17 +00:00
|
|
|
// release mpi (in case MPI_IMGTYPE_NUMBERED is used, e.g. for VDPAU)
|
2009-03-18 17:02:29 +00:00
|
|
|
mpi->usage_count--;
|
2009-02-15 13:17:04 +00:00
|
|
|
}
|
2003-11-09 23:55:28 +00:00
|
|
|
|
2011-10-22 00:51:37 +00:00
|
|
|
if (pic->type != FF_BUFFER_TYPE_USER) {
|
2003-04-25 00:57:04 +00:00
|
|
|
avcodec_default_release_buffer(avctx, pic);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2011-10-22 00:51:37 +00:00
|
|
|
for (int i = 0; i < 4; i++)
|
|
|
|
pic->data[i] = NULL;
|
2002-07-14 19:44:40 +00:00
|
|
|
}
|
|
|
|
|
2010-06-29 12:13:57 +00:00
|
|
|
static av_unused void swap_palette(void *pal)
|
2010-05-29 14:15:55 +00:00
|
|
|
{
|
2007-01-31 18:14:47 +00:00
|
|
|
int i;
|
|
|
|
uint32_t *p = pal;
|
|
|
|
for (i = 0; i < AVPALETTE_COUNT; i++)
|
|
|
|
p[i] = le2me_32(p[i]);
|
|
|
|
}
|
2004-08-29 13:52:19 +00:00
|
|
|
|
2011-08-20 17:25:43 +00:00
|
|
|
static struct mp_image *decode(struct sh_video *sh, struct demux_packet *packet,
|
|
|
|
void *data, int len, int flags,
|
|
|
|
double *reordered_pts)
|
2009-11-21 18:53:10 +00:00
|
|
|
{
|
2011-10-22 00:51:37 +00:00
|
|
|
int got_picture = 0;
|
2002-07-14 19:44:40 +00:00
|
|
|
int ret;
|
|
|
|
vd_ffmpeg_ctx *ctx = sh->context;
|
2011-10-22 00:51:37 +00:00
|
|
|
AVFrame *pic = ctx->pic;
|
2002-07-14 19:44:40 +00:00
|
|
|
AVCodecContext *avctx = ctx->avctx;
|
2008-04-24 00:59:21 +00:00
|
|
|
struct lavc_param *lavc_param = &sh->opts->lavc_param;
|
2011-10-22 00:51:37 +00:00
|
|
|
mp_image_t *mpi = NULL;
|
|
|
|
int dr1 = ctx->do_dr1;
|
2009-06-01 22:25:10 +00:00
|
|
|
AVPacket pkt;
|
2002-07-14 19:44:40 +00:00
|
|
|
|
2004-03-16 15:34:55 +00:00
|
|
|
if (!dr1)
|
2011-10-22 00:51:37 +00:00
|
|
|
avctx->draw_horiz_band = NULL;
|
2002-07-14 19:44:40 +00:00
|
|
|
|
2010-05-04 01:50:57 +00:00
|
|
|
if (flags & 2)
|
|
|
|
avctx->skip_frame = AVDISCARD_ALL;
|
|
|
|
else if (flags & 1)
|
|
|
|
avctx->skip_frame = AVDISCARD_NONREF;
|
|
|
|
else
|
2011-07-09 10:50:16 +00:00
|
|
|
avctx->skip_frame = ctx->skip_frame;
|
2002-07-14 19:44:40 +00:00
|
|
|
|
2009-06-01 22:25:10 +00:00
|
|
|
av_init_packet(&pkt);
|
|
|
|
pkt.data = data;
|
|
|
|
pkt.size = len;
|
2012-07-24 21:23:27 +00:00
|
|
|
/* Some codecs (ZeroCodec, some cases of PNG) may want keyframe info
|
|
|
|
* from demuxer. */
|
|
|
|
if (packet && packet->keyframe)
|
|
|
|
pkt.flags |= AV_PKT_FLAG_KEY;
|
2011-08-20 17:25:43 +00:00
|
|
|
if (packet && packet->avpacket) {
|
|
|
|
pkt.side_data = packet->avpacket->side_data;
|
|
|
|
pkt.side_data_elems = packet->avpacket->side_data_elems;
|
|
|
|
}
|
2009-11-21 18:53:10 +00:00
|
|
|
// The avcodec opaque field stupidly supports only int64_t type
|
2011-05-04 20:12:55 +00:00
|
|
|
union pts { int64_t i; double d; };
|
|
|
|
avctx->reordered_opaque = (union pts){.d = *reordered_pts}.i;
|
2009-06-01 22:25:10 +00:00
|
|
|
ret = avcodec_decode_video2(avctx, pic, &got_picture, &pkt);
|
2011-05-04 20:12:55 +00:00
|
|
|
*reordered_pts = (union pts){.i = pic->reordered_opaque}.d;
|
2004-08-29 13:52:19 +00:00
|
|
|
|
2011-10-22 00:51:37 +00:00
|
|
|
dr1 = ctx->do_dr1;
|
|
|
|
if (ret < 0)
|
|
|
|
mp_msg(MSGT_DECVIDEO, MSGL_WARN, "Error while decoding frame!\n");
|
|
|
|
//-- vstats generation
|
|
|
|
while (lavc_param->vstats) { // always one time loop
|
|
|
|
static FILE *fvstats = NULL;
|
2002-07-28 15:54:26 +00:00
|
|
|
char filename[20];
|
2011-10-22 00:51:37 +00:00
|
|
|
static long long int all_len = 0;
|
|
|
|
static int frame_number = 0;
|
|
|
|
static double all_frametime = 0.0;
|
|
|
|
AVFrame *pic = avctx->coded_frame;
|
|
|
|
double quality = 0.0;
|
2002-07-28 15:54:26 +00:00
|
|
|
|
2011-05-01 20:21:00 +00:00
|
|
|
if (!pic)
|
|
|
|
break;
|
|
|
|
|
2011-10-22 00:51:37 +00:00
|
|
|
if (!fvstats) {
|
2002-07-28 15:54:26 +00:00
|
|
|
time_t today2;
|
|
|
|
struct tm *today;
|
|
|
|
today2 = time(NULL);
|
|
|
|
today = localtime(&today2);
|
|
|
|
sprintf(filename, "vstats_%02d%02d%02d.log", today->tm_hour,
|
2011-10-22 00:51:37 +00:00
|
|
|
today->tm_min, today->tm_sec);
|
2009-02-14 17:43:06 +00:00
|
|
|
fvstats = fopen(filename, "w");
|
2011-10-22 00:51:37 +00:00
|
|
|
if (!fvstats) {
|
2002-07-28 15:54:26 +00:00
|
|
|
perror("fopen");
|
2011-10-22 00:51:37 +00:00
|
|
|
lavc_param->vstats = 0; // disable block
|
2002-07-28 15:54:26 +00:00
|
|
|
break;
|
|
|
|
/*exit(1);*/
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-02-12 15:39:32 +00:00
|
|
|
// average MB quantizer
|
|
|
|
{
|
|
|
|
int x, y;
|
2011-10-22 00:51:37 +00:00
|
|
|
int w = ((avctx->width << avctx->lowres) + 15) >> 4;
|
|
|
|
int h = ((avctx->height << avctx->lowres) + 15) >> 4;
|
2009-02-12 15:39:32 +00:00
|
|
|
int8_t *q = pic->qscale_table;
|
2011-10-22 00:51:37 +00:00
|
|
|
for (y = 0; y < h; y++) {
|
|
|
|
for (x = 0; x < w; x++)
|
|
|
|
quality += (double)*(q + x);
|
2009-02-12 15:39:32 +00:00
|
|
|
q += pic->qstride;
|
|
|
|
}
|
|
|
|
quality /= w * h;
|
|
|
|
}
|
2003-04-06 23:37:56 +00:00
|
|
|
|
2011-10-22 00:51:37 +00:00
|
|
|
all_len += len;
|
|
|
|
all_frametime += sh->frametime;
|
2002-12-09 09:12:23 +00:00
|
|
|
fprintf(fvstats, "frame= %5d q= %2.2f f_size= %6d s_size= %8.0fkB ",
|
2011-10-22 00:51:37 +00:00
|
|
|
++frame_number, quality, len, (double)all_len / 1024);
|
2002-07-28 21:56:18 +00:00
|
|
|
fprintf(fvstats, "time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
|
2011-10-22 00:51:37 +00:00
|
|
|
all_frametime, (double)(len * 8) / sh->frametime / 1000.0,
|
|
|
|
(double)(all_len * 8) / all_frametime / 1000.0);
|
|
|
|
switch (pic->pict_type) {
|
2012-01-28 11:41:36 +00:00
|
|
|
case AV_PICTURE_TYPE_I:
|
2002-11-03 00:15:55 +00:00
|
|
|
fprintf(fvstats, "type= I\n");
|
2009-02-12 15:39:32 +00:00
|
|
|
break;
|
2012-01-28 11:41:36 +00:00
|
|
|
case AV_PICTURE_TYPE_P:
|
2002-11-03 00:15:55 +00:00
|
|
|
fprintf(fvstats, "type= P\n");
|
2009-02-12 15:39:32 +00:00
|
|
|
break;
|
2012-01-28 11:41:36 +00:00
|
|
|
case AV_PICTURE_TYPE_S:
|
2002-11-03 00:15:55 +00:00
|
|
|
fprintf(fvstats, "type= S\n");
|
2009-02-12 15:39:32 +00:00
|
|
|
break;
|
2012-01-28 11:41:36 +00:00
|
|
|
case AV_PICTURE_TYPE_B:
|
2002-11-03 00:15:55 +00:00
|
|
|
fprintf(fvstats, "type= B\n");
|
2009-02-12 15:39:32 +00:00
|
|
|
break;
|
|
|
|
default:
|
2003-04-06 23:37:56 +00:00
|
|
|
fprintf(fvstats, "type= ? (%d)\n", pic->pict_type);
|
2009-02-12 15:39:32 +00:00
|
|
|
break;
|
|
|
|
}
|
2009-02-12 15:41:59 +00:00
|
|
|
|
2011-10-22 00:51:37 +00:00
|
|
|
ctx->qp_stat[(int)(quality + 0.5)]++;
|
2003-04-06 23:37:56 +00:00
|
|
|
ctx->qp_sum += quality;
|
2011-10-22 00:51:37 +00:00
|
|
|
ctx->inv_qp_sum += 1.0 / (double)quality;
|
2009-02-12 15:41:59 +00:00
|
|
|
|
2002-07-28 15:54:26 +00:00
|
|
|
break;
|
|
|
|
}
|
2011-10-22 00:51:37 +00:00
|
|
|
//--
|
2002-07-28 15:54:26 +00:00
|
|
|
|
2011-10-22 00:51:37 +00:00
|
|
|
if (!got_picture)
|
|
|
|
return NULL; // skipped image
|
2002-07-15 21:33:46 +00:00
|
|
|
|
2011-10-22 00:51:37 +00:00
|
|
|
if (init_vo(sh, avctx->pix_fmt) < 0)
|
|
|
|
return NULL;
|
2002-07-14 19:44:40 +00:00
|
|
|
|
2011-10-22 00:51:37 +00:00
|
|
|
if (dr1 && pic->opaque)
|
|
|
|
mpi = (mp_image_t *)pic->opaque;
|
2009-02-12 15:41:59 +00:00
|
|
|
|
2011-10-22 00:51:37 +00:00
|
|
|
if (!mpi)
|
|
|
|
mpi = mpcodecs_get_image(sh, MP_IMGTYPE_EXPORT, MP_IMGFLAG_PRESERVE,
|
|
|
|
avctx->width, avctx->height);
|
|
|
|
if (!mpi) { // temporary error?
|
|
|
|
mp_tmsg(MSGT_DECVIDEO, MSGL_WARN,
|
|
|
|
"[VD_FFMPEG] Couldn't allocate image for codec.\n");
|
2009-02-12 15:39:32 +00:00
|
|
|
return NULL;
|
2002-03-06 20:54:43 +00:00
|
|
|
}
|
2009-02-12 15:41:59 +00:00
|
|
|
|
2011-10-22 00:51:37 +00:00
|
|
|
if (!dr1) {
|
|
|
|
mpi->planes[0] = pic->data[0];
|
|
|
|
mpi->planes[1] = pic->data[1];
|
|
|
|
mpi->planes[2] = pic->data[2];
|
|
|
|
mpi->planes[3] = pic->data[3];
|
|
|
|
mpi->stride[0] = pic->linesize[0];
|
|
|
|
mpi->stride[1] = pic->linesize[1];
|
|
|
|
mpi->stride[2] = pic->linesize[2];
|
|
|
|
mpi->stride[3] = pic->linesize[3];
|
2002-07-14 19:44:40 +00:00
|
|
|
}
|
2009-02-12 15:41:59 +00:00
|
|
|
|
2003-11-03 10:42:28 +00:00
|
|
|
if (!mpi->planes[0])
|
2009-02-12 15:39:32 +00:00
|
|
|
return NULL;
|
2002-03-06 20:54:43 +00:00
|
|
|
|
2011-10-22 00:51:37 +00:00
|
|
|
if (ctx->best_csp == IMGFMT_422P && mpi->chroma_y_shift == 1) {
|
2009-02-12 15:39:32 +00:00
|
|
|
// we have 422p but user wants 420p
|
2011-10-22 00:51:37 +00:00
|
|
|
mpi->stride[1] *= 2;
|
|
|
|
mpi->stride[2] *= 2;
|
2002-03-06 20:54:43 +00:00
|
|
|
}
|
2009-02-12 15:41:59 +00:00
|
|
|
|
Remove compile time/runtime CPU detection, and drop some platforms
mplayer had three ways of enabling CPU specific assembler routines:
a) Enable them at compile time; crash if the CPU can't handle it.
b) Enable them at compile time, but let the configure script detect
your CPU. Your binary will only crash if you try to run it on a
different system that has less features than yours.
This was the default, I think.
c) Runtime detection.
The implementation of b) and c) suck. a) is not really feasible (it
sucks for users). Remove all code related to this, and use libav's CPU
detection instead. Now the configure script will always enable CPU
specific features, and disable them at runtime if libav reports them
not as available.
One implication is that now the compiler is always expected to handle
SSE (etc.) inline assembly at runtime, unless it's explicitly disabled.
Only checks for x86 CPU specific features are kept, the rest is either
unused or barely used.
Get rid of all the dump -mpcu, -march etc. flags. Trust the compiler
to select decent settings.
Get rid of support for the following operating systems:
- BSD/OS (some ancient BSD fork)
- QNX (don't care)
- BeOS (dead, Haiku support is still welcome)
- AIX (don't care)
- HP-UX (don't care)
- OS/2 (dead, actual support has been removed a while ago)
Remove the configure code for detecting the endianness. Instead, use
the standard header <endian.h>, which can be used if _GNU_SOURCE or
_BSD_SOURCE is defined. (Maybe these changes should have been in a
separate commit.)
Since this is a quite violent code removal orgy, and I'm testing only
on x86 32 bit Linux, expect regressions.
2012-07-29 15:20:57 +00:00
|
|
|
#if BYTE_ORDER == BIG_ENDIAN
|
2007-01-31 18:14:47 +00:00
|
|
|
// FIXME: this might cause problems for buffers with FF_BUFFER_HINTS_PRESERVE
|
|
|
|
if (mpi->bpp == 8)
|
|
|
|
swap_palette(mpi->planes[1]);
|
|
|
|
#endif
|
2011-10-22 00:51:37 +00:00
|
|
|
|
|
|
|
mpi->qscale = pic->qscale_table;
|
|
|
|
mpi->qstride = pic->qstride;
|
|
|
|
mpi->pict_type = pic->pict_type;
|
|
|
|
mpi->qscale_type = pic->qscale_type;
|
2003-12-22 17:26:19 +00:00
|
|
|
mpi->fields = MP_IMGFIELD_ORDERED;
|
2011-10-22 00:51:37 +00:00
|
|
|
if (pic->interlaced_frame)
|
|
|
|
mpi->fields |= MP_IMGFIELD_INTERLACED;
|
|
|
|
if (pic->top_field_first)
|
|
|
|
mpi->fields |= MP_IMGFIELD_TOP_FIRST;
|
|
|
|
if (pic->repeat_pict == 1)
|
|
|
|
mpi->fields |= MP_IMGFIELD_REPEAT_FIRST;
|
2006-07-13 23:02:03 +00:00
|
|
|
|
2002-03-06 20:54:43 +00:00
|
|
|
return mpi;
|
|
|
|
}
|
|
|
|
|
2009-02-14 17:43:06 +00:00
|
|
|
static enum PixelFormat get_format(struct AVCodecContext *avctx,
|
2011-10-22 00:51:37 +00:00
|
|
|
const enum PixelFormat *fmt)
|
|
|
|
{
|
2009-02-14 17:43:06 +00:00
|
|
|
sh_video_t *sh = avctx->opaque;
|
2009-02-14 17:29:59 +00:00
|
|
|
int i;
|
2004-03-01 14:58:20 +00:00
|
|
|
|
2011-10-22 00:51:37 +00:00
|
|
|
for (i = 0; fmt[i] != PIX_FMT_NONE; i++) {
|
|
|
|
int imgfmt = pixfmt2imgfmt(fmt[i]);
|
|
|
|
if (!IMGFMT_IS_HWACCEL(imgfmt))
|
|
|
|
continue;
|
2010-01-20 15:21:39 +00:00
|
|
|
mp_msg(MSGT_DECVIDEO, MSGL_V, "[VD_FFMPEG] Trying pixfmt=%d.\n", i);
|
2011-10-22 00:51:37 +00:00
|
|
|
if (init_vo(sh, fmt[i]) >= 0)
|
2009-02-15 17:23:05 +00:00
|
|
|
break;
|
|
|
|
}
|
2011-10-22 00:51:37 +00:00
|
|
|
return fmt[i];
|
2003-07-01 22:05:46 +00:00
|
|
|
}
|
2009-11-21 18:53:10 +00:00
|
|
|
|
2011-11-14 18:12:20 +00:00
|
|
|
static int control(sh_video_t *sh, int cmd, void *arg, ...)
|
|
|
|
{
|
|
|
|
vd_ffmpeg_ctx *ctx = sh->context;
|
|
|
|
AVCodecContext *avctx = ctx->avctx;
|
|
|
|
switch (cmd) {
|
|
|
|
case VDCTRL_QUERY_FORMAT: {
|
|
|
|
int format = (*((int *)arg));
|
|
|
|
if (format == ctx->best_csp)
|
|
|
|
return CONTROL_TRUE;
|
|
|
|
// possible conversions:
|
|
|
|
switch (format) {
|
|
|
|
case IMGFMT_YV12:
|
|
|
|
case IMGFMT_IYUV:
|
|
|
|
case IMGFMT_I420:
|
|
|
|
// "converted" using pointer/stride modification
|
|
|
|
if (ctx->best_csp == IMGFMT_YV12)
|
|
|
|
return CONTROL_TRUE; // u/v swap
|
|
|
|
if (ctx->best_csp == IMGFMT_422P && !ctx->do_dr1)
|
|
|
|
return CONTROL_TRUE; // half stride
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return CONTROL_FALSE;
|
|
|
|
}
|
|
|
|
case VDCTRL_RESYNC_STREAM:
|
|
|
|
avcodec_flush_buffers(avctx);
|
|
|
|
return CONTROL_TRUE;
|
|
|
|
case VDCTRL_QUERY_UNSEEN_FRAMES:;
|
|
|
|
int delay = avctx->has_b_frames;
|
2012-02-03 18:03:00 +00:00
|
|
|
if (avctx->active_thread_type & FF_THREAD_FRAME)
|
|
|
|
delay += avctx->thread_count - 1;
|
2011-11-14 18:12:20 +00:00
|
|
|
return delay + 10;
|
|
|
|
case VDCTRL_RESET_ASPECT:
|
|
|
|
if (ctx->vo_initialized)
|
|
|
|
ctx->vo_initialized = false;
|
|
|
|
init_vo(sh, avctx->pix_fmt);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return CONTROL_UNKNOWN;
|
|
|
|
}
|
|
|
|
|
2009-11-21 18:53:10 +00:00
|
|
|
const struct vd_functions mpcodecs_vd_ffmpeg = {
|
|
|
|
.info = &info,
|
|
|
|
.init = init,
|
|
|
|
.uninit = uninit,
|
|
|
|
.control = control,
|
|
|
|
.decode2 = decode
|
|
|
|
};
|