Beispiel #1
0
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);
}
Beispiel #2
0
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);
}
Beispiel #3
0
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;
  }
Beispiel #4
0
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);
}
Beispiel #6
0
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(&params);

  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 = &params;
    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;
}
Beispiel #7
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);
}
Beispiel #8
0
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(&params);

  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 = &params;
      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;
}
Beispiel #9
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;
}
Beispiel #10
0
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;
}
Beispiel #11
0
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;
}
Beispiel #12
0
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 (&params, 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(&params);

  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 (&params, 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;
}
Beispiel #13
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);
}