[vlc-commits] [Git][videolan/vlc][master] 5 commits: test: player: next_prev: use a struct for common variables
Felix Paul Kühne (@fkuehne)
gitlab at videolan.org
Thu Dec 11 07:57:39 UTC 2025
Felix Paul Kühne pushed to branch master at VideoLAN / VLC
Commits:
21d2cbb3 by Thomas Guillem at 2025-12-11T07:04:15+01:00
test: player: next_prev: use a struct for common variables
Avoid passing lot of variables to all functions.
No functional changes.
- - - - -
214083f8 by Thomas Guillem at 2025-12-11T07:04:15+01:00
test: player: next_prev: refactor, add wait_next_tc()
No functional changes.
- - - - -
18494571 by Thomas Guillem at 2025-12-11T07:04:15+01:00
vout: rework forced update with next/prev frames
Rework of 2bcff8a39311dea9333329d728e5ed4961547edb
Differentiate forced frames (when late, first) from next frames.
Next frames and forced frames need to be rendered now, but only signal a
forced clock point for the next-frame case.
Refs #29492
- - - - -
9e5373c8 by Thomas Guillem at 2025-12-11T07:04:15+01:00
player: timer: update forced points when paused
For now, only the video is sending forced points when paused and when
moving via next/prev frames.
Fixes the GUI not updated on next/prev frames.
Regression from d4b3e9f7cc5909a16156e8f9d9d442bb34879fd4:
On normal paused playback (not doing next/prev frames), timers will
receive a PAUSED event and won't receive any updates until playback is
resumed.
Fixes #29492
- - - - -
cfaeefa7 by Thomas Guillem at 2025-12-11T07:04:15+01:00
test: player: next_prev: also test the normal timer
Ensure it is receiving PAUSED, SEEK events and that it is moving in the
good direction.
This test fails without the last 2 commits.
- - - - -
3 changed files:
- src/player/timer.c
- src/video_output/video_output.c
- test/src/player/next_prev.c
Changes:
=====================================
src/player/timer.c
=====================================
@@ -515,7 +515,14 @@ vlc_player_UpdateTimer(vlc_player_t *player, vlc_es_id_t *es_source,
vlc_tick_t system_date = point->system_date;
if (player->timer.paused)
+ {
+ if (es_source != NULL && point->system_date == VLC_TICK_MAX)
+ {
+ /* Update was forced, probably a next/prev frame */
+ force_update = true;
+ }
system_date = VLC_TICK_MAX;
+ }
if (!player->timer.stopping)
vlc_player_UpdateTimerBestSource(player, es_source,
=====================================
src/video_output/video_output.c
=====================================
@@ -1400,7 +1400,15 @@ static int PrerenderPicture(vout_thread_sys_t *sys, picture_t *filtered,
return VLC_SUCCESS;
}
-static int RenderPicture(vout_thread_sys_t *sys, bool render_now)
+enum render_picture_type
+{
+ RENDER_PICTURE_NORMAL,
+ RENDER_PICTURE_FORCED,
+ RENDER_PICTURE_NEXT,
+};
+
+static int RenderPicture(vout_thread_sys_t *sys,
+ enum render_picture_type render_type)
{
vout_display_t *vd = sys->display;
@@ -1424,6 +1432,8 @@ static int RenderPicture(vout_thread_sys_t *sys, bool render_now)
return ret;
}
+ bool render_now = render_type != RENDER_PICTURE_NORMAL;
+
vlc_tick_t system_now = vlc_tick_now();
const vlc_tick_t pts = todisplay->date;
vlc_tick_t system_pts;
@@ -1507,11 +1517,17 @@ static int RenderPicture(vout_thread_sys_t *sys, bool render_now)
sys->displayed.date = system_now;
}
+ /* Next frames should be updated as forced points */
+ if (render_type == RENDER_PICTURE_NEXT)
+ system_now = VLC_TICK_MAX;
+ else
+ system_now = vlc_tick_now();
+
/* Display the direct buffer returned by vout_RenderPicture */
vout_display_Display(vd, todisplay);
vlc_clock_Lock(sys->clock);
vlc_tick_t drift = vlc_clock_UpdateVideo(sys->clock,
- vlc_tick_now(),
+ system_now,
pts, sys->rate,
frame_rate, frame_rate_base);
vlc_clock_Unlock(sys->clock);
@@ -1563,7 +1579,7 @@ static int DisplayNextFrame(vout_thread_sys_t *sys)
if (!next)
return VLC_EGENERIC;
- return RenderPicture(sys, true);
+ return RenderPicture(sys, RENDER_PICTURE_NEXT);
}
static bool UpdateCurrentPicture(vout_thread_sys_t *sys)
@@ -1643,7 +1659,8 @@ static vlc_tick_t DisplayPicture(vout_thread_sys_t *vout)
// display forced picture immediately
bool render_now = sys->displayed.current->b_force;
- RenderPicture(vout, render_now);
+ RenderPicture(vout, render_now ? RENDER_PICTURE_FORCED
+ : RENDER_PICTURE_NORMAL);
if (!render_now)
/* Prepare the next picture immediately without waiting */
return VLC_TICK_INVALID;
@@ -1652,7 +1669,7 @@ static vlc_tick_t DisplayPicture(vout_thread_sys_t *vout)
{
sys->wait_interrupted = false;
if (likely(sys->displayed.current != NULL))
- RenderPicture(vout, true);
+ RenderPicture(vout, RENDER_PICTURE_FORCED);
return VLC_TICK_INVALID;
}
else if (likely(sys->displayed.date != VLC_TICK_INVALID))
@@ -1674,7 +1691,7 @@ static vlc_tick_t DisplayPicture(vout_thread_sys_t *vout)
vlc_tick_t max_deadline = system_now + VOUT_REDISPLAY_DELAY;
return __MIN(date_refresh, max_deadline);
}
- RenderPicture(vout, true);
+ RenderPicture(vout, RENDER_PICTURE_FORCED);
}
// wait until the next deadline or a control
=====================================
test/src/player/next_prev.c
=====================================
@@ -8,37 +8,58 @@
#include "common.h"
#include "timers.h"
+struct np_ctx
+{
+ struct ctx *ctx;
+ struct timer_state timers[2];
+ size_t timers_count;
+ size_t prev_status_idx;
+ size_t next_status_idx;
+ struct vlc_player_timer_smpte_timecode tc;
+};
+
+static unsigned
+get_fps(struct ctx *ctx)
+{
+ return ceil(ctx->params.video_frame_rate /
+ (float) ctx->params.video_frame_rate_base);
+}
+
+
static void
-wait_prev_frame_status(struct ctx *ctx, size_t *pidx, size_t count,
- int status)
+wait_prev_frame_status(struct np_ctx *np_ctx, size_t count, int status)
{
- size_t idx = *pidx;
+ struct ctx *ctx = np_ctx->ctx;
+ size_t idx = np_ctx->prev_status_idx;
vec_on_prev_frame_status *vec = &ctx->report.on_prev_frame_status;
while (vec->size < idx + count)
vlc_player_CondWait(ctx->player, &ctx->wait);
for (size_t i = idx; i < idx + count; ++i)
assert(vec->data[i] == status);
idx += count;
- *pidx = idx;
+ np_ctx->prev_status_idx = idx;
}
static void
-wait_next_frame_status(struct ctx *ctx, size_t *pidx, size_t count,
- int status)
+wait_next_frame_status(struct np_ctx *np_ctx, size_t count, int status)
{
- size_t idx = *pidx;
+ struct ctx *ctx = np_ctx->ctx;
+ size_t idx = np_ctx->next_status_idx;
vec_on_next_frame_status *vec = &ctx->report.on_next_frame_status;
while (vec->size < idx + count)
vlc_player_CondWait(ctx->player, &ctx->wait);
for (size_t i = idx; i < idx + count; ++i)
assert(vec->data[i] == status);
idx += count;
- *pidx = idx;
+ np_ctx->next_status_idx = idx;
}
static void
-decrease_tc(struct vlc_player_timer_smpte_timecode *tc, unsigned fps)
+decrease_tc(struct np_ctx *np_ctx)
{
+ unsigned fps = get_fps(np_ctx->ctx);
+ struct vlc_player_timer_smpte_timecode *tc = &np_ctx->tc;
+
if (tc->frames == 0)
{
if (tc->seconds > 0)
@@ -52,8 +73,11 @@ decrease_tc(struct vlc_player_timer_smpte_timecode *tc, unsigned fps)
}
static void
-increase_tc(struct vlc_player_timer_smpte_timecode *tc, unsigned fps)
+increase_tc(struct np_ctx *np_ctx)
{
+ unsigned fps = get_fps(np_ctx->ctx);
+ struct vlc_player_timer_smpte_timecode *tc = &np_ctx->tc;
+
tc->frames++;
if (tc->frames == fps)
{
@@ -63,37 +87,65 @@ increase_tc(struct vlc_player_timer_smpte_timecode *tc, unsigned fps)
}
static void
-wait_type_timer(struct ctx *ctx, struct timer_state *timer, unsigned type,
- struct vlc_player_timer_smpte_timecode *tc)
+wait_type_timer(struct np_ctx *np_ctx, unsigned type)
{
+ struct ctx *ctx = np_ctx->ctx;
vlc_player_t *player = ctx->player;
- /* Seek events come with 2 reports (start/end) */
- unsigned nb_reports = type == REPORT_TIMER_SEEK ? 2 : 1;
- player_lock_timer(player, timer);
- for (;;)
+ for (size_t i = 0; i < np_ctx->timers_count; ++i)
{
- struct report_timer *r = timer_state_wait_next_report(timer);
- if (r->type == type)
+ struct timer_state *timer = &np_ctx->timers[i];
+ /* Seek events come with 2 reports (start/end) */
+ unsigned nb_reports = type == REPORT_TIMER_SEEK ? 2 : 1;
+ player_lock_timer(player, timer);
+ for (;;)
{
- nb_reports--;
- if (nb_reports == 0)
+ struct report_timer *r = timer_state_wait_next_report(timer);
+ if (r->type == type)
{
- player_unlock_timer(player, timer);
- return;
+ nb_reports--;
+ if (nb_reports == 0)
+ {
+ player_unlock_timer(player, timer);
+ break;
+ }
}
+ if (type != REPORT_TIMER_SEEK && r->type == REPORT_TIMER_TC)
+ np_ctx->tc = r->tc;
}
- if (tc != NULL && r->type == REPORT_TIMER_TC)
- *tc = r->tc;
+ }
+}
+
+static void
+wait_next_tc(struct np_ctx *np_ctx)
+{
+ struct ctx *ctx = np_ctx->ctx;
+ vlc_player_t *player = ctx->player;
+ struct timer_state *timer = &np_ctx->timers[0];
+ struct vlc_player_timer_smpte_timecode *tc = &np_ctx->tc;
+ player_lock_timer(player, timer);
+ struct report_timer *r = timer_state_wait_next_report(timer);
+ assert(r->type == REPORT_TIMER_TC);
+ *tc = r->tc;
+ player_unlock_timer(player, timer);
+
+ if (np_ctx->timers_count > 1)
+ {
+ struct timer_state *normal_timer = &np_ctx->timers[1];
+ player_lock_timer(player, normal_timer);
+ r = timer_state_wait_next_report(normal_timer);
+ assert(r->type == REPORT_TIMER_POINT);
+ player_unlock_timer(player, normal_timer);
}
- vlc_assert_unreachable();
}
+
static void
-check_resumed_timer(struct ctx *ctx, struct timer_state *timer,
- struct vlc_player_timer_smpte_timecode *tc)
+check_resumed_timer(struct np_ctx *np_ctx)
{
+ struct ctx *ctx = np_ctx->ctx;
+
/* Check that the player can be resumed and paused again after
* next/prev frame */
vlc_player_t *player = ctx->player;
@@ -102,66 +154,51 @@ check_resumed_timer(struct ctx *ctx, struct timer_state *timer,
wait_state(ctx, VLC_PLAYER_STATE_PLAYING);
/* Wait that a video frame is rendered */
- struct report_timer *r = NULL;
- player_lock_timer(player, timer);
- r = timer_state_wait_next_report(timer);
- assert(r->type == REPORT_TIMER_TC);
- *tc = r->tc;
- player_unlock_timer(player, timer);
+ wait_next_tc(np_ctx);
vlc_player_Pause(player);
wait_state(ctx, VLC_PLAYER_STATE_PAUSED);
- wait_type_timer(ctx, timer, REPORT_TIMER_PAUSED, tc);
+ wait_type_timer(np_ctx, REPORT_TIMER_PAUSED);
}
static void
-check_seek_timer(struct ctx *ctx, struct timer_state *timer,
- struct vlc_player_timer_smpte_timecode *tc)
+check_seek_timer(struct np_ctx *np_ctx)
{
/* Check that the player can be resumed and paused again after
* next/prev frame */
+ struct ctx *ctx = np_ctx->ctx;
vlc_player_t *player = ctx->player;
+
assert_state(ctx, VLC_PLAYER_STATE_PAUSED);
vlc_player_SetTime(player, ctx->params.length / 2);
assert_state(ctx, VLC_PLAYER_STATE_PAUSED);
/* Wait for the seek */
- wait_type_timer(ctx, timer, REPORT_TIMER_SEEK, NULL);
+ wait_type_timer(np_ctx, REPORT_TIMER_SEEK);
/* Wait that a video frame is rendered */
- struct report_timer *r = NULL;
- player_lock_timer(player, timer);
- r = timer_state_wait_next_report(timer);
- assert(r->type == REPORT_TIMER_TC);
- *tc = r->tc;
- player_unlock_timer(player, timer);
+ wait_next_tc(np_ctx);
assert_state(ctx, VLC_PLAYER_STATE_PAUSED);
}
-static unsigned
-get_fps(struct ctx *ctx)
-{
- return ceil(ctx->params.video_frame_rate /
- (float) ctx->params.video_frame_rate_base);
-}
-
static void
-check_next_frame_timer(struct ctx *ctx, struct timer_state *timer,
- size_t *next_status_idx,
- struct vlc_player_timer_smpte_timecode *tc)
+check_next_frame_timer(struct np_ctx *np_ctx)
{
/* Check that the player can go next frame after a prev frame */
+ struct ctx *ctx = np_ctx->ctx;
+ struct timer_state *timer = &np_ctx->timers[0];
vlc_player_t *player = ctx->player;
- unsigned fps = get_fps(ctx);
+ struct vlc_player_timer_smpte_timecode *tc = &np_ctx->tc;
+
assert_state(ctx, VLC_PLAYER_STATE_PAUSED);
vlc_player_NextVideoFrame(player);
- wait_next_frame_status(ctx, next_status_idx, 1, 0);
+ wait_next_frame_status(np_ctx, 1, 0);
- increase_tc(tc, fps);
+ increase_tc(np_ctx);
/* Wait that a video frame is rendered */
struct report_timer *r = NULL;
@@ -171,25 +208,59 @@ check_next_frame_timer(struct ctx *ctx, struct timer_state *timer,
assert(r->tc.seconds == tc->seconds);
assert(r->tc.frames == tc->frames);
player_unlock_timer(player, timer);
+
+ if (np_ctx->timers_count > 1)
+ {
+ struct timer_state *normal_timer = &np_ctx->timers[1];
+ player_lock_timer(player, normal_timer);
+ r = timer_state_wait_next_report(normal_timer);
+ assert(r->type == REPORT_TIMER_POINT);
+ player_unlock_timer(player, normal_timer);
+ }
}
static size_t
-get_frame_count_to_start(const struct vlc_player_timer_smpte_timecode *tc,
- unsigned fps)
+get_frame_count_to_start(struct np_ctx *np_ctx)
{
- return tc->frames + VLC_TICK_FROM_SEC(tc->seconds)
+ unsigned fps = get_fps(np_ctx->ctx);
+
+ return np_ctx->tc.frames + VLC_TICK_FROM_SEC(np_ctx->tc.seconds)
/ vlc_tick_rate_duration(fps);
}
+static void check_normal_timer(struct np_ctx *np_ctx, size_t count, bool next)
+{
+ if (np_ctx->timers_count < 2)
+ return;
+ struct ctx *ctx = np_ctx->ctx;
+ struct timer_state *normal_timer = &np_ctx->timers[1];
+ vlc_player_t *player = ctx->player;
+
+ player_lock_timer(player, normal_timer);
+ vlc_tick_t last_ts = next ? VLC_TICK_0 : VLC_TICK_MAX;
+ for (size_t i = 0; i < count; ++i)
+ {
+ struct report_timer *r = timer_state_wait_next_report(normal_timer);
+ assert(r->type == REPORT_TIMER_POINT);
+ if (next)
+ assert(r->point.ts > last_ts);
+ else
+ assert(last_ts > r->point.ts);
+ last_ts = r->point.ts;
+ }
+ player_unlock_timer(player, normal_timer);
+}
+
static void
-go_start(struct ctx *ctx, struct timer_state *timer,
- size_t *prev_status_idx, size_t *next_status_idx,
- struct vlc_player_timer_smpte_timecode *tc, bool extra_checks)
+go_start(struct np_ctx *np_ctx, bool extra_checks)
{
+ struct ctx *ctx = np_ctx->ctx;
+ struct timer_state *timer = &np_ctx->timers[0];
vlc_player_t *player = ctx->player;
+ struct vlc_player_timer_smpte_timecode *tc = &np_ctx->tc;
struct report_timer *r = NULL;
- unsigned fps = get_fps(ctx);
- size_t frame_prev_count_total = get_frame_count_to_start(tc, fps);
+
+ size_t frame_prev_count_total = get_frame_count_to_start(np_ctx);
unsigned burst = frame_prev_count_total > 4 ? frame_prev_count_total / 4
: frame_prev_count_total;
if (burst > 100)
@@ -198,7 +269,7 @@ go_start(struct ctx *ctx, struct timer_state *timer,
bool check_resume, check_seek, check_next;
check_resume = check_seek = check_next = extra_checks;
- decrease_tc(tc, fps);
+ decrease_tc(np_ctx);
/* Send prev-frame requests in burst until we reach start of file */
while (frame_prev_count_total > 0)
{
@@ -211,7 +282,7 @@ go_start(struct ctx *ctx, struct timer_state *timer,
vlc_player_PreviousVideoFrame(player);
/* Wait for all prev-frame status */
- wait_prev_frame_status(ctx, prev_status_idx, frame_prev_count, 0);
+ wait_prev_frame_status(np_ctx, frame_prev_count, 0);
/* Check that all video timecodes are decreasing */
player_lock_timer(player, timer);
@@ -222,38 +293,41 @@ go_start(struct ctx *ctx, struct timer_state *timer,
assert(r->tc.seconds == tc->seconds);
assert(r->tc.frames == tc->frames);
- decrease_tc(tc, fps);
+ decrease_tc(np_ctx);
}
player_unlock_timer(player, timer);
+ /* Ensure the normal timer is moving */
+ check_normal_timer(np_ctx, frame_prev_count, false);
+
/* extra checks */
if (check_seek)
{
/* Check seek is not broken after prev-frame */
- check_seek_timer(ctx, timer, tc);
+ check_seek_timer(np_ctx);
check_seek = false;
/* And continue prev-frame */
- frame_prev_count_total = get_frame_count_to_start(tc, fps);
- decrease_tc(tc, fps);
+ frame_prev_count_total = get_frame_count_to_start(np_ctx);
+ decrease_tc(np_ctx);
}
else if (check_resume)
{
/* Check resume is not broken after prev-frame */
- check_resumed_timer(ctx, timer, tc);
+ check_resumed_timer(np_ctx);
check_resume = false;
/* And continue prev-frame */
- frame_prev_count_total = get_frame_count_to_start(tc, fps);
- decrease_tc(tc, fps);
+ frame_prev_count_total = get_frame_count_to_start(np_ctx);
+ decrease_tc(np_ctx);
}
else if (check_next)
{
/* Check next-frame is not broken after prev-frame*/
/* Cancel last decrease_tc() from for loop */
- increase_tc(tc, fps);
- check_next_frame_timer(ctx, timer, next_status_idx, tc);
+ increase_tc(np_ctx);
+ check_next_frame_timer(np_ctx);
check_next = false;
- frame_prev_count_total = get_frame_count_to_start(tc, fps);
- decrease_tc(tc, fps);
+ frame_prev_count_total = get_frame_count_to_start(np_ctx);
+ decrease_tc(np_ctx);
}
}
assert(!check_resume);
@@ -265,23 +339,34 @@ go_start(struct ctx *ctx, struct timer_state *timer,
/* Ensure start of File is handled */
vlc_player_PreviousVideoFrame(player);
- wait_prev_frame_status(ctx, prev_status_idx, 1, -EAGAIN);
+ wait_prev_frame_status(np_ctx, 1, -EAGAIN);
}
static void
test_prev(struct ctx *ctx, const struct media_params *params)
{
- test_log("prev-frame (fps: %u/%u pts-delay: %"PRId64")\n",
+ test_log("prev-frame (fps: %u/%u pts-delay: %"PRId64" with_audio: %zu)\n",
params->video_frame_rate, params->video_frame_rate_base,
- params->pts_delay);
+ params->pts_delay, params->track_count[AUDIO_ES]);
vlc_player_t *player = ctx->player;
- size_t prev_status_idx = 0;
- size_t next_status_idx = 0;
+ struct np_ctx np_ctx = {
+ .ctx = ctx,
+ .prev_status_idx = 0,
+ .next_status_idx = 0,
+ };
player_set_current_mock_media(ctx, "media1", params, false);
- struct timer_state smpte_timer, *timer = &smpte_timer;
- player_add_timer(player, timer, true, VLC_TICK_INVALID);
+ player_add_timer(player, &np_ctx.timers[0], true, VLC_TICK_INVALID);
+ np_ctx.timers_count = 1;
+
+ /* Normal timer can't be tested reliably with audio as it will take the
+ * lead */
+ if (params->track_count[AUDIO_ES] == 0)
+ {
+ player_add_timer(player, &np_ctx.timers[1], false, VLC_TICK_INVALID);
+ np_ctx.timers_count++;
+ }
player_start(ctx);
@@ -294,57 +379,49 @@ test_prev(struct ctx *ctx, const struct media_params *params)
}
/* Wait for a first frame */
- struct vlc_player_timer_smpte_timecode tc;
- struct report_timer *r = NULL;
- player_lock_timer(player, timer);
- r = timer_state_wait_next_report(timer);
- assert(r->type == REPORT_TIMER_TC);
- tc = r->tc;
- player_unlock_timer(player, timer);
+ wait_next_tc(&np_ctx);
vlc_player_SetTime(player, params->length / 2);
/* Wait for a first frame */
- wait_type_timer(ctx, timer, REPORT_TIMER_SEEK, NULL);
+ wait_type_timer(&np_ctx, REPORT_TIMER_SEEK);
- /* Wait for a first fram after seek */
- player_lock_timer(player, timer);
- r = timer_state_wait_next_report(timer);
- assert(r->type == REPORT_TIMER_TC);
- tc = r->tc;
- player_unlock_timer(player, timer);
+ /* Wait for a first frame after seek */
+ wait_next_tc(&np_ctx);
vlc_player_PreviousVideoFrame(player);
/* First request is pausing the video */
- wait_prev_frame_status(ctx, &prev_status_idx, 1, -EAGAIN);
+ wait_prev_frame_status(&np_ctx, 1, -EAGAIN);
assert_state(ctx, VLC_PLAYER_STATE_PAUSED);
/* Also wait the timer is paused */
- wait_type_timer(ctx, timer, REPORT_TIMER_PAUSED, &tc);
+ wait_type_timer(&np_ctx, REPORT_TIMER_PAUSED);
- go_start(ctx, timer, &prev_status_idx, &next_status_idx, &tc, true);
+ go_start(&np_ctx, true);
/* Check start of file a second time */
vlc_player_PreviousVideoFrame(player);
- wait_prev_frame_status(ctx, &prev_status_idx, 1, -EAGAIN);
+ wait_prev_frame_status(&np_ctx, 1, -EAGAIN);
/* Check playback can be resumed */
- check_resumed_timer(ctx, timer, &tc);
+ check_resumed_timer(&np_ctx);
/* Go back to start */
- go_start(ctx, timer, &prev_status_idx, &next_status_idx, &tc, false);
+ go_start(&np_ctx, false);
/* Check we can seek again */
- check_seek_timer(ctx, timer, &tc);
+ check_seek_timer(&np_ctx);
/* Go back to start */
- go_start(ctx, timer, &prev_status_idx, &next_status_idx, &tc, false);
+ go_start(&np_ctx, false);
/* XXX check next-frame UNTIL EOF (currently NextFrame burst is not working) */
test_end(ctx);
- player_remove_timer(player, timer);
+ player_remove_timer(player, &np_ctx.timers[0]);
+ if (np_ctx.timers_count > 1)
+ player_remove_timer(player, &np_ctx.timers[1]);
}
static void
@@ -354,12 +431,17 @@ test_fail(struct ctx *ctx, const struct media_params *params, int error)
params->can_seek, params->can_pause);
vlc_player_t *player = ctx->player;
- size_t prev_status_idx = 0;
player_set_current_mock_media(ctx, "media1", params, false);
- struct timer_state smpte_timer, *timer = &smpte_timer;
- player_add_timer(player, timer, true, VLC_TICK_INVALID);
+ struct np_ctx np_ctx = {
+ .ctx = ctx,
+ .prev_status_idx = 0,
+ .next_status_idx = 0,
+ };
+ player_add_timer(player, &np_ctx.timers[0], true, VLC_TICK_INVALID);
+ np_ctx.timers_count = 1;
+ struct timer_state *timer = &np_ctx.timers[0];
player_start(ctx);
@@ -378,7 +460,7 @@ test_fail(struct ctx *ctx, const struct media_params *params, int error)
vlc_player_PreviousVideoFrame(player);
- wait_prev_frame_status(ctx, &prev_status_idx, 1, error);
+ wait_prev_frame_status(&np_ctx, 1, error);
test_end(ctx);
player_remove_timer(player, timer);
@@ -390,29 +472,34 @@ test_vout_fail(struct ctx *ctx, const struct media_params *params)
test_log("prev-frame fail (no vout)\n");
vlc_player_t *player = ctx->player;
- size_t prev_status_idx = 0;
player_set_current_mock_media(ctx, "media1", params, false);
- struct timer_state timer;
- player_add_timer(player, &timer, false, VLC_TICK_INVALID);
+ struct np_ctx np_ctx = {
+ .ctx = ctx,
+ .prev_status_idx = 0,
+ .next_status_idx = 0,
+ };
+ player_add_timer(player, &np_ctx.timers[0], false, VLC_TICK_INVALID);
+ np_ctx.timers_count = 1;
+ struct timer_state *timer = &np_ctx.timers[0];
player_start(ctx);
struct report_timer *r = NULL;
- player_lock_timer(player, &timer);
- r = timer_state_wait_next_report(&timer);
+ player_lock_timer(player, timer);
+ r = timer_state_wait_next_report(timer);
assert(r->type == REPORT_TIMER_POINT);
- player_unlock_timer(player, &timer);
+ player_unlock_timer(player, timer);
vlc_player_PreviousVideoFrame(player);
- wait_prev_frame_status(ctx, &prev_status_idx, 1, -EAGAIN);
+ wait_prev_frame_status(&np_ctx, 1, -EAGAIN);
vlc_player_PreviousVideoFrame(player);
- wait_prev_frame_status(ctx, &prev_status_idx, 1, -EBUSY);
+ wait_prev_frame_status(&np_ctx, 1, -EBUSY);
test_end(ctx);
- player_remove_timer(player, &timer);
+ player_remove_timer(player, timer);
}
int
@@ -439,6 +526,10 @@ main(void)
test_prev(&ctx, ¶ms);
params.video_frame_rate_base = 1;
+ /* Now, disable audio to also test normal timer */
+ params.track_count[AUDIO_ES] = 0;
+ params.track_count[SPU_ES] = 0;
+
/* 60 fps */
params.video_frame_rate = 60;
test_prev(&ctx, ¶ms);
View it on GitLab: https://code.videolan.org/videolan/vlc/-/compare/0ebf883d81957e4faa733b5e56251b4e8a5e665e...cfaeefa7adbe50acccb7e21411263fc4aea382bb
--
View it on GitLab: https://code.videolan.org/videolan/vlc/-/compare/0ebf883d81957e4faa733b5e56251b4e8a5e665e...cfaeefa7adbe50acccb7e21411263fc4aea382bb
You're receiving this email because of your account on code.videolan.org.
VideoLAN code repository instance
More information about the vlc-commits
mailing list