void
inv_test (int filter, int width, int height)
{
int i;
SchroFrame *test;
SchroFrame *orig;
SchroFrame *ref;
SchroFrameData *fd_test;
SchroFrameData *fd_orig;
SchroFrameData *fd_ref;
char name[TEST_PATTERN_NAME_SIZE] = { 0 };
orig = schro_frame_new_and_alloc (NULL, SCHRO_FRAME_FORMAT_S16_444,
width, height);
fd_orig = orig->components + 0;
test = schro_frame_new_and_alloc (NULL, SCHRO_FRAME_FORMAT_S16_444,
width, height);
fd_test = test->components + 0;
ref = schro_frame_new_and_alloc (NULL, SCHRO_FRAME_FORMAT_S16_444,
width, height);
fd_ref = ref->components + 0;
for(i=0;i<test_pattern_get_n_generators();i++){
test_pattern_generate (fd_orig, name, i);
printf(" reverse test \"%s\":\n", name);
fflush(stdout);
iwt_ref(fd_orig,filter);
schro_frame_convert (test, orig);
schro_frame_convert (ref, orig);
iiwt_ref(fd_ref,filter);
iiwt_test(fd_test,filter);
if (!frame_data_compare(fd_test, fd_ref)) {
printf(" failed\n");
if (verbose) frame_data_dump_full (fd_test, fd_ref, fd_orig);
fail = TRUE;
}
}
schro_frame_unref (orig);
schro_frame_unref (test);
schro_frame_unref (ref);
}
void
fwd_random_test_s32 (int filter, int width, int height)
{
SchroFrame *test;
SchroFrame *orig;
SchroFrame *ref;
SchroFrameData *fd_orig;
SchroFrameData *fd_test;
SchroFrameData *fd_ref;
char name[TEST_PATTERN_NAME_SIZE] = { 0 };
orig = schro_frame_new_and_alloc (NULL, SCHRO_FRAME_FORMAT_S16_444,
width, height);
fd_orig = orig->components + 0;
test = schro_frame_new_and_alloc (NULL, SCHRO_FRAME_FORMAT_S32_444,
width, height);
fd_test = test->components + 0;
ref = schro_frame_new_and_alloc (NULL, SCHRO_FRAME_FORMAT_S16_444,
width, height);
fd_ref = ref->components + 0;
test_pattern_generate (fd_orig, name, 0);
printf(" forward test 32-bit \"%s\":\n", name);
fflush(stdout);
schro_frame_convert (ref, orig);
schro_frame_convert (test, orig);
iwt_ref(fd_ref,filter);
iwt_test(fd_test,filter);
if (!frame_data_compare(fd_test, fd_ref)) {
printf(" failed\n");
if (verbose) frame_data_dump_full (fd_test, fd_ref, fd_orig);
fail = TRUE;
}
schro_frame_unref (orig);
schro_frame_unref (test);
schro_frame_unref (ref);
}
static void resync_schroedinger(bgav_stream_t * s)
{
schroedinger_priv_t * priv;
priv = s->decoder_priv;
/* TODO: Skip non-keyframes and update out_time */
schro_decoder_reset(priv->dec);
bgav_pts_cache_clear(&priv->pc);
if(priv->dec_frame)
{
schro_frame_unref(priv->dec_frame);
priv->dec_frame = NULL;
}
priv->eof = 0;
priv->buffer_size = 0;
priv->last_pts = GAVL_TIME_UNDEFINED;
}
static gavl_source_status_t
decode_schroedinger(bgav_stream_t * s, gavl_video_frame_t * frame)
{
gavl_source_status_t st;
schroedinger_priv_t * priv;
priv = s->decoder_priv;
if(!priv->dec_frame && ((st = decode_picture(s)) != GAVL_SOURCE_OK))
return st;
/* Copy frame */
// fprintf(stderr, "Decode schroedinger %p\n", frame);
// if(frame)
// {
priv->frame->planes[0] = priv->dec_frame->components[0].data;
priv->frame->planes[1] = priv->dec_frame->components[1].data;
priv->frame->planes[2] = priv->dec_frame->components[2].data;
priv->frame->strides[0] = priv->dec_frame->components[0].stride;
priv->frame->strides[1] = priv->dec_frame->components[1].stride;
priv->frame->strides[2] = priv->dec_frame->components[2].stride;
// gavl_video_frame_copy(&s->data.video.format,
// frame, priv->frame);
bgav_pts_cache_get_first(&priv->pc, priv->frame);
// }
// else
// bgav_pts_cache_get_first(&priv->pc, NULL);
schro_frame_unref(priv->dec_frame);
priv->dec_frame = NULL;
return GAVL_SOURCE_OK;
}
static void libschroedinger_decode_frame_free(void *frame)
{
schro_frame_unref(frame);
}
int
main (int argc, char *argv[])
{
SchroFrame *dest;
SchroFrame *dest_u8;
SchroFrame *ref;
SchroUpsampledFrame *uref;
SchroParams params;
SchroVideoFormat video_format;
SchroMotionVector *motion_vectors;
int i,j;
schro_init();
video_format.width = 720;
video_format.height = 480;
video_format.chroma_format = SCHRO_CHROMA_420;
schro_video_format_validate (&video_format);
params.video_format = &video_format;
params.xbsep_luma = 8;
params.ybsep_luma = 8;
params.xblen_luma = 12;
params.yblen_luma = 12;
schro_params_calculate_mc_sizes(¶ms);
dest = schro_frame_new_and_alloc (NULL, SCHRO_FRAME_FORMAT_S16_420,
video_format.width, video_format.height);
ref = schro_frame_new_and_alloc (NULL, SCHRO_FRAME_FORMAT_U8_420,
video_format.width, video_format.height);
dest_u8 = schro_frame_new_and_alloc (NULL, SCHRO_FRAME_FORMAT_U8_420,
video_format.width, video_format.height);
schro_frame_clear(dest);
schro_frame_create_pattern(ref,1);
motion_vectors = malloc(sizeof(SchroMotionVector) *
params.x_num_blocks * params.y_num_blocks);
memset (motion_vectors, 0, sizeof(SchroMotionVector) *
params.x_num_blocks * params.y_num_blocks);
printf("sizeof(SchroMotionVector) = %lu\n",(unsigned long) sizeof(SchroMotionVector));
printf("num blocks %d x %d\n", params.x_num_blocks, params.y_num_blocks);
for(j=0;j<params.y_num_blocks;j++){
int jj;
jj = j * params.x_num_blocks;
for(i=0;i<params.x_num_blocks;i++){
#if 0
if (i == 0 || i == 2 || i == params.x_num_blocks*2) {
motion_vectors[jj+i].u.dc[0] = 100;
motion_vectors[jj+i].u.dc[1] = 100;
motion_vectors[jj+i].u.dc[2] = 0;
motion_vectors[jj+i].pred_mode = 0;
} else {
motion_vectors[jj+i].u.dc[0] = 0;
motion_vectors[jj+i].u.dc[1] = 0;
motion_vectors[jj+i].u.dc[2] = 0;
motion_vectors[jj+i].pred_mode = 0;
}
#endif
motion_vectors[jj+i].dx[0] = 0;
motion_vectors[jj+i].dy[0] = -8*i;
motion_vectors[jj+i].pred_mode = 1;
motion_vectors[jj+i].split = 2;
}
}
uref = schro_upsampled_frame_new (ref);
{
SchroMotion motion;
motion.src1 = uref;
motion.src2 = NULL;
motion.motion_vectors = motion_vectors;
motion.params = ¶ms;
schro_motion_render (&motion, dest);
}
schro_frame_convert (dest_u8, dest);
schro_frame_dump (dest_u8);
//schro_frame_compare (ref, dest_u8);
schro_upsampled_frame_free (uref);
schro_frame_unref (dest);
schro_frame_unref (dest_u8);
free (motion_vectors);
return 0;
}
void
decode (FILE *file)
{
SchroDecoder *decoder;
SchroBuffer *buffer;
SchroVideoFormat *format = NULL;
SchroFrame *frame;
int picture_number;
int go;
int it;
int eos = FALSE;
void *packet;
int size;
int ret;
int parse_code;
decoder = schro_decoder_new();
schro_decoder_set_picture_order (decoder, SCHRO_DECODER_PICTURE_ORDER_CODED);
while(!eos) {
ret = parse_packet (file, &packet, &size);
if (!ret) {
exit(1);
}
if (size == 0) {
schro_decoder_push_end_of_stream (decoder);
} else {
parse_code = ((uint8_t *)packet)[4];
buffer = schro_buffer_new_with_data (packet, size);
buffer->free = buffer_free;
buffer->priv = packet;
printf("pushing 0x%02x size %d\n", parse_code, size);
if (SCHRO_PARSE_CODE_IS_PICTURE (parse_code)) {
frame = schro_frame_new_and_alloc (NULL,
schro_params_get_frame_format(8, format->chroma_format),
format->width, format->height);
schro_decoder_add_output_picture (decoder, frame);
}
it = schro_decoder_push (decoder, buffer);
if (it == SCHRO_DECODER_FIRST_ACCESS_UNIT) {
format = schro_decoder_get_video_format (decoder);
}
if (!SCHRO_PARSE_CODE_IS_PICTURE (parse_code)) {
continue;
}
}
go = 1;
while (go) {
it = schro_decoder_wait (decoder);
switch (it) {
case SCHRO_DECODER_NEED_BITS:
go = 0;
break;
case SCHRO_DECODER_NEED_FRAME:
frame = schro_frame_new_and_alloc (NULL,
schro_params_get_frame_format(8, format->chroma_format),
format->width, format->height);
schro_decoder_add_output_picture (decoder, frame);
break;
case SCHRO_DECODER_OK:
picture_number = schro_decoder_get_picture_number (decoder);
frame = schro_decoder_pull (decoder);
printf("got frame %p, picture number %d\n", frame,
picture_number);
if (frame) {
schro_frame_unref (frame);
}
go = 0;
break;
case SCHRO_DECODER_EOS:
printf("got eos\n");
eos = TRUE;
go = 0;
break;
case SCHRO_DECODER_STALLED:
printf("stall\n");
go = 0;
break;
case SCHRO_DECODER_ERROR:
exit(0);
break;
}
}
}
printf("freeing decoder\n");
schro_decoder_free (decoder);
free(format);
}
int
main (int argc, char *argv[])
{
SchroFrame *dest;
SchroFrame *ref;
SchroUpsampledFrame *uref;
SchroParams params;
SchroVideoFormat video_format;
SchroMotionVector *motion_vectors;
int i;
int j;
OilProfile prof;
double ave, std;
schro_init();
video_format.width = 720;
video_format.height = 480;
video_format.chroma_format = SCHRO_CHROMA_420;
schro_video_format_validate (&video_format);
params.video_format = &video_format;
params.xbsep_luma = 8;
params.ybsep_luma = 8;
params.xblen_luma = 12;
params.yblen_luma = 12;
schro_params_calculate_mc_sizes(¶ms);
dest = schro_frame_new_and_alloc (NULL, SCHRO_FRAME_FORMAT_S16_420,
video_format.width, video_format.height);
schro_frame_clear(dest);
ref = schro_frame_new_and_alloc (NULL, SCHRO_FRAME_FORMAT_U8_420,
video_format.width, video_format.height);
schro_frame_clear(ref);
uref = schro_upsampled_frame_new (ref);
schro_upsampled_frame_upsample (uref);
motion_vectors = malloc(sizeof(SchroMotionVector) *
params.x_num_blocks * params.y_num_blocks);
memset (motion_vectors, 0, sizeof(SchroMotionVector) *
params.x_num_blocks * params.y_num_blocks);
printf("sizeof(SchroMotionVector) = %lu\n",(unsigned long) sizeof(SchroMotionVector));
printf("num blocks %d x %d\n", params.x_num_blocks, params.y_num_blocks);
for(i=0;i<params.x_num_blocks*params.y_num_blocks;i++){
motion_vectors[i].dx[0] = 0;
motion_vectors[i].dy[0] = 0;
motion_vectors[i].pred_mode = 1;
motion_vectors[i].split = 2;
}
for(i=0;i<10;i++){
oil_profile_init (&prof);
for(j=0;j<10;j++){
SchroMotion motion;
motion.src1 = uref;
motion.src2 = NULL;
motion.motion_vectors = motion_vectors;
motion.params = ¶ms;
oil_profile_start(&prof);
schro_motion_render (&motion, dest);
oil_profile_stop(&prof);
}
oil_profile_get_ave_std (&prof, &ave, &std);
printf("cycles %g %g\n", ave, std);
}
schro_upsampled_frame_free (uref);
schro_frame_unref (dest);
free (motion_vectors);
return 0;
}
static GstFlowReturn
gst_schrodownsample_transform (GstBaseTransform * base_transform,
GstBuffer *inbuf, GstBuffer *outbuf)
{
GstSchrodownsample *compress;
SchroFrame *outframe;
int width, height;
uint32_t format;
SchroFrame *stack[10];
int n = 0;
g_return_val_if_fail (GST_IS_SCHRODOWNSAMPLE (base_transform), GST_FLOW_ERROR);
compress = GST_SCHRODOWNSAMPLE (base_transform);
gst_structure_get_fourcc (gst_caps_get_structure(inbuf->caps, 0),
"format", &format);
gst_structure_get_int (gst_caps_get_structure(inbuf->caps, 0),
"width", &width);
gst_structure_get_int (gst_caps_get_structure(inbuf->caps, 0),
"height", &height);
switch (format) {
case GST_MAKE_FOURCC('I','4','2','0'):
stack[n] = schro_frame_new_from_data_I420 (GST_BUFFER_DATA(inbuf),
width, height);
n++;
outframe = schro_frame_new_from_data_I420 (GST_BUFFER_DATA(outbuf),
width/2, height/2);
break;
case GST_MAKE_FOURCC('Y','V','1','2'):
stack[n] = schro_frame_new_from_data_YV12 (GST_BUFFER_DATA(inbuf),
width, height);
n++;
outframe = schro_frame_new_from_data_YV12 (GST_BUFFER_DATA(outbuf),
width/2, height/2);
break;
case GST_MAKE_FOURCC('Y','U','Y','2'):
stack[n] = schro_frame_new_from_data_YUY2 (GST_BUFFER_DATA(inbuf),
width, height);
n++;
stack[n] = schro_virt_frame_new_unpack (stack[n-1]);
n++;
outframe = schro_frame_new_from_data_YUY2 (GST_BUFFER_DATA(outbuf),
width/2, height/2);
break;
case GST_MAKE_FOURCC('U','Y','V','Y'):
stack[n] = schro_frame_new_from_data_UYVY (GST_BUFFER_DATA(inbuf),
width, height);
n++;
stack[n] = schro_virt_frame_new_unpack (stack[n-1]);
n++;
outframe = schro_frame_new_from_data_UYVY (GST_BUFFER_DATA(outbuf),
width/2, height/2);
break;
case GST_MAKE_FOURCC('A','Y','U','V'):
stack[n] = schro_frame_new_from_data_AYUV (GST_BUFFER_DATA(inbuf),
width, height);
n++;
stack[n] = schro_virt_frame_new_unpack (stack[n-1]);
n++;
outframe = schro_frame_new_from_data_AYUV (GST_BUFFER_DATA(outbuf),
width/2, height/2);
break;
default:
g_assert_not_reached();
}
stack[n] = schro_virt_frame_new_horiz_downsample (stack[n-1]);
n++;
stack[n] = schro_virt_frame_new_vert_downsample (stack[n-1]);
n++;
switch (format) {
case GST_MAKE_FOURCC('Y','U','Y','2'):
stack[n] = schro_virt_frame_new_pack_YUY2 (stack[n-1]);
n++;
break;
case GST_MAKE_FOURCC('U','Y','V','Y'):
stack[n] = schro_virt_frame_new_pack_UYVY (stack[n-1]);
n++;
break;
case GST_MAKE_FOURCC('A','Y','U','V'):
stack[n] = schro_virt_frame_new_pack_AYUV (stack[n-1]);
n++;
break;
default:
break;
}
schro_virt_frame_render (stack[n-1], outframe);
while(n>0) {
schro_frame_unref (stack[n-1]);
n--;
}
return GST_FLOW_OK;
}
static bool
RunTest(int bit_depth)
{
bool result = true;
const int seq_len = 5;
const int width = 100;
const int height = 10;
int luma_min = 16;
int luma_max = 235;
int chroma_zero = 128;
schro_init();
// set up encoder
SchroEncoder *encoder = schro_encoder_new();
schro_encoder_setting_set_double(encoder, "gop_structure", SCHRO_ENCODER_GOP_INTRA_ONLY);
schro_encoder_setting_set_double(encoder, "rate_control", SCHRO_ENCODER_RATE_CONTROL_LOSSLESS);
//schro_encoder_setting_set_double(encoder, "force_profile", SCHRO_ENCODER_PROFILE_VC2_SIMPLE);
//schro_encoder_setting_set_double(encoder, "queue_depth", seq_len);
//assert(seq_len <= SCHRO_LIMIT_FRAME_QUEUE_LENGTH);
SchroVideoFormat *format = schro_encoder_get_video_format(encoder);
if(format)
{
format->width = width;
format->height = height;
format->clean_width = format->width;
format->clean_height = format->height;
format->left_offset = 0;
format->top_offset = 0;
format->chroma_format = SCHRO_CHROMA_444;
const SchroSignalRange range = (bit_depth == 12 ? SCHRO_SIGNAL_RANGE_12BIT_VIDEO :
bit_depth == 10 ? SCHRO_SIGNAL_RANGE_10BIT_VIDEO :
SCHRO_SIGNAL_RANGE_8BIT_VIDEO);
schro_video_format_set_std_signal_range(format, range);
luma_min = format->luma_offset;
luma_max = format->luma_offset + format->luma_excursion;
chroma_zero = format->chroma_offset;
format->colour_primaries = SCHRO_COLOUR_PRIMARY_HDTV;
format->colour_matrix = SCHRO_COLOUR_MATRIX_HDTV;
format->transfer_function = SCHRO_TRANSFER_CHAR_TV_GAMMA;
format->interlaced = false;
format->frame_rate_numerator = 24;
format->frame_rate_denominator = 1;
format->aspect_ratio_numerator = 1;
format->aspect_ratio_denominator = 1;
schro_encoder_set_video_format(encoder, format);
free(format);
}
else
return false;
schro_encoder_start(encoder);
// create frame
SchroFrame *start_frame = schro_frame_new_and_alloc(NULL, SCHRO_FRAME_FORMAT_U8_444, width, height);
FillFrame<unsigned char>(start_frame, 16, 235, 128);
const SchroFrameFormat schro_format = (bit_depth > 8 ? SCHRO_FRAME_FORMAT_S16_444 : SCHRO_FRAME_FORMAT_U8_444);
SchroFrame *original_frame = schro_frame_new_and_alloc(NULL, schro_format, width, height);
schro_frame_convert(original_frame, start_frame);
SchroDecoder *decoder = schro_decoder_new();
// push frames to encoder
for(int t = 0; t < seq_len; t++)
{
SchroFrame *new_frame = schro_frame_dup(original_frame);
schro_encoder_push_frame(encoder, new_frame);
}
// pull packets out of encoder, pass to decoder
int packets_out = 0;
while(packets_out < seq_len)
{
SchroStateEnum encoder_state = schro_encoder_wait(encoder);
if(encoder_state == SCHRO_STATE_HAVE_BUFFER || encoder_state == SCHRO_STATE_END_OF_STREAM)
{
int n_decodable_frames = -1;
SchroBuffer *buffer = schro_encoder_pull(encoder, &n_decodable_frames);
if(buffer)
{
const int parse_code = buffer->data[4];
if(SCHRO_PARSE_CODE_IS_SEQ_HEADER(parse_code) ||
SCHRO_PARSE_CODE_IS_AUXILIARY_DATA(parse_code) ||
SCHRO_PARSE_CODE_IS_PICTURE(parse_code))
{
schro_decoder_push(decoder, buffer);
//schro_buffer_unref(buffer);
if(SCHRO_PARSE_CODE_IS_PICTURE(parse_code))
{
packets_out++;
}
}
}
}
else
{
assert(encoder_state == SCHRO_STATE_NEED_FRAME);
assert(encoder_state != SCHRO_STATE_AGAIN); // yeah, redundant
schro_encoder_end_of_stream(encoder);
}
}
// pull frames out of decoder
int frames_out = 0;
while(frames_out < seq_len)
{
int decoder_state = schro_decoder_wait(decoder);
if(decoder_state == SCHRO_DECODER_FIRST_ACCESS_UNIT)
{
SchroVideoFormat *format = schro_decoder_get_video_format(decoder);
if(format)
{
assert(format->width == width);
assert(format->height == height);
assert(format->chroma_format == SCHRO_CHROMA_444);
assert(format->luma_offset == luma_min);
assert(format->luma_offset + format->luma_excursion == luma_max);
assert(format->chroma_offset = chroma_zero);
free(format);
}
}
else if(decoder_state == SCHRO_DECODER_NEED_BITS)
{
schro_decoder_push_end_of_stream(decoder);
}
else if(decoder_state == SCHRO_DECODER_NEED_FRAME)
{
SchroFrame *decoder_frame = schro_frame_new_and_alloc(NULL, schro_format, width, height);
schro_decoder_add_output_picture(decoder, decoder_frame);
}
else if(decoder_state == SCHRO_DECODER_OK || decoder_state == SCHRO_DECODER_EOS)
{
SchroFrame *decoder_frame = schro_decoder_pull(decoder);
if(decoder_frame)
{
frames_out++;
bool match = CompareFrames(decoder_frame, original_frame);
//std::cout << (match ? "Match!" : "No Match!") << " " << std::endl;
if(!match)
{
// output doesn't match input, so print the values of the
// first line of the first component to see what went in and out
PrintFirstLine(original_frame);
std::cout << "==========" << std::endl;
PrintFirstLine(decoder_frame);
std::cout << "==========" << std::endl;
result = false;
}
schro_frame_unref(decoder_frame);
}
}
}
schro_frame_unref(original_frame);
schro_frame_unref(start_frame);
schro_decoder_free(decoder);
schro_encoder_free(encoder);
return result;
}
static GstFlowReturn
gst_schro_dec_process_buffer (GstSchroDec *schro_dec, SchroBuffer *input_buffer)
{
GstFlowReturn ret = GST_FLOW_OK;
SchroFrame *frame;
int size;
int earliest_frame;
GstBuffer *outbuf;
int go = 1;
if (input_buffer) {
ret = schro_decoder_push (schro_dec->decoder, input_buffer);
if (ret == SCHRO_DECODER_FIRST_ACCESS_UNIT) {
handle_first_access_unit (schro_dec);
}
} else {
ret = schro_decoder_push_end_of_stream (schro_dec->decoder);
}
if (schro_dec->have_access_unit) {
earliest_frame = gst_util_uint64_scale (
schro_dec->earliest_time - schro_dec->segment.start,
schro_dec->fps_n, schro_dec->fps_d * GST_SECOND);
GST_DEBUG("earliest frame %d", earliest_frame);
schro_decoder_set_earliest_frame (schro_dec->decoder, earliest_frame);
schro_decoder_set_skip_ratio (schro_dec->decoder,
1/schro_dec->proportion);
}
while (go) {
int it;
it = schro_decoder_wait (schro_dec->decoder);
switch (it) {
case SCHRO_DECODER_FIRST_ACCESS_UNIT:
handle_first_access_unit (schro_dec);
break;
case SCHRO_DECODER_NEED_BITS:
go = 0;
break;
case SCHRO_DECODER_NEED_FRAME:
size = get_buffer_size (schro_dec);
ret = gst_pad_alloc_buffer_and_set_caps (schro_dec->srcpad,
GST_BUFFER_OFFSET_NONE, size,
GST_PAD_CAPS (schro_dec->srcpad), &outbuf);
if (ret != GST_FLOW_OK) {
GST_DEBUG("could not allocate buffer for pad");
return ret;
}
frame = gst_schro_wrap_frame (schro_dec, outbuf);
schro_decoder_add_output_picture (schro_dec->decoder, frame);
break;
case SCHRO_DECODER_OK:
frame = schro_decoder_pull (schro_dec->decoder);
if (frame) {
if (frame->priv) {
outbuf = frame->priv;
if (schro_dec->discont) {
GST_DEBUG("discont timestamp %" G_GINT64_FORMAT,
GST_BUFFER_TIMESTAMP(outbuf));
GST_BUFFER_FLAG_SET (outbuf, GST_BUFFER_FLAG_DISCONT);
schro_dec->discont = FALSE;
}
GST_BUFFER_TIMESTAMP(outbuf) = gst_util_uint64_scale (
schro_dec->n_frames, schro_dec->fps_d * GST_SECOND,
schro_dec->fps_n) +
schro_dec->timestamp_offset;
GST_BUFFER_DURATION(outbuf) = gst_util_uint64_scale_int (GST_SECOND,
schro_dec->fps_d, schro_dec->fps_n);
gst_buffer_ref(outbuf);
ret = gst_pad_push (schro_dec->srcpad, outbuf);
if (ret != GST_FLOW_OK)
return ret;
} else {
GST_DEBUG("skipped frame %d", schro_dec->n_frames);
}
schro_dec->n_frames++;
schro_frame_unref (frame);
}
break;
case SCHRO_DECODER_EOS:
go = FALSE;
break;
case SCHRO_DECODER_ERROR:
go = FALSE;
GST_ERROR ("codec error");
ret = GST_FLOW_ERROR;
break;
}
}
return ret;
}
int
main (int argc, char *argv[])
{
SchroFrame *dest;
SchroFrame *ref;
SchroFrame *addframe;
SchroParams params;
SchroVideoFormat video_format;
SchroMotionVector *motion_vectors;
int i;
int j;
OrcProfile prof;
double ave, std;
schro_init();
memset (&video_format, 0, sizeof(video_format));
memset (¶ms, 0, sizeof(params));
schro_video_format_set_std_video_format (&video_format,
SCHRO_VIDEO_FORMAT_CUSTOM);
video_format.width = 720;
video_format.height = 480;
video_format.chroma_format = SCHRO_CHROMA_420;
schro_video_format_validate (&video_format);
params.video_format = &video_format;
params.xbsep_luma = 8;
params.ybsep_luma = 8;
params.xblen_luma = 12;
params.yblen_luma = 12;
schro_params_calculate_mc_sizes(¶ms);
dest = schro_frame_new_and_alloc (NULL, SCHRO_FRAME_FORMAT_S16_420,
video_format.width, video_format.height);
schro_frame_clear(dest);
ref = schro_frame_new_and_alloc_extended (NULL, SCHRO_FRAME_FORMAT_U8_420,
video_format.width, video_format.height, 32);
schro_frame_clear(ref);
addframe = schro_frame_new_and_alloc (NULL, SCHRO_FRAME_FORMAT_S16_420,
video_format.width, video_format.height);
schro_frame_clear(addframe);
schro_upsampled_frame_upsample (ref);
motion_vectors = malloc(sizeof(SchroMotionVector) *
params.x_num_blocks * params.y_num_blocks);
memset (motion_vectors, 0, sizeof(SchroMotionVector) *
params.x_num_blocks * params.y_num_blocks);
printf("sizeof(SchroMotionVector) = %lu\n",(unsigned long) sizeof(SchroMotionVector));
printf("num blocks %d x %d\n", params.x_num_blocks, params.y_num_blocks);
for(i=0;i<params.x_num_blocks*params.y_num_blocks;i++){
motion_vectors[i].u.vec.dx[0] = 0;
motion_vectors[i].u.vec.dy[0] = 0;
motion_vectors[i].pred_mode = 1;
motion_vectors[i].split = 2;
}
for(i=0;i<10;i++){
orc_profile_init (&prof);
for(j=0;j<10;j++){
SchroMotion *motion;
void *mv_save;
motion = schro_motion_new (¶ms, ref, NULL);
mv_save = motion->motion_vectors;
motion->motion_vectors = motion_vectors;
orc_profile_start(&prof);
schro_motion_render (motion, dest, addframe, FALSE, NULL);
orc_profile_stop(&prof);
motion->motion_vectors = mv_save;
schro_motion_free (motion);
}
orc_profile_get_ave_std (&prof, &ave, &std);
printf("cycles %g %g\n", ave, std);
}
schro_frame_unref (ref);
schro_frame_unref (dest);
free (motion_vectors);
return 0;
}
void
decode (FILE *file)
{
SchroDecoder *decoder;
SchroBuffer *buffer;
SchroVideoFormat *format = NULL;
SchroFrame *frame;
int go;
int it;
int eos = FALSE;
void *packet;
int size;
int ret;
decoder = schro_decoder_new();
while(!eos) {
ret = parse_packet (file, &packet, &size);
if (!ret) {
exit(1);
}
if (size == 0) {
schro_decoder_push_end_of_stream (decoder);
} else {
buffer = schro_buffer_new_with_data (packet, size);
buffer->free = buffer_free;
buffer->priv = packet;
it = schro_decoder_push (decoder, buffer);
if (it == SCHRO_DECODER_FIRST_ACCESS_UNIT) {
format = schro_decoder_get_video_format (decoder);
}
}
go = 1;
while (go) {
it = schro_decoder_wait (decoder);
switch (it) {
case SCHRO_DECODER_NEED_BITS:
go = 0;
break;
case SCHRO_DECODER_NEED_FRAME:
frame = schro_frame_new_and_alloc (NULL,
schro_params_get_frame_format(8, format->chroma_format),
format->width, format->height);
schro_decoder_add_output_picture (decoder, frame);
break;
case SCHRO_DECODER_OK:
frame = schro_decoder_pull (decoder);
//printf("got frame %p\n", frame);
if (frame) {
//printf("picture number %d\n",
// schro_decoder_get_picture_number (decoder) - 1);
schro_frame_unref (frame);
}
break;
case SCHRO_DECODER_EOS:
printf("got eos\n");
eos = TRUE;
go = 0;
break;
case SCHRO_DECODER_ERROR:
exit(0);
break;
}
}
}
printf("freeing decoder\n");
schro_decoder_free (decoder);
free(format);
}
