int
check (int n, int freq)
{
SchroBuffer *buffer;
OilProfile prof;
double ave, std;
int x;
int y;
buffer = schro_buffer_new_and_alloc (100000);
encode(buffer, n, freq);
print_speed();
x = decode(buffer, n, &prof, 0);
oil_profile_get_ave_std (&prof, &ave, &std);
printf("orig %d,%d: %g (%g) %d\n", n, freq, ave, std, x);
x = decode(buffer, n, &prof, 1);
oil_profile_get_ave_std (&prof, &ave, &std);
printf("ref %d,%d: %g (%g) %d\n", n, freq, ave, std, x);
y = decode(buffer, n, &prof, 2);
oil_profile_get_ave_std (&prof, &ave, &std);
printf("test %d,%d: %g (%g) %d\n", n, freq, ave, std, y);
if (x != y) {
printf("BROKEN\n");
}
schro_buffer_unref (buffer);
return 0;
}
static void
schro_buf_free_func (gpointer priv)
{
SchroBuffer *buffer = (SchroBuffer *) priv;
schro_buffer_unref (buffer);
}
int test4 (void)
{
SchroBuffer *buffer = schro_buffer_new_and_alloc (100);
SchroPack *pack;
SchroUnpack unpack;
int i;
int16_t x;
int ok = 1;
for(i=-1000;i<1000;i++){
pack = schro_pack_new ();
schro_pack_encode_init (pack, buffer);
schro_pack_encode_sint (pack, i);
schro_pack_flush(pack);
schro_pack_free (pack);
schro_unpack_init_with_data (&unpack, buffer->data, buffer->length, 1);
schro_unpack_decode_sint_s16 (&x, &unpack, 1);
if (i != x) {
printf("%d %d %c\n", i, x, (i==x)?' ':'x');
ok = 0;
}
}
schro_buffer_unref (buffer);
return ok;
}
int test1 (void)
{
SchroBuffer *buffer = schro_buffer_new_and_alloc (100);
SchroPack *pack;
SchroUnpack unpack;
int i;
int ref[800];
int x;
int guard;
for(i=0;i<800;i++){
ref[i] = rand()&1;
}
guard = rand()&1;
pack = schro_pack_new ();
schro_pack_encode_init (pack, buffer);
for(i=0;i<800;i++){
schro_pack_encode_bit (pack, ref[i]);
}
schro_pack_flush(pack);
schro_pack_free (pack);
schro_unpack_init_with_data (&unpack, buffer->data, buffer->length, guard);
for(i=0;i<800;i++){
x = schro_unpack_decode_bit (&unpack);
if (x != ref[i]) {
printf("test1 failed at bit %d\n", i);
schro_unpack_dump(&unpack);
return 0;
}
}
for(i=0;i<100;i++){
x = schro_unpack_decode_bit (&unpack);
if (x != guard) {
printf("test1 failed at guard bit %d\n", i);
schro_unpack_dump(&unpack);
return 0;
}
}
schro_buffer_unref (buffer);
return 1;
}
int test2 (void)
{
SchroBuffer *buffer = schro_buffer_new_and_alloc (1000);
SchroPack *pack;
SchroUnpack unpack;
int i;
int ref[100];
int x;
int n_bytes;
memset (buffer->data, 0, 1000);
for(i=0;i<100;i++){
ref[i] = rand()&0xff;
}
pack = schro_pack_new ();
schro_pack_encode_init (pack, buffer);
for(i=0;i<100;i++){
schro_pack_encode_uint (pack, ref[i]);
}
schro_pack_flush(pack);
n_bytes = schro_pack_get_offset (pack);
schro_pack_free (pack);
schro_unpack_init_with_data (&unpack, buffer->data, n_bytes, 1);
for(i=0;i<100;i++){
x = schro_unpack_decode_uint (&unpack);
if (x != ref[i]) {
printf("test2 failed at symbol %d (%d should be %d)\n", i, x, ref[i]);
schro_unpack_dump(&unpack);
return 0;
}
}
schro_buffer_unref (buffer);
return 1;
}
static int libschroedinger_encode_frame(AVCodecContext *avccontext, AVPacket *pkt,
const AVFrame *frame, int *got_packet)
{
int enc_size = 0;
SchroEncoderParams *p_schro_params = avccontext->priv_data;
SchroEncoder *encoder = p_schro_params->encoder;
struct FFSchroEncodedFrame *p_frame_output = NULL;
int go = 1;
SchroBuffer *enc_buf;
int presentation_frame;
int parse_code;
int last_frame_in_sequence = 0;
int pkt_size, ret;
if (!frame) {
/* Push end of sequence if not already signalled. */
if (!p_schro_params->eos_signalled) {
schro_encoder_end_of_stream(encoder);
p_schro_params->eos_signalled = 1;
}
} else {
/* Allocate frame data to schro input buffer. */
SchroFrame *in_frame = libschroedinger_frame_from_data(avccontext,
frame);
/* Load next frame. */
schro_encoder_push_frame(encoder, in_frame);
}
if (p_schro_params->eos_pulled)
go = 0;
/* Now check to see if we have any output from the encoder. */
while (go) {
SchroStateEnum state;
state = schro_encoder_wait(encoder);
switch (state) {
case SCHRO_STATE_HAVE_BUFFER:
case SCHRO_STATE_END_OF_STREAM:
enc_buf = schro_encoder_pull(encoder, &presentation_frame);
assert(enc_buf->length > 0);
assert(enc_buf->length <= buf_size);
parse_code = enc_buf->data[4];
/* All non-frame data is prepended to actual frame data to
* be able to set the pts correctly. So we don't write data
* to the frame output queue until we actually have a frame
*/
p_schro_params->enc_buf = av_realloc(p_schro_params->enc_buf,
p_schro_params->enc_buf_size + enc_buf->length);
memcpy(p_schro_params->enc_buf + p_schro_params->enc_buf_size,
enc_buf->data, enc_buf->length);
p_schro_params->enc_buf_size += enc_buf->length;
if (state == SCHRO_STATE_END_OF_STREAM) {
p_schro_params->eos_pulled = 1;
go = 0;
}
if (!SCHRO_PARSE_CODE_IS_PICTURE(parse_code)) {
schro_buffer_unref(enc_buf);
break;
}
/* Create output frame. */
p_frame_output = av_mallocz(sizeof(FFSchroEncodedFrame));
/* Set output data. */
p_frame_output->size = p_schro_params->enc_buf_size;
p_frame_output->p_encbuf = p_schro_params->enc_buf;
if (SCHRO_PARSE_CODE_IS_INTRA(parse_code) &&
SCHRO_PARSE_CODE_IS_REFERENCE(parse_code))
p_frame_output->key_frame = 1;
/* Parse the coded frame number from the bitstream. Bytes 14
* through 17 represesent the frame number. */
p_frame_output->frame_num = AV_RB32(enc_buf->data + 13);
ff_schro_queue_push_back(&p_schro_params->enc_frame_queue,
p_frame_output);
p_schro_params->enc_buf_size = 0;
p_schro_params->enc_buf = NULL;
schro_buffer_unref(enc_buf);
break;
case SCHRO_STATE_NEED_FRAME:
go = 0;
break;
case SCHRO_STATE_AGAIN:
break;
default:
av_log(avccontext, AV_LOG_ERROR, "Unknown Schro Encoder state\n");
return -1;
}
}
/* Copy 'next' frame in queue. */
if (p_schro_params->enc_frame_queue.size == 1 &&
p_schro_params->eos_pulled)
last_frame_in_sequence = 1;
p_frame_output = ff_schro_queue_pop(&p_schro_params->enc_frame_queue);
if (!p_frame_output)
return 0;
pkt_size = p_frame_output->size;
if (last_frame_in_sequence && p_schro_params->enc_buf_size > 0)
pkt_size += p_schro_params->enc_buf_size;
if ((ret = ff_alloc_packet(pkt, pkt_size)) < 0) {
av_log(avccontext, AV_LOG_ERROR, "Error getting output packet of size %d.\n", pkt_size);
goto error;
}
memcpy(pkt->data, p_frame_output->p_encbuf, p_frame_output->size);
avccontext->coded_frame->key_frame = p_frame_output->key_frame;
/* Use the frame number of the encoded frame as the pts. It is OK to
* do so since Dirac is a constant frame rate codec. It expects input
* to be of constant frame rate. */
pkt->pts =
avccontext->coded_frame->pts = p_frame_output->frame_num;
pkt->dts = p_schro_params->dts++;
enc_size = p_frame_output->size;
/* Append the end of sequence information to the last frame in the
* sequence. */
if (last_frame_in_sequence && p_schro_params->enc_buf_size > 0) {
memcpy(pkt->data + enc_size, p_schro_params->enc_buf,
p_schro_params->enc_buf_size);
enc_size += p_schro_params->enc_buf_size;
av_freep(&p_schro_params->enc_buf);
p_schro_params->enc_buf_size = 0;
}
if (p_frame_output->key_frame)
pkt->flags |= AV_PKT_FLAG_KEY;
*got_packet = 1;
error:
/* free frame */
libschroedinger_free_frame(p_frame_output);
return ret;
}
int test3 (void)
{
SchroBuffer *buffer = schro_buffer_new_and_alloc (1000);
SchroPack *pack;
SchroUnpack unpack;
SchroUnpack unpack2;
int i;
int ref[100];
int x;
int n_bytes;
int n_bits = 0;
int n_bits2 = 0;
memset (buffer->data, 0, 1000);
for(i=0;i<100;i++){
ref[i] = (rand()&0xff) - 128;
}
pack = schro_pack_new ();
schro_pack_encode_init (pack, buffer);
n_bits = 0;
for(i=0;i<50;i++){
schro_pack_encode_sint (pack, ref[i]);
n_bits += schro_pack_estimate_sint (ref[i]);
}
n_bits2 = 0;
for(i=50;i<100;i++){
schro_pack_encode_sint (pack, ref[i]);
n_bits2 += schro_pack_estimate_sint (ref[i]);
}
schro_pack_flush(pack);
n_bytes = schro_pack_get_offset (pack);
schro_pack_free (pack);
schro_unpack_init_with_data (&unpack, buffer->data, n_bytes, 1);
schro_unpack_copy (&unpack2, &unpack);
schro_unpack_limit_bits_remaining (&unpack, n_bits);
for(i=0;i<50;i++){
x = schro_unpack_decode_sint (&unpack);
if (x != ref[i]) {
SCHRO_ERROR("test3 failed at symbol %d (%d should be %d)", i, x, ref[i]);
schro_unpack_dump(&unpack);
return 0;
}
}
for(i=0;i<10;i++){
x = schro_unpack_decode_sint (&unpack);
if (x != 0) {
SCHRO_ERROR("test3 failed at symbol %d (%d should be 0)", i, x);
schro_unpack_dump(&unpack);
return 0;
}
}
schro_unpack_skip_bits (&unpack2, n_bits);
schro_unpack_limit_bits_remaining (&unpack2, n_bits2);
for(i=50;i<100;i++){
x = schro_unpack_decode_sint (&unpack2);
if (x != ref[i]) {
SCHRO_ERROR("test3 failed at symbol %d (%d should be %d)", i, x, ref[i]);
schro_unpack_dump(&unpack2);
return 0;
}
}
for(i=0;i<10;i++){
x = schro_unpack_decode_sint (&unpack2);
if (x != 0) {
SCHRO_ERROR("test3 failed at symbol %d (%d should be 0)", i, x);
schro_unpack_dump(&unpack2);
return 0;
}
}
schro_buffer_unref (buffer);
return 1;
}
