CuteLogger
Fast and simple logging solution for Qt based applications
moc_videowidget.cpp
1/****************************************************************************
2** Meta object code from reading C++ file 'videowidget.h'
3**
4** Created by: The Qt Meta Object Compiler version 69 (Qt 6.9.1)
5**
6** WARNING! All changes made in this file will be lost!
7*****************************************************************************/
8
9#include "../../../../src/videowidget.h"
10#include <QtCore/qmetatype.h>
11
12#include <QtCore/qtmochelpers.h>
13
14#include <memory>
15
16
17#include <QtCore/qxptype_traits.h>
18#if !defined(Q_MOC_OUTPUT_REVISION)
19#error "The header file 'videowidget.h' doesn't include <QObject>."
20#elif Q_MOC_OUTPUT_REVISION != 69
21#error "This file was generated using the moc from 6.9.1. It"
22#error "cannot be used with the include files from this version of Qt."
23#error "(The moc has changed too much.)"
24#endif
25
26#ifndef Q_CONSTINIT
27#define Q_CONSTINIT
28#endif
29
30QT_WARNING_PUSH
31QT_WARNING_DISABLE_DEPRECATED
32QT_WARNING_DISABLE_GCC("-Wuseless-cast")
33namespace {
34struct qt_meta_tag_ZN3Mlt11VideoWidgetE_t {};
35} // unnamed namespace
36
37template <> constexpr inline auto Mlt::VideoWidget::qt_create_metaobjectdata<qt_meta_tag_ZN3Mlt11VideoWidgetE_t>()
38{
39 namespace QMC = QtMocConstants;
40 QtMocHelpers::StringRefStorage qt_stringData {
41 "Mlt::VideoWidget",
42 "frameDisplayed",
43 "",
44 "SharedFrame",
45 "frame",
46 "dragStarted",
47 "seekTo",
48 "x",
49 "gpuNotSupported",
50 "started",
51 "paused",
52 "playing",
53 "rectChanged",
54 "gridChanged",
55 "zoomChanged",
56 "offsetChanged",
57 "offset",
58 "imageReady",
59 "snapToGridChanged",
60 "toggleZoom",
61 "setGrid",
62 "grid",
63 "setZoom",
64 "zoom",
65 "setOffsetX",
66 "setOffsetY",
67 "y",
68 "setBlankScene",
69 "setCurrentFilter",
70 "QmlFilter*",
71 "filter",
72 "QmlMetadata*",
73 "meta",
74 "setSnapToGrid",
75 "snap",
76 "initialize",
77 "beforeRendering",
78 "renderVideo",
79 "onFrameDisplayed",
80 "resizeVideo",
81 "width",
82 "height",
83 "onRefreshTimeout",
84 "rect",
85 "snapToGrid"
86 };
87
88 QtMocHelpers::UintData qt_methods {
89 // Signal 'frameDisplayed'
90 QtMocHelpers::SignalData<void(const SharedFrame &)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
91 { 0x80000000 | 3, 4 },
92 }}),
93 // Signal 'dragStarted'
94 QtMocHelpers::SignalData<void()>(5, 2, QMC::AccessPublic, QMetaType::Void),
95 // Signal 'seekTo'
96 QtMocHelpers::SignalData<void(int)>(6, 2, QMC::AccessPublic, QMetaType::Void, {{
97 { QMetaType::Int, 7 },
98 }}),
99 // Signal 'gpuNotSupported'
100 QtMocHelpers::SignalData<void()>(8, 2, QMC::AccessPublic, QMetaType::Void),
101 // Signal 'started'
102 QtMocHelpers::SignalData<void()>(9, 2, QMC::AccessPublic, QMetaType::Void),
103 // Signal 'paused'
104 QtMocHelpers::SignalData<void()>(10, 2, QMC::AccessPublic, QMetaType::Void),
105 // Signal 'playing'
106 QtMocHelpers::SignalData<void()>(11, 2, QMC::AccessPublic, QMetaType::Void),
107 // Signal 'rectChanged'
108 QtMocHelpers::SignalData<void()>(12, 2, QMC::AccessPublic, QMetaType::Void),
109 // Signal 'gridChanged'
110 QtMocHelpers::SignalData<void()>(13, 2, QMC::AccessPublic, QMetaType::Void),
111 // Signal 'zoomChanged'
112 QtMocHelpers::SignalData<void()>(14, 2, QMC::AccessPublic, QMetaType::Void),
113 // Signal 'offsetChanged'
114 QtMocHelpers::SignalData<void(const QPoint &)>(15, 2, QMC::AccessPublic, QMetaType::Void, {{
115 { QMetaType::QPoint, 16 },
116 }}),
117 // Signal 'offsetChanged'
118 QtMocHelpers::SignalData<void()>(15, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
119 // Signal 'imageReady'
120 QtMocHelpers::SignalData<void()>(17, 2, QMC::AccessPublic, QMetaType::Void),
121 // Signal 'snapToGridChanged'
122 QtMocHelpers::SignalData<void()>(18, 2, QMC::AccessPublic, QMetaType::Void),
123 // Signal 'toggleZoom'
124 QtMocHelpers::SignalData<void(bool)>(19, 2, QMC::AccessPublic, QMetaType::Void, {{
125 { QMetaType::Bool, 2 },
126 }}),
127 // Slot 'setGrid'
128 QtMocHelpers::SlotData<void(int)>(20, 2, QMC::AccessPublic, QMetaType::Void, {{
129 { QMetaType::Int, 21 },
130 }}),
131 // Slot 'setZoom'
132 QtMocHelpers::SlotData<void(float)>(22, 2, QMC::AccessPublic, QMetaType::Void, {{
133 { QMetaType::Float, 23 },
134 }}),
135 // Slot 'setOffsetX'
136 QtMocHelpers::SlotData<void(int)>(24, 2, QMC::AccessPublic, QMetaType::Void, {{
137 { QMetaType::Int, 7 },
138 }}),
139 // Slot 'setOffsetY'
140 QtMocHelpers::SlotData<void(int)>(25, 2, QMC::AccessPublic, QMetaType::Void, {{
141 { QMetaType::Int, 26 },
142 }}),
143 // Slot 'setBlankScene'
144 QtMocHelpers::SlotData<void()>(27, 2, QMC::AccessPublic, QMetaType::Void),
145 // Slot 'setCurrentFilter'
146 QtMocHelpers::SlotData<void(QmlFilter *, QmlMetadata *)>(28, 2, QMC::AccessPublic, QMetaType::Void, {{
147 { 0x80000000 | 29, 30 }, { 0x80000000 | 31, 32 },
148 }}),
149 // Slot 'setSnapToGrid'
150 QtMocHelpers::SlotData<void(bool)>(33, 2, QMC::AccessPublic, QMetaType::Void, {{
151 { QMetaType::Bool, 34 },
152 }}),
153 // Slot 'initialize'
154 QtMocHelpers::SlotData<void()>(35, 2, QMC::AccessPublic, QMetaType::Void),
155 // Slot 'beforeRendering'
156 QtMocHelpers::SlotData<void()>(36, 2, QMC::AccessPublic, QMetaType::Void),
157 // Slot 'renderVideo'
158 QtMocHelpers::SlotData<void()>(37, 2, QMC::AccessPublic, QMetaType::Void),
159 // Slot 'onFrameDisplayed'
160 QtMocHelpers::SlotData<void(const SharedFrame &)>(38, 2, QMC::AccessPublic, QMetaType::Void, {{
161 { 0x80000000 | 3, 4 },
162 }}),
163 // Slot 'resizeVideo'
164 QtMocHelpers::SlotData<void(int, int)>(39, 2, QMC::AccessPrivate, QMetaType::Void, {{
165 { QMetaType::Int, 40 }, { QMetaType::Int, 41 },
166 }}),
167 // Slot 'onRefreshTimeout'
168 QtMocHelpers::SlotData<void()>(42, 2, QMC::AccessPrivate, QMetaType::Void),
169 };
170 QtMocHelpers::UintData qt_properties {
171 // property 'rect'
172 QtMocHelpers::PropertyData<QRectF>(43, QMetaType::QRectF, QMC::DefaultPropertyFlags, 7),
173 // property 'grid'
174 QtMocHelpers::PropertyData<int>(21, QMetaType::Int, QMC::DefaultPropertyFlags, 8),
175 // property 'snapToGrid'
176 QtMocHelpers::PropertyData<bool>(44, QMetaType::Bool, QMC::DefaultPropertyFlags, 13),
177 // property 'zoom'
178 QtMocHelpers::PropertyData<float>(23, QMetaType::Float, QMC::DefaultPropertyFlags, 9),
179 // property 'offset'
180 QtMocHelpers::PropertyData<QPoint>(16, QMetaType::QPoint, QMC::DefaultPropertyFlags, 10),
181 };
182 QtMocHelpers::UintData qt_enums {
183 };
184 return QtMocHelpers::metaObjectData<VideoWidget, qt_meta_tag_ZN3Mlt11VideoWidgetE_t>(QMC::MetaObjectFlag{}, qt_stringData,
185 qt_methods, qt_properties, qt_enums);
186}
187Q_CONSTINIT const QMetaObject Mlt::VideoWidget::staticMetaObject = { {
188 QMetaObject::SuperData::link<QQuickWidget::staticMetaObject>(),
189 qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3Mlt11VideoWidgetE_t>.stringdata,
190 qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3Mlt11VideoWidgetE_t>.data,
191 qt_static_metacall,
192 nullptr,
193 qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3Mlt11VideoWidgetE_t>.metaTypes,
194 nullptr
195} };
196
197void Mlt::VideoWidget::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
198{
199 auto *_t = static_cast<VideoWidget *>(_o);
200 if (_c == QMetaObject::InvokeMetaMethod) {
201 switch (_id) {
202 case 0: _t->frameDisplayed((*reinterpret_cast< std::add_pointer_t<SharedFrame>>(_a[1]))); break;
203 case 1: _t->dragStarted(); break;
204 case 2: _t->seekTo((*reinterpret_cast< std::add_pointer_t<int>>(_a[1]))); break;
205 case 3: _t->gpuNotSupported(); break;
206 case 4: _t->started(); break;
207 case 5: _t->paused(); break;
208 case 6: _t->playing(); break;
209 case 7: _t->rectChanged(); break;
210 case 8: _t->gridChanged(); break;
211 case 9: _t->zoomChanged(); break;
212 case 10: _t->offsetChanged((*reinterpret_cast< std::add_pointer_t<QPoint>>(_a[1]))); break;
213 case 11: _t->offsetChanged(); break;
214 case 12: _t->imageReady(); break;
215 case 13: _t->snapToGridChanged(); break;
216 case 14: _t->toggleZoom((*reinterpret_cast< std::add_pointer_t<bool>>(_a[1]))); break;
217 case 15: _t->setGrid((*reinterpret_cast< std::add_pointer_t<int>>(_a[1]))); break;
218 case 16: _t->setZoom((*reinterpret_cast< std::add_pointer_t<float>>(_a[1]))); break;
219 case 17: _t->setOffsetX((*reinterpret_cast< std::add_pointer_t<int>>(_a[1]))); break;
220 case 18: _t->setOffsetY((*reinterpret_cast< std::add_pointer_t<int>>(_a[1]))); break;
221 case 19: _t->setBlankScene(); break;
222 case 20: _t->setCurrentFilter((*reinterpret_cast< std::add_pointer_t<QmlFilter*>>(_a[1])),(*reinterpret_cast< std::add_pointer_t<QmlMetadata*>>(_a[2]))); break;
223 case 21: _t->setSnapToGrid((*reinterpret_cast< std::add_pointer_t<bool>>(_a[1]))); break;
224 case 22: _t->initialize(); break;
225 case 23: _t->beforeRendering(); break;
226 case 24: _t->renderVideo(); break;
227 case 25: _t->onFrameDisplayed((*reinterpret_cast< std::add_pointer_t<SharedFrame>>(_a[1]))); break;
228 case 26: _t->resizeVideo((*reinterpret_cast< std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast< std::add_pointer_t<int>>(_a[2]))); break;
229 case 27: _t->onRefreshTimeout(); break;
230 default: ;
231 }
232 }
233 if (_c == QMetaObject::IndexOfMethod) {
234 if (QtMocHelpers::indexOfMethod<void (VideoWidget::*)(const SharedFrame & )>(_a, &VideoWidget::frameDisplayed, 0))
235 return;
236 if (QtMocHelpers::indexOfMethod<void (VideoWidget::*)()>(_a, &VideoWidget::dragStarted, 1))
237 return;
238 if (QtMocHelpers::indexOfMethod<void (VideoWidget::*)(int )>(_a, &VideoWidget::seekTo, 2))
239 return;
240 if (QtMocHelpers::indexOfMethod<void (VideoWidget::*)()>(_a, &VideoWidget::gpuNotSupported, 3))
241 return;
242 if (QtMocHelpers::indexOfMethod<void (VideoWidget::*)()>(_a, &VideoWidget::started, 4))
243 return;
244 if (QtMocHelpers::indexOfMethod<void (VideoWidget::*)()>(_a, &VideoWidget::paused, 5))
245 return;
246 if (QtMocHelpers::indexOfMethod<void (VideoWidget::*)()>(_a, &VideoWidget::playing, 6))
247 return;
248 if (QtMocHelpers::indexOfMethod<void (VideoWidget::*)()>(_a, &VideoWidget::rectChanged, 7))
249 return;
250 if (QtMocHelpers::indexOfMethod<void (VideoWidget::*)()>(_a, &VideoWidget::gridChanged, 8))
251 return;
252 if (QtMocHelpers::indexOfMethod<void (VideoWidget::*)()>(_a, &VideoWidget::zoomChanged, 9))
253 return;
254 if (QtMocHelpers::indexOfMethod<void (VideoWidget::*)(const QPoint & )>(_a, &VideoWidget::offsetChanged, 10))
255 return;
256 if (QtMocHelpers::indexOfMethod<void (VideoWidget::*)()>(_a, &VideoWidget::imageReady, 12))
257 return;
258 if (QtMocHelpers::indexOfMethod<void (VideoWidget::*)()>(_a, &VideoWidget::snapToGridChanged, 13))
259 return;
260 if (QtMocHelpers::indexOfMethod<void (VideoWidget::*)(bool )>(_a, &VideoWidget::toggleZoom, 14))
261 return;
262 }
263 if (_c == QMetaObject::ReadProperty) {
264 void *_v = _a[0];
265 switch (_id) {
266 case 0: *reinterpret_cast<QRectF*>(_v) = _t->rect(); break;
267 case 1: *reinterpret_cast<int*>(_v) = _t->grid(); break;
268 case 2: *reinterpret_cast<bool*>(_v) = _t->snapToGrid(); break;
269 case 3: *reinterpret_cast<float*>(_v) = _t->zoom(); break;
270 case 4: *reinterpret_cast<QPoint*>(_v) = _t->offset(); break;
271 default: break;
272 }
273 }
274}
275
276const QMetaObject *Mlt::VideoWidget::metaObject() const
277{
278 return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
279}
280
281void *Mlt::VideoWidget::qt_metacast(const char *_clname)
282{
283 if (!_clname) return nullptr;
284 if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3Mlt11VideoWidgetE_t>.strings))
285 return static_cast<void*>(this);
286 if (!strcmp(_clname, "Controller"))
287 return static_cast< Controller*>(this);
288 return QQuickWidget::qt_metacast(_clname);
289}
290
291int Mlt::VideoWidget::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
292{
293 _id = QQuickWidget::qt_metacall(_c, _id, _a);
294 if (_id < 0)
295 return _id;
296 if (_c == QMetaObject::InvokeMetaMethod) {
297 if (_id < 28)
298 qt_static_metacall(this, _c, _id, _a);
299 _id -= 28;
300 }
301 if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
302 if (_id < 28)
303 *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
304 _id -= 28;
305 }
306 if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
307 || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
308 || _c == QMetaObject::RegisterPropertyMetaType) {
309 qt_static_metacall(this, _c, _id, _a);
310 _id -= 5;
311 }
312 return _id;
313}
314
315// SIGNAL 0
316void Mlt::VideoWidget::frameDisplayed(const SharedFrame & _t1)
317{
318 QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1);
319}
320
321// SIGNAL 1
322void Mlt::VideoWidget::dragStarted()
323{
324 QMetaObject::activate(this, &staticMetaObject, 1, nullptr);
325}
326
327// SIGNAL 2
328void Mlt::VideoWidget::seekTo(int _t1)
329{
330 QMetaObject::activate<void>(this, &staticMetaObject, 2, nullptr, _t1);
331}
332
333// SIGNAL 3
334void Mlt::VideoWidget::gpuNotSupported()
335{
336 QMetaObject::activate(this, &staticMetaObject, 3, nullptr);
337}
338
339// SIGNAL 4
340void Mlt::VideoWidget::started()
341{
342 QMetaObject::activate(this, &staticMetaObject, 4, nullptr);
343}
344
345// SIGNAL 5
346void Mlt::VideoWidget::paused()
347{
348 QMetaObject::activate(this, &staticMetaObject, 5, nullptr);
349}
350
351// SIGNAL 6
352void Mlt::VideoWidget::playing()
353{
354 QMetaObject::activate(this, &staticMetaObject, 6, nullptr);
355}
356
357// SIGNAL 7
358void Mlt::VideoWidget::rectChanged()
359{
360 QMetaObject::activate(this, &staticMetaObject, 7, nullptr);
361}
362
363// SIGNAL 8
364void Mlt::VideoWidget::gridChanged()
365{
366 QMetaObject::activate(this, &staticMetaObject, 8, nullptr);
367}
368
369// SIGNAL 9
370void Mlt::VideoWidget::zoomChanged()
371{
372 QMetaObject::activate(this, &staticMetaObject, 9, nullptr);
373}
374
375// SIGNAL 10
376void Mlt::VideoWidget::offsetChanged(const QPoint & _t1)
377{
378 QMetaObject::activate<void>(this, &staticMetaObject, 10, nullptr, _t1);
379}
380
381// SIGNAL 12
382void Mlt::VideoWidget::imageReady()
383{
384 QMetaObject::activate(this, &staticMetaObject, 12, nullptr);
385}
386
387// SIGNAL 13
388void Mlt::VideoWidget::snapToGridChanged()
389{
390 QMetaObject::activate(this, &staticMetaObject, 13, nullptr);
391}
392
393// SIGNAL 14
394void Mlt::VideoWidget::toggleZoom(bool _t1)
395{
396 QMetaObject::activate<void>(this, &staticMetaObject, 14, nullptr, _t1);
397}
398namespace {
399struct qt_meta_tag_ZN3Mlt12RenderThreadE_t {};
400} // unnamed namespace
401
402template <> constexpr inline auto Mlt::RenderThread::qt_create_metaobjectdata<qt_meta_tag_ZN3Mlt12RenderThreadE_t>()
403{
404 namespace QMC = QtMocConstants;
405 QtMocHelpers::StringRefStorage qt_stringData {
406 "Mlt::RenderThread"
407 };
408
409 QtMocHelpers::UintData qt_methods {
410 };
411 QtMocHelpers::UintData qt_properties {
412 };
413 QtMocHelpers::UintData qt_enums {
414 };
415 return QtMocHelpers::metaObjectData<RenderThread, qt_meta_tag_ZN3Mlt12RenderThreadE_t>(QMC::MetaObjectFlag{}, qt_stringData,
416 qt_methods, qt_properties, qt_enums);
417}
418Q_CONSTINIT const QMetaObject Mlt::RenderThread::staticMetaObject = { {
419 QMetaObject::SuperData::link<QThread::staticMetaObject>(),
420 qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3Mlt12RenderThreadE_t>.stringdata,
421 qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3Mlt12RenderThreadE_t>.data,
422 qt_static_metacall,
423 nullptr,
424 qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3Mlt12RenderThreadE_t>.metaTypes,
425 nullptr
426} };
427
428void Mlt::RenderThread::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
429{
430 auto *_t = static_cast<RenderThread *>(_o);
431 (void)_t;
432 (void)_c;
433 (void)_id;
434 (void)_a;
435}
436
437const QMetaObject *Mlt::RenderThread::metaObject() const
438{
439 return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
440}
441
442void *Mlt::RenderThread::qt_metacast(const char *_clname)
443{
444 if (!_clname) return nullptr;
445 if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3Mlt12RenderThreadE_t>.strings))
446 return static_cast<void*>(this);
447 return QThread::qt_metacast(_clname);
448}
449
450int Mlt::RenderThread::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
451{
452 _id = QThread::qt_metacall(_c, _id, _a);
453 return _id;
454}
455namespace {
456struct qt_meta_tag_ZN3Mlt13FrameRendererE_t {};
457} // unnamed namespace
458
459template <> constexpr inline auto Mlt::FrameRenderer::qt_create_metaobjectdata<qt_meta_tag_ZN3Mlt13FrameRendererE_t>()
460{
461 namespace QMC = QtMocConstants;
462 QtMocHelpers::StringRefStorage qt_stringData {
463 "Mlt::FrameRenderer",
464 "frameDisplayed",
465 "",
466 "SharedFrame",
467 "frame",
468 "imageReady",
469 "showFrame",
470 "Mlt::Frame"
471 };
472
473 QtMocHelpers::UintData qt_methods {
474 // Signal 'frameDisplayed'
475 QtMocHelpers::SignalData<void(const SharedFrame &)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
476 { 0x80000000 | 3, 4 },
477 }}),
478 // Signal 'imageReady'
479 QtMocHelpers::SignalData<void()>(5, 2, QMC::AccessPublic, QMetaType::Void),
480 // Method 'showFrame'
481 QtMocHelpers::MethodData<void(Mlt::Frame)>(6, 2, QMC::AccessPublic, QMetaType::Void, {{
482 { 0x80000000 | 7, 4 },
483 }}),
484 };
485 QtMocHelpers::UintData qt_properties {
486 };
487 QtMocHelpers::UintData qt_enums {
488 };
489 return QtMocHelpers::metaObjectData<FrameRenderer, qt_meta_tag_ZN3Mlt13FrameRendererE_t>(QMC::MetaObjectFlag{}, qt_stringData,
490 qt_methods, qt_properties, qt_enums);
491}
492Q_CONSTINIT const QMetaObject Mlt::FrameRenderer::staticMetaObject = { {
493 QMetaObject::SuperData::link<QThread::staticMetaObject>(),
494 qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3Mlt13FrameRendererE_t>.stringdata,
495 qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3Mlt13FrameRendererE_t>.data,
496 qt_static_metacall,
497 nullptr,
498 qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3Mlt13FrameRendererE_t>.metaTypes,
499 nullptr
500} };
501
502void Mlt::FrameRenderer::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
503{
504 auto *_t = static_cast<FrameRenderer *>(_o);
505 if (_c == QMetaObject::InvokeMetaMethod) {
506 switch (_id) {
507 case 0: _t->frameDisplayed((*reinterpret_cast< std::add_pointer_t<SharedFrame>>(_a[1]))); break;
508 case 1: _t->imageReady(); break;
509 case 2: _t->showFrame((*reinterpret_cast< std::add_pointer_t<Mlt::Frame>>(_a[1]))); break;
510 default: ;
511 }
512 }
513 if (_c == QMetaObject::IndexOfMethod) {
514 if (QtMocHelpers::indexOfMethod<void (FrameRenderer::*)(const SharedFrame & )>(_a, &FrameRenderer::frameDisplayed, 0))
515 return;
516 if (QtMocHelpers::indexOfMethod<void (FrameRenderer::*)()>(_a, &FrameRenderer::imageReady, 1))
517 return;
518 }
519}
520
521const QMetaObject *Mlt::FrameRenderer::metaObject() const
522{
523 return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
524}
525
526void *Mlt::FrameRenderer::qt_metacast(const char *_clname)
527{
528 if (!_clname) return nullptr;
529 if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3Mlt13FrameRendererE_t>.strings))
530 return static_cast<void*>(this);
531 return QThread::qt_metacast(_clname);
532}
533
534int Mlt::FrameRenderer::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
535{
536 _id = QThread::qt_metacall(_c, _id, _a);
537 if (_id < 0)
538 return _id;
539 if (_c == QMetaObject::InvokeMetaMethod) {
540 if (_id < 3)
541 qt_static_metacall(this, _c, _id, _a);
542 _id -= 3;
543 }
544 if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
545 if (_id < 3)
546 *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
547 _id -= 3;
548 }
549 return _id;
550}
551
552// SIGNAL 0
553void Mlt::FrameRenderer::frameDisplayed(const SharedFrame & _t1)
554{
555 QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1);
556}
557
558// SIGNAL 1
559void Mlt::FrameRenderer::imageReady()
560{
561 QMetaObject::activate(this, &staticMetaObject, 1, nullptr);
562}
563QT_WARNING_POP