Форум программистов, компьютерный форум, киберфорум
Наши страницы

C++

Войти
Регистрация
Восстановить пароль
 
Рейтинг: Рейтинг темы: голосов - 14, средняя оценка - 4.93
Fnatick
0 / 0 / 0
Регистрация: 15.09.2013
Сообщений: 25
#1

Наложение звукового эффекта на wav файл - C++

24.03.2014, 22:57. Просмотров 2366. Ответов 10
Метки нет (Все метки)

Надо на звуковой файл в формате waw, наложить звуковой эффект, может кто проконсультировать
0
Лучшие ответы (1)
Надоела реклама? Зарегистрируйтесь и она исчезнет полностью.
Similar
Эксперт
41792 / 34177 / 6122
Регистрация: 12.04.2006
Сообщений: 57,940
24.03.2014, 22:57
Здравствуйте! Я подобрал для вас темы с ответами на вопрос Наложение звукового эффекта на wav файл (C++):

Написать функцию вычисляющую амплитудный спектр отсчетов звукового сигнала формата WAV - C++
Нужно написать функцию вычисляющую амплитудный спектр отсчетов звукового сигнала формата WAV. Посоветуйте с чего начать выполнение задания,...

Создать wav файл имея raw файл с данными - C++ Builder
Всем хорошего настроения! Пишу программу для обработки аudio данных, и есть необходимость преобразовывать данные wav - чистые данные -...

Как из dll воспроизвести wav файл ? - C++ Builder
Подскажите пожалуйста, я создал свою dll и запихнул туда wav файл. Нигде не могу найти как этот файл из dll воспроизвести. Если можно,...

WAV файл как ресурс проекта - C++ Builder
Товарищи помогите, как мне сделать чтобы в моем проекте был wav файл, чтобы его программа не искала нигде в папке(на диске) при компилляции...

Как воспроизвести wav файл функцией PlaySound - C++ Builder
//--------------------------------------------------------------------------- #include <vcl.h> #pragma hdrstop #include...

Как воспроизвести .wav файл - Visual C++
Если пишу просто PlaySound("Sound.wav",NULL,SND_FILENAME | SND_ASYNC); Выдает ошибку error C2065: 'SND_FILENAME' : undeclared...

10
Croessmah
Ушел
Эксперт CЭксперт С++
13557 / 7707 / 872
Регистрация: 27.09.2012
Сообщений: 18,996
Записей в блоге: 3
Завершенные тесты: 1
24.03.2014, 22:59 #2
Цитата Сообщение от Fnatick Посмотреть сообщение
может кто проконсультировать
в чем конкретно?
1
Fnatick
0 / 0 / 0
Регистрация: 15.09.2013
Сообщений: 25
24.03.2014, 23:01  [ТС] #3
Ну конкретно каким способом наложить эффект, ну как я понимаю это через массив делать надо
0
Croessmah
Ушел
Эксперт CЭксперт С++
13557 / 7707 / 872
Регистрация: 27.09.2012
Сообщений: 18,996
Записей в блоге: 3
Завершенные тесты: 1
24.03.2014, 23:04 #4
Цитата Сообщение от Fnatick Посмотреть сообщение
Ну конкретно каким способом наложить эффект, ну как я понимаю это через массив делать надо
Ну если у Вас уже есть распакованные данные, то нужно их обработать соответствующим образом(что там за эффект не знаю). Если файл wav pcm, то особых сложностей с чтением файла не возникнет, хотя и тут лучше использовать ккакое-нибудь готовое решение. Опять же, всё зависит от средств, которые Вы используете.
1
Fnatick
0 / 0 / 0
Регистрация: 15.09.2013
Сообщений: 25
24.03.2014, 23:05  [ТС] #5
Нет я на самой первой стадии тобеж ничего нету , и нужно с чего то начать
0
Croessmah
Ушел
Эксперт CЭксперт С++
13557 / 7707 / 872
Регистрация: 27.09.2012
Сообщений: 18,996
Записей в блоге: 3
Завершенные тесты: 1
24.03.2014, 23:09 #6
Лучший ответ Сообщение было отмечено автором темы, экспертом или модератором как ответ
не лучший пример:
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include <bitset>
 
 
//TODO: Проверить очистку памяти
 
 
class Chunk {
public:
 
    typedef std::vector<char> STREAM ;
    //Из строки в int
    static unsigned int inline getIDByName ( const char * nameString ) {
        return * reinterpret_cast < const unsigned int * > ( nameString ) ;
    }
 
    //Из int в строку
    static std::string inline getNameByID ( unsigned int value ) {
        char * pNow = reinterpret_cast < char * > ( &value ) ;
        return std::string ( pNow , pNow + sizeof ( value ) ) ;
    }
 
    //Конструкторы
    Chunk () : data ( 0 , 0 , STREAM() ) {}
 
    Chunk ( int nameID , int size , const STREAM & dataStream ) : data(nameID,size,dataStream) {
    }
 
    std::string inline get_name ( ) const {
        return getNameByID ( data.name ) ;
    }
 
    unsigned int inline get_nameID ( ) const {
        return data.name ;
    }
    unsigned int inline get_size ( ) const {
        return data.size ;
    }
    void set_nameID ( unsigned int value ) {
        data.name = value ;
    }
    void set_size ( unsigned int value ) {
        data.size = value ;
        data.data.resize ( value ) ;
    }
    void set_stream ( const STREAM & value ) {
        data.data = value ;
        data.size = value.size ( ) ;
    }
    STREAM  get_data ( ) {
        return data.data ;
    }
 
private:
    struct chunk {
        unsigned int name ;
        unsigned int size ;
        STREAM data ;
        chunk ( int name_ , int size_ , const STREAM & data_ ) : name(name_), size(size_),data (data_) {
        }
    } ;
    chunk data ;
} ;
 
 
 
class WaveFile {
 
private:
    Chunk RIFF ;
    unsigned int RIFFTYPE ;
    struct fmt{
        unsigned short audioFormat ; //Если значение не равно 1 , значит используется какое-то сжатие. PCM == 1
        unsigned short numChannels ; //Количество каналов
        unsigned int sampleRate ; //Частота дискретизации
        unsigned int byteRate ; //Количество байт переданных за секунду воспроизведения
        unsigned short blockAlign ; //Количество байт для одного сэмпла, включая все каналы
        unsigned short bitsPerSample ; //Количество бит в сэмпле. Глубина звучания.
        unsigned short extraFmtBytes ; //Количество дополнительных байт
    };
    std::vector < Chunk > collection ;
 
public:
 
    //Конструктор, создание Wav файла
    WaveFile ( const std::string & filePath ) {
        std::ifstream iFile ( filePath, std::ios_base::binary ) ;
        unsigned int temp_riffNameId ;
        unsigned int temp_riffSize ;
 
        //RIFF
        iFile.read ( reinterpret_cast < char * > ( & temp_riffNameId ) , sizeof(temp_riffNameId ) );
        //Проверка на соответствие RIFF
        if(RIFF.getNameByID(temp_riffNameId) != "RIFF"){
            throw std::string("Error. Not RIFF");
        }
 
        //Размер
        iFile.read ( reinterpret_cast < char * > ( & temp_riffSize ) , sizeof(temp_riffSize ) );
 
        RIFF.set_nameID ( temp_riffNameId ) ;
        RIFF.set_size ( temp_riffSize ) ;
 
        iFile.read ( reinterpret_cast < char * > ( & RIFFTYPE ) , sizeof( RIFFTYPE ) );
        //Проверка на соответствие WAVE
        if(RIFF.getNameByID(RIFFTYPE) != "WAVE"){
            throw std::string("Error. Not WAVE");
        }
 
        while ( iFile.read ( reinterpret_cast < char * > ( & temp_riffNameId ) , sizeof(temp_riffNameId ) ) ) {
            iFile.read ( reinterpret_cast < char * > ( & temp_riffSize ) , sizeof(temp_riffSize ) );
            Chunk::STREAM vec ( temp_riffSize ) ;
            iFile.read ( reinterpret_cast < char * > ( & vec[0] ) , temp_riffSize );
            collection.push_back ( Chunk ( temp_riffNameId , temp_riffSize , vec ) ) ;
        }
    }
 
 
    static char* StreamToChar(const Chunk::STREAM &v_data){
        //int size = v_data.size();
 
        char *data = new char[v_data.size()];
 
        for(unsigned int i = 0; i<v_data.size(); ++i){
            data[i]=v_data[i];
        }
 
        return data;
    }
 
    static Chunk::STREAM CharsToStream (const char* data, int size){
        return Chunk::STREAM (data , data + size ) ;
    }
 
    fmt* CharsToFmt(char * data_){
        fmt *dat;
        return dat = reinterpret_cast<fmt* >(data_);
    }
 
    void ShowInfo ( std::ostream & out ) {
 
        out << RIFF.get_name ( ) << "\n"
            << RIFF.get_size ( ) << "\n"
            << Chunk::getNameByID ( RIFFTYPE ) << "\n" ;
        for ( std::vector < Chunk > :: const_iterator it = collection.begin ( ) ; it != collection.end ( ) ; ++it ) {
            out << it->get_name ( ) << "\n"
                << it->get_size ( ) << std :: endl ;
        }
        out<<std::endl;
 
        char *data = StreamToChar(collection[0].get_data());
        fmt * dat = CharsToFmt(data);
 
        out<<"audio format: "<<dat->audioFormat<<"\n"
            <<"num channels: "<<dat->numChannels<<"\n"
            <<"sample rate: "<<dat->sampleRate<<"\n"
            <<"byte rate: "<<dat->byteRate<<"\n"
            <<"block Align: "<<dat->blockAlign<<"\n"
            <<"bits per sample: "<<dat->bitsPerSample<<"\n"
            <<"extra fmt bytes: "<<dat->extraFmtBytes<<std::endl;
        delete[] data;
    }
 
 
    inline int getIndexChunkByName(const std::string & chunkName ){
        int num = -1;
        for(unsigned int i = 0; i<collection.size(); i++){
            if(collection[i].get_name()==chunkName){
                num = i;
                break;
            }
        }
        return num;
    }
 
    inline int getSizeAData(){
        int size = collection[getIndexChunkByName("data")].get_size();
        return size;
    }
 
    inline char* getAData() {
        //вытащить данные блока data и записать их в char*
        char *data = StreamToChar(collection[getIndexChunkByName("data")].get_data());
        return data;
 
    }
 
 
    void setAData(Chunk::STREAM data){
        collection[getIndexChunkByName("data")].set_stream(data);
    }
 
    //FMT!!!!!!!!!!!!!!!!!!!!!!
    void setFMTData(fmt * fmt){
        collection[getIndexChunkByName("fmt ")].set_stream(CharsToStream(reinterpret_cast<char*>(fmt), collection[getIndexChunkByName("fmt ")].get_size()));
 
    }
 
    void SaveADataInTxt(const std::string &nameFile){
        std::ofstream file(nameFile, std::ios_base::binary);
 
        const int size = getSizeAData();
        char *data = getAData();
        file.write(data, size);
        delete[] data;
        file.close();
    }
 
    void CreateAndWrite(const std::string &fileName){
        std::ofstream file(fileName, std::ios_base::binary);
        int size = collection.size();
 
        unsigned int temp_riffNameId = RIFF.get_nameID();
        unsigned int temp_riffSize = RIFF.get_size();
 
        file.write(reinterpret_cast<char*>(&temp_riffNameId), sizeof(temp_riffNameId));
        file.write(reinterpret_cast<char*>(&temp_riffSize), sizeof(temp_riffSize));
        file.write(reinterpret_cast<char*>(&RIFFTYPE), sizeof(RIFFTYPE));
 
        for(int i = 0 ; i < size ; i++ ){
 
            temp_riffNameId = collection[i].get_nameID();
            temp_riffSize = collection[i].get_size();
 
            file.write(reinterpret_cast<char*>(&temp_riffNameId), sizeof(temp_riffNameId));
            file.write(reinterpret_cast<char*>(&temp_riffSize), sizeof(temp_riffSize));
 
            char *data = StreamToChar(collection[i].get_data());
            file.write(data, temp_riffSize);
        }
        file.close();
    }
 
    //Обработка аудиоданных
 
 
    //усиление/ослабление/нормализация звука
 
    /*
    void SoundNormalization( unsigned short val , unsigned short bits_per_sample ){
        //TODO: нормализовать звук
        int MAX, MIN, SILENT;
 
        if(bits_per_sample == 16){ // Для 16-битного
            MAX = 32767;  // максимальное значение
            MIN = -32768; // минимальное значение
            SILENT = 0;   // точка тишины
        }
 
    }
    */
 
 
    void SoundEnhancement(unsigned short int k){
        //Проверить!!!!!!!!!!!
 
        char *data_ = StreamToChar(collection[0].get_data());
        fmt * dat = CharsToFmt(data_);
 
        char* data = getAData();
        unsigned int size = getSizeAData();
        char *pData = new char[size];
 
        short temp_sample;
        for(unsigned int i = 0; i<size; i+= dat->blockAlign){
 
            if(dat->blockAlign==2){
                temp_sample = 256*data[i]+data[i+1];
            }else if(dat->blockAlign==1){
                temp_sample = data[i];
            }
 
            temp_sample*=k;
 
            if(dat->blockAlign==2){
                pData[i]=temp_sample/256;
                pData[i+1]=temp_sample - 256*pData[i];
            }else if(dat->blockAlign==1){
                pData[i] = temp_sample;
            }
 
        }
 
        setAData(CharsToStream(pData, size));
        delete[] data_;
        delete[] data;
    }
 
    //Ослабление звука
    void AttenuatesTheSound(unsigned short int k){
        //Проверить!!!!!!!!!!!!!!!!!!
        if(k==0) throw std::string("Division by zero");
        char *data_ = StreamToChar(collection[0].get_data());
        fmt * dat = CharsToFmt(data_);
 
        char* data = getAData();
        unsigned int size = getSizeAData();
        char *pData = new char[size];
 
        short temp_sample;
        for(unsigned int i = 0; i<size; i+= dat->blockAlign){
 
            if(dat->blockAlign==2){
                temp_sample = 256*data[i]+data[i+1];
            }else if(dat->blockAlign==1){
                temp_sample = data[i]-128; //смещение точки тишины в область нулевых значений
            }
 
            temp_sample/=k;
 
            if(dat->blockAlign==2){
                pData[i]=temp_sample/256;
                pData[i+1]=temp_sample - 256*pData[i];
                //pData[i]=reinterpret_cast<char*>(temp_sample);
            }else if(dat->blockAlign==1){
                pData[i] = temp_sample+128; //обратное смещение точки тишины == 128
            }
 
        }
 
        setAData(CharsToStream(pData, size));
        delete[] data_;
        delete[] data;
    }
 
    //частота дискретизации
    void UpSampleRate(){//УВЕЛИЧЕНИЕ В 2 РАЗА
        //TODO: проверить и исправить несовпадение размер аудиоданных/2!!!!!!!!!
        Chunk::STREAM dataOld = collection[getIndexChunkByName("data")].get_data ( ) ;
        Chunk::STREAM fmtBuffer = collection[getIndexChunkByName("fmt ")].get_data ( ) ;
        fmt * pFMT = reinterpret_cast < fmt* > ( fmtBuffer.data ( ) ) ;
        Chunk::STREAM dataNew ( dataOld.size ( ) * 2 ) ;
 
        for ( size_t i = 0 , j = 0 ; i < dataOld.size ( ) ; i+=pFMT->blockAlign , j += pFMT->blockAlign * 2 ) {
            for ( size_t d = 0 ;   d < pFMT->blockAlign ; ++d ) {
                dataNew [ j + d ] = dataOld [ i + d ] ;
                dataNew [ j + d + pFMT->blockAlign ] = dataOld [ i + d ] ;
            }
        }
        setAData ( dataNew ) ;
        RIFF.set_size ( RIFF.get_size ( ) + ( dataNew.size ( ) - dataOld.size ( ) ) ) ;
        pFMT -> sampleRate *= 2 ;
        pFMT -> byteRate *= 2 ;
        setFMTData ( pFMT ) ;
    }
 
    short LinearInterpolation(const double x1, const short y1, const double x2, const short y2,const double x){
        return y1 + ((y2-y1)/(x2-x1))*(x-x1); //формула линейной интерполяции
    }
 
    //частота дискретизации
    void DownSampleRate(){//УМЕНЬШЕНИЕ В 2 РАЗА
        Chunk::STREAM dataOld = collection[getIndexChunkByName("data")].get_data ( ) ;
        Chunk::STREAM fmtBuffer = collection[getIndexChunkByName("fmt ")].get_data ( ) ;
        fmt * pFMT = reinterpret_cast < fmt* > ( fmtBuffer.data ( ) ) ;
        Chunk::STREAM dataNew ;
        dataNew.resize ( dataOld.size ( ) / 2 +  dataOld.size ( ) % 2 + pFMT->blockAlign )  ;
 
        for ( size_t i = 0 , j = 0 ; i < dataOld.size ( ) ; i+=pFMT->blockAlign * 2 , j+= pFMT->blockAlign) {
            for ( size_t d = 0 ;   d < pFMT->blockAlign ; ++d )
                dataNew [ j + d ] = dataOld [ i + d ] ;
            std::cout << dataOld.size ( ) << "\n" << dataNew.size ( ) << "\n" << i << "\n" << j << std ::endl ;
        }
 
        setAData ( dataNew ) ;
        RIFF.set_size ( RIFF.get_size ( ) + ( dataNew.size ( ) - dataOld.size ( ) ) ) ;
        pFMT -> sampleRate /= 2 ;
        pFMT -> byteRate /= 2 ;
        setFMTData ( pFMT ) ;
    }
 
 
 
    //методы сокрытия информации
    unsigned int inline XorShift( unsigned int &x, unsigned int &y, unsigned int &z, unsigned int &w ){
 
        unsigned int t;
        t = ( x ^ ( x << 11 ) );
        x = y; y = z; z = w;
        return(w=(w^(w>>19))^(t^(t>>8)));
    }
 
    unsigned int GenerationKey(unsigned int &x, unsigned int &y, unsigned int &z, unsigned int &w){//!!!!!
        return XorShift(x, y, z, w);
    }
    unsigned char* getBufferFromKey(unsigned int &value){//!!!!!
        return reinterpret_cast <unsigned char * > ( &value ) ;
    }
 
    void ImpositionOfNoise(){
        //зашумление аудиоданных и запись ключа в отдельный файл
        std::ofstream file("key.txt", std::ios_base::binary );
        unsigned int x = 0x440000A4;
        unsigned int y = 0x00127C00;
        unsigned int z = 0x0400FFA4;
        unsigned int w = 0x10235011;
 
        unsigned int keyUInt ;
        unsigned char * key ;
 
        int size = getSizeAData();
        char * data = getAData();
 
        for(int i = 0 ; i < size; i++){
            if ( i%4 == 0 ) {
                keyUInt = GenerationKey( x,y,z,w );
                key = getBufferFromKey ( keyUInt ) ;
            }
            data[i]^=key[i%4];
            file.write ( (char*)&key[i%4] , 1 ) ;
        }
        collection[getIndexChunkByName("data")].set_stream(CharsToStream(data, size));
 
    }
 
 
    void RemovingNoise(const std::string name){
        //Снятие шума
        std::ifstream file(name, std::ios_base::binary);
 
        int size = getSizeAData();
        char * data = getAData();
        //std::string key;
        char* key = new char[size];
        file.read(key, size);
 
        for(int i = 0 ; i < size; i++){
            data[i]^=key[i];//!!!!!
        }
        delete[] key;
        collection[getIndexChunkByName("data")].set_stream(CharsToStream(data, size));
    }
 
 
    /*
    void IntroductionTxtFile8bit(const std::string name){
        //Внедрить txt файла в 8битный wav, заменяются 2 младших бита
        //TODO: довести до ума
        std::ifstream file(name, std::ios_base::binary);
        int num_collection = getNumChunkData();
 
        char *data_ = StreamToChar(collection[0].get_data());
        fmt * dat = CharsToFmt(data_);
        //delete[] data_;
 
        char* data = getAData();
        int size = getSizeAData();
 
        char *f_data = new char[size];
        if(file){
            file.read(f_data, size);
 
            for(int i = 0, j = 0; i < size; i+= dat->blockAlign*4, j++){
                std::bitset<8> byte_1(data[i]);
                std::bitset<8> byte_2(data[i+1]);
                std::bitset<8> byte_3(data[i+2]);
                std::bitset<8> byte_4(data[i+3]);
 
                std::bitset<8> byte_from_file(f_data[j]);
 
                byte_1[6] = byte_from_file[0];
                byte_1[7] = byte_from_file[1];
 
                byte_2[6] = byte_from_file[2];
                byte_2[7] = byte_from_file[3];
 
                byte_3[6] = byte_from_file[4];
                byte_3[7] = byte_from_file[5];
 
                byte_4[6] = byte_from_file[6];
                byte_4[7] = byte_from_file[7];
 
                data[i] = static_cast<char>(byte_1.to_ulong());
                data[i+1] = static_cast<char>(byte_2.to_ulong());
                data[i+2] = static_cast<char>(byte_3.to_ulong());
                data[i+3] = static_cast<char>(byte_4.to_ulong());
            }
        }
        delete[] f_data;
        setAData(CharsToStream(data, size));
    }
 
 
 
    void ExtractionTxtFile8bit(){
        //TODO: Извлечь txt файл
        std::ofstream file("out_stego8bit.txt", std::ios_base::binary);
 
        char *data_ = StreamToChar(collection[0].get_data());
        fmt * dat = CharsToFmt(data_);
        //delete[] data_;
 
        int size = getSizeAData();
        char *data = getAData();
 
        char *f_data = new char[size];
        int i = 0, j = 0;
        //for(int i = 0, j = 0; i < size; i+= dat->bitsPerSample*4, j++){
        while(i<size){
 
            std::bitset<8> byte_1(data[i]);
            std::bitset<8> byte_2(data[i+1]);
            std::bitset<8> byte_3(data[i+2]);
            std::bitset<8> byte_4(data[i+3]);
 
            std::bitset<8> byte_from_file(f_data[j]);
 
            byte_from_file[0] = byte_1[6];
            byte_from_file[1] = byte_1[7];
 
            byte_from_file[2] = byte_2[6];
            byte_from_file[3] = byte_2[7];
 
            byte_from_file[4] = byte_3[6];
            byte_from_file[5] = byte_3[7];
 
            byte_from_file[6] = byte_4[6];
            byte_from_file[7] = byte_4[7];
 
            f_data[j] = static_cast<char>(byte_from_file.to_ulong());
 
            i+= dat->blockAlign*4;
            j++;
 
        }
        file.write(f_data, size);
 
        delete[] data;
        delete[] f_data;
 
 
    }
    */
 
    bool IntroductionFile( const std :: string &  fileName , size_t count_bit ) {
        std::ifstream file(fileName, std::ios_base::binary);
 
        Chunk::STREAM streamFmt ( collection[getIndexChunkByName("fmt ")].get_data ( ) ) ;
        fmt * pFmt = reinterpret_cast<fmt*>( &(streamFmt[0]) );
        Chunk::STREAM streamData ( collection[getIndexChunkByName("data")].get_data ( ) ) ;
        unsigned char * pData = reinterpret_cast<unsigned char*>( &(streamData[0]) );
 
        int bitPerSample = pFmt->bitsPerSample ;
        int samplesCount = streamData.size ( ) / bitPerSample ;
 
        file.seekg ( 0 , std::ios_base::end ) ;//Смещаем текущю позицию в файле в конец файла
        int fileSize = file.peek ( ) + 1 ;//Считываем текущую позицию
        unsigned int bitsInFile = fileSize * 8 ;
        if ( bitsInFile > ( samplesCount * count_bit ) ) {
            return false ;
        }
 
        unsigned char * pText = new unsigned char [ fileSize ] ;
        pText [ fileSize - 1 ] = 0 ;
        file.seekg ( 0 , std::ios_base::beg ) ;//Смещаем позицию в файле на начало
        file.read ( (char*)pText , fileSize - 1 ) ;
 
        unsigned char mask = -1 ; //Заполняем маску двоичными единицами
        mask <<= count_bit ;//Заполняем младшие биты маски нулями
        for ( int i = bitPerSample / 8 -1 , textPos = 0 ; i < samplesCount ; i += bitPerSample / 8 , textPos+=count_bit ){
            pData [ i ] &= mask ;//Последний байт семпла умножаем на маску
 
            int nowByte = textPos / 8 ;
            unsigned char mult = ( pText [ nowByte ] << ( textPos % 8 ) ) >> ( 8 - textPos % 8 ) ;
            if ( ( textPos % 8 + count_bit ) > 8 ) {
                unsigned char adv_mask = -1 ;
                adv_mask <<= ( textPos % 8 + count_bit ) - 8 ;
                adv_mask &= ( pText [ nowByte +1 ] >> ( 8 - ( ( textPos % 8 + count_bit ) - 8 ) ) );
                mult <<= ( textPos % 8 + count_bit ) - 8 ;
                mult &= adv_mask ;
            }
            pData [ i ] &= mult ;
        }
 
        delete [] pText ;
 
        return true ;
    }
} ;
 
 
 
 
 
int main(){
 
    try{
        WaveFile wf ( "16bit.wav" ) ;
        wf.ShowInfo ( std :: cout ) ;
 
        std::cout<<"\n\n"<<std::endl;
    //  wf.SaveADataInTxt("out.txt");
 
    //  wf.SoundEnhancement(4);
    //  wf.CreateAndWrite("tralala.wav");
    //  wf.AttenuatesTheSound(5);
    //  wf.CreateAndWrite("tralala.wav");
    //  wf.ImpositionOfNoise();
    //  wf.CreateAndWrite("tralala.wav");
        //wf.SaveADataInTxt("out_noise.txt");
 
 
        wf.DownSampleRate();
        wf.CreateAndWrite("sampleRate_down.wav");
        wf.ShowInfo(std::cout);
 
        std::cout<<"\n\n"<<std::endl;
 
 
 
        wf.UpSampleRate();
        wf.CreateAndWrite("sampleRate_up.wav");
        wf.ShowInfo(std::cout);
 
 
    //  wf.RemovingNoise("key.txt");
        //  wf.SaveADataInTxt("out_no_noise.txt");
    //  wf.CreateAndWrite("tralala_withoutnoise.wav");
 
        //wf.IntroductionTxtFile8bit("sli.txt");
        //wf.CreateAndWrite("sli.wav");
 
        //wf.ExtractionTxtFile8bit();
 
    }catch(std::string msg){
        std::cerr<<msg<<std::endl;
    };
 
}
тут чтение файла, запись, наложение шума, изменение рейтов, усиление звука. Более новую версию не нашел, потерялася походу
Когда-то писали с пользователем Darv1n. Может у него есть что поновее
2
Fnatick
0 / 0 / 0
Регистрация: 15.09.2013
Сообщений: 25
24.03.2014, 23:11  [ТС] #7
Ох сколько кода , ладно спасибо за пример , буду сидеть разбираться
0
Xaviichi
0 / 0 / 0
Регистрация: 20.12.2014
Сообщений: 18
22.12.2014, 18:58 #8
Croessmah,
не могли бы Вы сказать, в функции записи Вы каждый раз перезаписываете информацию в файл (в коде файл tralala.wav)?
0
Trisha Ray
80 / 0 / 0
Регистрация: 01.02.2012
Сообщений: 93
28.06.2015, 23:15 #9
Здравствуйте. Croessmah,

Не могли бы вы подсказать, как из значений получаемых в чанке дата получить сами значения амплитуд? Я получаю значения от 0 до 65 535.
Матлаб встроенной функцией показывает массив таких значений
-0,001373
-0,002441
-0,001983
-0,001403
-0,001861
-0,002502
Т.е. отрицательные и положительные значения приближенные к +-1.

Как их получить?
0
Croessmah
Ушел
Эксперт CЭксперт С++
13557 / 7707 / 872
Регистрация: 27.09.2012
Сообщений: 18,996
Записей в блоге: 3
Завершенные тесты: 1
30.06.2015, 06:49 #10
Цитата Сообщение от Trisha Ray Посмотреть сообщение
Как их получить?
Господи, неужели так тяжело додуматься, откуда берутся значения от -1 до 1?
конкретно для Вашего файла немного переделал функцию-член ShowInfo и main(для вывода в файл):
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
    void ShowInfo ( std::ostream & out ) {
 
        char *data = StreamToChar(collection[0].get_data());
        fmt * dat = CharsToFmt(data);
 
        out<<"audio format: "<<dat->audioFormat<<"\n"
            <<"num channels: "<<dat->numChannels<<"\n"
            <<"sample rate: "<<dat->sampleRate<<"\n"
            <<"byte rate: "<<dat->byteRate<<"\n"
            <<"block Align: "<<dat->blockAlign<<"\n"
            <<"bits per sample: "<<dat->bitsPerSample<<"\n"
            <<"extra fmt bytes: "<<dat->extraFmtBytes<<std::endl;
 
 
 
        //ВОТ ОНО
        Chunk::STREAM data_stream ( collection[getIndexChunkByName("data")].get_data() ) ;
 
        long double delim = 32768.0 ;
        for ( size_t i = 0 ; i < data_stream.size() ; i+=dat->bitsPerSample/8 )
        {
            int16_t * data16 = (int16_t*)&data_stream[i] ;
            out << std::fixed<<std::setprecision(15) << *data16/delim<< '\n' ;
        }
        //КОНЕЦ
 
        delete[] data;
    }
 
 
 
//...
 
 
 
int main(){
 
    try{
        WaveFile wf ( "1.wav" ) ;
        std::ofstream outFile ("info.txt") ;
        if ( outFile )
            wf.ShowInfo ( outFile ) ;
 
    }catch(std::string msg){
        std::cerr<<msg<<std::endl;
    };
 
}

Всё происходит здесь:
C++
1
2
3
4
5
6
7
8
9
10
        //ВОТ ОНО
        Chunk::STREAM data_stream ( collection[getIndexChunkByName("data")].get_data() ) ;
 
        long double delim = 32768.0 ;
        for ( size_t i = 0 ; i < data_stream.size() ; i+=dat->bitsPerSample/8 )
        {
            int16_t * data16 = (int16_t*)&data_stream[i] ;
            out << std::fixed<<std::setprecision(15) << *data16/delim<< '\n' ;
        }
        //КОНЕЦ
Заточено сугубо под файл с bits per sample равным 16 бит. Универсальное решение делайте сами.
Коротко: значение, которое можно поместить в 16 бит лежит в диапазоне от -32768 до +32767 (для знаковых чисел). Берем значение выборки соответствующей длины (16 бит в данном случае) и делим на 32768 ( max( abs(-32768), abs(32767) ) ). Всё!
Из вашего файла matlab_zn.txt:
-0,00137329101562500
-0,00244140625000000
-0,00198364257812500
-0,00140380859375000
-0,00186157226562500
-0,00250244140625000
-0,00256347656250000
-0,00198364257812500
-0,00122070312500000
-0,00189208984375000
из моего info.txt:
-0.001373291015625
-0.002441406250000
-0.001983642578125
-0.001403808593750
-0.001861572265625
-0.002502441406250
-0.002563476562500
-0.001983642578125
-0.001220703125000
-0.001892089843750
0
SeregaZ
0 / 0 / 0
Регистрация: 24.02.2015
Сообщений: 14
09.09.2016, 21:14 #11
а у меня похожая задача файл в памяти и имеет 15000 частоты дискретизации. как можно пересчитать значения пиков файла чтоб в итоге вышло 10400? нет ли каких-то формул расчета? bass.dll не предлагать. хотелось бы избежать геморроя с этими дллами...

Добавлено через 1 час 44 минуты
все. посидел покумекал и родил
0
09.09.2016, 21:14
MoreAnswers
Эксперт
37091 / 29110 / 5898
Регистрация: 17.06.2006
Сообщений: 43,301
09.09.2016, 21:14
Привет! Вот еще темы с ответами:

Получить массив double значений с использованием mmsystem и записать wav файл - C++ WinAPI
Здравствуйте. Очень нужна помощь. Я никогда не работала с windows библиотеками. Немного разобралась с записью звука и его выводом через...

Наложение фильтров на WAV файл - C++
Добрый вечер! Согласно заданию, надо было реализовать функцию, объединяющую два wav файла в один, путем добавления отсчетов второго в конец...

Наложение эффекта на изображение - C#
Всем доброго времени суток В pictutebox загружается картинка, после нажатия на кнопку происходит сканирование Подскажите...

Нарисовать спектр звукового wav файла - Delphi
Доброго времени суток! Подскажите пожалуйста! Мне необходимо на основании записанного wav файла, нарисовать (построить) спектр, как на...


Искать еще темы с ответами

Или воспользуйтесь поиском по форуму:
11
Ответ Создать тему
Опции темы

КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2017, vBulletin Solutions, Inc.