2004-10-30 01:43:37 +00:00
|
|
|
/*
|
|
|
|
* Range coder
|
|
|
|
* Copyright (c) 2004 Michael Niedermayer <michaelni@gmx.at>
|
|
|
|
*
|
2006-10-07 15:30:46 +00:00
|
|
|
* This file is part of FFmpeg.
|
|
|
|
*
|
|
|
|
* FFmpeg is free software; you can redistribute it and/or
|
2004-10-30 01:43:37 +00:00
|
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
|
|
* License as published by the Free Software Foundation; either
|
2006-10-07 15:30:46 +00:00
|
|
|
* version 2.1 of the License, or (at your option) any later version.
|
2004-10-30 01:43:37 +00:00
|
|
|
*
|
2006-10-07 15:30:46 +00:00
|
|
|
* FFmpeg is distributed in the hope that it will be useful,
|
2004-10-30 01:43:37 +00:00
|
|
|
* 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
|
2006-10-07 15:30:46 +00:00
|
|
|
* License along with FFmpeg; if not, write to the Free Software
|
2006-01-12 22:43:26 +00:00
|
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
2004-10-30 01:43:37 +00:00
|
|
|
*/
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2004-10-30 01:43:37 +00:00
|
|
|
/**
|
2010-04-20 14:45:34 +00:00
|
|
|
* @file
|
2004-10-30 01:43:37 +00:00
|
|
|
* Range coder.
|
|
|
|
* based upon
|
|
|
|
* "Range encoding: an algorithm for removing redundancy from a digitised
|
|
|
|
* message.
|
|
|
|
* G. N. N. Martin Presented in March 1979 to the Video &
|
|
|
|
* Data Recording Conference,
|
|
|
|
* IBM UK Scientific Center held in Southampton July 24-27 1979."
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <string.h>
|
|
|
|
|
2013-02-01 09:31:59 +00:00
|
|
|
#include "libavutil/attributes.h"
|
2012-06-10 21:36:22 +00:00
|
|
|
#include "libavutil/avassert.h"
|
2004-10-30 01:43:37 +00:00
|
|
|
#include "avcodec.h"
|
|
|
|
#include "rangecoder.h"
|
2007-06-02 01:41:07 +00:00
|
|
|
#include "bytestream.h"
|
2004-10-30 01:43:37 +00:00
|
|
|
|
2013-02-01 09:31:59 +00:00
|
|
|
av_cold void ff_init_range_encoder(RangeCoder *c, uint8_t *buf, int buf_size)
|
2012-10-05 17:05:00 +00:00
|
|
|
{
|
|
|
|
c->bytestream_start =
|
|
|
|
c->bytestream = buf;
|
|
|
|
c->bytestream_end = buf + buf_size;
|
|
|
|
c->low = 0;
|
|
|
|
c->range = 0xFF00;
|
|
|
|
c->outstanding_count = 0;
|
|
|
|
c->outstanding_byte = -1;
|
2004-10-30 01:43:37 +00:00
|
|
|
}
|
|
|
|
|
2013-02-01 09:31:59 +00:00
|
|
|
av_cold void ff_init_range_decoder(RangeCoder *c, const uint8_t *buf,
|
|
|
|
int buf_size)
|
2012-10-05 17:05:00 +00:00
|
|
|
{
|
2005-09-06 21:25:35 +00:00
|
|
|
/* cast to avoid compiler warning */
|
2012-10-05 17:05:00 +00:00
|
|
|
ff_init_range_encoder(c, (uint8_t *)buf, buf_size);
|
2004-10-30 01:43:37 +00:00
|
|
|
|
2012-10-08 01:06:04 +00:00
|
|
|
c->low = bytestream_get_be16((const uint8_t **)&c->bytestream);
|
2004-10-30 01:43:37 +00:00
|
|
|
}
|
|
|
|
|
2012-10-05 17:05:00 +00:00
|
|
|
void ff_build_rac_states(RangeCoder *c, int factor, int max_p)
|
|
|
|
{
|
|
|
|
const int64_t one = 1LL << 32;
|
2004-10-30 01:43:37 +00:00
|
|
|
int64_t p;
|
2005-02-24 19:08:50 +00:00
|
|
|
int last_p8, p8, i;
|
2004-10-30 01:43:37 +00:00
|
|
|
|
|
|
|
memset(c->zero_state, 0, sizeof(c->zero_state));
|
2012-10-05 17:05:00 +00:00
|
|
|
memset(c->one_state, 0, sizeof(c->one_state));
|
|
|
|
|
|
|
|
last_p8 = 0;
|
|
|
|
p = one / 2;
|
|
|
|
for (i = 0; i < 128; i++) {
|
|
|
|
p8 = (256 * p + one / 2) >> 32; // FIXME: try without the one
|
|
|
|
if (p8 <= last_p8)
|
|
|
|
p8 = last_p8 + 1;
|
|
|
|
if (last_p8 && last_p8 < 256 && p8 <= max_p)
|
|
|
|
c->one_state[last_p8] = p8;
|
|
|
|
|
|
|
|
p += ((one - p) * factor + one / 2) >> 32;
|
|
|
|
last_p8 = p8;
|
2004-10-30 01:43:37 +00:00
|
|
|
}
|
2007-01-26 02:29:23 +00:00
|
|
|
|
2012-10-05 17:05:00 +00:00
|
|
|
for (i = 256 - max_p; i <= max_p; i++) {
|
|
|
|
if (c->one_state[i])
|
2004-10-30 01:43:37 +00:00
|
|
|
continue;
|
|
|
|
|
2012-10-05 17:05:00 +00:00
|
|
|
p = (i * one + 128) >> 8;
|
|
|
|
p += ((one - p) * factor + one / 2) >> 32;
|
|
|
|
p8 = (256 * p + one / 2) >> 32; // FIXME: try without the one
|
|
|
|
if (p8 <= i)
|
|
|
|
p8 = i + 1;
|
|
|
|
if (p8 > max_p)
|
|
|
|
p8 = max_p;
|
|
|
|
c->one_state[i] = p8;
|
2004-10-30 01:43:37 +00:00
|
|
|
}
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2012-10-05 17:05:00 +00:00
|
|
|
for (i = 1; i < 255; i++)
|
|
|
|
c->zero_state[i] = 256 - c->one_state[256 - i];
|
2004-10-30 01:43:37 +00:00
|
|
|
}
|
|
|
|
|
2012-10-05 17:05:00 +00:00
|
|
|
/* Return the number of bytes written. */
|
|
|
|
int ff_rac_terminate(RangeCoder *c)
|
|
|
|
{
|
|
|
|
c->range = 0xFF;
|
|
|
|
c->low += 0xFF;
|
2004-10-30 01:43:37 +00:00
|
|
|
renorm_encoder(c);
|
2012-10-05 17:05:00 +00:00
|
|
|
c->range = 0xFF;
|
2004-10-30 01:43:37 +00:00
|
|
|
renorm_encoder(c);
|
|
|
|
|
2012-06-10 21:36:22 +00:00
|
|
|
av_assert1(c->low == 0);
|
|
|
|
av_assert1(c->range >= 0x100);
|
2004-10-30 01:43:37 +00:00
|
|
|
|
|
|
|
return c->bytestream - c->bytestream_start;
|
|
|
|
}
|
|
|
|
|
2008-01-20 23:53:51 +00:00
|
|
|
#ifdef TEST
|
2004-10-30 01:43:37 +00:00
|
|
|
#define SIZE 10240
|
2009-03-20 11:48:27 +00:00
|
|
|
|
|
|
|
#include "libavutil/lfg.h"
|
2012-10-05 17:05:48 +00:00
|
|
|
#include "libavutil/log.h"
|
2009-03-20 11:48:27 +00:00
|
|
|
|
2014-09-01 21:08:56 +00:00
|
|
|
static uint8_t b[9 * SIZE];
|
|
|
|
static uint8_t r[9 * SIZE];
|
|
|
|
|
2012-10-05 17:05:00 +00:00
|
|
|
int main(void)
|
|
|
|
{
|
2004-10-30 01:43:37 +00:00
|
|
|
RangeCoder c;
|
|
|
|
int i;
|
2011-06-06 12:13:02 +00:00
|
|
|
uint8_t state[10];
|
2009-04-10 17:23:38 +00:00
|
|
|
AVLFG prng;
|
2009-03-20 11:48:27 +00:00
|
|
|
|
2009-04-10 17:23:38 +00:00
|
|
|
av_lfg_init(&prng, 1);
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2004-10-30 01:43:37 +00:00
|
|
|
ff_init_range_encoder(&c, b, SIZE);
|
2012-10-05 17:05:00 +00:00
|
|
|
ff_build_rac_states(&c, 0.05 * (1LL << 32), 128 + 64 + 32 + 16);
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2004-10-30 01:43:37 +00:00
|
|
|
memset(state, 128, sizeof(state));
|
|
|
|
|
2012-10-05 17:05:00 +00:00
|
|
|
for (i = 0; i < SIZE; i++)
|
2009-04-10 17:23:38 +00:00
|
|
|
r[i] = av_lfg_get(&prng) % 7;
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2012-10-05 16:53:12 +00:00
|
|
|
for (i = 0; i < SIZE; i++)
|
2012-10-05 17:05:00 +00:00
|
|
|
put_rac(&c, state, r[i] & 1);
|
2004-10-30 01:43:37 +00:00
|
|
|
|
2008-01-23 10:18:08 +00:00
|
|
|
ff_rac_terminate(&c);
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2004-10-30 01:43:37 +00:00
|
|
|
ff_init_range_decoder(&c, b, SIZE);
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2004-10-30 01:43:37 +00:00
|
|
|
memset(state, 128, sizeof(state));
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2012-10-05 16:53:12 +00:00
|
|
|
for (i = 0; i < SIZE; i++)
|
2012-10-12 19:14:56 +00:00
|
|
|
if ((r[i] & 1) != get_rac(&c, state)) {
|
2012-05-30 22:48:29 +00:00
|
|
|
av_log(NULL, AV_LOG_ERROR, "rac failure at %d\n", i);
|
2012-10-12 19:14:56 +00:00
|
|
|
return 1;
|
|
|
|
}
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2004-10-30 01:43:37 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2008-01-20 23:53:51 +00:00
|
|
|
#endif /* TEST */
|