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); }