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 68 (Qt 6.8.2)
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 != 68
21#error "This file was generated using the moc from 6.8.2. 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
37
38#ifdef QT_MOC_HAS_STRINGDATA
39static constexpr auto qt_meta_stringdata_ZN3Mlt11VideoWidgetE = QtMocHelpers::stringData(
40 "Mlt::VideoWidget",
41 "frameDisplayed",
42 "",
43 "SharedFrame",
44 "frame",
45 "dragStarted",
46 "seekTo",
47 "x",
48 "gpuNotSupported",
49 "started",
50 "paused",
51 "playing",
52 "rectChanged",
53 "gridChanged",
54 "zoomChanged",
55 "offsetChanged",
56 "offset",
57 "imageReady",
58 "snapToGridChanged",
59 "toggleZoom",
60 "setGrid",
61 "grid",
62 "setZoom",
63 "zoom",
64 "setOffsetX",
65 "setOffsetY",
66 "y",
67 "setBlankScene",
68 "setCurrentFilter",
69 "QmlFilter*",
70 "filter",
71 "QmlMetadata*",
72 "meta",
73 "setSnapToGrid",
74 "snap",
75 "initialize",
76 "beforeRendering",
77 "renderVideo",
78 "onFrameDisplayed",
79 "resizeVideo",
80 "width",
81 "height",
82 "onRefreshTimeout",
83 "rect",
84 "snapToGrid"
85);
86#else // !QT_MOC_HAS_STRINGDATA
87#error "qtmochelpers.h not found or too old."
88#endif // !QT_MOC_HAS_STRINGDATA
89
90Q_CONSTINIT static const uint qt_meta_data_ZN3Mlt11VideoWidgetE[] = {
91
92 // content:
93 12, // revision
94 0, // classname
95 0, 0, // classinfo
96 28, 14, // methods
97 5, 238, // properties
98 0, 0, // enums/sets
99 0, 0, // constructors
100 0, // flags
101 15, // signalCount
102
103 // signals: name, argc, parameters, tag, flags, initial metatype offsets
104 1, 1, 182, 2, 0x06, 6 /* Public */,
105 5, 0, 185, 2, 0x06, 8 /* Public */,
106 6, 1, 186, 2, 0x06, 9 /* Public */,
107 8, 0, 189, 2, 0x06, 11 /* Public */,
108 9, 0, 190, 2, 0x06, 12 /* Public */,
109 10, 0, 191, 2, 0x06, 13 /* Public */,
110 11, 0, 192, 2, 0x06, 14 /* Public */,
111 12, 0, 193, 2, 0x06, 15 /* Public */,
112 13, 0, 194, 2, 0x06, 16 /* Public */,
113 14, 0, 195, 2, 0x06, 17 /* Public */,
114 15, 1, 196, 2, 0x06, 18 /* Public */,
115 15, 0, 199, 2, 0x26, 20 /* Public | MethodCloned */,
116 17, 0, 200, 2, 0x06, 21 /* Public */,
117 18, 0, 201, 2, 0x06, 22 /* Public */,
118 19, 1, 202, 2, 0x06, 23 /* Public */,
119
120 // slots: name, argc, parameters, tag, flags, initial metatype offsets
121 20, 1, 205, 2, 0x0a, 25 /* Public */,
122 22, 1, 208, 2, 0x0a, 27 /* Public */,
123 24, 1, 211, 2, 0x0a, 29 /* Public */,
124 25, 1, 214, 2, 0x0a, 31 /* Public */,
125 27, 0, 217, 2, 0x0a, 33 /* Public */,
126 28, 2, 218, 2, 0x0a, 34 /* Public */,
127 33, 1, 223, 2, 0x0a, 37 /* Public */,
128 35, 0, 226, 2, 0x0a, 39 /* Public */,
129 36, 0, 227, 2, 0x0a, 40 /* Public */,
130 37, 0, 228, 2, 0x0a, 41 /* Public */,
131 38, 1, 229, 2, 0x0a, 42 /* Public */,
132 39, 2, 232, 2, 0x08, 44 /* Private */,
133 42, 0, 237, 2, 0x08, 47 /* Private */,
134
135 // signals: parameters
136 QMetaType::Void, 0x80000000 | 3, 4,
137 QMetaType::Void,
138 QMetaType::Void, QMetaType::Int, 7,
139 QMetaType::Void,
140 QMetaType::Void,
141 QMetaType::Void,
142 QMetaType::Void,
143 QMetaType::Void,
144 QMetaType::Void,
145 QMetaType::Void,
146 QMetaType::Void, QMetaType::QPoint, 16,
147 QMetaType::Void,
148 QMetaType::Void,
149 QMetaType::Void,
150 QMetaType::Void, QMetaType::Bool, 2,
151
152 // slots: parameters
153 QMetaType::Void, QMetaType::Int, 21,
154 QMetaType::Void, QMetaType::Float, 23,
155 QMetaType::Void, QMetaType::Int, 7,
156 QMetaType::Void, QMetaType::Int, 26,
157 QMetaType::Void,
158 QMetaType::Void, 0x80000000 | 29, 0x80000000 | 31, 30, 32,
159 QMetaType::Void, QMetaType::Bool, 34,
160 QMetaType::Void,
161 QMetaType::Void,
162 QMetaType::Void,
163 QMetaType::Void, 0x80000000 | 3, 4,
164 QMetaType::Void, QMetaType::Int, QMetaType::Int, 40, 41,
165 QMetaType::Void,
166
167 // properties: name, type, flags, notifyId, revision
168 43, QMetaType::QRectF, 0x00015001, uint(7), 0,
169 21, QMetaType::Int, 0x00015001, uint(8), 0,
170 44, QMetaType::Bool, 0x00015001, uint(13), 0,
171 23, QMetaType::Float, 0x00015001, uint(9), 0,
172 16, QMetaType::QPoint, 0x00015001, uint(10), 0,
173
174 0 // eod
175};
176
177Q_CONSTINIT const QMetaObject Mlt::VideoWidget::staticMetaObject = { {
178 QMetaObject::SuperData::link<QQuickWidget::staticMetaObject>(),
179 qt_meta_stringdata_ZN3Mlt11VideoWidgetE.offsetsAndSizes,
180 qt_meta_data_ZN3Mlt11VideoWidgetE,
181 qt_static_metacall,
182 nullptr,
183 qt_incomplete_metaTypeArray<qt_meta_tag_ZN3Mlt11VideoWidgetE_t,
184 // property 'rect'
185 QtPrivate::TypeAndForceComplete<QRectF, std::true_type>,
186 // property 'grid'
187 QtPrivate::TypeAndForceComplete<int, std::true_type>,
188 // property 'snapToGrid'
189 QtPrivate::TypeAndForceComplete<bool, std::true_type>,
190 // property 'zoom'
191 QtPrivate::TypeAndForceComplete<float, std::true_type>,
192 // property 'offset'
193 QtPrivate::TypeAndForceComplete<QPoint, std::true_type>,
194 // Q_OBJECT / Q_GADGET
195 QtPrivate::TypeAndForceComplete<VideoWidget, std::true_type>,
196 // method 'frameDisplayed'
197 QtPrivate::TypeAndForceComplete<void, std::false_type>,
198 QtPrivate::TypeAndForceComplete<const SharedFrame &, std::false_type>,
199 // method 'dragStarted'
200 QtPrivate::TypeAndForceComplete<void, std::false_type>,
201 // method 'seekTo'
202 QtPrivate::TypeAndForceComplete<void, std::false_type>,
203 QtPrivate::TypeAndForceComplete<int, std::false_type>,
204 // method 'gpuNotSupported'
205 QtPrivate::TypeAndForceComplete<void, std::false_type>,
206 // method 'started'
207 QtPrivate::TypeAndForceComplete<void, std::false_type>,
208 // method 'paused'
209 QtPrivate::TypeAndForceComplete<void, std::false_type>,
210 // method 'playing'
211 QtPrivate::TypeAndForceComplete<void, std::false_type>,
212 // method 'rectChanged'
213 QtPrivate::TypeAndForceComplete<void, std::false_type>,
214 // method 'gridChanged'
215 QtPrivate::TypeAndForceComplete<void, std::false_type>,
216 // method 'zoomChanged'
217 QtPrivate::TypeAndForceComplete<void, std::false_type>,
218 // method 'offsetChanged'
219 QtPrivate::TypeAndForceComplete<void, std::false_type>,
220 QtPrivate::TypeAndForceComplete<const QPoint &, std::false_type>,
221 // method 'offsetChanged'
222 QtPrivate::TypeAndForceComplete<void, std::false_type>,
223 // method 'imageReady'
224 QtPrivate::TypeAndForceComplete<void, std::false_type>,
225 // method 'snapToGridChanged'
226 QtPrivate::TypeAndForceComplete<void, std::false_type>,
227 // method 'toggleZoom'
228 QtPrivate::TypeAndForceComplete<void, std::false_type>,
229 QtPrivate::TypeAndForceComplete<bool, std::false_type>,
230 // method 'setGrid'
231 QtPrivate::TypeAndForceComplete<void, std::false_type>,
232 QtPrivate::TypeAndForceComplete<int, std::false_type>,
233 // method 'setZoom'
234 QtPrivate::TypeAndForceComplete<void, std::false_type>,
235 QtPrivate::TypeAndForceComplete<float, std::false_type>,
236 // method 'setOffsetX'
237 QtPrivate::TypeAndForceComplete<void, std::false_type>,
238 QtPrivate::TypeAndForceComplete<int, std::false_type>,
239 // method 'setOffsetY'
240 QtPrivate::TypeAndForceComplete<void, std::false_type>,
241 QtPrivate::TypeAndForceComplete<int, std::false_type>,
242 // method 'setBlankScene'
243 QtPrivate::TypeAndForceComplete<void, std::false_type>,
244 // method 'setCurrentFilter'
245 QtPrivate::TypeAndForceComplete<void, std::false_type>,
246 QtPrivate::TypeAndForceComplete<QmlFilter *, std::false_type>,
247 QtPrivate::TypeAndForceComplete<QmlMetadata *, std::false_type>,
248 // method 'setSnapToGrid'
249 QtPrivate::TypeAndForceComplete<void, std::false_type>,
250 QtPrivate::TypeAndForceComplete<bool, std::false_type>,
251 // method 'initialize'
252 QtPrivate::TypeAndForceComplete<void, std::false_type>,
253 // method 'beforeRendering'
254 QtPrivate::TypeAndForceComplete<void, std::false_type>,
255 // method 'renderVideo'
256 QtPrivate::TypeAndForceComplete<void, std::false_type>,
257 // method 'onFrameDisplayed'
258 QtPrivate::TypeAndForceComplete<void, std::false_type>,
259 QtPrivate::TypeAndForceComplete<const SharedFrame &, std::false_type>,
260 // method 'resizeVideo'
261 QtPrivate::TypeAndForceComplete<void, std::false_type>,
262 QtPrivate::TypeAndForceComplete<int, std::false_type>,
263 QtPrivate::TypeAndForceComplete<int, std::false_type>,
264 // method 'onRefreshTimeout'
265 QtPrivate::TypeAndForceComplete<void, std::false_type>
266 >,
267 nullptr
268} };
269
270void Mlt::VideoWidget::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
271{
272 auto *_t = static_cast<VideoWidget *>(_o);
273 if (_c == QMetaObject::InvokeMetaMethod) {
274 switch (_id) {
275 case 0: _t->frameDisplayed((*reinterpret_cast< std::add_pointer_t<SharedFrame>>(_a[1]))); break;
276 case 1: _t->dragStarted(); break;
277 case 2: _t->seekTo((*reinterpret_cast< std::add_pointer_t<int>>(_a[1]))); break;
278 case 3: _t->gpuNotSupported(); break;
279 case 4: _t->started(); break;
280 case 5: _t->paused(); break;
281 case 6: _t->playing(); break;
282 case 7: _t->rectChanged(); break;
283 case 8: _t->gridChanged(); break;
284 case 9: _t->zoomChanged(); break;
285 case 10: _t->offsetChanged((*reinterpret_cast< std::add_pointer_t<QPoint>>(_a[1]))); break;
286 case 11: _t->offsetChanged(); break;
287 case 12: _t->imageReady(); break;
288 case 13: _t->snapToGridChanged(); break;
289 case 14: _t->toggleZoom((*reinterpret_cast< std::add_pointer_t<bool>>(_a[1]))); break;
290 case 15: _t->setGrid((*reinterpret_cast< std::add_pointer_t<int>>(_a[1]))); break;
291 case 16: _t->setZoom((*reinterpret_cast< std::add_pointer_t<float>>(_a[1]))); break;
292 case 17: _t->setOffsetX((*reinterpret_cast< std::add_pointer_t<int>>(_a[1]))); break;
293 case 18: _t->setOffsetY((*reinterpret_cast< std::add_pointer_t<int>>(_a[1]))); break;
294 case 19: _t->setBlankScene(); break;
295 case 20: _t->setCurrentFilter((*reinterpret_cast< std::add_pointer_t<QmlFilter*>>(_a[1])),(*reinterpret_cast< std::add_pointer_t<QmlMetadata*>>(_a[2]))); break;
296 case 21: _t->setSnapToGrid((*reinterpret_cast< std::add_pointer_t<bool>>(_a[1]))); break;
297 case 22: _t->initialize(); break;
298 case 23: _t->beforeRendering(); break;
299 case 24: _t->renderVideo(); break;
300 case 25: _t->onFrameDisplayed((*reinterpret_cast< std::add_pointer_t<SharedFrame>>(_a[1]))); break;
301 case 26: _t->resizeVideo((*reinterpret_cast< std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast< std::add_pointer_t<int>>(_a[2]))); break;
302 case 27: _t->onRefreshTimeout(); break;
303 default: ;
304 }
305 }
306 if (_c == QMetaObject::IndexOfMethod) {
307 int *result = reinterpret_cast<int *>(_a[0]);
308 {
309 using _q_method_type = void (VideoWidget::*)(const SharedFrame & );
310 if (_q_method_type _q_method = &VideoWidget::frameDisplayed; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
311 *result = 0;
312 return;
313 }
314 }
315 {
316 using _q_method_type = void (VideoWidget::*)();
317 if (_q_method_type _q_method = &VideoWidget::dragStarted; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
318 *result = 1;
319 return;
320 }
321 }
322 {
323 using _q_method_type = void (VideoWidget::*)(int );
324 if (_q_method_type _q_method = &VideoWidget::seekTo; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
325 *result = 2;
326 return;
327 }
328 }
329 {
330 using _q_method_type = void (VideoWidget::*)();
331 if (_q_method_type _q_method = &VideoWidget::gpuNotSupported; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
332 *result = 3;
333 return;
334 }
335 }
336 {
337 using _q_method_type = void (VideoWidget::*)();
338 if (_q_method_type _q_method = &VideoWidget::started; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
339 *result = 4;
340 return;
341 }
342 }
343 {
344 using _q_method_type = void (VideoWidget::*)();
345 if (_q_method_type _q_method = &VideoWidget::paused; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
346 *result = 5;
347 return;
348 }
349 }
350 {
351 using _q_method_type = void (VideoWidget::*)();
352 if (_q_method_type _q_method = &VideoWidget::playing; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
353 *result = 6;
354 return;
355 }
356 }
357 {
358 using _q_method_type = void (VideoWidget::*)();
359 if (_q_method_type _q_method = &VideoWidget::rectChanged; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
360 *result = 7;
361 return;
362 }
363 }
364 {
365 using _q_method_type = void (VideoWidget::*)();
366 if (_q_method_type _q_method = &VideoWidget::gridChanged; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
367 *result = 8;
368 return;
369 }
370 }
371 {
372 using _q_method_type = void (VideoWidget::*)();
373 if (_q_method_type _q_method = &VideoWidget::zoomChanged; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
374 *result = 9;
375 return;
376 }
377 }
378 {
379 using _q_method_type = void (VideoWidget::*)(const QPoint & );
380 if (_q_method_type _q_method = &VideoWidget::offsetChanged; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
381 *result = 10;
382 return;
383 }
384 }
385 {
386 using _q_method_type = void (VideoWidget::*)();
387 if (_q_method_type _q_method = &VideoWidget::imageReady; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
388 *result = 12;
389 return;
390 }
391 }
392 {
393 using _q_method_type = void (VideoWidget::*)();
394 if (_q_method_type _q_method = &VideoWidget::snapToGridChanged; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
395 *result = 13;
396 return;
397 }
398 }
399 {
400 using _q_method_type = void (VideoWidget::*)(bool );
401 if (_q_method_type _q_method = &VideoWidget::toggleZoom; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
402 *result = 14;
403 return;
404 }
405 }
406 }
407 if (_c == QMetaObject::ReadProperty) {
408 void *_v = _a[0];
409 switch (_id) {
410 case 0: *reinterpret_cast< QRectF*>(_v) = _t->rect(); break;
411 case 1: *reinterpret_cast< int*>(_v) = _t->grid(); break;
412 case 2: *reinterpret_cast< bool*>(_v) = _t->snapToGrid(); break;
413 case 3: *reinterpret_cast< float*>(_v) = _t->zoom(); break;
414 case 4: *reinterpret_cast< QPoint*>(_v) = _t->offset(); break;
415 default: break;
416 }
417 }
418}
419
420const QMetaObject *Mlt::VideoWidget::metaObject() const
421{
422 return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
423}
424
425void *Mlt::VideoWidget::qt_metacast(const char *_clname)
426{
427 if (!_clname) return nullptr;
428 if (!strcmp(_clname, qt_meta_stringdata_ZN3Mlt11VideoWidgetE.stringdata0))
429 return static_cast<void*>(this);
430 if (!strcmp(_clname, "Controller"))
431 return static_cast< Controller*>(this);
432 return QQuickWidget::qt_metacast(_clname);
433}
434
435int Mlt::VideoWidget::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
436{
437 _id = QQuickWidget::qt_metacall(_c, _id, _a);
438 if (_id < 0)
439 return _id;
440 if (_c == QMetaObject::InvokeMetaMethod) {
441 if (_id < 28)
442 qt_static_metacall(this, _c, _id, _a);
443 _id -= 28;
444 }
445 if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
446 if (_id < 28)
447 *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
448 _id -= 28;
449 }
450 if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
451 || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
452 || _c == QMetaObject::RegisterPropertyMetaType) {
453 qt_static_metacall(this, _c, _id, _a);
454 _id -= 5;
455 }
456 return _id;
457}
458
459// SIGNAL 0
460void Mlt::VideoWidget::frameDisplayed(const SharedFrame & _t1)
461{
462 void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
463 QMetaObject::activate(this, &staticMetaObject, 0, _a);
464}
465
466// SIGNAL 1
467void Mlt::VideoWidget::dragStarted()
468{
469 QMetaObject::activate(this, &staticMetaObject, 1, nullptr);
470}
471
472// SIGNAL 2
473void Mlt::VideoWidget::seekTo(int _t1)
474{
475 void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
476 QMetaObject::activate(this, &staticMetaObject, 2, _a);
477}
478
479// SIGNAL 3
480void Mlt::VideoWidget::gpuNotSupported()
481{
482 QMetaObject::activate(this, &staticMetaObject, 3, nullptr);
483}
484
485// SIGNAL 4
486void Mlt::VideoWidget::started()
487{
488 QMetaObject::activate(this, &staticMetaObject, 4, nullptr);
489}
490
491// SIGNAL 5
492void Mlt::VideoWidget::paused()
493{
494 QMetaObject::activate(this, &staticMetaObject, 5, nullptr);
495}
496
497// SIGNAL 6
498void Mlt::VideoWidget::playing()
499{
500 QMetaObject::activate(this, &staticMetaObject, 6, nullptr);
501}
502
503// SIGNAL 7
504void Mlt::VideoWidget::rectChanged()
505{
506 QMetaObject::activate(this, &staticMetaObject, 7, nullptr);
507}
508
509// SIGNAL 8
510void Mlt::VideoWidget::gridChanged()
511{
512 QMetaObject::activate(this, &staticMetaObject, 8, nullptr);
513}
514
515// SIGNAL 9
516void Mlt::VideoWidget::zoomChanged()
517{
518 QMetaObject::activate(this, &staticMetaObject, 9, nullptr);
519}
520
521// SIGNAL 10
522void Mlt::VideoWidget::offsetChanged(const QPoint & _t1)
523{
524 void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
525 QMetaObject::activate(this, &staticMetaObject, 10, _a);
526}
527
528// SIGNAL 12
529void Mlt::VideoWidget::imageReady()
530{
531 QMetaObject::activate(this, &staticMetaObject, 12, nullptr);
532}
533
534// SIGNAL 13
535void Mlt::VideoWidget::snapToGridChanged()
536{
537 QMetaObject::activate(this, &staticMetaObject, 13, nullptr);
538}
539
540// SIGNAL 14
541void Mlt::VideoWidget::toggleZoom(bool _t1)
542{
543 void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
544 QMetaObject::activate(this, &staticMetaObject, 14, _a);
545}
546namespace {
547struct qt_meta_tag_ZN3Mlt12RenderThreadE_t {};
548} // unnamed namespace
549
550
551#ifdef QT_MOC_HAS_STRINGDATA
552static constexpr auto qt_meta_stringdata_ZN3Mlt12RenderThreadE = QtMocHelpers::stringData(
553 "Mlt::RenderThread"
554);
555#else // !QT_MOC_HAS_STRINGDATA
556#error "qtmochelpers.h not found or too old."
557#endif // !QT_MOC_HAS_STRINGDATA
558
559Q_CONSTINIT static const uint qt_meta_data_ZN3Mlt12RenderThreadE[] = {
560
561 // content:
562 12, // revision
563 0, // classname
564 0, 0, // classinfo
565 0, 0, // methods
566 0, 0, // properties
567 0, 0, // enums/sets
568 0, 0, // constructors
569 0, // flags
570 0, // signalCount
571
572 0 // eod
573};
574
575Q_CONSTINIT const QMetaObject Mlt::RenderThread::staticMetaObject = { {
576 QMetaObject::SuperData::link<QThread::staticMetaObject>(),
577 qt_meta_stringdata_ZN3Mlt12RenderThreadE.offsetsAndSizes,
578 qt_meta_data_ZN3Mlt12RenderThreadE,
579 qt_static_metacall,
580 nullptr,
581 qt_incomplete_metaTypeArray<qt_meta_tag_ZN3Mlt12RenderThreadE_t,
582 // Q_OBJECT / Q_GADGET
583 QtPrivate::TypeAndForceComplete<RenderThread, std::true_type>
584 >,
585 nullptr
586} };
587
588void Mlt::RenderThread::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
589{
590 auto *_t = static_cast<RenderThread *>(_o);
591 (void)_t;
592 (void)_c;
593 (void)_id;
594 (void)_a;
595}
596
597const QMetaObject *Mlt::RenderThread::metaObject() const
598{
599 return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
600}
601
602void *Mlt::RenderThread::qt_metacast(const char *_clname)
603{
604 if (!_clname) return nullptr;
605 if (!strcmp(_clname, qt_meta_stringdata_ZN3Mlt12RenderThreadE.stringdata0))
606 return static_cast<void*>(this);
607 return QThread::qt_metacast(_clname);
608}
609
610int Mlt::RenderThread::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
611{
612 _id = QThread::qt_metacall(_c, _id, _a);
613 return _id;
614}
615namespace {
616struct qt_meta_tag_ZN3Mlt13FrameRendererE_t {};
617} // unnamed namespace
618
619
620#ifdef QT_MOC_HAS_STRINGDATA
621static constexpr auto qt_meta_stringdata_ZN3Mlt13FrameRendererE = QtMocHelpers::stringData(
622 "Mlt::FrameRenderer",
623 "frameDisplayed",
624 "",
625 "SharedFrame",
626 "frame",
627 "imageReady",
628 "showFrame",
629 "Mlt::Frame"
630);
631#else // !QT_MOC_HAS_STRINGDATA
632#error "qtmochelpers.h not found or too old."
633#endif // !QT_MOC_HAS_STRINGDATA
634
635Q_CONSTINIT static const uint qt_meta_data_ZN3Mlt13FrameRendererE[] = {
636
637 // content:
638 12, // revision
639 0, // classname
640 0, 0, // classinfo
641 3, 14, // methods
642 0, 0, // properties
643 0, 0, // enums/sets
644 0, 0, // constructors
645 0, // flags
646 2, // signalCount
647
648 // signals: name, argc, parameters, tag, flags, initial metatype offsets
649 1, 1, 32, 2, 0x06, 1 /* Public */,
650 5, 0, 35, 2, 0x06, 3 /* Public */,
651
652 // methods: name, argc, parameters, tag, flags, initial metatype offsets
653 6, 1, 36, 2, 0x02, 4 /* Public */,
654
655 // signals: parameters
656 QMetaType::Void, 0x80000000 | 3, 4,
657 QMetaType::Void,
658
659 // methods: parameters
660 QMetaType::Void, 0x80000000 | 7, 4,
661
662 0 // eod
663};
664
665Q_CONSTINIT const QMetaObject Mlt::FrameRenderer::staticMetaObject = { {
666 QMetaObject::SuperData::link<QThread::staticMetaObject>(),
667 qt_meta_stringdata_ZN3Mlt13FrameRendererE.offsetsAndSizes,
668 qt_meta_data_ZN3Mlt13FrameRendererE,
669 qt_static_metacall,
670 nullptr,
671 qt_incomplete_metaTypeArray<qt_meta_tag_ZN3Mlt13FrameRendererE_t,
672 // Q_OBJECT / Q_GADGET
673 QtPrivate::TypeAndForceComplete<FrameRenderer, std::true_type>,
674 // method 'frameDisplayed'
675 QtPrivate::TypeAndForceComplete<void, std::false_type>,
676 QtPrivate::TypeAndForceComplete<const SharedFrame &, std::false_type>,
677 // method 'imageReady'
678 QtPrivate::TypeAndForceComplete<void, std::false_type>,
679 // method 'showFrame'
680 QtPrivate::TypeAndForceComplete<void, std::false_type>,
681 QtPrivate::TypeAndForceComplete<Mlt::Frame, std::false_type>
682 >,
683 nullptr
684} };
685
686void Mlt::FrameRenderer::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
687{
688 auto *_t = static_cast<FrameRenderer *>(_o);
689 if (_c == QMetaObject::InvokeMetaMethod) {
690 switch (_id) {
691 case 0: _t->frameDisplayed((*reinterpret_cast< std::add_pointer_t<SharedFrame>>(_a[1]))); break;
692 case 1: _t->imageReady(); break;
693 case 2: _t->showFrame((*reinterpret_cast< std::add_pointer_t<Mlt::Frame>>(_a[1]))); break;
694 default: ;
695 }
696 }
697 if (_c == QMetaObject::IndexOfMethod) {
698 int *result = reinterpret_cast<int *>(_a[0]);
699 {
700 using _q_method_type = void (FrameRenderer::*)(const SharedFrame & );
701 if (_q_method_type _q_method = &FrameRenderer::frameDisplayed; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
702 *result = 0;
703 return;
704 }
705 }
706 {
707 using _q_method_type = void (FrameRenderer::*)();
708 if (_q_method_type _q_method = &FrameRenderer::imageReady; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
709 *result = 1;
710 return;
711 }
712 }
713 }
714}
715
716const QMetaObject *Mlt::FrameRenderer::metaObject() const
717{
718 return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
719}
720
721void *Mlt::FrameRenderer::qt_metacast(const char *_clname)
722{
723 if (!_clname) return nullptr;
724 if (!strcmp(_clname, qt_meta_stringdata_ZN3Mlt13FrameRendererE.stringdata0))
725 return static_cast<void*>(this);
726 return QThread::qt_metacast(_clname);
727}
728
729int Mlt::FrameRenderer::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
730{
731 _id = QThread::qt_metacall(_c, _id, _a);
732 if (_id < 0)
733 return _id;
734 if (_c == QMetaObject::InvokeMetaMethod) {
735 if (_id < 3)
736 qt_static_metacall(this, _c, _id, _a);
737 _id -= 3;
738 }
739 if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
740 if (_id < 3)
741 *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
742 _id -= 3;
743 }
744 return _id;
745}
746
747// SIGNAL 0
748void Mlt::FrameRenderer::frameDisplayed(const SharedFrame & _t1)
749{
750 void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
751 QMetaObject::activate(this, &staticMetaObject, 0, _a);
752}
753
754// SIGNAL 1
755void Mlt::FrameRenderer::imageReady()
756{
757 QMetaObject::activate(this, &staticMetaObject, 1, nullptr);
758}
759QT_WARNING_POP