[vlc-commits] vout: spu: prerender text
Francois Cartegnie
git at videolan.org
Thu Aug 8 09:50:09 CEST 2019
vlc | branch: master | Francois Cartegnie <fcvlcdev at free.fr> | Thu Jun 27 16:44:04 2019 +0200| [d4358cd54624d9a7cd160c915979d91d5bb52ce0] | committer: Francois Cartegnie
vout: spu: prerender text
> http://git.videolan.org/gitweb.cgi/vlc.git/?a=commit;h=d4358cd54624d9a7cd160c915979d91d5bb52ce0
---
src/video_output/vout_subpictures.c | 337 +++++++++++++++++++++++++++++++-----
1 file changed, 289 insertions(+), 48 deletions(-)
diff --git a/src/video_output/vout_subpictures.c b/src/video_output/vout_subpictures.c
index 626bb38039..f8771a63e5 100644
--- a/src/video_output/vout_subpictures.c
+++ b/src/video_output/vout_subpictures.c
@@ -69,6 +69,8 @@ struct spu_channel {
};
typedef struct VLC_VECTOR(struct spu_channel) spu_channel_vector;
+typedef struct VLC_VECTOR(subpicture_t *) spu_prerender_vector;
+#define SPU_CHROMALIST_COUNT 8
struct spu_private_t {
vlc_mutex_t lock; /* lock to protect all followings fields */
@@ -106,12 +108,28 @@ struct spu_private_t {
char *filter_chain_update;
vlc_mutex_t filter_chain_lock;
filter_chain_t *filter_chain;
+ /**/
+ struct
+ {
+ vlc_thread_t thread;
+ vlc_mutex_t lock;
+ vlc_cond_t cond;
+ vlc_cond_t output_cond;
+ spu_prerender_vector vector;
+ subpicture_t *p_processed;
+ video_format_t fmtsrc;
+ video_format_t fmtdst;
+ vlc_fourcc_t chroma_list[SPU_CHROMALIST_COUNT+1];
+ } prerender;
/* */
vlc_tick_t last_sort_date;
vout_thread_t *vout;
};
+static void spu_PrerenderSync(spu_private_t *, const subpicture_t *);
+static void spu_PrerenderCancel(spu_private_t *, const subpicture_t *);
+
static void spu_channel_Init(struct spu_channel *channel, size_t id,
enum vlc_vout_order order, vlc_clock_t *clock)
{
@@ -144,11 +162,12 @@ static void spu_channel_DeleteAt(struct spu_channel *channel, size_t index)
vlc_vector_remove(&channel->entries, index);
}
-static void spu_channel_Clean(struct spu_channel *channel)
+static void spu_channel_Clean(spu_private_t *sys, struct spu_channel *channel)
{
for (size_t i = 0; i < channel->entries.size; i++)
{
assert(channel->entries.data[i].subpic);
+ spu_PrerenderCancel(sys, channel->entries.data[i].subpic);
subpicture_Delete(channel->entries.data[i].subpic);
}
vlc_vector_destroy(&channel->entries);
@@ -314,6 +333,16 @@ static void SpuRenderText(spu_t *spu,
assert(region->fmt.i_chroma == VLC_CODEC_TEXT);
+ //assume rendered text is in sRGB if nothing is set
+ if (region->fmt.transfer == TRANSFER_FUNC_UNDEF)
+ region->fmt.transfer = TRANSFER_FUNC_SRGB;
+ if (region->fmt.primaries == COLOR_PRIMARIES_UNDEF)
+ region->fmt.primaries = COLOR_PRIMARIES_SRGB;
+ if (region->fmt.space == COLOR_SPACE_UNDEF)
+ region->fmt.space = COLOR_SPACE_SRGB;
+ if (region->fmt.color_range == COLOR_RANGE_UNDEF)
+ region->fmt.color_range = COLOR_RANGE_FULL;
+
if ( region->p_text )
text->pf_render(text, region, region, chroma_list);
}
@@ -732,6 +761,7 @@ spu_SelectSubpictures(spu_t *spu, vlc_tick_t system_now,
if (is_rejeted)
{
+ spu_PrerenderCancel(sys, current);
subpicture_Delete(current);
vlc_vector_remove(&channel->entries, index);
}
@@ -1377,10 +1407,238 @@ static int SubSourceDelProxyCallbacks(filter_t *filter, void *opaque)
return VLC_SUCCESS;
}
+static void spu_PrerenderWake(spu_private_t *sys,
+ const video_format_t *fmt_dst,
+ const video_format_t *fmt_src,
+ const vlc_fourcc_t *chroma_list)
+{
+ vlc_mutex_lock(&sys->prerender.lock);
+ if(!video_format_IsSimilar(fmt_dst, &sys->prerender.fmtdst))
+ {
+ video_format_Clean(&sys->prerender.fmtdst);
+ video_format_Copy(&sys->prerender.fmtdst, fmt_dst);
+ }
+ if(!video_format_IsSimilar(fmt_src, &sys->prerender.fmtsrc))
+ {
+ video_format_Clean(&sys->prerender.fmtsrc);
+ video_format_Copy(&sys->prerender.fmtsrc, fmt_src);
+ }
+
+ for(size_t i=0; i<SPU_CHROMALIST_COUNT; i++)
+ {
+ sys->prerender.chroma_list[i] = chroma_list[i];
+ if(!chroma_list[i])
+ break;
+ }
+
+ vlc_cond_signal(&sys->prerender.cond);
+ vlc_mutex_unlock(&sys->prerender.lock);
+}
+
+static void spu_PrerenderEnqueue(spu_private_t *sys, subpicture_t *p_subpic)
+{
+ vlc_mutex_lock(&sys->prerender.lock);
+ vlc_vector_push(&sys->prerender.vector, p_subpic);
+ vlc_cond_signal(&sys->prerender.cond);
+ vlc_mutex_unlock(&sys->prerender.lock);
+}
+
+static void spu_PrerenderCancel(spu_private_t *sys, const subpicture_t *p_subpic)
+{
+ vlc_mutex_lock(&sys->prerender.lock);
+ ssize_t i_idx;
+ vlc_vector_index_of(&sys->prerender.vector, p_subpic, &i_idx);
+ if(i_idx >= 0)
+ vlc_vector_remove(&sys->prerender.vector, i_idx);
+ else while(sys->prerender.p_processed == p_subpic)
+ vlc_cond_wait(&sys->prerender.output_cond, &sys->prerender.lock);
+ vlc_mutex_unlock(&sys->prerender.lock);
+}
+
+static void spu_PrerenderSync(spu_private_t *sys, const subpicture_t *p_subpic)
+{
+ vlc_mutex_lock(&sys->prerender.lock);
+ ssize_t i_idx;
+ vlc_vector_index_of(&sys->prerender.vector, p_subpic, &i_idx);
+ while(i_idx >= 0 || sys->prerender.p_processed == p_subpic)
+ {
+ vlc_cond_wait(&sys->prerender.output_cond, &sys->prerender.lock);
+ vlc_vector_index_of(&sys->prerender.vector, p_subpic, &i_idx);
+ }
+ vlc_mutex_unlock(&sys->prerender.lock);
+}
+
+static void spu_PrerenderText(spu_t *spu, subpicture_t *p_subpic,
+ video_format_t *fmtsrc, video_format_t *fmtdst,
+ vlc_fourcc_t *chroma_list)
+{
+ spu_private_t *sys = spu->p;
+
+ if (p_subpic->i_original_picture_width <= 0 ||
+ p_subpic->i_original_picture_height <= 0) {
+ if (p_subpic->i_original_picture_width > 0 ||
+ p_subpic->i_original_picture_height > 0)
+ msg_Err(spu, "original picture size %dx%d is unsupported",
+ p_subpic->i_original_picture_width,
+ p_subpic->i_original_picture_height);
+ else
+ msg_Warn(spu, "original picture size is undefined");
+
+ p_subpic->i_original_picture_width = fmtsrc->i_visible_width;
+ p_subpic->i_original_picture_height = fmtsrc->i_visible_height;
+ }
+
+ /* FIXME aspect ratio ? */
+ sys->text->fmt_out.video.i_width =
+ sys->text->fmt_out.video.i_visible_width = p_subpic->i_original_picture_width;
+
+ sys->text->fmt_out.video.i_height =
+ sys->text->fmt_out.video.i_visible_height = p_subpic->i_original_picture_height;
+
+ subpicture_Update(p_subpic, fmtsrc, fmtdst,
+ p_subpic->b_subtitle ? p_subpic->i_start : vlc_tick_now());
+
+ subpicture_region_t *region;
+ for (region = p_subpic->p_region; region != NULL; region = region->p_next)
+ {
+ if(region->fmt.i_chroma != VLC_CODEC_TEXT)
+ continue;
+ SpuFixupRegionColospace(region);
+ SpuRenderText(spu, region, chroma_list);
+ }
+}
+
+struct spu_prerender_ctx_s
+{
+ video_format_t fmtsrc;
+ video_format_t fmtdst;
+ vlc_fourcc_t chroma_list[SPU_CHROMALIST_COUNT+1];
+ vlc_mutex_t *cleanuplock;
+};
+
+static void spu_prerender_cleanup_routine(void *priv)
+{
+ struct spu_prerender_ctx_s *ctx = priv;
+ video_format_Clean(&ctx->fmtdst);
+ video_format_Clean(&ctx->fmtsrc);
+ vlc_mutex_unlock(ctx->cleanuplock);
+}
+
+static void * spu_PrerenderThread(void *priv)
+{
+ spu_t *spu = priv;
+ spu_private_t *sys = spu->p;
+
+ struct spu_prerender_ctx_s ctx;
+ ctx.cleanuplock = &sys->prerender.lock;
+ ctx.chroma_list[SPU_CHROMALIST_COUNT] = 0;
+ video_format_Init(&ctx.fmtsrc, 0);
+ video_format_Init(&ctx.fmtdst, 0);
+
+ vlc_mutex_lock(&sys->prerender.lock);
+ for( ;; )
+ {
+ vlc_cleanup_push(spu_prerender_cleanup_routine, &ctx);
+ while(!sys->prerender.vector.size || !sys->prerender.chroma_list)
+ vlc_cond_wait(&sys->prerender.cond, &sys->prerender.lock);
+
+ size_t i_idx = 0;
+ sys->prerender.p_processed = sys->prerender.vector.data[0];
+ for(size_t i=1; i<sys->prerender.vector.size; i++)
+ {
+ if(sys->prerender.p_processed->i_start > sys->prerender.vector.data[i]->i_start)
+ {
+ sys->prerender.p_processed = sys->prerender.vector.data[i];
+ i_idx = i;
+ }
+ }
+ vlc_vector_remove(&sys->prerender.vector, i_idx);
+ memcpy(&ctx.chroma_list, sys->prerender.chroma_list, SPU_CHROMALIST_COUNT);
+ video_format_Clean(&ctx.fmtdst);
+ video_format_Clean(&ctx.fmtsrc);
+ video_format_Copy(&ctx.fmtdst, &sys->prerender.fmtdst);
+ video_format_Copy(&ctx.fmtsrc, &sys->prerender.fmtsrc);
+
+ vlc_mutex_unlock(&sys->prerender.lock);
+ vlc_cleanup_pop();
+
+ int canc = vlc_savecancel();
+ spu_PrerenderText(spu, sys->prerender.p_processed,
+ &ctx.fmtsrc, &ctx.fmtdst, ctx.chroma_list);
+ vlc_restorecancel(canc);
+
+ vlc_mutex_lock(&sys->prerender.lock);
+ sys->prerender.p_processed = NULL;
+ vlc_cond_signal(&sys->prerender.output_cond);
+ }
+
+ return NULL;
+}
+
/*****************************************************************************
* Public API
*****************************************************************************/
+static void spu_Cleanup(spu_t *spu)
+{
+ spu_private_t *sys = spu->p;
+
+ if (sys->text)
+ FilterRelease(sys->text);
+
+ if (sys->scale_yuvp)
+ FilterRelease(sys->scale_yuvp);
+
+ if (sys->scale)
+ FilterRelease(sys->scale);
+
+ filter_chain_ForEach(sys->source_chain, SubSourceClean, spu);
+ if (sys->vout)
+ filter_chain_ForEach(sys->source_chain,
+ SubSourceDelProxyCallbacks, sys->vout);
+ filter_chain_Delete(sys->source_chain);
+ free(sys->source_chain_current);
+ if (sys->vout)
+ filter_chain_ForEach(sys->filter_chain,
+ SubFilterDelProxyCallbacks, sys->vout);
+ filter_chain_Delete(sys->filter_chain);
+ free(sys->filter_chain_current);
+ vlc_mutex_destroy(&sys->filter_chain_lock);
+ free(sys->source_chain_update);
+ free(sys->filter_chain_update);
+
+ /* Destroy all remaining subpictures */
+ for (size_t i = 0; i < sys->channels.size; ++i)
+ spu_channel_Clean(sys, &sys->channels.data[i]);
+
+ vlc_vector_destroy(&sys->channels);
+
+ vlc_mutex_destroy(&sys->lock);
+
+ vlc_mutex_destroy(&sys->prerender.lock);
+ vlc_cond_destroy(&sys->prerender.cond);
+ vlc_cond_destroy(&sys->prerender.output_cond);
+ vlc_vector_clear(&sys->prerender.vector);
+ video_format_Clean(&sys->prerender.fmtdst);
+ video_format_Clean(&sys->prerender.fmtsrc);
+}
+
+/**
+ * Destroy the subpicture unit
+ *
+ * \param p_this the parent object which destroys the subpicture unit
+ */
+void spu_Destroy(spu_t *spu)
+{
+ spu_private_t *sys = spu->p;
+ /* stop prerendering */
+ vlc_cancel(sys->prerender.thread);
+ vlc_join(sys->prerender.thread, NULL);
+ /* delete filters and free resources */
+ spu_Cleanup(spu);
+ vlc_object_delete(spu);
+}
+
#undef spu_Create
/**
* Creates the subpicture unit
@@ -1451,51 +1709,23 @@ spu_t *spu_Create(vlc_object_t *object, vout_thread_t *vout)
sys->last_sort_date = -1;
sys->vout = vout;
- return spu;
-}
-
-/**
- * Destroy the subpicture unit
- *
- * \param p_this the parent object which destroys the subpicture unit
- */
-void spu_Destroy(spu_t *spu)
-{
- spu_private_t *sys = spu->p;
-
- if (sys->text)
- FilterRelease(sys->text);
-
- if (sys->scale_yuvp)
- FilterRelease(sys->scale_yuvp);
-
- if (sys->scale)
- FilterRelease(sys->scale);
-
- filter_chain_ForEach(sys->source_chain, SubSourceClean, spu);
- if (sys->vout)
- filter_chain_ForEach(sys->source_chain,
- SubSourceDelProxyCallbacks, sys->vout);
- filter_chain_Delete(sys->source_chain);
- free(sys->source_chain_current);
- if (sys->vout)
- filter_chain_ForEach(sys->filter_chain,
- SubFilterDelProxyCallbacks, sys->vout);
- filter_chain_Delete(sys->filter_chain);
- free(sys->filter_chain_current);
- vlc_mutex_destroy(&sys->filter_chain_lock);
- free(sys->source_chain_update);
- free(sys->filter_chain_update);
-
- /* Destroy all remaining subpictures */
- for (size_t i = 0; i < sys->channels.size; ++i)
- spu_channel_Clean(&sys->channels.data[i]);
-
- vlc_vector_destroy(&sys->channels);
-
- vlc_mutex_destroy(&sys->lock);
+ vlc_mutex_init(&sys->prerender.lock);
+ vlc_cond_init(&sys->prerender.cond);
+ vlc_cond_init(&sys->prerender.output_cond);
+ vlc_vector_init(&sys->prerender.vector);
+ video_format_Init(&sys->prerender.fmtdst, 0);
+ video_format_Init(&sys->prerender.fmtsrc, 0);
+ sys->prerender.p_processed = NULL;
+ sys->prerender.chroma_list[0] = 0;
+ sys->prerender.chroma_list[SPU_CHROMALIST_COUNT] = 0;
+ if(vlc_clone(&sys->prerender.thread, spu_PrerenderThread, spu, VLC_THREAD_PRIORITY_VIDEO))
+ {
+ spu_Cleanup(spu);
+ vlc_object_delete(spu);
+ spu = NULL;
+ }
- vlc_object_delete(spu);
+ return spu;
}
/**
@@ -1656,6 +1886,7 @@ void spu_PutSubpicture(spu_t *spu, subpicture_t *subpic)
subpicture_Delete(subpic);
return;
}
+ spu_PrerenderEnqueue(sys, subpic);
vlc_mutex_unlock(&sys->lock);
}
@@ -1716,6 +1947,9 @@ subpicture_t *spu_Render(spu_t *spu,
chroma_list = vlc_fourcc_IsYUV(fmt_dst->i_chroma) ? chroma_list_default_yuv
: chroma_list_default_rgb;
+ /* wake up prerenderer, we have some video size and chroma */
+ spu_PrerenderWake(sys, fmt_dst, fmt_src, chroma_list);
+
vlc_mutex_lock(&sys->lock);
size_t subpicture_count;
@@ -1734,6 +1968,9 @@ subpicture_t *spu_Render(spu_t *spu,
for (size_t i = 0; i < subpicture_count; i++) {
spu_render_entry_t *entry = &subpicture_array[i];
subpicture_t *subpic = entry->subpic;
+
+ spu_PrerenderSync(sys, entry->subpic);
+
if (!subpic->updater.pf_validate)
continue;
@@ -1793,10 +2030,14 @@ ssize_t spu_RegisterChannel(spu_t *spu)
return spu_RegisterChannelInternal(spu, NULL, NULL);
}
-static void spu_channel_Clear(struct spu_channel *channel)
+static void spu_channel_Clear(spu_private_t *sys,
+ struct spu_channel *channel)
{
for (size_t i = 0; i < channel->entries.size; i++)
+ {
+ spu_PrerenderCancel(sys, channel->entries.data[i].subpic);
spu_channel_DeleteAt(channel, i);
+ }
}
void spu_ClearChannel(spu_t *spu, size_t channel_id)
@@ -1804,7 +2045,7 @@ void spu_ClearChannel(spu_t *spu, size_t channel_id)
spu_private_t *sys = spu->p;
vlc_mutex_lock(&sys->lock);
struct spu_channel *channel = spu_GetChannel(spu, channel_id);
- spu_channel_Clear(channel);
+ spu_channel_Clear(sys, channel);
if (channel->clock)
{
vlc_clock_Reset(channel->clock);
@@ -1819,7 +2060,7 @@ void spu_UnregisterChannel(spu_t *spu, size_t channel_id)
vlc_mutex_lock(&sys->lock);
struct spu_channel *channel = spu_GetChannel(spu, channel_id);
- spu_channel_Clean(channel);
+ spu_channel_Clean(sys, channel);
vlc_vector_remove(&sys->channels, channel_id);
vlc_mutex_unlock(&sys->lock);
}
More information about the vlc-commits
mailing list