← Back to branch summary

~ubuntu-branches/ubuntu/jaunty/avidemux/jaunty

« back to all changes in this revision

Viewing changes to avidemux/ADM_userInterfaces/ADM_QT4/ADM_dialog/Q_equaliser.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Alessio Treglia
  • Date: 2009-02-17 23:41:46 UTC
  • mfrom: (1.1.12 upstream)
  • Revision ID: james.westby@ubuntu.com-20090217234146-eakx254awuch4wgw
Tags: 1:2.4.4-0.0ubuntu1
* Merge from debian multimedia, Ubuntu remaining changes:
  - debian/control:
    + Build-Depends on newer libx264-dev.
    + Don't Build-Depends on ccache and libamrnb-dev.
    + Build-Depends on libpulse-dev.
    + Fixed small typo in avidemux description.
  - Don't use ccache.
  - Drop patch to fix build with newer x264, it has been merged by upstream.

Show diffs side-by-side

added added

removed removed

Lines of Context:
avidemux/ADM_userInterfaces/ADM_QT4/ADM_dialog/Q_equaliser.cpp
 
1
/***************************************************************************
 
2
                               Q_equaliser.cpp
 
3
                                                           ---------------
 
4
 
 
5
    begin                : Tue Oct 7 2008
 
6
    copyright            : (C) 2008 by mean/gruntster
 
7
 ***************************************************************************/
 
8
 
 
9
/***************************************************************************
 
10
 *                                                                         *
 
11
 *   This program is free software; you can redistribute it and/or modify  *
 
12
 *   it under the terms of the GNU General Public License as published by  *
 
13
 *   the Free Software Foundation; either version 2 of the License, or     *
 
14
 *   (at your option) any later version.                                   *
 
15
 *                                                                         *
 
16
 ***************************************************************************/
 
17
 
 
18
#include "config.h"
 
19
#include <string.h>
 
20
#include <stdio.h>
 
21
#include <math.h>
 
22
 
 
23
#include "ui_equaliser.h"
 
24
 
 
25
#include "default.h"
 
26
#include "ADM_toolkit/toolkit.hxx"
 
27
#include "ADM_assert.h"
 
28
#include "ADM_video/ADM_genvideo.hxx"
 
29
#include "avi_vars.h"
 
30
 
 
31
#include "DIA_flyDialog.h"
 
32
#include "DIA_flyDialogQt4.h"
 
33
#include "DIA_flyEqualiser.h"
 
34
#include "T_EqualiserPath.h"
 
35
#include "ADM_video/ADM_vidEqualizer.h"
 
36
#include "../ADM_toolkit/qtToolkit.h"
 
37
 
 
38
class Ui_equaliserWindow : public QDialog
 
39
{
 
40
        Q_OBJECT
 
41
 
 
42
private:
 
43
        int lock;
 
44
        flyEqualiser *flyDialog;
 
45
        ADM_QCanvas *canvas, *histInCanvas, *histOutCanvas;
 
46
        EqualiserPath *path;
 
47
        int _width, _height;
 
48
 
 
49
        void updateDisplay();
 
50
 
 
51
public:
 
52
        Ui_equaliserWindow(QWidget* parent, EqualizerParam *param, AVDMGenericVideoStream *in);
 
53
        ~Ui_equaliserWindow();
 
54
        void gather(EqualizerParam *param);
 
55
 
 
56
        Ui_EqualiserDialog ui;
 
57
 
 
58
private slots:
 
59
        void sliderUpdate(int value);
 
60
        void pointChanged(int pointIndex, int value);
 
61
 
 
62
        void slider1Changed(int value);
 
63
        void slider2Changed(int value);
 
64
        void slider3Changed(int value);
 
65
        void slider4Changed(int value);
 
66
        void slider5Changed(int value);
 
67
        void slider6Changed(int value);
 
68
        void slider7Changed(int value);
 
69
        void slider8Changed(int value);
 
70
 
 
71
        void spinBox1Changed(int value);
 
72
        void spinBox2Changed(int value);
 
73
        void spinBox3Changed(int value);
 
74
        void spinBox4Changed(int value);
 
75
        void spinBox5Changed(int value);
 
76
        void spinBox6Changed(int value);
 
77
        void spinBox7Changed(int value);
 
78
        void spinBox8Changed(int value);
 
79
};
 
80
 
 
81
Ui_equaliserWindow::Ui_equaliserWindow(QWidget* parent, EqualizerParam *param, AVDMGenericVideoStream *in) : QDialog(parent)
 
82
{
 
83
        ui.setupUi(this);
 
84
 
 
85
        _width = in->getInfo()->width;
 
86
        _height = in->getInfo()->height;
 
87
        lock = 0;
 
88
 
 
89
        canvas = new ADM_QCanvas(ui.frame, _width, _height);
 
90
        histInCanvas = new ADM_QCanvas(ui.histInFrame, 256, 128);
 
91
        histOutCanvas = new ADM_QCanvas(ui.histOutFrame, 256, 128);
 
92
 
 
93
        flyDialog = new flyEqualiser(_width, _height, in, canvas, ui.horizontalSlider);
 
94
        path = new EqualiserPath(ui.frame_4, flyDialog->crossSettings);
 
95
        path->setMinimumSize(ui.frame_4->width(), ui.frame_4->height());
 
96
        path->resize(ui.frame_4->width(), ui.frame_4->height());
 
97
 
 
98
        connect(ui.horizontalSlider, SIGNAL(valueChanged(int)), this, SLOT(sliderUpdate(int)));
 
99
        connect(path, SIGNAL(pointChanged(int, int)), this, SLOT(pointChanged(int, int)));
 
100
 
 
101
        connect(ui.horizontalSlider1, SIGNAL(valueChanged(int)), this, SLOT(slider1Changed(int)));
 
102
        connect(ui.horizontalSlider2, SIGNAL(valueChanged(int)), this, SLOT(slider2Changed(int)));
 
103
        connect(ui.horizontalSlider3, SIGNAL(valueChanged(int)), this, SLOT(slider3Changed(int)));
 
104
        connect(ui.horizontalSlider4, SIGNAL(valueChanged(int)), this, SLOT(slider4Changed(int)));
 
105
        connect(ui.horizontalSlider5, SIGNAL(valueChanged(int)), this, SLOT(slider5Changed(int)));
 
106
        connect(ui.horizontalSlider6, SIGNAL(valueChanged(int)), this, SLOT(slider6Changed(int)));
 
107
        connect(ui.horizontalSlider7, SIGNAL(valueChanged(int)), this, SLOT(slider7Changed(int)));
 
108
        connect(ui.horizontalSlider8, SIGNAL(valueChanged(int)), this, SLOT(slider8Changed(int)));
 
109
 
 
110
        connect(ui.spinBox1, SIGNAL(valueChanged(int)), this, SLOT(spinBox1Changed(int)));
 
111
        connect(ui.spinBox2, SIGNAL(valueChanged(int)), this, SLOT(spinBox2Changed(int)));
 
112
        connect(ui.spinBox3, SIGNAL(valueChanged(int)), this, SLOT(spinBox3Changed(int)));
 
113
        connect(ui.spinBox4, SIGNAL(valueChanged(int)), this, SLOT(spinBox4Changed(int)));
 
114
        connect(ui.spinBox5, SIGNAL(valueChanged(int)), this, SLOT(spinBox5Changed(int)));
 
115
        connect(ui.spinBox6, SIGNAL(valueChanged(int)), this, SLOT(spinBox6Changed(int)));
 
116
        connect(ui.spinBox7, SIGNAL(valueChanged(int)), this, SLOT(spinBox7Changed(int)));
 
117
        connect(ui.spinBox8, SIGNAL(valueChanged(int)), this, SLOT(spinBox8Changed(int)));
 
118
 
 
119
        ui.horizontalSlider->setMaximum(in->getInfo()->nb_frames);
 
120
 
 
121
        flyDialog->_cookie = this;
 
122
 
 
123
        for (int i = 0; i < 8; i++)
 
124
                pointChanged(i, param->_scaler[flyDialog->crossSettings[i]]);
 
125
 
 
126
        flyDialog->sliderChanged();
 
127
}
 
128
 
 
129
Ui_equaliserWindow::~Ui_equaliserWindow()
 
130
{
 
131
        delete flyDialog;
 
132
        delete path;
 
133
        delete canvas;
 
134
        delete histInCanvas;
 
135
        delete histOutCanvas;
 
136
}
 
137
 
 
138
void Ui_equaliserWindow::sliderUpdate(int value)
 
139
{
 
140
        flyDialog->sliderChanged();
 
141
        updateDisplay();
 
142
}
 
143
 
 
144
void Ui_equaliserWindow::pointChanged(int pointIndex, int value)
 
145
{
 
146
        QSlider *slider[] = {ui.horizontalSlider1, ui.horizontalSlider2, ui.horizontalSlider3, ui.horizontalSlider4,
 
147
                ui.horizontalSlider5, ui.horizontalSlider6, ui.horizontalSlider7, ui.horizontalSlider8};
 
148
 
 
149
        slider[pointIndex]->setValue(value);
 
150
        updateDisplay();
 
151
}
 
152
 
 
153
void Ui_equaliserWindow::slider1Changed(int value)
 
154
{
 
155
        ui.spinBox1->setValue(value);
 
156
        path->updatePoint(0, value);
 
157
}
 
158
 
 
159
void Ui_equaliserWindow::slider2Changed(int value)
 
160
{
 
161
        ui.spinBox2->setValue(value);
 
162
        path->updatePoint(1, value);
 
163
}
 
164
 
 
165
void Ui_equaliserWindow::slider3Changed(int value)
 
166
{
 
167
        ui.spinBox3->setValue(value);
 
168
        path->updatePoint(2, value);
 
169
}
 
170
 
 
171
void Ui_equaliserWindow::slider4Changed(int value)
 
172
{
 
173
        ui.spinBox4->setValue(value);
 
174
        path->updatePoint(3, value);
 
175
}
 
176
 
 
177
void Ui_equaliserWindow::slider5Changed(int value)
 
178
{
 
179
        ui.spinBox5->setValue(value);
 
180
        path->updatePoint(4, value);
 
181
}
 
182
 
 
183
void Ui_equaliserWindow::slider6Changed(int value)
 
184
{
 
185
        ui.spinBox6->setValue(value);
 
186
        path->updatePoint(5, value);
 
187
}
 
188
 
 
189
void Ui_equaliserWindow::slider7Changed(int value)
 
190
{
 
191
        ui.spinBox7->setValue(value);
 
192
        path->updatePoint(6, value);
 
193
}
 
194
 
 
195
void Ui_equaliserWindow::slider8Changed(int value)
 
196
{
 
197
        ui.spinBox8->setValue(value);
 
198
        path->updatePoint(7, value);
 
199
}
 
200
 
 
201
void Ui_equaliserWindow::spinBox1Changed(int value)
 
202
{
 
203
        ui.horizontalSlider1->setValue(value);
 
204
}
 
205
 
 
206
void Ui_equaliserWindow::spinBox2Changed(int value)
 
207
{
 
208
        ui.horizontalSlider2->setValue(value);
 
209
}
 
210
 
 
211
void Ui_equaliserWindow::spinBox3Changed(int value)
 
212
{
 
213
        ui.horizontalSlider3->setValue(value);
 
214
}
 
215
 
 
216
void Ui_equaliserWindow::spinBox4Changed(int value)
 
217
{
 
218
        ui.horizontalSlider4->setValue(value);
 
219
}
 
220
 
 
221
void Ui_equaliserWindow::spinBox5Changed(int value)
 
222
{
 
223
        ui.horizontalSlider5->setValue(value);
 
224
}
 
225
 
 
226
void Ui_equaliserWindow::spinBox6Changed(int value)
 
227
{
 
228
        ui.horizontalSlider6->setValue(value);
 
229
}
 
230
 
 
231
void Ui_equaliserWindow::spinBox7Changed(int value)
 
232
{
 
233
        ui.horizontalSlider7->setValue(value);
 
234
}
 
235
 
 
236
void Ui_equaliserWindow::spinBox8Changed(int value)
 
237
{
 
238
        ui.horizontalSlider8->setValue(value);
 
239
}
 
240
 
 
241
void Ui_equaliserWindow::updateDisplay()
 
242
{
 
243
        if (lock)
 
244
                return;
 
245
 
 
246
        lock++;
 
247
 
 
248
        flyDialog->download();
 
249
        flyDialog->process();
 
250
        flyDialog->display();
 
251
 
 
252
        histInCanvas->dataBuffer = (uint8_t*)flyDialog->histogramIn;
 
253
        histInCanvas->repaint();
 
254
 
 
255
        histOutCanvas->dataBuffer = (uint8_t*)flyDialog->histogramOut;
 
256
        histOutCanvas->repaint();
 
257
 
 
258
        lock--;
 
259
}
 
260
 
 
261
void Ui_equaliserWindow::gather(EqualizerParam *param)
 
262
{
 
263
        flyDialog->download();
 
264
        memcpy(param->_scaler, flyDialog->scaler, 256 * sizeof(int));
 
265
}
 
266
 
 
267
uint8_t flyEqualiser::upload(void)
 
268
{
 
269
        Ui_equaliserWindow *window = (Ui_equaliserWindow*)_cookie;
 
270
 
 
271
        window->ui.spinBox1->setValue(points[0]);
 
272
        window->ui.spinBox2->setValue(points[1]);
 
273
        window->ui.spinBox3->setValue(points[2]);
 
274
        window->ui.spinBox4->setValue(points[3]);
 
275
        window->ui.spinBox5->setValue(points[4]);
 
276
        window->ui.spinBox6->setValue(points[5]);
 
277
        window->ui.spinBox7->setValue(points[6]);
 
278
        window->ui.spinBox8->setValue(points[7]);
 
279
 
 
280
        buildScaler(points, scaler);
 
281
}
 
282
 
 
283
uint8_t flyEqualiser::download(void)
 
284
{
 
285
        Ui_equaliserWindow *window = (Ui_equaliserWindow*)_cookie;
 
286
 
 
287
        points[0] = window->ui.spinBox1->value();
 
288
        points[1] = window->ui.spinBox2->value();
 
289
        points[2] = window->ui.spinBox3->value();
 
290
        points[3] = window->ui.spinBox4->value();
 
291
        points[4] = window->ui.spinBox5->value();
 
292
        points[5] = window->ui.spinBox6->value();
 
293
        points[6] = window->ui.spinBox7->value();
 
294
        points[7] = window->ui.spinBox8->value();
 
295
 
 
296
        upload();
 
297
}
 
298
 
 
299
uint8_t DIA_getEqualizer(EqualizerParam *param, AVDMGenericVideoStream *in)
 
300
{
 
301
        uint8_t ret = 0;
 
302
 
 
303
        Ui_equaliserWindow dialog(qtLastRegisteredDialog(), param, in);
 
304
        qtRegisterDialog(&dialog);
 
305
 
 
306
        if(dialog.exec() == QDialog::Accepted)
 
307
        {
 
308
                dialog.gather(param); 
 
309
                ret = 1;
 
310
        }
 
311
 
 
312
        qtUnregisterDialog(&dialog);
 
313
 
 
314
        return ret;
 
315
}