2010-05-18 17:58:33 +02:00
|
|
|
/*
|
2010-09-09 14:16:39 +02:00
|
|
|
* Copyright (c) 2010 The WebM project authors. All Rights Reserved.
|
2010-05-18 17:58:33 +02:00
|
|
|
*
|
2010-06-18 18:39:21 +02:00
|
|
|
* Use of this source code is governed by a BSD-style license
|
2010-06-04 22:19:40 +02:00
|
|
|
* that can be found in the LICENSE file in the root of the source
|
|
|
|
* tree. An additional intellectual property rights grant can be found
|
2010-06-18 18:39:21 +02:00
|
|
|
* in the file PATENTS. All contributing project authors may
|
2010-06-04 22:19:40 +02:00
|
|
|
* be found in the AUTHORS file in the root of the source tree.
|
2010-05-18 17:58:33 +02:00
|
|
|
*/
|
|
|
|
|
|
|
|
|
2013-03-05 23:12:16 +01:00
|
|
|
#include <stdio.h>
|
|
|
|
#include <assert.h>
|
|
|
|
|
2012-11-27 22:59:17 +01:00
|
|
|
#include "vp9/common/vp9_onyxc_int.h"
|
2010-05-18 17:58:33 +02:00
|
|
|
#if CONFIG_POSTPROC
|
2012-11-27 22:59:17 +01:00
|
|
|
#include "vp9/common/vp9_postproc.h"
|
2010-05-18 17:58:33 +02:00
|
|
|
#endif
|
2012-12-19 00:31:19 +01:00
|
|
|
#include "vp9/decoder/vp9_onyxd.h"
|
2012-11-28 19:41:40 +01:00
|
|
|
#include "vp9/decoder/vp9_onyxd_int.h"
|
2010-05-18 17:58:33 +02:00
|
|
|
#include "vpx_mem/vpx_mem.h"
|
2012-11-27 22:59:17 +01:00
|
|
|
#include "vp9/common/vp9_alloccommon.h"
|
|
|
|
#include "vp9/common/vp9_loopfilter.h"
|
|
|
|
#include "vp9/common/vp9_swapyv12buffer.h"
|
2010-08-11 17:02:31 +02:00
|
|
|
|
2012-11-27 22:59:17 +01:00
|
|
|
#include "vp9/common/vp9_quant_common.h"
|
2012-12-03 23:19:49 +01:00
|
|
|
#include "vpx_scale/vpx_scale.h"
|
2012-11-27 22:59:17 +01:00
|
|
|
#include "vp9/common/vp9_systemdependent.h"
|
2010-05-18 17:58:33 +02:00
|
|
|
#include "vpx_ports/vpx_timer.h"
|
2012-11-27 22:59:17 +01:00
|
|
|
#include "vp9/decoder/vp9_decodframe.h"
|
2012-11-28 19:41:40 +01:00
|
|
|
#include "vp9/decoder/vp9_detokenize.h"
|
2012-12-03 21:26:51 +01:00
|
|
|
#include "./vpx_scale_rtcd.h"
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-11-14 00:20:40 +01:00
|
|
|
#define WRITE_RECON_BUFFER 0
|
|
|
|
#if WRITE_RECON_BUFFER == 1
|
2013-01-30 01:58:52 +01:00
|
|
|
static void recon_write_yuv_frame(const char *name,
|
|
|
|
const YV12_BUFFER_CONFIG *s,
|
|
|
|
int w, int _h) {
|
2012-07-14 00:21:29 +02:00
|
|
|
FILE *yuv_file = fopen((char *)name, "ab");
|
2013-01-30 01:58:52 +01:00
|
|
|
const uint8_t *src = s->y_buffer;
|
|
|
|
int h = _h;
|
2011-02-14 23:18:18 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
do {
|
2013-01-30 01:58:52 +01:00
|
|
|
fwrite(src, w, 1, yuv_file);
|
2012-07-14 00:21:29 +02:00
|
|
|
src += s->y_stride;
|
|
|
|
} while (--h);
|
2011-02-14 23:18:18 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
src = s->u_buffer;
|
2013-01-30 01:58:52 +01:00
|
|
|
h = (_h + 1) >> 1;
|
|
|
|
w = (w + 1) >> 1;
|
2011-02-14 23:18:18 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
do {
|
2013-01-30 01:58:52 +01:00
|
|
|
fwrite(src, w, 1, yuv_file);
|
2012-07-14 00:21:29 +02:00
|
|
|
src += s->uv_stride;
|
|
|
|
} while (--h);
|
2011-02-14 23:18:18 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
src = s->v_buffer;
|
2013-01-30 01:58:52 +01:00
|
|
|
h = (_h + 1) >> 1;
|
2011-02-14 23:18:18 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
do {
|
2013-01-30 01:58:52 +01:00
|
|
|
fwrite(src, w, 1, yuv_file);
|
2012-07-14 00:21:29 +02:00
|
|
|
src += s->uv_stride;
|
|
|
|
} while (--h);
|
2011-02-14 23:18:18 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
fclose(yuv_file);
|
2011-02-14 23:18:18 +01:00
|
|
|
}
|
|
|
|
#endif
|
2012-11-14 00:20:40 +01:00
|
|
|
#if WRITE_RECON_BUFFER == 2
|
2012-07-14 00:21:29 +02:00
|
|
|
void write_dx_frame_to_file(YV12_BUFFER_CONFIG *frame, int this_frame) {
|
2011-11-16 01:16:30 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// write the frame
|
|
|
|
FILE *yframe;
|
|
|
|
int i;
|
|
|
|
char filename[255];
|
2011-11-16 01:16:30 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
sprintf(filename, "dx\\y%04d.raw", this_frame);
|
|
|
|
yframe = fopen(filename, "wb");
|
2011-11-16 01:16:30 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
for (i = 0; i < frame->y_height; i++)
|
|
|
|
fwrite(frame->y_buffer + i * frame->y_stride,
|
|
|
|
frame->y_width, 1, yframe);
|
2011-11-16 01:16:30 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
fclose(yframe);
|
|
|
|
sprintf(filename, "dx\\u%04d.raw", this_frame);
|
|
|
|
yframe = fopen(filename, "wb");
|
2011-11-16 01:16:30 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
for (i = 0; i < frame->uv_height; i++)
|
|
|
|
fwrite(frame->u_buffer + i * frame->uv_stride,
|
|
|
|
frame->uv_width, 1, yframe);
|
2011-11-16 01:16:30 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
fclose(yframe);
|
|
|
|
sprintf(filename, "dx\\v%04d.raw", this_frame);
|
|
|
|
yframe = fopen(filename, "wb");
|
2011-11-16 01:16:30 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
for (i = 0; i < frame->uv_height; i++)
|
|
|
|
fwrite(frame->v_buffer + i * frame->uv_stride,
|
|
|
|
frame->uv_width, 1, yframe);
|
2011-11-16 01:16:30 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
fclose(yframe);
|
2011-11-16 01:16:30 +01:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2013-03-05 23:12:16 +01:00
|
|
|
void vp9_initialize_dec() {
|
2012-07-14 00:21:29 +02:00
|
|
|
static int init_done = 0;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
if (!init_done) {
|
2012-10-31 00:25:53 +01:00
|
|
|
vp9_initialize_common();
|
|
|
|
vp9_init_quant_tables();
|
2012-07-14 00:21:29 +02:00
|
|
|
init_done = 1;
|
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
|
|
|
|
2012-10-31 22:40:53 +01:00
|
|
|
VP9D_PTR vp9_create_decompressor(VP9D_CONFIG *oxcf) {
|
2013-04-02 22:34:20 +02:00
|
|
|
VP9D_COMP *const pbi = vpx_memalign(32, sizeof(VP9D_COMP));
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
if (!pbi)
|
|
|
|
return NULL;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-10-31 01:53:32 +01:00
|
|
|
vpx_memset(pbi, 0, sizeof(VP9D_COMP));
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
if (setjmp(pbi->common.error.jmp)) {
|
|
|
|
pbi->common.error.setjmp = 0;
|
2012-10-31 00:16:28 +01:00
|
|
|
vp9_remove_decompressor(pbi);
|
2013-04-02 22:34:20 +02:00
|
|
|
return NULL;
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
pbi->common.error.setjmp = 1;
|
2012-10-31 00:16:28 +01:00
|
|
|
vp9_initialize_dec();
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-10-31 00:25:53 +01:00
|
|
|
vp9_create_common(&pbi->common);
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2013-04-02 22:34:20 +02:00
|
|
|
pbi->oxcf = *oxcf;
|
2012-07-14 00:21:29 +02:00
|
|
|
pbi->common.current_video_frame = 0;
|
|
|
|
pbi->ready_for_new_data = 1;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2013-04-26 21:30:20 +02:00
|
|
|
// vp9_init_dequantizer() is first called here. Add check in
|
2013-04-02 22:34:20 +02:00
|
|
|
// frame_init_dequantizer() to avoid unnecessary calling of
|
2013-04-26 21:30:20 +02:00
|
|
|
// vp9_init_dequantizer() for every frame.
|
|
|
|
vp9_init_dequantizer(&pbi->common);
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-10-31 00:25:53 +01:00
|
|
|
vp9_loop_filter_init(&pbi->common);
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
pbi->common.error.setjmp = 0;
|
|
|
|
pbi->decoded_key_frame = 0;
|
2011-05-02 15:30:51 +02:00
|
|
|
|
2013-04-02 22:34:20 +02:00
|
|
|
return pbi;
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
|
|
|
|
2012-10-31 22:40:53 +01:00
|
|
|
void vp9_remove_decompressor(VP9D_PTR ptr) {
|
2013-04-02 22:34:20 +02:00
|
|
|
VP9D_COMP *const pbi = (VP9D_COMP *)ptr;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
if (!pbi)
|
|
|
|
return;
|
2011-11-15 17:15:23 +01:00
|
|
|
|
2013-03-27 22:22:30 +01:00
|
|
|
if (pbi->common.last_frame_seg_map)
|
2012-07-14 00:21:29 +02:00
|
|
|
vpx_free(pbi->common.last_frame_seg_map);
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-10-31 00:25:53 +01:00
|
|
|
vp9_remove_common(&pbi->common);
|
2012-07-14 00:21:29 +02:00
|
|
|
vpx_free(pbi->mbc);
|
|
|
|
vpx_free(pbi);
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
|
|
|
|
2013-03-27 22:22:30 +01:00
|
|
|
static int equal_dimensions(YV12_BUFFER_CONFIG *a, YV12_BUFFER_CONFIG *b) {
|
|
|
|
return a->y_height == b->y_height && a->y_width == b->y_width &&
|
|
|
|
a->uv_height == b->uv_height && a->uv_width == b->uv_width;
|
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2013-03-13 20:15:43 +01:00
|
|
|
vpx_codec_err_t vp9_copy_reference_dec(VP9D_PTR ptr,
|
|
|
|
VP9_REFFRAME ref_frame_flag,
|
|
|
|
YV12_BUFFER_CONFIG *sd) {
|
2012-10-31 01:53:32 +01:00
|
|
|
VP9D_COMP *pbi = (VP9D_COMP *) ptr;
|
|
|
|
VP9_COMMON *cm = &pbi->common;
|
2012-07-14 00:21:29 +02:00
|
|
|
int ref_fb_idx;
|
|
|
|
|
2013-01-15 22:49:44 +01:00
|
|
|
/* TODO(jkoleszar): The decoder doesn't have any real knowledge of what the
|
|
|
|
* encoder is using the frame buffers for. This is just a stub to keep the
|
|
|
|
* vpxenc --test-decode functionality working, and will be replaced in a
|
|
|
|
* later commit that adds VP9-specific controls for this functionality.
|
|
|
|
*/
|
2013-03-27 22:22:30 +01:00
|
|
|
if (ref_frame_flag == VP9_LAST_FLAG) {
|
2013-03-12 16:33:40 +01:00
|
|
|
ref_fb_idx = pbi->common.ref_frame_map[0];
|
2013-03-27 22:22:30 +01:00
|
|
|
} else {
|
2012-07-14 00:21:29 +02:00
|
|
|
vpx_internal_error(&pbi->common.error, VPX_CODEC_ERROR,
|
|
|
|
"Invalid reference frame");
|
|
|
|
return pbi->common.error.error_code;
|
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2013-03-27 22:22:30 +01:00
|
|
|
if (!equal_dimensions(&cm->yv12_fb[ref_fb_idx], sd)) {
|
2012-07-14 00:21:29 +02:00
|
|
|
vpx_internal_error(&pbi->common.error, VPX_CODEC_ERROR,
|
|
|
|
"Incorrect buffer dimensions");
|
2013-03-27 22:22:30 +01:00
|
|
|
} else {
|
2012-11-02 01:53:44 +01:00
|
|
|
vp8_yv12_copy_frame(&cm->yv12_fb[ref_fb_idx], sd);
|
2013-03-27 22:22:30 +01:00
|
|
|
}
|
2010-07-22 14:07:32 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
return pbi->common.error.error_code;
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
2011-03-17 22:07:59 +01:00
|
|
|
|
|
|
|
|
2012-10-31 22:40:53 +01:00
|
|
|
vpx_codec_err_t vp9_set_reference_dec(VP9D_PTR ptr, VP9_REFFRAME ref_frame_flag,
|
2012-10-31 00:16:28 +01:00
|
|
|
YV12_BUFFER_CONFIG *sd) {
|
2012-10-31 01:53:32 +01:00
|
|
|
VP9D_COMP *pbi = (VP9D_COMP *) ptr;
|
|
|
|
VP9_COMMON *cm = &pbi->common;
|
2012-07-14 00:21:29 +02:00
|
|
|
int *ref_fb_ptr = NULL;
|
|
|
|
|
2013-01-15 22:49:44 +01:00
|
|
|
/* TODO(jkoleszar): The decoder doesn't have any real knowledge of what the
|
|
|
|
* encoder is using the frame buffers for. This is just a stub to keep the
|
|
|
|
* vpxenc --test-decode functionality working, and will be replaced in a
|
|
|
|
* later commit that adds VP9-specific controls for this functionality.
|
|
|
|
*/
|
2012-10-31 22:40:53 +01:00
|
|
|
if (ref_frame_flag == VP9_LAST_FLAG)
|
2013-01-15 22:49:44 +01:00
|
|
|
ref_fb_ptr = &pbi->common.active_ref_idx[0];
|
2012-10-31 22:40:53 +01:00
|
|
|
else if (ref_frame_flag == VP9_GOLD_FLAG)
|
2013-01-15 22:49:44 +01:00
|
|
|
ref_fb_ptr = &pbi->common.active_ref_idx[1];
|
2012-10-31 22:40:53 +01:00
|
|
|
else if (ref_frame_flag == VP9_ALT_FLAG)
|
2013-01-15 22:49:44 +01:00
|
|
|
ref_fb_ptr = &pbi->common.active_ref_idx[2];
|
2012-07-14 00:21:29 +02:00
|
|
|
else {
|
|
|
|
vpx_internal_error(&pbi->common.error, VPX_CODEC_ERROR,
|
|
|
|
"Invalid reference frame");
|
|
|
|
return pbi->common.error.error_code;
|
|
|
|
}
|
2011-05-23 13:47:33 +02:00
|
|
|
|
2013-03-27 22:22:30 +01:00
|
|
|
if (!equal_dimensions(&cm->yv12_fb[*ref_fb_ptr], sd)) {
|
2012-07-14 00:21:29 +02:00
|
|
|
vpx_internal_error(&pbi->common.error, VPX_CODEC_ERROR,
|
|
|
|
"Incorrect buffer dimensions");
|
|
|
|
} else {
|
2013-03-27 22:22:30 +01:00
|
|
|
// Find an empty frame buffer.
|
|
|
|
const int free_fb = get_free_fb(cm);
|
|
|
|
// Decrease fb_idx_ref_cnt since it will be increased again in
|
|
|
|
// ref_cnt_fb() below.
|
2012-07-14 00:21:29 +02:00
|
|
|
cm->fb_idx_ref_cnt[free_fb]--;
|
|
|
|
|
2013-03-27 22:22:30 +01:00
|
|
|
// Manage the reference counters and copy image.
|
2012-07-14 00:21:29 +02:00
|
|
|
ref_cnt_fb(cm->fb_idx_ref_cnt, ref_fb_ptr, free_fb);
|
2012-11-02 01:53:44 +01:00
|
|
|
vp8_yv12_copy_frame(sd, &cm->yv12_fb[*ref_fb_ptr]);
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
2010-07-22 14:07:32 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
return pbi->common.error.error_code;
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
|
|
|
|
2010-07-22 14:07:32 +02:00
|
|
|
|
2013-03-13 20:15:43 +01:00
|
|
|
int vp9_get_reference_dec(VP9D_PTR ptr, int index, YV12_BUFFER_CONFIG **fb) {
|
|
|
|
VP9D_COMP *pbi = (VP9D_COMP *) ptr;
|
|
|
|
VP9_COMMON *cm = &pbi->common;
|
|
|
|
|
|
|
|
if (index < 0 || index >= NUM_REF_FRAMES)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
*fb = &cm->yv12_fb[cm->ref_frame_map[index]];
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-04-03 00:08:50 +02:00
|
|
|
/* If any buffer updating is signaled it should be done here. */
|
2013-01-15 22:49:44 +01:00
|
|
|
static void swap_frame_buffers(VP9D_COMP *pbi) {
|
|
|
|
int ref_index = 0, mask;
|
2010-07-22 14:07:32 +02:00
|
|
|
|
2013-01-15 22:49:44 +01:00
|
|
|
for (mask = pbi->refresh_frame_flags; mask; mask >>= 1) {
|
|
|
|
if (mask & 1) {
|
|
|
|
ref_cnt_fb(pbi->common.fb_idx_ref_cnt,
|
2013-01-16 21:19:42 +01:00
|
|
|
&pbi->common.ref_frame_map[ref_index],
|
2013-01-15 22:49:44 +01:00
|
|
|
pbi->common.new_fb_idx);
|
|
|
|
}
|
|
|
|
++ref_index;
|
|
|
|
}
|
2010-07-22 14:07:32 +02:00
|
|
|
|
2013-01-15 22:49:44 +01:00
|
|
|
pbi->common.frame_to_show = &pbi->common.yv12_fb[pbi->common.new_fb_idx];
|
|
|
|
pbi->common.fb_idx_ref_cnt[pbi->common.new_fb_idx]--;
|
2013-01-16 21:19:42 +01:00
|
|
|
|
|
|
|
/* Invalidate these references until the next frame starts. */
|
|
|
|
for (ref_index = 0; ref_index < 3; ref_index++)
|
|
|
|
pbi->common.active_ref_idx[ref_index] = INT_MAX;
|
2010-07-22 14:07:32 +02:00
|
|
|
}
|
|
|
|
|
2013-04-02 22:34:20 +02:00
|
|
|
int vp9_receive_compressed_data(VP9D_PTR ptr,
|
|
|
|
uint64_t size, const uint8_t **psource,
|
2012-10-31 00:16:28 +01:00
|
|
|
int64_t time_stamp) {
|
2012-10-31 01:53:32 +01:00
|
|
|
VP9D_COMP *pbi = (VP9D_COMP *) ptr;
|
|
|
|
VP9_COMMON *cm = &pbi->common;
|
2013-04-02 22:34:20 +02:00
|
|
|
const uint8_t *source = *psource;
|
2012-07-14 00:21:29 +02:00
|
|
|
int retcode = 0;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
/*if(pbi->ready_for_new_data == 0)
|
|
|
|
return -1;*/
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2013-04-02 22:34:20 +02:00
|
|
|
if (ptr == 0)
|
2012-07-14 00:21:29 +02:00
|
|
|
return -1;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
pbi->common.error.error_code = VPX_CODEC_OK;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2013-04-02 22:34:20 +02:00
|
|
|
pbi->source = source;
|
2012-07-14 00:21:29 +02:00
|
|
|
pbi->source_sz = size;
|
2012-02-27 23:23:38 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
if (pbi->source_sz == 0) {
|
|
|
|
/* This is used to signal that we are missing frames.
|
|
|
|
* We do not know if the missing frame(s) was supposed to update
|
|
|
|
* any of the reference buffers, but we act conservative and
|
|
|
|
* mark only the last buffer as corrupted.
|
2013-01-15 22:49:44 +01:00
|
|
|
*
|
|
|
|
* TODO(jkoleszar): Error concealment is undefined and non-normative
|
|
|
|
* at this point, but if it becomes so, [0] may not always be the correct
|
|
|
|
* thing to do here.
|
2012-07-14 00:21:29 +02:00
|
|
|
*/
|
[WIP] Add column-based tiling.
This patch adds column-based tiling. The idea is to make each tile
independently decodable (after reading the common frame header) and
also independendly encodable (minus within-frame cost adjustments in
the RD loop) to speed-up hardware & software en/decoders if they used
multi-threading. Column-based tiling has the added advantage (over
other tiling methods) that it minimizes realtime use-case latency,
since all threads can start encoding data as soon as the first SB-row
worth of data is available to the encoder.
There is some test code that does random tile ordering in the decoder,
to confirm that each tile is indeed independently decodable from other
tiles in the same frame. At tile edges, all contexts assume default
values (i.e. 0, 0 motion vector, no coefficients, DC intra4x4 mode),
and motion vector search and ordering do not cross tiles in the same
frame.
t log
Tile independence is not maintained between frames ATM, i.e. tile 0 of
frame 1 is free to use motion vectors that point into any tile of frame
0. We support 1 (i.e. no tiling), 2 or 4 column-tiles.
The loopfilter crosses tile boundaries. I discussed this briefly with Aki
and he says that's OK. An in-loop loopfilter would need to do some sync
between tile threads, but that shouldn't be a big issue.
Resuls: with tiling disabled, we go up slightly because of improved edge
use in the intra4x4 prediction. With 2 tiles, we lose about ~1% on derf,
~0.35% on HD and ~0.55% on STD/HD. With 4 tiles, we lose another ~1.5%
on derf ~0.77% on HD and ~0.85% on STD/HD. Most of this loss is
concentrated in the low-bitrate end of clips, and most of it is because
of the loss of edges at tile boundaries and the resulting loss of intra
predictors.
TODO:
- more tiles (perhaps allow row-based tiling also, and max. 8 tiles)?
- maybe optionally (for EC purposes), motion vectors themselves
should not cross tile edges, or we should emulate such borders as
if they were off-frame, to limit error propagation to within one
tile only. This doesn't have to be the default behaviour but could
be an optional bitstream flag.
Change-Id: I5951c3a0742a767b20bc9fb5af685d9892c2c96f
2013-02-01 18:35:28 +01:00
|
|
|
if (cm->active_ref_idx[0] != INT_MAX)
|
|
|
|
cm->yv12_fb[cm->active_ref_idx[0]].corrupted = 1;
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
2010-12-16 16:46:31 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
cm->new_fb_idx = get_free_fb(cm);
|
2010-10-20 00:40:46 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
if (setjmp(pbi->common.error.jmp)) {
|
|
|
|
pbi->common.error.setjmp = 0;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
/* We do not know if the missing frame(s) was supposed to update
|
|
|
|
* any of the reference buffers, but we act conservative and
|
|
|
|
* mark only the last buffer as corrupted.
|
2013-01-15 22:49:44 +01:00
|
|
|
*
|
|
|
|
* TODO(jkoleszar): Error concealment is undefined and non-normative
|
|
|
|
* at this point, but if it becomes so, [0] may not always be the correct
|
|
|
|
* thing to do here.
|
2012-07-14 00:21:29 +02:00
|
|
|
*/
|
[WIP] Add column-based tiling.
This patch adds column-based tiling. The idea is to make each tile
independently decodable (after reading the common frame header) and
also independendly encodable (minus within-frame cost adjustments in
the RD loop) to speed-up hardware & software en/decoders if they used
multi-threading. Column-based tiling has the added advantage (over
other tiling methods) that it minimizes realtime use-case latency,
since all threads can start encoding data as soon as the first SB-row
worth of data is available to the encoder.
There is some test code that does random tile ordering in the decoder,
to confirm that each tile is indeed independently decodable from other
tiles in the same frame. At tile edges, all contexts assume default
values (i.e. 0, 0 motion vector, no coefficients, DC intra4x4 mode),
and motion vector search and ordering do not cross tiles in the same
frame.
t log
Tile independence is not maintained between frames ATM, i.e. tile 0 of
frame 1 is free to use motion vectors that point into any tile of frame
0. We support 1 (i.e. no tiling), 2 or 4 column-tiles.
The loopfilter crosses tile boundaries. I discussed this briefly with Aki
and he says that's OK. An in-loop loopfilter would need to do some sync
between tile threads, but that shouldn't be a big issue.
Resuls: with tiling disabled, we go up slightly because of improved edge
use in the intra4x4 prediction. With 2 tiles, we lose about ~1% on derf,
~0.35% on HD and ~0.55% on STD/HD. With 4 tiles, we lose another ~1.5%
on derf ~0.77% on HD and ~0.85% on STD/HD. Most of this loss is
concentrated in the low-bitrate end of clips, and most of it is because
of the loss of edges at tile boundaries and the resulting loss of intra
predictors.
TODO:
- more tiles (perhaps allow row-based tiling also, and max. 8 tiles)?
- maybe optionally (for EC purposes), motion vectors themselves
should not cross tile edges, or we should emulate such borders as
if they were off-frame, to limit error propagation to within one
tile only. This doesn't have to be the default behaviour but could
be an optional bitstream flag.
Change-Id: I5951c3a0742a767b20bc9fb5af685d9892c2c96f
2013-02-01 18:35:28 +01:00
|
|
|
if (cm->active_ref_idx[0] != INT_MAX)
|
|
|
|
cm->yv12_fb[cm->active_ref_idx[0]].corrupted = 1;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
if (cm->fb_idx_ref_cnt[cm->new_fb_idx] > 0)
|
|
|
|
cm->fb_idx_ref_cnt[cm->new_fb_idx]--;
|
2013-04-02 22:34:20 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
return -1;
|
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
pbi->common.error.setjmp = 1;
|
2012-02-27 23:23:38 +01:00
|
|
|
|
2012-11-15 21:19:07 +01:00
|
|
|
retcode = vp9_decode_frame(pbi, psource);
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
if (retcode < 0) {
|
|
|
|
pbi->common.error.error_code = VPX_CODEC_ERROR;
|
|
|
|
pbi->common.error.setjmp = 0;
|
|
|
|
if (cm->fb_idx_ref_cnt[cm->new_fb_idx] > 0)
|
|
|
|
cm->fb_idx_ref_cnt[cm->new_fb_idx]--;
|
|
|
|
return retcode;
|
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
{
|
2013-01-15 22:49:44 +01:00
|
|
|
swap_frame_buffers(pbi);
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-11-14 00:20:40 +01:00
|
|
|
#if WRITE_RECON_BUFFER == 2
|
2012-07-14 00:21:29 +02:00
|
|
|
if (cm->show_frame)
|
|
|
|
write_dx_frame_to_file(cm->frame_to_show,
|
|
|
|
cm->current_video_frame);
|
|
|
|
else
|
|
|
|
write_dx_frame_to_file(cm->frame_to_show,
|
|
|
|
cm->current_video_frame + 1000);
|
2011-11-16 01:16:30 +01:00
|
|
|
#endif
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
if (cm->filter_level) {
|
|
|
|
/* Apply the loop filter if appropriate. */
|
2013-03-20 18:22:20 +01:00
|
|
|
vp9_loop_filter_frame(cm, &pbi->mb, cm->filter_level, 0,
|
|
|
|
cm->dering_enabled);
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
2012-11-02 01:53:44 +01:00
|
|
|
vp8_yv12_extend_frame_borders(cm->frame_to_show);
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-11-14 00:20:40 +01:00
|
|
|
#if WRITE_RECON_BUFFER == 1
|
2012-07-14 00:21:29 +02:00
|
|
|
if (cm->show_frame)
|
2013-01-30 01:58:52 +01:00
|
|
|
recon_write_yuv_frame("recon.yuv", cm->frame_to_show,
|
2013-03-21 00:41:30 +01:00
|
|
|
cm->width, cm->height);
|
2011-02-14 23:18:18 +01:00
|
|
|
#endif
|
2010-09-01 02:43:14 +02:00
|
|
|
|
2012-10-31 22:40:53 +01:00
|
|
|
vp9_clear_system_state();
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2013-04-19 22:32:15 +02:00
|
|
|
cm->last_show_frame = cm->show_frame;
|
2012-07-14 00:21:29 +02:00
|
|
|
if (cm->show_frame) {
|
2013-04-19 22:32:15 +02:00
|
|
|
// current mip will be the prev_mip for the next frame
|
|
|
|
MODE_INFO *temp = cm->prev_mip;
|
|
|
|
cm->prev_mip = cm->mip;
|
|
|
|
cm->mip = temp;
|
|
|
|
|
|
|
|
// update the upper left visible macroblock ptrs
|
|
|
|
cm->mi = cm->mip + cm->mode_info_stride + 1;
|
|
|
|
cm->prev_mi = cm->prev_mip + cm->mode_info_stride + 1;
|
|
|
|
|
|
|
|
cm->current_video_frame++;
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
2011-11-16 01:16:30 +01:00
|
|
|
|
2012-10-31 00:25:53 +01:00
|
|
|
/*vp9_print_modes_and_motion_vectors(cm->mi, cm->mb_rows,cm->mb_cols,
|
2012-10-31 00:16:28 +01:00
|
|
|
cm->current_video_frame);*/
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
pbi->ready_for_new_data = 0;
|
|
|
|
pbi->last_time_stamp = time_stamp;
|
|
|
|
pbi->source_sz = 0;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
pbi->common.error.setjmp = 0;
|
|
|
|
return retcode;
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
2012-10-31 00:16:28 +01:00
|
|
|
|
2012-10-31 22:40:53 +01:00
|
|
|
int vp9_get_raw_frame(VP9D_PTR ptr, YV12_BUFFER_CONFIG *sd,
|
2012-10-31 00:16:28 +01:00
|
|
|
int64_t *time_stamp, int64_t *time_end_stamp,
|
2012-10-31 22:40:53 +01:00
|
|
|
vp9_ppflags_t *flags) {
|
2012-07-14 00:21:29 +02:00
|
|
|
int ret = -1;
|
2012-10-31 01:53:32 +01:00
|
|
|
VP9D_COMP *pbi = (VP9D_COMP *) ptr;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
if (pbi->ready_for_new_data == 1)
|
|
|
|
return ret;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
/* ie no raw frame to show!!! */
|
|
|
|
if (pbi->common.show_frame == 0)
|
|
|
|
return ret;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
pbi->ready_for_new_data = 1;
|
|
|
|
*time_stamp = pbi->last_time_stamp;
|
|
|
|
*time_end_stamp = 0;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
sd->clrtype = pbi->common.clr_type;
|
2010-05-18 17:58:33 +02:00
|
|
|
#if CONFIG_POSTPROC
|
2012-10-31 00:25:53 +01:00
|
|
|
ret = vp9_post_proc_frame(&pbi->common, sd, flags);
|
2010-05-18 17:58:33 +02:00
|
|
|
#else
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
if (pbi->common.frame_to_show) {
|
|
|
|
*sd = *pbi->common.frame_to_show;
|
2013-03-21 00:41:30 +01:00
|
|
|
sd->y_width = pbi->common.width;
|
|
|
|
sd->y_height = pbi->common.height;
|
|
|
|
sd->uv_height = pbi->common.height / 2;
|
2012-07-14 00:21:29 +02:00
|
|
|
ret = 0;
|
|
|
|
} else {
|
|
|
|
ret = -1;
|
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2010-10-28 01:04:02 +02:00
|
|
|
#endif /*!CONFIG_POSTPROC*/
|
2012-10-31 22:40:53 +01:00
|
|
|
vp9_clear_system_state();
|
2012-07-14 00:21:29 +02:00
|
|
|
return ret;
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|