public unsafe static int vp8_yv12_de_alloc_frame_buffer(ref YV12_BUFFER_CONFIG ybf)
{
//if (ybf)
//{
// If libvpx is using frame buffer callbacks then buffer_alloc_sz must
// not be set.
if (ybf.buffer_alloc != null && ybf.buffer_alloc_sz > 0)
{
vpx_mem.vpx_free(ybf.buffer_alloc);
ybf.buffer_alloc = null;
ybf.buffer_alloc_sz = 0;
}
/* buffer_alloc isn't accessed by most functions. Rather y_buffer,
* u_buffer and v_buffer point to buffer_alloc and are used. Clear out
* all of this so that a freed pointer isn't inadvertently used */
// memset(ybf, 0, sizeof(YV12_BUFFER_CONFIG));
//}
//else
//{
// return -1;
//}
return(0);
}
static vpx_image_t vp8_get_frame(vpx_codec_alg_priv_t ctx, vpx_codec_iter_t iter)
{
vpx_image_t img = null;
/* iter acts as a flip flop, so an image is only returned on the first
* call to get_frame.
*/
if (iter == IntPtr.Zero && ctx.yv12_frame_buffers.pbi[0] != null)
{
YV12_BUFFER_CONFIG sd = new YV12_BUFFER_CONFIG();
long time_stamp = 0, time_end_stamp = 0;
vp8_ppflags_t flags = new vp8_ppflags_t();
// Port AC: ppflags struct will be initialised to zero by default.
//vp8_zero(flags);
//if ([email protected]_flags & VPX_CODEC_USE_POSTPROC) {
// flags.post_proc_flag = ctx->postproc_cfg.post_proc_flag;
// flags.deblocking_level = ctx->postproc_cfg.deblocking_level;
// flags.noise_level = ctx->postproc_cfg.noise_level;
//}
if (0 == onyxd.vp8dx_get_raw_frame(ctx.yv12_frame_buffers.pbi[0], ref sd,
out time_stamp, out time_end_stamp, ref flags))
{
yuvconfig2image(ctx.img, sd, ctx.user_priv);
img = ctx.img;
//*iter = img;
}
}
return(img);
}
public bool Equals(YV12_BUFFER_CONFIG y)
{
return
(y_width == y.y_width &&
y_height == y.y_height &&
y_crop_width == y.y_crop_width &&
y_crop_height == y.y_crop_height &&
y_stride == y.y_stride &&
uv_width == y.uv_width &&
uv_height == y.uv_height &&
uv_crop_width == y.uv_crop_width &&
uv_crop_height == y.uv_crop_height &&
uv_stride == y.uv_stride &&
alpha_width == y.alpha_width &&
alpha_height == y.alpha_height &&
alpha_stride == y.alpha_stride &&
y_buffer == y.y_buffer &&
u_buffer == y.u_buffer &&
v_buffer == y.v_buffer &&
alpha_buffer == y.alpha_buffer &&
buffer_alloc == y.buffer_alloc &&
buffer_alloc_sz == y.buffer_alloc_sz &&
border == y.border &&
frame_size == y.frame_size &&
subsampling_x == y.subsampling_x &&
subsampling_y == y.subsampling_y &&
bit_depth == y.bit_depth &&
color_space == y.color_space &&
color_range == y.color_range &&
render_width == y.render_width &&
render_height == y.render_height &&
corrupted == y.corrupted &&
flags == y.flags);
}
public unsafe static void vp8_yv12_extend_frame_borders_c(YV12_BUFFER_CONFIG ybf)
{
int uv_border = ybf.border / 2;
//assert(ybf->border % 2 == 0);
//assert(ybf->y_height - ybf->y_crop_height < 16);
//assert(ybf->y_width - ybf->y_crop_width < 16);
//assert(ybf->y_height - ybf->y_crop_height >= 0);
//assert(ybf->y_width - ybf->y_crop_width >= 0);
extend_plane(ybf.y_buffer, ybf.y_stride, ybf.y_crop_width,
ybf.y_crop_height, ybf.border, ybf.border,
ybf.border + ybf.y_height - ybf.y_crop_height,
ybf.border + ybf.y_width - ybf.y_crop_width);
extend_plane(ybf.u_buffer, ybf.uv_stride, ybf.uv_crop_width,
ybf.uv_crop_height, uv_border, uv_border,
uv_border + ybf.uv_height - ybf.uv_crop_height,
uv_border + ybf.uv_width - ybf.uv_crop_width);
extend_plane(ybf.v_buffer, ybf.uv_stride, ybf.uv_crop_width,
ybf.uv_crop_height, uv_border, uv_border,
uv_border + ybf.uv_height - ybf.uv_crop_height,
uv_border + ybf.uv_width - ybf.uv_crop_width);
}
public static void vp8_setup_intra_recon_top_line(YV12_BUFFER_CONFIG ybf)
{
//memset(ybf->y_buffer - 1 - ybf->y_stride, 127, ybf->y_width + 5);
Mem.memset <byte>(ybf.y_buffer - 1 - ybf.y_stride, 127, ybf.y_width + 5);
//memset(ybf->u_buffer - 1 - ybf->uv_stride, 127, ybf->uv_width + 5);
Mem.memset <byte>(ybf.u_buffer - 1 - ybf.uv_stride, 127, ybf.uv_width + 5);
//memset(ybf->v_buffer - 1 - ybf->uv_stride, 127, ybf->uv_width + 5);
Mem.memset <byte>(ybf.v_buffer - 1 - ybf.uv_stride, 127, ybf.uv_width + 5);
}
public static int vp8dx_get_raw_frame(VP8D_COMP pbi, ref YV12_BUFFER_CONFIG sd,
out long time_stamp, out long time_end_stamp,
ref vp8_ppflags_t flags)
{
int ret = -1;
time_stamp = 0;
time_end_stamp = 0;
if (pbi.ready_for_new_data == 1)
{
return(ret);
}
/* ie no raw frame to show!!! */
if (pbi.common.show_frame == 0)
{
return(ret);
}
pbi.ready_for_new_data = 1;
time_stamp = pbi.last_time_stamp;
time_end_stamp = 0;
//(void)flags;
if (pbi.common.frame_to_show != null)
{
sd = pbi.common.frame_to_show;
sd.y_width = pbi.common.Width;
sd.y_height = pbi.common.Height;
sd.uv_height = pbi.common.Height / 2;
ret = 0;
}
else
{
ret = -1;
}
// Port AC: Noop in libvpx.
//vpx_clear_system_state();
return(ret);
}
// void vp8_yv12_copy_frame_c(const struct yv12_buffer_config *src_ybc, struct yv12_buffer_config *dst_ybc);
// #define vp8_yv12_copy_frame vp8_yv12_copy_frame_c
// Copies the source image into the destination image and updates the
// destination's UMV borders.
// Note: The frames are assumed to be identical in size.
public unsafe static void vp8_yv12_copy_frame(YV12_BUFFER_CONFIG src_ybc,
YV12_BUFFER_CONFIG dst_ybc)
{
int row;
byte *src = src_ybc.y_buffer;
byte *dst = dst_ybc.y_buffer;
for (row = 0; row < src_ybc.y_height; ++row)
{
//memcpy(dst, src, src_ybc.y_width);
Buffer.MemoryCopy(src, dst, dst_ybc.y_width, src_ybc.y_width);
src += src_ybc.y_stride;
dst += dst_ybc.y_stride;
}
src = src_ybc.u_buffer;
dst = dst_ybc.u_buffer;
for (row = 0; row < src_ybc.uv_height; ++row)
{
//memcpy(dst, src, src_ybc.uv_width);
Buffer.MemoryCopy(src, dst, dst_ybc.uv_width, src_ybc.uv_width);
src += src_ybc.uv_stride;
dst += dst_ybc.uv_stride;
}
src = src_ybc.v_buffer;
dst = dst_ybc.v_buffer;
for (row = 0; row < src_ybc.uv_height; ++row)
{
//memcpy(dst, src, src_ybc.uv_width);
Buffer.MemoryCopy(src, dst, dst_ybc.uv_width, src_ybc.uv_width);
src += src_ybc.uv_stride;
dst += dst_ybc.uv_stride;
}
vp8_yv12_extend_frame_borders_c(dst_ybc);
}
private unsafe static int vp8_yv12_realloc_frame_buffer(ref YV12_BUFFER_CONFIG ybf, int width,
int height, int border)
{
int aligned_width = (width + 15) & ~15;
int aligned_height = (height + 15) & ~15;
int y_stride = ((aligned_width + 2 * border) + 31) & ~31;
int yplane_size = (aligned_height + 2 * border) * y_stride;
int uv_width = aligned_width >> 1;
int uv_height = aligned_height >> 1;
/** There is currently a bunch of code which assumes
* uv_stride == y_stride/2, so enforce this here. */
int uv_stride = y_stride >> 1;
int uvplane_size = (uv_height + border) * uv_stride;
ulong frame_size = (ulong)yplane_size + 2 * (ulong)uvplane_size;
if (ybf.buffer_alloc == null || (IntPtr)ybf.buffer_alloc == IntPtr.Zero)
{
ybf.buffer_alloc = (byte *)vpx_mem.vpx_memalign(32, frame_size);
//ybf.buffer_alloc = (byte*)vpx_malloc((int)frame_size);
ybf.buffer_alloc_sz = frame_size;
}
// Port AC: This check seems intended to catch cases where a YV12 buffer needs to be re-used
// and the memory buffer was not released first. It would seem safer to simply release the
// existing memory if it was present and then allocate the new memory required. In order
// to keep compatibility this logic is currently being left as is and the caveat is the
// vp8_yv12_de_alloc_frame_buffer will always need to be called before re-using a buffer
// with a different size.
if (ybf.buffer_alloc == null ||
(IntPtr)ybf.buffer_alloc == IntPtr.Zero ||
ybf.buffer_alloc_sz < frame_size)
{
return(-1);
}
/* Only support allocating buffers that have a border that's a multiple
* of 32. The border restriction is required to get 16-byte alignment of
* the start of the chroma rows without introducing an arbitrary gap
* between planes, which would break the semantics of things like
* vpx_img_set_rect(). */
if ((border & 0x1f) > 0)
{
return(-3);
}
ybf.y_crop_width = width;
ybf.y_crop_height = height;
ybf.y_width = aligned_width;
ybf.y_height = aligned_height;
ybf.y_stride = y_stride;
ybf.uv_crop_width = (width + 1) / 2;
ybf.uv_crop_height = (height + 1) / 2;
ybf.uv_width = uv_width;
ybf.uv_height = uv_height;
ybf.uv_stride = uv_stride;
ybf.alpha_width = 0;
ybf.alpha_height = 0;
ybf.alpha_stride = 0;
ybf.border = border;
ybf.frame_size = frame_size;
ybf.y_buffer = ybf.buffer_alloc + (border * y_stride) + border;
ybf.u_buffer =
ybf.buffer_alloc + yplane_size + (border / 2 * uv_stride) + border / 2;
ybf.v_buffer = ybf.buffer_alloc + yplane_size + uvplane_size +
(border / 2 * uv_stride) + border / 2;
ybf.alpha_buffer = null;
ybf.corrupted = 0; /* assume not currupted by errors */
return(0);
}
/// <summary>
///
/// </summary>
/// <param name="ybf"></param>
/// <param name="width"></param>
/// <param name="height"></param>
/// <param name="border">The border must be a multiple of 32.</param>
/// <returns></returns>
public static int vp8_yv12_alloc_frame_buffer(ref YV12_BUFFER_CONFIG ybf, int width, int height,
int border)
{
vp8_yv12_de_alloc_frame_buffer(ref ybf);
return(vp8_yv12_realloc_frame_buffer(ref ybf, width, height, border));
}
