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.10.3)
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.10.3. 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 "QPoint",
58 "offset",
59 "imageReady",
60 "snapToGridChanged",
61 "toggleZoom",
62 "stepZoom",
63 "videoFrameReady",
64 "QVideoFrame",
65 "hdrTransferChanged",
66 "HdrTransfer",
67 "transfer",
68 "setGrid",
69 "grid",
70 "setZoom",
71 "zoom",
72 "setOffsetX",
73 "setOffsetY",
74 "y",
75 "setBlankScene",
76 "setCurrentFilter",
77 "QmlFilter*",
78 "filter",
79 "QmlMetadata*",
80 "meta",
81 "setSnapToGrid",
82 "snap",
83 "initialize",
84 "beforeRendering",
85 "renderVideo",
86 "onFrameDisplayed",
87 "showFrame",
88 "Mlt::Frame",
89 "p016Buffer",
90 "resizeVideo",
91 "width",
92 "height",
93 "onRefreshTimeout",
94 "setVideoSink",
95 "QVideoSink*",
96 "sink",
97 "rect",
98 "QRectF",
99 "snapToGrid",
100 "oldVideoOutput"
101 };
102
103 QtMocHelpers::UintData qt_methods {
104 // Signal 'frameDisplayed'
105 QtMocHelpers::SignalData<void(const SharedFrame &)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
106 { 0x80000000 | 3, 4 },
107 }}),
108 // Signal 'dragStarted'
109 QtMocHelpers::SignalData<void()>(5, 2, QMC::AccessPublic, QMetaType::Void),
110 // Signal 'seekTo'
111 QtMocHelpers::SignalData<void(int)>(6, 2, QMC::AccessPublic, QMetaType::Void, {{
112 { QMetaType::Int, 7 },
113 }}),
114 // Signal 'gpuNotSupported'
115 QtMocHelpers::SignalData<void()>(8, 2, QMC::AccessPublic, QMetaType::Void),
116 // Signal 'started'
117 QtMocHelpers::SignalData<void()>(9, 2, QMC::AccessPublic, QMetaType::Void),
118 // Signal 'paused'
119 QtMocHelpers::SignalData<void()>(10, 2, QMC::AccessPublic, QMetaType::Void),
120 // Signal 'playing'
121 QtMocHelpers::SignalData<void()>(11, 2, QMC::AccessPublic, QMetaType::Void),
122 // Signal 'rectChanged'
123 QtMocHelpers::SignalData<void()>(12, 2, QMC::AccessPublic, QMetaType::Void),
124 // Signal 'gridChanged'
125 QtMocHelpers::SignalData<void()>(13, 2, QMC::AccessPublic, QMetaType::Void),
126 // Signal 'zoomChanged'
127 QtMocHelpers::SignalData<void()>(14, 2, QMC::AccessPublic, QMetaType::Void),
128 // Signal 'offsetChanged'
129 QtMocHelpers::SignalData<void(const QPoint &)>(15, 2, QMC::AccessPublic, QMetaType::Void, {{
130 { 0x80000000 | 16, 17 },
131 }}),
132 // Signal 'offsetChanged'
133 QtMocHelpers::SignalData<void()>(15, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
134 // Signal 'imageReady'
135 QtMocHelpers::SignalData<void()>(18, 2, QMC::AccessPublic, QMetaType::Void),
136 // Signal 'snapToGridChanged'
137 QtMocHelpers::SignalData<void()>(19, 2, QMC::AccessPublic, QMetaType::Void),
138 // Signal 'toggleZoom'
139 QtMocHelpers::SignalData<void(bool)>(20, 2, QMC::AccessPublic, QMetaType::Void, {{
140 { QMetaType::Bool, 2 },
141 }}),
142 // Signal 'stepZoom'
143 QtMocHelpers::SignalData<void(float, float)>(21, 2, QMC::AccessPublic, QMetaType::Void, {{
144 { QMetaType::Float, 2 }, { QMetaType::Float, 2 },
145 }}),
146 // Signal 'videoFrameReady'
147 QtMocHelpers::SignalData<void(const QVideoFrame &)>(22, 2, QMC::AccessPublic, QMetaType::Void, {{
148 { 0x80000000 | 23, 4 },
149 }}),
150 // Signal 'hdrTransferChanged'
151 QtMocHelpers::SignalData<void(HdrTransfer)>(24, 2, QMC::AccessPublic, QMetaType::Void, {{
152 { 0x80000000 | 25, 26 },
153 }}),
154 // Slot 'setGrid'
155 QtMocHelpers::SlotData<void(int)>(27, 2, QMC::AccessPublic, QMetaType::Void, {{
156 { QMetaType::Int, 28 },
157 }}),
158 // Slot 'setZoom'
159 QtMocHelpers::SlotData<void(float)>(29, 2, QMC::AccessPublic, QMetaType::Void, {{
160 { QMetaType::Float, 30 },
161 }}),
162 // Slot 'setOffsetX'
163 QtMocHelpers::SlotData<void(int)>(31, 2, QMC::AccessPublic, QMetaType::Void, {{
164 { QMetaType::Int, 7 },
165 }}),
166 // Slot 'setOffsetY'
167 QtMocHelpers::SlotData<void(int)>(32, 2, QMC::AccessPublic, QMetaType::Void, {{
168 { QMetaType::Int, 33 },
169 }}),
170 // Slot 'setBlankScene'
171 QtMocHelpers::SlotData<void()>(34, 2, QMC::AccessPublic, QMetaType::Void),
172 // Slot 'setCurrentFilter'
173 QtMocHelpers::SlotData<void(QmlFilter *, QmlMetadata *)>(35, 2, QMC::AccessPublic, QMetaType::Void, {{
174 { 0x80000000 | 36, 37 }, { 0x80000000 | 38, 39 },
175 }}),
176 // Slot 'setSnapToGrid'
177 QtMocHelpers::SlotData<void(bool)>(40, 2, QMC::AccessPublic, QMetaType::Void, {{
178 { QMetaType::Bool, 41 },
179 }}),
180 // Slot 'initialize'
181 QtMocHelpers::SlotData<void()>(42, 2, QMC::AccessPublic, QMetaType::Void),
182 // Slot 'beforeRendering'
183 QtMocHelpers::SlotData<void()>(43, 2, QMC::AccessPublic, QMetaType::Void),
184 // Slot 'renderVideo'
185 QtMocHelpers::SlotData<void()>(44, 2, QMC::AccessPublic, QMetaType::Void),
186 // Slot 'onFrameDisplayed'
187 QtMocHelpers::SlotData<void(const SharedFrame &)>(45, 2, QMC::AccessPublic, QMetaType::Void, {{
188 { 0x80000000 | 3, 4 },
189 }}),
190 // Slot 'showFrame'
191 QtMocHelpers::SlotData<void(Mlt::Frame, QByteArray)>(46, 2, QMC::AccessPublic, QMetaType::Void, {{
192 { 0x80000000 | 47, 4 }, { QMetaType::QByteArray, 48 },
193 }}),
194 // Slot 'showFrame'
195 QtMocHelpers::SlotData<void(Mlt::Frame)>(46, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
196 { 0x80000000 | 47, 4 },
197 }}),
198 // Slot 'resizeVideo'
199 QtMocHelpers::SlotData<void(int, int)>(49, 2, QMC::AccessPrivate, QMetaType::Void, {{
200 { QMetaType::Int, 50 }, { QMetaType::Int, 51 },
201 }}),
202 // Slot 'onRefreshTimeout'
203 QtMocHelpers::SlotData<void()>(52, 2, QMC::AccessPrivate, QMetaType::Void),
204 // Method 'setVideoSink'
205 QtMocHelpers::MethodData<void(QVideoSink *)>(53, 2, QMC::AccessPublic, QMetaType::Void, {{
206 { 0x80000000 | 54, 55 },
207 }}),
208 };
209 QtMocHelpers::UintData qt_properties {
210 // property 'rect'
211 QtMocHelpers::PropertyData<QRectF>(56, 0x80000000 | 57, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 7),
212 // property 'grid'
213 QtMocHelpers::PropertyData<int>(28, QMetaType::Int, QMC::DefaultPropertyFlags, 8),
214 // property 'snapToGrid'
215 QtMocHelpers::PropertyData<bool>(58, QMetaType::Bool, QMC::DefaultPropertyFlags, 13),
216 // property 'zoom'
217 QtMocHelpers::PropertyData<float>(30, QMetaType::Float, QMC::DefaultPropertyFlags, 9),
218 // property 'offset'
219 QtMocHelpers::PropertyData<QPoint>(17, 0x80000000 | 16, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 10),
220 // property 'oldVideoOutput'
221 QtMocHelpers::PropertyData<bool>(59, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
222 };
223 QtMocHelpers::UintData qt_enums {
224 };
225 return QtMocHelpers::metaObjectData<VideoWidget, qt_meta_tag_ZN3Mlt11VideoWidgetE_t>(QMC::MetaObjectFlag{}, qt_stringData,
226 qt_methods, qt_properties, qt_enums);
227}
228Q_CONSTINIT const QMetaObject Mlt::VideoWidget::staticMetaObject = { {
229 QMetaObject::SuperData::link<QQuickWidget::staticMetaObject>(),
230 qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3Mlt11VideoWidgetE_t>.stringdata,
231 qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3Mlt11VideoWidgetE_t>.data,
232 qt_static_metacall,
233 nullptr,
234 qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3Mlt11VideoWidgetE_t>.metaTypes,
235 nullptr
236} };
237
238void Mlt::VideoWidget::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
239{
240 auto *_t = static_cast<VideoWidget *>(_o);
241 if (_c == QMetaObject::InvokeMetaMethod) {
242 switch (_id) {
243 case 0: _t->frameDisplayed((*reinterpret_cast<std::add_pointer_t<SharedFrame>>(_a[1]))); break;
244 case 1: _t->dragStarted(); break;
245 case 2: _t->seekTo((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
246 case 3: _t->gpuNotSupported(); break;
247 case 4: _t->started(); break;
248 case 5: _t->paused(); break;
249 case 6: _t->playing(); break;
250 case 7: _t->rectChanged(); break;
251 case 8: _t->gridChanged(); break;
252 case 9: _t->zoomChanged(); break;
253 case 10: _t->offsetChanged((*reinterpret_cast<std::add_pointer_t<QPoint>>(_a[1]))); break;
254 case 11: _t->offsetChanged(); break;
255 case 12: _t->imageReady(); break;
256 case 13: _t->snapToGridChanged(); break;
257 case 14: _t->toggleZoom((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
258 case 15: _t->stepZoom((*reinterpret_cast<std::add_pointer_t<float>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<float>>(_a[2]))); break;
259 case 16: _t->videoFrameReady((*reinterpret_cast<std::add_pointer_t<QVideoFrame>>(_a[1]))); break;
260 case 17: _t->hdrTransferChanged((*reinterpret_cast<std::add_pointer_t<HdrTransfer>>(_a[1]))); break;
261 case 18: _t->setGrid((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
262 case 19: _t->setZoom((*reinterpret_cast<std::add_pointer_t<float>>(_a[1]))); break;
263 case 20: _t->setOffsetX((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
264 case 21: _t->setOffsetY((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
265 case 22: _t->setBlankScene(); break;
266 case 23: _t->setCurrentFilter((*reinterpret_cast<std::add_pointer_t<QmlFilter*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QmlMetadata*>>(_a[2]))); break;
267 case 24: _t->setSnapToGrid((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
268 case 25: _t->initialize(); break;
269 case 26: _t->beforeRendering(); break;
270 case 27: _t->renderVideo(); break;
271 case 28: _t->onFrameDisplayed((*reinterpret_cast<std::add_pointer_t<SharedFrame>>(_a[1]))); break;
272 case 29: _t->showFrame((*reinterpret_cast<std::add_pointer_t<Mlt::Frame>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[2]))); break;
273 case 30: _t->showFrame((*reinterpret_cast<std::add_pointer_t<Mlt::Frame>>(_a[1]))); break;
274 case 31: _t->resizeVideo((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
275 case 32: _t->onRefreshTimeout(); break;
276 case 33: _t->setVideoSink((*reinterpret_cast<std::add_pointer_t<QVideoSink*>>(_a[1]))); break;
277 default: ;
278 }
279 }
280 if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
281 switch (_id) {
282 default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
283 case 16:
284 switch (*reinterpret_cast<int*>(_a[1])) {
285 default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
286 case 0:
287 *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QVideoFrame >(); break;
288 }
289 break;
290 case 33:
291 switch (*reinterpret_cast<int*>(_a[1])) {
292 default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
293 case 0:
294 *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QVideoSink* >(); break;
295 }
296 break;
297 }
298 }
299 if (_c == QMetaObject::IndexOfMethod) {
300 if (QtMocHelpers::indexOfMethod<void (VideoWidget::*)(const SharedFrame & )>(_a, &VideoWidget::frameDisplayed, 0))
301 return;
302 if (QtMocHelpers::indexOfMethod<void (VideoWidget::*)()>(_a, &VideoWidget::dragStarted, 1))
303 return;
304 if (QtMocHelpers::indexOfMethod<void (VideoWidget::*)(int )>(_a, &VideoWidget::seekTo, 2))
305 return;
306 if (QtMocHelpers::indexOfMethod<void (VideoWidget::*)()>(_a, &VideoWidget::gpuNotSupported, 3))
307 return;
308 if (QtMocHelpers::indexOfMethod<void (VideoWidget::*)()>(_a, &VideoWidget::started, 4))
309 return;
310 if (QtMocHelpers::indexOfMethod<void (VideoWidget::*)()>(_a, &VideoWidget::paused, 5))
311 return;
312 if (QtMocHelpers::indexOfMethod<void (VideoWidget::*)()>(_a, &VideoWidget::playing, 6))
313 return;
314 if (QtMocHelpers::indexOfMethod<void (VideoWidget::*)()>(_a, &VideoWidget::rectChanged, 7))
315 return;
316 if (QtMocHelpers::indexOfMethod<void (VideoWidget::*)()>(_a, &VideoWidget::gridChanged, 8))
317 return;
318 if (QtMocHelpers::indexOfMethod<void (VideoWidget::*)()>(_a, &VideoWidget::zoomChanged, 9))
319 return;
320 if (QtMocHelpers::indexOfMethod<void (VideoWidget::*)(const QPoint & )>(_a, &VideoWidget::offsetChanged, 10))
321 return;
322 if (QtMocHelpers::indexOfMethod<void (VideoWidget::*)()>(_a, &VideoWidget::imageReady, 12))
323 return;
324 if (QtMocHelpers::indexOfMethod<void (VideoWidget::*)()>(_a, &VideoWidget::snapToGridChanged, 13))
325 return;
326 if (QtMocHelpers::indexOfMethod<void (VideoWidget::*)(bool )>(_a, &VideoWidget::toggleZoom, 14))
327 return;
328 if (QtMocHelpers::indexOfMethod<void (VideoWidget::*)(float , float )>(_a, &VideoWidget::stepZoom, 15))
329 return;
330 if (QtMocHelpers::indexOfMethod<void (VideoWidget::*)(const QVideoFrame & )>(_a, &VideoWidget::videoFrameReady, 16))
331 return;
332 if (QtMocHelpers::indexOfMethod<void (VideoWidget::*)(HdrTransfer )>(_a, &VideoWidget::hdrTransferChanged, 17))
333 return;
334 }
335 if (_c == QMetaObject::ReadProperty) {
336 void *_v = _a[0];
337 switch (_id) {
338 case 0: *reinterpret_cast<QRectF*>(_v) = _t->rect(); break;
339 case 1: *reinterpret_cast<int*>(_v) = _t->grid(); break;
340 case 2: *reinterpret_cast<bool*>(_v) = _t->snapToGrid(); break;
341 case 3: *reinterpret_cast<float*>(_v) = _t->zoom(); break;
342 case 4: *reinterpret_cast<QPoint*>(_v) = _t->offset(); break;
343 case 5: *reinterpret_cast<bool*>(_v) = _t->oldVideoOutput(); break;
344 default: break;
345 }
346 }
347}
348
349const QMetaObject *Mlt::VideoWidget::metaObject() const
350{
351 return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
352}
353
354void *Mlt::VideoWidget::qt_metacast(const char *_clname)
355{
356 if (!_clname) return nullptr;
357 if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3Mlt11VideoWidgetE_t>.strings))
358 return static_cast<void*>(this);
359 if (!strcmp(_clname, "Controller"))
360 return static_cast< Controller*>(this);
361 return QQuickWidget::qt_metacast(_clname);
362}
363
364int Mlt::VideoWidget::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
365{
366 _id = QQuickWidget::qt_metacall(_c, _id, _a);
367 if (_id < 0)
368 return _id;
369 if (_c == QMetaObject::InvokeMetaMethod) {
370 if (_id < 34)
371 qt_static_metacall(this, _c, _id, _a);
372 _id -= 34;
373 }
374 if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
375 if (_id < 34)
376 qt_static_metacall(this, _c, _id, _a);
377 _id -= 34;
378 }
379 if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
380 || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
381 || _c == QMetaObject::RegisterPropertyMetaType) {
382 qt_static_metacall(this, _c, _id, _a);
383 _id -= 6;
384 }
385 return _id;
386}
387
388// SIGNAL 0
389void Mlt::VideoWidget::frameDisplayed(const SharedFrame & _t1)
390{
391 QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1);
392}
393
394// SIGNAL 1
395void Mlt::VideoWidget::dragStarted()
396{
397 QMetaObject::activate(this, &staticMetaObject, 1, nullptr);
398}
399
400// SIGNAL 2
401void Mlt::VideoWidget::seekTo(int _t1)
402{
403 QMetaObject::activate<void>(this, &staticMetaObject, 2, nullptr, _t1);
404}
405
406// SIGNAL 3
407void Mlt::VideoWidget::gpuNotSupported()
408{
409 QMetaObject::activate(this, &staticMetaObject, 3, nullptr);
410}
411
412// SIGNAL 4
413void Mlt::VideoWidget::started()
414{
415 QMetaObject::activate(this, &staticMetaObject, 4, nullptr);
416}
417
418// SIGNAL 5
419void Mlt::VideoWidget::paused()
420{
421 QMetaObject::activate(this, &staticMetaObject, 5, nullptr);
422}
423
424// SIGNAL 6
425void Mlt::VideoWidget::playing()
426{
427 QMetaObject::activate(this, &staticMetaObject, 6, nullptr);
428}
429
430// SIGNAL 7
431void Mlt::VideoWidget::rectChanged()
432{
433 QMetaObject::activate(this, &staticMetaObject, 7, nullptr);
434}
435
436// SIGNAL 8
437void Mlt::VideoWidget::gridChanged()
438{
439 QMetaObject::activate(this, &staticMetaObject, 8, nullptr);
440}
441
442// SIGNAL 9
443void Mlt::VideoWidget::zoomChanged()
444{
445 QMetaObject::activate(this, &staticMetaObject, 9, nullptr);
446}
447
448// SIGNAL 10
449void Mlt::VideoWidget::offsetChanged(const QPoint & _t1)
450{
451 QMetaObject::activate<void>(this, &staticMetaObject, 10, nullptr, _t1);
452}
453
454// SIGNAL 12
455void Mlt::VideoWidget::imageReady()
456{
457 QMetaObject::activate(this, &staticMetaObject, 12, nullptr);
458}
459
460// SIGNAL 13
461void Mlt::VideoWidget::snapToGridChanged()
462{
463 QMetaObject::activate(this, &staticMetaObject, 13, nullptr);
464}
465
466// SIGNAL 14
467void Mlt::VideoWidget::toggleZoom(bool _t1)
468{
469 QMetaObject::activate<void>(this, &staticMetaObject, 14, nullptr, _t1);
470}
471
472// SIGNAL 15
473void Mlt::VideoWidget::stepZoom(float _t1, float _t2)
474{
475 QMetaObject::activate<void>(this, &staticMetaObject, 15, nullptr, _t1, _t2);
476}
477
478// SIGNAL 16
479void Mlt::VideoWidget::videoFrameReady(const QVideoFrame & _t1)
480{
481 QMetaObject::activate<void>(this, &staticMetaObject, 16, nullptr, _t1);
482}
483
484// SIGNAL 17
485void Mlt::VideoWidget::hdrTransferChanged(HdrTransfer _t1)
486{
487 QMetaObject::activate<void>(this, &staticMetaObject, 17, nullptr, _t1);
488}
489namespace {
490struct qt_meta_tag_ZN3Mlt12RenderThreadE_t {};
491} // unnamed namespace
492
493template <> constexpr inline auto Mlt::RenderThread::qt_create_metaobjectdata<qt_meta_tag_ZN3Mlt12RenderThreadE_t>()
494{
495 namespace QMC = QtMocConstants;
496 QtMocHelpers::StringRefStorage qt_stringData {
497 "Mlt::RenderThread"
498 };
499
500 QtMocHelpers::UintData qt_methods {
501 };
502 QtMocHelpers::UintData qt_properties {
503 };
504 QtMocHelpers::UintData qt_enums {
505 };
506 return QtMocHelpers::metaObjectData<RenderThread, qt_meta_tag_ZN3Mlt12RenderThreadE_t>(QMC::MetaObjectFlag{}, qt_stringData,
507 qt_methods, qt_properties, qt_enums);
508}
509Q_CONSTINIT const QMetaObject Mlt::RenderThread::staticMetaObject = { {
510 QMetaObject::SuperData::link<QThread::staticMetaObject>(),
511 qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3Mlt12RenderThreadE_t>.stringdata,
512 qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3Mlt12RenderThreadE_t>.data,
513 qt_static_metacall,
514 nullptr,
515 qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3Mlt12RenderThreadE_t>.metaTypes,
516 nullptr
517} };
518
519void Mlt::RenderThread::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
520{
521 auto *_t = static_cast<RenderThread *>(_o);
522 (void)_t;
523 (void)_c;
524 (void)_id;
525 (void)_a;
526}
527
528const QMetaObject *Mlt::RenderThread::metaObject() const
529{
530 return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
531}
532
533void *Mlt::RenderThread::qt_metacast(const char *_clname)
534{
535 if (!_clname) return nullptr;
536 if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3Mlt12RenderThreadE_t>.strings))
537 return static_cast<void*>(this);
538 return QThread::qt_metacast(_clname);
539}
540
541int Mlt::RenderThread::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
542{
543 _id = QThread::qt_metacall(_c, _id, _a);
544 return _id;
545}
546namespace {
547struct qt_meta_tag_ZN3Mlt13FrameRendererE_t {};
548} // unnamed namespace
549
550template <> constexpr inline auto Mlt::FrameRenderer::qt_create_metaobjectdata<qt_meta_tag_ZN3Mlt13FrameRendererE_t>()
551{
552 namespace QMC = QtMocConstants;
553 QtMocHelpers::StringRefStorage qt_stringData {
554 "Mlt::FrameRenderer",
555 "frameDisplayed",
556 "",
557 "SharedFrame",
558 "frame",
559 "imageReady",
560 "showFrame",
561 "Mlt::Frame"
562 };
563
564 QtMocHelpers::UintData qt_methods {
565 // Signal 'frameDisplayed'
566 QtMocHelpers::SignalData<void(const SharedFrame &)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
567 { 0x80000000 | 3, 4 },
568 }}),
569 // Signal 'imageReady'
570 QtMocHelpers::SignalData<void()>(5, 2, QMC::AccessPublic, QMetaType::Void),
571 // Method 'showFrame'
572 QtMocHelpers::MethodData<void(Mlt::Frame)>(6, 2, QMC::AccessPublic, QMetaType::Void, {{
573 { 0x80000000 | 7, 4 },
574 }}),
575 };
576 QtMocHelpers::UintData qt_properties {
577 };
578 QtMocHelpers::UintData qt_enums {
579 };
580 return QtMocHelpers::metaObjectData<FrameRenderer, qt_meta_tag_ZN3Mlt13FrameRendererE_t>(QMC::MetaObjectFlag{}, qt_stringData,
581 qt_methods, qt_properties, qt_enums);
582}
583Q_CONSTINIT const QMetaObject Mlt::FrameRenderer::staticMetaObject = { {
584 QMetaObject::SuperData::link<QThread::staticMetaObject>(),
585 qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3Mlt13FrameRendererE_t>.stringdata,
586 qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3Mlt13FrameRendererE_t>.data,
587 qt_static_metacall,
588 nullptr,
589 qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3Mlt13FrameRendererE_t>.metaTypes,
590 nullptr
591} };
592
593void Mlt::FrameRenderer::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
594{
595 auto *_t = static_cast<FrameRenderer *>(_o);
596 if (_c == QMetaObject::InvokeMetaMethod) {
597 switch (_id) {
598 case 0: _t->frameDisplayed((*reinterpret_cast<std::add_pointer_t<SharedFrame>>(_a[1]))); break;
599 case 1: _t->imageReady(); break;
600 case 2: _t->showFrame((*reinterpret_cast<std::add_pointer_t<Mlt::Frame>>(_a[1]))); break;
601 default: ;
602 }
603 }
604 if (_c == QMetaObject::IndexOfMethod) {
605 if (QtMocHelpers::indexOfMethod<void (FrameRenderer::*)(const SharedFrame & )>(_a, &FrameRenderer::frameDisplayed, 0))
606 return;
607 if (QtMocHelpers::indexOfMethod<void (FrameRenderer::*)()>(_a, &FrameRenderer::imageReady, 1))
608 return;
609 }
610}
611
612const QMetaObject *Mlt::FrameRenderer::metaObject() const
613{
614 return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
615}
616
617void *Mlt::FrameRenderer::qt_metacast(const char *_clname)
618{
619 if (!_clname) return nullptr;
620 if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3Mlt13FrameRendererE_t>.strings))
621 return static_cast<void*>(this);
622 return QThread::qt_metacast(_clname);
623}
624
625int Mlt::FrameRenderer::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
626{
627 _id = QThread::qt_metacall(_c, _id, _a);
628 if (_id < 0)
629 return _id;
630 if (_c == QMetaObject::InvokeMetaMethod) {
631 if (_id < 3)
632 qt_static_metacall(this, _c, _id, _a);
633 _id -= 3;
634 }
635 if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
636 if (_id < 3)
637 *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
638 _id -= 3;
639 }
640 return _id;
641}
642
643// SIGNAL 0
644void Mlt::FrameRenderer::frameDisplayed(const SharedFrame & _t1)
645{
646 QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1);
647}
648
649// SIGNAL 1
650void Mlt::FrameRenderer::imageReady()
651{
652 QMetaObject::activate(this, &staticMetaObject, 1, nullptr);
653}
654QT_WARNING_POP
Generated on for CuteLogger by doxygen 1.14.0