← Back to branch summary

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

« back to all changes in this revision

Viewing changes to avidemux/ADM_audiocodec/ADM_codecac3.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_codecac3.cpp
24
24
#include "fourcc.h"
25
25
#include "ADM_audio/aviaudio.hxx"
26
26
#include "ADM_audiocodec/ADM_audiocodec.h"
 
27
#include "ADM_audiofilter/audiofilter_channel_route.h"
27
28
 
 
29
#include "ADM_toolkit/ADM_cpuCap.h"
 
30
#include "prefs.h"
28
31
 
29
32
#ifdef USE_AC3
30
 
#include "ADM_audiocodec/ADM_AC3.h"
31
 
 
32
 
ADM_AudiocodecAC3::ADM_AudiocodecAC3( uint32_t fourcc) :   ADM_Audiocodec(fourcc)
 
33
extern "C" {
 
34
#include "ADM_liba52/a52.h"
 
35
#include "ADM_liba52/mm_accel.h"
 
36
};
 
37
 
 
38
#define AC3_HANDLE ((a52_state_t *)ac3_handle)
 
39
 
 
40
ADM_AudiocodecAC3::ADM_AudiocodecAC3( uint32_t fourcc, WAVHeader *info) :   ADM_Audiocodec(fourcc)
33
41
{
34
 
        ADM_assert(fourcc==WAV_AC3);
35
 
 
 
42
    int flags=0;
 
43
    ADM_assert(fourcc==WAV_AC3);
 
44
    ac3_handle=NULL;
 
45
    ac3_sample=NULL;
 
46
#if (defined( ARCH_X86)  || defined(ARCH_X86_64))
 
47
#define CHK(x,y) if(CpuCaps::has##x()) flags|=MM_ACCEL_X86_##y;
 
48
    CHK(MMX,MMX);
 
49
    CHK(3DNOW,3DNOW);
 
50
    CHK(MMXEXT,MMXEXT);
 
51
#endif
 
52
    
 
53
    ac3_handle=(void *)a52_init(flags);
 
54
    if(!ac3_handle)
 
55
    {
 
56
        printf("Cannot init a52\n");
 
57
        ADM_assert(0);   
 
58
    }
 
59
    ac3_sample=(sample_t *)a52_samples(AC3_HANDLE);
 
60
    if(!ac3_sample)
 
61
    {
 
62
        printf("Cannot init a52 sample\n");
 
63
        ADM_assert(0);   
 
64
    }
 
65
        _downmix=0;
 
66
      _wavHeader = info;
 
67
      ADM_assert(_wavHeader);
36
68
}
 
69
 
37
70
ADM_AudiocodecAC3::~ADM_AudiocodecAC3( )
38
71
{
 
72
    if(ac3_handle)
 
73
    {
 
74
        a52_free(AC3_HANDLE);
 
75
        ac3_handle=NULL;
 
76
        ac3_sample=NULL;
 
77
    }
 
78
}
39
79
 
40
 
}
41
80
uint8_t ADM_AudiocodecAC3::beginDecompress( void )
42
81
{
43
 
                return ADM_AC3Init();
 
82
                return 1;
44
83
}
 
84
 
45
85
uint8_t ADM_AudiocodecAC3::endDecompress( void )
46
86
{
47
 
                return ADM_AC3End();
 
87
    return 1;
48
88
}
49
 
uint8_t ADM_AudiocodecAC3::run( uint8_t * ptr, uint32_t nbIn, uint8_t * outptr,   uint32_t * nbOut)
 
89
 
 
90
uint8_t ADM_AudiocodecAC3::run(uint8_t *inptr, uint32_t nbIn, float *outptr,   uint32_t *nbOut)
50
91
{
51
 
        return ADM_AC3Run(ptr,nbIn,outptr,nbOut);
52
 
 
 
92
    uint32_t avail;
 
93
    uint32_t length;
 
94
    int flags = 0, samprate = 0, bitrate = 0;
 
95
    uint8_t chan = _wavHeader->channels;
 
96
    *nbOut=0;
 
97
 
 
98
    //  Ready to decode
 
99
    while(nbIn)
 
100
    {
 
101
        if(nbIn<7)
 
102
        {
 
103
            if(nbIn)
 
104
                printf("[a52]: no data to decode avail %u\n",nbIn);
 
105
            break;
 
106
        }
 
107
        length = a52_syncinfo(inptr, &flags, &samprate, &bitrate);
 
108
        if(length==0)
 
109
        {
 
110
            printf("[a52] No startcode found\n");
 
111
            ADM_assert(0); 
 
112
        }
 
113
        if(length>nbIn)
 
114
        {
 
115
            // not enough data
 
116
            break;
 
117
        }
 
118
 
 
119
        if (ch_route.mode < 1) {
 
120
                CHANNEL_TYPE *p_ch_type = ch_route.input_type;
 
121
                if (flags & A52_LFE) {
 
122
                        *(p_ch_type++) = CH_LFE;
 
123
                }
 
124
                switch (flags & A52_CHANNEL_MASK) {
 
125
                        case A52_MONO:
 
126
                                *(p_ch_type++) = CH_MONO;
 
127
                        break;
 
128
                        case A52_STEREO:
 
129
                        case A52_DOLBY:
 
130
                                *(p_ch_type++) = CH_FRONT_LEFT;
 
131
                                *(p_ch_type++) = CH_FRONT_RIGHT;
 
132
                        break;
 
133
                        case A52_3F:
 
134
                                *(p_ch_type++) = CH_FRONT_LEFT;
 
135
                                *(p_ch_type++) = CH_FRONT_CENTER;
 
136
                                *(p_ch_type++) = CH_FRONT_RIGHT;
 
137
                        break;
 
138
                        case A52_2F1R:
 
139
                                *(p_ch_type++) = CH_FRONT_LEFT;
 
140
                                *(p_ch_type++) = CH_FRONT_RIGHT;
 
141
                                *(p_ch_type++) = CH_REAR_CENTER;
 
142
                        break;
 
143
                        case A52_3F1R:
 
144
                                *(p_ch_type++) = CH_FRONT_LEFT;
 
145
                                *(p_ch_type++) = CH_FRONT_CENTER;
 
146
                                *(p_ch_type++) = CH_FRONT_RIGHT;
 
147
                                *(p_ch_type++) = CH_REAR_CENTER;
 
148
                        break;
 
149
                        case A52_2F2R:
 
150
                                *(p_ch_type++) = CH_FRONT_LEFT;
 
151
                                *(p_ch_type++) = CH_FRONT_RIGHT;
 
152
                                *(p_ch_type++) = CH_REAR_LEFT;
 
153
                                *(p_ch_type++) = CH_REAR_RIGHT;
 
154
                        break;
 
155
                        case A52_3F2R:
 
156
                                *(p_ch_type++) = CH_FRONT_LEFT;
 
157
                                *(p_ch_type++) = CH_FRONT_CENTER;
 
158
                                *(p_ch_type++) = CH_FRONT_RIGHT;
 
159
                                *(p_ch_type++) = CH_REAR_LEFT;
 
160
                                *(p_ch_type++) = CH_REAR_RIGHT;
 
161
                        break;
 
162
                        default:
 
163
                                ADM_assert(0);
 
164
                }
 
165
        }
 
166
 
 
167
        sample_t level = 1, bias = 0;
 
168
 
 
169
        if (a52_frame(AC3_HANDLE, inptr, &flags, &level, bias))
 
170
        {
 
171
            printf("\n A52_frame failed!");
 
172
            inptr+=length;
 
173
            nbIn-=length;
 
174
            *nbOut += 256 * chan * 6;
 
175
            break;
 
176
        };
 
177
        inptr+=length;
 
178
        nbIn-=length;
 
179
        *nbOut += 256 * chan * 6;
 
180
 
 
181
        float *cur;
 
182
        for (int i = 0; i < 6; i++) {
 
183
                if (a52_block(AC3_HANDLE)) {
 
184
                        printf("\n A52_block failed! on fblock :%lu", i);
 
185
                        // in that case we silent out the chunk
 
186
                        memset(outptr, 0, 256 * chan * sizeof(float));
 
187
                } else {
 
188
                        for (int k = 0; k < chan; k++) {
 
189
                                sample_t *sample=(sample_t *)ac3_sample;
 
190
                                sample += 256 * k;
 
191
                                cur = outptr + k;
 
192
                                for (int j = 0; j < 256; j++) {
 
193
                                        *cur = *sample++;
 
194
                                        cur+=chan;
 
195
                                }
 
196
                        }
 
197
                }
 
198
                outptr += chan * 256;
 
199
        }
 
200
    }
 
201
    return 1; 
53
202
 
54
203
}
55
204