{
*did_decode = false;
{
- unique_lock<mutex> lock(cache_mu);
+ lock_guard<mutex> lock(cache_mu);
auto it = cache.find(frame_spec);
if (it != cache.end()) {
++metric_jpeg_cache_hit_frames;
*did_decode = true;
shared_ptr<Frame> frame = decode_jpeg(frame_reader->read_frame(frame_spec));
- unique_lock<mutex> lock(cache_mu);
+ lock_guard<mutex> lock(cache_mu);
cache_bytes_used += frame_size(*frame);
metric_jpeg_cache_used_bytes = cache_bytes_used;
cache[frame_spec] = LRUFrame{ frame, event_counter++ };
{
current_stream_idx = stream_idx; // TODO: Does this interact with fades?
- unique_lock<mutex> lock(cache_mu);
+ lock_guard<mutex> lock(cache_mu);
PendingDecode decode;
decode.primary = frame;
decode.secondary = secondary_frame;
void JPEGFrameView::setFrame(shared_ptr<Frame> frame)
{
- unique_lock<mutex> lock(cache_mu);
+ lock_guard<mutex> lock(cache_mu);
PendingDecode decode;
decode.frame = std::move(frame);
decode.destination = this;
// Corner case: If a new clip is waiting to be played, change its stream and then we're done.
{
- unique_lock<mutex> lock(queue_state_mu);
+ lock_guard<mutex> lock(queue_state_mu);
if (new_clip_ready) {
assert(queued_clip_list.size() == 1);
queued_clip_list[0].stream_idx = stream_idx;
void Player::take_queue_spot()
{
- unique_lock<mutex> lock(queue_state_mu);
+ lock_guard<mutex> lock(queue_state_mu);
++num_queued_frames;
}
void Player::release_queue_spot()
{
- unique_lock<mutex> lock(queue_state_mu);
+ lock_guard<mutex> lock(queue_state_mu);
assert(num_queued_frames > 0);
--num_queued_frames;
new_clip_changed.notify_all();
deque<QueuedFrame> q;
{
- unique_lock<mutex> lock(queue_lock);
+ lock_guard<mutex> lock(queue_lock);
q = move(frame_queue);
}
qf.display_func = move(display_func);
qf.queue_spot_holder = move(queue_spot_holder);
- unique_lock<mutex> lock(queue_lock);
+ lock_guard<mutex> lock(queue_lock);
frame_queue.push_back(move(qf));
queue_changed.notify_all();
}
// separate pools around.)
BorrowedInterpolatedFrameResources resources;
{
- unique_lock<mutex> lock(queue_lock);
+ lock_guard<mutex> lock(queue_lock);
if (interpolate_resources.empty()) {
fprintf(stderr, "WARNING: Too many interpolated frames already in transit; dropping one.\n");
return;
qf.resources = move(resources);
qf.local_pts = local_pts;
- unique_lock<mutex> lock(queue_lock);
+ lock_guard<mutex> lock(queue_lock);
frame_queue.push_back(move(qf));
queue_changed.notify_all();
}
// Get the temporary OpenGL resources we need for doing the interpolation.
BorrowedInterpolatedFrameResources resources;
{
- unique_lock<mutex> lock(queue_lock);
+ lock_guard<mutex> lock(queue_lock);
if (interpolate_resources.empty()) {
fprintf(stderr, "WARNING: Too many interpolated frames already in transit; dropping one.\n");
return;
check_error();
qf.resources = move(resources);
- unique_lock<mutex> lock(queue_lock);
+ lock_guard<mutex> lock(queue_lock);
frame_queue.push_back(move(qf));
queue_changed.notify_all();
}
qf.display_func = move(display_func);
qf.queue_spot_holder = move(queue_spot_holder);
- unique_lock<mutex> lock(queue_lock);
+ lock_guard<mutex> lock(queue_lock);
frame_queue.push_back(move(qf));
queue_changed.notify_all();
}
void operator() (InterpolatedFrameResources *ifr) const
{
if (ifr != nullptr) {
- std::unique_lock<std::mutex> lock(ifr->owner->queue_lock);
+ std::lock_guard<std::mutex> lock(ifr->owner->queue_lock);
ifr->owner->interpolate_resources.emplace_back(ifr);
}
}
void set_gain_staging_db(unsigned bus_index, float gain_db)
{
- std::unique_lock<std::mutex> lock(compressor_mutex);
+ std::lock_guard<std::mutex> lock(compressor_mutex);
level_compressor_enabled[bus_index] = false;
gain_staging_db[bus_index] = gain_db;
}
float get_gain_staging_db(unsigned bus_index) const
{
- std::unique_lock<std::mutex> lock(compressor_mutex);
+ std::lock_guard<std::mutex> lock(compressor_mutex);
return gain_staging_db[bus_index];
}
void set_gain_staging_auto(unsigned bus_index, bool enabled)
{
- std::unique_lock<std::mutex> lock(compressor_mutex);
+ std::lock_guard<std::mutex> lock(compressor_mutex);
level_compressor_enabled[bus_index] = enabled;
}
bool get_gain_staging_auto(unsigned bus_index) const
{
- std::unique_lock<std::mutex> lock(compressor_mutex);
+ std::lock_guard<std::mutex> lock(compressor_mutex);
return level_compressor_enabled[bus_index];
}
void set_final_makeup_gain_db(float gain_db)
{
- std::unique_lock<std::mutex> lock(compressor_mutex);
+ std::lock_guard<std::mutex> lock(compressor_mutex);
final_makeup_gain_auto = false;
final_makeup_gain = from_db(gain_db);
}
float get_final_makeup_gain_db()
{
- std::unique_lock<std::mutex> lock(compressor_mutex);
+ std::lock_guard<std::mutex> lock(compressor_mutex);
return to_db(final_makeup_gain);
}
void set_final_makeup_gain_auto(bool enabled)
{
- std::unique_lock<std::mutex> lock(compressor_mutex);
+ std::lock_guard<std::mutex> lock(compressor_mutex);
final_makeup_gain_auto = enabled;
}
bool get_final_makeup_gain_auto() const
{
- std::unique_lock<std::mutex> lock(compressor_mutex);
+ std::lock_guard<std::mutex> lock(compressor_mutex);
return final_makeup_gain_auto;
}
float level_db;
{
- unique_lock<mutex> lock(level_mutex);
+ lock_guard<mutex> lock(level_mutex);
level_db = this->level_db;
}
CompressionReductionMeter(QWidget *parent);
void set_reduction_db(float level_db) {
- std::unique_lock<std::mutex> lock(level_mutex);
+ std::lock_guard<std::mutex> lock(level_mutex);
this->level_db = level_db;
QMetaObject::invokeMethod(this, "update", Qt::AutoConnection);
}
float correlation;
{
- unique_lock<mutex> lock(correlation_mutex);
+ lock_guard<mutex> lock(correlation_mutex);
correlation = this->correlation;
}
CorrelationMeter(QWidget *parent);
void set_correlation(float correlation) {
- std::unique_lock<std::mutex> lock(correlation_mutex);
+ std::lock_guard<std::mutex> lock(correlation_mutex);
this->correlation = correlation;
QMetaObject::invokeMethod(this, "update", Qt::AutoConnection);
}
frame->duration = duration;
{
- unique_lock<mutex> lock(frame_queue_mutex);
+ lock_guard<mutex> lock(frame_queue_mutex);
pending_video_frames.push(move(frame));
}
frame_queues_changed.notify_all();
// so there's a fair amount of OpenGL memory waste anyway (the cache
// is mostly there to save startup time, not RAM).
{
- unique_lock<mutex> lock(all_images_lock);
+ lock_guard<mutex> lock(all_images_lock);
if (all_images[pathname] != current_image) {
current_image = all_images[pathname];
set_pixel_data(current_image->pixels.get());
shared_ptr<const ImageInput::Image> ImageInput::load_image(const string &filename, const string &pathname)
{
- unique_lock<mutex> lock(all_images_lock); // Held also during loading.
+ lock_guard<mutex> lock(all_images_lock); // Held also during loading.
if (all_images.count(pathname)) {
return all_images[pathname];
}
continue;
}
fprintf(stderr, "Loaded new version of %s from disk.\n", pathname.c_str());
- unique_lock<mutex> lock(all_images_lock);
+ lock_guard<mutex> lock(all_images_lock);
all_images[pathname] = image;
last_modified = image->last_modified;
}
void ImageInput::shutdown_updaters()
{
{
- unique_lock<mutex> lock(threads_should_quit_mu);
+ lock_guard<mutex> lock(threads_should_quit_mu);
threads_should_quit = true;
threads_should_quit_modified.notify_all();
}
float range_low_lufs;
float range_high_lufs;
{
- unique_lock<mutex> lock(level_mutex);
+ lock_guard<mutex> lock(level_mutex);
level_lufs = this->level_lufs;
range_low_lufs = this->range_low_lufs;
range_high_lufs = this->range_high_lufs;
LRAMeter(QWidget *parent);
void set_levels(float level_lufs, float range_low_lufs, float range_high_lufs) {
- std::unique_lock<std::mutex> lock(level_mutex);
+ std::lock_guard<std::mutex> lock(level_mutex);
this->level_lufs = level_lufs;
this->range_low_lufs = range_low_lufs;
this->range_high_lufs = range_high_lufs;
// Still send on the information that we _had_ a frame, even though it's corrupted,
// so that pts can go up accordingly.
{
- unique_lock<mutex> lock(card_mutex);
+ lock_guard<mutex> lock(card_mutex);
CaptureCard::NewFrame new_frame;
new_frame.frame = RefCountedFrame(FrameAllocator::Frame());
new_frame.length = frame_length;
}
{
- unique_lock<mutex> lock(card_mutex);
+ lock_guard<mutex> lock(card_mutex);
CaptureCard::NewFrame new_frame;
new_frame.frame = frame;
new_frame.length = frame_length;
// non-dropped frame; perhaps we should just discard that as well,
// since dropped frames are expected to be rare, and it might be
// better to just wait until we have a slightly more normal situation).
- unique_lock<mutex> lock(audio_mutex);
+ lock_guard<mutex> lock(audio_mutex);
bool adjust_rate = !dropped_frame && !is_preroll;
audio_task_queue.push(AudioTask{pts_int, num_samples_per_frame, adjust_rate, frame_timestamp});
audio_task_queue_changed.notify_one();
// Update Y'CbCr settings for all cards.
{
- unique_lock<mutex> lock(card_mutex);
+ lock_guard<mutex> lock(card_mutex);
for (unsigned card_index = 0; card_index < num_cards; ++card_index) {
YCbCrInterpretation *interpretation = &ycbcr_interpretation[card_index];
input_state.ycbcr_coefficients_auto[card_index] = interpretation->ycbcr_coefficients_auto;
YCbCrInterpretation Mixer::get_input_ycbcr_interpretation(unsigned card_index) const
{
- unique_lock<mutex> lock(card_mutex);
+ lock_guard<mutex> lock(card_mutex);
return ycbcr_interpretation[card_index];
}
void Mixer::set_input_ycbcr_interpretation(unsigned card_index, const YCbCrInterpretation &interpretation)
{
- unique_lock<mutex> lock(card_mutex);
+ lock_guard<mutex> lock(card_mutex);
ycbcr_interpretation[card_index] = interpretation;
}
map<uint32_t, VideoMode> Mixer::get_available_output_video_modes() const
{
assert(desired_output_card_index != -1);
- unique_lock<mutex> lock(card_mutex);
+ lock_guard<mutex> lock(card_mutex);
return cards[desired_output_card_index].output->get_available_video_modes();
}
// Store this frame for display. Remove the ready frame if any
// (it was seemingly never used).
{
- unique_lock<mutex> lock(frame_mutex);
+ lock_guard<mutex> lock(frame_mutex);
if (has_ready_frame) {
parent->release_display_frame(&ready_frame);
}
bool Mixer::OutputChannel::get_display_frame(DisplayFrame *frame)
{
- unique_lock<mutex> lock(frame_mutex);
+ lock_guard<mutex> lock(frame_mutex);
if (!has_current_frame && !has_ready_frame) {
return false;
}
void Mixer::OutputChannel::add_frame_ready_callback(void *key, Mixer::new_frame_ready_callback_t callback)
{
- unique_lock<mutex> lock(frame_mutex);
+ lock_guard<mutex> lock(frame_mutex);
new_frame_ready_callbacks[key] = callback;
}
void Mixer::OutputChannel::remove_frame_ready_callback(void *key)
{
- unique_lock<mutex> lock(frame_mutex);
+ lock_guard<mutex> lock(frame_mutex);
new_frame_ready_callbacks.erase(key);
}
void NageruCefApp::close_browser(CefRefPtr<CefBrowser> browser)
{
- unique_lock<mutex> lock(cef_mutex);
+ lock_guard<mutex> lock(cef_mutex);
browser->GetHost()->CloseBrowser(/*force_close=*/true);
}
{
Frame vf;
- unique_lock<mutex> lock(freelist_mutex); // Meh.
+ lock_guard<mutex> lock(freelist_mutex); // Meh.
if (freelist.empty()) {
printf("Frame overrun (no more spare PBO frames), dropping frame!\n");
} else {
}
#endif
- unique_lock<mutex> lock(freelist_mutex);
+ lock_guard<mutex> lock(freelist_mutex);
freelist.push(frame);
//--sumsum;
}
pic_param.CurrPic.frame_idx = current_ref_frame_num;
CurrentCurrPic.flags = VA_PICTURE_H264_SHORT_TERM_REFERENCE;
- unique_lock<mutex> lock(storage_task_queue_mutex);
+ lock_guard<mutex> lock(storage_task_queue_mutex);
// Insert the new frame at the start of the reference queue.
reference_frames.push_front(ReferenceFrame{ CurrentCurrPic, current_display_frame });
// this is weird. but it seems to put a new frame onto the queue
void QuickSyncEncoderImpl::storage_task_enqueue(storage_task task)
{
- unique_lock<mutex> lock(storage_task_queue_mutex);
+ lock_guard<mutex> lock(storage_task_queue_mutex);
storage_task_queue.push(move(task));
storage_task_queue_changed.notify_all();
}
// Unlock the frame, and all its references.
{
- unique_lock<mutex> lock(storage_task_queue_mutex);
+ lock_guard<mutex> lock(storage_task_queue_mutex);
release_gl_surface(display_order);
for (size_t frame_num : ref_display_frame_numbers) {
GLenum type = global_flags.x264_bit_depth > 8 ? GL_UNSIGNED_SHORT : GL_UNSIGNED_BYTE;
GLSurface *surf;
{
- unique_lock<mutex> lock(storage_task_queue_mutex);
+ lock_guard<mutex> lock(storage_task_queue_mutex);
surf = surface_for_frame[current_storage_frame];
assert(surf != nullptr);
}
check_error();
{
- unique_lock<mutex> lock(frame_queue_mutex);
+ lock_guard<mutex> lock(frame_queue_mutex);
current_video_frame.fence = fence;
pending_video_frames.push(move(current_video_frame));
++current_storage_frame;
}
{
- unique_lock<mutex> lock(frame_queue_mutex);
+ lock_guard<mutex> lock(frame_queue_mutex);
encode_thread_should_quit = true;
frame_queue_nonempty.notify_all();
}
encode_thread.join();
{
- unique_lock<mutex> lock(storage_task_queue_mutex);
+ lock_guard<mutex> lock(storage_task_queue_mutex);
storage_thread_should_quit = true;
frame_queue_nonempty.notify_all();
storage_task_queue_changed.notify_all();
pass_frame(frame, display_frame_num, frame.pts, frame.duration);
if (global_flags.x264_video_to_disk) {
- unique_lock<mutex> lock(storage_task_queue_mutex);
+ lock_guard<mutex> lock(storage_task_queue_mutex);
release_gl_surface(display_frame_num);
continue;
}
if (frame_type == FRAME_IDR) {
// Release any reference frames from the previous GOP.
{
- unique_lock<mutex> lock(storage_task_queue_mutex);
+ lock_guard<mutex> lock(storage_task_queue_mutex);
for (const ReferenceFrame &frame : reference_frames) {
release_gl_surface(frame.display_number);
}
GLSurface *surf;
{
- unique_lock<mutex> lock(storage_task_queue_mutex);
+ lock_guard<mutex> lock(storage_task_queue_mutex);
surf = surface_for_frame[display_frame_num];
assert(surf != nullptr);
}
GLSurface *surf;
{
- unique_lock<mutex> lock(storage_task_queue_mutex);
+ lock_guard<mutex> lock(storage_task_queue_mutex);
surf = surface_for_frame[display_frame_num];
assert(surf != nullptr);
}
// Lock the references for this frame; otherwise, they could be
// rendered to before this frame is done encoding.
{
- unique_lock<mutex> lock(storage_task_queue_mutex);
+ lock_guard<mutex> lock(storage_task_queue_mutex);
for (const ReferenceFrame &frame : reference_frames) {
assert(surface_for_frame.count(frame.display_number));
++surface_for_frame[frame.display_number]->refcount;
public:
LuaRefWithDeleter(mutex *m, lua_State *L, int ref) : m(m), L(L), ref(ref) {}
~LuaRefWithDeleter() {
- unique_lock<mutex> lock(*m);
+ lock_guard<mutex> lock(*m);
luaL_unref(L, LUA_REGISTRYINDEX, ref);
}
int get() const { return ref; }
{
Chain chain;
- unique_lock<mutex> lock(m);
+ lock_guard<mutex> lock(m);
assert(lua_gettop(L) == 0);
lua_getglobal(L, "get_chain"); /* function to be called */
lua_pushnumber(L, num);
assert(lua_gettop(L) == 0);
chain.setup_chain = [this, funcref, input_state, effect_chain]{
- unique_lock<mutex> lock(m);
+ lock_guard<mutex> lock(m);
assert(this->input_state == nullptr);
this->input_state = &input_state;
string Theme::get_channel_name(unsigned channel)
{
- unique_lock<mutex> lock(m);
+ lock_guard<mutex> lock(m);
lua_getglobal(L, "channel_name");
lua_pushnumber(L, channel);
if (lua_pcall(L, 1, 1, 0) != 0) {
int Theme::get_channel_signal(unsigned channel)
{
- unique_lock<mutex> lock(m);
+ lock_guard<mutex> lock(m);
lua_getglobal(L, "channel_signal");
lua_pushnumber(L, channel);
if (lua_pcall(L, 1, 1, 0) != 0) {
std::string Theme::get_channel_color(unsigned channel)
{
- unique_lock<mutex> lock(m);
+ lock_guard<mutex> lock(m);
lua_getglobal(L, "channel_color");
lua_pushnumber(L, channel);
if (lua_pcall(L, 1, 1, 0) != 0) {
bool Theme::get_supports_set_wb(unsigned channel)
{
- unique_lock<mutex> lock(m);
+ lock_guard<mutex> lock(m);
lua_getglobal(L, "supports_set_wb");
lua_pushnumber(L, channel);
if (lua_pcall(L, 1, 1, 0) != 0) {
void Theme::set_wb(unsigned channel, double r, double g, double b)
{
- unique_lock<mutex> lock(m);
+ lock_guard<mutex> lock(m);
lua_getglobal(L, "set_wb");
lua_pushnumber(L, channel);
lua_pushnumber(L, r);
vector<string> Theme::get_transition_names(float t)
{
- unique_lock<mutex> lock(m);
+ lock_guard<mutex> lock(m);
lua_getglobal(L, "get_transitions");
lua_pushnumber(L, t);
if (lua_pcall(L, 1, 1, 0) != 0) {
return -1 - signal_num;
}
- unique_lock<mutex> lock(map_m);
+ lock_guard<mutex> lock(map_m);
if (signal_to_card_mapping.count(signal_num)) {
return signal_to_card_mapping[signal_num];
}
void Theme::set_signal_mapping(int signal_num, int card_num)
{
- unique_lock<mutex> lock(map_m);
+ lock_guard<mutex> lock(map_m);
assert(card_num < int(num_cards));
signal_to_card_mapping[signal_num] = card_num;
}
void Theme::transition_clicked(int transition_num, float t)
{
- unique_lock<mutex> lock(m);
+ lock_guard<mutex> lock(m);
lua_getglobal(L, "transition_clicked");
lua_pushnumber(L, transition_num);
lua_pushnumber(L, t);
void Theme::channel_clicked(int preview_num)
{
- unique_lock<mutex> lock(m);
+ lock_guard<mutex> lock(m);
lua_getglobal(L, "channel_clicked");
lua_pushnumber(L, preview_num);
void Theme::theme_menu_entry_clicked(int lua_ref)
{
- unique_lock<mutex> lock(m);
+ lock_guard<mutex> lock(m);
lua_rawgeti(L, LUA_REGISTRYINDEX, lua_ref);
if (lua_pcall(L, 0, 0, 0) != 0) {
fprintf(stderr, "error running menu callback: %s\n", lua_tostring(L, -1));
float level_lufs[2], peak_lufs[2];
{
- unique_lock<mutex> lock(level_mutex);
+ lock_guard<mutex> lock(level_mutex);
level_lufs[0] = this->level_lufs[0];
level_lufs[1] = this->level_lufs[1];
peak_lufs[0] = this->peak_lufs[0];
}
void set_level(float level_lufs_left, float level_lufs_right) {
- std::unique_lock<std::mutex> lock(level_mutex);
+ std::lock_guard<std::mutex> lock(level_mutex);
this->level_lufs[0] = level_lufs_left;
this->level_lufs[1] = level_lufs_right;
QMetaObject::invokeMethod(this, "update", Qt::AutoConnection);
}
void set_peak(float peak_lufs_left, float peak_lufs_right) {
- std::unique_lock<std::mutex> lock(level_mutex);
+ std::lock_guard<std::mutex> lock(level_mutex);
this->peak_lufs[0] = peak_lufs_left;
this->peak_lufs[1] = peak_lufs_right;
QMetaObject::invokeMethod(this, "update", Qt::AutoConnection);
void HTTPD::add_data(StreamType stream_type, const char *buf, size_t size, bool keyframe, int64_t time, AVRational timebase)
{
- unique_lock<mutex> lock(streams_mutex);
+ lock_guard<mutex> lock(streams_mutex);
for (Stream *stream : streams) {
if (stream->get_stream_type() == stream_type) {
stream->add_data(buf, size, keyframe ? Stream::DATA_TYPE_KEYFRAME : Stream::DATA_TYPE_OTHER, time, timebase);
HTTPD::Stream *stream = new HTTPD::Stream(this, framing, stream_type);
stream->add_data(header[stream_type].data(), header[stream_type].size(), Stream::DATA_TYPE_HEADER, AV_NOPTS_VALUE, AVRational{ 1, 0 });
{
- unique_lock<mutex> lock(streams_mutex);
+ lock_guard<mutex> lock(streams_mutex);
streams.insert(stream);
}
++metric_num_connected_clients;
--httpd->metric_num_connected_multicam_clients;
}
{
- unique_lock<mutex> lock(httpd->streams_mutex);
+ lock_guard<mutex> lock(httpd->streams_mutex);
delete stream;
httpd->streams.erase(stream);
}
return;
}
- unique_lock<mutex> lock(buffer_mutex);
+ lock_guard<mutex> lock(buffer_mutex);
if (framing == FRAMING_METACUBE) {
int flags = 0;
void HTTPD::Stream::stop()
{
- unique_lock<mutex> lock(buffer_mutex);
+ lock_guard<mutex> lock(buffer_mutex);
should_quit = true;
has_buffered_data.notify_all();
}
projects / nageru / commitdiff