← Back to branch summary

~ubuntu-branches/ubuntu/hardy/avidemux/hardy

« back to all changes in this revision

Viewing changes to avidemux/ADM_audiocodec/ADM_codecwma.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Daniel T Chen
  • Date: 2006-12-15 17:13:20 UTC
  • mfrom: (1.1.6 upstream)
  • Revision ID: james.westby@ubuntu.com-20061215171320-w79pvpehxx2fr217
Tags: 1:2.3.0-0.0ubuntu1
* Merge from debian-multimedia.org, remaining Ubuntu change:
  - desktop file,
  - no support for ccache and make -j.
* Closes Ubuntu: #69614.

Show diffs side-by-side

added added

removed removed

Lines of Context:
avidemux/ADM_audiocodec/ADM_codecwma.cpp
34
34
 
35
35
#define _context ((AVCodecContext *)_contextVoid)
36
36
 
 
37
uint8_t scratchPad[SCRATCH_PAD_SIZE];
37
38
 
38
39
   uint8_t ADM_AudiocodecWMA::beginDecompress( void ) 
39
40
   {
50
51
       :  ADM_Audiocodec(fourcc)
51
52
 {
52
53
    _tail=_head=0;
53
 
    ADM_assert(fourcc==WAV_WMA);        
 
54
    ADM_assert(fourcc==WAV_WMA || fourcc==WAV_QDM2);    
54
55
    _contextVoid=(void *)avcodec_alloc_context();
55
56
    ADM_assert(_contextVoid);
56
57
    // Fills in some values...
57
58
    _context->sample_rate = info->frequency;
58
 
    
59
59
    _context->channels = info->channels;
60
 
    /*
61
 
    _context->bit_rate = info->byterate<<3; // byte -> bits
62
 
    */
63
 
//    _context->fourcc = fourcc;
64
 
    _context->block_align = info->blockalign;       // ...
65
 
    _context->codec_id = CODEC_ID_WMAV2;
66
 
    _blockalign=info->blockalign;
67
 
  
 
60
    _blockalign=_context->block_align = info->blockalign;
 
61
    _context->bit_rate = info->byterate*8;
 
62
    if(fourcc==WAV_WMA)
 
63
        _context->codec_id = CODEC_ID_WMAV2;
 
64
    else
 
65
        if(fourcc==WAV_QDM2)
 
66
        _context->codec_id = CODEC_ID_QDM2;
 
67
            else ADM_assert(0);
 
68
 
68
69
    _context->extradata=(void *)d;
69
70
    _context->extradata_size=(int)l;
70
 
 
71
71
    printf(" Using %ld bytes of extra header data\n",l);
72
72
    mixDump((uint8_t *)_context->extradata,_context->extradata_size);
73
73
 
74
 
   AVCodec *codec=avcodec_find_decoder(CODEC_ID_WMAV2);
75
 
   if(!codec) {GUI_Error_HIG("Internal error", "Cannot open WMA2 codec.");ADM_assert(0);} 
 
74
   AVCodec *codec=avcodec_find_decoder(_context->codec_id);
 
75
   if(!codec) {GUI_Error_HIG(_("Internal error"), _("Cannot open WMA2 codec."));ADM_assert(0);} 
76
76
    if (avcodec_open(_context, codec) < 0)
77
77
    {
78
78
        printf("\n WMA decoder init failed !\n");
79
79
        ADM_assert(0);
80
80
    }
 
81
    if(!_blockalign)
 
82
    { 
 
83
      if(_context->block_align) _blockalign=_context->block_align;
 
84
      else
 
85
      {
 
86
        printf("FFWMA : no blockalign taking 378\n");
 
87
        _blockalign=378;   
 
88
      }
 
89
    }
81
90
    printf("FFwma init successful (blockalign %d)\n",info->blockalign);
82
91
}
83
92
 ADM_AudiocodecWMA::~ADM_AudiocodecWMA()
89
98
/*-------------------------------------------------------------------------------------------------------------------------
90
99
-------------------------------------------------------------------------------------------------------------------------*/
91
100
 
92
 
uint8_t ADM_AudiocodecWMA::run( uint8_t * ptr, uint32_t nbIn, uint8_t * outptr,   uint32_t * nbOut)
 
101
uint8_t ADM_AudiocodecWMA::run(uint8_t *inptr, uint32_t nbIn, float *outptr, uint32_t *nbOut)
93
102
{
94
103
int out=0;
95
104
int max=0,pout=0;
 
105
int16_t *run16;
 
106
int nbChunk;
96
107
 
97
108
        *nbOut=0;
98
109
        // Shrink
104
115
        }
105
116
        //
106
117
        ADM_assert(nbIn+_tail<ADMWA_BUF);
107
 
        memcpy(_buffer+_tail,ptr,nbIn);
 
118
        memcpy(_buffer+_tail,inptr,nbIn);
108
119
        _tail+=nbIn;
109
 
        while(_tail-_head>_blockalign)
 
120
        while(_tail-_head>=_blockalign)
110
121
        {
111
 
                out=avcodec_decode_audio(_context,(int16_t *)outptr,&pout,_buffer+_head,_tail-_head);
112
 
                //printf("Align:%d In: %d out:%d\n",_blockalign,out,pout);
113
 
                if(out<0)
114
 
                {
115
 
                        printf( " *** WMA decoding error ***\n");
116
 
                        _head+=1; // Try skipping some bytes
117
 
                        continue;
118
 
                }
119
 
            
120
 
                _head+=out; // consumed bytes
121
 
                *nbOut+=pout;
122
 
                outptr+=pout;
123
 
 
 
122
          nbChunk=(_tail-_head)/_blockalign;
 
123
          pout=SCRATCH_PAD_SIZE;
 
124
          out=avcodec_decode_audio(_context,(int16_t *)scratchPad,
 
125
                                   &pout,_buffer+_head,nbChunk*_blockalign);
 
126
                
 
127
          if(out<0)
 
128
          {
 
129
            printf( " *** WMA decoding error (%u)***\n",_blockalign);
 
130
            _head+=1; // Try skipping some bytes
 
131
            continue;
 
132
          }
 
133
          if(pout>=SCRATCH_PAD_SIZE)
 
134
          {
 
135
            printf("Produced : %u, buffer %u,in%u\n",pout,SCRATCH_PAD_SIZE,_tail-_head);
 
136
            ADM_assert(0); 
 
137
          }
 
138
          _head+=out; // consumed bytes
 
139
          pout>>=1;
 
140
          *nbOut+=pout;
 
141
          run16=(int16_t *)scratchPad;
 
142
          for(int i=0;i<pout;i++)
 
143
          {
 
144
            *outptr++=((float)run16[i])/32767.;
 
145
          }
124
146
        }
 
147
        
 
148
        
 
149
        
125
150
        return 1;
126
151
}
127
152
///************************************************
135
160
            _tail=_head=0;
136
161
            return 1;
137
162
   };
138
 
   
 
163
/* AMR specific */
139
164
 ADM_AudiocodecAMR::ADM_AudiocodecAMR(uint32_t fourcc,WAVHeader *info)
140
165
       :  ADM_Audiocodec(fourcc)
141
166
 {
154
179
        printf(" Opening AMR codec\n");
155
180
 
156
181
        AVCodec *codec=avcodec_find_decoder(CODEC_ID_AMR_NB);
157
 
        if(!codec) {GUI_Error_HIG("Internal error", "Cannot open AMR codec.");ADM_assert(0);} 
 
182
        if(!codec) {GUI_Error_HIG(_("Internal error"), _("Cannot open AMR codec."));ADM_assert(0);} 
158
183
        if (avcodec_open(_context, codec) < 0)
159
184
        {
160
185
            printf("\n AMR decoder init failed !\n");
171
196
/*-------------------------------------------------------------------------------------------------------------------------
172
197
-------------------------------------------------------------------------------------------------------------------------*/
173
198
#define AMR_PACKET 32
174
 
uint8_t ADM_AudiocodecAMR::run( uint8_t * ptr, uint32_t nbIn, uint8_t * outptr,   uint32_t * nbOut)
 
199
uint8_t ADM_AudiocodecAMR::run(uint8_t *inptr, uint32_t nbIn, float *outptr, uint32_t *nbOut)
175
200
{
176
201
int out;
177
 
int max=0,pout=0,toread;
178
 
        
179
 
        *nbOut=0;
180
 
        // Shrink
 
202
int pout=0;
 
203
int16_t *run16;
 
204
 
 
205
 
 
206
        *nbOut=0;
 
207
        // Shrink
181
208
        if(_head && (_tail+nbIn)*3>ADM_AMR_BUFFER*2)
182
209
        {
183
210
            memmove(_buffer,_buffer+_head,_tail-_head);
186
213
        }
187
214
        //
188
215
        ADM_assert(nbIn+_tail<ADM_AMR_BUFFER);
189
 
        memcpy(_buffer+_tail,ptr,nbIn);
 
216
        memcpy(_buffer+_tail,inptr,nbIn);
190
217
        _tail+=nbIn;
191
218
        while(_tail-_head>AMR_PACKET)
192
219
        {
193
 
                out=avcodec_decode_audio(_context,(int16_t *)outptr,&pout,_buffer+_head,_tail-_head);
 
220
          out=avcodec_decode_audio(_context,(int16_t *)scratchPad,
 
221
                                   &pout,_buffer+_head,_tail-_head);
194
222
                
195
223
                if(out<0)
196
224
                {
197
 
                        printf( " *** WMA decoding error ***\n");
 
225
                        printf( " *** AMR decoding error ***\n");
198
226
                        _head+=1; // Try skipping some bytes
199
227
                        continue;
200
228
                }
201
229
            
202
230
                _head+=out; // consumed bytes
 
231
                pout>>=1;
203
232
                *nbOut+=pout;
204
 
                outptr+=pout;
205
 
 
 
233
                run16=(int16_t *)scratchPad;
 
234
                for(int i=0;i<pout;i++)
 
235
                {
 
236
                  *outptr++=((float)run16[i])/32767.;
 
237
                }
206
238
        }
 
239
        
 
240
 
207
241
        return 1;
208
242
}
209
243