1 #include <movit/effect_util.h>
2 #include <movit/util.h>
3 #include <movit/resource_pool.h> // Must be above the Xlib includes.
11 #include "chroma_subsampler.h"
12 #include "decklink_output.h"
13 #include "decklink_util.h"
15 #include "shared/metrics.h"
16 #include "print_latency.h"
17 #include "shared/timebase.h"
18 #include "v210_converter.h"
20 using namespace movit;
22 using namespace std::chrono;
26 // This class can be deleted during regular use, so make all the metrics static.
27 once_flag decklink_metrics_inited;
28 LatencyHistogram latency_histogram;
29 atomic<int64_t> metric_decklink_output_width_pixels{-1};
30 atomic<int64_t> metric_decklink_output_height_pixels{-1};
31 atomic<int64_t> metric_decklink_output_frame_rate_den{-1};
32 atomic<int64_t> metric_decklink_output_frame_rate_nom{-1};
33 atomic<int64_t> metric_decklink_output_inflight_frames{0};
34 atomic<int64_t> metric_decklink_output_color_mismatch_frames{0};
36 atomic<int64_t> metric_decklink_output_scheduled_frames_dropped{0};
37 atomic<int64_t> metric_decklink_output_scheduled_frames_late{0};
38 atomic<int64_t> metric_decklink_output_scheduled_frames_normal{0};
39 atomic<int64_t> metric_decklink_output_scheduled_frames_preroll{0};
41 atomic<int64_t> metric_decklink_output_completed_frames_completed{0};
42 atomic<int64_t> metric_decklink_output_completed_frames_dropped{0};
43 atomic<int64_t> metric_decklink_output_completed_frames_flushed{0};
44 atomic<int64_t> metric_decklink_output_completed_frames_late{0};
45 atomic<int64_t> metric_decklink_output_completed_frames_unknown{0};
47 atomic<int64_t> metric_decklink_output_scheduled_samples{0};
49 Summary metric_decklink_output_margin_seconds;
53 DeckLinkOutput::DeckLinkOutput(ResourcePool *resource_pool, QSurface *surface, unsigned width, unsigned height, unsigned card_index)
54 : resource_pool(resource_pool), surface(surface), width(width), height(height), card_index(card_index)
56 chroma_subsampler.reset(new ChromaSubsampler(resource_pool));
58 call_once(decklink_metrics_inited, [](){
59 latency_histogram.init("decklink_output");
60 global_metrics.add("decklink_output_width_pixels", &metric_decklink_output_width_pixels, Metrics::TYPE_GAUGE);
61 global_metrics.add("decklink_output_height_pixels", &metric_decklink_output_height_pixels, Metrics::TYPE_GAUGE);
62 global_metrics.add("decklink_output_frame_rate_den", &metric_decklink_output_frame_rate_den, Metrics::TYPE_GAUGE);
63 global_metrics.add("decklink_output_frame_rate_nom", &metric_decklink_output_frame_rate_nom, Metrics::TYPE_GAUGE);
64 global_metrics.add("decklink_output_inflight_frames", &metric_decklink_output_inflight_frames, Metrics::TYPE_GAUGE);
65 global_metrics.add("decklink_output_color_mismatch_frames", &metric_decklink_output_color_mismatch_frames);
67 global_metrics.add("decklink_output_scheduled_frames", {{ "status", "dropped" }}, &metric_decklink_output_scheduled_frames_dropped);
68 global_metrics.add("decklink_output_scheduled_frames", {{ "status", "late" }}, &metric_decklink_output_scheduled_frames_late);
69 global_metrics.add("decklink_output_scheduled_frames", {{ "status", "normal" }}, &metric_decklink_output_scheduled_frames_normal);
70 global_metrics.add("decklink_output_scheduled_frames", {{ "status", "preroll" }}, &metric_decklink_output_scheduled_frames_preroll);
72 global_metrics.add("decklink_output_completed_frames", {{ "status", "completed" }}, &metric_decklink_output_completed_frames_completed);
73 global_metrics.add("decklink_output_completed_frames", {{ "status", "dropped" }}, &metric_decklink_output_completed_frames_dropped);
74 global_metrics.add("decklink_output_completed_frames", {{ "status", "flushed" }}, &metric_decklink_output_completed_frames_flushed);
75 global_metrics.add("decklink_output_completed_frames", {{ "status", "late" }}, &metric_decklink_output_completed_frames_late);
76 global_metrics.add("decklink_output_completed_frames", {{ "status", "unknown" }}, &metric_decklink_output_completed_frames_unknown);
78 global_metrics.add("decklink_output_scheduled_samples", &metric_decklink_output_scheduled_samples);
79 vector<double> quantiles{0.01, 0.1, 0.25, 0.5, 0.75, 0.9, 0.99};
80 metric_decklink_output_margin_seconds.init(quantiles, 60.0);
81 global_metrics.add("decklink_output_margin_seconds", &metric_decklink_output_margin_seconds);
85 bool DeckLinkOutput::set_device(IDeckLink *decklink, IDeckLinkInput *input_arg)
88 if (decklink->QueryInterface(IID_IDeckLinkOutput, (void**)&output) != S_OK) {
89 fprintf(stderr, "Warning: Card %u has no outputs\n", card_index);
93 IDeckLinkDisplayModeIterator *mode_it;
94 if (output->GetDisplayModeIterator(&mode_it) != S_OK) {
95 fprintf(stderr, "Warning: Failed to enumerate output display modes for card %u\n", card_index);
101 for (const auto &it : summarize_video_modes(mode_it, card_index)) {
102 if (it.second.width != width || it.second.height != height) {
106 // We could support interlaced modes, but let's stay out of it for now,
107 // since we don't have interlaced stream output.
108 if (it.second.interlaced) {
112 video_modes.insert(it);
117 // HDMI or SDI generally mean “both HDMI and SDI at the same time” on DeckLink cards
118 // that support both; pick_default_video_connection() will generally pick one of those
119 // if they exist. (--prefer-hdmi-input would also affect the selection despite the name
120 // of the option, but since either generally means both, it's inconsequential.)
121 // We're not very likely to need analog outputs, so we don't need a way to change
123 video_connection = pick_default_video_connection(decklink, BMDDeckLinkVideoOutputConnections, card_index);
127 void DeckLinkOutput::start_output(uint32_t mode, int64_t base_pts)
130 assert(!playback_initiated);
132 if (video_modes.empty()) {
133 fprintf(stderr, "ERROR: No matching output modes for %dx%d found\n", width, height);
137 should_quit.unquit();
138 playback_initiated = true;
139 playback_started = false;
140 this->base_pts = base_pts;
142 IDeckLinkConfiguration *config = nullptr;
143 if (output->QueryInterface(IID_IDeckLinkConfiguration, (void**)&config) != S_OK) {
144 fprintf(stderr, "Failed to get configuration interface for output card\n");
147 if (config->SetFlag(bmdDeckLinkConfigLowLatencyVideoOutput, true) != S_OK) {
148 fprintf(stderr, "Failed to set low latency output\n");
151 if (config->SetInt(bmdDeckLinkConfigVideoOutputConnection, video_connection) != S_OK) {
152 fprintf(stderr, "Failed to set video output connection for card %u\n", card_index);
155 if (config->SetFlag(bmdDeckLinkConfigOutput1080pAsPsF, true) != S_OK) {
156 fprintf(stderr, "Failed to set PsF flag for card\n");
159 if (config->SetFlag(bmdDeckLinkConfigSMPTELevelAOutput, true) != S_OK) {
160 // This affects at least some no-name SDI->HDMI converters.
161 // Warn, but don't die.
162 fprintf(stderr, "WARNING: Failed to enable SMTPE Level A; resolutions like 1080p60 might have issues.\n");
165 BMDDisplayModeSupport support;
166 IDeckLinkDisplayMode *display_mode;
167 BMDPixelFormat pixel_format = global_flags.ten_bit_output ? bmdFormat10BitYUV : bmdFormat8BitYUV;
168 if (output->DoesSupportVideoMode(mode, pixel_format, bmdVideoOutputFlagDefault,
169 &support, &display_mode) != S_OK) {
170 fprintf(stderr, "Couldn't ask for format support\n");
174 if (support == bmdDisplayModeNotSupported) {
175 fprintf(stderr, "Requested display mode not supported\n");
179 current_mode_flags = display_mode->GetFlags();
181 BMDTimeValue time_value;
182 BMDTimeScale time_scale;
183 if (display_mode->GetFrameRate(&time_value, &time_scale) != S_OK) {
184 fprintf(stderr, "Couldn't get frame rate\n");
188 metric_decklink_output_width_pixels = width;
189 metric_decklink_output_height_pixels = height;
190 metric_decklink_output_frame_rate_nom = time_value;
191 metric_decklink_output_frame_rate_den = time_scale;
193 frame_duration = time_value * TIMEBASE / time_scale;
195 display_mode->Release();
197 if (input != nullptr) {
198 if (input->DisableVideoInput() != S_OK) {
199 fprintf(stderr, "Warning: Failed to disable video input for card %d\n", card_index);
201 if (input->DisableAudioInput() != S_OK) {
202 fprintf(stderr, "Warning: Failed to disable audio input for card %d\n", card_index);
206 HRESULT result = output->EnableVideoOutput(mode, bmdVideoOutputFlagDefault);
207 if (result != S_OK) {
208 fprintf(stderr, "Couldn't enable output with error 0x%x\n", result);
211 if (output->SetScheduledFrameCompletionCallback(this) != S_OK) {
212 fprintf(stderr, "Couldn't set callback\n");
215 assert(OUTPUT_FREQUENCY == 48000);
216 if (output->EnableAudioOutput(bmdAudioSampleRate48kHz, bmdAudioSampleType32bitInteger, 2, bmdAudioOutputStreamTimestamped) != S_OK) {
217 fprintf(stderr, "Couldn't enable audio output\n");
220 if (output->BeginAudioPreroll() != S_OK) {
221 fprintf(stderr, "Couldn't begin audio preroll\n");
225 present_thread = thread([this]{
226 QOpenGLContext *context = create_context(this->surface);
227 eglBindAPI(EGL_OPENGL_API);
228 if (!make_current(context, this->surface)) {
229 printf("display=%p surface=%p context=%p curr=%p err=%d\n", eglGetCurrentDisplay(), this->surface, context, eglGetCurrentContext(),
233 present_thread_func();
234 delete_context(context);
238 void DeckLinkOutput::end_output()
240 if (!playback_initiated) {
245 frame_queues_changed.notify_all();
246 present_thread.join();
247 playback_initiated = false;
249 output->StopScheduledPlayback(0, nullptr, 0);
250 output->DisableVideoOutput();
251 output->DisableAudioOutput();
253 // Wait until all frames are accounted for, and free them.
255 unique_lock<mutex> lock(frame_queue_mutex);
256 while (!(frame_freelist.empty() && scheduled_frames.empty())) {
257 frame_queues_changed.wait(lock, [this]{ return !frame_freelist.empty(); });
258 frame_freelist.pop();
262 if (input != nullptr) {
266 if (output != nullptr) {
272 void DeckLinkOutput::send_frame(GLuint y_tex, GLuint cbcr_tex, YCbCrLumaCoefficients output_ycbcr_coefficients, const vector<RefCountedFrame> &input_frames, int64_t pts, int64_t duration)
274 assert(!should_quit.should_quit());
276 if ((current_mode_flags & bmdDisplayModeColorspaceRec601) && output_ycbcr_coefficients == YCBCR_REC_709) {
277 if (!last_frame_had_mode_mismatch) {
278 fprintf(stderr, "WARNING: Chosen output mode expects Rec. 601 Y'CbCr coefficients.\n");
279 fprintf(stderr, " Consider --output-ycbcr-coefficients=rec601 (or =auto).\n");
281 last_frame_had_mode_mismatch = true;
282 ++metric_decklink_output_color_mismatch_frames;
283 } else if ((current_mode_flags & bmdDisplayModeColorspaceRec709) && output_ycbcr_coefficients == YCBCR_REC_601) {
284 if (!last_frame_had_mode_mismatch) {
285 fprintf(stderr, "WARNING: Chosen output mode expects Rec. 709 Y'CbCr coefficients.\n");
286 fprintf(stderr, " Consider --output-ycbcr-coefficients=rec709 (or =auto).\n");
288 last_frame_had_mode_mismatch = true;
289 ++metric_decklink_output_color_mismatch_frames;
291 last_frame_had_mode_mismatch = false;
294 unique_ptr<Frame> frame = get_frame();
295 if (global_flags.ten_bit_output) {
296 chroma_subsampler->create_v210(y_tex, cbcr_tex, width, height, frame->uyvy_tex);
298 chroma_subsampler->create_uyvy(y_tex, cbcr_tex, width, height, frame->uyvy_tex);
301 // Download the UYVY texture to the PBO.
302 glPixelStorei(GL_PACK_ROW_LENGTH, 0);
305 glBindBuffer(GL_PIXEL_PACK_BUFFER, frame->pbo);
308 if (global_flags.ten_bit_output) {
309 glBindTexture(GL_TEXTURE_2D, frame->uyvy_tex);
311 glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_INT_2_10_10_10_REV, BUFFER_OFFSET(0));
314 glBindTexture(GL_TEXTURE_2D, frame->uyvy_tex);
316 glGetTexImage(GL_TEXTURE_2D, 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, BUFFER_OFFSET(0));
320 glBindTexture(GL_TEXTURE_2D, 0);
322 glBindBuffer(GL_PIXEL_PACK_BUFFER, 0);
325 glMemoryBarrier(GL_TEXTURE_UPDATE_BARRIER_BIT | GL_CLIENT_MAPPED_BUFFER_BARRIER_BIT);
328 frame->fence = RefCountedGLsync(GL_SYNC_GPU_COMMANDS_COMPLETE, /*flags=*/0);
330 glFlush(); // Make the DeckLink thread see the fence as soon as possible.
333 frame->input_frames = input_frames;
334 frame->received_ts = find_received_timestamp(input_frames);
336 frame->duration = duration;
339 lock_guard<mutex> lock(frame_queue_mutex);
340 pending_video_frames.push(move(frame));
342 frame_queues_changed.notify_all();
345 void DeckLinkOutput::send_audio(int64_t pts, const std::vector<float> &samples)
347 unique_ptr<int32_t[]> int_samples(new int32_t[samples.size()]);
348 for (size_t i = 0; i < samples.size(); ++i) {
349 int_samples[i] = lrintf(samples[i] * 2147483648.0f);
352 uint32_t frames_written;
353 HRESULT result = output->ScheduleAudioSamples(int_samples.get(), samples.size() / 2,
354 pts, TIMEBASE, &frames_written);
355 if (result != S_OK) {
356 fprintf(stderr, "ScheduleAudioSamples(pts=%" PRId64 ") failed (result=0x%08x)\n", pts, result);
358 if (frames_written != samples.size() / 2) {
359 fprintf(stderr, "ScheduleAudioSamples() returned short write (%u/%zu)\n", frames_written, samples.size() / 2);
362 metric_decklink_output_scheduled_samples += samples.size() / 2;
365 void DeckLinkOutput::wait_for_frame(int64_t pts, int *dropped_frames, int64_t *frame_duration, bool *is_preroll, steady_clock::time_point *frame_timestamp)
367 assert(!should_quit.should_quit());
370 *frame_duration = this->frame_duration;
372 const BMDTimeValue buffer = lrint(*frame_duration * global_flags.output_buffer_frames);
373 const BMDTimeValue max_overshoot = lrint(*frame_duration * global_flags.output_slop_frames);
374 BMDTimeValue target_time = pts - buffer;
376 // While prerolling, we send out frames as quickly as we can.
377 if (target_time < base_pts) {
379 ++metric_decklink_output_scheduled_frames_preroll;
383 *is_preroll = !playback_started;
385 if (!playback_started) {
386 if (output->EndAudioPreroll() != S_OK) {
387 fprintf(stderr, "Could not end audio preroll\n");
390 if (output->StartScheduledPlayback(base_pts, TIMEBASE, 1.0) != S_OK) {
391 fprintf(stderr, "Could not start playback\n");
394 playback_started = true;
397 BMDTimeValue stream_frame_time;
398 double playback_speed;
399 output->GetScheduledStreamTime(TIMEBASE, &stream_frame_time, &playback_speed);
401 *frame_timestamp = steady_clock::now() +
402 nanoseconds((target_time - stream_frame_time) * 1000000000 / TIMEBASE);
404 metric_decklink_output_margin_seconds.count_event(
405 (target_time - stream_frame_time) / double(TIMEBASE));
407 // If we're ahead of time, wait for the frame to (approximately) start.
408 if (stream_frame_time < target_time) {
409 should_quit.sleep_until(*frame_timestamp);
410 ++metric_decklink_output_scheduled_frames_normal;
414 // If we overshot the previous frame by just a little,
415 // fire off one immediately.
416 if (stream_frame_time < target_time + max_overshoot) {
417 fprintf(stderr, "Warning: Frame was %ld ms late (but not skipping it due to --output-slop-frames).\n",
418 lrint((stream_frame_time - target_time) * 1000.0 / TIMEBASE));
419 ++metric_decklink_output_scheduled_frames_late;
423 // Oops, we missed by more than one frame. Return immediately,
424 // but drop so that we catch up.
425 *dropped_frames = (stream_frame_time - target_time + *frame_duration - 1) / *frame_duration;
426 const int64_t ns_per_frame = this->frame_duration * 1000000000 / TIMEBASE;
427 *frame_timestamp += nanoseconds(*dropped_frames * ns_per_frame);
428 fprintf(stderr, "Dropped %d output frames; skipping.\n", *dropped_frames);
429 metric_decklink_output_scheduled_frames_dropped += *dropped_frames;
430 ++metric_decklink_output_scheduled_frames_normal;
433 uint32_t DeckLinkOutput::pick_video_mode(uint32_t mode) const
435 if (video_modes.count(mode)) {
439 // Prioritize 59.94 > 60 > 29.97. If none of those are found, then pick the highest one.
440 for (const pair<int, int> &desired : vector<pair<int, int>>{ { 60000, 1001 }, { 60, 1 }, { 30000, 1001 } }) {
441 for (const auto &it : video_modes) {
442 if (it.second.frame_rate_num * desired.second == desired.first * it.second.frame_rate_den) {
448 uint32_t best_mode = 0;
449 double best_fps = 0.0;
450 for (const auto &it : video_modes) {
451 double fps = double(it.second.frame_rate_num) / it.second.frame_rate_den;
452 if (fps > best_fps) {
453 best_mode = it.first;
460 YCbCrLumaCoefficients DeckLinkOutput::preferred_ycbcr_coefficients() const
462 if (current_mode_flags & bmdDisplayModeColorspaceRec601) {
463 return YCBCR_REC_601;
465 // Don't bother checking bmdDisplayModeColorspaceRec709;
466 // if none is set, 709 is a good default anyway.
467 return YCBCR_REC_709;
471 HRESULT DeckLinkOutput::ScheduledFrameCompleted(/* in */ IDeckLinkVideoFrame *completedFrame, /* in */ BMDOutputFrameCompletionResult result)
473 Frame *frame = static_cast<Frame *>(completedFrame);
475 case bmdOutputFrameCompleted:
476 ++metric_decklink_output_completed_frames_completed;
478 case bmdOutputFrameDisplayedLate:
479 fprintf(stderr, "Output frame displayed late (pts=%" PRId64 ")\n", frame->pts);
480 fprintf(stderr, "Consider increasing --output-buffer-frames if this persists.\n");
481 ++metric_decklink_output_completed_frames_late;
483 case bmdOutputFrameDropped:
484 fprintf(stderr, "Output frame was dropped (pts=%" PRId64 ")\n", frame->pts);
485 fprintf(stderr, "Consider increasing --output-buffer-frames if this persists.\n");
486 ++metric_decklink_output_completed_frames_dropped;
488 case bmdOutputFrameFlushed:
489 fprintf(stderr, "Output frame was flushed (pts=%" PRId64 ")\n", frame->pts);
490 ++metric_decklink_output_completed_frames_flushed;
493 fprintf(stderr, "Output frame completed with unknown status %d\n", result);
494 ++metric_decklink_output_completed_frames_unknown;
498 static int frameno = 0;
499 print_latency("DeckLink output latency (frame received → output on HDMI):", frame->received_ts, false, &frameno, &latency_histogram);
502 lock_guard<mutex> lock(frame_queue_mutex);
503 frame_freelist.push(unique_ptr<Frame>(frame));
504 assert(scheduled_frames.front() == frame);
505 scheduled_frames.pop_front();
506 --metric_decklink_output_inflight_frames;
512 HRESULT DeckLinkOutput::ScheduledPlaybackHasStopped()
514 printf("playback stopped!\n");
518 unique_ptr<DeckLinkOutput::Frame> DeckLinkOutput::get_frame()
520 lock_guard<mutex> lock(frame_queue_mutex);
522 if (!frame_freelist.empty()) {
523 unique_ptr<Frame> frame = move(frame_freelist.front());
524 frame_freelist.pop();
528 unique_ptr<Frame> frame(new Frame);
531 if (global_flags.ten_bit_output) {
532 stride = v210Converter::get_v210_stride(width);
533 GLint v210_width = stride / sizeof(uint32_t);
534 frame->uyvy_tex = resource_pool->create_2d_texture(GL_RGB10_A2, v210_width, height);
536 // We need valid texture state, or NVIDIA won't allow us to write to the texture.
537 glBindTexture(GL_TEXTURE_2D, frame->uyvy_tex);
539 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
543 frame->uyvy_tex = resource_pool->create_2d_texture(GL_RGBA8, width / 2, height);
546 glGenBuffers(1, &frame->pbo);
548 glBindBuffer(GL_PIXEL_PACK_BUFFER, frame->pbo);
550 glBufferStorage(GL_PIXEL_PACK_BUFFER, stride * height, nullptr, GL_MAP_READ_BIT | GL_MAP_PERSISTENT_BIT);
552 frame->uyvy_ptr = (uint8_t *)glMapBufferRange(GL_PIXEL_PACK_BUFFER, 0, stride * height, GL_MAP_READ_BIT | GL_MAP_PERSISTENT_BIT);
554 frame->uyvy_ptr_local.reset(new uint8_t[stride * height]);
555 frame->resource_pool = resource_pool;
560 void DeckLinkOutput::present_thread_func()
562 pthread_setname_np(pthread_self(), "DeckLinkOutput");
564 unique_ptr<Frame> frame;
566 unique_lock<mutex> lock(frame_queue_mutex);
567 frame_queues_changed.wait(lock, [this]{
568 return should_quit.should_quit() || !pending_video_frames.empty();
570 if (should_quit.should_quit()) {
573 frame = move(pending_video_frames.front());
574 pending_video_frames.pop();
578 int err = glClientWaitSync(frame->fence.get(), /*flags=*/0, 0);
579 if (err == GL_TIMEOUT_EXPIRED) {
580 // NVIDIA likes to busy-wait; yield instead.
581 this_thread::sleep_for(milliseconds(1));
587 frame->fence.reset();
589 if (global_flags.ten_bit_output) {
590 memcpy(frame->uyvy_ptr_local.get(), frame->uyvy_ptr, v210Converter::get_v210_stride(width) * height);
592 memcpy(frame->uyvy_ptr_local.get(), frame->uyvy_ptr, width * height * 2);
595 // Release any input frames we needed to render this frame.
596 frame->input_frames.clear();
598 BMDTimeValue pts = frame->pts;
599 BMDTimeValue duration = frame->duration;
600 HRESULT res = output->ScheduleVideoFrame(frame.get(), pts, duration, TIMEBASE);
601 lock_guard<mutex> lock(frame_queue_mutex);
603 scheduled_frames.push_back(frame.release()); // Owned by the driver now.
604 ++metric_decklink_output_inflight_frames;
606 fprintf(stderr, "Could not schedule video frame! (error=0x%08x)\n", res);
608 frame_freelist.push(move(frame));
613 HRESULT STDMETHODCALLTYPE DeckLinkOutput::QueryInterface(REFIID, LPVOID *)
615 return E_NOINTERFACE;
618 ULONG STDMETHODCALLTYPE DeckLinkOutput::AddRef()
620 return refcount.fetch_add(1) + 1;
623 ULONG STDMETHODCALLTYPE DeckLinkOutput::Release()
625 int new_ref = refcount.fetch_sub(1) - 1;
631 DeckLinkOutput::Frame::~Frame()
633 glBindBuffer(GL_PIXEL_PACK_BUFFER, pbo);
635 glUnmapBuffer(GL_PIXEL_PACK_BUFFER);
637 glBindBuffer(GL_PIXEL_PACK_BUFFER, 0);
639 glDeleteBuffers(1, &pbo);
641 resource_pool->release_2d_texture(uyvy_tex);
645 HRESULT STDMETHODCALLTYPE DeckLinkOutput::Frame::QueryInterface(REFIID, LPVOID *)
647 return E_NOINTERFACE;
650 ULONG STDMETHODCALLTYPE DeckLinkOutput::Frame::AddRef()
652 return refcount.fetch_add(1) + 1;
655 ULONG STDMETHODCALLTYPE DeckLinkOutput::Frame::Release()
657 int new_ref = refcount.fetch_sub(1) - 1;
663 long DeckLinkOutput::Frame::GetWidth()
665 return global_flags.width;
668 long DeckLinkOutput::Frame::GetHeight()
670 return global_flags.height;
673 long DeckLinkOutput::Frame::GetRowBytes()
675 if (global_flags.ten_bit_output) {
676 return v210Converter::get_v210_stride(global_flags.width);
678 return global_flags.width * 2;
682 BMDPixelFormat DeckLinkOutput::Frame::GetPixelFormat()
684 if (global_flags.ten_bit_output) {
685 return bmdFormat10BitYUV;
687 return bmdFormat8BitYUV;
691 BMDFrameFlags DeckLinkOutput::Frame::GetFlags()
693 return bmdFrameFlagDefault;
696 HRESULT DeckLinkOutput::Frame::GetBytes(/* out */ void **buffer)
698 *buffer = uyvy_ptr_local.get();
702 HRESULT DeckLinkOutput::Frame::GetTimecode(/* in */ BMDTimecodeFormat format, /* out */ IDeckLinkTimecode **timecode)
704 fprintf(stderr, "STUB: GetTimecode()\n");
708 HRESULT DeckLinkOutput::Frame::GetAncillaryData(/* out */ IDeckLinkVideoFrameAncillary **ancillary)
710 fprintf(stderr, "STUB: GetAncillaryData()\n");