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