From cb02e5ca6b67cb3a2a4aef6546bc1f9dfd9d33f9 Mon Sep 17 00:00:00 2001 From: Jerome Duval Date: Sat, 10 Jun 2017 23:13:41 +0200 Subject: [PATCH] qmplay2: add recipe for version 17.04.21. * unstable, video doesn't seem to work. --- .../qmplay2/patches/qmplay2-17.04.21.patchset | 893 ++++++++++++++++++ media-video/qmplay2/qmplay2-17.04.21.recipe | 81 ++ 2 files changed, 974 insertions(+) create mode 100644 media-video/qmplay2/patches/qmplay2-17.04.21.patchset create mode 100644 media-video/qmplay2/qmplay2-17.04.21.recipe diff --git a/media-video/qmplay2/patches/qmplay2-17.04.21.patchset b/media-video/qmplay2/patches/qmplay2-17.04.21.patchset new file mode 100644 index 000000000..dc638e8d5 --- /dev/null +++ b/media-video/qmplay2/patches/qmplay2-17.04.21.patchset @@ -0,0 +1,893 @@ +From d6124aea2107519f759dc7ff90902f6ceb58c585 Mon Sep 17 00:00:00 2001 +From: Gerasim Troeglazov <3dEyes@gmail.com> +Date: Tue, 13 Oct 2015 02:56:37 +0000 +Subject: Add haiku support + + +diff --git a/haiku/QMPlay2.rdef b/haiku/QMPlay2.rdef +new file mode 100644 +index 0000000..e70bab0 +--- /dev/null ++++ b/haiku/QMPlay2.rdef +@@ -0,0 +1,42 @@ ++resource app_signature "application/x-vnd.QMPlay2"; ++resource app_flags B_MULTIPLE_LAUNCH; ++resource app_version { ++ major = 17, ++ middle = 04, ++ minor = 21, ++ ++ /* Application "variety" can be set to one of the following: ++ * B_APPV_DEVELOPMENT, ++ * B_APPV_ALPHA, ++ * B_APPV_BETA, ++ * B_APPV_GAMMA, ++ * B_APPV_GOLDEN_MASTER, ++ * B_APPV_FINAL ++ */ ++ variety = B_APPV_DEVELOPMENT, ++ internal = 0, ++ ++ short_info = "QMPlay2", ++ long_info = "QMPlay2 © 2010-2017 Błażej Szczygieł" ++}; ++ ++resource file_types message { ++ "types" = "video", ++ "types" = "audio" ++}; ++ ++resource vector_icon array { ++ $"6E63696602012C165AF20314D77803000DB4D0B47BB4D0B47BB5A4B493B717B5" ++ $"6DB659B515BCBFB846C814BDF0C26CBB17C8CEBE53CA3FBF23C99BBE9CCA9ABF" ++ $"6BCA35C053CA92C00FC985C0E0C7E7C196C8ADC12DC276C452B78EC9BFBD01C7" ++ $"06B6C1CA20B523CAD9B601CAA4B4ACCAF9B426CA1EB421CA9DB41FC965B46DC7" ++ $"FBB44EC8B0B561C2E0B4A9B879B57FBD9BB485B770B428B55FB438B66BB41CB4" ++ $"F6B4D0B47BB466B48CB4D0B47B0209B627B6EDB6A3B714B640B838B6A7BACAB6" ++ $"89B97FB6F3BD1FB6E1C1D3B6F0BF7BB6D1C408B623C864B659C633B71AC816B8" ++ $"DBC716B7F4C787BC65C561C369C1D7BFF0C3ADC4D7C11DC7BDBFBFC64EC075C7" ++ $"1DBF3FC5A7BE96C65EBEEFC0EEBC47B790B783BC40B9E3B71CB7480209B627B6" ++ $"EDB640B838B6A3B714B790B783B71CB748BC40B9E3C5A7BE96C0EEBC47C65EBE" ++ $"EFC7BDBFBFC71DBF3FC64EC075C369C1D7C4D7C11DBFF0C3ADB8DBC716BC65C5" ++ $"61B7F4C787B623C864B71AC816B659C633B6E1C1D3B6D1C408B6F0BF7BB6A7BA" ++ $"CAB6F3BD1FB689B97F020A00020001000A01010200" ++}; +diff --git a/src/gui/Main.cpp b/src/gui/Main.cpp +index 2fcea50..0ba765c 100644 +--- a/src/gui/Main.cpp ++++ b/src/gui/Main.cpp +@@ -456,6 +456,9 @@ int main(int argc, char *argv[]) + signal(SIGTERM, signal_handler); + atexit(exitProcedure); + ++#ifdef Q_OS_HAIKU ++ setenv("HOME", "/boot/home", 1); ++#endif + #if defined(Q_OS_MAC) && (QT_VERSION >= QT_VERSION_CHECK(5, 6, 0)) + QGuiApplication::setAttribute(Qt::AA_EnableHighDpiScaling); + #endif +@@ -544,7 +547,7 @@ int main(int argc, char *argv[]) + } + if (!cmakeBuildFound) + { +-#if !defined Q_OS_WIN && !defined Q_OS_MAC && !defined Q_OS_ANDROID ++#if !defined Q_OS_WIN && !defined Q_OS_MAC && !defined Q_OS_ANDROID && !defined Q_OS_HAIKU + sharePath = QCoreApplication::applicationDirPath() + "/../share/qmplay2"; + libPath = QMPlay2CoreClass::getLibDir(); + if (libPath.isEmpty() || !QDir(libPath).exists("qmplay2")) +diff --git a/src/gui/MainWidget.cpp b/src/gui/MainWidget.cpp +index c64cba3..adf936d 100644 +--- a/src/gui/MainWidget.cpp ++++ b/src/gui/MainWidget.cpp +@@ -158,7 +158,7 @@ MainWidget::MainWidget(QPair &arguments) + setIconSize({22, 22}); + + SettingsWidget::InitSettings(); +-#ifndef Q_OS_ANDROID ++#if !defined Q_OS_ANDROID && !defined Q_OS_HAIKU + settings.init("MainWidget/WidgetsLocked", false); + #else + settings.init("MainWidget/WidgetsLocked", true); +diff --git a/src/gui/gui.pro b/src/gui/gui.pro +index 7abeac2..7afaf02 100644 +--- a/src/gui/gui.pro ++++ b/src/gui/gui.pro +@@ -12,7 +12,7 @@ TARGET = QMPlay2 + + QMAKE_LIBDIR += ../../app/lib + DESTDIR = ../../app/bin +-!android: LIBS += -lrt #For glibc < 2.17 ++!android:!haiku: LIBS += -lrt #For glibc < 2.17 + LIBS += -lqmplay2 + + RESOURCES += resources.qrc +diff --git a/src/modules/FFmpeg/FFmpeg.pro b/src/modules/FFmpeg/FFmpeg.pro +index 7939af0..f5f8f32 100644 +--- a/src/modules/FFmpeg/FFmpeg.pro ++++ b/src/modules/FFmpeg/FFmpeg.pro +@@ -27,7 +27,7 @@ DEPENDPATH += . ../../qmplay2/headers + HEADERS += FFmpeg.hpp FFDemux.hpp FFDec.hpp FFDecSW.hpp FFReader.hpp FFCommon.hpp FormatContext.hpp OggHelper.hpp OpenThr.hpp + SOURCES += FFmpeg.cpp FFDemux.cpp FFDec.cpp FFDecSW.cpp FFReader.cpp FFCommon.cpp FormatContext.cpp OggHelper.cpp OpenThr.cpp + +-unix:!android { ++unix:!android:!haiku { + PKGCONFIG += libavdevice + DEFINES += QMPlay2_libavdevice + +diff --git a/src/modules/MediaKit/MediaKit.cpp b/src/modules/MediaKit/MediaKit.cpp +new file mode 100644 +index 0000000..16e99c4 +--- /dev/null ++++ b/src/modules/MediaKit/MediaKit.cpp +@@ -0,0 +1,65 @@ ++#include ++#include ++ ++MediaKit::MediaKit() : ++ Module( "MediaKit" ) ++{ ++ m_icon = QIcon( ":/MediaKit" ); ++ ++ init( "WriterEnabled", true ); ++ init( "Delay", 0.2 ); ++} ++ ++QList< MediaKit::Info > MediaKit::getModulesInfo( const bool showDisabled ) const ++{ ++ QList< Info > modulesInfo; ++ if ( showDisabled || getBool( "WriterEnabled" ) ) ++ modulesInfo += Info( MediaKitWriterName, WRITER, QStringList( "audio" ) ); ++ return modulesInfo; ++} ++void *MediaKit::createInstance( const QString &name ) ++{ ++ if ( name == MediaKitWriterName && getBool( "WriterEnabled" ) ) ++ return new MediaKitWriter( *this ); ++ return NULL; ++} ++ ++MediaKit::SettingsWidget *MediaKit::getSettingsWidget() ++{ ++ return new ModuleSettingsWidget( *this ); ++} ++ ++QMPLAY2_EXPORT_MODULE( MediaKit ) ++ ++/**/ ++ ++#include ++#include ++#include ++#include ++ ++ModuleSettingsWidget::ModuleSettingsWidget( Module &module ) : ++ Module::SettingsWidget( module ) ++{ ++ enabledB = new QCheckBox( tr( "Włączony" ) ); ++ enabledB->setChecked( sets().getBool( "WriterEnabled" ) ); ++ ++ QLabel *delayL = new QLabel( tr( "Opóźnienie" ) + ": " ); ++ ++ delayB = new QDoubleSpinBox; ++ delayB->setRange( 0.01, 1.0 ); ++ delayB->setSingleStep( 0.01 ); ++ delayB->setSuffix( " " + tr( "sek" ) ); ++ delayB->setValue( sets().getDouble( "Delay" ) ); ++ ++ QGridLayout *layout = new QGridLayout( this ); ++ layout->addWidget( enabledB, 0, 0, 1, 2 ); ++ layout->addWidget( delayL, 1, 0, 1, 1 ); ++ layout->addWidget( delayB, 1, 1, 1, 1 ); ++} ++ ++void ModuleSettingsWidget::saveSettings() ++{ ++ sets().set( "WriterEnabled", enabledB->isChecked() ); ++ sets().set( "Delay", delayB->value() ); ++} +diff --git a/src/modules/MediaKit/MediaKit.hpp b/src/modules/MediaKit/MediaKit.hpp +new file mode 100644 +index 0000000..16920f6 +--- /dev/null ++++ b/src/modules/MediaKit/MediaKit.hpp +@@ -0,0 +1,31 @@ ++#include ++ ++class MediaKit : public Module ++{ ++public: ++ MediaKit(); ++private: ++ QList< Info > getModulesInfo( const bool ) const; ++ void *createInstance( const QString & ); ++ ++ SettingsWidget *getSettingsWidget(); ++}; ++ ++/**/ ++ ++#include ++ ++class QDoubleSpinBox; ++class QCheckBox; ++ ++class ModuleSettingsWidget : public Module::SettingsWidget ++{ ++ Q_DECLARE_TR_FUNCTIONS( ModuleSettingsWidget ) ++public: ++ ModuleSettingsWidget( Module & ); ++private: ++ void saveSettings(); ++ ++ QCheckBox *enabledB; ++ QDoubleSpinBox *delayB; ++}; +diff --git a/src/modules/MediaKit/MediaKit.png b/src/modules/MediaKit/MediaKit.png +new file mode 100644 +index 0000000000000000000000000000000000000000..36cb89c5e5200c5b613e4cf005b772df61aef49c +GIT binary patch +literal 5396 +zcmV+v73=DWP)1<6FprHd1$Uua_7y$_eS%QE%L=ndUbzGUafkzy0 +z5K$OpK;(=98j&Cv0xD}p1ci`D!UV`lmhMivtC#AkuH~(F{VCh!<^JyP-iCMN9eGFoKa2J^{{5-INx%uf9AG-o2*iOHPz16-C$JUR1Uv)0 +z4)}kA@xEmdz^TAZC=l{6+g{*0V8&Y=(EpYNq<~KVA46#xfD;$A^5ILDFn9KJCQhuS +zzCKB9Z8bI3Rd}AnvTQ8dp;&b2+@EIC=IuPZW*tvHy}tYk7x)k0TR_j@4D7E>Kojsq +z;8Q>qz(+1QgAXh{h52o>X_?hX#Lz(-ISj4huQu%3_az;jy{uXLdp`ZSn<^h#jB<}d +zlD`%Kao|h9SAx%6ckK!;Uj80tAJG(ak$+)GmEc7{QpGi}uRYB@_x*;ifAh}r!&d>f +zAId=g8U&nyGRqc#?_Pg77hZ5GGpD5(0r2_qmxfD}CP*dJJS!M~J$|69Pd;~nhVNkAO99{3!< +z)nB-fPyf@|Oq)6}04zcJNa@qHx0@X=ZDrdN>&b2Z(-^Nx;Z@HCq6oJOt+XZlX2Q{@ +zbNoeTan#9eM9e6lgC=!y+xItY!Fp%c{w2~#H;(L(~NB05zO +zotPmoghrK9VB*V9G2!uRxahXeGr74DG#v)|S@VNSIQKi@*i!t3*+GAc;4c8y0JXP& +z|1z#wxs=J1;vh?aO?qD^Pu#MG|Nhy}u=~4k>dt2S!f*4)30LyacX=3%D4#56~aH?@G>F)`q6JAYDAyWy@2W*m&o?cs@AhiR?T5YW_6!B)VKd +zcgZDf```sZQPTno5TFZcOr2`e7}EkG0WpTq&@`y(*v^Gj_t19Qe9#OS=x5*B%b9)! +zpz?&-z@CGFI9v<309Xa+k3D!5%a$IAh6R);W;6WpN5A8ZUq1qXck=agU3xuTP4gJ^ +zHS(^+@g!LfH4Q+hhJ?^SD1f@qh#5MjA&5tGOkH5=0z;_pgr=HTJCTm3x3lPEsU`+9 +zN^Q?JCRKOwn~exmD!uOQB;XX3*+(8*{g1r=jF!OU^W+Y6^Wyi{klVHqE!Ilp;}77T +zz8s=)Y)?{fCAKRmdJ@Bz6v{CYK+_ZfnnqM;L<|uU5H$o5QFZ~MM>LYA0zWwsp(d(R6H&n}rO;H6Aji~`9`w;PrF8*lBiMU>`w<}X +ziiAWQA>h1)VTZ+U2Lb;I%)fMb8!IlIgGLtoEOt6g&o7=J;-&Fte2(4^-GCFX#gh_U +z(=dca)XpbS>fZy9t@N* +zPVi>{pHHRWy04x%>Kj8b<+$>WYAvA*eCI@g-T? +zCzXhhvwa2)LE4ev2PmW*3XJ|}5_C-)W&R+MzK>f|4}K0b3xs;MsXpvQ5sjp;Gb!$qwR8rm +z3^FB;ld0u%hjK4 +zeNEFwn7`7#=lkeF1O#|09{{351SAiafF{(Emd{+#f-VL@ +zmhjU#@hvoRBy`b0= +zfOjigAT<5q_(Sa@C7$gl|3`wQzOS%=_~8=pMIip&Z?@6g=&SkOv*Cqp2n}`{EBS)H +z0ITFurLZpZQP_^M0+`-^F3_WSEa0= +zmE1~aHV{!kL}=7R1&(hpIT2xE-le8cPK^mkNN8|$m4=9FxF{;NnJ0r=Y2{DAG;kqu_e34x}Hh<2T +z?3A^k_I=;S^*n6XV`i)~$Vh##iU4GW2eJPP;CmTB7%lQguLUE%;q?KdWn{%B*|oySWLrnT^!%X +zwr%WUo`l`ck%b;a)@19%6L5U6JrB!vDA+cq9JLi>;QYA^0DZX-&)!2NU=c9qqsvpw +zo=IT-7QD6#G*~AtW1VJJ_-cjkdXV;2P)oT!gN`4%gXQ|zo@8oGgc?&PhRvjo7dR$j +zQ5#L+c^FevGr>BQPdplmQgV(YU%W<(?7ss+VX2vsWj2@8L +z1wii*0oxCifMo#Zystjcz6HH`7z9TX74inrS +zc0Y4Jsbm$-lqp!2MX{(%*Rm|6lsJyV;NT$HY?hv$9y&TYXm4+)>(5)LYG}psAaB{! +zckCo0_5dbioiLBsK4kbC4wZnV0P|Z>;H3i{fS%$N{iCcm;vgj{LE!&#L;@qjIV$bQ +z&>B2XGH7}9ba$bzyOUH+lp3>JO3MBL?b=4<2dB=d9v9o +z>2#WOI!$+XH(gy_^z`)LbnYfvm7+M128d6G1r4qSZj!Y&)e}6yebei7YUIqpR=xZZqCjoN+Ce}mfSH%QGbarb;Qf2DIe3hCxK~VF2iS7HizQmJ~ +zxG!;ii6bSp=hN(i<$JK$f@!lSGKsjRwk6y!>vigDf{J$mrF{){ +zcf&QS)b09uRS;-zZ;t}E0jG_JfH*)+RRA8qs70D3x0lUBaGP>5T#@369 +z`~vp%z|}uh-Qw|~6>v*S3%hph0yvLx5Ksh?mYpV1en+ed>Boq;<0~OXQ02a|*u^5W +z?;5l3xIkCPC(pl-8B@Nhz?Xmwpo8ndZEJ`6Rk~F3Eh}yyd&kq%*PtT46Tr|w3i!#Ruagj{xJtxF6Wm)`%+bFJWn;p +z^{8o{!=lf8?+}nL;Odn(v*U`dP!nUw@5^Hn@ZeK$)xQmY?D*r4r>?G!>gsCZ@i>NI +z;JRV8dQ@FtEIWA}*!$$OOz$`V)0$9uHhY+ss3Mgq(e1^`(8E%I3|R0hh(Jng&qGRy +z?Rv~OQV&(02(~@dszPE;g4Q&$tBF2 +zH;;}EwJ0cOmzhka+~uY55a0tp1-`N7aky$laMyVl5u3{ywcEJ2?^p#`As+?W3rxQZ +zT>8GM+_*l8qZZM6^?cI%c2VqZCzsEulDJU?iF$rFa~JQO`(t!-mojyO@@|M4nSjTh +zg{4;wAM~O{i#Ye(bHk#F5F%V$ZQHi3-0ks^U=MacVg|4SF!sI((;86hi_4JFW&FJT +z-Mmzs7~mfb-1j^jUk(9xTx{Q`P_nRWhmvJeC|L{?OIRff9GmYLJ2`LmBh)2+t3XFk +zDOo)Dtd0Tk;8U>tOQQ$8YSk(l8X6cF7@)tupRTSh_V3@%&Ye41yLK(8x?l?<0^z|D +zy8+bsnuQZ5z-bFpsx;~zk(Iljvnk?cily6Yb(00 +z4{L^Duwlc7aw>ci@L%J#0DwsZQFG1R@PYTDOwa@THZad+hkFK3rCZogNQN5sg623b +zCC61|YsaBrIoOUvqEz4l+0H4(D;%46jF_=LoX^7+sURQ%JG<3Xw`!CD!_7C}%)*5W +zF-;RKD5IB`(Ob4`Vdct|Wren&Qm0|^X8Qs?sD1UPmt798{^4?tYFeW>@i)WZW@bBg +zFgvlBZ1u_Pc8{TBu!aMr82y&OMk26CdO0SMp-Hqe)!0r`@@XR4meKR4huS0534@*M +z!K2T^6}Jta=KQyCl_B#}rEjYcsHgIFwvZQDHhXjlxoZY=Qd<`z(v +zD}f&Zyt@8+j+(L)@^`Djx~PSSjhdg!e_e*=>vEF}kL2ZF_kzBXA>WU{z8u{41l;(m +z(F1C2ZKbWPjTtj$(A3mKDwPVSKGQT2Lh#F9{*oJSyb)AEbW!jtqhvgbyY(m|{rex@ +z^%M(Ey^wkHKL$=cSZTFeT%MmjMo(KKxB2~ms3NM0Q({$o$iZMhh#mw&? +z9S*v&v5|&`hA_wXg5089Jn=jaUDwexjTc{hk*|I2YoIj#LEfY!4u^hD@IAoO<%`>H +z{b!baU=dRr>k+;Ub`c60)iV2`Zy#jSkn4it02D27(%^&R!Oje9>V&mh;l7HzsHLTa +zcsxFANjp*u!yu7JkVqt`udgSSO3~5L!Rpnk%iu2o9{fvy4(FicB;XsU*kAxGS+an0 +z&soHA$4sXwRZYw<5_K}ftO4|a4szXHWV*ZQ>+7SpH_i4g_}R;_zJ2(Mo12@%GS+y+ +zFbv}HI6??IIy%Zlj{#sg@WgoD@m5ZX&Hz3RtRN_)9)`S%s@uPTs@|H1LPEJ<8qD*c +z%>Bc>$zI?{c{>hE3)CT`#i-L*^H3*ClBhhc6tqrMHnttLSGS(wJ2vN{s<%;4ZV-t? +z!g4tb6->vd5)YuJx?4F&wEw>%ZNRe(pF`fP?FGILjNflY$lv<0%H_8-jR3Y9eGE_EB^yvNfC*>uwT*u0000 ++#include ++ ++MediaKitWriter::MediaKitWriter( Module &module ) : ++ err( false ) ++{ ++ addParam( "delay" ); ++ addParam( "chn" ); ++ addParam( "rate" ); ++ ++ SetModule( module ); ++} ++ ++bool MediaKitWriter::set() ++{ ++ if ( player.delay != sets().getDouble( "Delay" ) ) ++ { ++ player.delay = sets().getDouble( "Delay" ); ++ return false; ++ } ++ return sets().getBool( "WriterEnabled" ); ++} ++ ++bool MediaKitWriter::readyWrite() const ++{ ++ return !err && player.isOpen(); ++} ++ ++bool MediaKitWriter::processParams( bool * ) ++{ ++ bool resetAudio = false; ++ ++ uchar chn = getParam( "chn" ).toUInt(); ++ if ( player.channels != chn ) ++ { ++ resetAudio = true; ++ player.channels = chn; ++ } ++ uint rate = getParam( "rate" ).toUInt(); ++ if ( player.sample_rate != rate ) ++ { ++ resetAudio = true; ++ player.sample_rate = rate; ++ } ++ ++ if ( resetAudio || err ) ++ { ++ player.stop(); ++ err = !player.start(); ++ if ( !err ) ++ modParam( "delay", player.delay ); ++ else ++ QMPlay2Core.logError( "MediaKitWriter :: " + tr ( "Nie można otworzyć strumienia wyjścia dźwięku" ) ); ++ } ++ ++ return readyWrite(); ++} ++qint64 MediaKitWriter::write( const QByteArray &arr ) ++{ ++ if ( !arr.size() || !readyWrite() ) ++ return 0; ++ ++ err = !player.write( arr ); ++ if ( err ) ++ { ++ QMPlay2Core.logError( "MediaKitWriter :: " + tr ( "Błąd podczas odtwarzania" ) ); ++ return 0; ++ } ++ ++ return arr.size(); ++} ++ ++qint64 MediaKitWriter::size() const ++{ ++ return -1; ++} ++QString MediaKitWriter::name() const ++{ ++ return MediaKitWriterName; ++} ++ ++bool MediaKitWriter::open() ++{ ++ return player.isOK(); ++} +diff --git a/src/modules/MediaKit/MediaKitWriter.hpp b/src/modules/MediaKit/MediaKitWriter.hpp +new file mode 100644 +index 0000000..28fa249 +--- /dev/null ++++ b/src/modules/MediaKit/MediaKitWriter.hpp +@@ -0,0 +1,30 @@ ++#include ++#include ++ ++#include ++ ++class MediaKitWriter : public Writer ++{ ++ Q_DECLARE_TR_FUNCTIONS( MediaKitWriter ) ++public: ++ MediaKitWriter( Module & ); ++private: ++ bool set(); ++ ++ bool readyWrite() const; ++ ++ bool processParams( bool *paramsCorrected ); ++ qint64 write( const QByteArray & ); ++ ++ qint64 size() const; ++ QString name() const; ++ ++ bool open(); ++ ++ /**/ ++ ++ SndPlayer player; ++ bool err; ++}; ++ ++#define MediaKitWriterName "MediaKit Writer" +diff --git a/src/modules/MediaKit/RingBuffer.cpp b/src/modules/MediaKit/RingBuffer.cpp +new file mode 100644 +index 0000000..915becc +--- /dev/null ++++ b/src/modules/MediaKit/RingBuffer.cpp +@@ -0,0 +1,129 @@ ++#include ++#include ++#include ++ ++#include "RingBuffer.hpp" ++ ++RingBuffer::RingBuffer( int size ) ++{ ++ initialized = false; ++ Buffer = new unsigned char[size]; ++ if(Buffer!=NULL) { ++ memset( Buffer, 0, size ); ++ BufferSize = size; ++ } else { ++ BufferSize = 0; ++ } ++ reader = 0; ++ writer = 0; ++ writeBytesAvailable = size; ++ if((locker=create_sem(1,"locker")) >= B_OK) { ++ initialized = true; ++ } else { ++ if(Buffer!=NULL) { ++ delete[] Buffer; ++ } ++ } ++} ++ ++RingBuffer::~RingBuffer( ) ++{ ++ if(initialized) { ++ delete[] Buffer; ++ delete_sem(locker); ++ } ++} ++ ++bool ++RingBuffer::Empty( void ) ++{ ++ memset( Buffer, 0, BufferSize ); ++ reader = 0; ++ writer = 0; ++ writeBytesAvailable = BufferSize; ++ return true; ++} ++ ++int ++RingBuffer::Read( unsigned char *data, int size ) ++{ ++ acquire_sem(locker); ++ ++ if( data == 0 || size <= 0 || writeBytesAvailable == BufferSize ) { ++ release_sem(locker); ++ return 0; ++ } ++ ++ int readBytesAvailable = BufferSize - writeBytesAvailable; ++ ++ if( size > readBytesAvailable ) { ++ size = readBytesAvailable; ++ } ++ ++ if(size > BufferSize - reader) { ++ int len = BufferSize - reader; ++ memcpy(data, Buffer + reader, len); ++ memcpy(data + len, Buffer, size-len); ++ } else { ++ memcpy(data, Buffer + reader, size); ++ } ++ ++ reader = (reader + size) % BufferSize; ++ writeBytesAvailable += size; ++ ++ release_sem(locker); ++ return size; ++} ++ ++int ++RingBuffer::Write( unsigned char *data, int size ) ++{ ++ acquire_sem(locker); ++ ++ if( data == 0 || size <= 0 || writeBytesAvailable == 0 ) { ++ release_sem(locker); ++ return 0; ++ } ++ ++ if( size > writeBytesAvailable ) { ++ size = writeBytesAvailable; ++ } ++ ++ if(size > BufferSize - writer) { ++ int len = BufferSize - writer; ++ memcpy(Buffer + writer, data, len); ++ memcpy(Buffer, data+len, size-len); ++ } else { ++ memcpy(Buffer + writer, data, size); ++ } ++ ++ writer = (writer + size) % BufferSize; ++ writeBytesAvailable -= size; ++ ++ release_sem(locker); ++ return size; ++} ++ ++int ++RingBuffer::GetSize( void ) ++{ ++ return BufferSize; ++} ++ ++int ++RingBuffer::GetWriteAvailable( void ) ++{ ++ return writeBytesAvailable; ++} ++ ++int ++RingBuffer::GetReadAvailable( void ) ++{ ++ return BufferSize - writeBytesAvailable; ++} ++ ++status_t ++RingBuffer::InitCheck( void ) ++{ ++ return initialized?B_OK:B_ERROR; ++} +diff --git a/src/modules/MediaKit/RingBuffer.hpp b/src/modules/MediaKit/RingBuffer.hpp +new file mode 100644 +index 0000000..4715632 +--- /dev/null ++++ b/src/modules/MediaKit/RingBuffer.hpp +@@ -0,0 +1,31 @@ ++#ifndef __RING_BUFFER_H__ ++#define __RING_BUFFER_H__ ++ ++#include ++ ++class RingBuffer { ++ ++public: ++ RingBuffer(int size); ++ ~RingBuffer(); ++ int Read( unsigned char* dataPtr, int numBytes ); ++ int Write( unsigned char *dataPtr, int numBytes ); ++ ++ bool Empty( void ); ++ int GetSize( ); ++ int GetWriteAvailable( ); ++ int GetReadAvailable( ); ++ status_t InitCheck( ); ++private: ++ unsigned char *Buffer; ++ int BufferSize; ++ int reader; ++ int writer; ++ int writeBytesAvailable; ++ ++ sem_id locker; ++ ++ bool initialized; ++}; ++ ++#endif +diff --git a/src/modules/MediaKit/SndPlayer.cpp b/src/modules/MediaKit/SndPlayer.cpp +new file mode 100644 +index 0000000..ca7ad89 +--- /dev/null ++++ b/src/modules/MediaKit/SndPlayer.cpp +@@ -0,0 +1,103 @@ ++#include ++ ++#include ++#include ++#include ++#include ++ ++ ++static void proc(void *cookie, void *buffer, size_t len, const media_raw_audio_format &format) ++{ ++ RingBuffer *ring = (RingBuffer*)cookie; ++ unsigned char* ptr = (unsigned char*)buffer; ++ ++ int readed = ring->Read(ptr,len); ++ ++ if(readed InitCheck() != B_OK) { ++ delete ring; ring = 0; ++ return false; ++ } ++ ++ player = new BSoundPlayer(&form, "QMPlay2_BSoundPlayer", proc, NULL, (void*)ring); ++ ++ if(player->InitCheck() != B_OK) { ++ delete player; ++ player = NULL; ++ return false; ++ } ++ ++ player->Start(); ++ player->SetHasData(true); ++ ++ _isOK = true; ++ ++ return player; ++} ++void SndPlayer::stop() ++{ ++ if ( player ) ++ { ++ if(player) { ++ player->Stop(); ++ delete player; ++ delete ring; ++ } ++ ++ player = NULL; ++ ring = NULL; ++ } ++} ++ ++double SndPlayer::getLatency() ++{ ++ double lat = player->Latency() / (ring->GetSize()*4.0); ++ ++ return lat; ++} ++ ++bool SndPlayer::write( const QByteArray &arr ) ++{ ++ int s = arr.size(); ++ while ( s > 0 && s % 4 ) ++ s--; ++ if ( s <= 0 ) ++ return false; ++ ++ int len=s; ++ ++ unsigned char *src_ptr = (unsigned char *)arr.data(); ++ ++ for(;;) { ++ int len2 = ring->Write(src_ptr,len); ++ if(len2 == len)break; ++ len -= len2; ++ src_ptr += len2; ++ snooze(100); ++ } ++ ++ return true; ++} +diff --git a/src/modules/MediaKit/SndPlayer.hpp b/src/modules/MediaKit/SndPlayer.hpp +new file mode 100644 +index 0000000..b0ca8c2 +--- /dev/null ++++ b/src/modules/MediaKit/SndPlayer.hpp +@@ -0,0 +1,49 @@ ++#ifndef PULSE_HPP ++#define PULSE_HPP ++ ++#include ++ ++#include ++ ++#include ++#include ++#include ++ ++#include "RingBuffer.hpp" ++ ++class SndPlayer ++{ ++public: ++ SndPlayer(); ++ inline ~SndPlayer() ++ { ++ stop(); ++ } ++ ++ inline bool isOK() const ++ { ++ return _isOK; ++ } ++ inline bool isOpen() const ++ { ++ return player; ++ } ++ ++ bool start(); ++ void stop(); ++ ++ double getLatency(); ++ ++ bool write( const QByteArray & ); ++ ++ double delay; ++ uchar channels; ++ uint sample_rate; ++ ++private: ++ bool _isOK; ++ BSoundPlayer *player; ++ RingBuffer *ring; ++}; ++ ++#endif +diff --git a/src/modules/MediaKit/icon.qrc b/src/modules/MediaKit/icon.qrc +new file mode 100644 +index 0000000..24b4ebd +--- /dev/null ++++ b/src/modules/MediaKit/icon.qrc +@@ -0,0 +1,3 @@ ++ ++ MediaKit.png ++ +diff --git a/src/modules/modules.pro b/src/modules/modules.pro +index 6e853ea..d0f6c21 100644 +--- a/src/modules/modules.pro ++++ b/src/modules/modules.pro +@@ -1,7 +1,7 @@ + TEMPLATE = subdirs + SUBDIRS = FFmpeg Inputs Modplug Playlists Subtitles QPainter Extensions Visualizations AudioFilters VideoFilters CUVID + +-!contains(QT_CONFIG, opengles1): SUBDIRS += OpenGL2 ++!contains(QT_CONFIG, opengles1):!haiku: SUBDIRS += OpenGL2 + else: message("OpenGL doesn't work with OpenGL|ES 1.0") + + !android: SUBDIRS += AudioCD Notify +@@ -10,11 +10,14 @@ linux*: { + !android: SUBDIRS += ALSA + else: SUBDIRS += OpenSLES + } ++haiku { ++ SUBDIRS += MediaKit ++} + else { + SUBDIRS += PortAudio + } + +-unix:!android { ++unix:!android:!haiku { + SUBDIRS += XVideo + + packagesExist(libpulse-simple): SUBDIRS += PulseAudio +diff --git a/src/qmplay2/QMPlay2Core.cpp b/src/qmplay2/QMPlay2Core.cpp +index 9506f86..2bb12ee 100644 +--- a/src/qmplay2/QMPlay2Core.cpp ++++ b/src/qmplay2/QMPlay2Core.cpp +@@ -167,7 +167,7 @@ void QMPlay2CoreClass::init(bool loadModules, bool modulesInSubdirs, const QStri + settingsDir = QCoreApplication::applicationDirPath() + "/settings/"; + else + { +-#if defined(Q_OS_WIN) ++#if defined(Q_OS_WIN) || defined(Q_OS_HAIKU) + settingsDir = QFileInfo(QSettings(QSettings::IniFormat, QSettings::UserScope, QString()).fileName()).absolutePath() + "/QMPlay2/"; + #elif defined(Q_OS_MAC) + settingsDir = Functions::cleanPath(QStandardPaths::standardLocations(QStandardPaths::DataLocation).value(0, settingsDir)); +@@ -363,6 +363,11 @@ QStringList QMPlay2CoreClass::getModules(const QString &type, int typeLen) const + #elif defined Q_OS_WIN + if (type == "videoWriters") + defaultModules << "OpenGL 2" << "DirectDraw"; ++#elif defined Q_OS_HAIKU ++ if ( type == "videoWriters" ) ++ defaultModules << "QPainter"; ++ else if ( type == "audioWriters" ) ++ defaultModules << "MediaKit"; + #endif + if (type == "decoders") + defaultModules << "FFmpeg Decoder"; +-- +2.12.2 + diff --git a/media-video/qmplay2/qmplay2-17.04.21.recipe b/media-video/qmplay2/qmplay2-17.04.21.recipe new file mode 100644 index 000000000..70b08e564 --- /dev/null +++ b/media-video/qmplay2/qmplay2-17.04.21.recipe @@ -0,0 +1,81 @@ +SUMMARY="A video and audio player which can play most formats and codecs" +DESCRIPTION="QMPlay2 is a video and audio player. It can play all formats \ +supported by ffmpeg, libmodplug (including J2B and SFX). It also supports \ +Audio CD, raw files and Rayman 2 music. It contains YouTube and Prostoplee\ +r browser." +HOMEPAGE="http://zaps166.sourceforge.net" +COPYRIGHT="2010-2017 Błażej Szczygieł" +LICENSE="GNU GPL v3" +REVISION="1" +SOURCE_URI="https://github.com/zaps166/QMPlay2/releases/download/$portVersion/QMPlay2-src-$portVersion.tar.xz" +CHECKSUM_SHA256="1a1d3910e28346febc7ef94dd3fcc3d7c0bde5e485114c744ada10647af31728" +SOURCE_DIR="QMPlay2-src-$portVersion" +PATCHES="qmplay2-$portVersion.patchset" + +ARCHITECTURES="!x86_gcc2 ?x86 ?x86_64" +SECONDARY_ARCHITECTURES="?x86" + +PROVIDES=" + qmplay2$secondaryArchSuffix = $portVersion + app:QMPlay2$secondaryArchSuffix = $portVersion + " +REQUIRES=" + haiku${secondaryArchSuffix} + lib:libass$secondaryArchSuffix + lib:libavcodec$secondaryArchSuffix + lib:libavformat$secondaryArchSuffix + lib:libavutil$secondaryArchSuffix + lib:libcddb$secondaryArchSuffix + lib:libcdio$secondaryArchSuffix + lib:libGL$secondaryArchSuffix + lib:libiconv$secondaryArchSuffix + lib:libQt5Core$secondaryArchSuffix + lib:libQt5DBus$secondaryArchSuffix + lib:libQt5Gui$secondaryArchSuffix + lib:libQt5Widgets$secondaryArchSuffix + lib:libswresample$secondaryArchSuffix + lib:libswscale$secondaryArchSuffix + lib:libtag$secondaryArchSuffix + " + +BUILD_REQUIRES=" + haiku${secondaryArchSuffix}_devel + devel:libass$secondaryArchSuffix + devel:libavcodec$secondaryArchSuffix + devel:libavformat$secondaryArchSuffix + devel:libavutil$secondaryArchSuffix + devel:libcddb$secondaryArchSuffix + devel:libcdio$secondaryArchSuffix + devel:libiconv$secondaryArchSuffix + devel:libQt5Core$secondaryArchSuffix + devel:libQt5DBus$secondaryArchSuffix + devel:libQt5Gui$secondaryArchSuffix + devel:libQt5Widgets$secondaryArchSuffix + devel:libswresample$secondaryArchSuffix + devel:libswscale$secondaryArchSuffix + devel:libtag$secondaryArchSuffix + " +BUILD_PREREQUIRES=" + cmd:qmake$secondaryArchSuffix + cmd:make + cmd:gcc$secondaryArchSuffix + cmd:pkg_config$secondaryArchSuffix + " + +BUILD() +{ + qmake . + make $jobArgs +} + +INSTALL() +{ + mkdir -p $appsDir/QMPlay2 + + cp app/bin/QMPlay2 $appsDir/QMPlay2 + cp -R app/lib $appsDir/QMPlay2 + mv $appsDir/QMPlay2/lib/qmplay2/modules $appsDir/QMPlay2/ + + addResourcesToBinaries haiku/QMPlay2.rdef $appsDir/QMPlay2/QMPlay2 + addAppDeskbarSymlink $appsDir/QMPlay2/QMPlay2 QMPlay2 +}