1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
|
/******************************************************************************
* recordMyDesktop *
*******************************************************************************
* *
* Copyright (C) 2006,2007,2008 John Varouhakis *
* *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the Free Software *
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA *
* *
* *
* *
* For further information contact me at johnvarouhakis@gmail.com *
******************************************************************************/
#include "config.h"
#include "rmd_timer.h"
#include "rmd_threads.h"
#include "rmd_types.h"
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <time.h>
#include <unistd.h>
static struct timespec us_to_timespec(unsigned int us)
{
return (struct timespec){
.tv_sec = us / 1000000,
.tv_nsec = (us % 1000000) * 1000,
};
}
static void sync_streams(ProgData *pdata, unsigned int *frame_step, struct timespec *delay) {
int avd;
pthread_mutex_lock(&pdata->avd_mutex);
avd = pdata->avd + pdata->frametime;
/* There are two knobs available for keeping the video synchronized with the audio:
* 1. frame_step; how many frames to encode from this frame (aka dropping frames if > 1)
* 2. delay; how long to delay the next get_frame
*
* When avd is negative, we need more video relative to audio. That can be achieved
* by either sleeping less between frames, or dropping them by having the encoder
* encode a given frame multiple times.
*
* When avd is positive, we need more audio relative to video, so less video. This
* can be achieved by sleeping more between frames.
*/
if (avd < 0) {
int frames_behind = -avd / pdata->frametime;
if (frames_behind > 0) {
/* more than a whole frame behind, drop frames to catch up */
*frame_step += frames_behind;
avd += frames_behind * pdata->frametime;
} else {
/* less than a whole frame behind, just sleep less */
*delay = us_to_timespec(pdata->frametime + avd);
}
} else if (avd > 0) {
/* sleep longer */
*delay = us_to_timespec(pdata->frametime + avd);
}
pdata->avd = avd;
pthread_mutex_unlock(&pdata->avd_mutex);
#if 0
printf("avd: %i frame_step: %u delay: %lu,%lu\n",
avd, *frame_step, (*delay).tv_sec, (*delay).tv_nsec);
#endif
}
void *rmdTimer(ProgData *pdata) {
rmdThreadsSetName("rmdTimer");
while (pdata->timer_alive) {
struct timespec delay;
unsigned int frame_step = 1;
delay.tv_sec = 1.f / pdata->args.fps;
delay.tv_nsec = 1000000000.f / pdata->args.fps - delay.tv_sec * 1000000000.f;
pthread_mutex_lock(&pdata->pause_mutex);
if (pdata->pause_state_changed) {
pdata->pause_state_changed = FALSE;
if (!pdata->paused) {
pdata->paused = TRUE;
fprintf(stderr,"STATE:PAUSED\n");fflush(stderr);
} else{
pdata->paused = FALSE;
fprintf(stderr,"STATE:RECORDING\n");fflush(stderr);
pthread_cond_broadcast(&pdata->pause_cond);
}
}
/* When paused, stop advancing time_frameno, get_frame only progresses
* when time_frameno > capture_frameno. But get_frame needs to service
* the event loop even when paused, so still signal time_cond just with
* pdata->time_frameno frozen. get_frame will then handle time_cond
* wakeups where capture_frameno >= time_frameno as "poll events".
*/
if (pdata->paused)
frame_step = 0;
pthread_mutex_unlock(&pdata->pause_mutex);
if (frame_step) {
if (!pdata->args.nosound)
sync_streams(pdata, &frame_step, &delay);
pthread_mutex_lock(&pdata->time_mutex);
pdata->time_frameno += frame_step;
pthread_mutex_unlock(&pdata->time_mutex);
}
pthread_cond_signal(&pdata->time_cond);
nanosleep(&delay, NULL);
}
pthread_exit(&errno);
}
|
