~ubuntu-branches/ubuntu/karmic/recordmydesktop/karmic

« back to all changes in this revision

Viewing changes to src/rmd_encode_sound_buffer.c

  • Committer: Bazaar Package Importer
  • Author(s): Alan Pope
  • Date: 2009-04-21 10:57:22 UTC
  • mfrom: (1.1.5 upstream)
  • Revision ID: james.westby@ubuntu.com-20090421105722-w6l4gz958gva15wn
Tags: 0.3.8.1-0ubuntu1
* New upstream release (LP: #364674)
* debian/control: Fixed libjack0.100.0-dev dependancy
* debian/control: Fixed project home page

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
/******************************************************************************
 
2
*                            recordMyDesktop                                  *
 
3
*******************************************************************************
 
4
*                                                                             *
 
5
*            Copyright (C) 2006,2007,2008 John Varouhakis                     *
 
6
*                                                                             *
 
7
*                                                                             *
 
8
*   This program is free software; you can redistribute it and/or modify      *
 
9
*   it under the terms of the GNU General Public License as published by      *
 
10
*   the Free Software Foundation; either version 2 of the License, or         *
 
11
*   (at your option) any later version.                                       *
 
12
*                                                                             *
 
13
*   This program is distributed in the hope that it will be useful,           *
 
14
*   but WITHOUT ANY WARRANTY; without even the implied warranty of            *
 
15
*   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the             *
 
16
*   GNU General Public License for more details.                              *
 
17
*                                                                             *
 
18
*   You should have received a copy of the GNU General Public License         *
 
19
*   along with this program; if not, write to the Free Software               *
 
20
*   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA  *
 
21
*                                                                             *
 
22
*                                                                             *
 
23
*                                                                             *
 
24
*   For further information contact me at johnvarouhakis@gmail.com            *
 
25
******************************************************************************/
 
26
 
 
27
#include "config.h"
 
28
#include "rmd_encode_sound_buffer.h"
 
29
 
 
30
#include "rmd_jack.h"
 
31
#include "rmd_types.h"
 
32
 
 
33
#include <pthread.h>
 
34
 
 
35
#include <stdlib.h>
 
36
#include <errno.h>
 
37
 
 
38
 
 
39
void *EncodeSoundBuffer(ProgData *pdata){
 
40
    int sampread=pdata->periodsize;
 
41
#ifdef HAVE_LIBJACK
 
42
    void *jackbuf=NULL;
 
43
    if(pdata->args.use_jack){
 
44
        jackbuf=malloc(pdata->sound_framesize*pdata->jdata->buffersize);
 
45
    }
 
46
#endif
 
47
    pdata->v_encoding_clean=0;
 
48
    while((pdata->running)){
 
49
        float **vorbis_buffer;
 
50
        int count=0,i,j;
 
51
        SndBuffer *buff=NULL;
 
52
 
 
53
        if (pdata->paused) {
 
54
            pthread_mutex_lock(&pdata->pause_mutex);
 
55
            pthread_cond_wait(&pdata->pause_cond, &pdata->pause_mutex);
 
56
            pthread_mutex_unlock(&pdata->pause_mutex);
 
57
        }
 
58
        if(!pdata->args.use_jack){
 
59
            if(pdata->sound_buffer==NULL){
 
60
                pdata->v_enc_thread_waiting=1;
 
61
                pthread_mutex_lock(&pdata->snd_buff_ready_mutex);
 
62
                pthread_cond_wait(&pdata->sound_data_read,
 
63
                                &pdata->snd_buff_ready_mutex);
 
64
                pthread_mutex_unlock(&pdata->snd_buff_ready_mutex);
 
65
                pdata->v_enc_thread_waiting=0;
 
66
            }
 
67
            if(pdata->sound_buffer==NULL || !pdata->running)
 
68
                break;
 
69
            pthread_mutex_lock(&pdata->sound_buffer_mutex);
 
70
            buff=pdata->sound_buffer;
 
71
            //advance the list
 
72
            pdata->sound_buffer=pdata->sound_buffer->next;
 
73
            pthread_mutex_unlock(&pdata->sound_buffer_mutex);
 
74
 
 
75
            vorbis_buffer=vorbis_analysis_buffer(&pdata->enc_data->m_vo_dsp,
 
76
                                                 sampread);
 
77
 
 
78
            for(i=0;i<sampread;i++){
 
79
                for(j=0;j<pdata->args.channels;j++){
 
80
                    vorbis_buffer[j][i]=((buff->data[count+1]<<8)|
 
81
                                        (0x00ff&(int)buff->data[count]))/
 
82
                                        32768.f;
 
83
                    count+=2;
 
84
                }
 
85
            }
 
86
            free(buff->data);
 
87
            free(buff);
 
88
        }
 
89
        else{
 
90
#ifdef HAVE_LIBJACK
 
91
            if((*jack_ringbuffer_read_space)(pdata->jdata->sound_buffer)>=
 
92
               (pdata->sound_framesize*pdata->jdata->buffersize)){
 
93
                (*jack_ringbuffer_read)(pdata->jdata->sound_buffer,
 
94
                                          jackbuf,
 
95
                                          (pdata->sound_framesize*
 
96
                                           pdata->jdata->buffersize));
 
97
                vorbis_buffer=vorbis_analysis_buffer(&pdata->enc_data->m_vo_dsp,
 
98
                                                    sampread);
 
99
                for(j=0;j<pdata->args.channels;j++){
 
100
                    for(i=0;i<sampread;i++){
 
101
                        vorbis_buffer[j][i]=((float*)jackbuf)[count];
 
102
                        count++;
 
103
                    }
 
104
                }
 
105
            }
 
106
            else{
 
107
                pdata->v_enc_thread_waiting=1;
 
108
                pthread_mutex_lock(&pdata->snd_buff_ready_mutex);
 
109
                pthread_cond_wait(&pdata->sound_data_read,
 
110
                                &pdata->snd_buff_ready_mutex);
 
111
                pthread_mutex_unlock(&pdata->snd_buff_ready_mutex);
 
112
                pdata->v_enc_thread_waiting=0;
 
113
                continue;
 
114
            }
 
115
#endif
 
116
        }
 
117
        vorbis_analysis_wrote(&pdata->enc_data->m_vo_dsp,sampread);
 
118
 
 
119
        pthread_mutex_lock(&pdata->libogg_mutex);
 
120
        while(vorbis_analysis_blockout(&pdata->enc_data->m_vo_dsp,
 
121
                                       &pdata->enc_data->m_vo_block)==1){
 
122
 
 
123
            vorbis_analysis(&pdata->enc_data->m_vo_block,NULL);
 
124
            vorbis_bitrate_addblock(&pdata->enc_data->m_vo_block);
 
125
 
 
126
            while(vorbis_bitrate_flushpacket(&pdata->enc_data->m_vo_dsp,
 
127
                                             &pdata->enc_data->m_ogg_pckt2)){
 
128
                ogg_stream_packetin(&pdata->enc_data->m_ogg_vs,
 
129
                                    &pdata->enc_data->m_ogg_pckt2);
 
130
            }
 
131
        }
 
132
        pthread_mutex_unlock(&pdata->libogg_mutex);
 
133
 
 
134
        pdata->avd-=pdata->periodtime;
 
135
 
 
136
 
 
137
    }
 
138
 
 
139
    pdata->v_encoding_clean=1;
 
140
    pthread_mutex_lock(&pdata->vorbis_lib_mutex);
 
141
    pthread_cond_signal(&pdata->vorbis_lib_clean);
 
142
    pthread_mutex_unlock(&pdata->vorbis_lib_mutex);
 
143
    pthread_exit(&errno);
 
144
}
 
145
 
 
146
void SyncEncodeSoundBuffer(ProgData *pdata,signed char *buff){
 
147
    float **vorbis_buffer;
 
148
    int count=0,i,j;
 
149
    int sampread=(buff!=NULL)?pdata->periodsize:0;
 
150
 
 
151
    vorbis_buffer=vorbis_analysis_buffer(&pdata->enc_data->m_vo_dsp,sampread);
 
152
 
 
153
    if(!pdata->args.use_jack){
 
154
        for(i=0;i<sampread;i++){
 
155
            for(j=0;j<pdata->args.channels;j++){
 
156
                vorbis_buffer[j][i]=((buff[count+1]<<8)|
 
157
                                        (0x00ff&(int)buff[count]))/
 
158
                                    32768.f;
 
159
                count+=2;
 
160
            }
 
161
        }
 
162
    }
 
163
    else{
 
164
        for(j=0;j<pdata->args.channels;j++){
 
165
            for(i=0;i<sampread;i++){
 
166
                vorbis_buffer[j][i]=((float*)buff)[count];
 
167
                count++;
 
168
            }
 
169
        }
 
170
    }
 
171
 
 
172
    vorbis_analysis_wrote(&pdata->enc_data->m_vo_dsp,sampread);
 
173
 
 
174
    pthread_mutex_lock(&pdata->libogg_mutex);
 
175
    while(vorbis_analysis_blockout(&pdata->enc_data->m_vo_dsp,
 
176
                                   &pdata->enc_data->m_vo_block)==1){
 
177
 
 
178
        vorbis_analysis(&pdata->enc_data->m_vo_block,NULL);
 
179
        vorbis_bitrate_addblock(&pdata->enc_data->m_vo_block);
 
180
 
 
181
        while(vorbis_bitrate_flushpacket(&pdata->enc_data->m_vo_dsp,
 
182
                                         &pdata->enc_data->m_ogg_pckt2)){
 
183
            ogg_stream_packetin(&pdata->enc_data->m_ogg_vs,
 
184
                                &pdata->enc_data->m_ogg_pckt2);
 
185
        }
 
186
    }
 
187
    pthread_mutex_unlock(&pdata->libogg_mutex);
 
188
 
 
189
    if(!pdata->running)pdata->enc_data->m_ogg_vs.e_o_s=1;
 
190
 
 
191
    pdata->avd-=pdata->periodtime;
 
192
}
 
193