mirror of
https://gitlab.freedesktop.org/gstreamer/gstreamer.git
synced 2024-09-29 15:22:17 +00:00
openjpegdec: support for a multithreaded decoding.
Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-bad/-/merge_requests/979>
This commit is contained in:
parent
18c3437546
commit
86be138973
3 changed files with 622 additions and 140 deletions
|
@ -41,9 +41,11 @@ typedef struct
|
||||||
{
|
{
|
||||||
GstVideoCodecFrame *frame;
|
GstVideoCodecFrame *frame;
|
||||||
GstBuffer *output_buffer;
|
GstBuffer *output_buffer;
|
||||||
|
GstBuffer *input_buffer;
|
||||||
gint stripe;
|
gint stripe;
|
||||||
OpenJPEGErrorCode last_error;
|
OpenJPEGErrorCode last_error;
|
||||||
gboolean direct;
|
gboolean direct;
|
||||||
|
gboolean last_subframe;
|
||||||
} GstOpenJPEGCodecMessage;
|
} GstOpenJPEGCodecMessage;
|
||||||
|
|
||||||
#endif /* __GST_OPENJPEG_H__ */
|
#endif /* __GST_OPENJPEG_H__ */
|
||||||
|
|
|
@ -20,6 +20,23 @@
|
||||||
*
|
*
|
||||||
*/
|
*/
|
||||||
|
|
||||||
|
/**
|
||||||
|
* SECTION:element-openjpegdec
|
||||||
|
* @title: openjpegdec
|
||||||
|
* @see_also: openjpegenc
|
||||||
|
*
|
||||||
|
* openjpegdec decodes openjpeg stream.
|
||||||
|
*
|
||||||
|
* ## Example launch lines
|
||||||
|
* |[
|
||||||
|
* gst-launch-1.0 -v videotestsrc num-buffers=10 ! openjpegenc ! jpeg2000parse ! openjpegdec ! videoconvert ! autovideosink sync=false
|
||||||
|
* ]| Encode and decode whole frames.
|
||||||
|
* |[
|
||||||
|
* gst-launch-1.0 -v videotestsrc num-buffers=10 ! openjpegenc num-threads=8 num-stripes=8 ! jpeg2000parse ! openjpegdec max-slice-threads=8 ! videoconvert ! autovideosink sync=fals
|
||||||
|
* ]| Encode and decode frame split with stripes.
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
|
||||||
#ifdef HAVE_CONFIG_H
|
#ifdef HAVE_CONFIG_H
|
||||||
#include "config.h"
|
#include "config.h"
|
||||||
#endif
|
#endif
|
||||||
|
@ -36,15 +53,24 @@ enum
|
||||||
{
|
{
|
||||||
PROP_0,
|
PROP_0,
|
||||||
PROP_MAX_THREADS,
|
PROP_MAX_THREADS,
|
||||||
|
PROP_MAX_SLICE_THREADS,
|
||||||
PROP_LAST
|
PROP_LAST
|
||||||
};
|
};
|
||||||
|
|
||||||
#define GST_OPENJPEG_DEC_DEFAULT_MAX_THREADS 0
|
#define GST_OPENJPEG_DEC_DEFAULT_MAX_THREADS 0
|
||||||
|
|
||||||
|
/* prototypes */
|
||||||
|
static void gst_openjpeg_dec_finalize (GObject * object);
|
||||||
|
|
||||||
|
static GstStateChangeReturn
|
||||||
|
gst_openjpeg_dec_change_state (GstElement * element, GstStateChange transition);
|
||||||
|
|
||||||
static gboolean gst_openjpeg_dec_start (GstVideoDecoder * decoder);
|
static gboolean gst_openjpeg_dec_start (GstVideoDecoder * decoder);
|
||||||
static gboolean gst_openjpeg_dec_stop (GstVideoDecoder * decoder);
|
static gboolean gst_openjpeg_dec_stop (GstVideoDecoder * decoder);
|
||||||
static gboolean gst_openjpeg_dec_set_format (GstVideoDecoder * decoder,
|
static gboolean gst_openjpeg_dec_set_format (GstVideoDecoder * decoder,
|
||||||
GstVideoCodecState * state);
|
GstVideoCodecState * state);
|
||||||
|
static gboolean gst_openjpeg_dec_flush (GstVideoDecoder * decoder);
|
||||||
|
static gboolean gst_openjpeg_dec_finish (GstVideoDecoder * decoder);
|
||||||
static GstFlowReturn gst_openjpeg_dec_handle_frame (GstVideoDecoder * decoder,
|
static GstFlowReturn gst_openjpeg_dec_handle_frame (GstVideoDecoder * decoder,
|
||||||
GstVideoCodecFrame * frame);
|
GstVideoCodecFrame * frame);
|
||||||
static gboolean gst_openjpeg_dec_decide_allocation (GstVideoDecoder * decoder,
|
static gboolean gst_openjpeg_dec_decide_allocation (GstVideoDecoder * decoder,
|
||||||
|
@ -54,6 +80,13 @@ static void gst_openjpeg_dec_set_property (GObject * object,
|
||||||
static void gst_openjpeg_dec_get_property (GObject * object,
|
static void gst_openjpeg_dec_get_property (GObject * object,
|
||||||
guint prop_id, GValue * value, GParamSpec * pspec);
|
guint prop_id, GValue * value, GParamSpec * pspec);
|
||||||
|
|
||||||
|
static gboolean gst_openjpeg_dec_decode_frame_multiple (GstVideoDecoder *
|
||||||
|
decoder, GstVideoCodecFrame * frame);
|
||||||
|
static gboolean gst_openjpeg_dec_decode_frame_single (GstVideoDecoder * decoder,
|
||||||
|
GstVideoCodecFrame * frame);
|
||||||
|
|
||||||
|
static void gst_openjpeg_dec_pause_loop (GstOpenJPEGDec * self,
|
||||||
|
GstFlowReturn flow_ret);
|
||||||
|
|
||||||
#if G_BYTE_ORDER == G_LITTLE_ENDIAN
|
#if G_BYTE_ORDER == G_LITTLE_ENDIAN
|
||||||
#define GRAY16 "GRAY16_LE"
|
#define GRAY16 "GRAY16_LE"
|
||||||
|
@ -110,8 +143,13 @@ gst_openjpeg_dec_class_init (GstOpenJPEGDecClass * klass)
|
||||||
"Decode JPEG2000 streams",
|
"Decode JPEG2000 streams",
|
||||||
"Sebastian Dröge <sebastian.droege@collabora.co.uk>");
|
"Sebastian Dröge <sebastian.droege@collabora.co.uk>");
|
||||||
|
|
||||||
|
element_class->change_state =
|
||||||
|
GST_DEBUG_FUNCPTR (gst_openjpeg_dec_change_state);
|
||||||
|
|
||||||
video_decoder_class->start = GST_DEBUG_FUNCPTR (gst_openjpeg_dec_start);
|
video_decoder_class->start = GST_DEBUG_FUNCPTR (gst_openjpeg_dec_start);
|
||||||
video_decoder_class->stop = GST_DEBUG_FUNCPTR (gst_openjpeg_dec_stop);
|
video_decoder_class->stop = GST_DEBUG_FUNCPTR (gst_openjpeg_dec_stop);
|
||||||
|
video_decoder_class->flush = GST_DEBUG_FUNCPTR (gst_openjpeg_dec_flush);
|
||||||
|
video_decoder_class->finish = GST_DEBUG_FUNCPTR (gst_openjpeg_dec_finish);
|
||||||
video_decoder_class->set_format =
|
video_decoder_class->set_format =
|
||||||
GST_DEBUG_FUNCPTR (gst_openjpeg_dec_set_format);
|
GST_DEBUG_FUNCPTR (gst_openjpeg_dec_set_format);
|
||||||
video_decoder_class->handle_frame =
|
video_decoder_class->handle_frame =
|
||||||
|
@ -119,17 +157,31 @@ gst_openjpeg_dec_class_init (GstOpenJPEGDecClass * klass)
|
||||||
video_decoder_class->decide_allocation = gst_openjpeg_dec_decide_allocation;
|
video_decoder_class->decide_allocation = gst_openjpeg_dec_decide_allocation;
|
||||||
gobject_class->set_property = gst_openjpeg_dec_set_property;
|
gobject_class->set_property = gst_openjpeg_dec_set_property;
|
||||||
gobject_class->get_property = gst_openjpeg_dec_get_property;
|
gobject_class->get_property = gst_openjpeg_dec_get_property;
|
||||||
|
gobject_class->finalize = gst_openjpeg_dec_finalize;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* GstOpenJPEGDec:max-slice-threads:
|
||||||
|
*
|
||||||
|
* Maximum number of worker threads to spawn. (0 = auto)
|
||||||
|
*
|
||||||
|
* Since: 1.20
|
||||||
|
*/
|
||||||
|
g_object_class_install_property (G_OBJECT_CLASS (klass),
|
||||||
|
PROP_MAX_SLICE_THREADS, g_param_spec_int ("max-slice-threads",
|
||||||
|
"Maximum slice decoding threads",
|
||||||
|
"Maximum number of worker threads to spawn according to the frame boundary. (0 = no thread)",
|
||||||
|
0, G_MAXINT, GST_OPENJPEG_DEC_DEFAULT_MAX_THREADS,
|
||||||
|
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
|
||||||
/**
|
/**
|
||||||
* GstOpenJPEGDec:max-threads:
|
* GstOpenJPEGDec:max-threads:
|
||||||
*
|
*
|
||||||
* Maximum number of worker threads to spawn. (0 = auto)
|
* Maximum number of worker threads to spawn used by openjpeg internally. (0 = no thread)
|
||||||
*
|
*
|
||||||
* Since: 1.18
|
* Since: 1.18
|
||||||
*/
|
*/
|
||||||
g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_MAX_THREADS,
|
g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_MAX_THREADS,
|
||||||
g_param_spec_int ("max-threads", "Maximum decode threads",
|
g_param_spec_int ("max-threads", "Maximum openjpeg threads",
|
||||||
"Maximum number of worker threads to spawn. (0 = auto)",
|
"Maximum number of worker threads to spawn used by openjpeg internally. (0 = no thread)",
|
||||||
0, G_MAXINT, GST_OPENJPEG_DEC_DEFAULT_MAX_THREADS,
|
0, G_MAXINT, GST_OPENJPEG_DEC_DEFAULT_MAX_THREADS,
|
||||||
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
|
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
|
||||||
|
|
||||||
|
@ -149,8 +201,13 @@ gst_openjpeg_dec_init (GstOpenJPEGDec * self)
|
||||||
GST_PAD_SET_ACCEPT_TEMPLATE (GST_VIDEO_DECODER_SINK_PAD (self));
|
GST_PAD_SET_ACCEPT_TEMPLATE (GST_VIDEO_DECODER_SINK_PAD (self));
|
||||||
opj_set_default_decoder_parameters (&self->params);
|
opj_set_default_decoder_parameters (&self->params);
|
||||||
self->sampling = GST_JPEG2000_SAMPLING_NONE;
|
self->sampling = GST_JPEG2000_SAMPLING_NONE;
|
||||||
self->max_threads = GST_OPENJPEG_DEC_DEFAULT_MAX_THREADS;
|
self->max_slice_threads = GST_OPENJPEG_DEC_DEFAULT_MAX_THREADS;
|
||||||
|
self->available_threads = GST_OPENJPEG_DEC_DEFAULT_MAX_THREADS;
|
||||||
self->num_procs = g_get_num_processors ();
|
self->num_procs = g_get_num_processors ();
|
||||||
|
g_mutex_init (&self->messages_lock);
|
||||||
|
g_mutex_init (&self->decoding_lock);
|
||||||
|
g_cond_init (&self->messages_cond);
|
||||||
|
g_queue_init (&self->messages);
|
||||||
}
|
}
|
||||||
|
|
||||||
static gboolean
|
static gboolean
|
||||||
|
@ -159,6 +216,11 @@ gst_openjpeg_dec_start (GstVideoDecoder * decoder)
|
||||||
GstOpenJPEGDec *self = GST_OPENJPEG_DEC (decoder);
|
GstOpenJPEGDec *self = GST_OPENJPEG_DEC (decoder);
|
||||||
|
|
||||||
GST_DEBUG_OBJECT (self, "Starting");
|
GST_DEBUG_OBJECT (self, "Starting");
|
||||||
|
self->available_threads = self->max_slice_threads;
|
||||||
|
if (self->available_threads)
|
||||||
|
self->decode_frame = gst_openjpeg_dec_decode_frame_multiple;
|
||||||
|
else
|
||||||
|
self->decode_frame = gst_openjpeg_dec_decode_frame_single;
|
||||||
|
|
||||||
return TRUE;
|
return TRUE;
|
||||||
}
|
}
|
||||||
|
@ -169,6 +231,8 @@ gst_openjpeg_dec_stop (GstVideoDecoder * video_decoder)
|
||||||
GstOpenJPEGDec *self = GST_OPENJPEG_DEC (video_decoder);
|
GstOpenJPEGDec *self = GST_OPENJPEG_DEC (video_decoder);
|
||||||
|
|
||||||
GST_DEBUG_OBJECT (self, "Stopping");
|
GST_DEBUG_OBJECT (self, "Stopping");
|
||||||
|
g_mutex_lock (&self->messages_lock);
|
||||||
|
gst_pad_stop_task (GST_VIDEO_DECODER_SRC_PAD (video_decoder));
|
||||||
|
|
||||||
if (self->output_state) {
|
if (self->output_state) {
|
||||||
gst_video_codec_state_unref (self->output_state);
|
gst_video_codec_state_unref (self->output_state);
|
||||||
|
@ -179,16 +243,77 @@ gst_openjpeg_dec_stop (GstVideoDecoder * video_decoder)
|
||||||
gst_video_codec_state_unref (self->input_state);
|
gst_video_codec_state_unref (self->input_state);
|
||||||
self->input_state = NULL;
|
self->input_state = NULL;
|
||||||
}
|
}
|
||||||
|
g_mutex_unlock (&self->messages_lock);
|
||||||
if (self->current_frame) {
|
|
||||||
gst_video_codec_frame_unref (self->current_frame);
|
|
||||||
self->current_frame = NULL;
|
|
||||||
}
|
|
||||||
GST_DEBUG_OBJECT (self, "Stopped");
|
GST_DEBUG_OBJECT (self, "Stopped");
|
||||||
|
|
||||||
return TRUE;
|
return TRUE;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
static void
|
||||||
|
gst_openjpeg_dec_finalize (GObject * object)
|
||||||
|
{
|
||||||
|
GstOpenJPEGDec *self = GST_OPENJPEG_DEC (object);
|
||||||
|
|
||||||
|
g_mutex_clear (&self->messages_lock);
|
||||||
|
g_mutex_clear (&self->decoding_lock);
|
||||||
|
g_cond_clear (&self->messages_cond);
|
||||||
|
|
||||||
|
G_OBJECT_CLASS (parent_class)->finalize (object);
|
||||||
|
}
|
||||||
|
|
||||||
|
static GstStateChangeReturn
|
||||||
|
gst_openjpeg_dec_change_state (GstElement * element, GstStateChange transition)
|
||||||
|
{
|
||||||
|
GstOpenJPEGDec *self;
|
||||||
|
GstStateChangeReturn ret = GST_STATE_CHANGE_SUCCESS;
|
||||||
|
|
||||||
|
g_return_val_if_fail (GST_IS_OPENJPEG_DEC (element),
|
||||||
|
GST_STATE_CHANGE_FAILURE);
|
||||||
|
self = GST_OPENJPEG_DEC (element);
|
||||||
|
|
||||||
|
switch (transition) {
|
||||||
|
case GST_STATE_CHANGE_NULL_TO_READY:
|
||||||
|
break;
|
||||||
|
case GST_STATE_CHANGE_READY_TO_PAUSED:
|
||||||
|
self->draining = FALSE;
|
||||||
|
self->started = FALSE;
|
||||||
|
self->flushing = FALSE;
|
||||||
|
break;
|
||||||
|
case GST_STATE_CHANGE_PAUSED_TO_PLAYING:
|
||||||
|
break;
|
||||||
|
case GST_STATE_CHANGE_PAUSED_TO_READY:
|
||||||
|
self->flushing = TRUE;
|
||||||
|
g_mutex_lock (&self->drain_lock);
|
||||||
|
self->draining = FALSE;
|
||||||
|
g_cond_broadcast (&self->drain_cond);
|
||||||
|
g_mutex_unlock (&self->drain_lock);
|
||||||
|
break;
|
||||||
|
default:
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
ret =
|
||||||
|
GST_ELEMENT_CLASS (gst_openjpeg_dec_parent_class)->change_state
|
||||||
|
(element, transition);
|
||||||
|
|
||||||
|
if (ret == GST_STATE_CHANGE_FAILURE)
|
||||||
|
return ret;
|
||||||
|
|
||||||
|
switch (transition) {
|
||||||
|
case GST_STATE_CHANGE_PLAYING_TO_PAUSED:
|
||||||
|
break;
|
||||||
|
case GST_STATE_CHANGE_PAUSED_TO_READY:
|
||||||
|
self->started = FALSE;
|
||||||
|
self->downstream_flow_ret = GST_FLOW_FLUSHING;
|
||||||
|
break;
|
||||||
|
case GST_STATE_CHANGE_READY_TO_NULL:
|
||||||
|
break;
|
||||||
|
default:
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
|
||||||
static void
|
static void
|
||||||
gst_openjpeg_dec_set_property (GObject * object,
|
gst_openjpeg_dec_set_property (GObject * object,
|
||||||
|
@ -197,6 +322,9 @@ gst_openjpeg_dec_set_property (GObject * object,
|
||||||
GstOpenJPEGDec *dec = (GstOpenJPEGDec *) object;
|
GstOpenJPEGDec *dec = (GstOpenJPEGDec *) object;
|
||||||
|
|
||||||
switch (prop_id) {
|
switch (prop_id) {
|
||||||
|
case PROP_MAX_SLICE_THREADS:
|
||||||
|
g_atomic_int_set (&dec->max_slice_threads, g_value_get_int (value));
|
||||||
|
break;
|
||||||
case PROP_MAX_THREADS:
|
case PROP_MAX_THREADS:
|
||||||
g_atomic_int_set (&dec->max_threads, g_value_get_int (value));
|
g_atomic_int_set (&dec->max_threads, g_value_get_int (value));
|
||||||
break;
|
break;
|
||||||
|
@ -213,6 +341,9 @@ gst_openjpeg_dec_get_property (GObject * object,
|
||||||
GstOpenJPEGDec *dec = (GstOpenJPEGDec *) object;
|
GstOpenJPEGDec *dec = (GstOpenJPEGDec *) object;
|
||||||
|
|
||||||
switch (prop_id) {
|
switch (prop_id) {
|
||||||
|
case PROP_MAX_SLICE_THREADS:
|
||||||
|
g_value_set_int (value, g_atomic_int_get (&dec->max_slice_threads));
|
||||||
|
break;
|
||||||
case PROP_MAX_THREADS:
|
case PROP_MAX_THREADS:
|
||||||
g_value_set_int (value, g_atomic_int_get (&dec->max_threads));
|
g_value_set_int (value, g_atomic_int_get (&dec->max_threads));
|
||||||
break;
|
break;
|
||||||
|
@ -313,6 +444,7 @@ fill_frame_packed8_4 (GstOpenJPEGDec * self, GstVideoFrame * frame,
|
||||||
/* copy only the stripe content (image) to the full size frame */
|
/* copy only the stripe content (image) to the full size frame */
|
||||||
y0 = image->y0;
|
y0 = image->y0;
|
||||||
y1 = image->y1;
|
y1 = image->y1;
|
||||||
|
GST_DEBUG_OBJECT (self, "yo=%d y1=%d", y0, y1);
|
||||||
data_out += y0 * dstride;
|
data_out += y0 * dstride;
|
||||||
for (y = y0; y < y1; y++) {
|
for (y = y0; y < y1; y++) {
|
||||||
tmp = data_out;
|
tmp = data_out;
|
||||||
|
@ -841,6 +973,9 @@ gst_openjpeg_dec_negotiate (GstOpenJPEGDec * self, opj_image_t * image)
|
||||||
if (image->color_space == OPJ_CLRSPC_UNKNOWN || image->color_space == 0)
|
if (image->color_space == OPJ_CLRSPC_UNKNOWN || image->color_space == 0)
|
||||||
image->color_space = self->color_space;
|
image->color_space = self->color_space;
|
||||||
|
|
||||||
|
if (!self->input_state)
|
||||||
|
return GST_FLOW_FLUSHING;
|
||||||
|
|
||||||
switch (image->color_space) {
|
switch (image->color_space) {
|
||||||
case OPJ_CLRSPC_SRGB:
|
case OPJ_CLRSPC_SRGB:
|
||||||
if (image->numcomps == 4) {
|
if (image->numcomps == 4) {
|
||||||
|
@ -1146,64 +1281,221 @@ seek_fn (OPJ_OFF_T p_nb_bytes, void *p_user_data)
|
||||||
return OPJ_TRUE;
|
return OPJ_TRUE;
|
||||||
}
|
}
|
||||||
|
|
||||||
static void
|
static gboolean
|
||||||
gst_openjpeg_dec_handle_frame_cleanup (GstOpenJPEGDec * self,
|
gst_openjpeg_dec_is_last_input_subframe (GstVideoDecoder * dec,
|
||||||
GstVideoCodecFrame * frame,
|
GstOpenJPEGCodecMessage * message)
|
||||||
GstMapInfo * map,
|
|
||||||
opj_codec_t * dec, opj_stream_t * stream, opj_image_t * image)
|
|
||||||
{
|
{
|
||||||
if (image)
|
GstOpenJPEGDec *self = GST_OPENJPEG_DEC (dec);
|
||||||
opj_image_destroy (image);
|
|
||||||
if (stream)
|
return (message->last_subframe || message->stripe == self->num_stripes);
|
||||||
opj_stream_destroy (stream);
|
|
||||||
if (dec)
|
|
||||||
opj_destroy_codec (dec);
|
|
||||||
if (frame) {
|
|
||||||
if (map)
|
|
||||||
gst_buffer_unmap (frame->input_buffer, map);
|
|
||||||
gst_video_codec_frame_unref (frame);
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
static GstFlowReturn
|
static gboolean
|
||||||
gst_openjpeg_dec_handle_frame (GstVideoDecoder * decoder,
|
gst_openjpeg_dec_is_last_output_subframe (GstVideoDecoder * dec,
|
||||||
GstVideoCodecFrame * frame)
|
GstOpenJPEGCodecMessage * message)
|
||||||
{
|
{
|
||||||
GstOpenJPEGDec *self = GST_OPENJPEG_DEC (decoder);
|
GstOpenJPEGDec *self = GST_OPENJPEG_DEC (dec);
|
||||||
GstFlowReturn ret = GST_FLOW_OK;
|
|
||||||
gint64 deadline;
|
return (gst_video_decoder_get_processed_subframe_index (dec,
|
||||||
|
message->frame) == (self->num_stripes - 1));
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
static gboolean
|
||||||
|
gst_openjpeg_dec_has_pending_job_to_finish (GstOpenJPEGDec * self)
|
||||||
|
{
|
||||||
|
gboolean res = FALSE;
|
||||||
|
if (self->downstream_flow_ret != GST_FLOW_OK)
|
||||||
|
return res;
|
||||||
|
g_mutex_lock (&self->messages_lock);
|
||||||
|
res = (!g_queue_is_empty (&self->messages)
|
||||||
|
|| (self->available_threads < self->max_slice_threads));
|
||||||
|
g_mutex_unlock (&self->messages_lock);
|
||||||
|
return res;
|
||||||
|
}
|
||||||
|
|
||||||
|
static GstOpenJPEGCodecMessage *
|
||||||
|
gst_openjpeg_decode_message_new (GstOpenJPEGDec * self,
|
||||||
|
GstVideoCodecFrame * frame, int num_stripe)
|
||||||
|
{
|
||||||
|
GstOpenJPEGCodecMessage *message = g_slice_new0 (GstOpenJPEGCodecMessage);
|
||||||
|
GST_DEBUG_OBJECT (self, "message: %p", message);
|
||||||
|
message->frame = gst_video_codec_frame_ref (frame);
|
||||||
|
message->stripe = num_stripe;
|
||||||
|
message->last_error = OPENJPEG_ERROR_NONE;
|
||||||
|
message->input_buffer = gst_buffer_ref (frame->input_buffer);
|
||||||
|
message->last_subframe = GST_BUFFER_FLAG_IS_SET (frame->input_buffer,
|
||||||
|
GST_BUFFER_FLAG_MARKER);
|
||||||
|
return message;
|
||||||
|
}
|
||||||
|
|
||||||
|
static GstOpenJPEGCodecMessage *
|
||||||
|
gst_openjpeg_decode_message_free (GstOpenJPEGDec * self,
|
||||||
|
GstOpenJPEGCodecMessage * message)
|
||||||
|
{
|
||||||
|
if (!message)
|
||||||
|
return message;
|
||||||
|
gst_buffer_unref (message->input_buffer);
|
||||||
|
gst_video_codec_frame_unref (message->frame);
|
||||||
|
GST_DEBUG_OBJECT (self, "message: %p", message);
|
||||||
|
g_slice_free (GstOpenJPEGCodecMessage, message);
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
static GstOpenJPEGCodecMessage *
|
||||||
|
gst_openjpeg_dec_wait_for_new_message (GstOpenJPEGDec * self, gboolean dry_run)
|
||||||
|
{
|
||||||
|
GstOpenJPEGCodecMessage *message = NULL;
|
||||||
|
g_mutex_lock (&self->messages_lock);
|
||||||
|
if (dry_run && self->available_threads == self->max_slice_threads)
|
||||||
|
goto done;
|
||||||
|
if (!g_queue_is_empty (&self->messages) && !dry_run) {
|
||||||
|
message = g_queue_pop_head (&self->messages);
|
||||||
|
} else {
|
||||||
|
g_cond_wait (&self->messages_cond, &self->messages_lock);
|
||||||
|
}
|
||||||
|
|
||||||
|
done:
|
||||||
|
g_mutex_unlock (&self->messages_lock);
|
||||||
|
return message;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void
|
||||||
|
gst_openjpeg_dec_pause_loop (GstOpenJPEGDec * self, GstFlowReturn flow_ret)
|
||||||
|
{
|
||||||
|
g_mutex_lock (&self->drain_lock);
|
||||||
|
GST_DEBUG_OBJECT (self, "Pause the loop draining %d flow_ret %s",
|
||||||
|
self->draining, gst_flow_get_name (flow_ret));
|
||||||
|
if (self->draining) {
|
||||||
|
self->draining = FALSE;
|
||||||
|
g_cond_broadcast (&self->drain_cond);
|
||||||
|
}
|
||||||
|
gst_pad_pause_task (GST_VIDEO_DECODER_SRC_PAD (self));
|
||||||
|
self->downstream_flow_ret = flow_ret;
|
||||||
|
self->started = FALSE;
|
||||||
|
g_mutex_unlock (&self->drain_lock);
|
||||||
|
}
|
||||||
|
|
||||||
|
static void
|
||||||
|
gst_openjpeg_dec_loop (GstOpenJPEGDec * self)
|
||||||
|
{
|
||||||
|
GstOpenJPEGCodecMessage *message;
|
||||||
|
GstVideoDecoder *decoder = GST_VIDEO_DECODER (self);
|
||||||
|
GstFlowReturn flow_ret = GST_FLOW_OK;
|
||||||
|
|
||||||
|
message = gst_openjpeg_dec_wait_for_new_message (self, FALSE);
|
||||||
|
if (message) {
|
||||||
|
GST_DEBUG_OBJECT (self,
|
||||||
|
"received message for frame %p stripe %d last_error %d threads %d",
|
||||||
|
message->frame, message->stripe, message->last_error,
|
||||||
|
self->available_threads);
|
||||||
|
|
||||||
|
if (self->flushing)
|
||||||
|
goto flushing;
|
||||||
|
|
||||||
|
if (message->last_error != OPENJPEG_ERROR_NONE)
|
||||||
|
goto decode_error;
|
||||||
|
|
||||||
|
g_mutex_lock (&self->decoding_lock);
|
||||||
|
|
||||||
|
if (gst_openjpeg_dec_is_last_output_subframe (decoder, message))
|
||||||
|
flow_ret = gst_video_decoder_finish_frame (decoder, message->frame);
|
||||||
|
else
|
||||||
|
gst_video_decoder_finish_subframe (decoder, message->frame);
|
||||||
|
g_mutex_unlock (&self->decoding_lock);
|
||||||
|
message = gst_openjpeg_decode_message_free (self, message);
|
||||||
|
g_cond_broadcast (&self->messages_cond);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (flow_ret != GST_FLOW_OK)
|
||||||
|
goto flow_error;
|
||||||
|
|
||||||
|
if (self->draining && !gst_openjpeg_dec_has_pending_job_to_finish (self))
|
||||||
|
gst_openjpeg_dec_pause_loop (self, GST_FLOW_OK);
|
||||||
|
|
||||||
|
if (self->flushing)
|
||||||
|
goto flushing;
|
||||||
|
|
||||||
|
return;
|
||||||
|
|
||||||
|
decode_error:
|
||||||
|
{
|
||||||
|
GST_ELEMENT_ERROR (self, LIBRARY, FAILED, (NULL),
|
||||||
|
("OPEN JPEG decode fail %d", message->last_error));
|
||||||
|
gst_video_codec_frame_unref (message->frame);
|
||||||
|
gst_pad_push_event (GST_VIDEO_DECODER_SRC_PAD (self), gst_event_new_eos ());
|
||||||
|
gst_openjpeg_dec_pause_loop (self, GST_FLOW_ERROR);
|
||||||
|
gst_openjpeg_decode_message_free (self, message);
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
flushing:
|
||||||
|
{
|
||||||
|
GST_DEBUG_OBJECT (self, "Flushing -- stopping task");
|
||||||
|
if (message) {
|
||||||
|
gst_video_codec_frame_unref (message->frame);
|
||||||
|
gst_openjpeg_decode_message_free (self, message);
|
||||||
|
}
|
||||||
|
gst_openjpeg_dec_pause_loop (self, GST_FLOW_FLUSHING);
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
flow_error:
|
||||||
|
{
|
||||||
|
if (flow_ret == GST_FLOW_EOS) {
|
||||||
|
GST_DEBUG_OBJECT (self, "EOS");
|
||||||
|
|
||||||
|
gst_pad_push_event (GST_VIDEO_DECODER_SRC_PAD (self),
|
||||||
|
gst_event_new_eos ());
|
||||||
|
} else if (flow_ret < GST_FLOW_EOS) {
|
||||||
|
GST_ELEMENT_ERROR (self, STREAM, FAILED,
|
||||||
|
("Internal data stream error."), ("stream stopped, reason %s",
|
||||||
|
gst_flow_get_name (flow_ret)));
|
||||||
|
|
||||||
|
gst_pad_push_event (GST_VIDEO_DECODER_SRC_PAD (self),
|
||||||
|
gst_event_new_eos ());
|
||||||
|
} else if (flow_ret == GST_FLOW_FLUSHING) {
|
||||||
|
GST_DEBUG_OBJECT (self, "Flushing -- stopping task");
|
||||||
|
}
|
||||||
|
gst_openjpeg_dec_pause_loop (self, flow_ret);
|
||||||
|
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
#define DECODE_ERROR(self, message, err_code, mutex_unlock) { \
|
||||||
|
GST_WARNING_OBJECT(self, "An error occurred err_code=%d", err_code);\
|
||||||
|
message->last_error = err_code; \
|
||||||
|
if (mutex_unlock) \
|
||||||
|
g_mutex_unlock (&self->decoding_lock);\
|
||||||
|
goto done; \
|
||||||
|
}
|
||||||
|
|
||||||
|
static void
|
||||||
|
gst_openjpeg_dec_decode_stripe (GstElement * element, gpointer user_data)
|
||||||
|
{
|
||||||
|
GstOpenJPEGDec *self = GST_OPENJPEG_DEC (element);
|
||||||
|
GstVideoDecoder *decoder = GST_VIDEO_DECODER (element);
|
||||||
|
GstOpenJPEGCodecMessage *message = (GstOpenJPEGCodecMessage *) user_data;
|
||||||
GstMapInfo map;
|
GstMapInfo map;
|
||||||
|
GstVideoFrame vframe;
|
||||||
opj_codec_t *dec = NULL;
|
opj_codec_t *dec = NULL;
|
||||||
opj_stream_t *stream = NULL;
|
opj_stream_t *stream = NULL;
|
||||||
MemStream mstream;
|
MemStream mstream;
|
||||||
opj_image_t *image = NULL;
|
opj_image_t *image = NULL;
|
||||||
GstVideoFrame vframe;
|
|
||||||
opj_dparameters_t params;
|
opj_dparameters_t params;
|
||||||
gint max_threads;
|
gint max_threads;
|
||||||
guint current_stripe = 1;
|
|
||||||
|
|
||||||
current_stripe = gst_video_decoder_get_current_subframe_index (decoder);
|
GstFlowReturn ret;
|
||||||
|
gint i;
|
||||||
|
|
||||||
GST_DEBUG_OBJECT (self, "Handling frame with current stripe %d",
|
GST_DEBUG_OBJECT (self, "Start to decode stripe %p %d", message->frame,
|
||||||
current_stripe);
|
message->stripe);
|
||||||
|
|
||||||
deadline = gst_video_decoder_get_max_decode_time (decoder, frame);
|
|
||||||
if (self->drop_subframes || deadline < 0) {
|
|
||||||
GST_INFO_OBJECT (self,
|
|
||||||
"Dropping too late frame: deadline %" G_GINT64_FORMAT, deadline);
|
|
||||||
self->drop_subframes = TRUE;
|
|
||||||
if (current_stripe == self->num_stripes) {
|
|
||||||
ret = gst_video_decoder_drop_frame (decoder, frame);
|
|
||||||
self->drop_subframes = FALSE;
|
|
||||||
} else
|
|
||||||
gst_video_decoder_drop_subframe (decoder, frame);
|
|
||||||
|
|
||||||
return ret;
|
|
||||||
}
|
|
||||||
|
|
||||||
dec = opj_create_decompress (self->codec_format);
|
dec = opj_create_decompress (self->codec_format);
|
||||||
if (!dec)
|
if (!dec)
|
||||||
goto initialization_error;
|
DECODE_ERROR (self, message, OPENJPEG_ERROR_INIT, FALSE);
|
||||||
|
|
||||||
if (G_UNLIKELY (gst_debug_category_get_threshold (GST_CAT_DEFAULT) >=
|
if (G_UNLIKELY (gst_debug_category_get_threshold (GST_CAT_DEFAULT) >=
|
||||||
GST_LEVEL_TRACE)) {
|
GST_LEVEL_TRACE)) {
|
||||||
|
@ -1220,24 +1512,25 @@ gst_openjpeg_dec_handle_frame (GstVideoDecoder * decoder,
|
||||||
if (self->ncomps)
|
if (self->ncomps)
|
||||||
params.jpwl_exp_comps = self->ncomps;
|
params.jpwl_exp_comps = self->ncomps;
|
||||||
if (!opj_setup_decoder (dec, ¶ms))
|
if (!opj_setup_decoder (dec, ¶ms))
|
||||||
goto open_error;
|
DECODE_ERROR (self, message, OPENJPEG_ERROR_OPEN, FALSE);
|
||||||
|
|
||||||
max_threads = g_atomic_int_get (&self->max_threads);
|
max_threads = g_atomic_int_get (&self->max_threads);
|
||||||
if (max_threads == 0)
|
if (max_threads > self->num_procs)
|
||||||
max_threads = self->num_procs;
|
max_threads = self->num_procs;
|
||||||
if (!opj_codec_set_threads (dec, max_threads))
|
if (!opj_codec_set_threads (dec, max_threads))
|
||||||
GST_WARNING_OBJECT (self, "Failed to set %d number of threads",
|
GST_WARNING_OBJECT (self, "Failed to set %d number of threads",
|
||||||
max_threads);
|
max_threads);
|
||||||
|
|
||||||
if (!gst_buffer_map (frame->input_buffer, &map, GST_MAP_READ))
|
if (!gst_buffer_map (message->input_buffer, &map, GST_MAP_READ))
|
||||||
goto map_read_error;
|
DECODE_ERROR (self, message, OPENJPEG_ERROR_MAP_READ, FALSE);
|
||||||
|
|
||||||
|
|
||||||
if (self->is_jp2c && map.size < 8)
|
if (self->is_jp2c && map.size < 8)
|
||||||
goto open_error;
|
DECODE_ERROR (self, message, OPENJPEG_ERROR_MAP_READ, FALSE);
|
||||||
|
|
||||||
stream = opj_stream_create (4096, OPJ_TRUE);
|
stream = opj_stream_create (4096, OPJ_TRUE);
|
||||||
if (!stream)
|
if (!stream)
|
||||||
goto open_error;
|
DECODE_ERROR (self, message, OPENJPEG_ERROR_OPEN, FALSE);
|
||||||
|
|
||||||
mstream.data = map.data + (self->is_jp2c ? 8 : 0);
|
mstream.data = map.data + (self->is_jp2c ? 8 : 0);
|
||||||
mstream.offset = 0;
|
mstream.offset = 0;
|
||||||
|
@ -1252,120 +1545,286 @@ gst_openjpeg_dec_handle_frame (GstVideoDecoder * decoder,
|
||||||
|
|
||||||
image = NULL;
|
image = NULL;
|
||||||
if (!opj_read_header (stream, dec, &image))
|
if (!opj_read_header (stream, dec, &image))
|
||||||
goto decode_error;
|
DECODE_ERROR (self, message, OPENJPEG_ERROR_DECODE, FALSE);
|
||||||
|
|
||||||
if (!opj_decode (dec, stream, image))
|
if (!opj_decode (dec, stream, image))
|
||||||
goto decode_error;
|
DECODE_ERROR (self, message, OPENJPEG_ERROR_DECODE, FALSE);
|
||||||
|
|
||||||
{
|
|
||||||
gint i;
|
|
||||||
|
|
||||||
for (i = 0; i < image->numcomps; i++) {
|
for (i = 0; i < image->numcomps; i++) {
|
||||||
if (image->comps[i].data == NULL)
|
if (image->comps[i].data == NULL)
|
||||||
goto decode_error;
|
DECODE_ERROR (self, message, OPENJPEG_ERROR_DECODE, FALSE);
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
gst_buffer_unmap (frame->input_buffer, &map);
|
gst_buffer_unmap (message->input_buffer, &map);
|
||||||
|
|
||||||
|
g_mutex_lock (&self->decoding_lock);
|
||||||
|
|
||||||
ret = gst_openjpeg_dec_negotiate (self, image);
|
ret = gst_openjpeg_dec_negotiate (self, image);
|
||||||
if (ret != GST_FLOW_OK)
|
if (ret != GST_FLOW_OK)
|
||||||
goto negotiate_error;
|
DECODE_ERROR (self, message, OPENJPEG_ERROR_NEGOCIATE, TRUE);
|
||||||
if (!gst_video_decoder_get_subframe_mode (decoder)
|
|
||||||
|| gst_video_decoder_get_current_subframe_index (decoder) == 1) {
|
if (message->frame->output_buffer == NULL) {
|
||||||
ret = gst_video_decoder_allocate_output_frame (decoder, frame);
|
ret = gst_video_decoder_allocate_output_frame (decoder, message->frame);
|
||||||
if (ret != GST_FLOW_OK)
|
if (ret != GST_FLOW_OK)
|
||||||
goto allocate_error;
|
DECODE_ERROR (self, message, OPENJPEG_ERROR_ALLOCATE, TRUE);
|
||||||
self->current_frame = gst_video_codec_frame_ref (frame);
|
|
||||||
}
|
}
|
||||||
|
|
||||||
if (!gst_video_frame_map (&vframe, &self->output_state->info,
|
if (!gst_video_frame_map (&vframe, &self->output_state->info,
|
||||||
self->current_frame->output_buffer, GST_MAP_WRITE))
|
message->frame->output_buffer, GST_MAP_WRITE))
|
||||||
goto map_write_error;
|
DECODE_ERROR (self, message, OPENJPEG_ERROR_MAP_WRITE, TRUE);
|
||||||
|
|
||||||
if (current_stripe)
|
if (message->stripe)
|
||||||
self->fill_frame (self, &vframe, image);
|
self->fill_frame (self, &vframe, image);
|
||||||
else {
|
else {
|
||||||
GST_ERROR_OBJECT (decoder, " current_stripe should be greater than 0");
|
GST_ERROR_OBJECT (decoder, " current_stripe should be greater than 0");
|
||||||
goto map_write_error;
|
DECODE_ERROR (self, message, OPENJPEG_ERROR_MAP_WRITE, TRUE);
|
||||||
}
|
}
|
||||||
gst_video_frame_unmap (&vframe);
|
gst_video_frame_unmap (&vframe);
|
||||||
|
g_mutex_unlock (&self->decoding_lock);
|
||||||
|
message->last_error = OPENJPEG_ERROR_NONE;
|
||||||
|
GST_DEBUG_OBJECT (self, "Finished to decode stripe message=%p stripe=%d",
|
||||||
|
message->frame, message->stripe);
|
||||||
|
done:
|
||||||
|
if (!message->direct) {
|
||||||
|
g_mutex_lock (&self->messages_lock);
|
||||||
|
self->available_threads++;
|
||||||
|
g_queue_push_tail (&self->messages, message);
|
||||||
|
g_mutex_unlock (&self->messages_lock);
|
||||||
|
g_cond_broadcast (&self->messages_cond);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (stream) {
|
||||||
opj_end_decompress (dec, stream);
|
opj_end_decompress (dec, stream);
|
||||||
opj_stream_destroy (stream);
|
opj_stream_destroy (stream);
|
||||||
|
}
|
||||||
|
if (image)
|
||||||
opj_image_destroy (image);
|
opj_image_destroy (image);
|
||||||
|
if (dec)
|
||||||
opj_destroy_codec (dec);
|
opj_destroy_codec (dec);
|
||||||
|
}
|
||||||
|
|
||||||
if (current_stripe == self->num_stripes) {
|
static GstFlowReturn
|
||||||
ret = gst_video_decoder_finish_frame (decoder, self->current_frame);
|
gst_openjpeg_dec_decode_frame_multiple (GstVideoDecoder * decoder,
|
||||||
gst_video_codec_frame_unref (frame);
|
GstVideoCodecFrame * frame)
|
||||||
self->current_frame = NULL;
|
{
|
||||||
} else if (gst_video_decoder_get_current_subframe_index (decoder) > 0)
|
GstOpenJPEGDec *self = GST_OPENJPEG_DEC (decoder);
|
||||||
gst_video_codec_frame_unref (frame);
|
GstOpenJPEGCodecMessage *message = NULL;
|
||||||
|
guint current_stripe =
|
||||||
|
gst_video_decoder_get_input_subframe_index (decoder, frame);
|
||||||
|
|
||||||
|
if (!self->started) {
|
||||||
|
GST_DEBUG_OBJECT (self, "Starting task");
|
||||||
|
gst_pad_start_task (GST_VIDEO_DECODER_SRC_PAD (self),
|
||||||
|
(GstTaskFunction) gst_openjpeg_dec_loop, decoder, NULL);
|
||||||
|
self->started = TRUE;
|
||||||
|
}
|
||||||
|
/* Make sure to release the base class stream lock, otherwise
|
||||||
|
* _loop() can't call _finish_frame() and we might block forever
|
||||||
|
* because no input buffers are released */
|
||||||
|
GST_VIDEO_DECODER_STREAM_UNLOCK (self);
|
||||||
|
|
||||||
|
while (!self->available_threads)
|
||||||
|
gst_openjpeg_dec_wait_for_new_message (self, TRUE);
|
||||||
|
|
||||||
|
GST_VIDEO_DECODER_STREAM_LOCK (self);
|
||||||
|
|
||||||
|
if (self->downstream_flow_ret != GST_FLOW_OK)
|
||||||
|
return self->downstream_flow_ret;
|
||||||
|
|
||||||
|
g_mutex_lock (&self->messages_lock);
|
||||||
|
message = gst_openjpeg_decode_message_new (self, frame, current_stripe);
|
||||||
|
GST_LOG_OBJECT (self,
|
||||||
|
"About to enqueue a decoding message from frame %p stripe %d", frame,
|
||||||
|
message->stripe);
|
||||||
|
|
||||||
|
if (self->available_threads)
|
||||||
|
self->available_threads--;
|
||||||
|
g_mutex_unlock (&self->messages_lock);
|
||||||
|
|
||||||
|
gst_element_call_async (GST_ELEMENT (self),
|
||||||
|
(GstElementCallAsyncFunc) gst_openjpeg_dec_decode_stripe, message, NULL);
|
||||||
|
if (gst_video_decoder_get_subframe_mode (decoder)
|
||||||
|
&& gst_openjpeg_dec_is_last_input_subframe (decoder, message))
|
||||||
|
gst_video_decoder_have_last_subframe (decoder, frame);
|
||||||
|
return GST_FLOW_OK;
|
||||||
|
}
|
||||||
|
|
||||||
|
static GstFlowReturn
|
||||||
|
gst_openjpeg_dec_decode_frame_single (GstVideoDecoder * decoder,
|
||||||
|
GstVideoCodecFrame * frame)
|
||||||
|
{
|
||||||
|
GstOpenJPEGDec *self = GST_OPENJPEG_DEC (decoder);
|
||||||
|
GstOpenJPEGCodecMessage *message = NULL;
|
||||||
|
guint current_stripe =
|
||||||
|
gst_video_decoder_get_input_subframe_index (decoder, frame);
|
||||||
|
GstFlowReturn ret = GST_FLOW_OK;
|
||||||
|
|
||||||
|
message = gst_openjpeg_decode_message_new (self, frame, current_stripe);
|
||||||
|
message->direct = TRUE;
|
||||||
|
gst_openjpeg_dec_decode_stripe (GST_ELEMENT (decoder), message);
|
||||||
|
if (message->last_error != OPENJPEG_ERROR_NONE) {
|
||||||
|
GST_WARNING_OBJECT
|
||||||
|
(self, "An error occured %d during the JPEG decoding",
|
||||||
|
message->last_error);
|
||||||
|
self->last_error = message->last_error;
|
||||||
|
ret = GST_FLOW_ERROR;
|
||||||
|
goto done;
|
||||||
|
}
|
||||||
|
if (gst_openjpeg_dec_is_last_output_subframe (decoder, message))
|
||||||
|
ret = gst_video_decoder_finish_frame (decoder, message->frame);
|
||||||
|
else
|
||||||
|
gst_video_decoder_finish_subframe (decoder, message->frame);
|
||||||
|
|
||||||
|
done:
|
||||||
|
gst_openjpeg_decode_message_free (self, message);
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
|
||||||
|
static gboolean
|
||||||
|
gst_openjpeg_dec_flush (GstVideoDecoder * decoder)
|
||||||
|
{
|
||||||
|
GstOpenJPEGDec *self = GST_OPENJPEG_DEC (decoder);
|
||||||
|
|
||||||
|
GST_DEBUG_OBJECT (self, "Flushing decoder");
|
||||||
|
|
||||||
|
/* 2) Wait until the srcpad loop is stopped,
|
||||||
|
* unlock GST_VIDEO_DECODER_STREAM_LOCK to prevent deadlocks
|
||||||
|
* caused by using this lock from inside the loop function */
|
||||||
|
GST_VIDEO_DECODER_STREAM_UNLOCK (self);
|
||||||
|
gst_pad_stop_task (GST_VIDEO_DECODER_SRC_PAD (decoder));
|
||||||
|
GST_DEBUG_OBJECT (self, "Flushing -- task stopped");
|
||||||
|
GST_VIDEO_DECODER_STREAM_LOCK (self);
|
||||||
|
|
||||||
|
/* Reset our state */
|
||||||
|
self->started = FALSE;
|
||||||
|
GST_DEBUG_OBJECT (self, "Flush finished");
|
||||||
|
|
||||||
|
return TRUE;
|
||||||
|
}
|
||||||
|
|
||||||
|
static GstFlowReturn
|
||||||
|
gst_openjpeg_dec_handle_frame (GstVideoDecoder * decoder,
|
||||||
|
GstVideoCodecFrame * frame)
|
||||||
|
{
|
||||||
|
GstOpenJPEGDec *self = GST_OPENJPEG_DEC (decoder);
|
||||||
|
GstFlowReturn ret = GST_FLOW_OK;
|
||||||
|
gint64 deadline;
|
||||||
|
guint current_stripe =
|
||||||
|
gst_video_decoder_get_input_subframe_index (decoder, frame);
|
||||||
|
|
||||||
|
if (self->downstream_flow_ret != GST_FLOW_OK) {
|
||||||
|
gst_video_codec_frame_unref (frame);
|
||||||
|
return self->downstream_flow_ret;
|
||||||
|
}
|
||||||
|
|
||||||
|
GST_DEBUG_OBJECT (self, "Handling frame with current stripe %d",
|
||||||
|
current_stripe);
|
||||||
|
|
||||||
|
deadline = gst_video_decoder_get_max_decode_time (decoder, frame);
|
||||||
|
if (self->drop_subframes || deadline < 0) {
|
||||||
|
GST_INFO_OBJECT (self,
|
||||||
|
"Dropping too late frame: deadline %" G_GINT64_FORMAT, deadline);
|
||||||
|
self->drop_subframes = TRUE;
|
||||||
|
if (current_stripe == self->num_stripes ||
|
||||||
|
GST_BUFFER_FLAG_IS_SET (frame->input_buffer, GST_BUFFER_FLAG_MARKER)) {
|
||||||
|
ret = gst_video_decoder_drop_frame (decoder, frame);
|
||||||
|
self->drop_subframes = FALSE;
|
||||||
|
} else {
|
||||||
|
gst_video_decoder_drop_subframe (decoder, frame);
|
||||||
|
}
|
||||||
|
|
||||||
|
goto done;
|
||||||
|
}
|
||||||
|
|
||||||
|
ret = self->decode_frame (decoder, frame);
|
||||||
|
if (ret != GST_FLOW_OK) {
|
||||||
|
GST_WARNING_OBJECT (self, "Unable to decode the frame with flow error: %s",
|
||||||
|
gst_flow_get_name (ret));
|
||||||
|
goto error;
|
||||||
|
}
|
||||||
|
|
||||||
|
done:
|
||||||
return ret;
|
return ret;
|
||||||
|
|
||||||
initialization_error:
|
error:
|
||||||
{
|
switch (self->last_error) {
|
||||||
gst_video_codec_frame_unref (frame);
|
case OPENJPEG_ERROR_INIT:
|
||||||
GST_ELEMENT_ERROR (self, LIBRARY, INIT,
|
GST_ELEMENT_ERROR (self, LIBRARY, INIT,
|
||||||
("Failed to initialize OpenJPEG decoder"), (NULL));
|
("Failed to initialize OpenJPEG decoder"), (NULL));
|
||||||
|
break;
|
||||||
return GST_FLOW_ERROR;
|
case OPENJPEG_ERROR_MAP_READ:
|
||||||
}
|
|
||||||
map_read_error:
|
|
||||||
{
|
|
||||||
gst_openjpeg_dec_handle_frame_cleanup (self, frame, NULL, dec, stream,
|
|
||||||
image);
|
|
||||||
|
|
||||||
GST_ELEMENT_ERROR (self, CORE, FAILED,
|
GST_ELEMENT_ERROR (self, CORE, FAILED,
|
||||||
("Failed to map input buffer"), (NULL));
|
("Failed to map input buffer"), (NULL));
|
||||||
return GST_FLOW_ERROR;
|
break;
|
||||||
}
|
case OPENJPEG_ERROR_MAP_WRITE:
|
||||||
open_error:
|
|
||||||
{
|
|
||||||
gst_openjpeg_dec_handle_frame_cleanup (self, frame, &map, dec, stream,
|
|
||||||
image);
|
|
||||||
|
|
||||||
GST_ELEMENT_ERROR (self, LIBRARY, INIT,
|
|
||||||
("Failed to open OpenJPEG stream"), (NULL));
|
|
||||||
return GST_FLOW_ERROR;
|
|
||||||
}
|
|
||||||
decode_error:
|
|
||||||
{
|
|
||||||
gst_openjpeg_dec_handle_frame_cleanup (self, frame, &map, dec, stream,
|
|
||||||
image);
|
|
||||||
|
|
||||||
GST_VIDEO_DECODER_ERROR (self, 1, STREAM, DECODE,
|
|
||||||
("Failed to decode OpenJPEG stream"), (NULL), ret);
|
|
||||||
return ret;
|
|
||||||
}
|
|
||||||
negotiate_error:
|
|
||||||
{
|
|
||||||
gst_openjpeg_dec_handle_frame_cleanup (self, frame, NULL, dec, stream,
|
|
||||||
image);
|
|
||||||
|
|
||||||
GST_ELEMENT_ERROR (self, CORE, NEGOTIATION,
|
|
||||||
("Failed to negotiate"), (NULL));
|
|
||||||
return ret;
|
|
||||||
}
|
|
||||||
allocate_error:
|
|
||||||
{
|
|
||||||
gst_openjpeg_dec_handle_frame_cleanup (self, frame, NULL, dec, stream,
|
|
||||||
image);
|
|
||||||
|
|
||||||
GST_ELEMENT_ERROR (self, CORE, FAILED,
|
GST_ELEMENT_ERROR (self, CORE, FAILED,
|
||||||
("Failed to allocate output buffer"), (NULL));
|
("Failed to map input buffer"), (NULL));
|
||||||
return ret;
|
break;
|
||||||
|
case OPENJPEG_ERROR_FILL_IMAGE:
|
||||||
|
GST_ELEMENT_ERROR (self, LIBRARY, INIT,
|
||||||
|
("Failed to fill OpenJPEG image"), (NULL));
|
||||||
|
break;
|
||||||
|
case OPENJPEG_ERROR_OPEN:
|
||||||
|
GST_ELEMENT_ERROR (self, LIBRARY, INIT,
|
||||||
|
("Failed to open OpenJPEG data"), (NULL));
|
||||||
|
break;
|
||||||
|
case OPENJPEG_ERROR_DECODE:
|
||||||
|
GST_ELEMENT_ERROR (self, LIBRARY, INIT,
|
||||||
|
("Failed to decode OpenJPEG data"), (NULL));
|
||||||
|
break;
|
||||||
|
case OPENJPEG_ERROR_NEGOCIATE:
|
||||||
|
GST_ELEMENT_ERROR (self, LIBRARY, INIT,
|
||||||
|
("Failed to negociate OpenJPEG data"), (NULL));
|
||||||
|
break;
|
||||||
|
case OPENJPEG_ERROR_ALLOCATE:
|
||||||
|
GST_ELEMENT_ERROR (self, LIBRARY, INIT,
|
||||||
|
("Failed to allocate OpenJPEG data"), (NULL));
|
||||||
|
break;
|
||||||
|
default:
|
||||||
|
GST_ELEMENT_ERROR (self, LIBRARY, INIT,
|
||||||
|
("Failed to encode OpenJPEG data"), (NULL));
|
||||||
|
break;
|
||||||
}
|
}
|
||||||
map_write_error:
|
|
||||||
{
|
|
||||||
gst_openjpeg_dec_handle_frame_cleanup (self, frame, NULL, dec, stream,
|
|
||||||
image);
|
|
||||||
GST_ELEMENT_ERROR (self, CORE, FAILED, ("Failed to map output buffer"),
|
|
||||||
(NULL));
|
|
||||||
return GST_FLOW_ERROR;
|
return GST_FLOW_ERROR;
|
||||||
|
}
|
||||||
|
|
||||||
|
static GstFlowReturn
|
||||||
|
gst_openjpeg_dec_finish (GstVideoDecoder * decoder)
|
||||||
|
{
|
||||||
|
GstOpenJPEGDec *self = GST_OPENJPEG_DEC (decoder);
|
||||||
|
|
||||||
|
GST_DEBUG_OBJECT (self, "Draining component");
|
||||||
|
|
||||||
|
if (!self->started) {
|
||||||
|
GST_DEBUG_OBJECT (self, "Component not started yet");
|
||||||
|
return GST_FLOW_OK;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
self->draining = TRUE;
|
||||||
|
if (!gst_openjpeg_dec_has_pending_job_to_finish (self)) {
|
||||||
|
GST_DEBUG_OBJECT (self, "Component ready");
|
||||||
|
g_cond_broadcast (&self->messages_cond);
|
||||||
|
return GST_FLOW_OK;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Make sure to release the base class stream lock, otherwise
|
||||||
|
* _loop() can't call _finish_frame() and we might block forever
|
||||||
|
* because no input buffers are released */
|
||||||
|
GST_VIDEO_DECODER_STREAM_UNLOCK (self);
|
||||||
|
|
||||||
|
g_mutex_lock (&self->drain_lock);
|
||||||
|
GST_DEBUG_OBJECT (self, "Waiting until component is drained");
|
||||||
|
|
||||||
|
while (self->draining)
|
||||||
|
g_cond_wait (&self->drain_cond, &self->drain_lock);
|
||||||
|
|
||||||
|
GST_DEBUG_OBJECT (self, "Drained component");
|
||||||
|
|
||||||
|
g_mutex_unlock (&self->drain_lock);
|
||||||
|
GST_VIDEO_DECODER_STREAM_LOCK (self);
|
||||||
|
self->started = FALSE;
|
||||||
|
return GST_FLOW_OK;
|
||||||
}
|
}
|
||||||
|
|
||||||
static gboolean
|
static gboolean
|
||||||
|
|
|
@ -58,15 +58,36 @@ struct _GstOpenJPEGDec
|
||||||
GstJPEG2000Sampling sampling;
|
GstJPEG2000Sampling sampling;
|
||||||
gint ncomps;
|
gint ncomps;
|
||||||
gint max_threads; /* atomic */
|
gint max_threads; /* atomic */
|
||||||
|
gint max_slice_threads; /* internal openjpeg threading system */
|
||||||
gint num_procs;
|
gint num_procs;
|
||||||
gint num_stripes;
|
gint num_stripes;
|
||||||
GstVideoCodecFrame *current_frame;
|
|
||||||
gboolean drop_subframes;
|
gboolean drop_subframes;
|
||||||
|
|
||||||
void (*fill_frame) (GstOpenJPEGDec *self,
|
void (*fill_frame) (GstOpenJPEGDec *self,
|
||||||
GstVideoFrame *frame, opj_image_t * image);
|
GstVideoFrame *frame, opj_image_t * image);
|
||||||
|
|
||||||
|
gboolean (*decode_frame) (GstVideoDecoder * decoder, GstVideoCodecFrame *frame);
|
||||||
|
|
||||||
opj_dparameters_t params;
|
opj_dparameters_t params;
|
||||||
|
|
||||||
|
guint available_threads;
|
||||||
|
GQueue messages;
|
||||||
|
|
||||||
|
GCond messages_cond;
|
||||||
|
GMutex messages_lock;
|
||||||
|
GMutex decoding_lock;
|
||||||
|
GstFlowReturn downstream_flow_ret;
|
||||||
|
gboolean flushing;
|
||||||
|
|
||||||
|
/* Draining state */
|
||||||
|
GMutex drain_lock;
|
||||||
|
GCond drain_cond;
|
||||||
|
/* TRUE if EOS buffers shouldn't be forwarded */
|
||||||
|
gboolean draining; /* protected by drain_lock */
|
||||||
|
|
||||||
|
int last_error;
|
||||||
|
|
||||||
|
gboolean started;
|
||||||
};
|
};
|
||||||
|
|
||||||
struct _GstOpenJPEGDecClass
|
struct _GstOpenJPEGDecClass
|
||||||
|
|
Loading…
Reference in a new issue