mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2025-06-05 06:58:56 +00:00
Code Issues 1 Projects Releases Wiki Activity

basevideo: Move common fields/functions to basecodec

Browse source
This commit is contained in:
David Schleef 2010-10-09 17:36:07 -07:00
parent 18c3302608
commit fe50055715
10 changed files with 250 additions and 220 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

26
ext/dirac/gstdiracenc.cc
View file

@ -1247,7 +1247,7 @@ gst_dirac_enc_shape_output_ogg (GstBaseVideoEncoder * base_video_encoder,
GST_BUFFER_OFFSET_END (buf) = dirac_enc->last_granulepos; GST_BUFFER_OFFSET_END (buf) = dirac_enc->last_granulepos;
} }
gst_buffer_set_caps (buf, base_video_encoder->caps); gst_buffer_set_caps (buf, GST_BASE_VIDEO_CODEC(base_video_encoder)->caps);
return gst_pad_push (GST_BASE_VIDEO_CODEC_SRC_PAD (base_video_encoder), buf); return gst_pad_push (GST_BASE_VIDEO_CODEC_SRC_PAD (base_video_encoder), buf);
} }
@ -1262,12 +1262,12 @@ gst_dirac_enc_shape_output_quicktime (GstBaseVideoEncoder * base_video_encoder,
state = gst_base_video_encoder_get_state (base_video_encoder); state = gst_base_video_encoder_get_state (base_video_encoder);
GST_BUFFER_TIMESTAMP (buf) = gst_video_state_get_timestamp (state, GST_BUFFER_TIMESTAMP (buf) = gst_video_state_get_timestamp (state,
&base_video_encoder->segment, frame->presentation_frame_number); &GST_BASE_VIDEO_CODEC(base_video_encoder)->segment, frame->presentation_frame_number);
GST_BUFFER_DURATION (buf) = gst_video_state_get_timestamp (state, GST_BUFFER_DURATION (buf) = gst_video_state_get_timestamp (state,
&base_video_encoder->segment, &GST_BASE_VIDEO_CODEC(base_video_encoder)->segment,
frame->presentation_frame_number + 1) - GST_BUFFER_TIMESTAMP (buf); frame->presentation_frame_number + 1) - GST_BUFFER_TIMESTAMP (buf);
GST_BUFFER_OFFSET_END (buf) = GST_BUFFER_OFFSET_END (buf) = gst_video_state_get_timestamp (state,
gst_video_state_get_timestamp (state, &base_video_encoder->segment, &GST_BASE_VIDEO_CODEC(base_video_encoder)->segment,
frame->system_frame_number); frame->system_frame_number);
GST_BUFFER_OFFSET (buf) = GST_CLOCK_TIME_NONE; GST_BUFFER_OFFSET (buf) = GST_CLOCK_TIME_NONE;
@ -1278,7 +1278,7 @@ gst_dirac_enc_shape_output_quicktime (GstBaseVideoEncoder * base_video_encoder,
GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_DELTA_UNIT); GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_DELTA_UNIT);
} }
gst_buffer_set_caps (buf, base_video_encoder->caps); gst_buffer_set_caps (buf, GST_BASE_VIDEO_CODEC(base_video_encoder)->caps);
return gst_pad_push (GST_BASE_VIDEO_CODEC_SRC_PAD (base_video_encoder), buf); return gst_pad_push (GST_BASE_VIDEO_CODEC_SRC_PAD (base_video_encoder), buf);
} }
@ -1293,17 +1293,19 @@ gst_dirac_enc_shape_output_mp4 (GstBaseVideoEncoder * base_video_encoder,
state = gst_base_video_encoder_get_state (base_video_encoder); state = gst_base_video_encoder_get_state (base_video_encoder);
GST_BUFFER_TIMESTAMP (buf) = gst_video_state_get_timestamp (state, GST_BUFFER_TIMESTAMP (buf) = gst_video_state_get_timestamp (state,
&base_video_encoder->segment, frame->presentation_frame_number); &GST_BASE_VIDEO_CODEC(base_video_encoder)->segment,
frame->presentation_frame_number);
GST_BUFFER_DURATION (buf) = gst_video_state_get_timestamp (state, GST_BUFFER_DURATION (buf) = gst_video_state_get_timestamp (state,
&base_video_encoder->segment, &GST_BASE_VIDEO_CODEC(base_video_encoder)->segment,
frame->presentation_frame_number + 1) - GST_BUFFER_TIMESTAMP (buf); frame->presentation_frame_number + 1) - GST_BUFFER_TIMESTAMP (buf);
GST_BUFFER_OFFSET_END (buf) = GST_BUFFER_OFFSET_END (buf) = gst_video_state_get_timestamp (state,
gst_video_state_get_timestamp (state, &base_video_encoder->segment, &GST_BASE_VIDEO_CODEC(base_video_encoder)->segment,
frame->decode_frame_number); frame->decode_frame_number);
GST_BUFFER_OFFSET (buf) = GST_CLOCK_TIME_NONE; GST_BUFFER_OFFSET (buf) = GST_CLOCK_TIME_NONE;
GST_BUFFER_OFFSET_END (buf) = gst_video_state_get_timestamp (state, GST_BUFFER_OFFSET_END (buf) = gst_video_state_get_timestamp (state,
&base_video_encoder->segment, frame->system_frame_number); &GST_BASE_VIDEO_CODEC(base_video_encoder)->segment,
frame->system_frame_number);
if (frame->is_sync_point && if (frame->is_sync_point &&
frame->presentation_frame_number == frame->system_frame_number) { frame->presentation_frame_number == frame->system_frame_number) {
@ -1312,7 +1314,7 @@ gst_dirac_enc_shape_output_mp4 (GstBaseVideoEncoder * base_video_encoder,
GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_DELTA_UNIT); GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_DELTA_UNIT);
} }
gst_buffer_set_caps (buf, base_video_encoder->caps); gst_buffer_set_caps (buf, GST_BASE_VIDEO_CODEC(base_video_encoder)->caps);
return gst_pad_push (GST_BASE_VIDEO_CODEC_SRC_PAD (base_video_encoder), buf); return gst_pad_push (GST_BASE_VIDEO_CODEC_SRC_PAD (base_video_encoder), buf);
} }

25
ext/schroedinger/gstschroenc.c
View file

@ -641,7 +641,7 @@ gst_schro_enc_shape_output_ogg (GstBaseVideoEncoder * base_video_encoder,
GST_BUFFER_OFFSET_END (buf) = schro_enc->last_granulepos; GST_BUFFER_OFFSET_END (buf) = schro_enc->last_granulepos;
} }
gst_buffer_set_caps (buf, base_video_encoder->caps); gst_buffer_set_caps (buf, GST_BASE_VIDEO_CODEC (base_video_encoder)->caps);
return gst_pad_push (GST_BASE_VIDEO_CODEC_SRC_PAD (base_video_encoder), buf); return gst_pad_push (GST_BASE_VIDEO_CODEC_SRC_PAD (base_video_encoder), buf);
} }
@ -656,12 +656,14 @@ gst_schro_enc_shape_output_quicktime (GstBaseVideoEncoder * base_video_encoder,
state = gst_base_video_encoder_get_state (base_video_encoder); state = gst_base_video_encoder_get_state (base_video_encoder);
GST_BUFFER_TIMESTAMP (buf) = gst_video_state_get_timestamp (state, GST_BUFFER_TIMESTAMP (buf) = gst_video_state_get_timestamp (state,
&base_video_encoder->segment, frame->presentation_frame_number); &GST_BASE_VIDEO_CODEC (base_video_encoder)->segment,
frame->presentation_frame_number);
GST_BUFFER_DURATION (buf) = gst_video_state_get_timestamp (state, GST_BUFFER_DURATION (buf) = gst_video_state_get_timestamp (state,
&base_video_encoder->segment, &GST_BASE_VIDEO_CODEC (base_video_encoder)->segment,
frame->presentation_frame_number + 1) - GST_BUFFER_TIMESTAMP (buf); frame->presentation_frame_number + 1) - GST_BUFFER_TIMESTAMP (buf);
GST_BUFFER_OFFSET_END (buf) = gst_video_state_get_timestamp (state, GST_BUFFER_OFFSET_END (buf) = gst_video_state_get_timestamp (state,
&base_video_encoder->segment, frame->system_frame_number); &GST_BASE_VIDEO_CODEC (base_video_encoder)->segment,
frame->system_frame_number);
GST_BUFFER_OFFSET (buf) = GST_CLOCK_TIME_NONE; GST_BUFFER_OFFSET (buf) = GST_CLOCK_TIME_NONE;
if (frame->is_sync_point && if (frame->is_sync_point &&
@ -671,7 +673,7 @@ gst_schro_enc_shape_output_quicktime (GstBaseVideoEncoder * base_video_encoder,
GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_DELTA_UNIT); GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_DELTA_UNIT);
} }
gst_buffer_set_caps (buf, base_video_encoder->caps); gst_buffer_set_caps (buf, GST_BASE_VIDEO_CODEC (base_video_encoder)->caps);
return gst_pad_push (GST_BASE_VIDEO_CODEC_SRC_PAD (base_video_encoder), buf); return gst_pad_push (GST_BASE_VIDEO_CODEC_SRC_PAD (base_video_encoder), buf);
} }
@ -686,16 +688,19 @@ gst_schro_enc_shape_output_mp4 (GstBaseVideoEncoder * base_video_encoder,
state = gst_base_video_encoder_get_state (base_video_encoder); state = gst_base_video_encoder_get_state (base_video_encoder);
GST_BUFFER_TIMESTAMP (buf) = gst_video_state_get_timestamp (state, GST_BUFFER_TIMESTAMP (buf) = gst_video_state_get_timestamp (state,
&base_video_encoder->segment, frame->presentation_frame_number); &GST_BASE_VIDEO_CODEC (base_video_encoder)->segment,
frame->presentation_frame_number);
GST_BUFFER_DURATION (buf) = gst_video_state_get_timestamp (state, GST_BUFFER_DURATION (buf) = gst_video_state_get_timestamp (state,
&base_video_encoder->segment, &GST_BASE_VIDEO_CODEC (base_video_encoder)->segment,
frame->presentation_frame_number + 1) - GST_BUFFER_TIMESTAMP (buf); frame->presentation_frame_number + 1) - GST_BUFFER_TIMESTAMP (buf);
GST_BUFFER_OFFSET_END (buf) = gst_video_state_get_timestamp (state, GST_BUFFER_OFFSET_END (buf) = gst_video_state_get_timestamp (state,
&base_video_encoder->segment, frame->decode_frame_number); &GST_BASE_VIDEO_CODEC (base_video_encoder)->segment,
frame->decode_frame_number);
GST_BUFFER_OFFSET (buf) = GST_CLOCK_TIME_NONE; GST_BUFFER_OFFSET (buf) = GST_CLOCK_TIME_NONE;
GST_BUFFER_OFFSET_END (buf) = gst_video_state_get_timestamp (state, GST_BUFFER_OFFSET_END (buf) = gst_video_state_get_timestamp (state,
&base_video_encoder->segment, frame->system_frame_number); &GST_BASE_VIDEO_CODEC (base_video_encoder)->segment,
frame->system_frame_number);
if (frame->is_sync_point && if (frame->is_sync_point &&
frame->presentation_frame_number == frame->system_frame_number) { frame->presentation_frame_number == frame->system_frame_number) {
@ -704,7 +709,7 @@ gst_schro_enc_shape_output_mp4 (GstBaseVideoEncoder * base_video_encoder,
GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_DELTA_UNIT); GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_DELTA_UNIT);
} }
gst_buffer_set_caps (buf, base_video_encoder->caps); gst_buffer_set_caps (buf, GST_BASE_VIDEO_CODEC (base_video_encoder)->caps);
return gst_pad_push (GST_BASE_VIDEO_CODEC_SRC_PAD (base_video_encoder), buf); return gst_pad_push (GST_BASE_VIDEO_CODEC_SRC_PAD (base_video_encoder), buf);
} }

41
ext/vp8/gstvp8dec.c
View file

@ -330,21 +330,17 @@ static void
gst_vp8_dec_image_to_buffer (GstVP8Dec * dec, const vpx_image_t * img, gst_vp8_dec_image_to_buffer (GstVP8Dec * dec, const vpx_image_t * img,
GstBuffer * buffer) GstBuffer * buffer)
{ {
GstBaseVideoDecoder *decoder = (GstBaseVideoDecoder *) dec;
int stride, w, h, i; int stride, w, h, i;
guint8 *d; guint8 *d;
GstVideoState *state = &GST_BASE_VIDEO_CODEC (dec)->state;
d = GST_BUFFER_DATA (buffer) + d = GST_BUFFER_DATA (buffer) +
gst_video_format_get_component_offset (decoder->state.format, 0, gst_video_format_get_component_offset (state->format, 0,
decoder->state.width, decoder->state.height); state->width, state->height);
stride = stride = gst_video_format_get_row_stride (state->format, 0, state->width);
gst_video_format_get_row_stride (decoder->state.format, 0, h = gst_video_format_get_component_height (state->format, 0, state->height);
decoder->state.width);
h = gst_video_format_get_component_height (decoder->state.format, 0,
decoder->state.height);
h = MIN (h, img->h); h = MIN (h, img->h);
w = gst_video_format_get_component_width (decoder->state.format, 0, w = gst_video_format_get_component_width (state->format, 0, state->width);
decoder->state.width);
w = MIN (w, img->w); w = MIN (w, img->w);
for (i = 0; i < h; i++) for (i = 0; i < h; i++)
@ -352,24 +348,20 @@ gst_vp8_dec_image_to_buffer (GstVP8Dec * dec, const vpx_image_t * img,
img->planes[VPX_PLANE_Y] + i * img->stride[VPX_PLANE_Y], w); img->planes[VPX_PLANE_Y] + i * img->stride[VPX_PLANE_Y], w);
d = GST_BUFFER_DATA (buffer) + d = GST_BUFFER_DATA (buffer) +
gst_video_format_get_component_offset (decoder->state.format, 1, gst_video_format_get_component_offset (state->format, 1,
decoder->state.width, decoder->state.height); state->width, state->height);
stride = stride = gst_video_format_get_row_stride (state->format, 1, state->width);
gst_video_format_get_row_stride (decoder->state.format, 1, h = gst_video_format_get_component_height (state->format, 1, state->height);
decoder->state.width);
h = gst_video_format_get_component_height (decoder->state.format, 1,
decoder->state.height);
h = MIN (h, img->h >> img->y_chroma_shift); h = MIN (h, img->h >> img->y_chroma_shift);
w = gst_video_format_get_component_width (decoder->state.format, 1, w = gst_video_format_get_component_width (state->format, 1, state->width);
decoder->state.width);
w = MIN (w, img->w >> img->x_chroma_shift); w = MIN (w, img->w >> img->x_chroma_shift);
for (i = 0; i < h; i++) for (i = 0; i < h; i++)
memcpy (d + i * stride, memcpy (d + i * stride,
img->planes[VPX_PLANE_U] + i * img->stride[VPX_PLANE_U], w); img->planes[VPX_PLANE_U] + i * img->stride[VPX_PLANE_U], w);
d = GST_BUFFER_DATA (buffer) + d = GST_BUFFER_DATA (buffer) +
gst_video_format_get_component_offset (decoder->state.format, 2, gst_video_format_get_component_offset (state->format, 2,
decoder->state.width, decoder->state.height); state->width, state->height);
/* Same stride, height, width as above */ /* Same stride, height, width as above */
for (i = 0; i < h; i++) for (i = 0; i < h; i++)
memcpy (d + i * stride, memcpy (d + i * stride,
@ -395,6 +387,7 @@ gst_vp8_dec_handle_frame (GstBaseVideoDecoder * decoder, GstVideoFrame * frame)
int flags = 0; int flags = 0;
vpx_codec_stream_info_t stream_info; vpx_codec_stream_info_t stream_info;
vpx_codec_caps_t caps; vpx_codec_caps_t caps;
GstVideoState *state = &GST_BASE_VIDEO_CODEC (dec)->state;
memset (&stream_info, 0, sizeof (stream_info)); memset (&stream_info, 0, sizeof (stream_info));
stream_info.sz = sizeof (stream_info); stream_info.sz = sizeof (stream_info);
@ -410,9 +403,9 @@ gst_vp8_dec_handle_frame (GstBaseVideoDecoder * decoder, GstVideoFrame * frame)
} }
/* should set size here */ /* should set size here */
decoder->state.width = stream_info.w; state->width = stream_info.w;
decoder->state.height = stream_info.h; state->height = stream_info.h;
decoder->state.format = GST_VIDEO_FORMAT_I420; state->format = GST_VIDEO_FORMAT_I420;
gst_vp8_dec_send_tags (dec); gst_vp8_dec_send_tags (dec);
caps = vpx_codec_get_caps (&vpx_codec_vp8_dx_algo); caps = vpx_codec_get_caps (&vpx_codec_vp8_dx_algo);

57
ext/vp8/gstvp8enc.c
View file

@ -672,34 +672,31 @@ static vpx_image_t *
gst_vp8_enc_buffer_to_image (GstVP8Enc * enc, GstBuffer * buffer) gst_vp8_enc_buffer_to_image (GstVP8Enc * enc, GstBuffer * buffer)
{ {
vpx_image_t *image = g_slice_new0 (vpx_image_t); vpx_image_t *image = g_slice_new0 (vpx_image_t);
GstBaseVideoEncoder *encoder = (GstBaseVideoEncoder *) enc;
guint8 *data = GST_BUFFER_DATA (buffer); guint8 *data = GST_BUFFER_DATA (buffer);
GstVideoState *state = &GST_BASE_VIDEO_CODEC (enc)->state;
image->fmt = VPX_IMG_FMT_I420; image->fmt = VPX_IMG_FMT_I420;
image->bps = 12; image->bps = 12;
image->x_chroma_shift = image->y_chroma_shift = 1; image->x_chroma_shift = image->y_chroma_shift = 1;
image->img_data = data; image->img_data = data;
image->w = image->d_w = encoder->state.width; image->w = image->d_w = state->width;
image->h = image->d_h = encoder->state.height; image->h = image->d_h = state->height;
image->stride[VPX_PLANE_Y] = image->stride[VPX_PLANE_Y] =
gst_video_format_get_row_stride (encoder->state.format, 0, gst_video_format_get_row_stride (state->format, 0, state->width);
encoder->state.width);
image->stride[VPX_PLANE_U] = image->stride[VPX_PLANE_U] =
gst_video_format_get_row_stride (encoder->state.format, 1, gst_video_format_get_row_stride (state->format, 1, state->width);
encoder->state.width);
image->stride[VPX_PLANE_V] = image->stride[VPX_PLANE_V] =
gst_video_format_get_row_stride (encoder->state.format, 2, gst_video_format_get_row_stride (state->format, 2, state->width);
encoder->state.width);
image->planes[VPX_PLANE_Y] = image->planes[VPX_PLANE_Y] =
data + gst_video_format_get_component_offset (encoder->state.format, 0, data + gst_video_format_get_component_offset (state->format, 0,
encoder->state.width, encoder->state.height); state->width, state->height);
image->planes[VPX_PLANE_U] = image->planes[VPX_PLANE_U] =
data + gst_video_format_get_component_offset (encoder->state.format, 1, data + gst_video_format_get_component_offset (state->format, 1,
encoder->state.width, encoder->state.height); state->width, state->height);
image->planes[VPX_PLANE_V] = image->planes[VPX_PLANE_V] =
data + gst_video_format_get_component_offset (encoder->state.format, 2, data + gst_video_format_get_component_offset (state->format, 2,
encoder->state.width, encoder->state.height); state->width, state->height);
return image; return image;
} }
@ -746,10 +743,10 @@ gst_vp8_enc_handle_frame (GstBaseVideoEncoder * base_video_encoder,
return FALSE; return FALSE;
} }
cfg.g_w = base_video_encoder->state.width; cfg.g_w = state->width;
cfg.g_h = base_video_encoder->state.height; cfg.g_h = state->height;
cfg.g_timebase.num = base_video_encoder->state.fps_d; cfg.g_timebase.num = state->fps_d;
cfg.g_timebase.den = base_video_encoder->state.fps_n; cfg.g_timebase.den = state->fps_n;
cfg.g_error_resilient = encoder->error_resilient; cfg.g_error_resilient = encoder->error_resilient;
cfg.g_lag_in_frames = encoder->max_latency; cfg.g_lag_in_frames = encoder->max_latency;
@ -818,8 +815,7 @@ gst_vp8_enc_handle_frame (GstBaseVideoEncoder * base_video_encoder,
gst_base_video_encoder_set_latency (base_video_encoder, 0, gst_base_video_encoder_set_latency (base_video_encoder, 0,
gst_util_uint64_scale (encoder->max_latency, gst_util_uint64_scale (encoder->max_latency,
base_video_encoder->state.fps_d * GST_SECOND, state->fps_d * GST_SECOND, state->fps_n));
base_video_encoder->state.fps_n));
encoder->inited = TRUE; encoder->inited = TRUE;
} }
@ -954,7 +950,8 @@ gst_vp8_enc_shape_output (GstBaseVideoEncoder * base_video_encoder,
} }
GST_BUFFER_TIMESTAMP (buf) = gst_video_state_get_timestamp (state, GST_BUFFER_TIMESTAMP (buf) = gst_video_state_get_timestamp (state,
&base_video_encoder->segment, frame->presentation_frame_number); &GST_BASE_VIDEO_CODEC (base_video_encoder)->segment,
frame->presentation_frame_number);
GST_BUFFER_DURATION (buf) = 0; GST_BUFFER_DURATION (buf) = 0;
GST_BUFFER_OFFSET_END (buf) = GST_BUFFER_OFFSET_END (buf) =
_to_granulepos (frame->presentation_frame_number + 1, _to_granulepos (frame->presentation_frame_number + 1,
@ -963,7 +960,7 @@ gst_vp8_enc_shape_output (GstBaseVideoEncoder * base_video_encoder,
gst_util_uint64_scale (frame->presentation_frame_number + 1, gst_util_uint64_scale (frame->presentation_frame_number + 1,
GST_SECOND * state->fps_d, state->fps_n); GST_SECOND * state->fps_d, state->fps_n);
gst_buffer_set_caps (buf, base_video_encoder->caps); gst_buffer_set_caps (buf, GST_BASE_VIDEO_CODEC (base_video_encoder)->caps);
ret = gst_pad_push (GST_BASE_VIDEO_CODEC_SRC_PAD (base_video_encoder), buf); ret = gst_pad_push (GST_BASE_VIDEO_CODEC_SRC_PAD (base_video_encoder), buf);
if (ret != GST_FLOW_OK) { if (ret != GST_FLOW_OK) {
@ -984,18 +981,20 @@ gst_vp8_enc_shape_output (GstBaseVideoEncoder * base_video_encoder,
} }
GST_BUFFER_TIMESTAMP (buf) = gst_video_state_get_timestamp (state, GST_BUFFER_TIMESTAMP (buf) = gst_video_state_get_timestamp (state,
&base_video_encoder->segment, frame->presentation_frame_number); &GST_BASE_VIDEO_CODEC (base_video_encoder)->segment,
GST_BUFFER_DURATION (buf) = gst_video_state_get_timestamp (state, frame->presentation_frame_number);
&base_video_encoder->segment, GST_BUFFER_DURATION (buf) =
gst_video_state_get_timestamp (state,
&GST_BASE_VIDEO_CODEC (base_video_encoder)->segment,
frame->presentation_frame_number + 1) - GST_BUFFER_TIMESTAMP (buf); frame->presentation_frame_number + 1) - GST_BUFFER_TIMESTAMP (buf);
GST_BUFFER_OFFSET_END (buf) = GST_BUFFER_OFFSET_END (buf) =
_to_granulepos (frame->presentation_frame_number + 1, _to_granulepos (frame->presentation_frame_number + 1, 0,
0, encoder->keyframe_distance); encoder->keyframe_distance);
GST_BUFFER_OFFSET (buf) = GST_BUFFER_OFFSET (buf) =
gst_util_uint64_scale (frame->presentation_frame_number + 1, gst_util_uint64_scale (frame->presentation_frame_number + 1,
GST_SECOND * state->fps_d, state->fps_n); GST_SECOND * state->fps_d, state->fps_n);
gst_buffer_set_caps (buf, base_video_encoder->caps); gst_buffer_set_caps (buf, GST_BASE_VIDEO_CODEC (base_video_encoder)->caps);
ret = gst_pad_push (GST_BASE_VIDEO_CODEC_SRC_PAD (base_video_encoder), buf); ret = gst_pad_push (GST_BASE_VIDEO_CODEC_SRC_PAD (base_video_encoder), buf);
if (ret != GST_FLOW_OK) { if (ret != GST_FLOW_OK) {

15
gst-libs/gst/video/gstbasevideocodec.c
View file

@ -104,13 +104,27 @@ gst_base_video_codec_init (GstBaseVideoCodec * base_video_codec,
gst_element_add_pad (GST_ELEMENT (base_video_codec), gst_element_add_pad (GST_ELEMENT (base_video_codec),
base_video_codec->srcpad); base_video_codec->srcpad);
gst_segment_init (&base_video_codec->segment, GST_FORMAT_TIME);
} }
static void static void
gst_base_video_codec_reset (GstBaseVideoCodec * base_video_codec) gst_base_video_codec_reset (GstBaseVideoCodec * base_video_codec)
{ {
GList *g;
GST_DEBUG ("reset"); GST_DEBUG ("reset");
for (g = base_video_codec->frames; g; g = g_list_next (g)) {
gst_base_video_codec_free_frame ((GstVideoFrame *) g->data);
}
g_list_free (base_video_codec->frames);
if (base_video_codec->caps) {
gst_caps_unref (base_video_codec->caps);
base_video_codec->caps = NULL;
}
} }
static void static void
@ -121,7 +135,6 @@ gst_base_video_codec_finalize (GObject * object)
g_return_if_fail (GST_IS_BASE_VIDEO_CODEC (object)); g_return_if_fail (GST_IS_BASE_VIDEO_CODEC (object));
base_video_codec = GST_BASE_VIDEO_CODEC (object); base_video_codec = GST_BASE_VIDEO_CODEC (object);
G_OBJECT_CLASS (parent_class)->finalize (object); G_OBJECT_CLASS (parent_class)->finalize (object);
} }

14
gst-libs/gst/video/gstbasevideocodec.h
View file

@ -90,6 +90,18 @@ struct _GstBaseVideoCodec
GstPad *srcpad; GstPad *srcpad;
guint64 system_frame_number; guint64 system_frame_number;
GList *frames;
GstVideoState state;
GstSegment segment;
GstCaps *caps;
gdouble proportion;
GstClockTime earliest_time;
/* FIXME before moving to base */
void *padding[GST_PADDING_LARGE];
}; };
struct _GstBaseVideoCodecClass struct _GstBaseVideoCodecClass
@ -105,6 +117,8 @@ struct _GstBaseVideoCodecClass
GstFlowReturn (*shape_output) (GstBaseVideoCodec *codec, GstVideoFrame *frame); GstFlowReturn (*shape_output) (GstBaseVideoCodec *codec, GstVideoFrame *frame);
GstCaps *(*get_caps) (GstBaseVideoCodec *codec); GstCaps *(*get_caps) (GstBaseVideoCodec *codec);
/* FIXME before moving to base */
void *padding[GST_PADDING_LARGE];
}; };
GType gst_base_video_codec_get_type (void); GType gst_base_video_codec_get_type (void);

186
gst-libs/gst/video/gstbasevideodecoder.c
View file

@ -120,7 +120,6 @@ gst_base_video_decoder_init (GstBaseVideoDecoder * base_video_decoder,
base_video_decoder->input_adapter = gst_adapter_new (); base_video_decoder->input_adapter = gst_adapter_new ();
base_video_decoder->output_adapter = gst_adapter_new (); base_video_decoder->output_adapter = gst_adapter_new ();
gst_segment_init (&base_video_decoder->segment, GST_FORMAT_TIME);
gst_base_video_decoder_reset (base_video_decoder); gst_base_video_decoder_reset (base_video_decoder);
base_video_decoder->current_frame = base_video_decoder->current_frame =
@ -145,7 +144,7 @@ gst_base_video_decoder_sink_setcaps (GstPad * pad, GstCaps * caps)
GST_DEBUG ("setcaps %" GST_PTR_FORMAT, caps); GST_DEBUG ("setcaps %" GST_PTR_FORMAT, caps);
state = &base_video_decoder->state; state = &GST_BASE_VIDEO_CODEC (base_video_decoder)->state;
if (state->codec_data) { if (state->codec_data) {
gst_buffer_unref (state->codec_data); gst_buffer_unref (state->codec_data);
@ -242,7 +241,7 @@ gst_base_video_decoder_sink_event (GstPad * pad, GstEvent * event)
gint64 start; gint64 start;
gint64 stop; gint64 stop;
gint64 position; gint64 position;
GstSegment *segment = &base_video_decoder->segment; GstSegment *segment = &GST_BASE_VIDEO_CODEC (base_video_decoder)->segment;
gst_event_parse_new_segment_full (event, &update, &rate, gst_event_parse_new_segment_full (event, &update, &rate,
&applied_rate, &format, &start, &stop, &position); &applied_rate, &format, &start, &stop, &position);
@ -276,9 +275,11 @@ gst_base_video_decoder_sink_event (GstPad * pad, GstEvent * event)
break; break;
case GST_EVENT_FLUSH_STOP:{ case GST_EVENT_FLUSH_STOP:{
GST_OBJECT_LOCK (base_video_decoder); GST_OBJECT_LOCK (base_video_decoder);
base_video_decoder->earliest_time = GST_CLOCK_TIME_NONE; GST_BASE_VIDEO_CODEC (base_video_decoder)->earliest_time =
base_video_decoder->proportion = 0.5; GST_CLOCK_TIME_NONE;
gst_segment_init (&base_video_decoder->segment, GST_FORMAT_TIME); GST_BASE_VIDEO_CODEC (base_video_decoder)->proportion = 0.5;
gst_segment_init (&GST_BASE_VIDEO_CODEC (base_video_decoder)->segment,
GST_FORMAT_TIME);
GST_OBJECT_UNLOCK (base_video_decoder); GST_OBJECT_UNLOCK (base_video_decoder);
} }
default: default:
@ -357,22 +358,25 @@ gst_base_video_decoder_src_event (GstPad * pad, GstEvent * event)
gst_event_parse_qos (event, &proportion, &diff, &timestamp); gst_event_parse_qos (event, &proportion, &diff, &timestamp);
GST_OBJECT_LOCK (base_video_decoder); GST_OBJECT_LOCK (base_video_decoder);
base_video_decoder->proportion = proportion; GST_BASE_VIDEO_CODEC (base_video_decoder)->proportion = proportion;
if (G_LIKELY (GST_CLOCK_TIME_IS_VALID (timestamp))) { if (G_LIKELY (GST_CLOCK_TIME_IS_VALID (timestamp))) {
if (G_UNLIKELY (diff > 0)) { if (G_UNLIKELY (diff > 0)) {
if (base_video_decoder->state.fps_n > 0) if (GST_BASE_VIDEO_CODEC (base_video_decoder)->state.fps_n > 0)
duration = duration =
gst_util_uint64_scale (GST_SECOND, gst_util_uint64_scale (GST_SECOND,
base_video_decoder->state.fps_d, GST_BASE_VIDEO_CODEC (base_video_decoder)->state.fps_d,
base_video_decoder->state.fps_n); GST_BASE_VIDEO_CODEC (base_video_decoder)->state.fps_n);
else else
duration = 0; duration = 0;
base_video_decoder->earliest_time = timestamp + 2 * diff + duration; GST_BASE_VIDEO_CODEC (base_video_decoder)->earliest_time =
timestamp + 2 * diff + duration;
} else { } else {
base_video_decoder->earliest_time = timestamp + diff; GST_BASE_VIDEO_CODEC (base_video_decoder)->earliest_time =
timestamp + diff;
} }
} else { } else {
base_video_decoder->earliest_time = GST_CLOCK_TIME_NONE; GST_BASE_VIDEO_CODEC (base_video_decoder)->earliest_time =
GST_CLOCK_TIME_NONE;
} }
GST_OBJECT_UNLOCK (base_video_decoder); GST_OBJECT_UNLOCK (base_video_decoder);
@ -547,7 +551,9 @@ gst_base_video_decoder_src_query (GstPad * pad, GstQuery * query)
} }
time = enc->last_timestamp; time = enc->last_timestamp;
time = gst_segment_to_stream_time (&enc->segment, GST_FORMAT_TIME, time); time =
gst_segment_to_stream_time (&GST_BASE_VIDEO_CODEC (enc)->segment,
GST_FORMAT_TIME, time);
gst_query_set_position (query, format, time); gst_query_set_position (query, format, time);
@ -597,7 +603,8 @@ gst_base_video_decoder_sink_query (GstPad * pad, GstQuery * query)
base_video_decoder = GST_BASE_VIDEO_DECODER (gst_pad_get_parent (pad)); base_video_decoder = GST_BASE_VIDEO_DECODER (gst_pad_get_parent (pad));
GST_DEBUG_OBJECT (base_video_decoder, "sink query fps=%d/%d", GST_DEBUG_OBJECT (base_video_decoder, "sink query fps=%d/%d",
base_video_decoder->state.fps_n, base_video_decoder->state.fps_d); GST_BASE_VIDEO_CODEC (base_video_decoder)->state.fps_n,
GST_BASE_VIDEO_CODEC (base_video_decoder)->state.fps_d);
switch (GST_QUERY_TYPE (query)) { switch (GST_QUERY_TYPE (query)) {
case GST_QUERY_CONVERT: case GST_QUERY_CONVERT:
{ {
@ -605,8 +612,9 @@ gst_base_video_decoder_sink_query (GstPad * pad, GstQuery * query)
gint64 src_val, dest_val; gint64 src_val, dest_val;
gst_query_parse_convert (query, &src_fmt, &src_val, &dest_fmt, &dest_val); gst_query_parse_convert (query, &src_fmt, &src_val, &dest_fmt, &dest_val);
res = gst_base_video_rawvideo_convert (&base_video_decoder->state, res =
src_fmt, src_val, &dest_fmt, &dest_val); gst_base_video_rawvideo_convert (&GST_BASE_VIDEO_CODEC
(base_video_decoder)->state, src_fmt, src_val, &dest_fmt, &dest_val);
if (!res) if (!res)
goto error; goto error;
gst_query_set_convert (query, src_fmt, src_val, dest_fmt, dest_val); gst_query_set_convert (query, src_fmt, src_val, dest_fmt, dest_val);
@ -706,7 +714,6 @@ static void
gst_base_video_decoder_reset (GstBaseVideoDecoder * base_video_decoder) gst_base_video_decoder_reset (GstBaseVideoDecoder * base_video_decoder)
{ {
GstBaseVideoDecoderClass *base_video_decoder_class; GstBaseVideoDecoderClass *base_video_decoder_class;
GList *g;
base_video_decoder_class = base_video_decoder_class =
GST_BASE_VIDEO_DECODER_GET_CLASS (base_video_decoder); GST_BASE_VIDEO_DECODER_GET_CLASS (base_video_decoder);
@ -719,7 +726,7 @@ gst_base_video_decoder_reset (GstBaseVideoDecoder * base_video_decoder)
base_video_decoder->have_sync = FALSE; base_video_decoder->have_sync = FALSE;
base_video_decoder->timestamp_offset = GST_CLOCK_TIME_NONE; base_video_decoder->timestamp_offset = GST_CLOCK_TIME_NONE;
base_video_decoder->system_frame_number = 0; GST_BASE_VIDEO_CODEC (base_video_decoder)->system_frame_number = 0;
base_video_decoder->presentation_frame_number = 0; base_video_decoder->presentation_frame_number = 0;
base_video_decoder->base_picture_number = 0; base_video_decoder->base_picture_number = 0;
base_video_decoder->last_timestamp = GST_CLOCK_TIME_NONE; base_video_decoder->last_timestamp = GST_CLOCK_TIME_NONE;
@ -734,11 +741,6 @@ gst_base_video_decoder_reset (GstBaseVideoDecoder * base_video_decoder)
if (base_video_decoder->output_adapter) { if (base_video_decoder->output_adapter) {
gst_adapter_clear (base_video_decoder->output_adapter); gst_adapter_clear (base_video_decoder->output_adapter);
} }
if (base_video_decoder->caps) {
gst_caps_unref (base_video_decoder->caps);
base_video_decoder->caps = NULL;
}
//gst_segment_init (&base_video_decoder->segment, GST_FORMAT_TIME); //gst_segment_init (&base_video_decoder->segment, GST_FORMAT_TIME);
if (base_video_decoder->current_frame) { if (base_video_decoder->current_frame) {
@ -748,16 +750,10 @@ gst_base_video_decoder_reset (GstBaseVideoDecoder * base_video_decoder)
base_video_decoder->have_src_caps = FALSE; base_video_decoder->have_src_caps = FALSE;
for (g = g_list_first (base_video_decoder->frames); g; g = g_list_next (g)) {
GstVideoFrame *frame = g->data;
gst_base_video_decoder_free_frame (frame);
}
g_list_free (base_video_decoder->frames);
base_video_decoder->frames = NULL;
GST_OBJECT_LOCK (base_video_decoder); GST_OBJECT_LOCK (base_video_decoder);
base_video_decoder->earliest_time = GST_CLOCK_TIME_NONE; GST_BASE_VIDEO_CODEC (base_video_decoder)->earliest_time =
base_video_decoder->proportion = 0.5; GST_CLOCK_TIME_NONE;
GST_BASE_VIDEO_CODEC (base_video_decoder)->proportion = 0.5;
GST_OBJECT_UNLOCK (base_video_decoder); GST_OBJECT_UNLOCK (base_video_decoder);
if (base_video_decoder_class->reset) { if (base_video_decoder_class->reset) {
@ -797,8 +793,9 @@ gst_base_video_decoder_chain (GstPad * pad, GstBuffer * buf)
GST_WARNING GST_WARNING
("Received buffer without a new-segment. Assuming timestamps start from 0."); ("Received buffer without a new-segment. Assuming timestamps start from 0.");
gst_segment_set_newsegment_full (&base_video_decoder->segment, gst_segment_set_newsegment_full (&GST_BASE_VIDEO_CODEC
FALSE, 1.0, 1.0, GST_FORMAT_TIME, 0, GST_CLOCK_TIME_NONE, 0); (base_video_decoder)->segment, FALSE, 1.0, 1.0, GST_FORMAT_TIME, 0,
GST_CLOCK_TIME_NONE, 0);
base_video_decoder->have_segment = TRUE; base_video_decoder->have_segment = TRUE;
event = gst_event_new_new_segment (FALSE, 1.0, GST_FORMAT_TIME, 0, event = gst_event_new_new_segment (FALSE, 1.0, GST_FORMAT_TIME, 0,
@ -926,7 +923,8 @@ gst_base_video_decoder_change_state (GstElement * element,
if (base_video_decoder_class->stop) { if (base_video_decoder_class->stop) {
base_video_decoder_class->stop (base_video_decoder); base_video_decoder_class->stop (base_video_decoder);
} }
gst_segment_init (&base_video_decoder->segment, GST_FORMAT_TIME); gst_segment_init (&GST_BASE_VIDEO_CODEC (base_video_decoder)->segment,
GST_FORMAT_TIME);
g_list_foreach (base_video_decoder->timestamps, (GFunc) g_free, NULL); g_list_foreach (base_video_decoder->timestamps, (GFunc) g_free, NULL);
g_list_free (base_video_decoder->timestamps); g_list_free (base_video_decoder->timestamps);
base_video_decoder->timestamps = NULL; base_video_decoder->timestamps = NULL;
@ -960,8 +958,9 @@ gst_base_video_decoder_new_frame (GstBaseVideoDecoder * base_video_decoder)
frame = g_malloc0 (sizeof (GstVideoFrame)); frame = g_malloc0 (sizeof (GstVideoFrame));
frame->system_frame_number = base_video_decoder->system_frame_number; frame->system_frame_number =
base_video_decoder->system_frame_number++; GST_BASE_VIDEO_CODEC (base_video_decoder)->system_frame_number;
GST_BASE_VIDEO_CODEC (base_video_decoder)->system_frame_number++;
frame->decode_frame_number = frame->system_frame_number - frame->decode_frame_number = frame->system_frame_number -
base_video_decoder->reorder_depth; base_video_decoder->reorder_depth;
@ -979,9 +978,14 @@ gst_base_video_decoder_finish_frame (GstBaseVideoDecoder * base_video_decoder,
GstVideoFrame * frame) GstVideoFrame * frame)
{ {
GstBaseVideoDecoderClass *base_video_decoder_class; GstBaseVideoDecoderClass *base_video_decoder_class;
GstVideoState *state = &GST_BASE_VIDEO_CODEC (base_video_decoder)->state;
GstBuffer *src_buffer; GstBuffer *src_buffer;
GST_DEBUG ("finish frame"); GST_DEBUG ("finish frame");
GST_DEBUG ("n %d in %d out %d",
g_list_length (GST_BASE_VIDEO_CODEC (base_video_decoder)->frames),
gst_adapter_available (base_video_decoder->input_adapter),
gst_adapter_available (base_video_decoder->output_adapter));
base_video_decoder_class = base_video_decoder_class =
GST_BASE_VIDEO_DECODER_GET_CLASS (base_video_decoder); GST_BASE_VIDEO_DECODER_GET_CLASS (base_video_decoder);
@ -994,7 +998,7 @@ gst_base_video_decoder_finish_frame (GstBaseVideoDecoder * base_video_decoder,
GST_DEBUG ("sync timestamp %" GST_TIME_FORMAT " diff %" GST_TIME_FORMAT, GST_DEBUG ("sync timestamp %" GST_TIME_FORMAT " diff %" GST_TIME_FORMAT,
GST_TIME_ARGS (frame->presentation_timestamp), GST_TIME_ARGS (frame->presentation_timestamp),
GST_TIME_ARGS (frame->presentation_timestamp - GST_TIME_ARGS (frame->presentation_timestamp -
base_video_decoder->segment.start)); GST_BASE_VIDEO_CODEC (base_video_decoder)->segment.start));
base_video_decoder->timestamp_offset = frame->presentation_timestamp; base_video_decoder->timestamp_offset = frame->presentation_timestamp;
base_video_decoder->field_index &= 1; base_video_decoder->field_index &= 1;
} else { } else {
@ -1010,7 +1014,7 @@ gst_base_video_decoder_finish_frame (GstBaseVideoDecoder * base_video_decoder,
GST_WARNING GST_WARNING
("No base timestamp. Assuming frames start at segment start"); ("No base timestamp. Assuming frames start at segment start");
base_video_decoder->timestamp_offset = base_video_decoder->timestamp_offset =
base_video_decoder->segment.start; GST_BASE_VIDEO_CODEC (base_video_decoder)->segment.start;
base_video_decoder->field_index &= 1; base_video_decoder->field_index &= 1;
} }
} }
@ -1043,8 +1047,8 @@ gst_base_video_decoder_finish_frame (GstBaseVideoDecoder * base_video_decoder,
base_video_decoder->last_timestamp = frame->presentation_timestamp; base_video_decoder->last_timestamp = frame->presentation_timestamp;
GST_BUFFER_FLAG_UNSET (frame->src_buffer, GST_BUFFER_FLAG_DELTA_UNIT); GST_BUFFER_FLAG_UNSET (frame->src_buffer, GST_BUFFER_FLAG_DELTA_UNIT);
if (base_video_decoder->state.interlaced) { if (state->interlaced) {
int tff = base_video_decoder->state.top_field_first; int tff = state->top_field_first;
if (frame->field_index & 1) { if (frame->field_index & 1) {
tff ^= 1; tff ^= 1;
@ -1075,8 +1079,8 @@ gst_base_video_decoder_finish_frame (GstBaseVideoDecoder * base_video_decoder,
GST_DEBUG ("pushing frame %" GST_TIME_FORMAT, GST_DEBUG ("pushing frame %" GST_TIME_FORMAT,
GST_TIME_ARGS (frame->presentation_timestamp)); GST_TIME_ARGS (frame->presentation_timestamp));
base_video_decoder->frames = GST_BASE_VIDEO_CODEC (base_video_decoder)->frames =
g_list_remove (base_video_decoder->frames, frame); g_list_remove (GST_BASE_VIDEO_CODEC (base_video_decoder)->frames, frame);
gst_base_video_decoder_set_src_caps (base_video_decoder); gst_base_video_decoder_set_src_caps (base_video_decoder);
@ -1089,9 +1093,9 @@ gst_base_video_decoder_finish_frame (GstBaseVideoDecoder * base_video_decoder,
gint64 start = GST_BUFFER_TIMESTAMP (src_buffer); gint64 start = GST_BUFFER_TIMESTAMP (src_buffer);
gint64 stop = GST_BUFFER_TIMESTAMP (src_buffer) + gint64 stop = GST_BUFFER_TIMESTAMP (src_buffer) +
GST_BUFFER_DURATION (src_buffer); GST_BUFFER_DURATION (src_buffer);
GstSegment *segment = &GST_BASE_VIDEO_CODEC (base_video_decoder)->segment;
if (gst_segment_clip (&base_video_decoder->segment, GST_FORMAT_TIME, if (gst_segment_clip (segment, GST_FORMAT_TIME, start, stop, &start, &stop)) {
start, stop, &start, &stop)) {
GST_BUFFER_TIMESTAMP (src_buffer) = start; GST_BUFFER_TIMESTAMP (src_buffer) = start;
GST_BUFFER_DURATION (src_buffer) = stop - start; GST_BUFFER_DURATION (src_buffer) = stop - start;
GST_DEBUG ("accepting buffer inside segment: %" GST_TIME_FORMAT GST_DEBUG ("accepting buffer inside segment: %" GST_TIME_FORMAT
@ -1101,9 +1105,8 @@ gst_base_video_decoder_finish_frame (GstBaseVideoDecoder * base_video_decoder,
GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (src_buffer)), GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (src_buffer)),
GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (src_buffer) + GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (src_buffer) +
GST_BUFFER_DURATION (src_buffer)), GST_BUFFER_DURATION (src_buffer)),
GST_TIME_ARGS (base_video_decoder->segment.start), GST_TIME_ARGS (segment->start),
GST_TIME_ARGS (base_video_decoder->segment.stop), GST_TIME_ARGS (segment->stop), GST_TIME_ARGS (segment->time));
GST_TIME_ARGS (base_video_decoder->segment.time));
} else { } else {
GST_DEBUG ("dropping buffer outside segment: %" GST_TIME_FORMAT GST_DEBUG ("dropping buffer outside segment: %" GST_TIME_FORMAT
" %" GST_TIME_FORMAT " %" GST_TIME_FORMAT
@ -1112,9 +1115,8 @@ gst_base_video_decoder_finish_frame (GstBaseVideoDecoder * base_video_decoder,
GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (src_buffer)), GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (src_buffer)),
GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (src_buffer) + GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (src_buffer) +
GST_BUFFER_DURATION (src_buffer)), GST_BUFFER_DURATION (src_buffer)),
GST_TIME_ARGS (base_video_decoder->segment.start), GST_TIME_ARGS (segment->start),
GST_TIME_ARGS (base_video_decoder->segment.stop), GST_TIME_ARGS (segment->stop), GST_TIME_ARGS (segment->time));
GST_TIME_ARGS (base_video_decoder->segment.time));
gst_buffer_unref (src_buffer); gst_buffer_unref (src_buffer);
return GST_FLOW_OK; return GST_FLOW_OK;
} }
@ -1143,7 +1145,7 @@ gst_base_video_decoder_skip_frame (GstBaseVideoDecoder * base_video_decoder,
GST_DEBUG ("sync timestamp %" GST_TIME_FORMAT " diff %" GST_TIME_FORMAT, GST_DEBUG ("sync timestamp %" GST_TIME_FORMAT " diff %" GST_TIME_FORMAT,
GST_TIME_ARGS (frame->presentation_timestamp), GST_TIME_ARGS (frame->presentation_timestamp),
GST_TIME_ARGS (frame->presentation_timestamp - GST_TIME_ARGS (frame->presentation_timestamp -
base_video_decoder->segment.start)); GST_BASE_VIDEO_CODEC (base_video_decoder)->segment.start));
base_video_decoder->timestamp_offset = frame->presentation_timestamp; base_video_decoder->timestamp_offset = frame->presentation_timestamp;
base_video_decoder->field_index = 0; base_video_decoder->field_index = 0;
} else { } else {
@ -1159,7 +1161,7 @@ gst_base_video_decoder_skip_frame (GstBaseVideoDecoder * base_video_decoder,
GST_WARNING GST_WARNING
("No base timestamp. Assuming frames start at segment start"); ("No base timestamp. Assuming frames start at segment start");
base_video_decoder->timestamp_offset = base_video_decoder->timestamp_offset =
base_video_decoder->segment.start; GST_BASE_VIDEO_CODEC (base_video_decoder)->segment.start;
base_video_decoder->field_index = 0; base_video_decoder->field_index = 0;
} }
} }
@ -1187,8 +1189,8 @@ gst_base_video_decoder_skip_frame (GstBaseVideoDecoder * base_video_decoder,
GST_DEBUG ("skipping frame %" GST_TIME_FORMAT, GST_DEBUG ("skipping frame %" GST_TIME_FORMAT,
GST_TIME_ARGS (frame->presentation_timestamp)); GST_TIME_ARGS (frame->presentation_timestamp));
base_video_decoder->frames = GST_BASE_VIDEO_CODEC (base_video_decoder)->frames =
g_list_remove (base_video_decoder->frames, frame); g_list_remove (GST_BASE_VIDEO_CODEC (base_video_decoder)->frames, frame);
gst_base_video_decoder_free_frame (frame); gst_base_video_decoder_free_frame (frame);
@ -1198,13 +1200,17 @@ gst_base_video_decoder_skip_frame (GstBaseVideoDecoder * base_video_decoder,
int int
gst_base_video_decoder_get_height (GstBaseVideoDecoder * base_video_decoder) gst_base_video_decoder_get_height (GstBaseVideoDecoder * base_video_decoder)
{ {
return base_video_decoder->state.height; GstVideoState *state = &GST_BASE_VIDEO_CODEC (base_video_decoder)->state;
return state->height;
} }
int int
gst_base_video_decoder_get_width (GstBaseVideoDecoder * base_video_decoder) gst_base_video_decoder_get_width (GstBaseVideoDecoder * base_video_decoder)
{ {
return base_video_decoder->state.width; GstVideoState *state = &GST_BASE_VIDEO_CODEC (base_video_decoder)->state;
return state->width;
} }
GstFlowReturn GstFlowReturn
@ -1212,7 +1218,7 @@ gst_base_video_decoder_end_of_stream (GstBaseVideoDecoder * base_video_decoder,
GstBuffer * buffer) GstBuffer * buffer)
{ {
if (base_video_decoder->frames) { if (GST_BASE_VIDEO_CODEC (base_video_decoder)->frames) {
GST_DEBUG ("EOS with frames left over"); GST_DEBUG ("EOS with frames left over");
} }
@ -1244,20 +1250,20 @@ static guint64
gst_base_video_decoder_get_timestamp (GstBaseVideoDecoder * base_video_decoder, gst_base_video_decoder_get_timestamp (GstBaseVideoDecoder * base_video_decoder,
int picture_number) int picture_number)
{ {
if (base_video_decoder->state.fps_d == 0) { GstVideoState *state = &GST_BASE_VIDEO_CODEC (base_video_decoder)->state;
if (state->fps_d == 0) {
return -1; return -1;
} }
if (picture_number < base_video_decoder->base_picture_number) { if (picture_number < base_video_decoder->base_picture_number) {
return base_video_decoder->timestamp_offset - return base_video_decoder->timestamp_offset -
(gint64) gst_util_uint64_scale (base_video_decoder->base_picture_number (gint64) gst_util_uint64_scale (base_video_decoder->base_picture_number
- picture_number, base_video_decoder->state.fps_d * GST_SECOND, - picture_number, state->fps_d * GST_SECOND, state->fps_n);
base_video_decoder->state.fps_n);
} else { } else {
return base_video_decoder->timestamp_offset + return base_video_decoder->timestamp_offset +
gst_util_uint64_scale (picture_number - gst_util_uint64_scale (picture_number -
base_video_decoder->base_picture_number, base_video_decoder->base_picture_number,
base_video_decoder->state.fps_d * GST_SECOND, state->fps_d * GST_SECOND, state->fps_n);
base_video_decoder->state.fps_n);
} }
} }
@ -1265,7 +1271,9 @@ static guint64
gst_base_video_decoder_get_field_timestamp (GstBaseVideoDecoder * gst_base_video_decoder_get_field_timestamp (GstBaseVideoDecoder *
base_video_decoder, int field_offset) base_video_decoder, int field_offset)
{ {
if (base_video_decoder->state.fps_d == 0) { GstVideoState *state = &GST_BASE_VIDEO_CODEC (base_video_decoder)->state;
if (state->fps_d == 0) {
return GST_CLOCK_TIME_NONE; return GST_CLOCK_TIME_NONE;
} }
if (field_offset < 0) { if (field_offset < 0) {
@ -1273,25 +1281,25 @@ gst_base_video_decoder_get_field_timestamp (GstBaseVideoDecoder *
return GST_CLOCK_TIME_NONE; return GST_CLOCK_TIME_NONE;
} }
return base_video_decoder->timestamp_offset + return base_video_decoder->timestamp_offset +
gst_util_uint64_scale (field_offset, gst_util_uint64_scale (field_offset, state->fps_d * GST_SECOND,
base_video_decoder->state.fps_d * GST_SECOND, state->fps_n * 2);
base_video_decoder->state.fps_n * 2);
} }
static guint64 static guint64
gst_base_video_decoder_get_field_duration (GstBaseVideoDecoder * gst_base_video_decoder_get_field_duration (GstBaseVideoDecoder *
base_video_decoder, int n_fields) base_video_decoder, int n_fields)
{ {
if (base_video_decoder->state.fps_d == 0) { GstVideoState *state = &GST_BASE_VIDEO_CODEC (base_video_decoder)->state;
if (state->fps_d == 0) {
return GST_CLOCK_TIME_NONE; return GST_CLOCK_TIME_NONE;
} }
if (n_fields < 0) { if (n_fields < 0) {
GST_WARNING ("n_fields < 0"); GST_WARNING ("n_fields < 0");
return GST_CLOCK_TIME_NONE; return GST_CLOCK_TIME_NONE;
} }
return gst_util_uint64_scale (n_fields, return gst_util_uint64_scale (n_fields, state->fps_d * GST_SECOND,
base_video_decoder->state.fps_d * GST_SECOND, state->fps_n * 2);
base_video_decoder->state.fps_n * 2);
} }
@ -1345,11 +1353,13 @@ gst_base_video_decoder_have_frame_2 (GstBaseVideoDecoder * base_video_decoder)
GST_DEBUG ("dts %" GST_TIME_FORMAT, GST_TIME_ARGS (frame->decode_timestamp)); GST_DEBUG ("dts %" GST_TIME_FORMAT, GST_TIME_ARGS (frame->decode_timestamp));
GST_DEBUG ("dist %d", frame->distance_from_sync); GST_DEBUG ("dist %d", frame->distance_from_sync);
base_video_decoder->frames = g_list_append (base_video_decoder->frames, GST_BASE_VIDEO_CODEC (base_video_decoder)->frames =
frame); g_list_append (GST_BASE_VIDEO_CODEC (base_video_decoder)->frames, frame);
frame->deadline = gst_segment_to_running_time (&base_video_decoder->segment, frame->deadline =
GST_FORMAT_TIME, frame->presentation_timestamp); gst_segment_to_running_time (&GST_BASE_VIDEO_CODEC
(base_video_decoder)->segment, GST_FORMAT_TIME,
frame->presentation_timestamp);
/* do something with frame */ /* do something with frame */
ret = base_video_decoder_class->handle_frame (base_video_decoder, frame); ret = base_video_decoder_class->handle_frame (base_video_decoder, frame);
@ -1367,7 +1377,7 @@ gst_base_video_decoder_have_frame_2 (GstBaseVideoDecoder * base_video_decoder)
GstVideoState * GstVideoState *
gst_base_video_decoder_get_state (GstBaseVideoDecoder * base_video_decoder) gst_base_video_decoder_get_state (GstBaseVideoDecoder * base_video_decoder)
{ {
return &base_video_decoder->state; return &GST_BASE_VIDEO_CODEC (base_video_decoder)->state;
} }
@ -1375,7 +1385,8 @@ void
gst_base_video_decoder_set_state (GstBaseVideoDecoder * base_video_decoder, gst_base_video_decoder_set_state (GstBaseVideoDecoder * base_video_decoder,
GstVideoState * state) GstVideoState * state)
{ {
memcpy (&base_video_decoder->state, state, sizeof (*state)); memcpy (&GST_BASE_VIDEO_CODEC (base_video_decoder)->state,
state, sizeof (*state));
} }
@ -1408,7 +1419,7 @@ gst_base_video_decoder_get_oldest_frame (GstBaseVideoDecoder *
{ {
GList *g; GList *g;
g = g_list_first (base_video_decoder->frames); g = g_list_first (GST_BASE_VIDEO_CODEC (base_video_decoder)->frames);
if (g == NULL) if (g == NULL)
return NULL; return NULL;
@ -1421,7 +1432,8 @@ gst_base_video_decoder_get_frame (GstBaseVideoDecoder * base_video_decoder,
{ {
GList *g; GList *g;
for (g = g_list_first (base_video_decoder->frames); g; g = g_list_next (g)) { for (g = g_list_first (GST_BASE_VIDEO_CODEC (base_video_decoder)->frames);
g; g = g_list_next (g)) {
GstVideoFrame *frame = g->data; GstVideoFrame *frame = g->data;
if (frame->system_frame_number == frame_number) { if (frame->system_frame_number == frame_number) {
@ -1436,7 +1448,7 @@ void
gst_base_video_decoder_set_src_caps (GstBaseVideoDecoder * base_video_decoder) gst_base_video_decoder_set_src_caps (GstBaseVideoDecoder * base_video_decoder)
{ {
GstCaps *caps; GstCaps *caps;
GstVideoState *state = &base_video_decoder->state; GstVideoState *state = &GST_BASE_VIDEO_CODEC (base_video_decoder)->state;
if (base_video_decoder->have_src_caps) if (base_video_decoder->have_src_caps)
return; return;
@ -1462,11 +1474,12 @@ gst_base_video_decoder_alloc_src_frame (GstBaseVideoDecoder *
{ {
GstFlowReturn flow_ret; GstFlowReturn flow_ret;
int num_bytes; int num_bytes;
GstVideoState *state = &GST_BASE_VIDEO_CODEC (base_video_decoder)->state;
gst_base_video_decoder_set_src_caps (base_video_decoder); gst_base_video_decoder_set_src_caps (base_video_decoder);
num_bytes = gst_video_format_get_size (base_video_decoder->state.format, num_bytes = gst_video_format_get_size (state->format, state->width,
base_video_decoder->state.width, base_video_decoder->state.height); state->height);
flow_ret = flow_ret =
gst_pad_alloc_buffer_and_set_caps (GST_BASE_VIDEO_CODEC_SRC_PAD gst_pad_alloc_buffer_and_set_caps (GST_BASE_VIDEO_CODEC_SRC_PAD
(base_video_decoder), GST_BUFFER_OFFSET_NONE, num_bytes, (base_video_decoder), GST_BUFFER_OFFSET_NONE, num_bytes,
@ -1485,10 +1498,11 @@ gst_base_video_decoder_get_max_decode_time (GstBaseVideoDecoder *
base_video_decoder, GstVideoFrame * frame) base_video_decoder, GstVideoFrame * frame)
{ {
GstClockTimeDiff deadline; GstClockTimeDiff deadline;
GstClockTime earliest_time;
if (GST_CLOCK_TIME_IS_VALID (base_video_decoder->earliest_time)) earliest_time = GST_BASE_VIDEO_CODEC (base_video_decoder)->earliest_time;
deadline = GST_CLOCK_DIFF (base_video_decoder->earliest_time, if (GST_CLOCK_TIME_IS_VALID (earliest_time))
frame->deadline); deadline = GST_CLOCK_DIFF (earliest_time, frame->deadline);
else else
deadline = G_MAXINT64; deadline = G_MAXINT64;

16
gst-libs/gst/video/gstbasevideodecoder.h
View file

@ -73,21 +73,14 @@ struct _GstBaseVideoDecoder
GstAdapter *input_adapter; GstAdapter *input_adapter;
GstAdapter *output_adapter; GstAdapter *output_adapter;
GList *frames;
gboolean have_sync; gboolean have_sync;
gboolean discont; gboolean discont;
gboolean started; gboolean started;
GstVideoState state;
GstSegment segment;
gboolean sink_clipping; gboolean sink_clipping;
guint64 presentation_frame_number; guint64 presentation_frame_number;
guint64 system_frame_number;
GstCaps *caps;
gboolean have_src_caps; gboolean have_src_caps;
GstVideoFrame *current_frame; GstVideoFrame *current_frame;
@ -99,9 +92,6 @@ struct _GstBaseVideoDecoder
GstClockTime timestamp_offset; GstClockTime timestamp_offset;
gdouble proportion;
GstClockTime earliest_time;
//GstBuffer *codec_data; //GstBuffer *codec_data;
guint64 input_offset; guint64 input_offset;
@ -117,6 +107,9 @@ struct _GstBaseVideoDecoder
GList *timestamps; GList *timestamps;
gboolean have_segment; gboolean have_segment;
/* FIXME before moving to base */
void *padding[GST_PADDING_LARGE];
}; };
struct _GstBaseVideoDecoderClass struct _GstBaseVideoDecoderClass
@ -139,6 +132,9 @@ struct _GstBaseVideoDecoderClass
guint32 capture_mask; guint32 capture_mask;
guint32 capture_pattern; guint32 capture_pattern;
/* FIXME before moving to base */
void *padding[GST_PADDING_LARGE];
}; };
GType gst_base_video_decoder_get_type (void); GType gst_base_video_decoder_get_type (void);

78
gst-libs/gst/video/gstbasevideoencoder.c
View file

@ -110,7 +110,7 @@ gst_base_video_encoder_sink_setcaps (GstPad * pad, GstCaps * caps)
GST_DEBUG ("setcaps"); GST_DEBUG ("setcaps");
state = &base_video_encoder->state; state = &GST_BASE_VIDEO_CODEC (base_video_encoder)->state;
structure = gst_caps_get_structure (caps, 0); structure = gst_caps_get_structure (caps, 0);
gst_video_format_parse_caps (caps, &state->format, gst_video_format_parse_caps (caps, &state->format,
@ -137,7 +137,7 @@ gst_base_video_encoder_sink_setcaps (GstPad * pad, GstCaps * caps)
state->clean_offset_top = 0; state->clean_offset_top = 0;
ret = base_video_encoder_class->set_format (base_video_encoder, ret = base_video_encoder_class->set_format (base_video_encoder,
&base_video_encoder->state); &GST_BASE_VIDEO_CODEC (base_video_encoder)->state);
if (ret) { if (ret) {
ret = base_video_encoder_class->start (base_video_encoder); ret = base_video_encoder_class->start (base_video_encoder);
} }
@ -152,7 +152,6 @@ gst_base_video_encoder_finalize (GObject * object)
{ {
GstBaseVideoEncoder *base_video_encoder; GstBaseVideoEncoder *base_video_encoder;
GstBaseVideoEncoderClass *base_video_encoder_class; GstBaseVideoEncoderClass *base_video_encoder_class;
GList *g;
g_return_if_fail (GST_IS_BASE_VIDEO_ENCODER (object)); g_return_if_fail (GST_IS_BASE_VIDEO_ENCODER (object));
base_video_encoder = GST_BASE_VIDEO_ENCODER (object); base_video_encoder = GST_BASE_VIDEO_ENCODER (object);
@ -160,16 +159,6 @@ gst_base_video_encoder_finalize (GObject * object)
GST_DEBUG ("finalize"); GST_DEBUG ("finalize");
for (g = base_video_encoder->frames; g; g = g_list_next (g)) {
gst_base_video_codec_free_frame ((GstVideoFrame *) g->data);
}
g_list_free (base_video_encoder->frames);
if (base_video_encoder->caps) {
gst_caps_unref (base_video_encoder->caps);
base_video_encoder->caps = NULL;
}
G_OBJECT_CLASS (parent_class)->finalize (object); G_OBJECT_CLASS (parent_class)->finalize (object);
} }
@ -215,8 +204,9 @@ gst_base_video_encoder_sink_event (GstPad * pad, GstEvent * event)
GST_DEBUG ("new segment %" GST_TIME_FORMAT " %" GST_TIME_FORMAT, GST_DEBUG ("new segment %" GST_TIME_FORMAT " %" GST_TIME_FORMAT,
GST_TIME_ARGS (start), GST_TIME_ARGS (position)); GST_TIME_ARGS (start), GST_TIME_ARGS (position));
gst_segment_set_newsegment_full (&base_video_encoder->segment, gst_segment_set_newsegment_full (&GST_BASE_VIDEO_CODEC
update, rate, applied_rate, format, start, stop, position); (base_video_encoder)->segment, update, rate, applied_rate, format,
start, stop, position);
ret = ret =
gst_pad_push_event (GST_BASE_VIDEO_CODEC_SRC_PAD (base_video_encoder), gst_pad_push_event (GST_BASE_VIDEO_CODEC_SRC_PAD (base_video_encoder),
@ -338,8 +328,8 @@ gst_base_video_encoder_src_query (GstPad * pad, GstQuery * query)
gst_query_parse_convert (query, &src_fmt, &src_val, &dest_fmt, &dest_val); gst_query_parse_convert (query, &src_fmt, &src_val, &dest_fmt, &dest_val);
res = res =
gst_base_video_encoded_video_convert (&enc->state, src_fmt, src_val, gst_base_video_encoded_video_convert (&GST_BASE_VIDEO_CODEC
&dest_fmt, &dest_val); (enc)->state, src_fmt, src_val, &dest_fmt, &dest_val);
if (!res) if (!res)
goto error; goto error;
gst_query_set_convert (query, src_fmt, src_val, dest_fmt, dest_val); gst_query_set_convert (query, src_fmt, src_val, dest_fmt, dest_val);
@ -413,7 +403,7 @@ gst_base_video_encoder_chain (GstPad * pad, GstBuffer * buf)
gint64 clip_start; gint64 clip_start;
gint64 clip_stop; gint64 clip_stop;
if (!gst_segment_clip (&base_video_encoder->segment, if (!gst_segment_clip (&GST_BASE_VIDEO_CODEC (base_video_encoder)->segment,
GST_FORMAT_TIME, start, stop, &clip_start, &clip_stop)) { GST_FORMAT_TIME, start, stop, &clip_start, &clip_stop)) {
GST_DEBUG ("clipping to segment dropped frame"); GST_DEBUG ("clipping to segment dropped frame");
goto done; goto done;
@ -430,8 +420,8 @@ gst_base_video_encoder_chain (GstPad * pad, GstBuffer * buf)
base_video_encoder->presentation_frame_number; base_video_encoder->presentation_frame_number;
base_video_encoder->presentation_frame_number++; base_video_encoder->presentation_frame_number++;
base_video_encoder->frames = GST_BASE_VIDEO_CODEC (base_video_encoder)->frames =
g_list_append (base_video_encoder->frames, frame); g_list_append (GST_BASE_VIDEO_CODEC (base_video_encoder)->frames, frame);
klass->handle_frame (base_video_encoder, frame); klass->handle_frame (base_video_encoder, frame);
@ -482,8 +472,9 @@ gst_base_video_encoder_finish_frame (GstBaseVideoEncoder * base_video_encoder,
base_video_encoder_class = base_video_encoder_class =
GST_BASE_VIDEO_ENCODER_GET_CLASS (base_video_encoder); GST_BASE_VIDEO_ENCODER_GET_CLASS (base_video_encoder);
frame->system_frame_number = base_video_encoder->system_frame_number; frame->system_frame_number =
base_video_encoder->system_frame_number++; GST_BASE_VIDEO_CODEC (base_video_encoder)->system_frame_number;
GST_BASE_VIDEO_CODEC (base_video_encoder)->system_frame_number++;
if (frame->is_sync_point) { if (frame->is_sync_point) {
base_video_encoder->distance_from_sync = 0; base_video_encoder->distance_from_sync = 0;
@ -500,41 +491,46 @@ gst_base_video_encoder_finish_frame (GstBaseVideoEncoder * base_video_encoder,
frame->decode_timestamp = 0; frame->decode_timestamp = 0;
} else { } else {
frame->decode_timestamp = gst_util_uint64_scale (frame->decode_frame_number, frame->decode_timestamp = gst_util_uint64_scale (frame->decode_frame_number,
GST_SECOND * base_video_encoder->state.fps_d, GST_SECOND * GST_BASE_VIDEO_CODEC (base_video_encoder)->state.fps_d,
base_video_encoder->state.fps_n); GST_BASE_VIDEO_CODEC (base_video_encoder)->state.fps_n);
} }
GST_BUFFER_TIMESTAMP (frame->src_buffer) = frame->presentation_timestamp; GST_BUFFER_TIMESTAMP (frame->src_buffer) = frame->presentation_timestamp;
GST_BUFFER_DURATION (frame->src_buffer) = frame->presentation_duration; GST_BUFFER_DURATION (frame->src_buffer) = frame->presentation_duration;
GST_BUFFER_OFFSET (frame->src_buffer) = frame->decode_timestamp; GST_BUFFER_OFFSET (frame->src_buffer) = frame->decode_timestamp;
base_video_encoder->frames = GST_BASE_VIDEO_CODEC (base_video_encoder)->frames =
g_list_remove (base_video_encoder->frames, frame); g_list_remove (GST_BASE_VIDEO_CODEC (base_video_encoder)->frames, frame);
if (!base_video_encoder->set_output_caps) { if (!base_video_encoder->set_output_caps) {
if (base_video_encoder_class->get_caps) { if (base_video_encoder_class->get_caps) {
base_video_encoder->caps = GST_BASE_VIDEO_CODEC (base_video_encoder)->caps =
base_video_encoder_class->get_caps (base_video_encoder); base_video_encoder_class->get_caps (base_video_encoder);
} else { } else {
base_video_encoder->caps = gst_caps_new_simple ("video/unknown", NULL); GST_BASE_VIDEO_CODEC (base_video_encoder)->caps =
gst_caps_new_simple ("video/unknown", NULL);
} }
gst_pad_set_caps (GST_BASE_VIDEO_CODEC_SRC_PAD (base_video_encoder), gst_pad_set_caps (GST_BASE_VIDEO_CODEC_SRC_PAD (base_video_encoder),
base_video_encoder->caps); GST_BASE_VIDEO_CODEC (base_video_encoder)->caps);
base_video_encoder->set_output_caps = TRUE; base_video_encoder->set_output_caps = TRUE;
} }
gst_buffer_set_caps (GST_BUFFER (frame->src_buffer), gst_buffer_set_caps (GST_BUFFER (frame->src_buffer),
base_video_encoder->caps); GST_BASE_VIDEO_CODEC (base_video_encoder)->caps);
if (frame->force_keyframe) { if (frame->force_keyframe) {
GstClockTime stream_time; GstClockTime stream_time;
GstClockTime running_time; GstClockTime running_time;
GstStructure *s; GstStructure *s;
running_time = gst_segment_to_running_time (&base_video_encoder->segment, running_time =
GST_FORMAT_TIME, frame->presentation_timestamp); gst_segment_to_running_time (&GST_BASE_VIDEO_CODEC
stream_time = gst_segment_to_stream_time (&base_video_encoder->segment, (base_video_encoder)->segment, GST_FORMAT_TIME,
GST_FORMAT_TIME, frame->presentation_timestamp); frame->presentation_timestamp);
stream_time =
gst_segment_to_stream_time (&GST_BASE_VIDEO_CODEC
(base_video_encoder)->segment, GST_FORMAT_TIME,
frame->presentation_timestamp);
/* FIXME this should send the event that we got on the sink pad /* FIXME this should send the event that we got on the sink pad
instead of creating a new one */ instead of creating a new one */
@ -563,19 +559,19 @@ gst_base_video_encoder_finish_frame (GstBaseVideoEncoder * base_video_encoder,
int int
gst_base_video_encoder_get_height (GstBaseVideoEncoder * base_video_encoder) gst_base_video_encoder_get_height (GstBaseVideoEncoder * base_video_encoder)
{ {
return base_video_encoder->state.height; return GST_BASE_VIDEO_CODEC (base_video_encoder)->state.height;
} }
int int
gst_base_video_encoder_get_width (GstBaseVideoEncoder * base_video_encoder) gst_base_video_encoder_get_width (GstBaseVideoEncoder * base_video_encoder)
{ {
return base_video_encoder->state.width; return GST_BASE_VIDEO_CODEC (base_video_encoder)->state.width;
} }
const GstVideoState * const GstVideoState *
gst_base_video_encoder_get_state (GstBaseVideoEncoder * base_video_encoder) gst_base_video_encoder_get_state (GstBaseVideoEncoder * base_video_encoder)
{ {
return &base_video_encoder->state; return &GST_BASE_VIDEO_CODEC (base_video_encoder)->state;
} }
GstFlowReturn GstFlowReturn
@ -583,7 +579,7 @@ gst_base_video_encoder_end_of_stream (GstBaseVideoEncoder * base_video_encoder,
GstBuffer * buffer) GstBuffer * buffer)
{ {
if (base_video_encoder->frames) { if (GST_BASE_VIDEO_CODEC (base_video_encoder)->frames) {
GST_WARNING ("EOS with frames left over"); GST_WARNING ("EOS with frames left over");
} }
@ -612,8 +608,8 @@ gst_base_video_encoder_set_latency_fields (GstBaseVideoEncoder *
gint64 latency; gint64 latency;
latency = gst_util_uint64_scale (n_fields, latency = gst_util_uint64_scale (n_fields,
base_video_encoder->state.fps_d * GST_SECOND, GST_BASE_VIDEO_CODEC (base_video_encoder)->state.fps_d * GST_SECOND,
2 * base_video_encoder->state.fps_n); 2 * GST_BASE_VIDEO_CODEC (base_video_encoder)->state.fps_n);
gst_base_video_encoder_set_latency (base_video_encoder, latency, latency); gst_base_video_encoder_set_latency (base_video_encoder, latency, latency);
@ -625,7 +621,7 @@ gst_base_video_encoder_get_oldest_frame (GstBaseVideoEncoder *
{ {
GList *g; GList *g;
g = g_list_first (base_video_encoder->frames); g = g_list_first (GST_BASE_VIDEO_CODEC (base_video_encoder)->frames);
if (g == NULL) if (g == NULL)
return NULL; return NULL;

12
gst-libs/gst/video/gstbasevideoencoder.h
View file

@ -65,24 +65,20 @@ struct _GstBaseVideoEncoder
GstBaseVideoCodec base_video_codec; GstBaseVideoCodec base_video_codec;
/*< private >*/ /*< private >*/
GList *frames;
GstVideoState state;
GstSegment segment;
gboolean sink_clipping; gboolean sink_clipping;
guint64 presentation_frame_number; guint64 presentation_frame_number;
guint64 system_frame_number;
int distance_from_sync; int distance_from_sync;
GstCaps *caps;
gboolean set_output_caps; gboolean set_output_caps;
gint64 min_latency; gint64 min_latency;
gint64 max_latency; gint64 max_latency;
gboolean force_keyframe; gboolean force_keyframe;
/* FIXME before moving to base */
void *padding[GST_PADDING_LARGE];
}; };
struct _GstBaseVideoEncoderClass struct _GstBaseVideoEncoderClass
@ -97,6 +93,8 @@ struct _GstBaseVideoEncoderClass
GstFlowReturn (*shape_output) (GstBaseVideoEncoder *coder, GstVideoFrame *frame); GstFlowReturn (*shape_output) (GstBaseVideoEncoder *coder, GstVideoFrame *frame);
GstCaps *(*get_caps) (GstBaseVideoEncoder *coder); GstCaps *(*get_caps) (GstBaseVideoEncoder *coder);
/* FIXME before moving to base */
void *padding[GST_PADDING_LARGE];
}; };
GType gst_base_video_encoder_get_type (void); GType gst_base_video_encoder_get_type (void);