2012-02-05 13:31:33 +03:00
|
|
|
/*
|
2014-02-18 13:52:30 +03:00
|
|
|
* VP7/VP8 compatible video decoder
|
2010-06-22 22:24:09 +03:00
|
|
|
*
|
|
|
|
* Copyright (C) 2010 David Conrad
|
|
|
|
* Copyright (C) 2010 Ronald S. Bultje
|
2014-07-01 12:52:37 +03:00
|
|
|
* Copyright (C) 2010 Fiona Glaser
|
2012-07-12 23:07:06 +03:00
|
|
|
* Copyright (C) 2012 Daniel Kang
|
2014-02-18 13:52:30 +03:00
|
|
|
* Copyright (C) 2014 Peter Ross
|
2010-06-22 22:24:09 +03:00
|
|
|
*
|
|
|
|
* 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
|
|
|
|
*/
|
|
|
|
|
2022-02-23 14:56:49 +02:00
|
|
|
#include "config_components.h"
|
|
|
|
|
2011-02-07 15:37:08 +02:00
|
|
|
#include "libavutil/imgutils.h"
|
2020-06-10 15:38:08 +02:00
|
|
|
#include "libavutil/mem_internal.h"
|
2014-03-28 03:13:54 +03:00
|
|
|
|
2010-06-22 22:24:09 +03:00
|
|
|
#include "avcodec.h"
|
2022-03-16 19:18:28 +02:00
|
|
|
#include "codec_internal.h"
|
2020-04-13 17:33:14 +02:00
|
|
|
#include "hwconfig.h"
|
2011-11-15 23:34:50 +03:00
|
|
|
#include "internal.h"
|
2016-03-24 12:16:53 +02:00
|
|
|
#include "mathops.h"
|
2010-06-22 22:24:09 +03:00
|
|
|
#include "rectangle.h"
|
2011-05-02 16:55:52 +03:00
|
|
|
#include "thread.h"
|
2022-02-06 08:08:01 +02:00
|
|
|
#include "threadframe.h"
|
2014-03-28 03:13:54 +03:00
|
|
|
#include "vp8.h"
|
2022-07-23 00:04:29 +02:00
|
|
|
#include "vp89_rac.h"
|
2014-03-28 03:13:54 +03:00
|
|
|
#include "vp8data.h"
|
2022-07-23 01:28:48 +02:00
|
|
|
#include "vpx_rac.h"
|
2010-06-22 22:24:09 +03:00
|
|
|
|
2011-02-02 00:38:15 +02:00
|
|
|
#if ARCH_ARM
|
|
|
|
# include "arm/vp8.h"
|
|
|
|
#endif
|
|
|
|
|
2014-02-18 13:52:30 +03:00
|
|
|
#if CONFIG_VP7_DECODER && CONFIG_VP8_DECODER
|
|
|
|
#define VPX(vp7, f) (vp7 ? vp7_ ## f : vp8_ ## f)
|
|
|
|
#elif CONFIG_VP7_DECODER
|
|
|
|
#define VPX(vp7, f) vp7_ ## f
|
|
|
|
#else // CONFIG_VP8_DECODER
|
|
|
|
#define VPX(vp7, f) vp8_ ## f
|
|
|
|
#endif
|
|
|
|
|
2022-07-22 23:29:29 +02:00
|
|
|
// fixme: add 1 bit to all the calls to this?
|
2022-07-23 01:28:48 +02:00
|
|
|
static int vp8_rac_get_sint(VPXRangeCoder *c, int bits)
|
2022-07-22 23:29:29 +02:00
|
|
|
{
|
|
|
|
int v;
|
|
|
|
|
2022-07-23 00:04:29 +02:00
|
|
|
if (!vp89_rac_get(c))
|
2022-07-22 23:29:29 +02:00
|
|
|
return 0;
|
|
|
|
|
2022-07-23 00:04:29 +02:00
|
|
|
v = vp89_rac_get_uint(c, bits);
|
2022-07-22 23:29:29 +02:00
|
|
|
|
2022-07-23 00:04:29 +02:00
|
|
|
if (vp89_rac_get(c))
|
2022-07-22 23:29:29 +02:00
|
|
|
v = -v;
|
|
|
|
|
|
|
|
return v;
|
|
|
|
}
|
|
|
|
|
2022-07-23 01:28:48 +02:00
|
|
|
static int vp8_rac_get_nn(VPXRangeCoder *c)
|
2022-07-22 23:29:29 +02:00
|
|
|
{
|
2022-07-23 00:04:29 +02:00
|
|
|
int v = vp89_rac_get_uint(c, 7) << 1;
|
2022-07-22 23:29:29 +02:00
|
|
|
return v + !v;
|
|
|
|
}
|
|
|
|
|
|
|
|
// DCTextra
|
2022-07-23 01:28:48 +02:00
|
|
|
static int vp8_rac_get_coeff(VPXRangeCoder *c, const uint8_t *prob)
|
2022-07-22 23:29:29 +02:00
|
|
|
{
|
|
|
|
int v = 0;
|
|
|
|
|
|
|
|
do {
|
2022-07-23 01:28:48 +02:00
|
|
|
v = (v<<1) + vpx_rac_get_prob(c, *prob++);
|
2022-07-22 23:29:29 +02:00
|
|
|
} while (*prob);
|
|
|
|
|
|
|
|
return v;
|
|
|
|
}
|
|
|
|
|
2011-10-15 00:27:52 +03:00
|
|
|
static void free_buffers(VP8Context *s)
|
|
|
|
{
|
2012-07-12 23:07:06 +03:00
|
|
|
int i;
|
|
|
|
if (s->thread_data)
|
|
|
|
for (i = 0; i < MAX_THREADS; i++) {
|
2013-03-28 03:29:57 +03:00
|
|
|
#if HAVE_THREADS
|
|
|
|
pthread_cond_destroy(&s->thread_data[i].cond);
|
|
|
|
pthread_mutex_destroy(&s->thread_data[i].lock);
|
|
|
|
#endif
|
2012-07-12 23:07:06 +03:00
|
|
|
av_freep(&s->thread_data[i].filter_strength);
|
|
|
|
}
|
|
|
|
av_freep(&s->thread_data);
|
2011-10-15 00:27:52 +03:00
|
|
|
av_freep(&s->macroblocks_base);
|
|
|
|
av_freep(&s->intra4x4_pred_mode_top);
|
|
|
|
av_freep(&s->top_nnz);
|
|
|
|
av_freep(&s->top_border);
|
|
|
|
|
|
|
|
s->macroblocks = NULL;
|
|
|
|
}
|
|
|
|
|
2012-11-21 23:34:46 +03:00
|
|
|
static int vp8_alloc_frame(VP8Context *s, VP8Frame *f, int ref)
|
2011-10-18 03:10:16 +03:00
|
|
|
{
|
|
|
|
int ret;
|
2022-02-06 08:44:10 +02:00
|
|
|
if ((ret = ff_thread_get_ext_buffer(s->avctx, &f->tf,
|
|
|
|
ref ? AV_GET_BUFFER_FLAG_REF : 0)) < 0)
|
2011-10-18 03:10:16 +03:00
|
|
|
return ret;
|
2017-11-18 19:55:18 +02:00
|
|
|
if (!(f->seg_map = av_buffer_allocz(s->mb_width * s->mb_height)))
|
|
|
|
goto fail;
|
|
|
|
if (s->avctx->hwaccel) {
|
|
|
|
const AVHWAccel *hwaccel = s->avctx->hwaccel;
|
|
|
|
if (hwaccel->frame_priv_data_size) {
|
|
|
|
f->hwaccel_priv_buf = av_buffer_allocz(hwaccel->frame_priv_data_size);
|
|
|
|
if (!f->hwaccel_priv_buf)
|
|
|
|
goto fail;
|
|
|
|
f->hwaccel_picture_private = f->hwaccel_priv_buf->data;
|
|
|
|
}
|
2011-10-18 03:10:16 +03:00
|
|
|
}
|
|
|
|
return 0;
|
2017-11-18 19:55:18 +02:00
|
|
|
|
|
|
|
fail:
|
|
|
|
av_buffer_unref(&f->seg_map);
|
2022-02-06 08:44:10 +02:00
|
|
|
ff_thread_release_ext_buffer(s->avctx, &f->tf);
|
2017-11-18 19:55:18 +02:00
|
|
|
return AVERROR(ENOMEM);
|
2011-10-18 03:10:16 +03:00
|
|
|
}
|
|
|
|
|
2012-11-21 23:34:46 +03:00
|
|
|
static void vp8_release_frame(VP8Context *s, VP8Frame *f)
|
2011-10-18 03:10:16 +03:00
|
|
|
{
|
2012-11-21 23:34:46 +03:00
|
|
|
av_buffer_unref(&f->seg_map);
|
2017-11-18 19:55:18 +02:00
|
|
|
av_buffer_unref(&f->hwaccel_priv_buf);
|
|
|
|
f->hwaccel_picture_private = NULL;
|
2022-02-06 08:44:10 +02:00
|
|
|
ff_thread_release_ext_buffer(s->avctx, &f->tf);
|
2012-11-21 23:34:46 +03:00
|
|
|
}
|
|
|
|
|
2014-02-18 13:52:30 +03:00
|
|
|
#if CONFIG_VP8_DECODER
|
2012-11-21 23:34:46 +03:00
|
|
|
static int vp8_ref_frame(VP8Context *s, VP8Frame *dst, VP8Frame *src)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
vp8_release_frame(s, dst);
|
|
|
|
|
|
|
|
if ((ret = ff_thread_ref_frame(&dst->tf, &src->tf)) < 0)
|
|
|
|
return ret;
|
|
|
|
if (src->seg_map &&
|
|
|
|
!(dst->seg_map = av_buffer_ref(src->seg_map))) {
|
|
|
|
vp8_release_frame(s, dst);
|
|
|
|
return AVERROR(ENOMEM);
|
2011-10-18 03:10:16 +03:00
|
|
|
}
|
2017-11-18 19:55:18 +02:00
|
|
|
if (src->hwaccel_picture_private) {
|
|
|
|
dst->hwaccel_priv_buf = av_buffer_ref(src->hwaccel_priv_buf);
|
|
|
|
if (!dst->hwaccel_priv_buf)
|
|
|
|
return AVERROR(ENOMEM);
|
|
|
|
dst->hwaccel_picture_private = dst->hwaccel_priv_buf->data;
|
|
|
|
}
|
2012-11-21 23:34:46 +03:00
|
|
|
|
|
|
|
return 0;
|
2011-10-18 03:10:16 +03:00
|
|
|
}
|
2014-04-01 15:21:51 +03:00
|
|
|
#endif /* CONFIG_VP8_DECODER */
|
2011-10-18 03:10:16 +03:00
|
|
|
|
2012-11-21 23:34:46 +03:00
|
|
|
static void vp8_decode_flush_impl(AVCodecContext *avctx, int free_mem)
|
2010-06-22 22:24:09 +03:00
|
|
|
{
|
|
|
|
VP8Context *s = avctx->priv_data;
|
|
|
|
int i;
|
|
|
|
|
2012-11-21 23:34:46 +03:00
|
|
|
for (i = 0; i < FF_ARRAY_ELEMS(s->frames); i++)
|
|
|
|
vp8_release_frame(s, &s->frames[i]);
|
2010-06-22 22:24:09 +03:00
|
|
|
memset(s->framep, 0, sizeof(s->framep));
|
|
|
|
|
2012-11-21 23:34:46 +03:00
|
|
|
if (free_mem)
|
2011-10-29 09:48:43 +03:00
|
|
|
free_buffers(s);
|
2011-10-18 03:10:16 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static void vp8_decode_flush(AVCodecContext *avctx)
|
|
|
|
{
|
2012-11-21 23:34:46 +03:00
|
|
|
vp8_decode_flush_impl(avctx, 0);
|
2010-06-22 22:24:09 +03:00
|
|
|
}
|
|
|
|
|
2014-04-01 15:21:51 +03:00
|
|
|
static VP8Frame *vp8_find_free_buffer(VP8Context *s)
|
2014-02-14 14:58:55 +03:00
|
|
|
{
|
|
|
|
VP8Frame *frame = NULL;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
// find a free buffer
|
|
|
|
for (i = 0; i < 5; i++)
|
avcodec/vp8, vp9: Avoid using VP56mv and VP56Frame in VP8/9
Instead replace VP56mv by new and identical structures VP8mv and VP9mv.
Also replace VP56Frame by VP8FrameType in vp8.h and use that
in VP8 code. Also remove VP56_FRAME_GOLDEN2, as this has only
been used by VP8, and use VP8_FRAME_ALTREF as replacement for
its usage in VP8 as this is more in line with VP8 verbiage.
This allows to remove all inclusions of vp56.h from everything
that is not VP5/6. This also removes implicit inclusions
of hpeldsp.h, h264chroma.h, vp3dsp.h and vp56dsp.h from all VP8/9
files.
(This also fixes a build issue: If one compiles with -O0 and disables
everything except the VP8-VAAPI encoder, the file containing
ff_vpx_norm_shift is not compiled, yet this is used implicitly
by vp56_rac_gets_nn() which is defined in vp56.h; it is unused
by the VP8-VAAPI encoder and declared as av_unused, yet with -O0
unused noninline functions are not optimized away, leading to
linking failures. With this patch, said function is not included
in vaapi_encode_vp8.c any more.)
Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
2022-07-23 02:01:41 +02:00
|
|
|
if (&s->frames[i] != s->framep[VP8_FRAME_CURRENT] &&
|
|
|
|
&s->frames[i] != s->framep[VP8_FRAME_PREVIOUS] &&
|
|
|
|
&s->frames[i] != s->framep[VP8_FRAME_GOLDEN] &&
|
|
|
|
&s->frames[i] != s->framep[VP8_FRAME_ALTREF]) {
|
2014-02-14 14:58:55 +03:00
|
|
|
frame = &s->frames[i];
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (i == 5) {
|
|
|
|
av_log(s->avctx, AV_LOG_FATAL, "Ran out of free frames!\n");
|
|
|
|
abort();
|
|
|
|
}
|
2017-11-18 19:55:18 +02:00
|
|
|
if (frame->tf.f->buf[0])
|
2014-02-14 14:58:55 +03:00
|
|
|
vp8_release_frame(s, frame);
|
|
|
|
|
|
|
|
return frame;
|
|
|
|
}
|
|
|
|
|
2017-11-30 01:53:53 +02:00
|
|
|
static enum AVPixelFormat get_pixel_format(VP8Context *s)
|
|
|
|
{
|
|
|
|
enum AVPixelFormat pix_fmts[] = {
|
|
|
|
#if CONFIG_VP8_VAAPI_HWACCEL
|
|
|
|
AV_PIX_FMT_VAAPI,
|
|
|
|
#endif
|
|
|
|
#if CONFIG_VP8_NVDEC_HWACCEL
|
|
|
|
AV_PIX_FMT_CUDA,
|
|
|
|
#endif
|
|
|
|
AV_PIX_FMT_YUV420P,
|
|
|
|
AV_PIX_FMT_NONE,
|
|
|
|
};
|
|
|
|
|
|
|
|
return ff_get_format(s->avctx, pix_fmts);
|
|
|
|
}
|
|
|
|
|
2014-04-01 15:21:51 +03:00
|
|
|
static av_always_inline
|
|
|
|
int update_dimensions(VP8Context *s, int width, int height, int is_vp7)
|
2010-06-22 22:24:09 +03:00
|
|
|
{
|
2012-07-12 23:07:06 +03:00
|
|
|
AVCodecContext *avctx = s->avctx;
|
2019-06-11 08:52:29 +02:00
|
|
|
int i, ret, dim_reset = 0;
|
2012-07-12 23:07:06 +03:00
|
|
|
|
2012-04-23 04:29:48 +03:00
|
|
|
if (width != s->avctx->width || ((width+15)/16 != s->mb_width || (height+15)/16 != s->mb_height) && s->macroblocks_base ||
|
2011-05-02 16:55:52 +03:00
|
|
|
height != s->avctx->height) {
|
2012-11-21 23:34:46 +03:00
|
|
|
vp8_decode_flush_impl(s->avctx, 1);
|
2010-06-22 22:24:09 +03:00
|
|
|
|
2013-10-27 12:02:26 +03:00
|
|
|
ret = ff_set_dimensions(s->avctx, width, height);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
2019-06-11 08:52:29 +02:00
|
|
|
|
|
|
|
dim_reset = (s->macroblocks_base != NULL);
|
2011-05-02 16:55:52 +03:00
|
|
|
}
|
2010-06-22 22:24:09 +03:00
|
|
|
|
2019-06-11 08:52:29 +02:00
|
|
|
if ((s->pix_fmt == AV_PIX_FMT_NONE || dim_reset) &&
|
|
|
|
!s->actually_webp && !is_vp7) {
|
2017-11-30 01:53:53 +02:00
|
|
|
s->pix_fmt = get_pixel_format(s);
|
|
|
|
if (s->pix_fmt < 0)
|
|
|
|
return AVERROR(EINVAL);
|
|
|
|
avctx->pix_fmt = s->pix_fmt;
|
|
|
|
}
|
|
|
|
|
2014-03-28 03:13:54 +03:00
|
|
|
s->mb_width = (s->avctx->coded_width + 15) / 16;
|
|
|
|
s->mb_height = (s->avctx->coded_height + 15) / 16;
|
2010-06-22 22:24:09 +03:00
|
|
|
|
2014-04-01 15:21:51 +03:00
|
|
|
s->mb_layout = is_vp7 || avctx->active_thread_type == FF_THREAD_SLICE &&
|
2015-09-30 13:10:48 +02:00
|
|
|
avctx->thread_count > 1;
|
2012-07-12 23:07:06 +03:00
|
|
|
if (!s->mb_layout) { // Frame threading and one thread
|
2014-03-28 03:13:54 +03:00
|
|
|
s->macroblocks_base = av_mallocz((s->mb_width + s->mb_height * 2 + 1) *
|
|
|
|
sizeof(*s->macroblocks));
|
|
|
|
s->intra4x4_pred_mode_top = av_mallocz(s->mb_width * 4);
|
|
|
|
} else // Sliced threading
|
|
|
|
s->macroblocks_base = av_mallocz((s->mb_width + 2) * (s->mb_height + 2) *
|
|
|
|
sizeof(*s->macroblocks));
|
|
|
|
s->top_nnz = av_mallocz(s->mb_width * sizeof(*s->top_nnz));
|
|
|
|
s->top_border = av_mallocz((s->mb_width + 1) * sizeof(*s->top_border));
|
|
|
|
s->thread_data = av_mallocz(MAX_THREADS * sizeof(VP8ThreadData));
|
2010-06-22 22:24:09 +03:00
|
|
|
|
2014-12-17 17:02:08 +02:00
|
|
|
if (!s->macroblocks_base || !s->top_nnz || !s->top_border ||
|
|
|
|
!s->thread_data || (!s->intra4x4_pred_mode_top && !s->mb_layout)) {
|
|
|
|
free_buffers(s);
|
|
|
|
return AVERROR(ENOMEM);
|
|
|
|
}
|
|
|
|
|
2012-07-12 23:07:06 +03:00
|
|
|
for (i = 0; i < MAX_THREADS; i++) {
|
2014-03-28 03:13:54 +03:00
|
|
|
s->thread_data[i].filter_strength =
|
|
|
|
av_mallocz(s->mb_width * sizeof(*s->thread_data[0].filter_strength));
|
2014-12-17 17:02:08 +02:00
|
|
|
if (!s->thread_data[i].filter_strength) {
|
|
|
|
free_buffers(s);
|
|
|
|
return AVERROR(ENOMEM);
|
|
|
|
}
|
2012-07-15 00:11:35 +03:00
|
|
|
#if HAVE_THREADS
|
2012-07-12 23:07:06 +03:00
|
|
|
pthread_mutex_init(&s->thread_data[i].lock, NULL);
|
|
|
|
pthread_cond_init(&s->thread_data[i].cond, NULL);
|
2012-07-15 00:11:35 +03:00
|
|
|
#endif
|
2012-07-12 23:07:06 +03:00
|
|
|
}
|
2010-06-22 22:24:09 +03:00
|
|
|
|
2014-03-28 03:13:54 +03:00
|
|
|
s->macroblocks = s->macroblocks_base + 1;
|
2010-06-22 22:24:09 +03:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-04-01 15:21:51 +03:00
|
|
|
static int vp7_update_dimensions(VP8Context *s, int width, int height)
|
|
|
|
{
|
|
|
|
return update_dimensions(s, width, height, IS_VP7);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int vp8_update_dimensions(VP8Context *s, int width, int height)
|
|
|
|
{
|
|
|
|
return update_dimensions(s, width, height, IS_VP8);
|
|
|
|
}
|
|
|
|
|
2014-02-18 13:52:30 +03:00
|
|
|
|
2010-06-22 22:24:09 +03:00
|
|
|
static void parse_segment_info(VP8Context *s)
|
|
|
|
{
|
2022-07-23 01:28:48 +02:00
|
|
|
VPXRangeCoder *c = &s->c;
|
2010-06-22 22:24:09 +03:00
|
|
|
int i;
|
|
|
|
|
2022-07-23 00:04:29 +02:00
|
|
|
s->segmentation.update_map = vp89_rac_get(c);
|
|
|
|
s->segmentation.update_feature_data = vp89_rac_get(c);
|
2010-06-22 22:24:09 +03:00
|
|
|
|
2017-11-18 19:55:18 +02:00
|
|
|
if (s->segmentation.update_feature_data) {
|
2022-07-23 00:04:29 +02:00
|
|
|
s->segmentation.absolute_vals = vp89_rac_get(c);
|
2010-06-22 22:24:09 +03:00
|
|
|
|
|
|
|
for (i = 0; i < 4; i++)
|
|
|
|
s->segmentation.base_quant[i] = vp8_rac_get_sint(c, 7);
|
|
|
|
|
|
|
|
for (i = 0; i < 4; i++)
|
|
|
|
s->segmentation.filter_level[i] = vp8_rac_get_sint(c, 6);
|
|
|
|
}
|
|
|
|
if (s->segmentation.update_map)
|
|
|
|
for (i = 0; i < 3; i++)
|
2022-07-23 00:04:29 +02:00
|
|
|
s->prob->segmentid[i] = vp89_rac_get(c) ? vp89_rac_get_uint(c, 8) : 255;
|
2010-06-22 22:24:09 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static void update_lf_deltas(VP8Context *s)
|
|
|
|
{
|
2022-07-23 01:28:48 +02:00
|
|
|
VPXRangeCoder *c = &s->c;
|
2010-06-22 22:24:09 +03:00
|
|
|
int i;
|
|
|
|
|
2012-03-19 10:35:09 +03:00
|
|
|
for (i = 0; i < 4; i++) {
|
2022-07-23 00:04:29 +02:00
|
|
|
if (vp89_rac_get(c)) {
|
|
|
|
s->lf_delta.ref[i] = vp89_rac_get_uint(c, 6);
|
2010-06-22 22:24:09 +03:00
|
|
|
|
2022-07-23 00:04:29 +02:00
|
|
|
if (vp89_rac_get(c))
|
2012-03-19 10:35:09 +03:00
|
|
|
s->lf_delta.ref[i] = -s->lf_delta.ref[i];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = MODE_I4x4; i <= VP8_MVMODE_SPLIT; i++) {
|
2022-07-23 00:04:29 +02:00
|
|
|
if (vp89_rac_get(c)) {
|
|
|
|
s->lf_delta.mode[i] = vp89_rac_get_uint(c, 6);
|
2012-03-19 10:35:09 +03:00
|
|
|
|
2022-07-23 00:04:29 +02:00
|
|
|
if (vp89_rac_get(c))
|
2012-03-19 10:35:09 +03:00
|
|
|
s->lf_delta.mode[i] = -s->lf_delta.mode[i];
|
|
|
|
}
|
|
|
|
}
|
2010-06-22 22:24:09 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static int setup_partitions(VP8Context *s, const uint8_t *buf, int buf_size)
|
|
|
|
{
|
|
|
|
const uint8_t *sizes = buf;
|
|
|
|
int i;
|
2017-03-07 20:09:38 +02:00
|
|
|
int ret;
|
2010-06-22 22:24:09 +03:00
|
|
|
|
2022-07-23 00:04:29 +02:00
|
|
|
s->num_coeff_partitions = 1 << vp89_rac_get_uint(&s->c, 2);
|
2010-06-22 22:24:09 +03:00
|
|
|
|
2014-03-28 03:13:54 +03:00
|
|
|
buf += 3 * (s->num_coeff_partitions - 1);
|
|
|
|
buf_size -= 3 * (s->num_coeff_partitions - 1);
|
2010-06-22 22:24:09 +03:00
|
|
|
if (buf_size < 0)
|
|
|
|
return -1;
|
|
|
|
|
2014-03-28 03:13:54 +03:00
|
|
|
for (i = 0; i < s->num_coeff_partitions - 1; i++) {
|
|
|
|
int size = AV_RL24(sizes + 3 * i);
|
2010-06-22 22:24:09 +03:00
|
|
|
if (buf_size - size < 0)
|
|
|
|
return -1;
|
2017-11-18 19:55:18 +02:00
|
|
|
s->coeff_partition_size[i] = size;
|
2010-06-22 22:24:09 +03:00
|
|
|
|
2022-07-23 01:28:48 +02:00
|
|
|
ret = ff_vpx_init_range_decoder(&s->coeff_partition[i], buf, size);
|
2017-03-07 20:09:38 +02:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
2010-06-22 22:24:09 +03:00
|
|
|
buf += size;
|
|
|
|
buf_size -= size;
|
|
|
|
}
|
2017-11-18 19:55:18 +02:00
|
|
|
|
|
|
|
s->coeff_partition_size[i] = buf_size;
|
2022-07-23 01:28:48 +02:00
|
|
|
ff_vpx_init_range_decoder(&s->coeff_partition[i], buf, buf_size);
|
2017-11-18 19:55:18 +02:00
|
|
|
|
|
|
|
return 0;
|
2010-06-22 22:24:09 +03:00
|
|
|
}
|
2014-02-18 13:52:30 +03:00
|
|
|
|
|
|
|
static void vp7_get_quants(VP8Context *s)
|
|
|
|
{
|
2022-07-23 01:28:48 +02:00
|
|
|
VPXRangeCoder *c = &s->c;
|
2014-02-18 13:52:30 +03:00
|
|
|
|
2022-07-23 00:04:29 +02:00
|
|
|
int yac_qi = vp89_rac_get_uint(c, 7);
|
|
|
|
int ydc_qi = vp89_rac_get(c) ? vp89_rac_get_uint(c, 7) : yac_qi;
|
|
|
|
int y2dc_qi = vp89_rac_get(c) ? vp89_rac_get_uint(c, 7) : yac_qi;
|
|
|
|
int y2ac_qi = vp89_rac_get(c) ? vp89_rac_get_uint(c, 7) : yac_qi;
|
|
|
|
int uvdc_qi = vp89_rac_get(c) ? vp89_rac_get_uint(c, 7) : yac_qi;
|
|
|
|
int uvac_qi = vp89_rac_get(c) ? vp89_rac_get_uint(c, 7) : yac_qi;
|
2014-02-18 13:52:30 +03:00
|
|
|
|
|
|
|
s->qmat[0].luma_qmul[0] = vp7_ydc_qlookup[ydc_qi];
|
|
|
|
s->qmat[0].luma_qmul[1] = vp7_yac_qlookup[yac_qi];
|
|
|
|
s->qmat[0].luma_dc_qmul[0] = vp7_y2dc_qlookup[y2dc_qi];
|
|
|
|
s->qmat[0].luma_dc_qmul[1] = vp7_y2ac_qlookup[y2ac_qi];
|
|
|
|
s->qmat[0].chroma_qmul[0] = FFMIN(vp7_ydc_qlookup[uvdc_qi], 132);
|
|
|
|
s->qmat[0].chroma_qmul[1] = vp7_yac_qlookup[uvac_qi];
|
|
|
|
}
|
2010-06-22 22:24:09 +03:00
|
|
|
|
2014-02-18 13:52:30 +03:00
|
|
|
static void vp8_get_quants(VP8Context *s)
|
2010-06-22 22:24:09 +03:00
|
|
|
{
|
2022-07-23 01:28:48 +02:00
|
|
|
VPXRangeCoder *c = &s->c;
|
2010-06-22 22:24:09 +03:00
|
|
|
int i, base_qi;
|
|
|
|
|
2022-07-23 00:04:29 +02:00
|
|
|
s->quant.yac_qi = vp89_rac_get_uint(c, 7);
|
2017-11-18 19:55:18 +02:00
|
|
|
s->quant.ydc_delta = vp8_rac_get_sint(c, 4);
|
|
|
|
s->quant.y2dc_delta = vp8_rac_get_sint(c, 4);
|
|
|
|
s->quant.y2ac_delta = vp8_rac_get_sint(c, 4);
|
|
|
|
s->quant.uvdc_delta = vp8_rac_get_sint(c, 4);
|
|
|
|
s->quant.uvac_delta = vp8_rac_get_sint(c, 4);
|
2010-06-22 22:24:09 +03:00
|
|
|
|
|
|
|
for (i = 0; i < 4; i++) {
|
|
|
|
if (s->segmentation.enabled) {
|
|
|
|
base_qi = s->segmentation.base_quant[i];
|
|
|
|
if (!s->segmentation.absolute_vals)
|
2017-11-18 19:55:18 +02:00
|
|
|
base_qi += s->quant.yac_qi;
|
2010-06-22 22:24:09 +03:00
|
|
|
} else
|
2017-11-18 19:55:18 +02:00
|
|
|
base_qi = s->quant.yac_qi;
|
2010-06-22 22:24:09 +03:00
|
|
|
|
2017-11-18 19:55:18 +02:00
|
|
|
s->qmat[i].luma_qmul[0] = vp8_dc_qlookup[av_clip_uintp2(base_qi + s->quant.ydc_delta, 7)];
|
2014-03-28 03:13:54 +03:00
|
|
|
s->qmat[i].luma_qmul[1] = vp8_ac_qlookup[av_clip_uintp2(base_qi, 7)];
|
2017-11-18 19:55:18 +02:00
|
|
|
s->qmat[i].luma_dc_qmul[0] = vp8_dc_qlookup[av_clip_uintp2(base_qi + s->quant.y2dc_delta, 7)] * 2;
|
2012-07-25 00:23:12 +03:00
|
|
|
/* 101581>>16 is equivalent to 155/100 */
|
2017-11-18 19:55:18 +02:00
|
|
|
s->qmat[i].luma_dc_qmul[1] = vp8_ac_qlookup[av_clip_uintp2(base_qi + s->quant.y2ac_delta, 7)] * 101581 >> 16;
|
|
|
|
s->qmat[i].chroma_qmul[0] = vp8_dc_qlookup[av_clip_uintp2(base_qi + s->quant.uvdc_delta, 7)];
|
|
|
|
s->qmat[i].chroma_qmul[1] = vp8_ac_qlookup[av_clip_uintp2(base_qi + s->quant.uvac_delta, 7)];
|
2010-07-28 02:09:13 +03:00
|
|
|
|
|
|
|
s->qmat[i].luma_dc_qmul[1] = FFMAX(s->qmat[i].luma_dc_qmul[1], 8);
|
|
|
|
s->qmat[i].chroma_qmul[0] = FFMIN(s->qmat[i].chroma_qmul[0], 132);
|
2010-06-22 22:24:09 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Determine which buffers golden and altref should be updated with after this frame.
|
|
|
|
* The spec isn't clear here, so I'm going by my understanding of what libvpx does
|
|
|
|
*
|
|
|
|
* Intra frames update all 3 references
|
avcodec/vp8, vp9: Avoid using VP56mv and VP56Frame in VP8/9
Instead replace VP56mv by new and identical structures VP8mv and VP9mv.
Also replace VP56Frame by VP8FrameType in vp8.h and use that
in VP8 code. Also remove VP56_FRAME_GOLDEN2, as this has only
been used by VP8, and use VP8_FRAME_ALTREF as replacement for
its usage in VP8 as this is more in line with VP8 verbiage.
This allows to remove all inclusions of vp56.h from everything
that is not VP5/6. This also removes implicit inclusions
of hpeldsp.h, h264chroma.h, vp3dsp.h and vp56dsp.h from all VP8/9
files.
(This also fixes a build issue: If one compiles with -O0 and disables
everything except the VP8-VAAPI encoder, the file containing
ff_vpx_norm_shift is not compiled, yet this is used implicitly
by vp56_rac_gets_nn() which is defined in vp56.h; it is unused
by the VP8-VAAPI encoder and declared as av_unused, yet with -O0
unused noninline functions are not optimized away, leading to
linking failures. With this patch, said function is not included
in vaapi_encode_vp8.c any more.)
Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
2022-07-23 02:01:41 +02:00
|
|
|
* Inter frames update VP8_FRAME_PREVIOUS if the update_last flag is set
|
2010-06-22 22:24:09 +03:00
|
|
|
* If the update (golden|altref) flag is set, it's updated with the current frame
|
avcodec/vp8, vp9: Avoid using VP56mv and VP56Frame in VP8/9
Instead replace VP56mv by new and identical structures VP8mv and VP9mv.
Also replace VP56Frame by VP8FrameType in vp8.h and use that
in VP8 code. Also remove VP56_FRAME_GOLDEN2, as this has only
been used by VP8, and use VP8_FRAME_ALTREF as replacement for
its usage in VP8 as this is more in line with VP8 verbiage.
This allows to remove all inclusions of vp56.h from everything
that is not VP5/6. This also removes implicit inclusions
of hpeldsp.h, h264chroma.h, vp3dsp.h and vp56dsp.h from all VP8/9
files.
(This also fixes a build issue: If one compiles with -O0 and disables
everything except the VP8-VAAPI encoder, the file containing
ff_vpx_norm_shift is not compiled, yet this is used implicitly
by vp56_rac_gets_nn() which is defined in vp56.h; it is unused
by the VP8-VAAPI encoder and declared as av_unused, yet with -O0
unused noninline functions are not optimized away, leading to
linking failures. With this patch, said function is not included
in vaapi_encode_vp8.c any more.)
Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
2022-07-23 02:01:41 +02:00
|
|
|
* if update_last is set, and VP8_FRAME_PREVIOUS otherwise.
|
2010-06-22 22:24:09 +03:00
|
|
|
* If the flag is not set, the number read means:
|
|
|
|
* 0: no update
|
avcodec/vp8, vp9: Avoid using VP56mv and VP56Frame in VP8/9
Instead replace VP56mv by new and identical structures VP8mv and VP9mv.
Also replace VP56Frame by VP8FrameType in vp8.h and use that
in VP8 code. Also remove VP56_FRAME_GOLDEN2, as this has only
been used by VP8, and use VP8_FRAME_ALTREF as replacement for
its usage in VP8 as this is more in line with VP8 verbiage.
This allows to remove all inclusions of vp56.h from everything
that is not VP5/6. This also removes implicit inclusions
of hpeldsp.h, h264chroma.h, vp3dsp.h and vp56dsp.h from all VP8/9
files.
(This also fixes a build issue: If one compiles with -O0 and disables
everything except the VP8-VAAPI encoder, the file containing
ff_vpx_norm_shift is not compiled, yet this is used implicitly
by vp56_rac_gets_nn() which is defined in vp56.h; it is unused
by the VP8-VAAPI encoder and declared as av_unused, yet with -O0
unused noninline functions are not optimized away, leading to
linking failures. With this patch, said function is not included
in vaapi_encode_vp8.c any more.)
Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
2022-07-23 02:01:41 +02:00
|
|
|
* 1: VP8_FRAME_PREVIOUS
|
2010-06-22 22:24:09 +03:00
|
|
|
* 2: update golden with altref, or update altref with golden
|
|
|
|
*/
|
avcodec/vp8, vp9: Avoid using VP56mv and VP56Frame in VP8/9
Instead replace VP56mv by new and identical structures VP8mv and VP9mv.
Also replace VP56Frame by VP8FrameType in vp8.h and use that
in VP8 code. Also remove VP56_FRAME_GOLDEN2, as this has only
been used by VP8, and use VP8_FRAME_ALTREF as replacement for
its usage in VP8 as this is more in line with VP8 verbiage.
This allows to remove all inclusions of vp56.h from everything
that is not VP5/6. This also removes implicit inclusions
of hpeldsp.h, h264chroma.h, vp3dsp.h and vp56dsp.h from all VP8/9
files.
(This also fixes a build issue: If one compiles with -O0 and disables
everything except the VP8-VAAPI encoder, the file containing
ff_vpx_norm_shift is not compiled, yet this is used implicitly
by vp56_rac_gets_nn() which is defined in vp56.h; it is unused
by the VP8-VAAPI encoder and declared as av_unused, yet with -O0
unused noninline functions are not optimized away, leading to
linking failures. With this patch, said function is not included
in vaapi_encode_vp8.c any more.)
Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
2022-07-23 02:01:41 +02:00
|
|
|
static VP8FrameType ref_to_update(VP8Context *s, int update, VP8FrameType ref)
|
2010-06-22 22:24:09 +03:00
|
|
|
{
|
2022-07-23 01:28:48 +02:00
|
|
|
VPXRangeCoder *c = &s->c;
|
2010-06-22 22:24:09 +03:00
|
|
|
|
|
|
|
if (update)
|
avcodec/vp8, vp9: Avoid using VP56mv and VP56Frame in VP8/9
Instead replace VP56mv by new and identical structures VP8mv and VP9mv.
Also replace VP56Frame by VP8FrameType in vp8.h and use that
in VP8 code. Also remove VP56_FRAME_GOLDEN2, as this has only
been used by VP8, and use VP8_FRAME_ALTREF as replacement for
its usage in VP8 as this is more in line with VP8 verbiage.
This allows to remove all inclusions of vp56.h from everything
that is not VP5/6. This also removes implicit inclusions
of hpeldsp.h, h264chroma.h, vp3dsp.h and vp56dsp.h from all VP8/9
files.
(This also fixes a build issue: If one compiles with -O0 and disables
everything except the VP8-VAAPI encoder, the file containing
ff_vpx_norm_shift is not compiled, yet this is used implicitly
by vp56_rac_gets_nn() which is defined in vp56.h; it is unused
by the VP8-VAAPI encoder and declared as av_unused, yet with -O0
unused noninline functions are not optimized away, leading to
linking failures. With this patch, said function is not included
in vaapi_encode_vp8.c any more.)
Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
2022-07-23 02:01:41 +02:00
|
|
|
return VP8_FRAME_CURRENT;
|
2010-06-22 22:24:09 +03:00
|
|
|
|
2022-07-23 00:04:29 +02:00
|
|
|
switch (vp89_rac_get_uint(c, 2)) {
|
2010-06-22 22:24:09 +03:00
|
|
|
case 1:
|
avcodec/vp8, vp9: Avoid using VP56mv and VP56Frame in VP8/9
Instead replace VP56mv by new and identical structures VP8mv and VP9mv.
Also replace VP56Frame by VP8FrameType in vp8.h and use that
in VP8 code. Also remove VP56_FRAME_GOLDEN2, as this has only
been used by VP8, and use VP8_FRAME_ALTREF as replacement for
its usage in VP8 as this is more in line with VP8 verbiage.
This allows to remove all inclusions of vp56.h from everything
that is not VP5/6. This also removes implicit inclusions
of hpeldsp.h, h264chroma.h, vp3dsp.h and vp56dsp.h from all VP8/9
files.
(This also fixes a build issue: If one compiles with -O0 and disables
everything except the VP8-VAAPI encoder, the file containing
ff_vpx_norm_shift is not compiled, yet this is used implicitly
by vp56_rac_gets_nn() which is defined in vp56.h; it is unused
by the VP8-VAAPI encoder and declared as av_unused, yet with -O0
unused noninline functions are not optimized away, leading to
linking failures. With this patch, said function is not included
in vaapi_encode_vp8.c any more.)
Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
2022-07-23 02:01:41 +02:00
|
|
|
return VP8_FRAME_PREVIOUS;
|
2010-06-22 22:24:09 +03:00
|
|
|
case 2:
|
avcodec/vp8, vp9: Avoid using VP56mv and VP56Frame in VP8/9
Instead replace VP56mv by new and identical structures VP8mv and VP9mv.
Also replace VP56Frame by VP8FrameType in vp8.h and use that
in VP8 code. Also remove VP56_FRAME_GOLDEN2, as this has only
been used by VP8, and use VP8_FRAME_ALTREF as replacement for
its usage in VP8 as this is more in line with VP8 verbiage.
This allows to remove all inclusions of vp56.h from everything
that is not VP5/6. This also removes implicit inclusions
of hpeldsp.h, h264chroma.h, vp3dsp.h and vp56dsp.h from all VP8/9
files.
(This also fixes a build issue: If one compiles with -O0 and disables
everything except the VP8-VAAPI encoder, the file containing
ff_vpx_norm_shift is not compiled, yet this is used implicitly
by vp56_rac_gets_nn() which is defined in vp56.h; it is unused
by the VP8-VAAPI encoder and declared as av_unused, yet with -O0
unused noninline functions are not optimized away, leading to
linking failures. With this patch, said function is not included
in vaapi_encode_vp8.c any more.)
Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
2022-07-23 02:01:41 +02:00
|
|
|
return (ref == VP8_FRAME_GOLDEN) ? VP8_FRAME_ALTREF : VP8_FRAME_GOLDEN;
|
2010-06-22 22:24:09 +03:00
|
|
|
}
|
avcodec/vp8, vp9: Avoid using VP56mv and VP56Frame in VP8/9
Instead replace VP56mv by new and identical structures VP8mv and VP9mv.
Also replace VP56Frame by VP8FrameType in vp8.h and use that
in VP8 code. Also remove VP56_FRAME_GOLDEN2, as this has only
been used by VP8, and use VP8_FRAME_ALTREF as replacement for
its usage in VP8 as this is more in line with VP8 verbiage.
This allows to remove all inclusions of vp56.h from everything
that is not VP5/6. This also removes implicit inclusions
of hpeldsp.h, h264chroma.h, vp3dsp.h and vp56dsp.h from all VP8/9
files.
(This also fixes a build issue: If one compiles with -O0 and disables
everything except the VP8-VAAPI encoder, the file containing
ff_vpx_norm_shift is not compiled, yet this is used implicitly
by vp56_rac_gets_nn() which is defined in vp56.h; it is unused
by the VP8-VAAPI encoder and declared as av_unused, yet with -O0
unused noninline functions are not optimized away, leading to
linking failures. With this patch, said function is not included
in vaapi_encode_vp8.c any more.)
Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
2022-07-23 02:01:41 +02:00
|
|
|
return VP8_FRAME_NONE;
|
2010-06-22 22:24:09 +03:00
|
|
|
}
|
2014-02-18 13:52:30 +03:00
|
|
|
|
|
|
|
static void vp78_reset_probability_tables(VP8Context *s)
|
|
|
|
{
|
|
|
|
int i, j;
|
|
|
|
for (i = 0; i < 4; i++)
|
|
|
|
for (j = 0; j < 16; j++)
|
2014-04-01 15:21:51 +03:00
|
|
|
memcpy(s->prob->token[i][j], vp8_token_default_probs[i][vp8_coeff_band[j]],
|
2014-02-18 13:52:30 +03:00
|
|
|
sizeof(s->prob->token[i][j]));
|
|
|
|
}
|
|
|
|
|
|
|
|
static void vp78_update_probability_tables(VP8Context *s)
|
|
|
|
{
|
2022-07-23 01:28:48 +02:00
|
|
|
VPXRangeCoder *c = &s->c;
|
2014-02-18 13:52:30 +03:00
|
|
|
int i, j, k, l, m;
|
|
|
|
|
|
|
|
for (i = 0; i < 4; i++)
|
|
|
|
for (j = 0; j < 8; j++)
|
|
|
|
for (k = 0; k < 3; k++)
|
2014-04-01 15:21:51 +03:00
|
|
|
for (l = 0; l < NUM_DCT_TOKENS-1; l++)
|
2022-07-23 01:28:48 +02:00
|
|
|
if (vpx_rac_get_prob_branchy(c, vp8_token_update_probs[i][j][k][l])) {
|
2022-07-23 00:04:29 +02:00
|
|
|
int prob = vp89_rac_get_uint(c, 8);
|
2014-02-18 13:52:30 +03:00
|
|
|
for (m = 0; vp8_coeff_band_indexes[j][m] >= 0; m++)
|
|
|
|
s->prob->token[i][vp8_coeff_band_indexes[j][m]][k][l] = prob;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-04-01 15:21:51 +03:00
|
|
|
#define VP7_MVC_SIZE 17
|
|
|
|
#define VP8_MVC_SIZE 19
|
|
|
|
|
|
|
|
static void vp78_update_pred16x16_pred8x8_mvc_probabilities(VP8Context *s,
|
|
|
|
int mvc_size)
|
2014-02-18 13:52:30 +03:00
|
|
|
{
|
2022-07-23 01:28:48 +02:00
|
|
|
VPXRangeCoder *c = &s->c;
|
2014-02-18 13:52:30 +03:00
|
|
|
int i, j;
|
|
|
|
|
2022-07-23 00:04:29 +02:00
|
|
|
if (vp89_rac_get(c))
|
2014-02-18 13:52:30 +03:00
|
|
|
for (i = 0; i < 4; i++)
|
2022-07-23 00:04:29 +02:00
|
|
|
s->prob->pred16x16[i] = vp89_rac_get_uint(c, 8);
|
|
|
|
if (vp89_rac_get(c))
|
2014-02-18 13:52:30 +03:00
|
|
|
for (i = 0; i < 3; i++)
|
2022-07-23 00:04:29 +02:00
|
|
|
s->prob->pred8x8c[i] = vp89_rac_get_uint(c, 8);
|
2014-02-18 13:52:30 +03:00
|
|
|
|
|
|
|
// 17.2 MV probability update
|
|
|
|
for (i = 0; i < 2; i++)
|
2014-04-01 15:21:51 +03:00
|
|
|
for (j = 0; j < mvc_size; j++)
|
2022-07-23 01:28:48 +02:00
|
|
|
if (vpx_rac_get_prob_branchy(c, vp8_mv_update_prob[i][j]))
|
2014-02-18 13:52:30 +03:00
|
|
|
s->prob->mvc[i][j] = vp8_rac_get_nn(c);
|
|
|
|
}
|
2010-06-22 22:24:09 +03:00
|
|
|
|
|
|
|
static void update_refs(VP8Context *s)
|
|
|
|
{
|
2022-07-23 01:28:48 +02:00
|
|
|
VPXRangeCoder *c = &s->c;
|
2010-06-22 22:24:09 +03:00
|
|
|
|
2022-07-23 00:04:29 +02:00
|
|
|
int update_golden = vp89_rac_get(c);
|
|
|
|
int update_altref = vp89_rac_get(c);
|
2010-06-22 22:24:09 +03:00
|
|
|
|
avcodec/vp8, vp9: Avoid using VP56mv and VP56Frame in VP8/9
Instead replace VP56mv by new and identical structures VP8mv and VP9mv.
Also replace VP56Frame by VP8FrameType in vp8.h and use that
in VP8 code. Also remove VP56_FRAME_GOLDEN2, as this has only
been used by VP8, and use VP8_FRAME_ALTREF as replacement for
its usage in VP8 as this is more in line with VP8 verbiage.
This allows to remove all inclusions of vp56.h from everything
that is not VP5/6. This also removes implicit inclusions
of hpeldsp.h, h264chroma.h, vp3dsp.h and vp56dsp.h from all VP8/9
files.
(This also fixes a build issue: If one compiles with -O0 and disables
everything except the VP8-VAAPI encoder, the file containing
ff_vpx_norm_shift is not compiled, yet this is used implicitly
by vp56_rac_gets_nn() which is defined in vp56.h; it is unused
by the VP8-VAAPI encoder and declared as av_unused, yet with -O0
unused noninline functions are not optimized away, leading to
linking failures. With this patch, said function is not included
in vaapi_encode_vp8.c any more.)
Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
2022-07-23 02:01:41 +02:00
|
|
|
s->update_golden = ref_to_update(s, update_golden, VP8_FRAME_GOLDEN);
|
|
|
|
s->update_altref = ref_to_update(s, update_altref, VP8_FRAME_ALTREF);
|
2010-06-22 22:24:09 +03:00
|
|
|
}
|
2014-02-18 13:52:30 +03:00
|
|
|
|
2014-04-05 22:31:25 +03:00
|
|
|
static void copy_chroma(AVFrame *dst, AVFrame *src, int width, int height)
|
2014-04-01 15:21:51 +03:00
|
|
|
{
|
|
|
|
int i, j;
|
|
|
|
|
|
|
|
for (j = 1; j < 3; j++) {
|
|
|
|
for (i = 0; i < height / 2; i++)
|
|
|
|
memcpy(dst->data[j] + i * dst->linesize[j],
|
|
|
|
src->data[j] + i * src->linesize[j], width / 2);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-03-19 20:10:28 +02:00
|
|
|
static void fade(uint8_t *dst, ptrdiff_t dst_linesize,
|
|
|
|
const uint8_t *src, ptrdiff_t src_linesize,
|
2014-04-04 15:31:04 +03:00
|
|
|
int width, int height,
|
2014-04-01 15:21:51 +03:00
|
|
|
int alpha, int beta)
|
2014-02-18 13:52:30 +03:00
|
|
|
{
|
|
|
|
int i, j;
|
2014-04-01 15:21:51 +03:00
|
|
|
for (j = 0; j < height; j++) {
|
2018-06-24 02:50:16 +02:00
|
|
|
const uint8_t *src2 = src + j * src_linesize;
|
|
|
|
uint8_t *dst2 = dst + j * dst_linesize;
|
2014-02-18 13:52:30 +03:00
|
|
|
for (i = 0; i < width; i++) {
|
2018-06-24 02:50:16 +02:00
|
|
|
uint8_t y = src2[i];
|
|
|
|
dst2[i] = av_clip_uint8(y + ((y * beta) >> 8) + alpha);
|
2014-02-18 13:52:30 +03:00
|
|
|
}
|
2014-04-01 15:21:51 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-08-01 13:54:21 +02:00
|
|
|
static int vp7_fade_frame(VP8Context *s, int alpha, int beta)
|
2014-04-01 15:21:51 +03:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (!s->keyframe && (alpha || beta)) {
|
|
|
|
int width = s->mb_width * 16;
|
|
|
|
int height = s->mb_height * 16;
|
|
|
|
AVFrame *src, *dst;
|
|
|
|
|
avcodec/vp8, vp9: Avoid using VP56mv and VP56Frame in VP8/9
Instead replace VP56mv by new and identical structures VP8mv and VP9mv.
Also replace VP56Frame by VP8FrameType in vp8.h and use that
in VP8 code. Also remove VP56_FRAME_GOLDEN2, as this has only
been used by VP8, and use VP8_FRAME_ALTREF as replacement for
its usage in VP8 as this is more in line with VP8 verbiage.
This allows to remove all inclusions of vp56.h from everything
that is not VP5/6. This also removes implicit inclusions
of hpeldsp.h, h264chroma.h, vp3dsp.h and vp56dsp.h from all VP8/9
files.
(This also fixes a build issue: If one compiles with -O0 and disables
everything except the VP8-VAAPI encoder, the file containing
ff_vpx_norm_shift is not compiled, yet this is used implicitly
by vp56_rac_gets_nn() which is defined in vp56.h; it is unused
by the VP8-VAAPI encoder and declared as av_unused, yet with -O0
unused noninline functions are not optimized away, leading to
linking failures. With this patch, said function is not included
in vaapi_encode_vp8.c any more.)
Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
2022-07-23 02:01:41 +02:00
|
|
|
if (!s->framep[VP8_FRAME_PREVIOUS] ||
|
|
|
|
!s->framep[VP8_FRAME_GOLDEN]) {
|
2014-04-04 15:31:04 +03:00
|
|
|
av_log(s->avctx, AV_LOG_WARNING, "Discarding interframe without a prior keyframe!\n");
|
2014-04-01 15:21:51 +03:00
|
|
|
return AVERROR_INVALIDDATA;
|
2014-04-04 15:31:04 +03:00
|
|
|
}
|
2014-04-01 15:21:51 +03:00
|
|
|
|
|
|
|
dst =
|
avcodec/vp8, vp9: Avoid using VP56mv and VP56Frame in VP8/9
Instead replace VP56mv by new and identical structures VP8mv and VP9mv.
Also replace VP56Frame by VP8FrameType in vp8.h and use that
in VP8 code. Also remove VP56_FRAME_GOLDEN2, as this has only
been used by VP8, and use VP8_FRAME_ALTREF as replacement for
its usage in VP8 as this is more in line with VP8 verbiage.
This allows to remove all inclusions of vp56.h from everything
that is not VP5/6. This also removes implicit inclusions
of hpeldsp.h, h264chroma.h, vp3dsp.h and vp56dsp.h from all VP8/9
files.
(This also fixes a build issue: If one compiles with -O0 and disables
everything except the VP8-VAAPI encoder, the file containing
ff_vpx_norm_shift is not compiled, yet this is used implicitly
by vp56_rac_gets_nn() which is defined in vp56.h; it is unused
by the VP8-VAAPI encoder and declared as av_unused, yet with -O0
unused noninline functions are not optimized away, leading to
linking failures. With this patch, said function is not included
in vaapi_encode_vp8.c any more.)
Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
2022-07-23 02:01:41 +02:00
|
|
|
src = s->framep[VP8_FRAME_PREVIOUS]->tf.f;
|
2014-04-01 15:21:51 +03:00
|
|
|
|
|
|
|
/* preserve the golden frame, write a new previous frame */
|
avcodec/vp8, vp9: Avoid using VP56mv and VP56Frame in VP8/9
Instead replace VP56mv by new and identical structures VP8mv and VP9mv.
Also replace VP56Frame by VP8FrameType in vp8.h and use that
in VP8 code. Also remove VP56_FRAME_GOLDEN2, as this has only
been used by VP8, and use VP8_FRAME_ALTREF as replacement for
its usage in VP8 as this is more in line with VP8 verbiage.
This allows to remove all inclusions of vp56.h from everything
that is not VP5/6. This also removes implicit inclusions
of hpeldsp.h, h264chroma.h, vp3dsp.h and vp56dsp.h from all VP8/9
files.
(This also fixes a build issue: If one compiles with -O0 and disables
everything except the VP8-VAAPI encoder, the file containing
ff_vpx_norm_shift is not compiled, yet this is used implicitly
by vp56_rac_gets_nn() which is defined in vp56.h; it is unused
by the VP8-VAAPI encoder and declared as av_unused, yet with -O0
unused noninline functions are not optimized away, leading to
linking failures. With this patch, said function is not included
in vaapi_encode_vp8.c any more.)
Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
2022-07-23 02:01:41 +02:00
|
|
|
if (s->framep[VP8_FRAME_GOLDEN] == s->framep[VP8_FRAME_PREVIOUS]) {
|
|
|
|
s->framep[VP8_FRAME_PREVIOUS] = vp8_find_free_buffer(s);
|
|
|
|
if ((ret = vp8_alloc_frame(s, s->framep[VP8_FRAME_PREVIOUS], 1)) < 0)
|
2014-04-04 15:31:04 +03:00
|
|
|
return ret;
|
2014-04-01 15:21:51 +03:00
|
|
|
|
avcodec/vp8, vp9: Avoid using VP56mv and VP56Frame in VP8/9
Instead replace VP56mv by new and identical structures VP8mv and VP9mv.
Also replace VP56Frame by VP8FrameType in vp8.h and use that
in VP8 code. Also remove VP56_FRAME_GOLDEN2, as this has only
been used by VP8, and use VP8_FRAME_ALTREF as replacement for
its usage in VP8 as this is more in line with VP8 verbiage.
This allows to remove all inclusions of vp56.h from everything
that is not VP5/6. This also removes implicit inclusions
of hpeldsp.h, h264chroma.h, vp3dsp.h and vp56dsp.h from all VP8/9
files.
(This also fixes a build issue: If one compiles with -O0 and disables
everything except the VP8-VAAPI encoder, the file containing
ff_vpx_norm_shift is not compiled, yet this is used implicitly
by vp56_rac_gets_nn() which is defined in vp56.h; it is unused
by the VP8-VAAPI encoder and declared as av_unused, yet with -O0
unused noninline functions are not optimized away, leading to
linking failures. With this patch, said function is not included
in vaapi_encode_vp8.c any more.)
Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
2022-07-23 02:01:41 +02:00
|
|
|
dst = s->framep[VP8_FRAME_PREVIOUS]->tf.f;
|
2014-04-01 15:21:51 +03:00
|
|
|
|
2014-04-05 22:31:25 +03:00
|
|
|
copy_chroma(dst, src, width, height);
|
2014-04-01 15:21:51 +03:00
|
|
|
}
|
|
|
|
|
2014-04-04 15:31:04 +03:00
|
|
|
fade(dst->data[0], dst->linesize[0],
|
|
|
|
src->data[0], src->linesize[0],
|
|
|
|
width, height, alpha, beta);
|
2014-04-01 15:21:51 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
2014-02-18 13:52:30 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static int vp7_decode_frame_header(VP8Context *s, const uint8_t *buf, int buf_size)
|
|
|
|
{
|
2022-07-23 01:28:48 +02:00
|
|
|
VPXRangeCoder *c = &s->c;
|
2014-02-18 13:52:30 +03:00
|
|
|
int part1_size, hscale, vscale, i, j, ret;
|
|
|
|
int width = s->avctx->width;
|
|
|
|
int height = s->avctx->height;
|
2019-08-01 13:54:21 +02:00
|
|
|
int alpha = 0;
|
|
|
|
int beta = 0;
|
2014-02-18 13:52:30 +03:00
|
|
|
|
2015-08-13 15:35:53 +02:00
|
|
|
if (buf_size < 4) {
|
|
|
|
return AVERROR_INVALIDDATA;
|
|
|
|
}
|
|
|
|
|
2014-04-01 15:21:51 +03:00
|
|
|
s->profile = (buf[0] >> 1) & 7;
|
2014-02-18 13:52:30 +03:00
|
|
|
if (s->profile > 1) {
|
|
|
|
avpriv_request_sample(s->avctx, "Unknown profile %d", s->profile);
|
|
|
|
return AVERROR_INVALIDDATA;
|
|
|
|
}
|
|
|
|
|
|
|
|
s->keyframe = !(buf[0] & 1);
|
|
|
|
s->invisible = 0;
|
|
|
|
part1_size = AV_RL24(buf) >> 4;
|
|
|
|
|
2014-03-29 06:25:50 +03:00
|
|
|
if (buf_size < 4 - s->profile + part1_size) {
|
|
|
|
av_log(s->avctx, AV_LOG_ERROR, "Buffer size %d is too small, needed : %d\n", buf_size, 4 - s->profile + part1_size);
|
|
|
|
return AVERROR_INVALIDDATA;
|
|
|
|
}
|
|
|
|
|
2014-02-18 13:52:30 +03:00
|
|
|
buf += 4 - s->profile;
|
|
|
|
buf_size -= 4 - s->profile;
|
|
|
|
|
|
|
|
memcpy(s->put_pixels_tab, s->vp8dsp.put_vp8_epel_pixels_tab, sizeof(s->put_pixels_tab));
|
|
|
|
|
2022-07-23 01:28:48 +02:00
|
|
|
ret = ff_vpx_init_range_decoder(c, buf, part1_size);
|
2017-03-07 20:09:38 +02:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
2014-02-18 13:52:30 +03:00
|
|
|
buf += part1_size;
|
|
|
|
buf_size -= part1_size;
|
|
|
|
|
|
|
|
/* A. Dimension information (keyframes only) */
|
|
|
|
if (s->keyframe) {
|
2022-07-23 00:04:29 +02:00
|
|
|
width = vp89_rac_get_uint(c, 12);
|
|
|
|
height = vp89_rac_get_uint(c, 12);
|
|
|
|
hscale = vp89_rac_get_uint(c, 2);
|
|
|
|
vscale = vp89_rac_get_uint(c, 2);
|
2014-02-18 13:52:30 +03:00
|
|
|
if (hscale || vscale)
|
|
|
|
avpriv_request_sample(s->avctx, "Upscaling");
|
|
|
|
|
avcodec/vp8, vp9: Avoid using VP56mv and VP56Frame in VP8/9
Instead replace VP56mv by new and identical structures VP8mv and VP9mv.
Also replace VP56Frame by VP8FrameType in vp8.h and use that
in VP8 code. Also remove VP56_FRAME_GOLDEN2, as this has only
been used by VP8, and use VP8_FRAME_ALTREF as replacement for
its usage in VP8 as this is more in line with VP8 verbiage.
This allows to remove all inclusions of vp56.h from everything
that is not VP5/6. This also removes implicit inclusions
of hpeldsp.h, h264chroma.h, vp3dsp.h and vp56dsp.h from all VP8/9
files.
(This also fixes a build issue: If one compiles with -O0 and disables
everything except the VP8-VAAPI encoder, the file containing
ff_vpx_norm_shift is not compiled, yet this is used implicitly
by vp56_rac_gets_nn() which is defined in vp56.h; it is unused
by the VP8-VAAPI encoder and declared as av_unused, yet with -O0
unused noninline functions are not optimized away, leading to
linking failures. With this patch, said function is not included
in vaapi_encode_vp8.c any more.)
Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
2022-07-23 02:01:41 +02:00
|
|
|
s->update_golden = s->update_altref = VP8_FRAME_CURRENT;
|
2014-02-18 13:52:30 +03:00
|
|
|
vp78_reset_probability_tables(s);
|
2014-04-01 15:21:51 +03:00
|
|
|
memcpy(s->prob->pred16x16, vp8_pred16x16_prob_inter,
|
|
|
|
sizeof(s->prob->pred16x16));
|
|
|
|
memcpy(s->prob->pred8x8c, vp8_pred8x8c_prob_inter,
|
|
|
|
sizeof(s->prob->pred8x8c));
|
2014-02-18 13:52:30 +03:00
|
|
|
for (i = 0; i < 2; i++)
|
2014-04-01 15:21:51 +03:00
|
|
|
memcpy(s->prob->mvc[i], vp7_mv_default_prob[i],
|
|
|
|
sizeof(vp7_mv_default_prob[i]));
|
2014-02-18 13:52:30 +03:00
|
|
|
memset(&s->segmentation, 0, sizeof(s->segmentation));
|
|
|
|
memset(&s->lf_delta, 0, sizeof(s->lf_delta));
|
2016-03-24 12:16:53 +02:00
|
|
|
memcpy(s->prob[0].scan, ff_zigzag_scan, sizeof(s->prob[0].scan));
|
2014-02-18 13:52:30 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
if (s->keyframe || s->profile > 0)
|
|
|
|
memset(s->inter_dc_pred, 0 , sizeof(s->inter_dc_pred));
|
|
|
|
|
|
|
|
/* B. Decoding information for all four macroblock-level features */
|
|
|
|
for (i = 0; i < 4; i++) {
|
2022-07-23 00:04:29 +02:00
|
|
|
s->feature_enabled[i] = vp89_rac_get(c);
|
2014-02-18 13:52:30 +03:00
|
|
|
if (s->feature_enabled[i]) {
|
2022-07-23 00:04:29 +02:00
|
|
|
s->feature_present_prob[i] = vp89_rac_get_uint(c, 8);
|
2014-02-18 13:52:30 +03:00
|
|
|
|
|
|
|
for (j = 0; j < 3; j++)
|
2014-04-01 15:21:51 +03:00
|
|
|
s->feature_index_prob[i][j] =
|
2022-07-23 00:04:29 +02:00
|
|
|
vp89_rac_get(c) ? vp89_rac_get_uint(c, 8) : 255;
|
2014-02-18 13:52:30 +03:00
|
|
|
|
2014-04-06 18:02:09 +03:00
|
|
|
if (vp7_feature_value_size[s->profile][i])
|
2014-02-18 13:52:30 +03:00
|
|
|
for (j = 0; j < 4; j++)
|
2014-04-01 15:21:51 +03:00
|
|
|
s->feature_value[i][j] =
|
2022-07-23 00:04:29 +02:00
|
|
|
vp89_rac_get(c) ? vp89_rac_get_uint(c, vp7_feature_value_size[s->profile][i]) : 0;
|
2014-02-18 13:52:30 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-04-01 15:21:51 +03:00
|
|
|
s->segmentation.enabled = 0;
|
2014-02-18 13:52:30 +03:00
|
|
|
s->segmentation.update_map = 0;
|
2014-04-01 15:21:51 +03:00
|
|
|
s->lf_delta.enabled = 0;
|
2014-02-18 13:52:30 +03:00
|
|
|
|
|
|
|
s->num_coeff_partitions = 1;
|
2022-07-23 01:28:48 +02:00
|
|
|
ret = ff_vpx_init_range_decoder(&s->coeff_partition[0], buf, buf_size);
|
2017-03-07 20:09:38 +02:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
2014-02-18 13:52:30 +03:00
|
|
|
|
|
|
|
if (!s->macroblocks_base || /* first frame */
|
2014-04-01 15:21:51 +03:00
|
|
|
width != s->avctx->width || height != s->avctx->height ||
|
|
|
|
(width + 15) / 16 != s->mb_width || (height + 15) / 16 != s->mb_height) {
|
|
|
|
if ((ret = vp7_update_dimensions(s, width, height)) < 0)
|
2014-02-18 13:52:30 +03:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* C. Dequantization indices */
|
|
|
|
vp7_get_quants(s);
|
|
|
|
|
|
|
|
/* D. Golden frame update flag (a Flag) for interframes only */
|
|
|
|
if (!s->keyframe) {
|
avcodec/vp8, vp9: Avoid using VP56mv and VP56Frame in VP8/9
Instead replace VP56mv by new and identical structures VP8mv and VP9mv.
Also replace VP56Frame by VP8FrameType in vp8.h and use that
in VP8 code. Also remove VP56_FRAME_GOLDEN2, as this has only
been used by VP8, and use VP8_FRAME_ALTREF as replacement for
its usage in VP8 as this is more in line with VP8 verbiage.
This allows to remove all inclusions of vp56.h from everything
that is not VP5/6. This also removes implicit inclusions
of hpeldsp.h, h264chroma.h, vp3dsp.h and vp56dsp.h from all VP8/9
files.
(This also fixes a build issue: If one compiles with -O0 and disables
everything except the VP8-VAAPI encoder, the file containing
ff_vpx_norm_shift is not compiled, yet this is used implicitly
by vp56_rac_gets_nn() which is defined in vp56.h; it is unused
by the VP8-VAAPI encoder and declared as av_unused, yet with -O0
unused noninline functions are not optimized away, leading to
linking failures. With this patch, said function is not included
in vaapi_encode_vp8.c any more.)
Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
2022-07-23 02:01:41 +02:00
|
|
|
s->update_golden = vp89_rac_get(c) ? VP8_FRAME_CURRENT : VP8_FRAME_NONE;
|
|
|
|
s->sign_bias[VP8_FRAME_GOLDEN] = 0;
|
2014-02-18 13:52:30 +03:00
|
|
|
}
|
|
|
|
|
2014-04-01 15:21:51 +03:00
|
|
|
s->update_last = 1;
|
2014-02-18 13:52:30 +03:00
|
|
|
s->update_probabilities = 1;
|
|
|
|
s->fade_present = 1;
|
|
|
|
|
|
|
|
if (s->profile > 0) {
|
2022-07-23 00:04:29 +02:00
|
|
|
s->update_probabilities = vp89_rac_get(c);
|
2014-02-18 13:52:30 +03:00
|
|
|
if (!s->update_probabilities)
|
|
|
|
s->prob[1] = s->prob[0];
|
|
|
|
|
|
|
|
if (!s->keyframe)
|
2022-07-23 00:04:29 +02:00
|
|
|
s->fade_present = vp89_rac_get(c);
|
2014-02-18 13:52:30 +03:00
|
|
|
}
|
|
|
|
|
2022-07-23 01:28:48 +02:00
|
|
|
if (vpx_rac_is_end(c))
|
2018-02-17 05:20:52 +02:00
|
|
|
return AVERROR_INVALIDDATA;
|
2014-02-18 13:52:30 +03:00
|
|
|
/* E. Fading information for previous frame */
|
2022-07-23 00:04:29 +02:00
|
|
|
if (s->fade_present && vp89_rac_get(c)) {
|
|
|
|
alpha = (int8_t) vp89_rac_get_uint(c, 8);
|
|
|
|
beta = (int8_t) vp89_rac_get_uint(c, 8);
|
2014-02-18 13:52:30 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/* F. Loop filter type */
|
|
|
|
if (!s->profile)
|
2022-07-23 00:04:29 +02:00
|
|
|
s->filter.simple = vp89_rac_get(c);
|
2014-02-18 13:52:30 +03:00
|
|
|
|
|
|
|
/* G. DCT coefficient ordering specification */
|
2022-07-23 00:04:29 +02:00
|
|
|
if (vp89_rac_get(c))
|
2014-02-18 13:52:30 +03:00
|
|
|
for (i = 1; i < 16; i++)
|
2022-07-23 00:04:29 +02:00
|
|
|
s->prob[0].scan[i] = ff_zigzag_scan[vp89_rac_get_uint(c, 4)];
|
2014-02-18 13:52:30 +03:00
|
|
|
|
|
|
|
/* H. Loop filter levels */
|
|
|
|
if (s->profile > 0)
|
2022-07-23 00:04:29 +02:00
|
|
|
s->filter.simple = vp89_rac_get(c);
|
|
|
|
s->filter.level = vp89_rac_get_uint(c, 6);
|
|
|
|
s->filter.sharpness = vp89_rac_get_uint(c, 3);
|
2014-02-18 13:52:30 +03:00
|
|
|
|
|
|
|
/* I. DCT coefficient probability update; 13.3 Token Probability Updates */
|
|
|
|
vp78_update_probability_tables(s);
|
|
|
|
|
|
|
|
s->mbskip_enabled = 0;
|
|
|
|
|
|
|
|
/* J. The remaining frame header data occurs ONLY FOR INTERFRAMES */
|
|
|
|
if (!s->keyframe) {
|
2022-07-23 00:04:29 +02:00
|
|
|
s->prob->intra = vp89_rac_get_uint(c, 8);
|
|
|
|
s->prob->last = vp89_rac_get_uint(c, 8);
|
2014-04-01 15:21:51 +03:00
|
|
|
vp78_update_pred16x16_pred8x8_mvc_probabilities(s, VP7_MVC_SIZE);
|
2014-02-18 13:52:30 +03:00
|
|
|
}
|
|
|
|
|
2022-07-23 01:28:48 +02:00
|
|
|
if (vpx_rac_is_end(c))
|
2019-08-01 13:54:21 +02:00
|
|
|
return AVERROR_INVALIDDATA;
|
|
|
|
|
|
|
|
if ((ret = vp7_fade_frame(s, alpha, beta)) < 0)
|
|
|
|
return ret;
|
|
|
|
|
2014-02-18 13:52:30 +03:00
|
|
|
return 0;
|
|
|
|
}
|
2010-06-22 22:24:09 +03:00
|
|
|
|
2014-02-18 13:52:30 +03:00
|
|
|
static int vp8_decode_frame_header(VP8Context *s, const uint8_t *buf, int buf_size)
|
2010-06-22 22:24:09 +03:00
|
|
|
{
|
2022-07-23 01:28:48 +02:00
|
|
|
VPXRangeCoder *c = &s->c;
|
2014-02-18 13:52:30 +03:00
|
|
|
int header_size, hscale, vscale, ret;
|
2010-06-22 22:24:09 +03:00
|
|
|
int width = s->avctx->width;
|
|
|
|
int height = s->avctx->height;
|
|
|
|
|
2015-07-18 19:18:24 +02:00
|
|
|
if (buf_size < 3) {
|
|
|
|
av_log(s->avctx, AV_LOG_ERROR, "Insufficent data (%d) for header\n", buf_size);
|
|
|
|
return AVERROR_INVALIDDATA;
|
|
|
|
}
|
|
|
|
|
2010-06-22 22:24:09 +03:00
|
|
|
s->keyframe = !(buf[0] & 1);
|
|
|
|
s->profile = (buf[0]>>1) & 7;
|
|
|
|
s->invisible = !(buf[0] & 0x10);
|
2010-07-24 00:17:18 +03:00
|
|
|
header_size = AV_RL24(buf) >> 5;
|
2010-06-22 22:24:09 +03:00
|
|
|
buf += 3;
|
|
|
|
buf_size -= 3;
|
|
|
|
|
2017-11-18 19:55:18 +02:00
|
|
|
s->header_partition_size = header_size;
|
|
|
|
|
2010-06-27 04:46:29 +03:00
|
|
|
if (s->profile > 3)
|
|
|
|
av_log(s->avctx, AV_LOG_WARNING, "Unknown profile %d\n", s->profile);
|
|
|
|
|
|
|
|
if (!s->profile)
|
2014-03-28 03:13:54 +03:00
|
|
|
memcpy(s->put_pixels_tab, s->vp8dsp.put_vp8_epel_pixels_tab,
|
|
|
|
sizeof(s->put_pixels_tab));
|
2010-06-27 04:46:29 +03:00
|
|
|
else // profile 1-3 use bilinear, 4+ aren't defined so whatever
|
2014-03-28 03:13:54 +03:00
|
|
|
memcpy(s->put_pixels_tab, s->vp8dsp.put_vp8_bilinear_pixels_tab,
|
|
|
|
sizeof(s->put_pixels_tab));
|
2010-06-22 22:24:09 +03:00
|
|
|
|
2014-03-28 03:13:54 +03:00
|
|
|
if (header_size > buf_size - 7 * s->keyframe) {
|
2010-06-22 22:24:09 +03:00
|
|
|
av_log(s->avctx, AV_LOG_ERROR, "Header size larger than data provided\n");
|
|
|
|
return AVERROR_INVALIDDATA;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (s->keyframe) {
|
2010-07-24 00:17:18 +03:00
|
|
|
if (AV_RL24(buf) != 0x2a019d) {
|
2014-03-28 03:13:54 +03:00
|
|
|
av_log(s->avctx, AV_LOG_ERROR,
|
|
|
|
"Invalid start code 0x%x\n", AV_RL24(buf));
|
2010-06-22 22:24:09 +03:00
|
|
|
return AVERROR_INVALIDDATA;
|
|
|
|
}
|
2014-03-28 03:13:54 +03:00
|
|
|
width = AV_RL16(buf + 3) & 0x3fff;
|
|
|
|
height = AV_RL16(buf + 5) & 0x3fff;
|
|
|
|
hscale = buf[4] >> 6;
|
|
|
|
vscale = buf[6] >> 6;
|
2010-06-22 22:24:09 +03:00
|
|
|
buf += 7;
|
|
|
|
buf_size -= 7;
|
|
|
|
|
2010-06-27 03:37:43 +03:00
|
|
|
if (hscale || vscale)
|
2013-03-13 23:18:34 +03:00
|
|
|
avpriv_request_sample(s->avctx, "Upscaling");
|
2010-06-27 03:37:43 +03:00
|
|
|
|
avcodec/vp8, vp9: Avoid using VP56mv and VP56Frame in VP8/9
Instead replace VP56mv by new and identical structures VP8mv and VP9mv.
Also replace VP56Frame by VP8FrameType in vp8.h and use that
in VP8 code. Also remove VP56_FRAME_GOLDEN2, as this has only
been used by VP8, and use VP8_FRAME_ALTREF as replacement for
its usage in VP8 as this is more in line with VP8 verbiage.
This allows to remove all inclusions of vp56.h from everything
that is not VP5/6. This also removes implicit inclusions
of hpeldsp.h, h264chroma.h, vp3dsp.h and vp56dsp.h from all VP8/9
files.
(This also fixes a build issue: If one compiles with -O0 and disables
everything except the VP8-VAAPI encoder, the file containing
ff_vpx_norm_shift is not compiled, yet this is used implicitly
by vp56_rac_gets_nn() which is defined in vp56.h; it is unused
by the VP8-VAAPI encoder and declared as av_unused, yet with -O0
unused noninline functions are not optimized away, leading to
linking failures. With this patch, said function is not included
in vaapi_encode_vp8.c any more.)
Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
2022-07-23 02:01:41 +02:00
|
|
|
s->update_golden = s->update_altref = VP8_FRAME_CURRENT;
|
2014-02-18 13:52:30 +03:00
|
|
|
vp78_reset_probability_tables(s);
|
2014-03-28 03:13:54 +03:00
|
|
|
memcpy(s->prob->pred16x16, vp8_pred16x16_prob_inter,
|
|
|
|
sizeof(s->prob->pred16x16));
|
|
|
|
memcpy(s->prob->pred8x8c, vp8_pred8x8c_prob_inter,
|
|
|
|
sizeof(s->prob->pred8x8c));
|
|
|
|
memcpy(s->prob->mvc, vp8_mv_default_prob,
|
|
|
|
sizeof(s->prob->mvc));
|
2010-06-22 22:24:09 +03:00
|
|
|
memset(&s->segmentation, 0, sizeof(s->segmentation));
|
2012-10-13 13:43:24 +03:00
|
|
|
memset(&s->lf_delta, 0, sizeof(s->lf_delta));
|
2010-06-22 22:24:09 +03:00
|
|
|
}
|
|
|
|
|
2022-07-23 01:28:48 +02:00
|
|
|
ret = ff_vpx_init_range_decoder(c, buf, header_size);
|
2017-03-07 20:09:38 +02:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
2010-06-22 22:24:09 +03:00
|
|
|
buf += header_size;
|
|
|
|
buf_size -= header_size;
|
|
|
|
|
|
|
|
if (s->keyframe) {
|
2022-07-23 00:04:29 +02:00
|
|
|
s->colorspace = vp89_rac_get(c);
|
2014-10-06 00:58:50 +03:00
|
|
|
if (s->colorspace)
|
2010-06-22 22:24:09 +03:00
|
|
|
av_log(s->avctx, AV_LOG_WARNING, "Unspecified colorspace\n");
|
2022-07-23 00:04:29 +02:00
|
|
|
s->fullrange = vp89_rac_get(c);
|
2010-06-22 22:24:09 +03:00
|
|
|
}
|
|
|
|
|
2022-07-23 00:04:29 +02:00
|
|
|
if ((s->segmentation.enabled = vp89_rac_get(c)))
|
2010-06-22 22:24:09 +03:00
|
|
|
parse_segment_info(s);
|
|
|
|
else
|
|
|
|
s->segmentation.update_map = 0; // FIXME: move this to some init function?
|
|
|
|
|
2022-07-23 00:04:29 +02:00
|
|
|
s->filter.simple = vp89_rac_get(c);
|
|
|
|
s->filter.level = vp89_rac_get_uint(c, 6);
|
|
|
|
s->filter.sharpness = vp89_rac_get_uint(c, 3);
|
2010-06-22 22:24:09 +03:00
|
|
|
|
2022-07-23 00:04:29 +02:00
|
|
|
if ((s->lf_delta.enabled = vp89_rac_get(c))) {
|
|
|
|
s->lf_delta.update = vp89_rac_get(c);
|
2017-11-18 19:55:18 +02:00
|
|
|
if (s->lf_delta.update)
|
2010-06-22 22:24:09 +03:00
|
|
|
update_lf_deltas(s);
|
2017-11-18 19:55:18 +02:00
|
|
|
}
|
2010-06-22 22:24:09 +03:00
|
|
|
|
|
|
|
if (setup_partitions(s, buf, buf_size)) {
|
|
|
|
av_log(s->avctx, AV_LOG_ERROR, "Invalid partitions\n");
|
|
|
|
return AVERROR_INVALIDDATA;
|
|
|
|
}
|
|
|
|
|
2012-07-12 23:07:06 +03:00
|
|
|
if (!s->macroblocks_base || /* first frame */
|
2014-03-30 03:39:46 +03:00
|
|
|
width != s->avctx->width || height != s->avctx->height ||
|
|
|
|
(width+15)/16 != s->mb_width || (height+15)/16 != s->mb_height)
|
2014-04-01 15:21:51 +03:00
|
|
|
if ((ret = vp8_update_dimensions(s, width, height)) < 0)
|
2012-07-12 23:07:06 +03:00
|
|
|
return ret;
|
|
|
|
|
2014-02-18 13:52:30 +03:00
|
|
|
vp8_get_quants(s);
|
2010-06-22 22:24:09 +03:00
|
|
|
|
|
|
|
if (!s->keyframe) {
|
|
|
|
update_refs(s);
|
avcodec/vp8, vp9: Avoid using VP56mv and VP56Frame in VP8/9
Instead replace VP56mv by new and identical structures VP8mv and VP9mv.
Also replace VP56Frame by VP8FrameType in vp8.h and use that
in VP8 code. Also remove VP56_FRAME_GOLDEN2, as this has only
been used by VP8, and use VP8_FRAME_ALTREF as replacement for
its usage in VP8 as this is more in line with VP8 verbiage.
This allows to remove all inclusions of vp56.h from everything
that is not VP5/6. This also removes implicit inclusions
of hpeldsp.h, h264chroma.h, vp3dsp.h and vp56dsp.h from all VP8/9
files.
(This also fixes a build issue: If one compiles with -O0 and disables
everything except the VP8-VAAPI encoder, the file containing
ff_vpx_norm_shift is not compiled, yet this is used implicitly
by vp56_rac_gets_nn() which is defined in vp56.h; it is unused
by the VP8-VAAPI encoder and declared as av_unused, yet with -O0
unused noninline functions are not optimized away, leading to
linking failures. With this patch, said function is not included
in vaapi_encode_vp8.c any more.)
Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
2022-07-23 02:01:41 +02:00
|
|
|
s->sign_bias[VP8_FRAME_GOLDEN] = vp89_rac_get(c);
|
|
|
|
s->sign_bias[VP8_FRAME_ALTREF] = vp89_rac_get(c);
|
2010-06-22 22:24:09 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// if we aren't saving this frame's probabilities for future frames,
|
|
|
|
// make a copy of the current probabilities
|
2022-07-23 00:04:29 +02:00
|
|
|
if (!(s->update_probabilities = vp89_rac_get(c)))
|
2010-06-22 22:24:09 +03:00
|
|
|
s->prob[1] = s->prob[0];
|
|
|
|
|
2022-07-23 00:04:29 +02:00
|
|
|
s->update_last = s->keyframe || vp89_rac_get(c);
|
2010-06-22 22:24:09 +03:00
|
|
|
|
2014-02-18 13:52:30 +03:00
|
|
|
vp78_update_probability_tables(s);
|
2010-06-22 22:24:09 +03:00
|
|
|
|
2022-07-23 00:04:29 +02:00
|
|
|
if ((s->mbskip_enabled = vp89_rac_get(c)))
|
|
|
|
s->prob->mbskip = vp89_rac_get_uint(c, 8);
|
2010-06-22 22:24:09 +03:00
|
|
|
|
|
|
|
if (!s->keyframe) {
|
2022-07-23 00:04:29 +02:00
|
|
|
s->prob->intra = vp89_rac_get_uint(c, 8);
|
|
|
|
s->prob->last = vp89_rac_get_uint(c, 8);
|
|
|
|
s->prob->golden = vp89_rac_get_uint(c, 8);
|
2014-04-01 15:21:51 +03:00
|
|
|
vp78_update_pred16x16_pred8x8_mvc_probabilities(s, VP8_MVC_SIZE);
|
2010-06-22 22:24:09 +03:00
|
|
|
}
|
|
|
|
|
2017-11-18 19:55:18 +02:00
|
|
|
// Record the entropy coder state here so that hwaccels can use it.
|
2022-07-23 01:28:48 +02:00
|
|
|
s->c.code_word = vpx_rac_renorm(&s->c);
|
2017-11-18 19:55:18 +02:00
|
|
|
s->coder_state_at_header_end.input = s->c.buffer - (-s->c.bits / 8);
|
|
|
|
s->coder_state_at_header_end.range = s->c.high;
|
|
|
|
s->coder_state_at_header_end.value = s->c.code_word >> 16;
|
|
|
|
s->coder_state_at_header_end.bit_count = -s->c.bits % 8;
|
|
|
|
|
2010-06-22 22:24:09 +03:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-03-28 03:13:54 +03:00
|
|
|
static av_always_inline
|
avcodec/vp8, vp9: Avoid using VP56mv and VP56Frame in VP8/9
Instead replace VP56mv by new and identical structures VP8mv and VP9mv.
Also replace VP56Frame by VP8FrameType in vp8.h and use that
in VP8 code. Also remove VP56_FRAME_GOLDEN2, as this has only
been used by VP8, and use VP8_FRAME_ALTREF as replacement for
its usage in VP8 as this is more in line with VP8 verbiage.
This allows to remove all inclusions of vp56.h from everything
that is not VP5/6. This also removes implicit inclusions
of hpeldsp.h, h264chroma.h, vp3dsp.h and vp56dsp.h from all VP8/9
files.
(This also fixes a build issue: If one compiles with -O0 and disables
everything except the VP8-VAAPI encoder, the file containing
ff_vpx_norm_shift is not compiled, yet this is used implicitly
by vp56_rac_gets_nn() which is defined in vp56.h; it is unused
by the VP8-VAAPI encoder and declared as av_unused, yet with -O0
unused noninline functions are not optimized away, leading to
linking failures. With this patch, said function is not included
in vaapi_encode_vp8.c any more.)
Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
2022-07-23 02:01:41 +02:00
|
|
|
void clamp_mv(VP8mvbounds *s, VP8mv *dst, const VP8mv *src)
|
2010-06-22 22:24:09 +03:00
|
|
|
{
|
vp8: change mv_{min,max}.{x,y} type to int
If one of the dimensions is larger than 8176, s->mb_width or
s->mb_height is larger than 511, leading to an int16_t overflow of
s->mv_max.{x,y}. This then causes av_clip to be called with amin > amax.
Changing the type to int avoids the overflow and has no negative
effect, because s->mv_max is only used in clamp_mv for clipping.
Since mv_max.{x,y} is positive and mv_min.{x,y} negative, av_clip can't
increase the absolute value. The input to av_clip is an int16_t, and
thus the output fits into int16_t as well.
For additional safety, s->mv_{min,max}.{x,y} are clipped to int16_t range
before use.
Reviewed-by: Ronald S. Bultje <rsbultje@gmail.com>
Signed-off-by: Andreas Cadhalpun <Andreas.Cadhalpun@googlemail.com>
2015-06-08 22:38:29 +02:00
|
|
|
dst->x = av_clip(src->x, av_clip(s->mv_min.x, INT16_MIN, INT16_MAX),
|
|
|
|
av_clip(s->mv_max.x, INT16_MIN, INT16_MAX));
|
|
|
|
dst->y = av_clip(src->y, av_clip(s->mv_min.y, INT16_MIN, INT16_MAX),
|
|
|
|
av_clip(s->mv_max.y, INT16_MIN, INT16_MAX));
|
2010-06-22 22:24:09 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Motion vector coding, 17.1.
|
|
|
|
*/
|
2022-07-23 01:28:48 +02:00
|
|
|
static av_always_inline int read_mv_component(VPXRangeCoder *c, const uint8_t *p, int vp7)
|
2010-06-22 22:24:09 +03:00
|
|
|
{
|
2010-07-24 00:46:25 +03:00
|
|
|
int bit, x = 0;
|
2010-06-22 22:24:09 +03:00
|
|
|
|
2022-07-23 01:28:48 +02:00
|
|
|
if (vpx_rac_get_prob_branchy(c, p[0])) {
|
2010-06-22 22:24:09 +03:00
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < 3; i++)
|
2022-07-23 01:28:48 +02:00
|
|
|
x += vpx_rac_get_prob(c, p[9 + i]) << i;
|
2014-02-18 13:52:30 +03:00
|
|
|
for (i = (vp7 ? 7 : 9); i > 3; i--)
|
2022-07-23 01:28:48 +02:00
|
|
|
x += vpx_rac_get_prob(c, p[9 + i]) << i;
|
|
|
|
if (!(x & (vp7 ? 0xF0 : 0xFFF0)) || vpx_rac_get_prob(c, p[12]))
|
2010-06-22 22:24:09 +03:00
|
|
|
x += 8;
|
2010-07-24 00:46:25 +03:00
|
|
|
} else {
|
|
|
|
// small_mvtree
|
2014-03-28 03:13:54 +03:00
|
|
|
const uint8_t *ps = p + 2;
|
2022-07-23 01:28:48 +02:00
|
|
|
bit = vpx_rac_get_prob(c, *ps);
|
2014-03-28 03:13:54 +03:00
|
|
|
ps += 1 + 3 * bit;
|
|
|
|
x += 4 * bit;
|
2022-07-23 01:28:48 +02:00
|
|
|
bit = vpx_rac_get_prob(c, *ps);
|
2010-07-24 00:46:25 +03:00
|
|
|
ps += 1 + bit;
|
2014-03-28 03:13:54 +03:00
|
|
|
x += 2 * bit;
|
2022-07-23 01:28:48 +02:00
|
|
|
x += vpx_rac_get_prob(c, *ps);
|
2010-07-24 00:46:25 +03:00
|
|
|
}
|
2010-06-22 22:24:09 +03:00
|
|
|
|
2022-07-23 01:28:48 +02:00
|
|
|
return (x && vpx_rac_get_prob(c, p[1])) ? -x : x;
|
2010-06-22 22:24:09 +03:00
|
|
|
}
|
|
|
|
|
2022-07-23 01:28:48 +02:00
|
|
|
static int vp7_read_mv_component(VPXRangeCoder *c, const uint8_t *p)
|
2014-02-18 13:52:30 +03:00
|
|
|
{
|
|
|
|
return read_mv_component(c, p, 1);
|
|
|
|
}
|
|
|
|
|
2022-07-23 01:28:48 +02:00
|
|
|
static int vp8_read_mv_component(VPXRangeCoder *c, const uint8_t *p)
|
2014-02-18 13:52:30 +03:00
|
|
|
{
|
|
|
|
return read_mv_component(c, p, 0);
|
|
|
|
}
|
|
|
|
|
2010-07-24 00:36:21 +03:00
|
|
|
static av_always_inline
|
2014-04-01 15:21:51 +03:00
|
|
|
const uint8_t *get_submv_prob(uint32_t left, uint32_t top, int is_vp7)
|
2010-06-22 22:24:09 +03:00
|
|
|
{
|
2014-04-01 15:21:51 +03:00
|
|
|
if (is_vp7)
|
|
|
|
return vp7_submv_prob;
|
|
|
|
|
2010-07-22 09:29:26 +03:00
|
|
|
if (left == top)
|
2014-03-28 03:13:54 +03:00
|
|
|
return vp8_submv_prob[4 - !!left];
|
2010-07-22 09:29:26 +03:00
|
|
|
if (!top)
|
2010-06-22 22:24:09 +03:00
|
|
|
return vp8_submv_prob[2];
|
2014-03-28 03:13:54 +03:00
|
|
|
return vp8_submv_prob[1 - !!left];
|
2010-06-22 22:24:09 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Split motion vector prediction, 16.4.
|
2010-06-28 19:04:14 +03:00
|
|
|
* @returns the number of motion vectors parsed (2, 4 or 16)
|
2010-06-22 22:24:09 +03:00
|
|
|
*/
|
2010-07-24 00:36:21 +03:00
|
|
|
static av_always_inline
|
2022-07-23 01:28:48 +02:00
|
|
|
int decode_splitmvs(VP8Context *s, VPXRangeCoder *c, VP8Macroblock *mb,
|
2014-04-01 15:21:51 +03:00
|
|
|
int layout, int is_vp7)
|
2010-06-22 22:24:09 +03:00
|
|
|
{
|
2010-08-03 14:10:58 +03:00
|
|
|
int part_idx;
|
|
|
|
int n, num;
|
2012-07-12 23:07:06 +03:00
|
|
|
VP8Macroblock *top_mb;
|
2010-07-22 09:29:26 +03:00
|
|
|
VP8Macroblock *left_mb = &mb[-1];
|
2014-03-28 03:13:54 +03:00
|
|
|
const uint8_t *mbsplits_left = vp8_mbsplits[left_mb->partitioning];
|
|
|
|
const uint8_t *mbsplits_top, *mbsplits_cur, *firstidx;
|
avcodec/vp8, vp9: Avoid using VP56mv and VP56Frame in VP8/9
Instead replace VP56mv by new and identical structures VP8mv and VP9mv.
Also replace VP56Frame by VP8FrameType in vp8.h and use that
in VP8 code. Also remove VP56_FRAME_GOLDEN2, as this has only
been used by VP8, and use VP8_FRAME_ALTREF as replacement for
its usage in VP8 as this is more in line with VP8 verbiage.
This allows to remove all inclusions of vp56.h from everything
that is not VP5/6. This also removes implicit inclusions
of hpeldsp.h, h264chroma.h, vp3dsp.h and vp56dsp.h from all VP8/9
files.
(This also fixes a build issue: If one compiles with -O0 and disables
everything except the VP8-VAAPI encoder, the file containing
ff_vpx_norm_shift is not compiled, yet this is used implicitly
by vp56_rac_gets_nn() which is defined in vp56.h; it is unused
by the VP8-VAAPI encoder and declared as av_unused, yet with -O0
unused noninline functions are not optimized away, leading to
linking failures. With this patch, said function is not included
in vaapi_encode_vp8.c any more.)
Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
2022-07-23 02:01:41 +02:00
|
|
|
VP8mv *top_mv;
|
|
|
|
VP8mv *left_mv = left_mb->bmv;
|
|
|
|
VP8mv *cur_mv = mb->bmv;
|
2010-06-22 22:24:09 +03:00
|
|
|
|
2012-07-12 23:07:06 +03:00
|
|
|
if (!layout) // layout is inlined, s->mb_layout is not
|
|
|
|
top_mb = &mb[2];
|
|
|
|
else
|
2014-03-28 03:13:54 +03:00
|
|
|
top_mb = &mb[-s->mb_width - 1];
|
2012-07-12 23:07:06 +03:00
|
|
|
mbsplits_top = vp8_mbsplits[top_mb->partitioning];
|
2014-03-28 03:13:54 +03:00
|
|
|
top_mv = top_mb->bmv;
|
2012-07-12 23:07:06 +03:00
|
|
|
|
2022-07-23 01:28:48 +02:00
|
|
|
if (vpx_rac_get_prob_branchy(c, vp8_mbsplit_prob[0])) {
|
|
|
|
if (vpx_rac_get_prob_branchy(c, vp8_mbsplit_prob[1]))
|
|
|
|
part_idx = VP8_SPLITMVMODE_16x8 + vpx_rac_get_prob(c, vp8_mbsplit_prob[2]);
|
2014-03-28 03:13:54 +03:00
|
|
|
else
|
2010-08-03 14:10:58 +03:00
|
|
|
part_idx = VP8_SPLITMVMODE_8x8;
|
|
|
|
} else {
|
|
|
|
part_idx = VP8_SPLITMVMODE_4x4;
|
|
|
|
}
|
|
|
|
|
2014-03-28 03:13:54 +03:00
|
|
|
num = vp8_mbsplit_count[part_idx];
|
|
|
|
mbsplits_cur = vp8_mbsplits[part_idx],
|
|
|
|
firstidx = vp8_mbfirstidx[part_idx];
|
2010-08-03 14:10:58 +03:00
|
|
|
mb->partitioning = part_idx;
|
|
|
|
|
2010-06-22 22:24:09 +03:00
|
|
|
for (n = 0; n < num; n++) {
|
2010-06-28 19:04:14 +03:00
|
|
|
int k = firstidx[n];
|
2010-07-22 09:29:26 +03:00
|
|
|
uint32_t left, above;
|
2010-06-28 19:04:14 +03:00
|
|
|
const uint8_t *submv_prob;
|
|
|
|
|
2010-07-22 09:29:26 +03:00
|
|
|
if (!(k & 3))
|
|
|
|
left = AV_RN32A(&left_mv[mbsplits_left[k + 3]]);
|
|
|
|
else
|
2014-03-28 03:13:54 +03:00
|
|
|
left = AV_RN32A(&cur_mv[mbsplits_cur[k - 1]]);
|
2010-07-22 09:29:26 +03:00
|
|
|
if (k <= 3)
|
|
|
|
above = AV_RN32A(&top_mv[mbsplits_top[k + 12]]);
|
|
|
|
else
|
|
|
|
above = AV_RN32A(&cur_mv[mbsplits_cur[k - 4]]);
|
2010-06-28 19:04:14 +03:00
|
|
|
|
2014-04-01 15:21:51 +03:00
|
|
|
submv_prob = get_submv_prob(left, above, is_vp7);
|
2010-06-22 22:24:09 +03:00
|
|
|
|
2022-07-23 01:28:48 +02:00
|
|
|
if (vpx_rac_get_prob_branchy(c, submv_prob[0])) {
|
|
|
|
if (vpx_rac_get_prob_branchy(c, submv_prob[1])) {
|
|
|
|
if (vpx_rac_get_prob_branchy(c, submv_prob[2])) {
|
2014-04-01 15:21:51 +03:00
|
|
|
mb->bmv[n].y = mb->mv.y +
|
|
|
|
read_mv_component(c, s->prob->mvc[0], is_vp7);
|
|
|
|
mb->bmv[n].x = mb->mv.x +
|
|
|
|
read_mv_component(c, s->prob->mvc[1], is_vp7);
|
2010-08-03 13:37:14 +03:00
|
|
|
} else {
|
|
|
|
AV_ZERO32(&mb->bmv[n]);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
AV_WN32A(&mb->bmv[n], above);
|
|
|
|
}
|
|
|
|
} else {
|
2010-07-22 09:29:26 +03:00
|
|
|
AV_WN32A(&mb->bmv[n], left);
|
2010-06-22 22:24:09 +03:00
|
|
|
}
|
|
|
|
}
|
2010-06-28 19:04:14 +03:00
|
|
|
|
|
|
|
return num;
|
2010-06-22 22:24:09 +03:00
|
|
|
}
|
|
|
|
|
2014-02-18 13:52:30 +03:00
|
|
|
/**
|
2014-04-01 15:21:51 +03:00
|
|
|
* The vp7 reference decoder uses a padding macroblock column (added to right
|
|
|
|
* edge of the frame) to guard against illegal macroblock offsets. The
|
|
|
|
* algorithm has bugs that permit offsets to straddle the padding column.
|
|
|
|
* This function replicates those bugs.
|
|
|
|
*
|
2014-02-18 13:52:30 +03:00
|
|
|
* @param[out] edge_x macroblock x address
|
|
|
|
* @param[out] edge_y macroblock y address
|
2014-04-01 15:21:51 +03:00
|
|
|
*
|
2014-02-18 13:52:30 +03:00
|
|
|
* @return macroblock offset legal (boolean)
|
|
|
|
*/
|
2014-04-01 15:21:51 +03:00
|
|
|
static int vp7_calculate_mb_offset(int mb_x, int mb_y, int mb_width,
|
|
|
|
int xoffset, int yoffset, int boundary,
|
|
|
|
int *edge_x, int *edge_y)
|
2014-02-18 13:52:30 +03:00
|
|
|
{
|
|
|
|
int vwidth = mb_width + 1;
|
|
|
|
int new = (mb_y + yoffset) * vwidth + mb_x + xoffset;
|
|
|
|
if (new < boundary || new % vwidth == vwidth - 1)
|
|
|
|
return 0;
|
|
|
|
*edge_y = new / vwidth;
|
|
|
|
*edge_x = new % vwidth;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
avcodec/vp8, vp9: Avoid using VP56mv and VP56Frame in VP8/9
Instead replace VP56mv by new and identical structures VP8mv and VP9mv.
Also replace VP56Frame by VP8FrameType in vp8.h and use that
in VP8 code. Also remove VP56_FRAME_GOLDEN2, as this has only
been used by VP8, and use VP8_FRAME_ALTREF as replacement for
its usage in VP8 as this is more in line with VP8 verbiage.
This allows to remove all inclusions of vp56.h from everything
that is not VP5/6. This also removes implicit inclusions
of hpeldsp.h, h264chroma.h, vp3dsp.h and vp56dsp.h from all VP8/9
files.
(This also fixes a build issue: If one compiles with -O0 and disables
everything except the VP8-VAAPI encoder, the file containing
ff_vpx_norm_shift is not compiled, yet this is used implicitly
by vp56_rac_gets_nn() which is defined in vp56.h; it is unused
by the VP8-VAAPI encoder and declared as av_unused, yet with -O0
unused noninline functions are not optimized away, leading to
linking failures. With this patch, said function is not included
in vaapi_encode_vp8.c any more.)
Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
2022-07-23 02:01:41 +02:00
|
|
|
static const VP8mv *get_bmv_ptr(const VP8Macroblock *mb, int subblock)
|
2014-02-18 13:52:30 +03:00
|
|
|
{
|
|
|
|
return &mb->bmv[mb->mode == VP8_MVMODE_SPLIT ? vp8_mbsplits[mb->partitioning][subblock] : 0];
|
|
|
|
}
|
|
|
|
|
2011-02-10 08:43:25 +02:00
|
|
|
static av_always_inline
|
2014-04-01 15:21:51 +03:00
|
|
|
void vp7_decode_mvs(VP8Context *s, VP8Macroblock *mb,
|
|
|
|
int mb_x, int mb_y, int layout)
|
2014-02-18 13:52:30 +03:00
|
|
|
{
|
|
|
|
VP8Macroblock *mb_edge[12];
|
|
|
|
enum { CNT_ZERO, CNT_NEAREST, CNT_NEAR };
|
|
|
|
enum { VP8_EDGE_TOP, VP8_EDGE_LEFT, VP8_EDGE_TOPLEFT };
|
|
|
|
int idx = CNT_ZERO;
|
avcodec/vp8, vp9: Avoid using VP56mv and VP56Frame in VP8/9
Instead replace VP56mv by new and identical structures VP8mv and VP9mv.
Also replace VP56Frame by VP8FrameType in vp8.h and use that
in VP8 code. Also remove VP56_FRAME_GOLDEN2, as this has only
been used by VP8, and use VP8_FRAME_ALTREF as replacement for
its usage in VP8 as this is more in line with VP8 verbiage.
This allows to remove all inclusions of vp56.h from everything
that is not VP5/6. This also removes implicit inclusions
of hpeldsp.h, h264chroma.h, vp3dsp.h and vp56dsp.h from all VP8/9
files.
(This also fixes a build issue: If one compiles with -O0 and disables
everything except the VP8-VAAPI encoder, the file containing
ff_vpx_norm_shift is not compiled, yet this is used implicitly
by vp56_rac_gets_nn() which is defined in vp56.h; it is unused
by the VP8-VAAPI encoder and declared as av_unused, yet with -O0
unused noninline functions are not optimized away, leading to
linking failures. With this patch, said function is not included
in vaapi_encode_vp8.c any more.)
Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
2022-07-23 02:01:41 +02:00
|
|
|
VP8mv near_mv[3];
|
2014-02-18 13:52:30 +03:00
|
|
|
uint8_t cnt[3] = { 0 };
|
2022-07-23 01:28:48 +02:00
|
|
|
VPXRangeCoder *c = &s->c;
|
2014-02-18 13:52:30 +03:00
|
|
|
int i;
|
|
|
|
|
|
|
|
AV_ZERO32(&near_mv[0]);
|
|
|
|
AV_ZERO32(&near_mv[1]);
|
|
|
|
AV_ZERO32(&near_mv[2]);
|
|
|
|
|
|
|
|
for (i = 0; i < VP7_MV_PRED_COUNT; i++) {
|
|
|
|
const VP7MVPred * pred = &vp7_mv_pred[i];
|
|
|
|
int edge_x, edge_y;
|
|
|
|
|
2014-04-01 15:21:51 +03:00
|
|
|
if (vp7_calculate_mb_offset(mb_x, mb_y, s->mb_width, pred->xoffset,
|
|
|
|
pred->yoffset, !s->profile, &edge_x, &edge_y)) {
|
|
|
|
VP8Macroblock *edge = mb_edge[i] = (s->mb_layout == 1)
|
|
|
|
? s->macroblocks_base + 1 + edge_x +
|
|
|
|
(s->mb_width + 1) * (edge_y + 1)
|
|
|
|
: s->macroblocks + edge_x +
|
|
|
|
(s->mb_height - edge_y - 1) * 2;
|
2014-02-18 13:52:30 +03:00
|
|
|
uint32_t mv = AV_RN32A(get_bmv_ptr(edge, vp7_mv_pred[i].subblock));
|
|
|
|
if (mv) {
|
|
|
|
if (AV_RN32A(&near_mv[CNT_NEAREST])) {
|
|
|
|
if (mv == AV_RN32A(&near_mv[CNT_NEAREST])) {
|
|
|
|
idx = CNT_NEAREST;
|
|
|
|
} else if (AV_RN32A(&near_mv[CNT_NEAR])) {
|
|
|
|
if (mv != AV_RN32A(&near_mv[CNT_NEAR]))
|
|
|
|
continue;
|
|
|
|
idx = CNT_NEAR;
|
|
|
|
} else {
|
|
|
|
AV_WN32A(&near_mv[CNT_NEAR], mv);
|
|
|
|
idx = CNT_NEAR;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
AV_WN32A(&near_mv[CNT_NEAREST], mv);
|
|
|
|
idx = CNT_NEAREST;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
idx = CNT_ZERO;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
idx = CNT_ZERO;
|
|
|
|
}
|
|
|
|
cnt[idx] += vp7_mv_pred[i].score;
|
|
|
|
}
|
|
|
|
|
|
|
|
mb->partitioning = VP8_SPLITMVMODE_NONE;
|
|
|
|
|
2022-07-23 01:28:48 +02:00
|
|
|
if (vpx_rac_get_prob_branchy(c, vp7_mode_contexts[cnt[CNT_ZERO]][0])) {
|
2014-02-18 13:52:30 +03:00
|
|
|
mb->mode = VP8_MVMODE_MV;
|
|
|
|
|
2022-07-23 01:28:48 +02:00
|
|
|
if (vpx_rac_get_prob_branchy(c, vp7_mode_contexts[cnt[CNT_NEAREST]][1])) {
|
2014-02-18 13:52:30 +03:00
|
|
|
|
2022-07-23 01:28:48 +02:00
|
|
|
if (vpx_rac_get_prob_branchy(c, vp7_mode_contexts[cnt[CNT_NEAR]][2])) {
|
2014-02-18 13:52:30 +03:00
|
|
|
|
|
|
|
if (cnt[CNT_NEAREST] > cnt[CNT_NEAR])
|
|
|
|
AV_WN32A(&mb->mv, cnt[CNT_ZERO] > cnt[CNT_NEAREST] ? 0 : AV_RN32A(&near_mv[CNT_NEAREST]));
|
|
|
|
else
|
|
|
|
AV_WN32A(&mb->mv, cnt[CNT_ZERO] > cnt[CNT_NEAR] ? 0 : AV_RN32A(&near_mv[CNT_NEAR]));
|
|
|
|
|
2022-07-23 01:28:48 +02:00
|
|
|
if (vpx_rac_get_prob_branchy(c, vp7_mode_contexts[cnt[CNT_NEAR]][3])) {
|
2014-02-18 13:52:30 +03:00
|
|
|
mb->mode = VP8_MVMODE_SPLIT;
|
2014-04-01 15:21:51 +03:00
|
|
|
mb->mv = mb->bmv[decode_splitmvs(s, c, mb, layout, IS_VP7) - 1];
|
2014-02-18 13:52:30 +03:00
|
|
|
} else {
|
|
|
|
mb->mv.y += vp7_read_mv_component(c, s->prob->mvc[0]);
|
|
|
|
mb->mv.x += vp7_read_mv_component(c, s->prob->mvc[1]);
|
|
|
|
mb->bmv[0] = mb->mv;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
mb->mv = near_mv[CNT_NEAR];
|
|
|
|
mb->bmv[0] = mb->mv;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
mb->mv = near_mv[CNT_NEAREST];
|
|
|
|
mb->bmv[0] = mb->mv;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
mb->mode = VP8_MVMODE_ZERO;
|
|
|
|
AV_ZERO32(&mb->mv);
|
|
|
|
mb->bmv[0] = mb->mv;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static av_always_inline
|
2017-04-05 22:19:55 +02:00
|
|
|
void vp8_decode_mvs(VP8Context *s, VP8mvbounds *mv_bounds, VP8Macroblock *mb,
|
2014-03-30 03:39:46 +03:00
|
|
|
int mb_x, int mb_y, int layout)
|
2011-02-10 08:43:25 +02:00
|
|
|
{
|
2014-03-28 03:13:54 +03:00
|
|
|
VP8Macroblock *mb_edge[3] = { 0 /* top */,
|
2011-02-10 08:43:25 +02:00
|
|
|
mb - 1 /* left */,
|
2014-03-28 03:13:54 +03:00
|
|
|
0 /* top-left */ };
|
2011-02-10 08:43:25 +02:00
|
|
|
enum { CNT_ZERO, CNT_NEAREST, CNT_NEAR, CNT_SPLITMV };
|
2011-03-22 23:36:57 +02:00
|
|
|
enum { VP8_EDGE_TOP, VP8_EDGE_LEFT, VP8_EDGE_TOPLEFT };
|
2011-02-10 08:43:25 +02:00
|
|
|
int idx = CNT_ZERO;
|
|
|
|
int cur_sign_bias = s->sign_bias[mb->ref_frame];
|
2011-03-11 23:43:10 +02:00
|
|
|
int8_t *sign_bias = s->sign_bias;
|
avcodec/vp8, vp9: Avoid using VP56mv and VP56Frame in VP8/9
Instead replace VP56mv by new and identical structures VP8mv and VP9mv.
Also replace VP56Frame by VP8FrameType in vp8.h and use that
in VP8 code. Also remove VP56_FRAME_GOLDEN2, as this has only
been used by VP8, and use VP8_FRAME_ALTREF as replacement for
its usage in VP8 as this is more in line with VP8 verbiage.
This allows to remove all inclusions of vp56.h from everything
that is not VP5/6. This also removes implicit inclusions
of hpeldsp.h, h264chroma.h, vp3dsp.h and vp56dsp.h from all VP8/9
files.
(This also fixes a build issue: If one compiles with -O0 and disables
everything except the VP8-VAAPI encoder, the file containing
ff_vpx_norm_shift is not compiled, yet this is used implicitly
by vp56_rac_gets_nn() which is defined in vp56.h; it is unused
by the VP8-VAAPI encoder and declared as av_unused, yet with -O0
unused noninline functions are not optimized away, leading to
linking failures. With this patch, said function is not included
in vaapi_encode_vp8.c any more.)
Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
2022-07-23 02:01:41 +02:00
|
|
|
VP8mv near_mv[4];
|
2011-02-10 08:43:25 +02:00
|
|
|
uint8_t cnt[4] = { 0 };
|
2022-07-23 01:28:48 +02:00
|
|
|
VPXRangeCoder *c = &s->c;
|
2011-02-10 08:43:25 +02:00
|
|
|
|
2012-07-12 23:07:06 +03:00
|
|
|
if (!layout) { // layout is inlined (s->mb_layout is not)
|
|
|
|
mb_edge[0] = mb + 2;
|
|
|
|
mb_edge[2] = mb + 1;
|
2014-03-28 03:13:54 +03:00
|
|
|
} else {
|
|
|
|
mb_edge[0] = mb - s->mb_width - 1;
|
|
|
|
mb_edge[2] = mb - s->mb_width - 2;
|
2012-07-12 23:07:06 +03:00
|
|
|
}
|
|
|
|
|
2011-02-10 08:43:25 +02:00
|
|
|
AV_ZERO32(&near_mv[0]);
|
|
|
|
AV_ZERO32(&near_mv[1]);
|
2011-10-15 00:43:29 +03:00
|
|
|
AV_ZERO32(&near_mv[2]);
|
2011-02-10 08:43:25 +02:00
|
|
|
|
|
|
|
/* Process MB on top, left and top-left */
|
2014-03-28 03:13:54 +03:00
|
|
|
#define MV_EDGE_CHECK(n) \
|
|
|
|
{ \
|
|
|
|
VP8Macroblock *edge = mb_edge[n]; \
|
|
|
|
int edge_ref = edge->ref_frame; \
|
avcodec/vp8, vp9: Avoid using VP56mv and VP56Frame in VP8/9
Instead replace VP56mv by new and identical structures VP8mv and VP9mv.
Also replace VP56Frame by VP8FrameType in vp8.h and use that
in VP8 code. Also remove VP56_FRAME_GOLDEN2, as this has only
been used by VP8, and use VP8_FRAME_ALTREF as replacement for
its usage in VP8 as this is more in line with VP8 verbiage.
This allows to remove all inclusions of vp56.h from everything
that is not VP5/6. This also removes implicit inclusions
of hpeldsp.h, h264chroma.h, vp3dsp.h and vp56dsp.h from all VP8/9
files.
(This also fixes a build issue: If one compiles with -O0 and disables
everything except the VP8-VAAPI encoder, the file containing
ff_vpx_norm_shift is not compiled, yet this is used implicitly
by vp56_rac_gets_nn() which is defined in vp56.h; it is unused
by the VP8-VAAPI encoder and declared as av_unused, yet with -O0
unused noninline functions are not optimized away, leading to
linking failures. With this patch, said function is not included
in vaapi_encode_vp8.c any more.)
Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
2022-07-23 02:01:41 +02:00
|
|
|
if (edge_ref != VP8_FRAME_CURRENT) { \
|
2014-03-28 03:13:54 +03:00
|
|
|
uint32_t mv = AV_RN32A(&edge->mv); \
|
|
|
|
if (mv) { \
|
|
|
|
if (cur_sign_bias != sign_bias[edge_ref]) { \
|
|
|
|
/* SWAR negate of the values in mv. */ \
|
|
|
|
mv = ~mv; \
|
|
|
|
mv = ((mv & 0x7fff7fff) + \
|
|
|
|
0x00010001) ^ (mv & 0x80008000); \
|
|
|
|
} \
|
|
|
|
if (!n || mv != AV_RN32A(&near_mv[idx])) \
|
|
|
|
AV_WN32A(&near_mv[++idx], mv); \
|
|
|
|
cnt[idx] += 1 + (n != 2); \
|
|
|
|
} else \
|
|
|
|
cnt[CNT_ZERO] += 1 + (n != 2); \
|
|
|
|
} \
|
2011-02-10 08:43:25 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
MV_EDGE_CHECK(0)
|
|
|
|
MV_EDGE_CHECK(1)
|
|
|
|
MV_EDGE_CHECK(2)
|
|
|
|
|
|
|
|
mb->partitioning = VP8_SPLITMVMODE_NONE;
|
2022-07-23 01:28:48 +02:00
|
|
|
if (vpx_rac_get_prob_branchy(c, vp8_mode_contexts[cnt[CNT_ZERO]][0])) {
|
2011-02-10 08:43:25 +02:00
|
|
|
mb->mode = VP8_MVMODE_MV;
|
|
|
|
|
|
|
|
/* If we have three distinct MVs, merge first and last if they're the same */
|
2014-03-28 03:13:54 +03:00
|
|
|
if (cnt[CNT_SPLITMV] &&
|
|
|
|
AV_RN32A(&near_mv[1 + VP8_EDGE_TOP]) == AV_RN32A(&near_mv[1 + VP8_EDGE_TOPLEFT]))
|
2011-02-10 08:43:25 +02:00
|
|
|
cnt[CNT_NEAREST] += 1;
|
|
|
|
|
|
|
|
/* Swap near and nearest if necessary */
|
|
|
|
if (cnt[CNT_NEAR] > cnt[CNT_NEAREST]) {
|
|
|
|
FFSWAP(uint8_t, cnt[CNT_NEAREST], cnt[CNT_NEAR]);
|
avcodec/vp8, vp9: Avoid using VP56mv and VP56Frame in VP8/9
Instead replace VP56mv by new and identical structures VP8mv and VP9mv.
Also replace VP56Frame by VP8FrameType in vp8.h and use that
in VP8 code. Also remove VP56_FRAME_GOLDEN2, as this has only
been used by VP8, and use VP8_FRAME_ALTREF as replacement for
its usage in VP8 as this is more in line with VP8 verbiage.
This allows to remove all inclusions of vp56.h from everything
that is not VP5/6. This also removes implicit inclusions
of hpeldsp.h, h264chroma.h, vp3dsp.h and vp56dsp.h from all VP8/9
files.
(This also fixes a build issue: If one compiles with -O0 and disables
everything except the VP8-VAAPI encoder, the file containing
ff_vpx_norm_shift is not compiled, yet this is used implicitly
by vp56_rac_gets_nn() which is defined in vp56.h; it is unused
by the VP8-VAAPI encoder and declared as av_unused, yet with -O0
unused noninline functions are not optimized away, leading to
linking failures. With this patch, said function is not included
in vaapi_encode_vp8.c any more.)
Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
2022-07-23 02:01:41 +02:00
|
|
|
FFSWAP(VP8mv, near_mv[CNT_NEAREST], near_mv[CNT_NEAR]);
|
2011-02-10 08:43:25 +02:00
|
|
|
}
|
|
|
|
|
2022-07-23 01:28:48 +02:00
|
|
|
if (vpx_rac_get_prob_branchy(c, vp8_mode_contexts[cnt[CNT_NEAREST]][1])) {
|
|
|
|
if (vpx_rac_get_prob_branchy(c, vp8_mode_contexts[cnt[CNT_NEAR]][2])) {
|
2011-02-10 08:43:25 +02:00
|
|
|
/* Choose the best mv out of 0,0 and the nearest mv */
|
2017-04-05 22:19:55 +02:00
|
|
|
clamp_mv(mv_bounds, &mb->mv, &near_mv[CNT_ZERO + (cnt[CNT_NEAREST] >= cnt[CNT_ZERO])]);
|
2011-03-22 23:36:57 +02:00
|
|
|
cnt[CNT_SPLITMV] = ((mb_edge[VP8_EDGE_LEFT]->mode == VP8_MVMODE_SPLIT) +
|
|
|
|
(mb_edge[VP8_EDGE_TOP]->mode == VP8_MVMODE_SPLIT)) * 2 +
|
|
|
|
(mb_edge[VP8_EDGE_TOPLEFT]->mode == VP8_MVMODE_SPLIT);
|
2011-02-10 08:43:25 +02:00
|
|
|
|
2022-07-23 01:28:48 +02:00
|
|
|
if (vpx_rac_get_prob_branchy(c, vp8_mode_contexts[cnt[CNT_SPLITMV]][3])) {
|
2011-02-10 08:43:25 +02:00
|
|
|
mb->mode = VP8_MVMODE_SPLIT;
|
2014-04-01 15:21:51 +03:00
|
|
|
mb->mv = mb->bmv[decode_splitmvs(s, c, mb, layout, IS_VP8) - 1];
|
2011-02-10 08:43:25 +02:00
|
|
|
} else {
|
2014-03-30 03:39:46 +03:00
|
|
|
mb->mv.y += vp8_read_mv_component(c, s->prob->mvc[0]);
|
|
|
|
mb->mv.x += vp8_read_mv_component(c, s->prob->mvc[1]);
|
2011-02-10 08:43:25 +02:00
|
|
|
mb->bmv[0] = mb->mv;
|
|
|
|
}
|
|
|
|
} else {
|
2017-04-05 22:19:55 +02:00
|
|
|
clamp_mv(mv_bounds, &mb->mv, &near_mv[CNT_NEAR]);
|
2011-02-10 08:43:25 +02:00
|
|
|
mb->bmv[0] = mb->mv;
|
|
|
|
}
|
|
|
|
} else {
|
2017-04-05 22:19:55 +02:00
|
|
|
clamp_mv(mv_bounds, &mb->mv, &near_mv[CNT_NEAREST]);
|
2011-02-10 08:43:25 +02:00
|
|
|
mb->bmv[0] = mb->mv;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
mb->mode = VP8_MVMODE_ZERO;
|
|
|
|
AV_ZERO32(&mb->mv);
|
|
|
|
mb->bmv[0] = mb->mv;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-07-24 00:36:21 +03:00
|
|
|
static av_always_inline
|
2022-07-23 01:28:48 +02:00
|
|
|
void decode_intra4x4_modes(VP8Context *s, VPXRangeCoder *c, VP8Macroblock *mb,
|
2012-07-12 23:07:06 +03:00
|
|
|
int mb_x, int keyframe, int layout)
|
2010-06-22 22:24:09 +03:00
|
|
|
{
|
2012-07-11 21:34:05 +03:00
|
|
|
uint8_t *intra4x4 = mb->intra4x4_pred_mode_mb;
|
|
|
|
|
2014-01-18 18:38:45 +03:00
|
|
|
if (layout) {
|
2012-07-12 23:07:06 +03:00
|
|
|
VP8Macroblock *mb_top = mb - s->mb_width - 1;
|
|
|
|
memcpy(mb->intra4x4_pred_mode_top, mb_top->intra4x4_pred_mode_top, 4);
|
|
|
|
}
|
2010-07-22 10:04:45 +03:00
|
|
|
if (keyframe) {
|
2010-08-02 12:44:53 +03:00
|
|
|
int x, y;
|
2014-03-28 03:13:54 +03:00
|
|
|
uint8_t *top;
|
|
|
|
uint8_t *const left = s->intra4x4_pred_mode_left;
|
2014-01-18 18:38:45 +03:00
|
|
|
if (layout)
|
2012-07-12 23:07:06 +03:00
|
|
|
top = mb->intra4x4_pred_mode_top;
|
|
|
|
else
|
|
|
|
top = s->intra4x4_pred_mode_top + 4 * mb_x;
|
2010-07-22 10:04:45 +03:00
|
|
|
for (y = 0; y < 4; y++) {
|
|
|
|
for (x = 0; x < 4; x++) {
|
2010-08-02 12:44:53 +03:00
|
|
|
const uint8_t *ctx;
|
2014-03-28 03:13:54 +03:00
|
|
|
ctx = vp8_pred4x4_prob_intra[top[x]][left[y]];
|
2022-07-23 00:04:29 +02:00
|
|
|
*intra4x4 = vp89_rac_get_tree(c, vp8_pred4x4_tree, ctx);
|
2014-03-28 03:13:54 +03:00
|
|
|
left[y] = top[x] = *intra4x4;
|
2010-08-02 12:44:53 +03:00
|
|
|
intra4x4++;
|
2010-06-22 22:24:09 +03:00
|
|
|
}
|
|
|
|
}
|
2010-07-22 10:04:45 +03:00
|
|
|
} else {
|
2010-08-02 12:44:53 +03:00
|
|
|
int i;
|
2010-07-22 10:04:45 +03:00
|
|
|
for (i = 0; i < 16; i++)
|
2022-07-23 00:04:29 +02:00
|
|
|
intra4x4[i] = vp89_rac_get_tree(c, vp8_pred4x4_tree,
|
|
|
|
vp8_pred4x4_prob_inter);
|
2010-06-22 22:24:09 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-07-24 00:36:21 +03:00
|
|
|
static av_always_inline
|
2017-04-05 22:19:55 +02:00
|
|
|
void decode_mb_mode(VP8Context *s, VP8mvbounds *mv_bounds,
|
|
|
|
VP8Macroblock *mb, int mb_x, int mb_y,
|
2022-07-22 07:11:47 +02:00
|
|
|
uint8_t *segment, const uint8_t *ref, int layout, int is_vp7)
|
2010-06-22 22:24:09 +03:00
|
|
|
{
|
2022-07-23 01:28:48 +02:00
|
|
|
VPXRangeCoder *c = &s->c;
|
2016-07-03 10:09:36 +02:00
|
|
|
static const char * const vp7_feature_name[] = { "q-index",
|
|
|
|
"lf-delta",
|
|
|
|
"partial-golden-update",
|
|
|
|
"blit-pitch" };
|
2014-04-01 15:21:51 +03:00
|
|
|
if (is_vp7) {
|
2014-02-18 13:52:30 +03:00
|
|
|
int i;
|
|
|
|
*segment = 0;
|
|
|
|
for (i = 0; i < 4; i++) {
|
|
|
|
if (s->feature_enabled[i]) {
|
2022-07-23 01:28:48 +02:00
|
|
|
if (vpx_rac_get_prob_branchy(c, s->feature_present_prob[i])) {
|
2022-07-23 00:04:29 +02:00
|
|
|
int index = vp89_rac_get_tree(c, vp7_feature_index_tree,
|
|
|
|
s->feature_index_prob[i]);
|
2014-04-01 15:21:51 +03:00
|
|
|
av_log(s->avctx, AV_LOG_WARNING,
|
|
|
|
"Feature %s present in macroblock (value 0x%x)\n",
|
|
|
|
vp7_feature_name[i], s->feature_value[i][index]);
|
2014-02-18 13:52:30 +03:00
|
|
|
}
|
2014-04-01 15:21:51 +03:00
|
|
|
}
|
2014-02-18 13:52:30 +03:00
|
|
|
}
|
2014-04-04 15:31:04 +03:00
|
|
|
} else if (s->segmentation.update_map) {
|
2022-07-23 01:28:48 +02:00
|
|
|
int bit = vpx_rac_get_prob(c, s->prob->segmentid[0]);
|
|
|
|
*segment = vpx_rac_get_prob(c, s->prob->segmentid[1+bit]) + 2*bit;
|
2014-04-04 15:31:04 +03:00
|
|
|
} else if (s->segmentation.enabled)
|
2011-05-02 16:55:52 +03:00
|
|
|
*segment = ref ? *ref : *segment;
|
2012-07-11 21:34:05 +03:00
|
|
|
mb->segment = *segment;
|
2010-06-22 22:24:09 +03:00
|
|
|
|
2022-07-23 01:28:48 +02:00
|
|
|
mb->skip = s->mbskip_enabled ? vpx_rac_get_prob(c, s->prob->mbskip) : 0;
|
2010-06-22 22:24:09 +03:00
|
|
|
|
|
|
|
if (s->keyframe) {
|
2022-07-23 00:04:29 +02:00
|
|
|
mb->mode = vp89_rac_get_tree(c, vp8_pred16x16_tree_intra,
|
|
|
|
vp8_pred16x16_prob_intra);
|
2010-06-22 22:24:09 +03:00
|
|
|
|
|
|
|
if (mb->mode == MODE_I4x4) {
|
2012-07-12 23:07:06 +03:00
|
|
|
decode_intra4x4_modes(s, c, mb, mb_x, 1, layout);
|
2010-08-02 12:44:53 +03:00
|
|
|
} else {
|
2014-04-01 15:21:51 +03:00
|
|
|
const uint32_t modes = (is_vp7 ? vp7_pred4x4_mode
|
|
|
|
: vp8_pred4x4_mode)[mb->mode] * 0x01010101u;
|
2014-01-18 18:38:45 +03:00
|
|
|
if (s->mb_layout)
|
2012-07-12 23:07:06 +03:00
|
|
|
AV_WN32A(mb->intra4x4_pred_mode_top, modes);
|
|
|
|
else
|
|
|
|
AV_WN32A(s->intra4x4_pred_mode_top + 4 * mb_x, modes);
|
2014-03-28 03:13:54 +03:00
|
|
|
AV_WN32A(s->intra4x4_pred_mode_left, modes);
|
2010-08-02 12:44:53 +03:00
|
|
|
}
|
2010-06-22 22:24:09 +03:00
|
|
|
|
2022-07-23 00:04:29 +02:00
|
|
|
mb->chroma_pred_mode = vp89_rac_get_tree(c, vp8_pred8x8c_tree,
|
|
|
|
vp8_pred8x8c_prob_intra);
|
avcodec/vp8, vp9: Avoid using VP56mv and VP56Frame in VP8/9
Instead replace VP56mv by new and identical structures VP8mv and VP9mv.
Also replace VP56Frame by VP8FrameType in vp8.h and use that
in VP8 code. Also remove VP56_FRAME_GOLDEN2, as this has only
been used by VP8, and use VP8_FRAME_ALTREF as replacement for
its usage in VP8 as this is more in line with VP8 verbiage.
This allows to remove all inclusions of vp56.h from everything
that is not VP5/6. This also removes implicit inclusions
of hpeldsp.h, h264chroma.h, vp3dsp.h and vp56dsp.h from all VP8/9
files.
(This also fixes a build issue: If one compiles with -O0 and disables
everything except the VP8-VAAPI encoder, the file containing
ff_vpx_norm_shift is not compiled, yet this is used implicitly
by vp56_rac_gets_nn() which is defined in vp56.h; it is unused
by the VP8-VAAPI encoder and declared as av_unused, yet with -O0
unused noninline functions are not optimized away, leading to
linking failures. With this patch, said function is not included
in vaapi_encode_vp8.c any more.)
Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
2022-07-23 02:01:41 +02:00
|
|
|
mb->ref_frame = VP8_FRAME_CURRENT;
|
2022-07-23 01:28:48 +02:00
|
|
|
} else if (vpx_rac_get_prob_branchy(c, s->prob->intra)) {
|
2010-06-22 22:24:09 +03:00
|
|
|
// inter MB, 16.2
|
2022-07-23 01:28:48 +02:00
|
|
|
if (vpx_rac_get_prob_branchy(c, s->prob->last))
|
2014-03-28 03:13:54 +03:00
|
|
|
mb->ref_frame =
|
avcodec/vp8, vp9: Avoid using VP56mv and VP56Frame in VP8/9
Instead replace VP56mv by new and identical structures VP8mv and VP9mv.
Also replace VP56Frame by VP8FrameType in vp8.h and use that
in VP8 code. Also remove VP56_FRAME_GOLDEN2, as this has only
been used by VP8, and use VP8_FRAME_ALTREF as replacement for
its usage in VP8 as this is more in line with VP8 verbiage.
This allows to remove all inclusions of vp56.h from everything
that is not VP5/6. This also removes implicit inclusions
of hpeldsp.h, h264chroma.h, vp3dsp.h and vp56dsp.h from all VP8/9
files.
(This also fixes a build issue: If one compiles with -O0 and disables
everything except the VP8-VAAPI encoder, the file containing
ff_vpx_norm_shift is not compiled, yet this is used implicitly
by vp56_rac_gets_nn() which is defined in vp56.h; it is unused
by the VP8-VAAPI encoder and declared as av_unused, yet with -O0
unused noninline functions are not optimized away, leading to
linking failures. With this patch, said function is not included
in vaapi_encode_vp8.c any more.)
Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
2022-07-23 02:01:41 +02:00
|
|
|
(!is_vp7 && vpx_rac_get_prob(c, s->prob->golden)) ? VP8_FRAME_ALTREF
|
|
|
|
: VP8_FRAME_GOLDEN;
|
2010-06-22 22:24:09 +03:00
|
|
|
else
|
avcodec/vp8, vp9: Avoid using VP56mv and VP56Frame in VP8/9
Instead replace VP56mv by new and identical structures VP8mv and VP9mv.
Also replace VP56Frame by VP8FrameType in vp8.h and use that
in VP8 code. Also remove VP56_FRAME_GOLDEN2, as this has only
been used by VP8, and use VP8_FRAME_ALTREF as replacement for
its usage in VP8 as this is more in line with VP8 verbiage.
This allows to remove all inclusions of vp56.h from everything
that is not VP5/6. This also removes implicit inclusions
of hpeldsp.h, h264chroma.h, vp3dsp.h and vp56dsp.h from all VP8/9
files.
(This also fixes a build issue: If one compiles with -O0 and disables
everything except the VP8-VAAPI encoder, the file containing
ff_vpx_norm_shift is not compiled, yet this is used implicitly
by vp56_rac_gets_nn() which is defined in vp56.h; it is unused
by the VP8-VAAPI encoder and declared as av_unused, yet with -O0
unused noninline functions are not optimized away, leading to
linking failures. With this patch, said function is not included
in vaapi_encode_vp8.c any more.)
Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
2022-07-23 02:01:41 +02:00
|
|
|
mb->ref_frame = VP8_FRAME_PREVIOUS;
|
2014-03-28 03:13:54 +03:00
|
|
|
s->ref_count[mb->ref_frame - 1]++;
|
2010-06-22 22:24:09 +03:00
|
|
|
|
|
|
|
// motion vectors, 16.3
|
2014-04-01 15:21:51 +03:00
|
|
|
if (is_vp7)
|
2014-02-18 13:52:30 +03:00
|
|
|
vp7_decode_mvs(s, mb, mb_x, mb_y, layout);
|
|
|
|
else
|
2017-04-05 22:19:55 +02:00
|
|
|
vp8_decode_mvs(s, mv_bounds, mb, mb_x, mb_y, layout);
|
2010-06-22 22:24:09 +03:00
|
|
|
} else {
|
|
|
|
// intra MB, 16.1
|
2022-07-23 00:04:29 +02:00
|
|
|
mb->mode = vp89_rac_get_tree(c, vp8_pred16x16_tree_inter,
|
|
|
|
s->prob->pred16x16);
|
2010-06-22 22:24:09 +03:00
|
|
|
|
2010-07-22 09:39:54 +03:00
|
|
|
if (mb->mode == MODE_I4x4)
|
2012-07-12 23:07:06 +03:00
|
|
|
decode_intra4x4_modes(s, c, mb, mb_x, 0, layout);
|
2010-06-22 22:24:09 +03:00
|
|
|
|
2022-07-23 00:04:29 +02:00
|
|
|
mb->chroma_pred_mode = vp89_rac_get_tree(c, vp8_pred8x8c_tree,
|
|
|
|
s->prob->pred8x8c);
|
avcodec/vp8, vp9: Avoid using VP56mv and VP56Frame in VP8/9
Instead replace VP56mv by new and identical structures VP8mv and VP9mv.
Also replace VP56Frame by VP8FrameType in vp8.h and use that
in VP8 code. Also remove VP56_FRAME_GOLDEN2, as this has only
been used by VP8, and use VP8_FRAME_ALTREF as replacement for
its usage in VP8 as this is more in line with VP8 verbiage.
This allows to remove all inclusions of vp56.h from everything
that is not VP5/6. This also removes implicit inclusions
of hpeldsp.h, h264chroma.h, vp3dsp.h and vp56dsp.h from all VP8/9
files.
(This also fixes a build issue: If one compiles with -O0 and disables
everything except the VP8-VAAPI encoder, the file containing
ff_vpx_norm_shift is not compiled, yet this is used implicitly
by vp56_rac_gets_nn() which is defined in vp56.h; it is unused
by the VP8-VAAPI encoder and declared as av_unused, yet with -O0
unused noninline functions are not optimized away, leading to
linking failures. With this patch, said function is not included
in vaapi_encode_vp8.c any more.)
Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
2022-07-23 02:01:41 +02:00
|
|
|
mb->ref_frame = VP8_FRAME_CURRENT;
|
2014-03-28 03:13:54 +03:00
|
|
|
mb->partitioning = VP8_SPLITMVMODE_NONE;
|
2010-07-23 13:42:19 +03:00
|
|
|
AV_ZERO32(&mb->bmv[0]);
|
2010-06-22 22:24:09 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2014-03-28 03:13:54 +03:00
|
|
|
* @param r arithmetic bitstream reader context
|
2010-07-08 18:01:59 +03:00
|
|
|
* @param block destination for block coefficients
|
|
|
|
* @param probs probabilities to use when reading trees from the bitstream
|
2014-03-28 03:13:54 +03:00
|
|
|
* @param i initial coeff index, 0 unless a separate DC block is coded
|
|
|
|
* @param qmul array holding the dc/ac dequant factor at position 0/1
|
|
|
|
*
|
2010-06-22 22:24:09 +03:00
|
|
|
* @return 0 if no coeffs were decoded
|
|
|
|
* otherwise, the index of the last coeff decoded plus one
|
|
|
|
*/
|
2014-02-18 13:52:30 +03:00
|
|
|
static av_always_inline
|
2022-07-23 01:28:48 +02:00
|
|
|
int decode_block_coeffs_internal(VPXRangeCoder *r, int16_t block[16],
|
2014-04-01 15:21:51 +03:00
|
|
|
uint8_t probs[16][3][NUM_DCT_TOKENS - 1],
|
|
|
|
int i, uint8_t *token_prob, int16_t qmul[2],
|
|
|
|
const uint8_t scan[16], int vp7)
|
2010-06-22 22:24:09 +03:00
|
|
|
{
|
2022-07-23 01:28:48 +02:00
|
|
|
VPXRangeCoder c = *r;
|
2010-08-04 04:38:08 +03:00
|
|
|
goto skip_eob;
|
2010-07-24 00:46:17 +03:00
|
|
|
do {
|
2010-08-04 05:23:25 +03:00
|
|
|
int coeff;
|
2014-02-18 13:52:30 +03:00
|
|
|
restart:
|
2022-07-23 01:28:48 +02:00
|
|
|
if (!vpx_rac_get_prob_branchy(&c, token_prob[0])) // DCT_EOB
|
2012-05-29 20:56:15 +03:00
|
|
|
break;
|
2010-06-22 22:24:09 +03:00
|
|
|
|
2010-07-24 00:46:17 +03:00
|
|
|
skip_eob:
|
2022-07-23 01:28:48 +02:00
|
|
|
if (!vpx_rac_get_prob_branchy(&c, token_prob[1])) { // DCT_0
|
2010-08-02 02:20:06 +03:00
|
|
|
if (++i == 16)
|
2012-05-29 20:56:15 +03:00
|
|
|
break; // invalid input; blocks should end with EOB
|
2010-08-03 01:48:38 +03:00
|
|
|
token_prob = probs[i][0];
|
2014-02-18 13:52:30 +03:00
|
|
|
if (vp7)
|
|
|
|
goto restart;
|
2010-08-02 02:20:06 +03:00
|
|
|
goto skip_eob;
|
2010-07-24 00:46:17 +03:00
|
|
|
}
|
|
|
|
|
2022-07-23 01:28:48 +02:00
|
|
|
if (!vpx_rac_get_prob_branchy(&c, token_prob[2])) { // DCT_1
|
2010-07-24 00:46:17 +03:00
|
|
|
coeff = 1;
|
2014-03-28 03:13:54 +03:00
|
|
|
token_prob = probs[i + 1][1];
|
2010-07-24 00:46:17 +03:00
|
|
|
} else {
|
2022-07-23 01:28:48 +02:00
|
|
|
if (!vpx_rac_get_prob_branchy(&c, token_prob[3])) { // DCT 2,3,4
|
|
|
|
coeff = vpx_rac_get_prob_branchy(&c, token_prob[4]);
|
2010-07-24 00:46:17 +03:00
|
|
|
if (coeff)
|
2022-07-23 01:28:48 +02:00
|
|
|
coeff += vpx_rac_get_prob(&c, token_prob[5]);
|
2010-07-24 00:46:17 +03:00
|
|
|
coeff += 2;
|
|
|
|
} else {
|
|
|
|
// DCT_CAT*
|
2022-07-23 01:28:48 +02:00
|
|
|
if (!vpx_rac_get_prob_branchy(&c, token_prob[6])) {
|
|
|
|
if (!vpx_rac_get_prob_branchy(&c, token_prob[7])) { // DCT_CAT1
|
|
|
|
coeff = 5 + vpx_rac_get_prob(&c, vp8_dct_cat1_prob[0]);
|
2010-07-24 00:46:17 +03:00
|
|
|
} else { // DCT_CAT2
|
|
|
|
coeff = 7;
|
2022-07-23 01:28:48 +02:00
|
|
|
coeff += vpx_rac_get_prob(&c, vp8_dct_cat2_prob[0]) << 1;
|
|
|
|
coeff += vpx_rac_get_prob(&c, vp8_dct_cat2_prob[1]);
|
2010-07-24 00:46:17 +03:00
|
|
|
}
|
|
|
|
} else { // DCT_CAT3 and up
|
2022-07-23 01:28:48 +02:00
|
|
|
int a = vpx_rac_get_prob(&c, token_prob[8]);
|
|
|
|
int b = vpx_rac_get_prob(&c, token_prob[9 + a]);
|
2014-03-28 03:13:54 +03:00
|
|
|
int cat = (a << 1) + b;
|
|
|
|
coeff = 3 + (8 << cat);
|
2012-05-29 20:56:15 +03:00
|
|
|
coeff += vp8_rac_get_coeff(&c, ff_vp8_dct_cat_prob[cat]);
|
2010-07-24 00:46:17 +03:00
|
|
|
}
|
|
|
|
}
|
2014-03-28 03:13:54 +03:00
|
|
|
token_prob = probs[i + 1][2];
|
2010-07-24 00:46:17 +03:00
|
|
|
}
|
2022-07-23 00:04:29 +02:00
|
|
|
block[scan[i]] = (vp89_rac_get(&c) ? -coeff : coeff) * qmul[!!i];
|
2010-08-04 04:38:08 +03:00
|
|
|
} while (++i < 16);
|
2010-07-24 00:46:17 +03:00
|
|
|
|
2012-05-29 20:56:15 +03:00
|
|
|
*r = c;
|
2010-08-04 04:38:08 +03:00
|
|
|
return i;
|
2010-06-22 22:24:09 +03:00
|
|
|
}
|
2014-02-18 13:52:30 +03:00
|
|
|
|
2014-04-01 15:21:51 +03:00
|
|
|
static av_always_inline
|
|
|
|
int inter_predict_dc(int16_t block[16], int16_t pred[2])
|
2014-02-18 13:52:30 +03:00
|
|
|
{
|
2014-04-01 15:21:51 +03:00
|
|
|
int16_t dc = block[0];
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
if (pred[1] > 3) {
|
|
|
|
dc += pred[0];
|
|
|
|
ret = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!pred[0] | !dc | ((int32_t)pred[0] ^ (int32_t)dc) >> 31) {
|
|
|
|
block[0] = pred[0] = dc;
|
|
|
|
pred[1] = 0;
|
|
|
|
} else {
|
|
|
|
if (pred[0] == dc)
|
|
|
|
pred[1]++;
|
|
|
|
block[0] = pred[0] = dc;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2022-07-23 01:28:48 +02:00
|
|
|
static int vp7_decode_block_coeffs_internal(VPXRangeCoder *r,
|
2014-04-01 15:21:51 +03:00
|
|
|
int16_t block[16],
|
|
|
|
uint8_t probs[16][3][NUM_DCT_TOKENS - 1],
|
|
|
|
int i, uint8_t *token_prob,
|
|
|
|
int16_t qmul[2],
|
|
|
|
const uint8_t scan[16])
|
|
|
|
{
|
|
|
|
return decode_block_coeffs_internal(r, block, probs, i,
|
|
|
|
token_prob, qmul, scan, IS_VP7);
|
2014-02-18 13:52:30 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
#ifndef vp8_decode_block_coeffs_internal
|
2022-07-23 01:28:48 +02:00
|
|
|
static int vp8_decode_block_coeffs_internal(VPXRangeCoder *r,
|
2014-04-01 15:21:51 +03:00
|
|
|
int16_t block[16],
|
|
|
|
uint8_t probs[16][3][NUM_DCT_TOKENS - 1],
|
|
|
|
int i, uint8_t *token_prob,
|
|
|
|
int16_t qmul[2])
|
2014-02-18 13:52:30 +03:00
|
|
|
{
|
2014-04-01 15:21:51 +03:00
|
|
|
return decode_block_coeffs_internal(r, block, probs, i,
|
2016-03-24 12:16:53 +02:00
|
|
|
token_prob, qmul, ff_zigzag_scan, IS_VP8);
|
2014-02-18 13:52:30 +03:00
|
|
|
}
|
2011-02-02 00:38:15 +02:00
|
|
|
#endif
|
2010-06-22 22:24:09 +03:00
|
|
|
|
2011-07-03 17:09:37 +03:00
|
|
|
/**
|
2014-03-28 03:13:54 +03:00
|
|
|
* @param c arithmetic bitstream reader context
|
|
|
|
* @param block destination for block coefficients
|
|
|
|
* @param probs probabilities to use when reading trees from the bitstream
|
|
|
|
* @param i initial coeff index, 0 unless a separate DC block is coded
|
2011-07-03 17:09:37 +03:00
|
|
|
* @param zero_nhood the initial prediction context for number of surrounding
|
|
|
|
* all-zero blocks (only left/top, so 0-2)
|
2014-03-28 03:13:54 +03:00
|
|
|
* @param qmul array holding the dc/ac dequant factor at position 0/1
|
2014-03-30 03:39:46 +03:00
|
|
|
* @param scan scan pattern (VP7 only)
|
2014-03-28 03:13:54 +03:00
|
|
|
*
|
2011-07-03 17:09:37 +03:00
|
|
|
* @return 0 if no coeffs were decoded
|
|
|
|
* otherwise, the index of the last coeff decoded plus one
|
|
|
|
*/
|
2010-08-04 05:23:25 +03:00
|
|
|
static av_always_inline
|
2022-07-23 01:28:48 +02:00
|
|
|
int decode_block_coeffs(VPXRangeCoder *c, int16_t block[16],
|
2014-03-28 03:13:54 +03:00
|
|
|
uint8_t probs[16][3][NUM_DCT_TOKENS - 1],
|
2014-02-18 13:52:30 +03:00
|
|
|
int i, int zero_nhood, int16_t qmul[2],
|
|
|
|
const uint8_t scan[16], int vp7)
|
2010-08-04 05:23:25 +03:00
|
|
|
{
|
|
|
|
uint8_t *token_prob = probs[i][zero_nhood];
|
2022-07-23 01:28:48 +02:00
|
|
|
if (!vpx_rac_get_prob_branchy(c, token_prob[0])) // DCT_EOB
|
2010-08-04 05:23:25 +03:00
|
|
|
return 0;
|
2014-04-01 15:21:51 +03:00
|
|
|
return vp7 ? vp7_decode_block_coeffs_internal(c, block, probs, i,
|
|
|
|
token_prob, qmul, scan)
|
|
|
|
: vp8_decode_block_coeffs_internal(c, block, probs, i,
|
|
|
|
token_prob, qmul);
|
2010-08-04 05:23:25 +03:00
|
|
|
}
|
|
|
|
|
2010-07-24 00:36:21 +03:00
|
|
|
static av_always_inline
|
2022-07-23 01:28:48 +02:00
|
|
|
void decode_mb_coeffs(VP8Context *s, VP8ThreadData *td, VPXRangeCoder *c,
|
2014-03-30 03:39:46 +03:00
|
|
|
VP8Macroblock *mb, uint8_t t_nnz[9], uint8_t l_nnz[9],
|
2014-04-01 15:21:51 +03:00
|
|
|
int is_vp7)
|
2010-06-22 22:24:09 +03:00
|
|
|
{
|
|
|
|
int i, x, y, luma_start = 0, luma_ctx = 3;
|
|
|
|
int nnz_pred, nnz, nnz_total = 0;
|
2012-07-11 21:34:05 +03:00
|
|
|
int segment = mb->segment;
|
2010-08-02 23:57:03 +03:00
|
|
|
int block_dc = 0;
|
2010-06-22 22:24:09 +03:00
|
|
|
|
2014-04-01 15:21:51 +03:00
|
|
|
if (mb->mode != MODE_I4x4 && (is_vp7 || mb->mode != VP8_MVMODE_SPLIT)) {
|
2010-06-22 22:24:09 +03:00
|
|
|
nnz_pred = t_nnz[8] + l_nnz[8];
|
|
|
|
|
|
|
|
// decode DC values and do hadamard
|
2014-03-28 03:13:54 +03:00
|
|
|
nnz = decode_block_coeffs(c, td->block_dc, s->prob->token[1], 0,
|
2014-03-30 03:39:46 +03:00
|
|
|
nnz_pred, s->qmat[segment].luma_dc_qmul,
|
2016-03-24 12:16:53 +02:00
|
|
|
ff_zigzag_scan, is_vp7);
|
2010-06-22 22:24:09 +03:00
|
|
|
l_nnz[8] = t_nnz[8] = !!nnz;
|
2014-02-18 13:52:30 +03:00
|
|
|
|
2014-04-01 15:21:51 +03:00
|
|
|
if (is_vp7 && mb->mode > MODE_I4x4) {
|
|
|
|
nnz |= inter_predict_dc(td->block_dc,
|
|
|
|
s->inter_dc_pred[mb->ref_frame - 1]);
|
|
|
|
}
|
2014-02-18 13:52:30 +03:00
|
|
|
|
2010-08-02 23:57:03 +03:00
|
|
|
if (nnz) {
|
|
|
|
nnz_total += nnz;
|
2014-03-28 03:13:54 +03:00
|
|
|
block_dc = 1;
|
2010-08-02 23:57:03 +03:00
|
|
|
if (nnz == 1)
|
2012-07-12 23:07:06 +03:00
|
|
|
s->vp8dsp.vp8_luma_dc_wht_dc(td->block, td->block_dc);
|
2010-08-02 23:57:03 +03:00
|
|
|
else
|
2012-07-12 23:07:06 +03:00
|
|
|
s->vp8dsp.vp8_luma_dc_wht(td->block, td->block_dc);
|
2010-08-02 23:57:03 +03:00
|
|
|
}
|
2010-06-22 22:24:09 +03:00
|
|
|
luma_start = 1;
|
2014-03-28 03:13:54 +03:00
|
|
|
luma_ctx = 0;
|
2010-06-22 22:24:09 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// luma blocks
|
|
|
|
for (y = 0; y < 4; y++)
|
|
|
|
for (x = 0; x < 4; x++) {
|
2010-08-04 04:40:58 +03:00
|
|
|
nnz_pred = l_nnz[y] + t_nnz[x];
|
2014-03-28 03:13:54 +03:00
|
|
|
nnz = decode_block_coeffs(c, td->block[y][x],
|
|
|
|
s->prob->token[luma_ctx],
|
|
|
|
luma_start, nnz_pred,
|
2014-03-30 03:39:46 +03:00
|
|
|
s->qmat[segment].luma_qmul,
|
2014-04-01 15:21:51 +03:00
|
|
|
s->prob[0].scan, is_vp7);
|
2014-03-28 03:13:54 +03:00
|
|
|
/* nnz+block_dc may be one more than the actual last index,
|
|
|
|
* but we don't care */
|
2012-07-12 23:07:06 +03:00
|
|
|
td->non_zero_count_cache[y][x] = nnz + block_dc;
|
2010-06-22 22:24:09 +03:00
|
|
|
t_nnz[x] = l_nnz[y] = !!nnz;
|
|
|
|
nnz_total += nnz;
|
|
|
|
}
|
|
|
|
|
|
|
|
// chroma blocks
|
|
|
|
// TODO: what to do about dimensions? 2nd dim for luma is x,
|
|
|
|
// but for chroma it's (y<<1)|x
|
|
|
|
for (i = 4; i < 6; i++)
|
|
|
|
for (y = 0; y < 2; y++)
|
|
|
|
for (x = 0; x < 2; x++) {
|
2014-03-28 03:13:54 +03:00
|
|
|
nnz_pred = l_nnz[i + 2 * y] + t_nnz[i + 2 * x];
|
2014-04-01 15:21:51 +03:00
|
|
|
nnz = decode_block_coeffs(c, td->block[i][(y << 1) + x],
|
|
|
|
s->prob->token[2], 0, nnz_pred,
|
|
|
|
s->qmat[segment].chroma_qmul,
|
|
|
|
s->prob[0].scan, is_vp7);
|
2014-03-28 03:13:54 +03:00
|
|
|
td->non_zero_count_cache[i][(y << 1) + x] = nnz;
|
|
|
|
t_nnz[i + 2 * x] = l_nnz[i + 2 * y] = !!nnz;
|
2014-04-01 15:21:51 +03:00
|
|
|
nnz_total += nnz;
|
2010-06-22 22:24:09 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// if there were no coded coeffs despite the macroblock not being marked skip,
|
|
|
|
// we MUST not do the inner loop filter and should not do IDCT
|
|
|
|
// Since skip isn't used for bitstream prediction, just manually set it.
|
|
|
|
if (!nnz_total)
|
|
|
|
mb->skip = 1;
|
|
|
|
}
|
|
|
|
|
2010-07-16 10:20:35 +03:00
|
|
|
static av_always_inline
|
2014-03-28 03:13:54 +03:00
|
|
|
void backup_mb_border(uint8_t *top_border, uint8_t *src_y,
|
|
|
|
uint8_t *src_cb, uint8_t *src_cr,
|
2016-08-23 23:26:35 +02:00
|
|
|
ptrdiff_t linesize, ptrdiff_t uvlinesize, int simple)
|
2010-07-16 10:20:35 +03:00
|
|
|
{
|
2014-03-28 03:13:54 +03:00
|
|
|
AV_COPY128(top_border, src_y + 15 * linesize);
|
2010-07-16 10:20:35 +03:00
|
|
|
if (!simple) {
|
2014-03-28 03:13:54 +03:00
|
|
|
AV_COPY64(top_border + 16, src_cb + 7 * uvlinesize);
|
|
|
|
AV_COPY64(top_border + 24, src_cr + 7 * uvlinesize);
|
2010-07-16 10:20:35 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static av_always_inline
|
2014-03-28 03:13:54 +03:00
|
|
|
void xchg_mb_border(uint8_t *top_border, uint8_t *src_y, uint8_t *src_cb,
|
2016-08-23 23:26:35 +02:00
|
|
|
uint8_t *src_cr, ptrdiff_t linesize, ptrdiff_t uvlinesize, int mb_x,
|
2014-03-28 03:13:54 +03:00
|
|
|
int mb_y, int mb_width, int simple, int xchg)
|
2010-07-16 10:20:35 +03:00
|
|
|
{
|
2014-03-28 03:13:54 +03:00
|
|
|
uint8_t *top_border_m1 = top_border - 32; // for TL prediction
|
|
|
|
src_y -= linesize;
|
2010-07-16 10:20:35 +03:00
|
|
|
src_cb -= uvlinesize;
|
|
|
|
src_cr -= uvlinesize;
|
|
|
|
|
2014-03-28 03:13:54 +03:00
|
|
|
#define XCHG(a, b, xchg) \
|
|
|
|
do { \
|
|
|
|
if (xchg) \
|
|
|
|
AV_SWAP64(b, a); \
|
|
|
|
else \
|
|
|
|
AV_COPY64(b, a); \
|
2010-07-20 20:54:28 +03:00
|
|
|
} while (0)
|
2010-07-16 10:20:35 +03:00
|
|
|
|
2014-03-28 03:13:54 +03:00
|
|
|
XCHG(top_border_m1 + 8, src_y - 8, xchg);
|
|
|
|
XCHG(top_border, src_y, xchg);
|
|
|
|
XCHG(top_border + 8, src_y + 8, 1);
|
|
|
|
if (mb_x < mb_width - 1)
|
|
|
|
XCHG(top_border + 32, src_y + 16, 1);
|
2010-07-20 20:54:25 +03:00
|
|
|
|
2010-07-16 10:20:35 +03:00
|
|
|
// only copy chroma for normal loop filter
|
|
|
|
// or to initialize the top row to 127
|
|
|
|
if (!simple || !mb_y) {
|
2014-03-28 03:13:54 +03:00
|
|
|
XCHG(top_border_m1 + 16, src_cb - 8, xchg);
|
|
|
|
XCHG(top_border_m1 + 24, src_cr - 8, xchg);
|
|
|
|
XCHG(top_border + 16, src_cb, 1);
|
|
|
|
XCHG(top_border + 24, src_cr, 1);
|
2010-07-16 10:20:35 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-07-24 00:36:21 +03:00
|
|
|
static av_always_inline
|
2010-12-28 19:37:19 +02:00
|
|
|
int check_dc_pred8x8_mode(int mode, int mb_x, int mb_y)
|
|
|
|
{
|
2014-03-28 03:13:54 +03:00
|
|
|
if (!mb_x)
|
2010-12-28 19:37:19 +02:00
|
|
|
return mb_y ? TOP_DC_PRED8x8 : DC_128_PRED8x8;
|
2014-03-28 03:13:54 +03:00
|
|
|
else
|
2010-12-28 19:37:19 +02:00
|
|
|
return mb_y ? mode : LEFT_DC_PRED8x8;
|
|
|
|
}
|
|
|
|
|
|
|
|
static av_always_inline
|
2014-02-18 13:52:30 +03:00
|
|
|
int check_tm_pred8x8_mode(int mode, int mb_x, int mb_y, int vp7)
|
2010-12-28 19:37:19 +02:00
|
|
|
{
|
2014-03-28 03:13:54 +03:00
|
|
|
if (!mb_x)
|
2014-02-18 13:52:30 +03:00
|
|
|
return mb_y ? VERT_PRED8x8 : (vp7 ? DC_128_PRED8x8 : DC_129_PRED8x8);
|
2014-03-28 03:13:54 +03:00
|
|
|
else
|
2010-12-28 19:37:19 +02:00
|
|
|
return mb_y ? mode : HOR_PRED8x8;
|
|
|
|
}
|
|
|
|
|
|
|
|
static av_always_inline
|
2014-02-18 13:52:30 +03:00
|
|
|
int check_intra_pred8x8_mode_emuedge(int mode, int mb_x, int mb_y, int vp7)
|
2010-12-28 19:37:19 +02:00
|
|
|
{
|
|
|
|
switch (mode) {
|
|
|
|
case DC_PRED8x8:
|
|
|
|
return check_dc_pred8x8_mode(mode, mb_x, mb_y);
|
|
|
|
case VERT_PRED8x8:
|
2014-02-18 13:52:30 +03:00
|
|
|
return !mb_y ? (vp7 ? DC_128_PRED8x8 : DC_127_PRED8x8) : mode;
|
2010-12-28 19:37:19 +02:00
|
|
|
case HOR_PRED8x8:
|
2014-02-18 13:52:30 +03:00
|
|
|
return !mb_x ? (vp7 ? DC_128_PRED8x8 : DC_129_PRED8x8) : mode;
|
2014-03-28 03:13:54 +03:00
|
|
|
case PLANE_PRED8x8: /* TM */
|
2014-02-18 13:52:30 +03:00
|
|
|
return check_tm_pred8x8_mode(mode, mb_x, mb_y, vp7);
|
2010-12-28 19:37:19 +02:00
|
|
|
}
|
|
|
|
return mode;
|
|
|
|
}
|
|
|
|
|
|
|
|
static av_always_inline
|
2014-02-18 13:52:30 +03:00
|
|
|
int check_tm_pred4x4_mode(int mode, int mb_x, int mb_y, int vp7)
|
2010-12-28 19:37:19 +02:00
|
|
|
{
|
|
|
|
if (!mb_x) {
|
2014-02-18 13:52:30 +03:00
|
|
|
return mb_y ? VERT_VP8_PRED : (vp7 ? DC_128_PRED : DC_129_PRED);
|
2010-12-28 19:37:19 +02:00
|
|
|
} else {
|
|
|
|
return mb_y ? mode : HOR_VP8_PRED;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static av_always_inline
|
2014-04-01 15:21:51 +03:00
|
|
|
int check_intra_pred4x4_mode_emuedge(int mode, int mb_x, int mb_y,
|
|
|
|
int *copy_buf, int vp7)
|
2010-12-28 19:37:19 +02:00
|
|
|
{
|
|
|
|
switch (mode) {
|
|
|
|
case VERT_PRED:
|
|
|
|
if (!mb_x && mb_y) {
|
|
|
|
*copy_buf = 1;
|
|
|
|
return mode;
|
|
|
|
}
|
|
|
|
/* fall-through */
|
|
|
|
case DIAG_DOWN_LEFT_PRED:
|
|
|
|
case VERT_LEFT_PRED:
|
2014-02-18 13:52:30 +03:00
|
|
|
return !mb_y ? (vp7 ? DC_128_PRED : DC_127_PRED) : mode;
|
2010-12-28 19:37:19 +02:00
|
|
|
case HOR_PRED:
|
|
|
|
if (!mb_y) {
|
|
|
|
*copy_buf = 1;
|
|
|
|
return mode;
|
2010-07-23 13:24:38 +03:00
|
|
|
}
|
2010-12-28 19:37:19 +02:00
|
|
|
/* fall-through */
|
|
|
|
case HOR_UP_PRED:
|
2014-02-18 13:52:30 +03:00
|
|
|
return !mb_x ? (vp7 ? DC_128_PRED : DC_129_PRED) : mode;
|
2010-12-28 19:37:19 +02:00
|
|
|
case TM_VP8_PRED:
|
2014-02-18 13:52:30 +03:00
|
|
|
return check_tm_pred4x4_mode(mode, mb_x, mb_y, vp7);
|
2014-03-28 03:13:54 +03:00
|
|
|
case DC_PRED: /* 4x4 DC doesn't use the same "H.264-style" exceptions
|
|
|
|
* as 16x16/8x8 DC */
|
2010-12-28 19:37:19 +02:00
|
|
|
case DIAG_DOWN_RIGHT_PRED:
|
|
|
|
case VERT_RIGHT_PRED:
|
|
|
|
case HOR_DOWN_PRED:
|
|
|
|
if (!mb_y || !mb_x)
|
|
|
|
*copy_buf = 1;
|
|
|
|
return mode;
|
2010-06-22 22:24:09 +03:00
|
|
|
}
|
|
|
|
return mode;
|
|
|
|
}
|
|
|
|
|
2010-07-24 00:36:21 +03:00
|
|
|
static av_always_inline
|
2012-07-12 23:07:06 +03:00
|
|
|
void intra_predict(VP8Context *s, VP8ThreadData *td, uint8_t *dst[3],
|
2014-04-01 15:21:51 +03:00
|
|
|
VP8Macroblock *mb, int mb_x, int mb_y, int is_vp7)
|
2010-06-22 22:24:09 +03:00
|
|
|
{
|
2011-10-08 17:03:51 +03:00
|
|
|
int x, y, mode, nnz;
|
|
|
|
uint32_t tr;
|
2010-06-22 22:24:09 +03:00
|
|
|
|
2014-03-28 03:13:54 +03:00
|
|
|
/* for the first row, we need to run xchg_mb_border to init the top edge
|
|
|
|
* to 127 otherwise, skip it if we aren't going to deblock */
|
2013-12-20 13:20:24 +03:00
|
|
|
if (mb_y && (s->deblock_filter || !mb_y) && td->thread_nr == 0)
|
2014-03-28 03:13:54 +03:00
|
|
|
xchg_mb_border(s->top_border[mb_x + 1], dst[0], dst[1], dst[2],
|
2010-07-16 10:20:35 +03:00
|
|
|
s->linesize, s->uvlinesize, mb_x, mb_y, s->mb_width,
|
|
|
|
s->filter.simple, 1);
|
|
|
|
|
2010-06-22 22:24:09 +03:00
|
|
|
if (mb->mode < MODE_I4x4) {
|
2014-04-01 15:21:51 +03:00
|
|
|
mode = check_intra_pred8x8_mode_emuedge(mb->mode, mb_x, mb_y, is_vp7);
|
2010-06-22 22:24:09 +03:00
|
|
|
s->hpc.pred16x16[mode](dst[0], s->linesize);
|
|
|
|
} else {
|
|
|
|
uint8_t *ptr = dst[0];
|
2012-07-11 21:34:05 +03:00
|
|
|
uint8_t *intra4x4 = mb->intra4x4_pred_mode_mb;
|
2014-04-01 15:21:51 +03:00
|
|
|
const uint8_t lo = is_vp7 ? 128 : 127;
|
|
|
|
const uint8_t hi = is_vp7 ? 128 : 129;
|
2014-02-18 13:52:30 +03:00
|
|
|
uint8_t tr_top[4] = { lo, lo, lo, lo };
|
2010-06-22 22:24:09 +03:00
|
|
|
|
|
|
|
// all blocks on the right edge of the macroblock use bottom edge
|
|
|
|
// the top macroblock for their topright edge
|
|
|
|
uint8_t *tr_right = ptr - s->linesize + 16;
|
|
|
|
|
|
|
|
// if we're on the right edge of the frame, said edge is extended
|
|
|
|
// from the top macroblock
|
2014-03-28 03:13:54 +03:00
|
|
|
if (mb_y && mb_x == s->mb_width - 1) {
|
|
|
|
tr = tr_right[-1] * 0x01010101u;
|
|
|
|
tr_right = (uint8_t *) &tr;
|
2010-06-22 22:24:09 +03:00
|
|
|
}
|
|
|
|
|
2010-07-23 03:05:44 +03:00
|
|
|
if (mb->skip)
|
2012-07-12 23:07:06 +03:00
|
|
|
AV_ZERO128(td->non_zero_count_cache);
|
2010-07-23 03:05:44 +03:00
|
|
|
|
2010-06-22 22:24:09 +03:00
|
|
|
for (y = 0; y < 4; y++) {
|
|
|
|
uint8_t *topright = ptr + 4 - s->linesize;
|
|
|
|
for (x = 0; x < 4; x++) {
|
2016-08-23 23:26:35 +02:00
|
|
|
int copy = 0;
|
|
|
|
ptrdiff_t linesize = s->linesize;
|
2014-03-28 03:13:54 +03:00
|
|
|
uint8_t *dst = ptr + 4 * x;
|
2015-03-14 15:26:16 +02:00
|
|
|
LOCAL_ALIGNED(4, uint8_t, copy_dst, [5 * 8]);
|
2010-12-28 19:37:19 +02:00
|
|
|
|
2013-12-20 13:20:24 +03:00
|
|
|
if ((y == 0 || x == 3) && mb_y == 0) {
|
2010-12-28 19:37:19 +02:00
|
|
|
topright = tr_top;
|
|
|
|
} else if (x == 3)
|
2010-06-22 22:24:09 +03:00
|
|
|
topright = tr_right;
|
|
|
|
|
2014-04-01 15:21:51 +03:00
|
|
|
mode = check_intra_pred4x4_mode_emuedge(intra4x4[x], mb_x + x,
|
|
|
|
mb_y + y, ©, is_vp7);
|
2013-12-20 13:20:24 +03:00
|
|
|
if (copy) {
|
2014-03-28 03:13:54 +03:00
|
|
|
dst = copy_dst + 12;
|
2013-12-20 13:20:24 +03:00
|
|
|
linesize = 8;
|
|
|
|
if (!(mb_y + y)) {
|
2014-02-18 13:52:30 +03:00
|
|
|
copy_dst[3] = lo;
|
2014-03-30 03:39:46 +03:00
|
|
|
AV_WN32A(copy_dst + 4, lo * 0x01010101U);
|
2013-12-20 13:20:24 +03:00
|
|
|
} else {
|
2014-03-28 03:13:54 +03:00
|
|
|
AV_COPY32(copy_dst + 4, ptr + 4 * x - s->linesize);
|
2010-12-28 19:37:19 +02:00
|
|
|
if (!(mb_x + x)) {
|
2014-02-18 13:52:30 +03:00
|
|
|
copy_dst[3] = hi;
|
2010-12-28 19:37:19 +02:00
|
|
|
} else {
|
2014-03-28 03:13:54 +03:00
|
|
|
copy_dst[3] = ptr[4 * x - s->linesize - 1];
|
2010-12-28 19:37:19 +02:00
|
|
|
}
|
|
|
|
}
|
2013-12-20 13:20:24 +03:00
|
|
|
if (!(mb_x + x)) {
|
|
|
|
copy_dst[11] =
|
|
|
|
copy_dst[19] =
|
|
|
|
copy_dst[27] =
|
2014-02-18 13:52:30 +03:00
|
|
|
copy_dst[35] = hi;
|
2013-12-20 13:20:24 +03:00
|
|
|
} else {
|
2014-03-28 03:13:54 +03:00
|
|
|
copy_dst[11] = ptr[4 * x - 1];
|
|
|
|
copy_dst[19] = ptr[4 * x + s->linesize - 1];
|
|
|
|
copy_dst[27] = ptr[4 * x + s->linesize * 2 - 1];
|
|
|
|
copy_dst[35] = ptr[4 * x + s->linesize * 3 - 1];
|
2013-12-20 13:20:24 +03:00
|
|
|
}
|
2010-12-28 19:37:19 +02:00
|
|
|
}
|
|
|
|
s->hpc.pred4x4[mode](dst, topright, linesize);
|
|
|
|
if (copy) {
|
2014-03-28 03:13:54 +03:00
|
|
|
AV_COPY32(ptr + 4 * x, copy_dst + 12);
|
|
|
|
AV_COPY32(ptr + 4 * x + s->linesize, copy_dst + 20);
|
|
|
|
AV_COPY32(ptr + 4 * x + s->linesize * 2, copy_dst + 28);
|
|
|
|
AV_COPY32(ptr + 4 * x + s->linesize * 3, copy_dst + 36);
|
2010-12-28 19:37:19 +02:00
|
|
|
}
|
2010-06-22 22:24:09 +03:00
|
|
|
|
2012-07-12 23:07:06 +03:00
|
|
|
nnz = td->non_zero_count_cache[y][x];
|
2010-06-22 22:24:09 +03:00
|
|
|
if (nnz) {
|
|
|
|
if (nnz == 1)
|
2014-03-28 03:13:54 +03:00
|
|
|
s->vp8dsp.vp8_idct_dc_add(ptr + 4 * x,
|
|
|
|
td->block[y][x], s->linesize);
|
2010-06-22 22:24:09 +03:00
|
|
|
else
|
2014-03-28 03:13:54 +03:00
|
|
|
s->vp8dsp.vp8_idct_add(ptr + 4 * x,
|
|
|
|
td->block[y][x], s->linesize);
|
2010-06-22 22:24:09 +03:00
|
|
|
}
|
|
|
|
topright += 4;
|
|
|
|
}
|
|
|
|
|
2014-03-28 03:13:54 +03:00
|
|
|
ptr += 4 * s->linesize;
|
2010-08-02 12:44:53 +03:00
|
|
|
intra4x4 += 4;
|
2010-06-22 22:24:09 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-04-01 15:21:51 +03:00
|
|
|
mode = check_intra_pred8x8_mode_emuedge(mb->chroma_pred_mode,
|
|
|
|
mb_x, mb_y, is_vp7);
|
2010-06-22 22:24:09 +03:00
|
|
|
s->hpc.pred8x8[mode](dst[1], s->uvlinesize);
|
|
|
|
s->hpc.pred8x8[mode](dst[2], s->uvlinesize);
|
2010-07-16 10:20:35 +03:00
|
|
|
|
2013-12-20 13:20:24 +03:00
|
|
|
if (mb_y && (s->deblock_filter || !mb_y) && td->thread_nr == 0)
|
2014-03-28 03:13:54 +03:00
|
|
|
xchg_mb_border(s->top_border[mb_x + 1], dst[0], dst[1], dst[2],
|
2010-07-16 10:20:35 +03:00
|
|
|
s->linesize, s->uvlinesize, mb_x, mb_y, s->mb_width,
|
|
|
|
s->filter.simple, 0);
|
2010-06-22 22:24:09 +03:00
|
|
|
}
|
|
|
|
|
2011-02-01 05:04:29 +02:00
|
|
|
static const uint8_t subpel_idx[3][8] = {
|
|
|
|
{ 0, 1, 2, 1, 2, 1, 2, 1 }, // nr. of left extra pixels,
|
|
|
|
// also function pointer index
|
|
|
|
{ 0, 3, 5, 3, 5, 3, 5, 3 }, // nr. of extra pixels required
|
|
|
|
{ 0, 2, 3, 2, 3, 2, 3, 2 }, // nr. of right extra pixels
|
|
|
|
};
|
|
|
|
|
2010-06-22 22:24:09 +03:00
|
|
|
/**
|
2011-07-03 17:09:37 +03:00
|
|
|
* luma MC function
|
2010-06-22 22:24:09 +03:00
|
|
|
*
|
2014-03-28 03:13:54 +03:00
|
|
|
* @param s VP8 decoding context
|
|
|
|
* @param dst target buffer for block data at block position
|
|
|
|
* @param ref reference picture buffer at origin (0, 0)
|
|
|
|
* @param mv motion vector (relative to block position) to get pixel data from
|
|
|
|
* @param x_off horizontal position of block from origin (0, 0)
|
|
|
|
* @param y_off vertical position of block from origin (0, 0)
|
|
|
|
* @param block_w width of block (16, 8 or 4)
|
|
|
|
* @param block_h height of block (always same as block_w)
|
|
|
|
* @param width width of src/dst plane data
|
|
|
|
* @param height height of src/dst plane data
|
2010-06-22 22:24:09 +03:00
|
|
|
* @param linesize size of a single line of plane data, including padding
|
2014-03-28 03:13:54 +03:00
|
|
|
* @param mc_func motion compensation function pointers (bilinear or sixtap MC)
|
2010-06-22 22:24:09 +03:00
|
|
|
*/
|
2010-07-24 00:36:21 +03:00
|
|
|
static av_always_inline
|
2012-07-12 23:07:06 +03:00
|
|
|
void vp8_mc_luma(VP8Context *s, VP8ThreadData *td, uint8_t *dst,
|
2022-07-22 07:11:47 +02:00
|
|
|
const ThreadFrame *ref, const VP8mv *mv,
|
2011-02-01 05:04:29 +02:00
|
|
|
int x_off, int y_off, int block_w, int block_h,
|
2013-09-28 03:13:59 +03:00
|
|
|
int width, int height, ptrdiff_t linesize,
|
2011-02-01 05:04:29 +02:00
|
|
|
vp8_mc_func mc_func[3][3])
|
2010-06-22 22:24:09 +03:00
|
|
|
{
|
2012-11-21 23:34:46 +03:00
|
|
|
uint8_t *src = ref->f->data[0];
|
2011-05-02 16:55:52 +03:00
|
|
|
|
2010-07-22 08:49:09 +03:00
|
|
|
if (AV_RN32A(mv)) {
|
2016-08-23 23:26:35 +02:00
|
|
|
ptrdiff_t src_linesize = linesize;
|
2011-02-01 05:04:29 +02:00
|
|
|
|
2015-03-11 17:55:07 +02:00
|
|
|
int mx = (mv->x * 2) & 7, mx_idx = subpel_idx[0][mx];
|
|
|
|
int my = (mv->y * 2) & 7, my_idx = subpel_idx[0][my];
|
2011-02-01 05:04:29 +02:00
|
|
|
|
|
|
|
x_off += mv->x >> 2;
|
|
|
|
y_off += mv->y >> 2;
|
2010-07-22 08:49:09 +03:00
|
|
|
|
|
|
|
// edge emulation
|
2011-05-02 16:55:52 +03:00
|
|
|
ff_thread_await_progress(ref, (3 + y_off + block_h + subpel_idx[2][my]) >> 4, 0);
|
2010-07-22 08:49:09 +03:00
|
|
|
src += y_off * linesize + x_off;
|
2011-02-01 05:04:29 +02:00
|
|
|
if (x_off < mx_idx || x_off >= width - block_w - subpel_idx[2][mx] ||
|
|
|
|
y_off < my_idx || y_off >= height - block_h - subpel_idx[2][my]) {
|
2013-10-14 04:13:10 +03:00
|
|
|
s->vdsp.emulated_edge_mc(td->edge_emu_buffer,
|
|
|
|
src - my_idx * linesize - mx_idx,
|
2014-01-20 15:12:54 +03:00
|
|
|
EDGE_EMU_LINESIZE, linesize,
|
2013-09-20 15:01:19 +03:00
|
|
|
block_w + subpel_idx[1][mx],
|
|
|
|
block_h + subpel_idx[1][my],
|
2014-03-28 03:13:54 +03:00
|
|
|
x_off - mx_idx, y_off - my_idx,
|
|
|
|
width, height);
|
2014-01-20 15:12:54 +03:00
|
|
|
src = td->edge_emu_buffer + mx_idx + EDGE_EMU_LINESIZE * my_idx;
|
|
|
|
src_linesize = EDGE_EMU_LINESIZE;
|
2010-07-22 08:49:09 +03:00
|
|
|
}
|
2013-09-20 15:01:19 +03:00
|
|
|
mc_func[my_idx][mx_idx](dst, linesize, src, src_linesize, block_h, mx, my);
|
2011-05-02 16:55:52 +03:00
|
|
|
} else {
|
|
|
|
ff_thread_await_progress(ref, (3 + y_off + block_h) >> 4, 0);
|
2014-03-28 03:13:54 +03:00
|
|
|
mc_func[0][0](dst, linesize, src + y_off * linesize + x_off,
|
|
|
|
linesize, block_h, 0, 0);
|
2011-05-02 16:55:52 +03:00
|
|
|
}
|
2010-06-22 22:24:09 +03:00
|
|
|
}
|
|
|
|
|
2011-07-03 17:09:37 +03:00
|
|
|
/**
|
|
|
|
* chroma MC function
|
|
|
|
*
|
2014-03-28 03:13:54 +03:00
|
|
|
* @param s VP8 decoding context
|
|
|
|
* @param dst1 target buffer for block data at block position (U plane)
|
|
|
|
* @param dst2 target buffer for block data at block position (V plane)
|
|
|
|
* @param ref reference picture buffer at origin (0, 0)
|
|
|
|
* @param mv motion vector (relative to block position) to get pixel data from
|
|
|
|
* @param x_off horizontal position of block from origin (0, 0)
|
|
|
|
* @param y_off vertical position of block from origin (0, 0)
|
|
|
|
* @param block_w width of block (16, 8 or 4)
|
|
|
|
* @param block_h height of block (always same as block_w)
|
|
|
|
* @param width width of src/dst plane data
|
|
|
|
* @param height height of src/dst plane data
|
2011-07-03 17:09:37 +03:00
|
|
|
* @param linesize size of a single line of plane data, including padding
|
2014-03-28 03:13:54 +03:00
|
|
|
* @param mc_func motion compensation function pointers (bilinear or sixtap MC)
|
2011-07-03 17:09:37 +03:00
|
|
|
*/
|
2011-02-01 05:04:29 +02:00
|
|
|
static av_always_inline
|
2014-03-28 03:13:54 +03:00
|
|
|
void vp8_mc_chroma(VP8Context *s, VP8ThreadData *td, uint8_t *dst1,
|
2022-07-22 07:11:47 +02:00
|
|
|
uint8_t *dst2, const ThreadFrame *ref, const VP8mv *mv,
|
2014-03-28 03:13:54 +03:00
|
|
|
int x_off, int y_off, int block_w, int block_h,
|
|
|
|
int width, int height, ptrdiff_t linesize,
|
2011-02-01 05:04:29 +02:00
|
|
|
vp8_mc_func mc_func[3][3])
|
|
|
|
{
|
2012-11-21 23:34:46 +03:00
|
|
|
uint8_t *src1 = ref->f->data[1], *src2 = ref->f->data[2];
|
2011-05-02 16:55:52 +03:00
|
|
|
|
2011-02-01 05:04:29 +02:00
|
|
|
if (AV_RN32A(mv)) {
|
2014-03-28 03:13:54 +03:00
|
|
|
int mx = mv->x & 7, mx_idx = subpel_idx[0][mx];
|
|
|
|
int my = mv->y & 7, my_idx = subpel_idx[0][my];
|
2011-02-01 05:04:29 +02:00
|
|
|
|
|
|
|
x_off += mv->x >> 3;
|
|
|
|
y_off += mv->y >> 3;
|
|
|
|
|
|
|
|
// edge emulation
|
|
|
|
src1 += y_off * linesize + x_off;
|
|
|
|
src2 += y_off * linesize + x_off;
|
2011-05-02 16:55:52 +03:00
|
|
|
ff_thread_await_progress(ref, (3 + y_off + block_h + subpel_idx[2][my]) >> 3, 0);
|
2011-02-01 05:04:29 +02:00
|
|
|
if (x_off < mx_idx || x_off >= width - block_w - subpel_idx[2][mx] ||
|
|
|
|
y_off < my_idx || y_off >= height - block_h - subpel_idx[2][my]) {
|
2013-10-14 04:13:10 +03:00
|
|
|
s->vdsp.emulated_edge_mc(td->edge_emu_buffer,
|
|
|
|
src1 - my_idx * linesize - mx_idx,
|
2014-01-20 15:12:54 +03:00
|
|
|
EDGE_EMU_LINESIZE, linesize,
|
2013-09-20 15:01:19 +03:00
|
|
|
block_w + subpel_idx[1][mx],
|
|
|
|
block_h + subpel_idx[1][my],
|
2012-12-15 20:46:02 +03:00
|
|
|
x_off - mx_idx, y_off - my_idx, width, height);
|
2014-01-20 15:12:54 +03:00
|
|
|
src1 = td->edge_emu_buffer + mx_idx + EDGE_EMU_LINESIZE * my_idx;
|
|
|
|
mc_func[my_idx][mx_idx](dst1, linesize, src1, EDGE_EMU_LINESIZE, block_h, mx, my);
|
2011-02-01 05:04:29 +02:00
|
|
|
|
2013-10-14 04:13:10 +03:00
|
|
|
s->vdsp.emulated_edge_mc(td->edge_emu_buffer,
|
|
|
|
src2 - my_idx * linesize - mx_idx,
|
2014-01-20 15:12:54 +03:00
|
|
|
EDGE_EMU_LINESIZE, linesize,
|
2013-09-20 15:01:19 +03:00
|
|
|
block_w + subpel_idx[1][mx],
|
|
|
|
block_h + subpel_idx[1][my],
|
2012-12-15 20:46:02 +03:00
|
|
|
x_off - mx_idx, y_off - my_idx, width, height);
|
2014-02-04 18:10:24 +03:00
|
|
|
src2 = td->edge_emu_buffer + mx_idx + EDGE_EMU_LINESIZE * my_idx;
|
2014-01-20 15:12:54 +03:00
|
|
|
mc_func[my_idx][mx_idx](dst2, linesize, src2, EDGE_EMU_LINESIZE, block_h, mx, my);
|
2011-02-01 05:04:29 +02:00
|
|
|
} else {
|
|
|
|
mc_func[my_idx][mx_idx](dst1, linesize, src1, linesize, block_h, mx, my);
|
|
|
|
mc_func[my_idx][mx_idx](dst2, linesize, src2, linesize, block_h, mx, my);
|
|
|
|
}
|
|
|
|
} else {
|
2011-05-02 16:55:52 +03:00
|
|
|
ff_thread_await_progress(ref, (3 + y_off + block_h) >> 3, 0);
|
2011-02-01 05:04:29 +02:00
|
|
|
mc_func[0][0](dst1, linesize, src1 + y_off * linesize + x_off, linesize, block_h, 0, 0);
|
|
|
|
mc_func[0][0](dst2, linesize, src2 + y_off * linesize + x_off, linesize, block_h, 0, 0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-07-24 00:36:21 +03:00
|
|
|
static av_always_inline
|
2012-07-12 23:07:06 +03:00
|
|
|
void vp8_mc_part(VP8Context *s, VP8ThreadData *td, uint8_t *dst[3],
|
2012-11-21 23:34:46 +03:00
|
|
|
ThreadFrame *ref_frame, int x_off, int y_off,
|
2014-03-28 03:13:54 +03:00
|
|
|
int bx_off, int by_off, int block_w, int block_h,
|
avcodec/vp8, vp9: Avoid using VP56mv and VP56Frame in VP8/9
Instead replace VP56mv by new and identical structures VP8mv and VP9mv.
Also replace VP56Frame by VP8FrameType in vp8.h and use that
in VP8 code. Also remove VP56_FRAME_GOLDEN2, as this has only
been used by VP8, and use VP8_FRAME_ALTREF as replacement for
its usage in VP8 as this is more in line with VP8 verbiage.
This allows to remove all inclusions of vp56.h from everything
that is not VP5/6. This also removes implicit inclusions
of hpeldsp.h, h264chroma.h, vp3dsp.h and vp56dsp.h from all VP8/9
files.
(This also fixes a build issue: If one compiles with -O0 and disables
everything except the VP8-VAAPI encoder, the file containing
ff_vpx_norm_shift is not compiled, yet this is used implicitly
by vp56_rac_gets_nn() which is defined in vp56.h; it is unused
by the VP8-VAAPI encoder and declared as av_unused, yet with -O0
unused noninline functions are not optimized away, leading to
linking failures. With this patch, said function is not included
in vaapi_encode_vp8.c any more.)
Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
2022-07-23 02:01:41 +02:00
|
|
|
int width, int height, VP8mv *mv)
|
2010-06-28 16:50:55 +03:00
|
|
|
{
|
avcodec/vp8, vp9: Avoid using VP56mv and VP56Frame in VP8/9
Instead replace VP56mv by new and identical structures VP8mv and VP9mv.
Also replace VP56Frame by VP8FrameType in vp8.h and use that
in VP8 code. Also remove VP56_FRAME_GOLDEN2, as this has only
been used by VP8, and use VP8_FRAME_ALTREF as replacement for
its usage in VP8 as this is more in line with VP8 verbiage.
This allows to remove all inclusions of vp56.h from everything
that is not VP5/6. This also removes implicit inclusions
of hpeldsp.h, h264chroma.h, vp3dsp.h and vp56dsp.h from all VP8/9
files.
(This also fixes a build issue: If one compiles with -O0 and disables
everything except the VP8-VAAPI encoder, the file containing
ff_vpx_norm_shift is not compiled, yet this is used implicitly
by vp56_rac_gets_nn() which is defined in vp56.h; it is unused
by the VP8-VAAPI encoder and declared as av_unused, yet with -O0
unused noninline functions are not optimized away, leading to
linking failures. With this patch, said function is not included
in vaapi_encode_vp8.c any more.)
Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
2022-07-23 02:01:41 +02:00
|
|
|
VP8mv uvmv = *mv;
|
2010-06-28 16:50:55 +03:00
|
|
|
|
|
|
|
/* Y */
|
2012-07-12 23:07:06 +03:00
|
|
|
vp8_mc_luma(s, td, dst[0] + by_off * s->linesize + bx_off,
|
2011-05-02 16:55:52 +03:00
|
|
|
ref_frame, mv, x_off + bx_off, y_off + by_off,
|
2011-02-01 05:04:29 +02:00
|
|
|
block_w, block_h, width, height, s->linesize,
|
|
|
|
s->put_pixels_tab[block_w == 8]);
|
2010-06-28 16:50:55 +03:00
|
|
|
|
|
|
|
/* U/V */
|
|
|
|
if (s->profile == 3) {
|
2014-04-01 15:21:51 +03:00
|
|
|
/* this block only applies VP8; it is safe to check
|
|
|
|
* only the profile, as VP7 profile <= 1 */
|
2010-06-28 16:50:55 +03:00
|
|
|
uvmv.x &= ~7;
|
|
|
|
uvmv.y &= ~7;
|
|
|
|
}
|
2014-03-28 03:13:54 +03:00
|
|
|
x_off >>= 1;
|
|
|
|
y_off >>= 1;
|
|
|
|
bx_off >>= 1;
|
|
|
|
by_off >>= 1;
|
|
|
|
width >>= 1;
|
|
|
|
height >>= 1;
|
|
|
|
block_w >>= 1;
|
|
|
|
block_h >>= 1;
|
2012-07-12 23:07:06 +03:00
|
|
|
vp8_mc_chroma(s, td, dst[1] + by_off * s->uvlinesize + bx_off,
|
2011-05-02 16:55:52 +03:00
|
|
|
dst[2] + by_off * s->uvlinesize + bx_off, ref_frame,
|
|
|
|
&uvmv, x_off + bx_off, y_off + by_off,
|
2011-02-01 05:04:29 +02:00
|
|
|
block_w, block_h, width, height, s->uvlinesize,
|
|
|
|
s->put_pixels_tab[1 + (block_w == 4)]);
|
2010-06-28 16:50:55 +03:00
|
|
|
}
|
|
|
|
|
2010-07-22 06:09:10 +03:00
|
|
|
/* Fetch pixels for estimated mv 4 macroblocks ahead.
|
2014-03-28 03:13:54 +03:00
|
|
|
* Optimized for 64-byte cache lines. Inspired by ffh264 prefetch_motion. */
|
|
|
|
static av_always_inline
|
|
|
|
void prefetch_motion(VP8Context *s, VP8Macroblock *mb, int mb_x, int mb_y,
|
|
|
|
int mb_xy, int ref)
|
2010-07-22 06:09:10 +03:00
|
|
|
{
|
2010-07-23 04:59:56 +03:00
|
|
|
/* Don't prefetch refs that haven't been used very often this frame. */
|
2014-03-28 03:13:54 +03:00
|
|
|
if (s->ref_count[ref - 1] > (mb_xy >> 5)) {
|
2010-07-23 02:03:08 +03:00
|
|
|
int x_off = mb_x << 4, y_off = mb_y << 4;
|
2014-03-28 03:13:54 +03:00
|
|
|
int mx = (mb->mv.x >> 2) + x_off + 8;
|
|
|
|
int my = (mb->mv.y >> 2) + y_off;
|
|
|
|
uint8_t **src = s->framep[ref]->tf.f->data;
|
|
|
|
int off = mx + (my + (mb_x & 3) * 4) * s->linesize + 64;
|
2011-05-02 16:55:52 +03:00
|
|
|
/* For threading, a ff_thread_await_progress here might be useful, but
|
|
|
|
* it actually slows down the decoder. Since a bad prefetch doesn't
|
|
|
|
* generate bad decoder output, we don't run it here. */
|
2014-03-28 03:13:54 +03:00
|
|
|
s->vdsp.prefetch(src[0] + off, s->linesize, 4);
|
|
|
|
off = (mx >> 1) + ((my >> 1) + (mb_x & 7)) * s->uvlinesize + 64;
|
|
|
|
s->vdsp.prefetch(src[1] + off, src[2] - src[1], 2);
|
2010-07-23 02:03:08 +03:00
|
|
|
}
|
2010-07-22 06:09:10 +03:00
|
|
|
}
|
|
|
|
|
2010-06-22 22:24:09 +03:00
|
|
|
/**
|
|
|
|
* Apply motion vectors to prediction buffer, chapter 18.
|
|
|
|
*/
|
2010-07-24 00:36:21 +03:00
|
|
|
static av_always_inline
|
2012-07-12 23:07:06 +03:00
|
|
|
void inter_predict(VP8Context *s, VP8ThreadData *td, uint8_t *dst[3],
|
|
|
|
VP8Macroblock *mb, int mb_x, int mb_y)
|
2010-06-22 22:24:09 +03:00
|
|
|
{
|
|
|
|
int x_off = mb_x << 4, y_off = mb_y << 4;
|
2014-03-28 03:13:54 +03:00
|
|
|
int width = 16 * s->mb_width, height = 16 * s->mb_height;
|
2012-11-21 23:34:46 +03:00
|
|
|
ThreadFrame *ref = &s->framep[mb->ref_frame]->tf;
|
avcodec/vp8, vp9: Avoid using VP56mv and VP56Frame in VP8/9
Instead replace VP56mv by new and identical structures VP8mv and VP9mv.
Also replace VP56Frame by VP8FrameType in vp8.h and use that
in VP8 code. Also remove VP56_FRAME_GOLDEN2, as this has only
been used by VP8, and use VP8_FRAME_ALTREF as replacement for
its usage in VP8 as this is more in line with VP8 verbiage.
This allows to remove all inclusions of vp56.h from everything
that is not VP5/6. This also removes implicit inclusions
of hpeldsp.h, h264chroma.h, vp3dsp.h and vp56dsp.h from all VP8/9
files.
(This also fixes a build issue: If one compiles with -O0 and disables
everything except the VP8-VAAPI encoder, the file containing
ff_vpx_norm_shift is not compiled, yet this is used implicitly
by vp56_rac_gets_nn() which is defined in vp56.h; it is unused
by the VP8-VAAPI encoder and declared as av_unused, yet with -O0
unused noninline functions are not optimized away, leading to
linking failures. With this patch, said function is not included
in vaapi_encode_vp8.c any more.)
Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
2022-07-23 02:01:41 +02:00
|
|
|
VP8mv *bmv = mb->bmv;
|
2010-06-22 22:24:09 +03:00
|
|
|
|
2011-01-30 07:09:33 +02:00
|
|
|
switch (mb->partitioning) {
|
|
|
|
case VP8_SPLITMVMODE_NONE:
|
2012-07-12 23:07:06 +03:00
|
|
|
vp8_mc_part(s, td, dst, ref, x_off, y_off,
|
2010-06-28 16:50:55 +03:00
|
|
|
0, 0, 16, 16, width, height, &mb->mv);
|
2011-01-30 07:09:33 +02:00
|
|
|
break;
|
2010-06-28 16:50:55 +03:00
|
|
|
case VP8_SPLITMVMODE_4x4: {
|
2010-06-22 22:24:09 +03:00
|
|
|
int x, y;
|
avcodec/vp8, vp9: Avoid using VP56mv and VP56Frame in VP8/9
Instead replace VP56mv by new and identical structures VP8mv and VP9mv.
Also replace VP56Frame by VP8FrameType in vp8.h and use that
in VP8 code. Also remove VP56_FRAME_GOLDEN2, as this has only
been used by VP8, and use VP8_FRAME_ALTREF as replacement for
its usage in VP8 as this is more in line with VP8 verbiage.
This allows to remove all inclusions of vp56.h from everything
that is not VP5/6. This also removes implicit inclusions
of hpeldsp.h, h264chroma.h, vp3dsp.h and vp56dsp.h from all VP8/9
files.
(This also fixes a build issue: If one compiles with -O0 and disables
everything except the VP8-VAAPI encoder, the file containing
ff_vpx_norm_shift is not compiled, yet this is used implicitly
by vp56_rac_gets_nn() which is defined in vp56.h; it is unused
by the VP8-VAAPI encoder and declared as av_unused, yet with -O0
unused noninline functions are not optimized away, leading to
linking failures. With this patch, said function is not included
in vaapi_encode_vp8.c any more.)
Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
2022-07-23 02:01:41 +02:00
|
|
|
VP8mv uvmv;
|
2010-06-22 22:24:09 +03:00
|
|
|
|
|
|
|
/* Y */
|
|
|
|
for (y = 0; y < 4; y++) {
|
|
|
|
for (x = 0; x < 4; x++) {
|
2014-03-28 03:13:54 +03:00
|
|
|
vp8_mc_luma(s, td, dst[0] + 4 * y * s->linesize + x * 4,
|
|
|
|
ref, &bmv[4 * y + x],
|
|
|
|
4 * x + x_off, 4 * y + y_off, 4, 4,
|
2011-02-01 05:04:29 +02:00
|
|
|
width, height, s->linesize,
|
|
|
|
s->put_pixels_tab[2]);
|
2010-06-22 22:24:09 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* U/V */
|
2014-03-28 03:13:54 +03:00
|
|
|
x_off >>= 1;
|
|
|
|
y_off >>= 1;
|
|
|
|
width >>= 1;
|
|
|
|
height >>= 1;
|
2010-06-22 22:24:09 +03:00
|
|
|
for (y = 0; y < 2; y++) {
|
|
|
|
for (x = 0; x < 2; x++) {
|
2014-03-28 03:13:54 +03:00
|
|
|
uvmv.x = mb->bmv[2 * y * 4 + 2 * x ].x +
|
|
|
|
mb->bmv[2 * y * 4 + 2 * x + 1].x +
|
|
|
|
mb->bmv[(2 * y + 1) * 4 + 2 * x ].x +
|
|
|
|
mb->bmv[(2 * y + 1) * 4 + 2 * x + 1].x;
|
|
|
|
uvmv.y = mb->bmv[2 * y * 4 + 2 * x ].y +
|
|
|
|
mb->bmv[2 * y * 4 + 2 * x + 1].y +
|
|
|
|
mb->bmv[(2 * y + 1) * 4 + 2 * x ].y +
|
|
|
|
mb->bmv[(2 * y + 1) * 4 + 2 * x + 1].y;
|
2014-11-17 01:22:27 +02:00
|
|
|
uvmv.x = (uvmv.x + 2 + FF_SIGNBIT(uvmv.x)) >> 2;
|
|
|
|
uvmv.y = (uvmv.y + 2 + FF_SIGNBIT(uvmv.y)) >> 2;
|
2010-06-22 22:24:09 +03:00
|
|
|
if (s->profile == 3) {
|
|
|
|
uvmv.x &= ~7;
|
|
|
|
uvmv.y &= ~7;
|
|
|
|
}
|
2014-03-28 03:13:54 +03:00
|
|
|
vp8_mc_chroma(s, td, dst[1] + 4 * y * s->uvlinesize + x * 4,
|
|
|
|
dst[2] + 4 * y * s->uvlinesize + x * 4, ref,
|
|
|
|
&uvmv, 4 * x + x_off, 4 * y + y_off, 4, 4,
|
2011-02-01 05:04:29 +02:00
|
|
|
width, height, s->uvlinesize,
|
|
|
|
s->put_pixels_tab[2]);
|
2010-06-22 22:24:09 +03:00
|
|
|
}
|
|
|
|
}
|
2010-06-28 16:50:55 +03:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case VP8_SPLITMVMODE_16x8:
|
2012-07-12 23:07:06 +03:00
|
|
|
vp8_mc_part(s, td, dst, ref, x_off, y_off,
|
2010-07-23 00:05:30 +03:00
|
|
|
0, 0, 16, 8, width, height, &bmv[0]);
|
2012-07-12 23:07:06 +03:00
|
|
|
vp8_mc_part(s, td, dst, ref, x_off, y_off,
|
2010-07-23 00:05:30 +03:00
|
|
|
0, 8, 16, 8, width, height, &bmv[1]);
|
2010-06-28 16:50:55 +03:00
|
|
|
break;
|
|
|
|
case VP8_SPLITMVMODE_8x16:
|
2012-07-12 23:07:06 +03:00
|
|
|
vp8_mc_part(s, td, dst, ref, x_off, y_off,
|
2010-07-23 00:05:30 +03:00
|
|
|
0, 0, 8, 16, width, height, &bmv[0]);
|
2012-07-12 23:07:06 +03:00
|
|
|
vp8_mc_part(s, td, dst, ref, x_off, y_off,
|
2010-07-23 00:05:30 +03:00
|
|
|
8, 0, 8, 16, width, height, &bmv[1]);
|
2010-06-28 16:50:55 +03:00
|
|
|
break;
|
|
|
|
case VP8_SPLITMVMODE_8x8:
|
2012-07-12 23:07:06 +03:00
|
|
|
vp8_mc_part(s, td, dst, ref, x_off, y_off,
|
2010-07-23 00:05:30 +03:00
|
|
|
0, 0, 8, 8, width, height, &bmv[0]);
|
2012-07-12 23:07:06 +03:00
|
|
|
vp8_mc_part(s, td, dst, ref, x_off, y_off,
|
2010-07-23 00:05:30 +03:00
|
|
|
8, 0, 8, 8, width, height, &bmv[1]);
|
2012-07-12 23:07:06 +03:00
|
|
|
vp8_mc_part(s, td, dst, ref, x_off, y_off,
|
2010-07-23 00:05:30 +03:00
|
|
|
0, 8, 8, 8, width, height, &bmv[2]);
|
2012-07-12 23:07:06 +03:00
|
|
|
vp8_mc_part(s, td, dst, ref, x_off, y_off,
|
2010-07-23 00:05:30 +03:00
|
|
|
8, 8, 8, 8, width, height, &bmv[3]);
|
2010-06-28 16:50:55 +03:00
|
|
|
break;
|
2010-06-22 22:24:09 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-03-28 03:13:54 +03:00
|
|
|
static av_always_inline
|
|
|
|
void idct_mb(VP8Context *s, VP8ThreadData *td, uint8_t *dst[3], VP8Macroblock *mb)
|
2010-06-22 22:24:09 +03:00
|
|
|
{
|
2010-07-23 06:44:37 +03:00
|
|
|
int x, y, ch;
|
2010-06-22 22:24:09 +03:00
|
|
|
|
2010-07-23 05:58:27 +03:00
|
|
|
if (mb->mode != MODE_I4x4) {
|
|
|
|
uint8_t *y_dst = dst[0];
|
2010-06-22 22:24:09 +03:00
|
|
|
for (y = 0; y < 4; y++) {
|
2012-07-12 23:07:06 +03:00
|
|
|
uint32_t nnz4 = AV_RL32(td->non_zero_count_cache[y]);
|
2010-07-23 06:44:37 +03:00
|
|
|
if (nnz4) {
|
2014-03-28 03:13:54 +03:00
|
|
|
if (nnz4 & ~0x01010101) {
|
2010-07-23 05:58:27 +03:00
|
|
|
for (x = 0; x < 4; x++) {
|
2014-03-28 03:13:54 +03:00
|
|
|
if ((uint8_t) nnz4 == 1)
|
|
|
|
s->vp8dsp.vp8_idct_dc_add(y_dst + 4 * x,
|
|
|
|
td->block[y][x],
|
|
|
|
s->linesize);
|
|
|
|
else if ((uint8_t) nnz4 > 1)
|
|
|
|
s->vp8dsp.vp8_idct_add(y_dst + 4 * x,
|
|
|
|
td->block[y][x],
|
|
|
|
s->linesize);
|
2011-02-06 07:19:52 +02:00
|
|
|
nnz4 >>= 8;
|
|
|
|
if (!nnz4)
|
|
|
|
break;
|
2010-07-23 05:58:27 +03:00
|
|
|
}
|
|
|
|
} else {
|
2012-07-12 23:07:06 +03:00
|
|
|
s->vp8dsp.vp8_idct_dc_add4y(y_dst, td->block[y], s->linesize);
|
2010-06-22 22:24:09 +03:00
|
|
|
}
|
|
|
|
}
|
2014-03-28 03:13:54 +03:00
|
|
|
y_dst += 4 * s->linesize;
|
2010-06-22 22:24:09 +03:00
|
|
|
}
|
2010-07-23 05:58:27 +03:00
|
|
|
}
|
2010-06-22 22:24:09 +03:00
|
|
|
|
2010-07-23 05:58:27 +03:00
|
|
|
for (ch = 0; ch < 2; ch++) {
|
2014-03-28 03:13:54 +03:00
|
|
|
uint32_t nnz4 = AV_RL32(td->non_zero_count_cache[4 + ch]);
|
2010-07-23 09:02:52 +03:00
|
|
|
if (nnz4) {
|
2014-03-28 03:13:54 +03:00
|
|
|
uint8_t *ch_dst = dst[1 + ch];
|
|
|
|
if (nnz4 & ~0x01010101) {
|
2010-07-23 09:02:52 +03:00
|
|
|
for (y = 0; y < 2; y++) {
|
|
|
|
for (x = 0; x < 2; x++) {
|
2014-03-28 03:13:54 +03:00
|
|
|
if ((uint8_t) nnz4 == 1)
|
|
|
|
s->vp8dsp.vp8_idct_dc_add(ch_dst + 4 * x,
|
|
|
|
td->block[4 + ch][(y << 1) + x],
|
|
|
|
s->uvlinesize);
|
|
|
|
else if ((uint8_t) nnz4 > 1)
|
|
|
|
s->vp8dsp.vp8_idct_add(ch_dst + 4 * x,
|
|
|
|
td->block[4 + ch][(y << 1) + x],
|
|
|
|
s->uvlinesize);
|
2011-02-06 07:19:52 +02:00
|
|
|
nnz4 >>= 8;
|
|
|
|
if (!nnz4)
|
2011-03-09 23:46:23 +02:00
|
|
|
goto chroma_idct_end;
|
2010-07-23 05:58:27 +03:00
|
|
|
}
|
2014-03-28 03:13:54 +03:00
|
|
|
ch_dst += 4 * s->uvlinesize;
|
2010-07-23 05:58:27 +03:00
|
|
|
}
|
2010-07-23 09:02:52 +03:00
|
|
|
} else {
|
2014-03-28 03:13:54 +03:00
|
|
|
s->vp8dsp.vp8_idct_dc_add4uv(ch_dst, td->block[4 + ch], s->uvlinesize);
|
2010-06-22 22:24:09 +03:00
|
|
|
}
|
|
|
|
}
|
2014-03-28 03:13:54 +03:00
|
|
|
chroma_idct_end:
|
|
|
|
;
|
2010-06-22 22:24:09 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-03-28 03:13:54 +03:00
|
|
|
static av_always_inline
|
2014-04-01 15:21:51 +03:00
|
|
|
void filter_level_for_mb(VP8Context *s, VP8Macroblock *mb,
|
|
|
|
VP8FilterStrength *f, int is_vp7)
|
2010-06-22 22:24:09 +03:00
|
|
|
{
|
|
|
|
int interior_limit, filter_level;
|
|
|
|
|
|
|
|
if (s->segmentation.enabled) {
|
2012-07-11 21:34:05 +03:00
|
|
|
filter_level = s->segmentation.filter_level[mb->segment];
|
2010-06-22 22:24:09 +03:00
|
|
|
if (!s->segmentation.absolute_vals)
|
|
|
|
filter_level += s->filter.level;
|
|
|
|
} else
|
|
|
|
filter_level = s->filter.level;
|
|
|
|
|
|
|
|
if (s->lf_delta.enabled) {
|
|
|
|
filter_level += s->lf_delta.ref[mb->ref_frame];
|
2011-02-04 05:17:13 +02:00
|
|
|
filter_level += s->lf_delta.mode[mb->mode];
|
2010-06-22 22:24:09 +03:00
|
|
|
}
|
2011-02-04 05:44:32 +02:00
|
|
|
|
2011-05-13 18:39:17 +03:00
|
|
|
filter_level = av_clip_uintp2(filter_level, 6);
|
2010-06-22 22:24:09 +03:00
|
|
|
|
|
|
|
interior_limit = filter_level;
|
|
|
|
if (s->filter.sharpness) {
|
2011-02-04 09:37:30 +02:00
|
|
|
interior_limit >>= (s->filter.sharpness + 3) >> 2;
|
2010-06-22 22:24:09 +03:00
|
|
|
interior_limit = FFMIN(interior_limit, 9 - s->filter.sharpness);
|
|
|
|
}
|
|
|
|
interior_limit = FFMAX(interior_limit, 1);
|
|
|
|
|
2010-07-22 10:24:22 +03:00
|
|
|
f->filter_level = filter_level;
|
|
|
|
f->inner_limit = interior_limit;
|
2014-04-01 15:21:51 +03:00
|
|
|
f->inner_filter = is_vp7 || !mb->skip || mb->mode == MODE_I4x4 ||
|
2014-03-28 03:13:54 +03:00
|
|
|
mb->mode == VP8_MVMODE_SPLIT;
|
2010-06-22 22:24:09 +03:00
|
|
|
}
|
|
|
|
|
2014-03-28 03:13:54 +03:00
|
|
|
static av_always_inline
|
|
|
|
void filter_mb(VP8Context *s, uint8_t *dst[3], VP8FilterStrength *f,
|
2014-04-01 15:21:51 +03:00
|
|
|
int mb_x, int mb_y, int is_vp7)
|
2010-06-22 22:24:09 +03:00
|
|
|
{
|
2014-02-18 13:52:30 +03:00
|
|
|
int mbedge_lim, bedge_lim_y, bedge_lim_uv, hev_thresh;
|
2010-07-22 10:24:22 +03:00
|
|
|
int filter_level = f->filter_level;
|
|
|
|
int inner_limit = f->inner_limit;
|
2010-07-22 14:45:18 +03:00
|
|
|
int inner_filter = f->inner_filter;
|
2016-08-23 23:26:35 +02:00
|
|
|
ptrdiff_t linesize = s->linesize;
|
|
|
|
ptrdiff_t uvlinesize = s->uvlinesize;
|
2011-02-04 08:48:53 +02:00
|
|
|
static const uint8_t hev_thresh_lut[2][64] = {
|
|
|
|
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1,
|
|
|
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
|
|
3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
|
|
|
|
3, 3, 3, 3 },
|
|
|
|
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1,
|
|
|
|
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
|
|
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
|
|
2, 2, 2, 2 }
|
|
|
|
};
|
2010-06-22 22:24:09 +03:00
|
|
|
|
|
|
|
if (!filter_level)
|
|
|
|
return;
|
|
|
|
|
2014-04-01 15:21:51 +03:00
|
|
|
if (is_vp7) {
|
|
|
|
bedge_lim_y = filter_level;
|
|
|
|
bedge_lim_uv = filter_level * 2;
|
|
|
|
mbedge_lim = filter_level + 2;
|
2014-02-18 13:52:30 +03:00
|
|
|
} else {
|
|
|
|
bedge_lim_y =
|
2014-04-01 15:21:51 +03:00
|
|
|
bedge_lim_uv = filter_level * 2 + inner_limit;
|
|
|
|
mbedge_lim = bedge_lim_y + 4;
|
2014-02-18 13:52:30 +03:00
|
|
|
}
|
2010-07-22 10:24:22 +03:00
|
|
|
|
2011-02-04 08:48:53 +02:00
|
|
|
hev_thresh = hev_thresh_lut[s->keyframe][filter_level];
|
2010-07-03 00:04:45 +03:00
|
|
|
|
2010-06-22 22:24:09 +03:00
|
|
|
if (mb_x) {
|
2014-03-28 03:13:54 +03:00
|
|
|
s->vp8dsp.vp8_h_loop_filter16y(dst[0], linesize,
|
2010-07-20 00:18:04 +03:00
|
|
|
mbedge_lim, inner_limit, hev_thresh);
|
2014-03-28 03:13:54 +03:00
|
|
|
s->vp8dsp.vp8_h_loop_filter8uv(dst[1], dst[2], uvlinesize,
|
2010-07-20 00:18:04 +03:00
|
|
|
mbedge_lim, inner_limit, hev_thresh);
|
2010-06-22 22:24:09 +03:00
|
|
|
}
|
|
|
|
|
2014-04-01 15:21:51 +03:00
|
|
|
#define H_LOOP_FILTER_16Y_INNER(cond) \
|
|
|
|
if (cond && inner_filter) { \
|
|
|
|
s->vp8dsp.vp8_h_loop_filter16y_inner(dst[0] + 4, linesize, \
|
|
|
|
bedge_lim_y, inner_limit, \
|
|
|
|
hev_thresh); \
|
|
|
|
s->vp8dsp.vp8_h_loop_filter16y_inner(dst[0] + 8, linesize, \
|
|
|
|
bedge_lim_y, inner_limit, \
|
|
|
|
hev_thresh); \
|
|
|
|
s->vp8dsp.vp8_h_loop_filter16y_inner(dst[0] + 12, linesize, \
|
|
|
|
bedge_lim_y, inner_limit, \
|
|
|
|
hev_thresh); \
|
|
|
|
s->vp8dsp.vp8_h_loop_filter8uv_inner(dst[1] + 4, dst[2] + 4, \
|
|
|
|
uvlinesize, bedge_lim_uv, \
|
|
|
|
inner_limit, hev_thresh); \
|
2010-06-22 22:24:09 +03:00
|
|
|
}
|
|
|
|
|
2014-04-01 15:21:51 +03:00
|
|
|
H_LOOP_FILTER_16Y_INNER(!is_vp7)
|
2014-02-18 13:52:30 +03:00
|
|
|
|
2010-06-22 22:24:09 +03:00
|
|
|
if (mb_y) {
|
2014-03-28 03:13:54 +03:00
|
|
|
s->vp8dsp.vp8_v_loop_filter16y(dst[0], linesize,
|
2010-07-20 00:18:04 +03:00
|
|
|
mbedge_lim, inner_limit, hev_thresh);
|
2014-03-28 03:13:54 +03:00
|
|
|
s->vp8dsp.vp8_v_loop_filter8uv(dst[1], dst[2], uvlinesize,
|
2010-07-20 00:18:04 +03:00
|
|
|
mbedge_lim, inner_limit, hev_thresh);
|
2010-06-22 22:24:09 +03:00
|
|
|
}
|
|
|
|
|
2010-07-22 14:45:18 +03:00
|
|
|
if (inner_filter) {
|
2014-03-28 03:13:54 +03:00
|
|
|
s->vp8dsp.vp8_v_loop_filter16y_inner(dst[0] + 4 * linesize,
|
2014-03-30 03:39:46 +03:00
|
|
|
linesize, bedge_lim_y,
|
2010-07-23 02:11:40 +03:00
|
|
|
inner_limit, hev_thresh);
|
2014-03-28 03:13:54 +03:00
|
|
|
s->vp8dsp.vp8_v_loop_filter16y_inner(dst[0] + 8 * linesize,
|
2014-03-30 03:39:46 +03:00
|
|
|
linesize, bedge_lim_y,
|
2010-07-23 02:11:40 +03:00
|
|
|
inner_limit, hev_thresh);
|
2014-03-28 03:13:54 +03:00
|
|
|
s->vp8dsp.vp8_v_loop_filter16y_inner(dst[0] + 12 * linesize,
|
2014-03-30 03:39:46 +03:00
|
|
|
linesize, bedge_lim_y,
|
2010-07-23 02:11:40 +03:00
|
|
|
inner_limit, hev_thresh);
|
2014-03-28 03:13:54 +03:00
|
|
|
s->vp8dsp.vp8_v_loop_filter8uv_inner(dst[1] + 4 * uvlinesize,
|
|
|
|
dst[2] + 4 * uvlinesize,
|
2014-03-30 03:39:46 +03:00
|
|
|
uvlinesize, bedge_lim_uv,
|
2010-07-20 00:18:04 +03:00
|
|
|
inner_limit, hev_thresh);
|
2010-06-22 22:24:09 +03:00
|
|
|
}
|
2014-02-18 13:52:30 +03:00
|
|
|
|
2014-04-01 15:21:51 +03:00
|
|
|
H_LOOP_FILTER_16Y_INNER(is_vp7)
|
2010-06-22 22:24:09 +03:00
|
|
|
}
|
|
|
|
|
2014-03-28 03:13:54 +03:00
|
|
|
static av_always_inline
|
|
|
|
void filter_mb_simple(VP8Context *s, uint8_t *dst, VP8FilterStrength *f,
|
|
|
|
int mb_x, int mb_y)
|
2010-06-22 22:24:09 +03:00
|
|
|
{
|
2010-07-22 10:24:22 +03:00
|
|
|
int mbedge_lim, bedge_lim;
|
|
|
|
int filter_level = f->filter_level;
|
2014-03-28 03:13:54 +03:00
|
|
|
int inner_limit = f->inner_limit;
|
2010-07-22 14:45:18 +03:00
|
|
|
int inner_filter = f->inner_filter;
|
2016-08-23 23:26:35 +02:00
|
|
|
ptrdiff_t linesize = s->linesize;
|
2010-06-22 22:24:09 +03:00
|
|
|
|
|
|
|
if (!filter_level)
|
|
|
|
return;
|
|
|
|
|
2014-03-28 03:13:54 +03:00
|
|
|
bedge_lim = 2 * filter_level + inner_limit;
|
2011-02-04 08:48:53 +02:00
|
|
|
mbedge_lim = bedge_lim + 4;
|
2010-06-22 22:24:09 +03:00
|
|
|
|
|
|
|
if (mb_x)
|
2010-07-23 02:11:40 +03:00
|
|
|
s->vp8dsp.vp8_h_loop_filter_simple(dst, linesize, mbedge_lim);
|
2010-07-22 14:45:18 +03:00
|
|
|
if (inner_filter) {
|
2014-03-28 03:13:54 +03:00
|
|
|
s->vp8dsp.vp8_h_loop_filter_simple(dst + 4, linesize, bedge_lim);
|
|
|
|
s->vp8dsp.vp8_h_loop_filter_simple(dst + 8, linesize, bedge_lim);
|
|
|
|
s->vp8dsp.vp8_h_loop_filter_simple(dst + 12, linesize, bedge_lim);
|
2010-06-22 22:24:09 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
if (mb_y)
|
2010-07-23 02:11:40 +03:00
|
|
|
s->vp8dsp.vp8_v_loop_filter_simple(dst, linesize, mbedge_lim);
|
2010-07-22 14:45:18 +03:00
|
|
|
if (inner_filter) {
|
2014-03-28 03:13:54 +03:00
|
|
|
s->vp8dsp.vp8_v_loop_filter_simple(dst + 4 * linesize, linesize, bedge_lim);
|
|
|
|
s->vp8dsp.vp8_v_loop_filter_simple(dst + 8 * linesize, linesize, bedge_lim);
|
|
|
|
s->vp8dsp.vp8_v_loop_filter_simple(dst + 12 * linesize, linesize, bedge_lim);
|
2010-06-22 22:24:09 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-07-11 21:34:04 +03:00
|
|
|
#define MARGIN (16 << 2)
|
2014-02-18 13:52:30 +03:00
|
|
|
static av_always_inline
|
2018-12-15 02:53:16 +02:00
|
|
|
int vp78_decode_mv_mb_modes(AVCodecContext *avctx, VP8Frame *curframe,
|
2014-04-01 15:21:51 +03:00
|
|
|
VP8Frame *prev_frame, int is_vp7)
|
2012-07-11 21:34:04 +03:00
|
|
|
{
|
|
|
|
VP8Context *s = avctx->priv_data;
|
2012-07-12 23:07:06 +03:00
|
|
|
int mb_x, mb_y;
|
|
|
|
|
2017-04-05 22:19:55 +02:00
|
|
|
s->mv_bounds.mv_min.y = -MARGIN;
|
|
|
|
s->mv_bounds.mv_max.y = ((s->mb_height - 1) << 6) + MARGIN;
|
2012-07-12 23:07:06 +03:00
|
|
|
for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
|
2014-03-28 03:13:54 +03:00
|
|
|
VP8Macroblock *mb = s->macroblocks_base +
|
|
|
|
((s->mb_width + 1) * (mb_y + 1) + 1);
|
|
|
|
int mb_xy = mb_y * s->mb_width;
|
2012-07-12 23:07:06 +03:00
|
|
|
|
2014-03-28 03:13:54 +03:00
|
|
|
AV_WN32A(s->intra4x4_pred_mode_left, DC_PRED * 0x01010101);
|
2012-07-12 23:07:06 +03:00
|
|
|
|
2017-04-05 22:19:55 +02:00
|
|
|
s->mv_bounds.mv_min.x = -MARGIN;
|
|
|
|
s->mv_bounds.mv_max.x = ((s->mb_width - 1) << 6) + MARGIN;
|
2018-12-15 02:53:16 +02:00
|
|
|
|
2012-07-12 23:07:06 +03:00
|
|
|
for (mb_x = 0; mb_x < s->mb_width; mb_x++, mb_xy++, mb++) {
|
2022-07-23 01:28:48 +02:00
|
|
|
if (vpx_rac_is_end(&s->c)) {
|
2021-02-15 18:13:34 +02:00
|
|
|
return AVERROR_INVALIDDATA;
|
|
|
|
}
|
2012-07-12 23:07:06 +03:00
|
|
|
if (mb_y == 0)
|
2014-03-28 03:13:54 +03:00
|
|
|
AV_WN32A((mb - s->mb_width - 1)->intra4x4_pred_mode_top,
|
|
|
|
DC_PRED * 0x01010101);
|
2017-04-05 22:19:55 +02:00
|
|
|
decode_mb_mode(s, &s->mv_bounds, mb, mb_x, mb_y, curframe->seg_map->data + mb_xy,
|
2012-11-21 23:34:46 +03:00
|
|
|
prev_frame && prev_frame->seg_map ?
|
2014-04-01 15:21:51 +03:00
|
|
|
prev_frame->seg_map->data + mb_xy : NULL, 1, is_vp7);
|
2017-04-05 22:19:55 +02:00
|
|
|
s->mv_bounds.mv_min.x -= 64;
|
|
|
|
s->mv_bounds.mv_max.x -= 64;
|
2012-07-12 23:07:06 +03:00
|
|
|
}
|
2017-04-05 22:19:55 +02:00
|
|
|
s->mv_bounds.mv_min.y -= 64;
|
|
|
|
s->mv_bounds.mv_max.y -= 64;
|
2012-07-12 23:07:06 +03:00
|
|
|
}
|
2018-12-15 02:53:16 +02:00
|
|
|
return 0;
|
2012-07-12 23:07:06 +03:00
|
|
|
}
|
|
|
|
|
2018-12-15 02:53:16 +02:00
|
|
|
static int vp7_decode_mv_mb_modes(AVCodecContext *avctx, VP8Frame *cur_frame,
|
2014-02-18 13:52:30 +03:00
|
|
|
VP8Frame *prev_frame)
|
|
|
|
{
|
2018-12-15 02:53:16 +02:00
|
|
|
return vp78_decode_mv_mb_modes(avctx, cur_frame, prev_frame, IS_VP7);
|
2014-02-18 13:52:30 +03:00
|
|
|
}
|
|
|
|
|
2018-12-15 02:53:16 +02:00
|
|
|
static int vp8_decode_mv_mb_modes(AVCodecContext *avctx, VP8Frame *cur_frame,
|
2014-02-18 13:52:30 +03:00
|
|
|
VP8Frame *prev_frame)
|
|
|
|
{
|
2018-12-15 02:53:16 +02:00
|
|
|
return vp78_decode_mv_mb_modes(avctx, cur_frame, prev_frame, IS_VP8);
|
2014-02-18 13:52:30 +03:00
|
|
|
}
|
|
|
|
|
2012-07-15 00:11:35 +03:00
|
|
|
#if HAVE_THREADS
|
2014-03-28 03:13:54 +03:00
|
|
|
#define check_thread_pos(td, otd, mb_x_check, mb_y_check) \
|
|
|
|
do { \
|
|
|
|
int tmp = (mb_y_check << 16) | (mb_x_check & 0xFFFF); \
|
2017-04-05 22:18:54 +02:00
|
|
|
if (atomic_load(&otd->thread_mb_pos) < tmp) { \
|
2014-03-28 03:13:54 +03:00
|
|
|
pthread_mutex_lock(&otd->lock); \
|
2017-04-05 22:18:54 +02:00
|
|
|
atomic_store(&td->wait_mb_pos, tmp); \
|
2014-03-28 03:13:54 +03:00
|
|
|
do { \
|
2017-04-05 22:18:54 +02:00
|
|
|
if (atomic_load(&otd->thread_mb_pos) >= tmp) \
|
2014-03-28 03:13:54 +03:00
|
|
|
break; \
|
|
|
|
pthread_cond_wait(&otd->cond, &otd->lock); \
|
|
|
|
} while (1); \
|
2017-04-05 22:18:54 +02:00
|
|
|
atomic_store(&td->wait_mb_pos, INT_MAX); \
|
2014-03-28 03:13:54 +03:00
|
|
|
pthread_mutex_unlock(&otd->lock); \
|
|
|
|
} \
|
2015-01-18 01:34:19 +02:00
|
|
|
} while (0)
|
2014-03-28 03:13:54 +03:00
|
|
|
|
|
|
|
#define update_pos(td, mb_y, mb_x) \
|
|
|
|
do { \
|
|
|
|
int pos = (mb_y << 16) | (mb_x & 0xFFFF); \
|
|
|
|
int sliced_threading = (avctx->active_thread_type == FF_THREAD_SLICE) && \
|
|
|
|
(num_jobs > 1); \
|
2014-08-14 23:31:24 +03:00
|
|
|
int is_null = !next_td || !prev_td; \
|
2017-04-05 22:18:54 +02:00
|
|
|
int pos_check = (is_null) ? 1 : \
|
|
|
|
(next_td != td && pos >= atomic_load(&next_td->wait_mb_pos)) || \
|
|
|
|
(prev_td != td && pos >= atomic_load(&prev_td->wait_mb_pos)); \
|
|
|
|
atomic_store(&td->thread_mb_pos, pos); \
|
2014-03-28 03:13:54 +03:00
|
|
|
if (sliced_threading && pos_check) { \
|
|
|
|
pthread_mutex_lock(&td->lock); \
|
|
|
|
pthread_cond_broadcast(&td->cond); \
|
|
|
|
pthread_mutex_unlock(&td->lock); \
|
|
|
|
} \
|
2015-01-18 01:34:19 +02:00
|
|
|
} while (0)
|
2012-07-15 00:11:35 +03:00
|
|
|
#else
|
2015-05-06 16:02:57 +02:00
|
|
|
#define check_thread_pos(td, otd, mb_x_check, mb_y_check) while(0)
|
|
|
|
#define update_pos(td, mb_y, mb_x) while(0)
|
2012-07-15 00:11:35 +03:00
|
|
|
#endif
|
2012-07-12 23:07:06 +03:00
|
|
|
|
2017-02-28 04:55:02 +02:00
|
|
|
static av_always_inline int decode_mb_row_no_filter(AVCodecContext *avctx, void *tdata,
|
2014-04-01 15:21:51 +03:00
|
|
|
int jobnr, int threadnr, int is_vp7)
|
2012-07-12 23:07:06 +03:00
|
|
|
{
|
|
|
|
VP8Context *s = avctx->priv_data;
|
|
|
|
VP8ThreadData *prev_td, *next_td, *td = &s->thread_data[threadnr];
|
2017-04-05 22:18:54 +02:00
|
|
|
int mb_y = atomic_load(&td->thread_mb_pos) >> 16;
|
2014-03-28 03:13:54 +03:00
|
|
|
int mb_x, mb_xy = mb_y * s->mb_width;
|
2012-07-12 23:07:06 +03:00
|
|
|
int num_jobs = s->num_jobs;
|
2022-07-22 07:11:47 +02:00
|
|
|
const VP8Frame *prev_frame = s->prev_frame;
|
|
|
|
VP8Frame *curframe = s->curframe;
|
2022-07-23 01:28:48 +02:00
|
|
|
VPXRangeCoder *c = &s->coeff_partition[mb_y & (s->num_coeff_partitions - 1)];
|
2012-07-12 23:07:06 +03:00
|
|
|
VP8Macroblock *mb;
|
2010-06-22 22:24:09 +03:00
|
|
|
uint8_t *dst[3] = {
|
2014-03-28 03:13:54 +03:00
|
|
|
curframe->tf.f->data[0] + 16 * mb_y * s->linesize,
|
|
|
|
curframe->tf.f->data[1] + 8 * mb_y * s->uvlinesize,
|
|
|
|
curframe->tf.f->data[2] + 8 * mb_y * s->uvlinesize
|
2010-06-22 22:24:09 +03:00
|
|
|
};
|
2017-02-28 04:55:02 +02:00
|
|
|
|
2022-07-23 01:28:48 +02:00
|
|
|
if (vpx_rac_is_end(c))
|
2017-02-28 04:55:02 +02:00
|
|
|
return AVERROR_INVALIDDATA;
|
|
|
|
|
2014-03-28 03:13:54 +03:00
|
|
|
if (mb_y == 0)
|
|
|
|
prev_td = td;
|
|
|
|
else
|
|
|
|
prev_td = &s->thread_data[(jobnr + num_jobs - 1) % num_jobs];
|
|
|
|
if (mb_y == s->mb_height - 1)
|
|
|
|
next_td = td;
|
|
|
|
else
|
|
|
|
next_td = &s->thread_data[(jobnr + 1) % num_jobs];
|
2012-07-12 23:07:06 +03:00
|
|
|
if (s->mb_layout == 1)
|
2014-03-28 03:13:54 +03:00
|
|
|
mb = s->macroblocks_base + ((s->mb_width + 1) * (mb_y + 1) + 1);
|
2012-07-12 23:07:06 +03:00
|
|
|
else {
|
2013-06-23 07:16:11 +03:00
|
|
|
// Make sure the previous frame has read its segmentation map,
|
|
|
|
// if we re-use the same map.
|
|
|
|
if (prev_frame && s->segmentation.enabled &&
|
|
|
|
!s->segmentation.update_map)
|
|
|
|
ff_thread_await_progress(&prev_frame->tf, mb_y, 0);
|
2014-03-28 03:13:54 +03:00
|
|
|
mb = s->macroblocks + (s->mb_height - mb_y - 1) * 2;
|
2012-07-12 23:07:06 +03:00
|
|
|
memset(mb - 1, 0, sizeof(*mb)); // zero left macroblock
|
2014-03-28 03:13:54 +03:00
|
|
|
AV_WN32A(s->intra4x4_pred_mode_left, DC_PRED * 0x01010101);
|
2012-07-12 23:07:06 +03:00
|
|
|
}
|
|
|
|
|
2014-04-01 15:21:51 +03:00
|
|
|
if (!is_vp7 || mb_y == 0)
|
2014-02-18 13:52:30 +03:00
|
|
|
memset(td->left_nnz, 0, sizeof(td->left_nnz));
|
2012-07-11 21:34:04 +03:00
|
|
|
|
2017-04-05 22:19:55 +02:00
|
|
|
td->mv_bounds.mv_min.x = -MARGIN;
|
|
|
|
td->mv_bounds.mv_max.x = ((s->mb_width - 1) << 6) + MARGIN;
|
2012-07-11 21:34:04 +03:00
|
|
|
|
|
|
|
for (mb_x = 0; mb_x < s->mb_width; mb_x++, mb_xy++, mb++) {
|
2022-07-23 01:28:48 +02:00
|
|
|
if (vpx_rac_is_end(c))
|
2017-03-07 20:09:39 +02:00
|
|
|
return AVERROR_INVALIDDATA;
|
2012-07-12 23:07:06 +03:00
|
|
|
// Wait for previous thread to read mb_x+2, and reach mb_y-1.
|
|
|
|
if (prev_td != td) {
|
|
|
|
if (threadnr != 0) {
|
2014-04-01 15:21:51 +03:00
|
|
|
check_thread_pos(td, prev_td,
|
|
|
|
mb_x + (is_vp7 ? 2 : 1),
|
|
|
|
mb_y - (is_vp7 ? 2 : 1));
|
2012-07-12 23:07:06 +03:00
|
|
|
} else {
|
2014-03-28 03:13:54 +03:00
|
|
|
check_thread_pos(td, prev_td,
|
2014-04-01 15:21:51 +03:00
|
|
|
mb_x + (is_vp7 ? 2 : 1) + s->mb_width + 3,
|
|
|
|
mb_y - (is_vp7 ? 2 : 1));
|
2012-07-12 23:07:06 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-03-28 03:13:54 +03:00
|
|
|
s->vdsp.prefetch(dst[0] + (mb_x & 3) * 4 * s->linesize + 64,
|
|
|
|
s->linesize, 4);
|
|
|
|
s->vdsp.prefetch(dst[1] + (mb_x & 7) * s->uvlinesize + 64,
|
|
|
|
dst[2] - dst[1], 2);
|
2012-07-11 21:34:04 +03:00
|
|
|
|
2012-07-12 23:07:06 +03:00
|
|
|
if (!s->mb_layout)
|
2017-04-05 22:19:55 +02:00
|
|
|
decode_mb_mode(s, &td->mv_bounds, mb, mb_x, mb_y, curframe->seg_map->data + mb_xy,
|
2012-11-21 23:34:46 +03:00
|
|
|
prev_frame && prev_frame->seg_map ?
|
2014-04-01 15:21:51 +03:00
|
|
|
prev_frame->seg_map->data + mb_xy : NULL, 0, is_vp7);
|
2012-07-11 21:34:04 +03:00
|
|
|
|
avcodec/vp8, vp9: Avoid using VP56mv and VP56Frame in VP8/9
Instead replace VP56mv by new and identical structures VP8mv and VP9mv.
Also replace VP56Frame by VP8FrameType in vp8.h and use that
in VP8 code. Also remove VP56_FRAME_GOLDEN2, as this has only
been used by VP8, and use VP8_FRAME_ALTREF as replacement for
its usage in VP8 as this is more in line with VP8 verbiage.
This allows to remove all inclusions of vp56.h from everything
that is not VP5/6. This also removes implicit inclusions
of hpeldsp.h, h264chroma.h, vp3dsp.h and vp56dsp.h from all VP8/9
files.
(This also fixes a build issue: If one compiles with -O0 and disables
everything except the VP8-VAAPI encoder, the file containing
ff_vpx_norm_shift is not compiled, yet this is used implicitly
by vp56_rac_gets_nn() which is defined in vp56.h; it is unused
by the VP8-VAAPI encoder and declared as av_unused, yet with -O0
unused noninline functions are not optimized away, leading to
linking failures. With this patch, said function is not included
in vaapi_encode_vp8.c any more.)
Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
2022-07-23 02:01:41 +02:00
|
|
|
prefetch_motion(s, mb, mb_x, mb_y, mb_xy, VP8_FRAME_PREVIOUS);
|
2012-07-11 21:34:04 +03:00
|
|
|
|
|
|
|
if (!mb->skip)
|
2014-04-01 15:21:51 +03:00
|
|
|
decode_mb_coeffs(s, td, c, mb, s->top_nnz[mb_x], td->left_nnz, is_vp7);
|
2012-07-11 21:34:04 +03:00
|
|
|
|
|
|
|
if (mb->mode <= MODE_I4x4)
|
2014-04-01 15:21:51 +03:00
|
|
|
intra_predict(s, td, dst, mb, mb_x, mb_y, is_vp7);
|
2012-07-11 21:34:04 +03:00
|
|
|
else
|
2012-07-12 23:07:06 +03:00
|
|
|
inter_predict(s, td, dst, mb, mb_x, mb_y);
|
2012-07-11 21:34:04 +03:00
|
|
|
|
avcodec/vp8, vp9: Avoid using VP56mv and VP56Frame in VP8/9
Instead replace VP56mv by new and identical structures VP8mv and VP9mv.
Also replace VP56Frame by VP8FrameType in vp8.h and use that
in VP8 code. Also remove VP56_FRAME_GOLDEN2, as this has only
been used by VP8, and use VP8_FRAME_ALTREF as replacement for
its usage in VP8 as this is more in line with VP8 verbiage.
This allows to remove all inclusions of vp56.h from everything
that is not VP5/6. This also removes implicit inclusions
of hpeldsp.h, h264chroma.h, vp3dsp.h and vp56dsp.h from all VP8/9
files.
(This also fixes a build issue: If one compiles with -O0 and disables
everything except the VP8-VAAPI encoder, the file containing
ff_vpx_norm_shift is not compiled, yet this is used implicitly
by vp56_rac_gets_nn() which is defined in vp56.h; it is unused
by the VP8-VAAPI encoder and declared as av_unused, yet with -O0
unused noninline functions are not optimized away, leading to
linking failures. With this patch, said function is not included
in vaapi_encode_vp8.c any more.)
Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
2022-07-23 02:01:41 +02:00
|
|
|
prefetch_motion(s, mb, mb_x, mb_y, mb_xy, VP8_FRAME_GOLDEN);
|
2012-07-11 21:34:04 +03:00
|
|
|
|
|
|
|
if (!mb->skip) {
|
2012-07-12 23:07:06 +03:00
|
|
|
idct_mb(s, td, dst, mb);
|
2012-07-11 21:34:04 +03:00
|
|
|
} else {
|
2012-07-12 23:07:06 +03:00
|
|
|
AV_ZERO64(td->left_nnz);
|
2012-07-11 21:34:04 +03:00
|
|
|
AV_WN64(s->top_nnz[mb_x], 0); // array of 9, so unaligned
|
|
|
|
|
2014-03-28 03:13:54 +03:00
|
|
|
/* Reset DC block predictors if they would exist
|
|
|
|
* if the mb had coefficients */
|
2012-07-11 21:34:04 +03:00
|
|
|
if (mb->mode != MODE_I4x4 && mb->mode != VP8_MVMODE_SPLIT) {
|
2012-07-12 23:07:06 +03:00
|
|
|
td->left_nnz[8] = 0;
|
2012-07-11 21:34:04 +03:00
|
|
|
s->top_nnz[mb_x][8] = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (s->deblock_filter)
|
2014-04-01 15:21:51 +03:00
|
|
|
filter_level_for_mb(s, mb, &td->filter_strength[mb_x], is_vp7);
|
2012-07-12 23:07:06 +03:00
|
|
|
|
2014-03-28 03:13:54 +03:00
|
|
|
if (s->deblock_filter && num_jobs != 1 && threadnr == num_jobs - 1) {
|
2012-07-12 23:07:06 +03:00
|
|
|
if (s->filter.simple)
|
2014-03-28 03:13:54 +03:00
|
|
|
backup_mb_border(s->top_border[mb_x + 1], dst[0],
|
|
|
|
NULL, NULL, s->linesize, 0, 1);
|
2012-07-12 23:07:06 +03:00
|
|
|
else
|
2014-03-28 03:13:54 +03:00
|
|
|
backup_mb_border(s->top_border[mb_x + 1], dst[0],
|
|
|
|
dst[1], dst[2], s->linesize, s->uvlinesize, 0);
|
2012-07-12 23:07:06 +03:00
|
|
|
}
|
2012-07-11 21:34:04 +03:00
|
|
|
|
avcodec/vp8, vp9: Avoid using VP56mv and VP56Frame in VP8/9
Instead replace VP56mv by new and identical structures VP8mv and VP9mv.
Also replace VP56Frame by VP8FrameType in vp8.h and use that
in VP8 code. Also remove VP56_FRAME_GOLDEN2, as this has only
been used by VP8, and use VP8_FRAME_ALTREF as replacement for
its usage in VP8 as this is more in line with VP8 verbiage.
This allows to remove all inclusions of vp56.h from everything
that is not VP5/6. This also removes implicit inclusions
of hpeldsp.h, h264chroma.h, vp3dsp.h and vp56dsp.h from all VP8/9
files.
(This also fixes a build issue: If one compiles with -O0 and disables
everything except the VP8-VAAPI encoder, the file containing
ff_vpx_norm_shift is not compiled, yet this is used implicitly
by vp56_rac_gets_nn() which is defined in vp56.h; it is unused
by the VP8-VAAPI encoder and declared as av_unused, yet with -O0
unused noninline functions are not optimized away, leading to
linking failures. With this patch, said function is not included
in vaapi_encode_vp8.c any more.)
Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
2022-07-23 02:01:41 +02:00
|
|
|
prefetch_motion(s, mb, mb_x, mb_y, mb_xy, VP8_FRAME_ALTREF);
|
2010-06-22 22:24:09 +03:00
|
|
|
|
2014-03-28 03:13:54 +03:00
|
|
|
dst[0] += 16;
|
|
|
|
dst[1] += 8;
|
|
|
|
dst[2] += 8;
|
2017-04-05 22:19:55 +02:00
|
|
|
td->mv_bounds.mv_min.x -= 64;
|
|
|
|
td->mv_bounds.mv_max.x -= 64;
|
2012-07-12 23:07:06 +03:00
|
|
|
|
2014-03-28 03:13:54 +03:00
|
|
|
if (mb_x == s->mb_width + 1) {
|
|
|
|
update_pos(td, mb_y, s->mb_width + 3);
|
2012-07-12 23:07:06 +03:00
|
|
|
} else {
|
|
|
|
update_pos(td, mb_y, mb_x);
|
|
|
|
}
|
2010-06-22 22:24:09 +03:00
|
|
|
}
|
2017-02-28 04:55:02 +02:00
|
|
|
return 0;
|
2010-06-22 22:24:09 +03:00
|
|
|
}
|
|
|
|
|
2017-02-28 04:55:02 +02:00
|
|
|
static int vp7_decode_mb_row_no_filter(AVCodecContext *avctx, void *tdata,
|
2014-02-18 13:52:30 +03:00
|
|
|
int jobnr, int threadnr)
|
|
|
|
{
|
2017-02-28 04:55:02 +02:00
|
|
|
return decode_mb_row_no_filter(avctx, tdata, jobnr, threadnr, 1);
|
2014-02-18 13:52:30 +03:00
|
|
|
}
|
|
|
|
|
2017-02-28 04:55:02 +02:00
|
|
|
static int vp8_decode_mb_row_no_filter(AVCodecContext *avctx, void *tdata,
|
2014-02-18 13:52:30 +03:00
|
|
|
int jobnr, int threadnr)
|
|
|
|
{
|
2017-02-28 04:55:02 +02:00
|
|
|
return decode_mb_row_no_filter(avctx, tdata, jobnr, threadnr, 0);
|
2014-02-18 13:52:30 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static av_always_inline void filter_mb_row(AVCodecContext *avctx, void *tdata,
|
2014-04-01 15:21:51 +03:00
|
|
|
int jobnr, int threadnr, int is_vp7)
|
2010-06-22 22:24:09 +03:00
|
|
|
{
|
2012-07-12 23:07:06 +03:00
|
|
|
VP8Context *s = avctx->priv_data;
|
|
|
|
VP8ThreadData *td = &s->thread_data[threadnr];
|
2017-04-05 22:18:54 +02:00
|
|
|
int mb_x, mb_y = atomic_load(&td->thread_mb_pos) >> 16, num_jobs = s->num_jobs;
|
2012-11-21 23:34:46 +03:00
|
|
|
AVFrame *curframe = s->curframe->tf.f;
|
2012-07-12 23:07:06 +03:00
|
|
|
VP8Macroblock *mb;
|
|
|
|
VP8ThreadData *prev_td, *next_td;
|
|
|
|
uint8_t *dst[3] = {
|
2014-03-28 03:13:54 +03:00
|
|
|
curframe->data[0] + 16 * mb_y * s->linesize,
|
|
|
|
curframe->data[1] + 8 * mb_y * s->uvlinesize,
|
|
|
|
curframe->data[2] + 8 * mb_y * s->uvlinesize
|
2012-07-12 23:07:06 +03:00
|
|
|
};
|
2010-06-22 22:24:09 +03:00
|
|
|
|
2012-07-12 23:07:06 +03:00
|
|
|
if (s->mb_layout == 1)
|
2014-03-28 03:13:54 +03:00
|
|
|
mb = s->macroblocks_base + ((s->mb_width + 1) * (mb_y + 1) + 1);
|
2012-07-12 23:07:06 +03:00
|
|
|
else
|
2014-03-28 03:13:54 +03:00
|
|
|
mb = s->macroblocks + (s->mb_height - mb_y - 1) * 2;
|
2012-07-12 23:07:06 +03:00
|
|
|
|
2014-03-28 03:13:54 +03:00
|
|
|
if (mb_y == 0)
|
|
|
|
prev_td = td;
|
|
|
|
else
|
|
|
|
prev_td = &s->thread_data[(jobnr + num_jobs - 1) % num_jobs];
|
|
|
|
if (mb_y == s->mb_height - 1)
|
|
|
|
next_td = td;
|
|
|
|
else
|
|
|
|
next_td = &s->thread_data[(jobnr + 1) % num_jobs];
|
2012-07-12 23:07:06 +03:00
|
|
|
|
|
|
|
for (mb_x = 0; mb_x < s->mb_width; mb_x++, mb++) {
|
|
|
|
VP8FilterStrength *f = &td->filter_strength[mb_x];
|
2014-03-28 03:13:54 +03:00
|
|
|
if (prev_td != td)
|
|
|
|
check_thread_pos(td, prev_td,
|
|
|
|
(mb_x + 1) + (s->mb_width + 3), mb_y - 1);
|
2012-07-12 23:07:06 +03:00
|
|
|
if (next_td != td)
|
2014-03-28 03:13:54 +03:00
|
|
|
if (next_td != &s->thread_data[0])
|
|
|
|
check_thread_pos(td, next_td, mb_x + 1, mb_y + 1);
|
2012-07-12 23:07:06 +03:00
|
|
|
|
|
|
|
if (num_jobs == 1) {
|
|
|
|
if (s->filter.simple)
|
2014-03-28 03:13:54 +03:00
|
|
|
backup_mb_border(s->top_border[mb_x + 1], dst[0],
|
|
|
|
NULL, NULL, s->linesize, 0, 1);
|
2012-07-12 23:07:06 +03:00
|
|
|
else
|
2014-03-28 03:13:54 +03:00
|
|
|
backup_mb_border(s->top_border[mb_x + 1], dst[0],
|
|
|
|
dst[1], dst[2], s->linesize, s->uvlinesize, 0);
|
2012-07-12 23:07:06 +03:00
|
|
|
}
|
|
|
|
|
2012-07-11 21:34:04 +03:00
|
|
|
if (s->filter.simple)
|
2012-07-12 23:07:06 +03:00
|
|
|
filter_mb_simple(s, dst[0], f, mb_x, mb_y);
|
2012-07-11 21:34:04 +03:00
|
|
|
else
|
2014-04-01 15:21:51 +03:00
|
|
|
filter_mb(s, dst, f, mb_x, mb_y, is_vp7);
|
2012-07-12 23:07:06 +03:00
|
|
|
dst[0] += 16;
|
|
|
|
dst[1] += 8;
|
|
|
|
dst[2] += 8;
|
|
|
|
|
2014-03-28 03:13:54 +03:00
|
|
|
update_pos(td, mb_y, (s->mb_width + 3) + mb_x);
|
2010-06-22 22:24:09 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-02-18 13:52:30 +03:00
|
|
|
static void vp7_filter_mb_row(AVCodecContext *avctx, void *tdata,
|
|
|
|
int jobnr, int threadnr)
|
|
|
|
{
|
|
|
|
filter_mb_row(avctx, tdata, jobnr, threadnr, 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void vp8_filter_mb_row(AVCodecContext *avctx, void *tdata,
|
|
|
|
int jobnr, int threadnr)
|
|
|
|
{
|
|
|
|
filter_mb_row(avctx, tdata, jobnr, threadnr, 0);
|
|
|
|
}
|
|
|
|
|
2014-04-01 15:21:51 +03:00
|
|
|
static av_always_inline
|
|
|
|
int vp78_decode_mb_row_sliced(AVCodecContext *avctx, void *tdata, int jobnr,
|
|
|
|
int threadnr, int is_vp7)
|
2011-10-18 03:10:16 +03:00
|
|
|
{
|
2022-07-23 04:35:33 +02:00
|
|
|
const VP8Context *s = avctx->priv_data;
|
2012-07-12 23:07:06 +03:00
|
|
|
VP8ThreadData *td = &s->thread_data[jobnr];
|
|
|
|
VP8ThreadData *next_td = NULL, *prev_td = NULL;
|
2012-11-21 23:34:46 +03:00
|
|
|
VP8Frame *curframe = s->curframe;
|
2012-07-12 23:07:06 +03:00
|
|
|
int mb_y, num_jobs = s->num_jobs;
|
2017-02-28 04:55:02 +02:00
|
|
|
int ret;
|
2014-03-28 03:13:54 +03:00
|
|
|
|
2012-07-12 23:07:06 +03:00
|
|
|
td->thread_nr = threadnr;
|
2017-04-05 22:19:55 +02:00
|
|
|
td->mv_bounds.mv_min.y = -MARGIN - 64 * threadnr;
|
|
|
|
td->mv_bounds.mv_max.y = ((s->mb_height - 1) << 6) + MARGIN - 64 * threadnr;
|
2012-07-12 23:07:06 +03:00
|
|
|
for (mb_y = jobnr; mb_y < s->mb_height; mb_y += num_jobs) {
|
2017-04-05 22:18:54 +02:00
|
|
|
atomic_store(&td->thread_mb_pos, mb_y << 16);
|
2017-02-28 04:55:02 +02:00
|
|
|
ret = s->decode_mb_row_no_filter(avctx, tdata, jobnr, threadnr);
|
2017-03-10 01:15:39 +02:00
|
|
|
if (ret < 0) {
|
|
|
|
update_pos(td, s->mb_height, INT_MAX & 0xFFFF);
|
2017-02-28 04:55:02 +02:00
|
|
|
return ret;
|
2017-03-10 01:15:39 +02:00
|
|
|
}
|
2012-07-12 23:07:06 +03:00
|
|
|
if (s->deblock_filter)
|
2014-02-18 13:52:30 +03:00
|
|
|
s->filter_mb_row(avctx, tdata, jobnr, threadnr);
|
2012-07-12 23:07:06 +03:00
|
|
|
update_pos(td, mb_y, INT_MAX & 0xFFFF);
|
|
|
|
|
2017-04-05 22:19:55 +02:00
|
|
|
td->mv_bounds.mv_min.y -= 64 * num_jobs;
|
|
|
|
td->mv_bounds.mv_max.y -= 64 * num_jobs;
|
2012-07-12 23:07:06 +03:00
|
|
|
|
|
|
|
if (avctx->active_thread_type == FF_THREAD_FRAME)
|
2012-11-21 23:34:46 +03:00
|
|
|
ff_thread_report_progress(&curframe->tf, mb_y, 0);
|
2012-07-11 21:34:04 +03:00
|
|
|
}
|
2012-07-12 23:07:06 +03:00
|
|
|
|
|
|
|
return 0;
|
2011-10-18 03:10:16 +03:00
|
|
|
}
|
|
|
|
|
2014-04-01 15:21:51 +03:00
|
|
|
static int vp7_decode_mb_row_sliced(AVCodecContext *avctx, void *tdata,
|
|
|
|
int jobnr, int threadnr)
|
|
|
|
{
|
|
|
|
return vp78_decode_mb_row_sliced(avctx, tdata, jobnr, threadnr, IS_VP7);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int vp8_decode_mb_row_sliced(AVCodecContext *avctx, void *tdata,
|
|
|
|
int jobnr, int threadnr)
|
|
|
|
{
|
|
|
|
return vp78_decode_mb_row_sliced(avctx, tdata, jobnr, threadnr, IS_VP8);
|
|
|
|
}
|
|
|
|
|
|
|
|
static av_always_inline
|
2022-03-30 21:33:24 +02:00
|
|
|
int vp78_decode_frame(AVCodecContext *avctx, AVFrame *rframe, int *got_frame,
|
2021-03-04 14:13:20 +02:00
|
|
|
const AVPacket *avpkt, int is_vp7)
|
2010-06-22 22:24:09 +03:00
|
|
|
{
|
|
|
|
VP8Context *s = avctx->priv_data;
|
2012-07-12 23:07:06 +03:00
|
|
|
int ret, i, referenced, num_jobs;
|
2010-06-22 22:24:09 +03:00
|
|
|
enum AVDiscard skip_thresh;
|
2012-11-21 23:34:46 +03:00
|
|
|
VP8Frame *av_uninit(curframe), *prev_frame;
|
2011-10-18 03:10:16 +03:00
|
|
|
|
2014-04-01 15:21:51 +03:00
|
|
|
if (is_vp7)
|
|
|
|
ret = vp7_decode_frame_header(s, avpkt->data, avpkt->size);
|
|
|
|
else
|
|
|
|
ret = vp8_decode_frame_header(s, avpkt->data, avpkt->size);
|
|
|
|
|
|
|
|
if (ret < 0)
|
2012-02-01 02:17:59 +03:00
|
|
|
goto err;
|
2010-06-22 22:24:09 +03:00
|
|
|
|
2017-11-18 19:55:18 +02:00
|
|
|
if (s->actually_webp) {
|
|
|
|
// avctx->pix_fmt already set in caller.
|
|
|
|
} else if (!is_vp7 && s->pix_fmt == AV_PIX_FMT_NONE) {
|
2017-11-30 01:53:53 +02:00
|
|
|
s->pix_fmt = get_pixel_format(s);
|
2017-11-18 19:55:18 +02:00
|
|
|
if (s->pix_fmt < 0) {
|
|
|
|
ret = AVERROR(EINVAL);
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
avctx->pix_fmt = s->pix_fmt;
|
|
|
|
}
|
|
|
|
|
avcodec/vp8, vp9: Avoid using VP56mv and VP56Frame in VP8/9
Instead replace VP56mv by new and identical structures VP8mv and VP9mv.
Also replace VP56Frame by VP8FrameType in vp8.h and use that
in VP8 code. Also remove VP56_FRAME_GOLDEN2, as this has only
been used by VP8, and use VP8_FRAME_ALTREF as replacement for
its usage in VP8 as this is more in line with VP8 verbiage.
This allows to remove all inclusions of vp56.h from everything
that is not VP5/6. This also removes implicit inclusions
of hpeldsp.h, h264chroma.h, vp3dsp.h and vp56dsp.h from all VP8/9
files.
(This also fixes a build issue: If one compiles with -O0 and disables
everything except the VP8-VAAPI encoder, the file containing
ff_vpx_norm_shift is not compiled, yet this is used implicitly
by vp56_rac_gets_nn() which is defined in vp56.h; it is unused
by the VP8-VAAPI encoder and declared as av_unused, yet with -O0
unused noninline functions are not optimized away, leading to
linking failures. With this patch, said function is not included
in vaapi_encode_vp8.c any more.)
Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
2022-07-23 02:01:41 +02:00
|
|
|
prev_frame = s->framep[VP8_FRAME_CURRENT];
|
2011-11-28 18:21:47 +03:00
|
|
|
|
avcodec/vp8, vp9: Avoid using VP56mv and VP56Frame in VP8/9
Instead replace VP56mv by new and identical structures VP8mv and VP9mv.
Also replace VP56Frame by VP8FrameType in vp8.h and use that
in VP8 code. Also remove VP56_FRAME_GOLDEN2, as this has only
been used by VP8, and use VP8_FRAME_ALTREF as replacement for
its usage in VP8 as this is more in line with VP8 verbiage.
This allows to remove all inclusions of vp56.h from everything
that is not VP5/6. This also removes implicit inclusions
of hpeldsp.h, h264chroma.h, vp3dsp.h and vp56dsp.h from all VP8/9
files.
(This also fixes a build issue: If one compiles with -O0 and disables
everything except the VP8-VAAPI encoder, the file containing
ff_vpx_norm_shift is not compiled, yet this is used implicitly
by vp56_rac_gets_nn() which is defined in vp56.h; it is unused
by the VP8-VAAPI encoder and declared as av_unused, yet with -O0
unused noninline functions are not optimized away, leading to
linking failures. With this patch, said function is not included
in vaapi_encode_vp8.c any more.)
Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
2022-07-23 02:01:41 +02:00
|
|
|
referenced = s->update_last || s->update_golden == VP8_FRAME_CURRENT ||
|
|
|
|
s->update_altref == VP8_FRAME_CURRENT;
|
2010-06-22 22:24:09 +03:00
|
|
|
|
2014-03-28 03:13:54 +03:00
|
|
|
skip_thresh = !referenced ? AVDISCARD_NONREF
|
|
|
|
: !s->keyframe ? AVDISCARD_NONKEY
|
|
|
|
: AVDISCARD_ALL;
|
2010-06-22 22:24:09 +03:00
|
|
|
|
|
|
|
if (avctx->skip_frame >= skip_thresh) {
|
|
|
|
s->invisible = 1;
|
2012-02-01 02:17:59 +03:00
|
|
|
memcpy(&s->next_framep[0], &s->framep[0], sizeof(s->framep[0]) * 4);
|
2010-06-22 22:24:09 +03:00
|
|
|
goto skip_decode;
|
|
|
|
}
|
2010-07-16 10:20:35 +03:00
|
|
|
s->deblock_filter = s->filter.level && avctx->skip_loop_filter < skip_thresh;
|
2010-06-22 22:24:09 +03:00
|
|
|
|
2011-05-02 16:55:52 +03:00
|
|
|
// release no longer referenced frames
|
|
|
|
for (i = 0; i < 5; i++)
|
2017-11-18 19:55:18 +02:00
|
|
|
if (s->frames[i].tf.f->buf[0] &&
|
2011-05-02 16:55:52 +03:00
|
|
|
&s->frames[i] != prev_frame &&
|
avcodec/vp8, vp9: Avoid using VP56mv and VP56Frame in VP8/9
Instead replace VP56mv by new and identical structures VP8mv and VP9mv.
Also replace VP56Frame by VP8FrameType in vp8.h and use that
in VP8 code. Also remove VP56_FRAME_GOLDEN2, as this has only
been used by VP8, and use VP8_FRAME_ALTREF as replacement for
its usage in VP8 as this is more in line with VP8 verbiage.
This allows to remove all inclusions of vp56.h from everything
that is not VP5/6. This also removes implicit inclusions
of hpeldsp.h, h264chroma.h, vp3dsp.h and vp56dsp.h from all VP8/9
files.
(This also fixes a build issue: If one compiles with -O0 and disables
everything except the VP8-VAAPI encoder, the file containing
ff_vpx_norm_shift is not compiled, yet this is used implicitly
by vp56_rac_gets_nn() which is defined in vp56.h; it is unused
by the VP8-VAAPI encoder and declared as av_unused, yet with -O0
unused noninline functions are not optimized away, leading to
linking failures. With this patch, said function is not included
in vaapi_encode_vp8.c any more.)
Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
2022-07-23 02:01:41 +02:00
|
|
|
&s->frames[i] != s->framep[VP8_FRAME_PREVIOUS] &&
|
|
|
|
&s->frames[i] != s->framep[VP8_FRAME_GOLDEN] &&
|
|
|
|
&s->frames[i] != s->framep[VP8_FRAME_ALTREF])
|
2012-11-21 23:34:46 +03:00
|
|
|
vp8_release_frame(s, &s->frames[i]);
|
2011-05-02 16:55:52 +03:00
|
|
|
|
avcodec/vp8, vp9: Avoid using VP56mv and VP56Frame in VP8/9
Instead replace VP56mv by new and identical structures VP8mv and VP9mv.
Also replace VP56Frame by VP8FrameType in vp8.h and use that
in VP8 code. Also remove VP56_FRAME_GOLDEN2, as this has only
been used by VP8, and use VP8_FRAME_ALTREF as replacement for
its usage in VP8 as this is more in line with VP8 verbiage.
This allows to remove all inclusions of vp56.h from everything
that is not VP5/6. This also removes implicit inclusions
of hpeldsp.h, h264chroma.h, vp3dsp.h and vp56dsp.h from all VP8/9
files.
(This also fixes a build issue: If one compiles with -O0 and disables
everything except the VP8-VAAPI encoder, the file containing
ff_vpx_norm_shift is not compiled, yet this is used implicitly
by vp56_rac_gets_nn() which is defined in vp56.h; it is unused
by the VP8-VAAPI encoder and declared as av_unused, yet with -O0
unused noninline functions are not optimized away, leading to
linking failures. With this patch, said function is not included
in vaapi_encode_vp8.c any more.)
Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
2022-07-23 02:01:41 +02:00
|
|
|
curframe = s->framep[VP8_FRAME_CURRENT] = vp8_find_free_buffer(s);
|
2010-06-22 22:24:09 +03:00
|
|
|
|
2014-10-06 00:58:50 +03:00
|
|
|
if (!s->colorspace)
|
|
|
|
avctx->colorspace = AVCOL_SPC_BT470BG;
|
|
|
|
if (s->fullrange)
|
|
|
|
avctx->color_range = AVCOL_RANGE_JPEG;
|
|
|
|
else
|
|
|
|
avctx->color_range = AVCOL_RANGE_MPEG;
|
|
|
|
|
2014-03-28 03:13:54 +03:00
|
|
|
/* Given that arithmetic probabilities are updated every frame, it's quite
|
|
|
|
* likely that the values we have on a random interframe are complete
|
|
|
|
* junk if we didn't start decode on a keyframe. So just don't display
|
|
|
|
* anything rather than junk. */
|
avcodec/vp8, vp9: Avoid using VP56mv and VP56Frame in VP8/9
Instead replace VP56mv by new and identical structures VP8mv and VP9mv.
Also replace VP56Frame by VP8FrameType in vp8.h and use that
in VP8 code. Also remove VP56_FRAME_GOLDEN2, as this has only
been used by VP8, and use VP8_FRAME_ALTREF as replacement for
its usage in VP8 as this is more in line with VP8 verbiage.
This allows to remove all inclusions of vp56.h from everything
that is not VP5/6. This also removes implicit inclusions
of hpeldsp.h, h264chroma.h, vp3dsp.h and vp56dsp.h from all VP8/9
files.
(This also fixes a build issue: If one compiles with -O0 and disables
everything except the VP8-VAAPI encoder, the file containing
ff_vpx_norm_shift is not compiled, yet this is used implicitly
by vp56_rac_gets_nn() which is defined in vp56.h; it is unused
by the VP8-VAAPI encoder and declared as av_unused, yet with -O0
unused noninline functions are not optimized away, leading to
linking failures. With this patch, said function is not included
in vaapi_encode_vp8.c any more.)
Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
2022-07-23 02:01:41 +02:00
|
|
|
if (!s->keyframe && (!s->framep[VP8_FRAME_PREVIOUS] ||
|
|
|
|
!s->framep[VP8_FRAME_GOLDEN] ||
|
|
|
|
!s->framep[VP8_FRAME_ALTREF])) {
|
2014-03-28 03:13:54 +03:00
|
|
|
av_log(avctx, AV_LOG_WARNING,
|
|
|
|
"Discarding interframe without a prior keyframe!\n");
|
2012-02-01 02:17:59 +03:00
|
|
|
ret = AVERROR_INVALIDDATA;
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
|
2012-11-21 23:34:46 +03:00
|
|
|
curframe->tf.f->key_frame = s->keyframe;
|
2014-03-28 03:13:54 +03:00
|
|
|
curframe->tf.f->pict_type = s->keyframe ? AV_PICTURE_TYPE_I
|
|
|
|
: AV_PICTURE_TYPE_P;
|
lavc: factorize ff_{thread_,re,}get_buffer error messages.
Coccinelle profile used:
@@
expression r, ctx, f, loglevel, str, flags;
@@
-if ((r = ff_get_buffer(ctx, f, flags)) < 0) {
- av_log(ctx, loglevel, str);
- return r;
-}
+if ((r = ff_get_buffer(ctx, f, flags)) < 0)
+ return r;
@@
expression r, ctx, f, loglevel, str;
@@
-if ((r = ff_reget_buffer(ctx, f)) < 0) {
- av_log(ctx, loglevel, str);
- return r;
-}
+if ((r = ff_reget_buffer(ctx, f)) < 0)
+ return r;
@@
expression r, ctx, f, loglevel, str, flags;
@@
-if ((r = ff_thread_get_buffer(ctx, f, flags)) < 0) {
- av_log(ctx, loglevel, str);
- return r;
-}
+if ((r = ff_thread_get_buffer(ctx, f, flags)) < 0)
+ return r;
...along with some manual patches for the remaining ones.
2013-03-12 10:41:53 +03:00
|
|
|
if ((ret = vp8_alloc_frame(s, curframe, referenced)) < 0)
|
2012-02-01 02:17:59 +03:00
|
|
|
goto err;
|
2010-06-22 22:24:09 +03:00
|
|
|
|
2011-05-02 16:55:52 +03:00
|
|
|
// check if golden and altref are swapped
|
avcodec/vp8, vp9: Avoid using VP56mv and VP56Frame in VP8/9
Instead replace VP56mv by new and identical structures VP8mv and VP9mv.
Also replace VP56Frame by VP8FrameType in vp8.h and use that
in VP8 code. Also remove VP56_FRAME_GOLDEN2, as this has only
been used by VP8, and use VP8_FRAME_ALTREF as replacement for
its usage in VP8 as this is more in line with VP8 verbiage.
This allows to remove all inclusions of vp56.h from everything
that is not VP5/6. This also removes implicit inclusions
of hpeldsp.h, h264chroma.h, vp3dsp.h and vp56dsp.h from all VP8/9
files.
(This also fixes a build issue: If one compiles with -O0 and disables
everything except the VP8-VAAPI encoder, the file containing
ff_vpx_norm_shift is not compiled, yet this is used implicitly
by vp56_rac_gets_nn() which is defined in vp56.h; it is unused
by the VP8-VAAPI encoder and declared as av_unused, yet with -O0
unused noninline functions are not optimized away, leading to
linking failures. With this patch, said function is not included
in vaapi_encode_vp8.c any more.)
Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
2022-07-23 02:01:41 +02:00
|
|
|
if (s->update_altref != VP8_FRAME_NONE)
|
|
|
|
s->next_framep[VP8_FRAME_ALTREF] = s->framep[s->update_altref];
|
2014-03-28 03:13:54 +03:00
|
|
|
else
|
avcodec/vp8, vp9: Avoid using VP56mv and VP56Frame in VP8/9
Instead replace VP56mv by new and identical structures VP8mv and VP9mv.
Also replace VP56Frame by VP8FrameType in vp8.h and use that
in VP8 code. Also remove VP56_FRAME_GOLDEN2, as this has only
been used by VP8, and use VP8_FRAME_ALTREF as replacement for
its usage in VP8 as this is more in line with VP8 verbiage.
This allows to remove all inclusions of vp56.h from everything
that is not VP5/6. This also removes implicit inclusions
of hpeldsp.h, h264chroma.h, vp3dsp.h and vp56dsp.h from all VP8/9
files.
(This also fixes a build issue: If one compiles with -O0 and disables
everything except the VP8-VAAPI encoder, the file containing
ff_vpx_norm_shift is not compiled, yet this is used implicitly
by vp56_rac_gets_nn() which is defined in vp56.h; it is unused
by the VP8-VAAPI encoder and declared as av_unused, yet with -O0
unused noninline functions are not optimized away, leading to
linking failures. With this patch, said function is not included
in vaapi_encode_vp8.c any more.)
Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
2022-07-23 02:01:41 +02:00
|
|
|
s->next_framep[VP8_FRAME_ALTREF] = s->framep[VP8_FRAME_ALTREF];
|
2014-03-28 03:13:54 +03:00
|
|
|
|
avcodec/vp8, vp9: Avoid using VP56mv and VP56Frame in VP8/9
Instead replace VP56mv by new and identical structures VP8mv and VP9mv.
Also replace VP56Frame by VP8FrameType in vp8.h and use that
in VP8 code. Also remove VP56_FRAME_GOLDEN2, as this has only
been used by VP8, and use VP8_FRAME_ALTREF as replacement for
its usage in VP8 as this is more in line with VP8 verbiage.
This allows to remove all inclusions of vp56.h from everything
that is not VP5/6. This also removes implicit inclusions
of hpeldsp.h, h264chroma.h, vp3dsp.h and vp56dsp.h from all VP8/9
files.
(This also fixes a build issue: If one compiles with -O0 and disables
everything except the VP8-VAAPI encoder, the file containing
ff_vpx_norm_shift is not compiled, yet this is used implicitly
by vp56_rac_gets_nn() which is defined in vp56.h; it is unused
by the VP8-VAAPI encoder and declared as av_unused, yet with -O0
unused noninline functions are not optimized away, leading to
linking failures. With this patch, said function is not included
in vaapi_encode_vp8.c any more.)
Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
2022-07-23 02:01:41 +02:00
|
|
|
if (s->update_golden != VP8_FRAME_NONE)
|
|
|
|
s->next_framep[VP8_FRAME_GOLDEN] = s->framep[s->update_golden];
|
2014-03-28 03:13:54 +03:00
|
|
|
else
|
avcodec/vp8, vp9: Avoid using VP56mv and VP56Frame in VP8/9
Instead replace VP56mv by new and identical structures VP8mv and VP9mv.
Also replace VP56Frame by VP8FrameType in vp8.h and use that
in VP8 code. Also remove VP56_FRAME_GOLDEN2, as this has only
been used by VP8, and use VP8_FRAME_ALTREF as replacement for
its usage in VP8 as this is more in line with VP8 verbiage.
This allows to remove all inclusions of vp56.h from everything
that is not VP5/6. This also removes implicit inclusions
of hpeldsp.h, h264chroma.h, vp3dsp.h and vp56dsp.h from all VP8/9
files.
(This also fixes a build issue: If one compiles with -O0 and disables
everything except the VP8-VAAPI encoder, the file containing
ff_vpx_norm_shift is not compiled, yet this is used implicitly
by vp56_rac_gets_nn() which is defined in vp56.h; it is unused
by the VP8-VAAPI encoder and declared as av_unused, yet with -O0
unused noninline functions are not optimized away, leading to
linking failures. With this patch, said function is not included
in vaapi_encode_vp8.c any more.)
Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
2022-07-23 02:01:41 +02:00
|
|
|
s->next_framep[VP8_FRAME_GOLDEN] = s->framep[VP8_FRAME_GOLDEN];
|
2014-03-28 03:13:54 +03:00
|
|
|
|
|
|
|
if (s->update_last)
|
avcodec/vp8, vp9: Avoid using VP56mv and VP56Frame in VP8/9
Instead replace VP56mv by new and identical structures VP8mv and VP9mv.
Also replace VP56Frame by VP8FrameType in vp8.h and use that
in VP8 code. Also remove VP56_FRAME_GOLDEN2, as this has only
been used by VP8, and use VP8_FRAME_ALTREF as replacement for
its usage in VP8 as this is more in line with VP8 verbiage.
This allows to remove all inclusions of vp56.h from everything
that is not VP5/6. This also removes implicit inclusions
of hpeldsp.h, h264chroma.h, vp3dsp.h and vp56dsp.h from all VP8/9
files.
(This also fixes a build issue: If one compiles with -O0 and disables
everything except the VP8-VAAPI encoder, the file containing
ff_vpx_norm_shift is not compiled, yet this is used implicitly
by vp56_rac_gets_nn() which is defined in vp56.h; it is unused
by the VP8-VAAPI encoder and declared as av_unused, yet with -O0
unused noninline functions are not optimized away, leading to
linking failures. With this patch, said function is not included
in vaapi_encode_vp8.c any more.)
Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
2022-07-23 02:01:41 +02:00
|
|
|
s->next_framep[VP8_FRAME_PREVIOUS] = curframe;
|
2014-03-28 03:13:54 +03:00
|
|
|
else
|
avcodec/vp8, vp9: Avoid using VP56mv and VP56Frame in VP8/9
Instead replace VP56mv by new and identical structures VP8mv and VP9mv.
Also replace VP56Frame by VP8FrameType in vp8.h and use that
in VP8 code. Also remove VP56_FRAME_GOLDEN2, as this has only
been used by VP8, and use VP8_FRAME_ALTREF as replacement for
its usage in VP8 as this is more in line with VP8 verbiage.
This allows to remove all inclusions of vp56.h from everything
that is not VP5/6. This also removes implicit inclusions
of hpeldsp.h, h264chroma.h, vp3dsp.h and vp56dsp.h from all VP8/9
files.
(This also fixes a build issue: If one compiles with -O0 and disables
everything except the VP8-VAAPI encoder, the file containing
ff_vpx_norm_shift is not compiled, yet this is used implicitly
by vp56_rac_gets_nn() which is defined in vp56.h; it is unused
by the VP8-VAAPI encoder and declared as av_unused, yet with -O0
unused noninline functions are not optimized away, leading to
linking failures. With this patch, said function is not included
in vaapi_encode_vp8.c any more.)
Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
2022-07-23 02:01:41 +02:00
|
|
|
s->next_framep[VP8_FRAME_PREVIOUS] = s->framep[VP8_FRAME_PREVIOUS];
|
2014-03-28 03:13:54 +03:00
|
|
|
|
avcodec/vp8, vp9: Avoid using VP56mv and VP56Frame in VP8/9
Instead replace VP56mv by new and identical structures VP8mv and VP9mv.
Also replace VP56Frame by VP8FrameType in vp8.h and use that
in VP8 code. Also remove VP56_FRAME_GOLDEN2, as this has only
been used by VP8, and use VP8_FRAME_ALTREF as replacement for
its usage in VP8 as this is more in line with VP8 verbiage.
This allows to remove all inclusions of vp56.h from everything
that is not VP5/6. This also removes implicit inclusions
of hpeldsp.h, h264chroma.h, vp3dsp.h and vp56dsp.h from all VP8/9
files.
(This also fixes a build issue: If one compiles with -O0 and disables
everything except the VP8-VAAPI encoder, the file containing
ff_vpx_norm_shift is not compiled, yet this is used implicitly
by vp56_rac_gets_nn() which is defined in vp56.h; it is unused
by the VP8-VAAPI encoder and declared as av_unused, yet with -O0
unused noninline functions are not optimized away, leading to
linking failures. With this patch, said function is not included
in vaapi_encode_vp8.c any more.)
Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
2022-07-23 02:01:41 +02:00
|
|
|
s->next_framep[VP8_FRAME_CURRENT] = curframe;
|
2011-05-02 16:55:52 +03:00
|
|
|
|
2022-03-16 22:09:54 +02:00
|
|
|
if (ffcodec(avctx->codec)->update_thread_context)
|
2019-11-14 06:29:55 +02:00
|
|
|
ff_thread_finish_setup(avctx);
|
2011-12-11 18:02:30 +03:00
|
|
|
|
2017-11-18 19:55:18 +02:00
|
|
|
if (avctx->hwaccel) {
|
|
|
|
ret = avctx->hwaccel->start_frame(avctx, avpkt->data, avpkt->size);
|
|
|
|
if (ret < 0)
|
|
|
|
goto err;
|
2010-06-22 22:24:09 +03:00
|
|
|
|
2017-11-18 19:55:18 +02:00
|
|
|
ret = avctx->hwaccel->decode_slice(avctx, avpkt->data, avpkt->size);
|
|
|
|
if (ret < 0)
|
|
|
|
goto err;
|
2010-07-22 14:45:18 +03:00
|
|
|
|
2017-11-18 19:55:18 +02:00
|
|
|
ret = avctx->hwaccel->end_frame(avctx);
|
|
|
|
if (ret < 0)
|
|
|
|
goto err;
|
2010-06-22 22:24:09 +03:00
|
|
|
|
2017-11-18 19:55:18 +02:00
|
|
|
} else {
|
|
|
|
s->linesize = curframe->tf.f->linesize[0];
|
|
|
|
s->uvlinesize = curframe->tf.f->linesize[1];
|
|
|
|
|
|
|
|
memset(s->top_nnz, 0, s->mb_width * sizeof(*s->top_nnz));
|
|
|
|
/* Zero macroblock structures for top/top-left prediction
|
|
|
|
* from outside the frame. */
|
|
|
|
if (!s->mb_layout)
|
|
|
|
memset(s->macroblocks + s->mb_height * 2 - 1, 0,
|
|
|
|
(s->mb_width + 1) * sizeof(*s->macroblocks));
|
|
|
|
if (!s->mb_layout && s->keyframe)
|
|
|
|
memset(s->intra4x4_pred_mode_top, DC_PRED, s->mb_width * 4);
|
|
|
|
|
|
|
|
memset(s->ref_count, 0, sizeof(s->ref_count));
|
|
|
|
|
|
|
|
if (s->mb_layout == 1) {
|
|
|
|
// Make sure the previous frame has read its segmentation map,
|
|
|
|
// if we re-use the same map.
|
|
|
|
if (prev_frame && s->segmentation.enabled &&
|
|
|
|
!s->segmentation.update_map)
|
|
|
|
ff_thread_await_progress(&prev_frame->tf, 1, 0);
|
|
|
|
if (is_vp7)
|
2018-12-15 02:53:16 +02:00
|
|
|
ret = vp7_decode_mv_mb_modes(avctx, curframe, prev_frame);
|
2017-11-18 19:55:18 +02:00
|
|
|
else
|
2018-12-15 02:53:16 +02:00
|
|
|
ret = vp8_decode_mv_mb_modes(avctx, curframe, prev_frame);
|
|
|
|
if (ret < 0)
|
|
|
|
goto err;
|
2017-11-18 19:55:18 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if (avctx->active_thread_type == FF_THREAD_FRAME)
|
|
|
|
num_jobs = 1;
|
|
|
|
else
|
|
|
|
num_jobs = FFMIN(s->num_coeff_partitions, avctx->thread_count);
|
|
|
|
s->num_jobs = num_jobs;
|
|
|
|
s->curframe = curframe;
|
|
|
|
s->prev_frame = prev_frame;
|
|
|
|
s->mv_bounds.mv_min.y = -MARGIN;
|
|
|
|
s->mv_bounds.mv_max.y = ((s->mb_height - 1) << 6) + MARGIN;
|
|
|
|
for (i = 0; i < MAX_THREADS; i++) {
|
|
|
|
VP8ThreadData *td = &s->thread_data[i];
|
|
|
|
atomic_init(&td->thread_mb_pos, 0);
|
|
|
|
atomic_init(&td->wait_mb_pos, INT_MAX);
|
|
|
|
}
|
2014-04-01 15:21:51 +03:00
|
|
|
if (is_vp7)
|
2017-11-18 19:55:18 +02:00
|
|
|
avctx->execute2(avctx, vp7_decode_mb_row_sliced, s->thread_data, NULL,
|
|
|
|
num_jobs);
|
2014-04-01 15:21:51 +03:00
|
|
|
else
|
2017-11-18 19:55:18 +02:00
|
|
|
avctx->execute2(avctx, vp8_decode_mb_row_sliced, s->thread_data, NULL,
|
|
|
|
num_jobs);
|
2012-07-12 23:07:06 +03:00
|
|
|
}
|
2010-06-22 22:24:09 +03:00
|
|
|
|
2012-11-21 23:34:46 +03:00
|
|
|
ff_thread_report_progress(&curframe->tf, INT_MAX, 0);
|
2012-02-01 02:17:59 +03:00
|
|
|
memcpy(&s->framep[0], &s->next_framep[0], sizeof(s->framep[0]) * 4);
|
|
|
|
|
2010-06-22 22:24:09 +03:00
|
|
|
skip_decode:
|
|
|
|
// if future frames don't use the updated probabilities,
|
|
|
|
// reset them to the values we saved
|
|
|
|
if (!s->update_probabilities)
|
|
|
|
s->prob[0] = s->prob[1];
|
|
|
|
|
|
|
|
if (!s->invisible) {
|
2022-03-30 21:33:24 +02:00
|
|
|
if ((ret = av_frame_ref(rframe, curframe->tf.f)) < 0)
|
2012-11-21 23:34:46 +03:00
|
|
|
return ret;
|
2014-03-28 03:13:54 +03:00
|
|
|
*got_frame = 1;
|
2010-06-22 22:24:09 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
return avpkt->size;
|
2012-02-01 02:17:59 +03:00
|
|
|
err:
|
|
|
|
memcpy(&s->next_framep[0], &s->framep[0], sizeof(s->framep[0]) * 4);
|
2011-12-11 18:02:30 +03:00
|
|
|
return ret;
|
2010-06-22 22:24:09 +03:00
|
|
|
}
|
|
|
|
|
2022-03-30 21:33:24 +02:00
|
|
|
int ff_vp8_decode_frame(AVCodecContext *avctx, AVFrame *frame,
|
|
|
|
int *got_frame, AVPacket *avpkt)
|
2014-04-01 15:21:51 +03:00
|
|
|
{
|
2022-03-30 21:33:24 +02:00
|
|
|
return vp78_decode_frame(avctx, frame, got_frame, avpkt, IS_VP8);
|
2014-04-01 15:21:51 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
#if CONFIG_VP7_DECODER
|
2022-03-30 21:33:24 +02:00
|
|
|
static int vp7_decode_frame(AVCodecContext *avctx, AVFrame *frame,
|
|
|
|
int *got_frame, AVPacket *avpkt)
|
2014-04-01 15:21:51 +03:00
|
|
|
{
|
2022-03-30 21:33:24 +02:00
|
|
|
return vp78_decode_frame(avctx, frame, got_frame, avpkt, IS_VP7);
|
2014-04-01 15:21:51 +03:00
|
|
|
}
|
|
|
|
#endif /* CONFIG_VP7_DECODER */
|
|
|
|
|
2013-04-16 20:12:26 +03:00
|
|
|
av_cold int ff_vp8_decode_free(AVCodecContext *avctx)
|
2012-11-21 23:34:46 +03:00
|
|
|
{
|
|
|
|
VP8Context *s = avctx->priv_data;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
vp8_decode_flush_impl(avctx, 1);
|
|
|
|
for (i = 0; i < FF_ARRAY_ELEMS(s->frames); i++)
|
|
|
|
av_frame_free(&s->frames[i].tf.f);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static av_cold int vp8_init_frames(VP8Context *s)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
for (i = 0; i < FF_ARRAY_ELEMS(s->frames); i++) {
|
|
|
|
s->frames[i].tf.f = av_frame_alloc();
|
|
|
|
if (!s->frames[i].tf.f)
|
|
|
|
return AVERROR(ENOMEM);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-04-01 15:21:51 +03:00
|
|
|
static av_always_inline
|
|
|
|
int vp78_decode_init(AVCodecContext *avctx, int is_vp7)
|
2010-06-22 22:24:09 +03:00
|
|
|
{
|
|
|
|
VP8Context *s = avctx->priv_data;
|
2012-11-21 23:34:46 +03:00
|
|
|
int ret;
|
2010-06-22 22:24:09 +03:00
|
|
|
|
|
|
|
s->avctx = avctx;
|
2014-02-18 13:52:30 +03:00
|
|
|
s->vp7 = avctx->codec->id == AV_CODEC_ID_VP7;
|
2017-11-18 19:55:18 +02:00
|
|
|
s->pix_fmt = AV_PIX_FMT_NONE;
|
2012-10-06 13:10:34 +03:00
|
|
|
avctx->pix_fmt = AV_PIX_FMT_YUV420P;
|
2010-06-22 22:24:09 +03:00
|
|
|
|
2012-12-15 20:46:02 +03:00
|
|
|
ff_videodsp_init(&s->vdsp, 8);
|
2014-02-18 13:52:30 +03:00
|
|
|
|
2014-04-01 15:21:51 +03:00
|
|
|
ff_vp78dsp_init(&s->vp8dsp);
|
|
|
|
if (CONFIG_VP7_DECODER && is_vp7) {
|
|
|
|
ff_h264_pred_init(&s->hpc, AV_CODEC_ID_VP7, 8, 1);
|
|
|
|
ff_vp7dsp_init(&s->vp8dsp);
|
2014-04-04 15:31:04 +03:00
|
|
|
s->decode_mb_row_no_filter = vp7_decode_mb_row_no_filter;
|
|
|
|
s->filter_mb_row = vp7_filter_mb_row;
|
2014-04-01 15:21:51 +03:00
|
|
|
} else if (CONFIG_VP8_DECODER && !is_vp7) {
|
|
|
|
ff_h264_pred_init(&s->hpc, AV_CODEC_ID_VP8, 8, 1);
|
|
|
|
ff_vp8dsp_init(&s->vp8dsp);
|
2014-04-04 15:31:04 +03:00
|
|
|
s->decode_mb_row_no_filter = vp8_decode_mb_row_no_filter;
|
|
|
|
s->filter_mb_row = vp8_filter_mb_row;
|
2014-04-01 15:21:51 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/* does not change for VP8 */
|
2016-03-24 12:16:53 +02:00
|
|
|
memcpy(s->prob[0].scan, ff_zigzag_scan, sizeof(s->prob[0].scan));
|
2010-06-22 22:24:09 +03:00
|
|
|
|
2012-11-21 23:34:46 +03:00
|
|
|
if ((ret = vp8_init_frames(s)) < 0) {
|
2013-04-16 20:12:26 +03:00
|
|
|
ff_vp8_decode_free(avctx);
|
2012-11-21 23:34:46 +03:00
|
|
|
return ret;
|
|
|
|
}
|
2010-06-22 22:24:09 +03:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-04-01 15:21:51 +03:00
|
|
|
#if CONFIG_VP7_DECODER
|
|
|
|
static int vp7_decode_init(AVCodecContext *avctx)
|
|
|
|
{
|
|
|
|
return vp78_decode_init(avctx, IS_VP7);
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_VP7_DECODER */
|
|
|
|
|
|
|
|
av_cold int ff_vp8_decode_init(AVCodecContext *avctx)
|
|
|
|
{
|
|
|
|
return vp78_decode_init(avctx, IS_VP8);
|
|
|
|
}
|
|
|
|
|
2014-02-18 13:52:30 +03:00
|
|
|
#if CONFIG_VP8_DECODER
|
2015-09-17 04:22:27 +02:00
|
|
|
#if HAVE_THREADS
|
2014-06-18 03:55:49 +03:00
|
|
|
#define REBASE(pic) ((pic) ? (pic) - &s_src->frames[0] + &s->frames[0] : NULL)
|
2011-05-02 16:55:52 +03:00
|
|
|
|
2014-03-28 03:13:54 +03:00
|
|
|
static int vp8_decode_update_thread_context(AVCodecContext *dst,
|
|
|
|
const AVCodecContext *src)
|
2011-05-02 16:55:52 +03:00
|
|
|
{
|
|
|
|
VP8Context *s = dst->priv_data, *s_src = src->priv_data;
|
2012-11-21 23:34:46 +03:00
|
|
|
int i;
|
2011-05-02 16:55:52 +03:00
|
|
|
|
2011-10-15 00:27:52 +03:00
|
|
|
if (s->macroblocks_base &&
|
|
|
|
(s_src->mb_width != s->mb_width || s_src->mb_height != s->mb_height)) {
|
|
|
|
free_buffers(s);
|
2012-05-01 19:59:04 +03:00
|
|
|
s->mb_width = s_src->mb_width;
|
|
|
|
s->mb_height = s_src->mb_height;
|
2011-10-15 00:27:52 +03:00
|
|
|
}
|
|
|
|
|
2017-11-18 19:55:18 +02:00
|
|
|
s->pix_fmt = s_src->pix_fmt;
|
2014-03-28 03:13:54 +03:00
|
|
|
s->prob[0] = s_src->prob[!s_src->update_probabilities];
|
2011-05-02 16:55:52 +03:00
|
|
|
s->segmentation = s_src->segmentation;
|
2014-03-28 03:13:54 +03:00
|
|
|
s->lf_delta = s_src->lf_delta;
|
2011-05-02 16:55:52 +03:00
|
|
|
memcpy(s->sign_bias, s_src->sign_bias, sizeof(s->sign_bias));
|
|
|
|
|
2012-11-21 23:34:46 +03:00
|
|
|
for (i = 0; i < FF_ARRAY_ELEMS(s_src->frames); i++) {
|
2017-11-18 19:55:18 +02:00
|
|
|
if (s_src->frames[i].tf.f->buf[0]) {
|
2012-11-21 23:34:46 +03:00
|
|
|
int ret = vp8_ref_frame(s, &s->frames[i], &s_src->frames[i]);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-05-02 16:55:52 +03:00
|
|
|
s->framep[0] = REBASE(s_src->next_framep[0]);
|
|
|
|
s->framep[1] = REBASE(s_src->next_framep[1]);
|
|
|
|
s->framep[2] = REBASE(s_src->next_framep[2]);
|
|
|
|
s->framep[3] = REBASE(s_src->next_framep[3]);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2015-09-17 04:22:27 +02:00
|
|
|
#endif /* HAVE_THREADS */
|
2014-04-01 15:21:51 +03:00
|
|
|
#endif /* CONFIG_VP8_DECODER */
|
2011-05-02 16:55:52 +03:00
|
|
|
|
2014-02-18 13:52:30 +03:00
|
|
|
#if CONFIG_VP7_DECODER
|
2022-03-16 22:09:54 +02:00
|
|
|
const FFCodec ff_vp7_decoder = {
|
|
|
|
.p.name = "vp7",
|
|
|
|
.p.long_name = NULL_IF_CONFIG_SMALL("On2 VP7"),
|
|
|
|
.p.type = AVMEDIA_TYPE_VIDEO,
|
|
|
|
.p.id = AV_CODEC_ID_VP7,
|
2014-02-18 13:52:30 +03:00
|
|
|
.priv_data_size = sizeof(VP8Context),
|
2014-04-01 15:21:51 +03:00
|
|
|
.init = vp7_decode_init,
|
2014-02-18 13:52:30 +03:00
|
|
|
.close = ff_vp8_decode_free,
|
2022-03-30 23:28:24 +02:00
|
|
|
FF_CODEC_DECODE_CB(vp7_decode_frame),
|
2022-03-16 22:09:54 +02:00
|
|
|
.p.capabilities = AV_CODEC_CAP_DR1,
|
2014-02-18 13:52:30 +03:00
|
|
|
.flush = vp8_decode_flush,
|
|
|
|
};
|
2014-04-01 15:21:51 +03:00
|
|
|
#endif /* CONFIG_VP7_DECODER */
|
2014-02-18 13:52:30 +03:00
|
|
|
|
|
|
|
#if CONFIG_VP8_DECODER
|
2022-03-16 22:09:54 +02:00
|
|
|
const FFCodec ff_vp8_decoder = {
|
|
|
|
.p.name = "vp8",
|
|
|
|
.p.long_name = NULL_IF_CONFIG_SMALL("On2 VP8"),
|
|
|
|
.p.type = AVMEDIA_TYPE_VIDEO,
|
|
|
|
.p.id = AV_CODEC_ID_VP8,
|
2012-04-06 19:19:39 +03:00
|
|
|
.priv_data_size = sizeof(VP8Context),
|
2013-04-16 20:12:26 +03:00
|
|
|
.init = ff_vp8_decode_init,
|
|
|
|
.close = ff_vp8_decode_free,
|
2022-03-30 23:28:24 +02:00
|
|
|
FF_CODEC_DECODE_CB(ff_vp8_decode_frame),
|
2022-03-16 22:09:54 +02:00
|
|
|
.p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS |
|
2015-07-07 02:41:27 +02:00
|
|
|
AV_CODEC_CAP_SLICE_THREADS,
|
2022-07-10 00:05:45 +02:00
|
|
|
.caps_internal = FF_CODEC_CAP_ALLOCATE_PROGRESS,
|
2012-04-06 19:19:39 +03:00
|
|
|
.flush = vp8_decode_flush,
|
2011-05-02 16:55:52 +03:00
|
|
|
.update_thread_context = ONLY_IF_THREADS_ENABLED(vp8_decode_update_thread_context),
|
2020-12-27 18:36:59 +02:00
|
|
|
.hw_configs = (const AVCodecHWConfigInternal *const []) {
|
2017-11-18 19:55:24 +02:00
|
|
|
#if CONFIG_VP8_VAAPI_HWACCEL
|
|
|
|
HWACCEL_VAAPI(vp8),
|
2017-11-19 18:42:39 +02:00
|
|
|
#endif
|
|
|
|
#if CONFIG_VP8_NVDEC_HWACCEL
|
|
|
|
HWACCEL_NVDEC(vp8),
|
2017-11-18 19:55:24 +02:00
|
|
|
#endif
|
2017-11-18 19:55:18 +02:00
|
|
|
NULL
|
|
|
|
},
|
2010-06-22 22:24:09 +03:00
|
|
|
};
|
2014-04-01 15:21:51 +03:00
|
|
|
#endif /* CONFIG_VP7_DECODER */
|