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.6.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#if __has_include(<QtCore/qtmochelpers.h>)
13#include <QtCore/qtmochelpers.h>
14#else
15QT_BEGIN_MOC_NAMESPACE
16#endif
17
18
19#include <memory>
20
21#if !defined(Q_MOC_OUTPUT_REVISION)
22#error "The header file 'videowidget.h' doesn't include <QObject>."
23#elif Q_MOC_OUTPUT_REVISION != 68
24#error "This file was generated using the moc from 6.6.2. It"
25#error "cannot be used with the include files from this version of Qt."
26#error "(The moc has changed too much.)"
27#endif
28
29#ifndef Q_CONSTINIT
30#define Q_CONSTINIT
31#endif
32
33QT_WARNING_PUSH
34QT_WARNING_DISABLE_DEPRECATED
35QT_WARNING_DISABLE_GCC("-Wuseless-cast")
36namespace {
37
38#ifdef QT_MOC_HAS_STRINGDATA
39struct qt_meta_stringdata_CLASSMltSCOPEVideoWidgetENDCLASS_t {};
40constexpr auto qt_meta_stringdata_CLASSMltSCOPEVideoWidgetENDCLASS = QtMocHelpers::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#else // !QT_MOC_HAS_STRING_DATA
88struct qt_meta_stringdata_CLASSMltSCOPEVideoWidgetENDCLASS_t {
89 uint offsetsAndSizes[90];
90 char stringdata0[17];
91 char stringdata1[15];
92 char stringdata2[1];
93 char stringdata3[12];
94 char stringdata4[6];
95 char stringdata5[12];
96 char stringdata6[7];
97 char stringdata7[2];
98 char stringdata8[16];
99 char stringdata9[8];
100 char stringdata10[7];
101 char stringdata11[8];
102 char stringdata12[12];
103 char stringdata13[12];
104 char stringdata14[12];
105 char stringdata15[14];
106 char stringdata16[7];
107 char stringdata17[11];
108 char stringdata18[18];
109 char stringdata19[11];
110 char stringdata20[8];
111 char stringdata21[5];
112 char stringdata22[8];
113 char stringdata23[5];
114 char stringdata24[11];
115 char stringdata25[11];
116 char stringdata26[2];
117 char stringdata27[14];
118 char stringdata28[17];
119 char stringdata29[11];
120 char stringdata30[7];
121 char stringdata31[13];
122 char stringdata32[5];
123 char stringdata33[14];
124 char stringdata34[5];
125 char stringdata35[11];
126 char stringdata36[16];
127 char stringdata37[12];
128 char stringdata38[17];
129 char stringdata39[12];
130 char stringdata40[6];
131 char stringdata41[7];
132 char stringdata42[17];
133 char stringdata43[5];
134 char stringdata44[11];
135};
136#define QT_MOC_LITERAL(ofs, len) \
137 uint(sizeof(qt_meta_stringdata_CLASSMltSCOPEVideoWidgetENDCLASS_t::offsetsAndSizes) + ofs), len
138Q_CONSTINIT static const qt_meta_stringdata_CLASSMltSCOPEVideoWidgetENDCLASS_t qt_meta_stringdata_CLASSMltSCOPEVideoWidgetENDCLASS = {
139 {
140 QT_MOC_LITERAL(0, 16), // "Mlt::VideoWidget"
141 QT_MOC_LITERAL(17, 14), // "frameDisplayed"
142 QT_MOC_LITERAL(32, 0), // ""
143 QT_MOC_LITERAL(33, 11), // "SharedFrame"
144 QT_MOC_LITERAL(45, 5), // "frame"
145 QT_MOC_LITERAL(51, 11), // "dragStarted"
146 QT_MOC_LITERAL(63, 6), // "seekTo"
147 QT_MOC_LITERAL(70, 1), // "x"
148 QT_MOC_LITERAL(72, 15), // "gpuNotSupported"
149 QT_MOC_LITERAL(88, 7), // "started"
150 QT_MOC_LITERAL(96, 6), // "paused"
151 QT_MOC_LITERAL(103, 7), // "playing"
152 QT_MOC_LITERAL(111, 11), // "rectChanged"
153 QT_MOC_LITERAL(123, 11), // "gridChanged"
154 QT_MOC_LITERAL(135, 11), // "zoomChanged"
155 QT_MOC_LITERAL(147, 13), // "offsetChanged"
156 QT_MOC_LITERAL(161, 6), // "offset"
157 QT_MOC_LITERAL(168, 10), // "imageReady"
158 QT_MOC_LITERAL(179, 17), // "snapToGridChanged"
159 QT_MOC_LITERAL(197, 10), // "toggleZoom"
160 QT_MOC_LITERAL(208, 7), // "setGrid"
161 QT_MOC_LITERAL(216, 4), // "grid"
162 QT_MOC_LITERAL(221, 7), // "setZoom"
163 QT_MOC_LITERAL(229, 4), // "zoom"
164 QT_MOC_LITERAL(234, 10), // "setOffsetX"
165 QT_MOC_LITERAL(245, 10), // "setOffsetY"
166 QT_MOC_LITERAL(256, 1), // "y"
167 QT_MOC_LITERAL(258, 13), // "setBlankScene"
168 QT_MOC_LITERAL(272, 16), // "setCurrentFilter"
169 QT_MOC_LITERAL(289, 10), // "QmlFilter*"
170 QT_MOC_LITERAL(300, 6), // "filter"
171 QT_MOC_LITERAL(307, 12), // "QmlMetadata*"
172 QT_MOC_LITERAL(320, 4), // "meta"
173 QT_MOC_LITERAL(325, 13), // "setSnapToGrid"
174 QT_MOC_LITERAL(339, 4), // "snap"
175 QT_MOC_LITERAL(344, 10), // "initialize"
176 QT_MOC_LITERAL(355, 15), // "beforeRendering"
177 QT_MOC_LITERAL(371, 11), // "renderVideo"
178 QT_MOC_LITERAL(383, 16), // "onFrameDisplayed"
179 QT_MOC_LITERAL(400, 11), // "resizeVideo"
180 QT_MOC_LITERAL(412, 5), // "width"
181 QT_MOC_LITERAL(418, 6), // "height"
182 QT_MOC_LITERAL(425, 16), // "onRefreshTimeout"
183 QT_MOC_LITERAL(442, 4), // "rect"
184 QT_MOC_LITERAL(447, 10) // "snapToGrid"
185 },
186 "Mlt::VideoWidget",
187 "frameDisplayed",
188 "",
189 "SharedFrame",
190 "frame",
191 "dragStarted",
192 "seekTo",
193 "x",
194 "gpuNotSupported",
195 "started",
196 "paused",
197 "playing",
198 "rectChanged",
199 "gridChanged",
200 "zoomChanged",
201 "offsetChanged",
202 "offset",
203 "imageReady",
204 "snapToGridChanged",
205 "toggleZoom",
206 "setGrid",
207 "grid",
208 "setZoom",
209 "zoom",
210 "setOffsetX",
211 "setOffsetY",
212 "y",
213 "setBlankScene",
214 "setCurrentFilter",
215 "QmlFilter*",
216 "filter",
217 "QmlMetadata*",
218 "meta",
219 "setSnapToGrid",
220 "snap",
221 "initialize",
222 "beforeRendering",
223 "renderVideo",
224 "onFrameDisplayed",
225 "resizeVideo",
226 "width",
227 "height",
228 "onRefreshTimeout",
229 "rect",
230 "snapToGrid"
231};
232#undef QT_MOC_LITERAL
233#endif // !QT_MOC_HAS_STRING_DATA
234} // unnamed namespace
235
236Q_CONSTINIT static const uint qt_meta_data_CLASSMltSCOPEVideoWidgetENDCLASS[] = {
237
238 // content:
239 12, // revision
240 0, // classname
241 0, 0, // classinfo
242 28, 14, // methods
243 5, 238, // properties
244 0, 0, // enums/sets
245 0, 0, // constructors
246 0, // flags
247 15, // signalCount
248
249 // signals: name, argc, parameters, tag, flags, initial metatype offsets
250 1, 1, 182, 2, 0x06, 6 /* Public */,
251 5, 0, 185, 2, 0x06, 8 /* Public */,
252 6, 1, 186, 2, 0x06, 9 /* Public */,
253 8, 0, 189, 2, 0x06, 11 /* Public */,
254 9, 0, 190, 2, 0x06, 12 /* Public */,
255 10, 0, 191, 2, 0x06, 13 /* Public */,
256 11, 0, 192, 2, 0x06, 14 /* Public */,
257 12, 0, 193, 2, 0x06, 15 /* Public */,
258 13, 0, 194, 2, 0x06, 16 /* Public */,
259 14, 0, 195, 2, 0x06, 17 /* Public */,
260 15, 1, 196, 2, 0x06, 18 /* Public */,
261 15, 0, 199, 2, 0x26, 20 /* Public | MethodCloned */,
262 17, 0, 200, 2, 0x06, 21 /* Public */,
263 18, 0, 201, 2, 0x06, 22 /* Public */,
264 19, 1, 202, 2, 0x06, 23 /* Public */,
265
266 // slots: name, argc, parameters, tag, flags, initial metatype offsets
267 20, 1, 205, 2, 0x0a, 25 /* Public */,
268 22, 1, 208, 2, 0x0a, 27 /* Public */,
269 24, 1, 211, 2, 0x0a, 29 /* Public */,
270 25, 1, 214, 2, 0x0a, 31 /* Public */,
271 27, 0, 217, 2, 0x0a, 33 /* Public */,
272 28, 2, 218, 2, 0x0a, 34 /* Public */,
273 33, 1, 223, 2, 0x0a, 37 /* Public */,
274 35, 0, 226, 2, 0x0a, 39 /* Public */,
275 36, 0, 227, 2, 0x0a, 40 /* Public */,
276 37, 0, 228, 2, 0x0a, 41 /* Public */,
277 38, 1, 229, 2, 0x0a, 42 /* Public */,
278 39, 2, 232, 2, 0x08, 44 /* Private */,
279 42, 0, 237, 2, 0x08, 47 /* Private */,
280
281 // signals: parameters
282 QMetaType::Void, 0x80000000 | 3, 4,
283 QMetaType::Void,
284 QMetaType::Void, QMetaType::Int, 7,
285 QMetaType::Void,
286 QMetaType::Void,
287 QMetaType::Void,
288 QMetaType::Void,
289 QMetaType::Void,
290 QMetaType::Void,
291 QMetaType::Void,
292 QMetaType::Void, QMetaType::QPoint, 16,
293 QMetaType::Void,
294 QMetaType::Void,
295 QMetaType::Void,
296 QMetaType::Void, QMetaType::Bool, 2,
297
298 // slots: parameters
299 QMetaType::Void, QMetaType::Int, 21,
300 QMetaType::Void, QMetaType::Float, 23,
301 QMetaType::Void, QMetaType::Int, 7,
302 QMetaType::Void, QMetaType::Int, 26,
303 QMetaType::Void,
304 QMetaType::Void, 0x80000000 | 29, 0x80000000 | 31, 30, 32,
305 QMetaType::Void, QMetaType::Bool, 34,
306 QMetaType::Void,
307 QMetaType::Void,
308 QMetaType::Void,
309 QMetaType::Void, 0x80000000 | 3, 4,
310 QMetaType::Void, QMetaType::Int, QMetaType::Int, 40, 41,
311 QMetaType::Void,
312
313 // properties: name, type, flags
314 43, QMetaType::QRectF, 0x00015001, uint(7), 0,
315 21, QMetaType::Int, 0x00015001, uint(8), 0,
316 44, QMetaType::Bool, 0x00015001, uint(13), 0,
317 23, QMetaType::Float, 0x00015001, uint(9), 0,
318 16, QMetaType::QPoint, 0x00015001, uint(10), 0,
319
320 0 // eod
321};
322
323Q_CONSTINIT const QMetaObject Mlt::VideoWidget::staticMetaObject = { {
324 QMetaObject::SuperData::link<QQuickWidget::staticMetaObject>(),
325 qt_meta_stringdata_CLASSMltSCOPEVideoWidgetENDCLASS.offsetsAndSizes,
326 qt_meta_data_CLASSMltSCOPEVideoWidgetENDCLASS,
327 qt_static_metacall,
328 nullptr,
329 qt_incomplete_metaTypeArray<qt_meta_stringdata_CLASSMltSCOPEVideoWidgetENDCLASS_t,
330 // property 'rect'
331 QtPrivate::TypeAndForceComplete<QRectF, std::true_type>,
332 // property 'grid'
333 QtPrivate::TypeAndForceComplete<int, std::true_type>,
334 // property 'snapToGrid'
335 QtPrivate::TypeAndForceComplete<bool, std::true_type>,
336 // property 'zoom'
337 QtPrivate::TypeAndForceComplete<float, std::true_type>,
338 // property 'offset'
339 QtPrivate::TypeAndForceComplete<QPoint, std::true_type>,
340 // Q_OBJECT / Q_GADGET
341 QtPrivate::TypeAndForceComplete<VideoWidget, std::true_type>,
342 // method 'frameDisplayed'
343 QtPrivate::TypeAndForceComplete<void, std::false_type>,
344 QtPrivate::TypeAndForceComplete<const SharedFrame &, std::false_type>,
345 // method 'dragStarted'
346 QtPrivate::TypeAndForceComplete<void, std::false_type>,
347 // method 'seekTo'
348 QtPrivate::TypeAndForceComplete<void, std::false_type>,
349 QtPrivate::TypeAndForceComplete<int, std::false_type>,
350 // method 'gpuNotSupported'
351 QtPrivate::TypeAndForceComplete<void, std::false_type>,
352 // method 'started'
353 QtPrivate::TypeAndForceComplete<void, std::false_type>,
354 // method 'paused'
355 QtPrivate::TypeAndForceComplete<void, std::false_type>,
356 // method 'playing'
357 QtPrivate::TypeAndForceComplete<void, std::false_type>,
358 // method 'rectChanged'
359 QtPrivate::TypeAndForceComplete<void, std::false_type>,
360 // method 'gridChanged'
361 QtPrivate::TypeAndForceComplete<void, std::false_type>,
362 // method 'zoomChanged'
363 QtPrivate::TypeAndForceComplete<void, std::false_type>,
364 // method 'offsetChanged'
365 QtPrivate::TypeAndForceComplete<void, std::false_type>,
366 QtPrivate::TypeAndForceComplete<const QPoint &, std::false_type>,
367 // method 'offsetChanged'
368 QtPrivate::TypeAndForceComplete<void, std::false_type>,
369 // method 'imageReady'
370 QtPrivate::TypeAndForceComplete<void, std::false_type>,
371 // method 'snapToGridChanged'
372 QtPrivate::TypeAndForceComplete<void, std::false_type>,
373 // method 'toggleZoom'
374 QtPrivate::TypeAndForceComplete<void, std::false_type>,
375 QtPrivate::TypeAndForceComplete<bool, std::false_type>,
376 // method 'setGrid'
377 QtPrivate::TypeAndForceComplete<void, std::false_type>,
378 QtPrivate::TypeAndForceComplete<int, std::false_type>,
379 // method 'setZoom'
380 QtPrivate::TypeAndForceComplete<void, std::false_type>,
381 QtPrivate::TypeAndForceComplete<float, std::false_type>,
382 // method 'setOffsetX'
383 QtPrivate::TypeAndForceComplete<void, std::false_type>,
384 QtPrivate::TypeAndForceComplete<int, std::false_type>,
385 // method 'setOffsetY'
386 QtPrivate::TypeAndForceComplete<void, std::false_type>,
387 QtPrivate::TypeAndForceComplete<int, std::false_type>,
388 // method 'setBlankScene'
389 QtPrivate::TypeAndForceComplete<void, std::false_type>,
390 // method 'setCurrentFilter'
391 QtPrivate::TypeAndForceComplete<void, std::false_type>,
392 QtPrivate::TypeAndForceComplete<QmlFilter *, std::false_type>,
393 QtPrivate::TypeAndForceComplete<QmlMetadata *, std::false_type>,
394 // method 'setSnapToGrid'
395 QtPrivate::TypeAndForceComplete<void, std::false_type>,
396 QtPrivate::TypeAndForceComplete<bool, std::false_type>,
397 // method 'initialize'
398 QtPrivate::TypeAndForceComplete<void, std::false_type>,
399 // method 'beforeRendering'
400 QtPrivate::TypeAndForceComplete<void, std::false_type>,
401 // method 'renderVideo'
402 QtPrivate::TypeAndForceComplete<void, std::false_type>,
403 // method 'onFrameDisplayed'
404 QtPrivate::TypeAndForceComplete<void, std::false_type>,
405 QtPrivate::TypeAndForceComplete<const SharedFrame &, std::false_type>,
406 // method 'resizeVideo'
407 QtPrivate::TypeAndForceComplete<void, std::false_type>,
408 QtPrivate::TypeAndForceComplete<int, std::false_type>,
409 QtPrivate::TypeAndForceComplete<int, std::false_type>,
410 // method 'onRefreshTimeout'
411 QtPrivate::TypeAndForceComplete<void, std::false_type>
412 >,
413 nullptr
414} };
415
416void Mlt::VideoWidget::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
417{
418 if (_c == QMetaObject::InvokeMetaMethod) {
419 auto *_t = static_cast<VideoWidget *>(_o);
420 (void)_t;
421 switch (_id) {
422 case 0: _t->frameDisplayed((*reinterpret_cast< std::add_pointer_t<SharedFrame>>(_a[1]))); break;
423 case 1: _t->dragStarted(); break;
424 case 2: _t->seekTo((*reinterpret_cast< std::add_pointer_t<int>>(_a[1]))); break;
425 case 3: _t->gpuNotSupported(); break;
426 case 4: _t->started(); break;
427 case 5: _t->paused(); break;
428 case 6: _t->playing(); break;
429 case 7: _t->rectChanged(); break;
430 case 8: _t->gridChanged(); break;
431 case 9: _t->zoomChanged(); break;
432 case 10: _t->offsetChanged((*reinterpret_cast< std::add_pointer_t<QPoint>>(_a[1]))); break;
433 case 11: _t->offsetChanged(); break;
434 case 12: _t->imageReady(); break;
435 case 13: _t->snapToGridChanged(); break;
436 case 14: _t->toggleZoom((*reinterpret_cast< std::add_pointer_t<bool>>(_a[1]))); break;
437 case 15: _t->setGrid((*reinterpret_cast< std::add_pointer_t<int>>(_a[1]))); break;
438 case 16: _t->setZoom((*reinterpret_cast< std::add_pointer_t<float>>(_a[1]))); break;
439 case 17: _t->setOffsetX((*reinterpret_cast< std::add_pointer_t<int>>(_a[1]))); break;
440 case 18: _t->setOffsetY((*reinterpret_cast< std::add_pointer_t<int>>(_a[1]))); break;
441 case 19: _t->setBlankScene(); break;
442 case 20: _t->setCurrentFilter((*reinterpret_cast< std::add_pointer_t<QmlFilter*>>(_a[1])),(*reinterpret_cast< std::add_pointer_t<QmlMetadata*>>(_a[2]))); break;
443 case 21: _t->setSnapToGrid((*reinterpret_cast< std::add_pointer_t<bool>>(_a[1]))); break;
444 case 22: _t->initialize(); break;
445 case 23: _t->beforeRendering(); break;
446 case 24: _t->renderVideo(); break;
447 case 25: _t->onFrameDisplayed((*reinterpret_cast< std::add_pointer_t<SharedFrame>>(_a[1]))); break;
448 case 26: _t->resizeVideo((*reinterpret_cast< std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast< std::add_pointer_t<int>>(_a[2]))); break;
449 case 27: _t->onRefreshTimeout(); break;
450 default: ;
451 }
452 } else if (_c == QMetaObject::IndexOfMethod) {
453 int *result = reinterpret_cast<int *>(_a[0]);
454 {
455 using _t = void (VideoWidget::*)(const SharedFrame & );
456 if (_t _q_method = &VideoWidget::frameDisplayed; *reinterpret_cast<_t *>(_a[1]) == _q_method) {
457 *result = 0;
458 return;
459 }
460 }
461 {
462 using _t = void (VideoWidget::*)();
463 if (_t _q_method = &VideoWidget::dragStarted; *reinterpret_cast<_t *>(_a[1]) == _q_method) {
464 *result = 1;
465 return;
466 }
467 }
468 {
469 using _t = void (VideoWidget::*)(int );
470 if (_t _q_method = &VideoWidget::seekTo; *reinterpret_cast<_t *>(_a[1]) == _q_method) {
471 *result = 2;
472 return;
473 }
474 }
475 {
476 using _t = void (VideoWidget::*)();
477 if (_t _q_method = &VideoWidget::gpuNotSupported; *reinterpret_cast<_t *>(_a[1]) == _q_method) {
478 *result = 3;
479 return;
480 }
481 }
482 {
483 using _t = void (VideoWidget::*)();
484 if (_t _q_method = &VideoWidget::started; *reinterpret_cast<_t *>(_a[1]) == _q_method) {
485 *result = 4;
486 return;
487 }
488 }
489 {
490 using _t = void (VideoWidget::*)();
491 if (_t _q_method = &VideoWidget::paused; *reinterpret_cast<_t *>(_a[1]) == _q_method) {
492 *result = 5;
493 return;
494 }
495 }
496 {
497 using _t = void (VideoWidget::*)();
498 if (_t _q_method = &VideoWidget::playing; *reinterpret_cast<_t *>(_a[1]) == _q_method) {
499 *result = 6;
500 return;
501 }
502 }
503 {
504 using _t = void (VideoWidget::*)();
505 if (_t _q_method = &VideoWidget::rectChanged; *reinterpret_cast<_t *>(_a[1]) == _q_method) {
506 *result = 7;
507 return;
508 }
509 }
510 {
511 using _t = void (VideoWidget::*)();
512 if (_t _q_method = &VideoWidget::gridChanged; *reinterpret_cast<_t *>(_a[1]) == _q_method) {
513 *result = 8;
514 return;
515 }
516 }
517 {
518 using _t = void (VideoWidget::*)();
519 if (_t _q_method = &VideoWidget::zoomChanged; *reinterpret_cast<_t *>(_a[1]) == _q_method) {
520 *result = 9;
521 return;
522 }
523 }
524 {
525 using _t = void (VideoWidget::*)(const QPoint & );
526 if (_t _q_method = &VideoWidget::offsetChanged; *reinterpret_cast<_t *>(_a[1]) == _q_method) {
527 *result = 10;
528 return;
529 }
530 }
531 {
532 using _t = void (VideoWidget::*)();
533 if (_t _q_method = &VideoWidget::imageReady; *reinterpret_cast<_t *>(_a[1]) == _q_method) {
534 *result = 12;
535 return;
536 }
537 }
538 {
539 using _t = void (VideoWidget::*)();
540 if (_t _q_method = &VideoWidget::snapToGridChanged; *reinterpret_cast<_t *>(_a[1]) == _q_method) {
541 *result = 13;
542 return;
543 }
544 }
545 {
546 using _t = void (VideoWidget::*)(bool );
547 if (_t _q_method = &VideoWidget::toggleZoom; *reinterpret_cast<_t *>(_a[1]) == _q_method) {
548 *result = 14;
549 return;
550 }
551 }
552 } else if (_c == QMetaObject::ReadProperty) {
553 auto *_t = static_cast<VideoWidget *>(_o);
554 (void)_t;
555 void *_v = _a[0];
556 switch (_id) {
557 case 0: *reinterpret_cast< QRectF*>(_v) = _t->rect(); break;
558 case 1: *reinterpret_cast< int*>(_v) = _t->grid(); break;
559 case 2: *reinterpret_cast< bool*>(_v) = _t->snapToGrid(); break;
560 case 3: *reinterpret_cast< float*>(_v) = _t->zoom(); break;
561 case 4: *reinterpret_cast< QPoint*>(_v) = _t->offset(); break;
562 default: break;
563 }
564 } else if (_c == QMetaObject::WriteProperty) {
565 } else if (_c == QMetaObject::ResetProperty) {
566 } else if (_c == QMetaObject::BindableProperty) {
567 }
568}
569
570const QMetaObject *Mlt::VideoWidget::metaObject() const
571{
572 return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
573}
574
575void *Mlt::VideoWidget::qt_metacast(const char *_clname)
576{
577 if (!_clname) return nullptr;
578 if (!strcmp(_clname, qt_meta_stringdata_CLASSMltSCOPEVideoWidgetENDCLASS.stringdata0))
579 return static_cast<void*>(this);
580 if (!strcmp(_clname, "Controller"))
581 return static_cast< Controller*>(this);
582 return QQuickWidget::qt_metacast(_clname);
583}
584
585int Mlt::VideoWidget::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
586{
587 _id = QQuickWidget::qt_metacall(_c, _id, _a);
588 if (_id < 0)
589 return _id;
590 if (_c == QMetaObject::InvokeMetaMethod) {
591 if (_id < 28)
592 qt_static_metacall(this, _c, _id, _a);
593 _id -= 28;
594 } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
595 if (_id < 28)
596 *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
597 _id -= 28;
598 }else if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
599 || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
600 || _c == QMetaObject::RegisterPropertyMetaType) {
601 qt_static_metacall(this, _c, _id, _a);
602 _id -= 5;
603 }
604 return _id;
605}
606
607// SIGNAL 0
608void Mlt::VideoWidget::frameDisplayed(const SharedFrame & _t1)
609{
610 void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
611 QMetaObject::activate(this, &staticMetaObject, 0, _a);
612}
613
614// SIGNAL 1
615void Mlt::VideoWidget::dragStarted()
616{
617 QMetaObject::activate(this, &staticMetaObject, 1, nullptr);
618}
619
620// SIGNAL 2
621void Mlt::VideoWidget::seekTo(int _t1)
622{
623 void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
624 QMetaObject::activate(this, &staticMetaObject, 2, _a);
625}
626
627// SIGNAL 3
628void Mlt::VideoWidget::gpuNotSupported()
629{
630 QMetaObject::activate(this, &staticMetaObject, 3, nullptr);
631}
632
633// SIGNAL 4
634void Mlt::VideoWidget::started()
635{
636 QMetaObject::activate(this, &staticMetaObject, 4, nullptr);
637}
638
639// SIGNAL 5
640void Mlt::VideoWidget::paused()
641{
642 QMetaObject::activate(this, &staticMetaObject, 5, nullptr);
643}
644
645// SIGNAL 6
646void Mlt::VideoWidget::playing()
647{
648 QMetaObject::activate(this, &staticMetaObject, 6, nullptr);
649}
650
651// SIGNAL 7
652void Mlt::VideoWidget::rectChanged()
653{
654 QMetaObject::activate(this, &staticMetaObject, 7, nullptr);
655}
656
657// SIGNAL 8
658void Mlt::VideoWidget::gridChanged()
659{
660 QMetaObject::activate(this, &staticMetaObject, 8, nullptr);
661}
662
663// SIGNAL 9
664void Mlt::VideoWidget::zoomChanged()
665{
666 QMetaObject::activate(this, &staticMetaObject, 9, nullptr);
667}
668
669// SIGNAL 10
670void Mlt::VideoWidget::offsetChanged(const QPoint & _t1)
671{
672 void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
673 QMetaObject::activate(this, &staticMetaObject, 10, _a);
674}
675
676// SIGNAL 12
677void Mlt::VideoWidget::imageReady()
678{
679 QMetaObject::activate(this, &staticMetaObject, 12, nullptr);
680}
681
682// SIGNAL 13
683void Mlt::VideoWidget::snapToGridChanged()
684{
685 QMetaObject::activate(this, &staticMetaObject, 13, nullptr);
686}
687
688// SIGNAL 14
689void Mlt::VideoWidget::toggleZoom(bool _t1)
690{
691 void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
692 QMetaObject::activate(this, &staticMetaObject, 14, _a);
693}
694namespace {
695
696#ifdef QT_MOC_HAS_STRINGDATA
697struct qt_meta_stringdata_CLASSMltSCOPERenderThreadENDCLASS_t {};
698constexpr auto qt_meta_stringdata_CLASSMltSCOPERenderThreadENDCLASS = QtMocHelpers::stringData(
699 "Mlt::RenderThread"
700);
701#else // !QT_MOC_HAS_STRING_DATA
702struct qt_meta_stringdata_CLASSMltSCOPERenderThreadENDCLASS_t {
703 uint offsetsAndSizes[2];
704 char stringdata0[18];
705};
706#define QT_MOC_LITERAL(ofs, len) \
707 uint(sizeof(qt_meta_stringdata_CLASSMltSCOPERenderThreadENDCLASS_t::offsetsAndSizes) + ofs), len
708Q_CONSTINIT static const qt_meta_stringdata_CLASSMltSCOPERenderThreadENDCLASS_t qt_meta_stringdata_CLASSMltSCOPERenderThreadENDCLASS = {
709 {
710 QT_MOC_LITERAL(0, 17) // "Mlt::RenderThread"
711 },
712 "Mlt::RenderThread"
713};
714#undef QT_MOC_LITERAL
715#endif // !QT_MOC_HAS_STRING_DATA
716} // unnamed namespace
717
718Q_CONSTINIT static const uint qt_meta_data_CLASSMltSCOPERenderThreadENDCLASS[] = {
719
720 // content:
721 12, // revision
722 0, // classname
723 0, 0, // classinfo
724 0, 0, // methods
725 0, 0, // properties
726 0, 0, // enums/sets
727 0, 0, // constructors
728 0, // flags
729 0, // signalCount
730
731 0 // eod
732};
733
734Q_CONSTINIT const QMetaObject Mlt::RenderThread::staticMetaObject = { {
735 QMetaObject::SuperData::link<QThread::staticMetaObject>(),
736 qt_meta_stringdata_CLASSMltSCOPERenderThreadENDCLASS.offsetsAndSizes,
737 qt_meta_data_CLASSMltSCOPERenderThreadENDCLASS,
738 qt_static_metacall,
739 nullptr,
740 qt_incomplete_metaTypeArray<qt_meta_stringdata_CLASSMltSCOPERenderThreadENDCLASS_t,
741 // Q_OBJECT / Q_GADGET
742 QtPrivate::TypeAndForceComplete<RenderThread, std::true_type>
743 >,
744 nullptr
745} };
746
747void Mlt::RenderThread::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
748{
749 (void)_o;
750 (void)_id;
751 (void)_c;
752 (void)_a;
753}
754
755const QMetaObject *Mlt::RenderThread::metaObject() const
756{
757 return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
758}
759
760void *Mlt::RenderThread::qt_metacast(const char *_clname)
761{
762 if (!_clname) return nullptr;
763 if (!strcmp(_clname, qt_meta_stringdata_CLASSMltSCOPERenderThreadENDCLASS.stringdata0))
764 return static_cast<void*>(this);
765 return QThread::qt_metacast(_clname);
766}
767
768int Mlt::RenderThread::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
769{
770 _id = QThread::qt_metacall(_c, _id, _a);
771 return _id;
772}
773namespace {
774
775#ifdef QT_MOC_HAS_STRINGDATA
776struct qt_meta_stringdata_CLASSMltSCOPEFrameRendererENDCLASS_t {};
777constexpr auto qt_meta_stringdata_CLASSMltSCOPEFrameRendererENDCLASS = QtMocHelpers::stringData(
778 "Mlt::FrameRenderer",
779 "frameDisplayed",
780 "",
781 "SharedFrame",
782 "frame",
783 "imageReady",
784 "showFrame",
785 "Mlt::Frame"
786);
787#else // !QT_MOC_HAS_STRING_DATA
788struct qt_meta_stringdata_CLASSMltSCOPEFrameRendererENDCLASS_t {
789 uint offsetsAndSizes[16];
790 char stringdata0[19];
791 char stringdata1[15];
792 char stringdata2[1];
793 char stringdata3[12];
794 char stringdata4[6];
795 char stringdata5[11];
796 char stringdata6[10];
797 char stringdata7[11];
798};
799#define QT_MOC_LITERAL(ofs, len) \
800 uint(sizeof(qt_meta_stringdata_CLASSMltSCOPEFrameRendererENDCLASS_t::offsetsAndSizes) + ofs), len
801Q_CONSTINIT static const qt_meta_stringdata_CLASSMltSCOPEFrameRendererENDCLASS_t qt_meta_stringdata_CLASSMltSCOPEFrameRendererENDCLASS = {
802 {
803 QT_MOC_LITERAL(0, 18), // "Mlt::FrameRenderer"
804 QT_MOC_LITERAL(19, 14), // "frameDisplayed"
805 QT_MOC_LITERAL(34, 0), // ""
806 QT_MOC_LITERAL(35, 11), // "SharedFrame"
807 QT_MOC_LITERAL(47, 5), // "frame"
808 QT_MOC_LITERAL(53, 10), // "imageReady"
809 QT_MOC_LITERAL(64, 9), // "showFrame"
810 QT_MOC_LITERAL(74, 10) // "Mlt::Frame"
811 },
812 "Mlt::FrameRenderer",
813 "frameDisplayed",
814 "",
815 "SharedFrame",
816 "frame",
817 "imageReady",
818 "showFrame",
819 "Mlt::Frame"
820};
821#undef QT_MOC_LITERAL
822#endif // !QT_MOC_HAS_STRING_DATA
823} // unnamed namespace
824
825Q_CONSTINIT static const uint qt_meta_data_CLASSMltSCOPEFrameRendererENDCLASS[] = {
826
827 // content:
828 12, // revision
829 0, // classname
830 0, 0, // classinfo
831 3, 14, // methods
832 0, 0, // properties
833 0, 0, // enums/sets
834 0, 0, // constructors
835 0, // flags
836 2, // signalCount
837
838 // signals: name, argc, parameters, tag, flags, initial metatype offsets
839 1, 1, 32, 2, 0x06, 1 /* Public */,
840 5, 0, 35, 2, 0x06, 3 /* Public */,
841
842 // methods: name, argc, parameters, tag, flags, initial metatype offsets
843 6, 1, 36, 2, 0x02, 4 /* Public */,
844
845 // signals: parameters
846 QMetaType::Void, 0x80000000 | 3, 4,
847 QMetaType::Void,
848
849 // methods: parameters
850 QMetaType::Void, 0x80000000 | 7, 4,
851
852 0 // eod
853};
854
855Q_CONSTINIT const QMetaObject Mlt::FrameRenderer::staticMetaObject = { {
856 QMetaObject::SuperData::link<QThread::staticMetaObject>(),
857 qt_meta_stringdata_CLASSMltSCOPEFrameRendererENDCLASS.offsetsAndSizes,
858 qt_meta_data_CLASSMltSCOPEFrameRendererENDCLASS,
859 qt_static_metacall,
860 nullptr,
861 qt_incomplete_metaTypeArray<qt_meta_stringdata_CLASSMltSCOPEFrameRendererENDCLASS_t,
862 // Q_OBJECT / Q_GADGET
863 QtPrivate::TypeAndForceComplete<FrameRenderer, std::true_type>,
864 // method 'frameDisplayed'
865 QtPrivate::TypeAndForceComplete<void, std::false_type>,
866 QtPrivate::TypeAndForceComplete<const SharedFrame &, std::false_type>,
867 // method 'imageReady'
868 QtPrivate::TypeAndForceComplete<void, std::false_type>,
869 // method 'showFrame'
870 QtPrivate::TypeAndForceComplete<void, std::false_type>,
871 QtPrivate::TypeAndForceComplete<Mlt::Frame, std::false_type>
872 >,
873 nullptr
874} };
875
876void Mlt::FrameRenderer::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
877{
878 if (_c == QMetaObject::InvokeMetaMethod) {
879 auto *_t = static_cast<FrameRenderer *>(_o);
880 (void)_t;
881 switch (_id) {
882 case 0: _t->frameDisplayed((*reinterpret_cast< std::add_pointer_t<SharedFrame>>(_a[1]))); break;
883 case 1: _t->imageReady(); break;
884 case 2: _t->showFrame((*reinterpret_cast< std::add_pointer_t<Mlt::Frame>>(_a[1]))); break;
885 default: ;
886 }
887 } else if (_c == QMetaObject::IndexOfMethod) {
888 int *result = reinterpret_cast<int *>(_a[0]);
889 {
890 using _t = void (FrameRenderer::*)(const SharedFrame & );
891 if (_t _q_method = &FrameRenderer::frameDisplayed; *reinterpret_cast<_t *>(_a[1]) == _q_method) {
892 *result = 0;
893 return;
894 }
895 }
896 {
897 using _t = void (FrameRenderer::*)();
898 if (_t _q_method = &FrameRenderer::imageReady; *reinterpret_cast<_t *>(_a[1]) == _q_method) {
899 *result = 1;
900 return;
901 }
902 }
903 }
904}
905
906const QMetaObject *Mlt::FrameRenderer::metaObject() const
907{
908 return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
909}
910
911void *Mlt::FrameRenderer::qt_metacast(const char *_clname)
912{
913 if (!_clname) return nullptr;
914 if (!strcmp(_clname, qt_meta_stringdata_CLASSMltSCOPEFrameRendererENDCLASS.stringdata0))
915 return static_cast<void*>(this);
916 return QThread::qt_metacast(_clname);
917}
918
919int Mlt::FrameRenderer::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
920{
921 _id = QThread::qt_metacall(_c, _id, _a);
922 if (_id < 0)
923 return _id;
924 if (_c == QMetaObject::InvokeMetaMethod) {
925 if (_id < 3)
926 qt_static_metacall(this, _c, _id, _a);
927 _id -= 3;
928 } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
929 if (_id < 3)
930 *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
931 _id -= 3;
932 }
933 return _id;
934}
935
936// SIGNAL 0
937void Mlt::FrameRenderer::frameDisplayed(const SharedFrame & _t1)
938{
939 void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
940 QMetaObject::activate(this, &staticMetaObject, 0, _a);
941}
942
943// SIGNAL 1
944void Mlt::FrameRenderer::imageReady()
945{
946 QMetaObject::activate(this, &staticMetaObject, 1, nullptr);
947}
948QT_WARNING_POP
The SharedFrame provides thread safe access to Mlt::Frame data.
Definition sharedframe.h:49