First version of VLC Phonon backend
[phonon:phonon-mplayer.git] / phonon-vlc / backend.cpp
1 /*
2  * VLC backend for the Phonon library
3  * Copyright (C) 2007-2008  Tanguy Krotoff <tkrotoff@gmail.com>
4  *
5  * This program is free software: you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License as published by
7  * the Free Software Foundation, either version 3 of the License, or
8  * (at your option) any later version.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
17  */
18
19 #include "backend.h"
20
21 #include "mediaobject.h"
22 #include "videowidget.h"
23 #include "audiooutput.h"
24
25 #include "vlcloader.h"
26
27 #include <QtCore/QByteArray>
28 #include <QtCore/QSet>
29 #include <QtCore/QVariant>
30 #include <QtCore/QtPlugin>
31
32 Q_EXPORT_PLUGIN2(phonon_vlc, Phonon::VLC::Backend);
33
34 namespace Phonon
35 {
36 namespace VLC
37 {
38
39 Backend::Backend(QObject * parent, const QVariantList &)
40         : QObject(parent) {
41
42         setProperty("identifier", QLatin1String("phonon_vlc"));
43         setProperty("backendName", QLatin1String("VLC"));
44         setProperty("backendComment", QLatin1String("VLC plugin for Phonon"));
45         setProperty("backendVersion", QLatin1String("0.1"));
46         setProperty("backendWebsite", QLatin1String("http://multimedia.kde.org/"));
47
48         qDebug() << "Using VLC version:" << "not yet implemented";
49
50         //Before everything else
51         //Create VLC instance through lazy initialization
52         VLCLoader::get();
53 }
54
55 Backend::~Backend() {
56         VLCLoader::get()->libvlc_release();
57 }
58
59 QObject * Backend::createObject(BackendInterface::Class c, QObject * parent, const QList<QVariant> & args) {
60         switch (c) {
61         case MediaObjectClass:
62                 return new MediaObject(parent);
63         /*case VolumeFaderEffectClass:
64                 return new VolumeFaderEffect(parent);
65         */
66         case AudioOutputClass:
67                 return new AudioOutput(parent);
68         /*case AudioDataOutputClass:
69                 return new AudioDataOutput(parent);
70         case VisualizationClass:
71                 return new Visualization(parent);
72         case VideoDataOutputClass:
73                 return new VideoDataOutput(parent);
74         case EffectClass: {
75                 Q_ASSERT(args.size() == 1);
76                 qDebug() << "creating Effect(" << args[0];
77                 Effect * effect = new Effect(args[0].toInt(), parent);
78                 if (effect->isValid()) {
79                         return effect;
80                 }
81                 delete effect;
82                 return NULL;
83         }*/
84         case VideoWidgetClass: {
85                 VideoWidget * videoWidget = new VideoWidget(qobject_cast<QWidget *>(parent));
86                 return videoWidget;
87         }
88         }
89         return NULL;
90 }
91
92 bool Backend::supportsVideo() const {
93         return true;
94 }
95
96 bool Backend::supportsOSD() const {
97         return true;
98 }
99
100 bool Backend::supportsFourcc(quint32 fourcc) const {
101         switch(fourcc) {
102         case 0x00000000:
103                 return true;
104         default:
105                 return false;
106         }
107 }
108
109 bool Backend::supportsSubtitles() const {
110         return true;
111 }
112
113 QStringList Backend::availableMimeTypes() const {
114         if (m_supportedMimeTypes.isEmpty()) {
115                 //Audio mime types
116                 m_supportedMimeTypes
117                         << "audio/mp3"
118                         << "audio/x-mp3"
119                         << "audio/wav"
120
121                         << "audio/mpeg"
122                         << "audio/x-ms-wma"
123                         << "audio/vnd.rn-realaudio"
124                         << "audio/x-wav";
125
126                 //Video mime types
127                 m_supportedMimeTypes
128                         << "video/mpg"
129                         << "video/avi"
130
131                         << "video/mpeg"
132                         << "video/mp4"
133                         << "video/quicktime"
134                         << "video/x-ms-wmv";
135         }
136
137         return m_supportedMimeTypes;
138 }
139
140 QList<int> Backend::objectDescriptionIndexes(ObjectDescriptionType type) const {
141         QList<int> list;
142
143         /*switch(type) {
144         case Phonon::AudioOutputDeviceType:
145                 break;
146         case Phonon::AudioCaptureDeviceType:
147                 break;
148         case Phonon::VideoOutputDeviceType:
149                 break;
150         case Phonon::VideoCaptureDeviceType:
151                 break;
152         case Phonon::VisualizationType:
153                 break;
154         case Phonon::AudioCodecType:
155                 break;
156         case Phonon::VideoCodecType:
157                 break;
158         case Phonon::ContainerFormatType:
159                 break;
160         case Phonon::EffectType:
161                 break;
162         }*/
163
164         return list;
165 }
166
167 QHash<QByteArray, QVariant> Backend::objectDescriptionProperties(ObjectDescriptionType type, int index) const {
168         QHash<QByteArray, QVariant> ret;
169
170         /*switch (type) {
171         case Phonon::AudioOutputDeviceType:
172                 break;
173         case Phonon::AudioCaptureDeviceType:
174                 break;
175         case Phonon::VideoOutputDeviceType:
176                 break;
177         case Phonon::VideoCaptureDeviceType:
178                 break;
179         case Phonon::VisualizationType:
180                 break;
181         case Phonon::AudioCodecType:
182                 break;
183         case Phonon::VideoCodecType:
184                 break;
185         case Phonon::ContainerFormatType:
186                 break;
187         case Phonon::EffectType:
188                 break;
189         }*/
190
191         return ret;
192 }
193
194 bool Backend::startConnectionChange(QSet<QObject *> nodes) {
195         Q_UNUSED(nodes);
196         // there's nothing we can do but hope the connection changes won't take too long so that buffers
197         // would underrun. But we should be pretty safe the way xine works by not doing anything here.
198         return true;
199 }
200
201 bool Backend::connectNodes(QObject * _source, QObject * _sink) {
202         return true;
203 }
204
205 bool Backend::disconnectNodes(QObject * _source, QObject * _sink) {
206         return true;
207 }
208
209 bool Backend::endConnectionChange(QSet<QObject *> nodes) {
210         return true;
211 }
212
213 void Backend::freeSoundcardDevices() {
214 }
215
216 QString Backend::toString() const {
217         return "VLC Phonon Backend by Tanguy Krotoff <tkrotoff@gmail.com>";
218 }
219
220 }}      //Namespace Phonon::VLC