← Back to branch summary

~ubuntu-branches/ubuntu/edgy/gstreamer0.10-ffmpeg/edgy

« back to all changes in this revision

Viewing changes to gst-libs/ext/ffmpeg/libavcodec/wmadec.c

  • Committer: Bazaar Package Importer
  • Author(s): Sebastian Dröge
  • Date: 2006-04-01 16:13:43 UTC
  • mto: This revision was merged to the branch mainline in revision 5.
  • Revision ID: james.westby@ubuntu.com-20060401161343-n621cgjlujio0otg
Tags: upstream-0.10.1
Import upstream version 0.10.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
gst-libs/ext/ffmpeg/libavcodec/wmadec.c
14
14
 *
15
15
 * You should have received a copy of the GNU Lesser General Public
16
16
 * License along with this library; if not, write to the Free Software
17
 
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
17
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
18
18
 */
19
19
 
20
20
/**
21
21
 * @file wmadec.c
22
22
 * WMA compatible decoder.
23
23
 * This decoder handles Microsoft Windows Media Audio data, versions 1 & 2.
24
 
 * WMA v1 is identified by audio format 0x160 in Microsoft media files 
 
24
 * WMA v1 is identified by audio format 0x160 in Microsoft media files
25
25
 * (ASF/AVI/WAV). WMA v2 is identified by audio format 0x161.
26
26
 *
27
27
 * To use this decoder, a calling application must supply the extra data
28
28
 * bytes provided with the WMA data. These are the extra, codec-specific
29
 
 * bytes at the end of a WAVEFORMATEX data structure. Transmit these bytes 
30
 
 * to the decoder using the extradata[_size] fields in AVCodecContext. There 
 
29
 * bytes at the end of a WAVEFORMATEX data structure. Transmit these bytes
 
30
 * to the decoder using the extradata[_size] fields in AVCodecContext. There
31
31
 * should be 4 extra bytes for v1 data and 6 extra bytes for v2 data.
32
32
 */
33
33
 
56
56
 
57
57
#define LSP_POW_BITS 7
58
58
 
 
59
#define VLCBITS 9
 
60
#define VLCMAX ((22+VLCBITS-1)/VLCBITS)
 
61
 
 
62
#define EXPVLCBITS 8
 
63
#define EXPMAX ((19+EXPVLCBITS-1)/EXPVLCBITS)
 
64
 
 
65
#define HGAINVLCBITS 9
 
66
#define HGAINMAX ((13+HGAINVLCBITS-1)/HGAINVLCBITS)
 
67
 
59
68
typedef struct WMADecodeContext {
60
69
    GetBitContext gb;
61
70
    int sample_rate;
75
84
    int coefs_start;               /* first coded coef */
76
85
    int coefs_end[BLOCK_NB_SIZES]; /* max number of coded coefficients */
77
86
    int exponent_high_sizes[BLOCK_NB_SIZES];
78
 
    int exponent_high_bands[BLOCK_NB_SIZES][HIGH_BAND_MAX_SIZE]; 
 
87
    int exponent_high_bands[BLOCK_NB_SIZES][HIGH_BAND_MAX_SIZE];
79
88
    VLC hgain_vlc;
80
 
    
 
89
 
81
90
    /* coded values in high bands */
82
91
    int high_band_coded[MAX_CHANNELS][HIGH_BAND_MAX_SIZE];
83
92
    int high_band_values[MAX_CHANNELS][HIGH_BAND_MAX_SIZE];
100
109
    int block_pos; /* current position in frame */
101
110
    uint8_t ms_stereo; /* true if mid/side stereo mode */
102
111
    uint8_t channel_coded[MAX_CHANNELS]; /* true if channel is coded */
103
 
    float exponents[MAX_CHANNELS][BLOCK_MAX_SIZE] __attribute__((aligned(16)));
 
112
    DECLARE_ALIGNED_16(float, exponents[MAX_CHANNELS][BLOCK_MAX_SIZE]);
104
113
    float max_exponent[MAX_CHANNELS];
105
114
    int16_t coefs1[MAX_CHANNELS][BLOCK_MAX_SIZE];
106
 
    float coefs[MAX_CHANNELS][BLOCK_MAX_SIZE] __attribute__((aligned(16)));
 
115
    DECLARE_ALIGNED_16(float, coefs[MAX_CHANNELS][BLOCK_MAX_SIZE]);
107
116
    MDCTContext mdct_ctx[BLOCK_NB_SIZES];
108
117
    float *windows[BLOCK_NB_SIZES];
109
 
    FFTSample mdct_tmp[BLOCK_MAX_SIZE] __attribute__((aligned(16))); /* temporary storage for imdct */
 
118
    DECLARE_ALIGNED_16(FFTSample, mdct_tmp[BLOCK_MAX_SIZE]); /* temporary storage for imdct */
110
119
    /* output buffer for one frame and the last for IMDCT windowing */
111
 
    float frame_out[MAX_CHANNELS][BLOCK_MAX_SIZE * 2] __attribute__((aligned(16)));
 
120
    DECLARE_ALIGNED_16(float, frame_out[MAX_CHANNELS][BLOCK_MAX_SIZE * 2]);
112
121
    /* last frame info */
113
122
    uint8_t last_superframe[MAX_CODED_SUPERFRAME_SIZE + 4]; /* padding added */
114
123
    int last_bitoffset;
171
180
#endif
172
181
 
173
182
/* XXX: use same run/length optimization as mpeg decoders */
174
 
static void init_coef_vlc(VLC *vlc, 
 
183
static void init_coef_vlc(VLC *vlc,
175
184
                          uint16_t **prun_table, uint16_t **plevel_table,
176
185
                          const CoefVLCTable *vlc_table)
177
186
{
183
192
    const uint16_t *p;
184
193
    int i, l, j, level;
185
194
 
186
 
    init_vlc(vlc, 9, n, table_bits, 1, 1, table_codes, 4, 4, 0);
 
195
    init_vlc(vlc, VLCBITS, n, table_bits, 1, 1, table_codes, 4, 4, 0);
187
196
 
188
197
    run_table = av_malloc(n * sizeof(uint16_t));
189
198
    level_table = av_malloc(n * sizeof(uint16_t));
213
222
    volatile float bps;
214
223
    int sample_rate1;
215
224
    int coef_vlc_table;
216
 
    
 
225
 
217
226
    s->sample_rate = avctx->sample_rate;
218
227
    s->nb_channels = avctx->channels;
219
228
    s->bit_rate = avctx->bit_rate;
224
233
    } else {
225
234
        s->version = 2;
226
235
    }
227
 
    
 
236
 
228
237
    /* extract flag infos */
229
238
    flags1 = 0;
230
239
    flags2 = 0;
233
242
        flags1 = extradata[0] | (extradata[1] << 8);
234
243
        flags2 = extradata[2] | (extradata[3] << 8);
235
244
    } else if (s->version == 2 && avctx->extradata_size >= 6) {
236
 
        flags1 = extradata[0] | (extradata[1] << 8) | 
 
245
        flags1 = extradata[0] | (extradata[1] << 8) |
237
246
            (extradata[2] << 16) | (extradata[3] << 24);
238
247
        flags2 = extradata[4] | (extradata[5] << 8);
239
248
    }
244
253
    /* compute MDCT block size */
245
254
    if (s->sample_rate <= 16000) {
246
255
        s->frame_len_bits = 9;
247
 
    } else if (s->sample_rate <= 22050 || 
 
256
    } else if (s->sample_rate <= 22050 ||
248
257
               (s->sample_rate <= 32000 && s->version == 1)) {
249
258
        s->frame_len_bits = 10;
250
259
    } else {
271
280
    /* if version 2, then the rates are normalized */
272
281
    sample_rate1 = s->sample_rate;
273
282
    if (s->version == 2) {
274
 
        if (sample_rate1 >= 44100) 
 
283
        if (sample_rate1 >= 44100)
275
284
            sample_rate1 = 44100;
276
 
        else if (sample_rate1 >= 22050) 
 
285
        else if (sample_rate1 >= 22050)
277
286
            sample_rate1 = 22050;
278
 
        else if (sample_rate1 >= 16000) 
 
287
        else if (sample_rate1 >= 16000)
279
288
            sample_rate1 = 16000;
280
 
        else if (sample_rate1 >= 11025) 
 
289
        else if (sample_rate1 >= 11025)
281
290
            sample_rate1 = 11025;
282
 
        else if (sample_rate1 >= 8000) 
 
291
        else if (sample_rate1 >= 8000)
283
292
            sample_rate1 = 8000;
284
293
    }
285
294
 
286
295
    bps = (float)s->bit_rate / (float)(s->nb_channels * s->sample_rate);
287
 
    s->byte_offset_bits = av_log2((int)(bps * s->frame_len / 8.0)) + 2;
 
296
    s->byte_offset_bits = av_log2((int)(bps * s->frame_len / 8.0 + 0.5)) + 2;
288
297
 
289
298
    /* compute high frequency value and choose if noise coding should
290
299
       be activated */
299
308
    } else if (sample_rate1 == 22050) {
300
309
        if (bps1 >= 1.16)
301
310
            s->use_noise_coding = 0;
302
 
        else if (bps1 >= 0.72) 
 
311
        else if (bps1 >= 0.72)
303
312
            high_freq = high_freq * 0.7;
304
313
        else
305
314
            high_freq = high_freq * 0.6;
329
338
    }
330
339
    dprintf("flags1=0x%x flags2=0x%x\n", flags1, flags2);
331
340
    dprintf("version=%d channels=%d sample_rate=%d bitrate=%d block_align=%d\n",
332
 
           s->version, s->nb_channels, s->sample_rate, s->bit_rate, 
 
341
           s->version, s->nb_channels, s->sample_rate, s->bit_rate,
333
342
           s->block_align);
334
 
    dprintf("bps=%f bps1=%f high_freq=%f bitoffset=%d\n", 
 
343
    dprintf("bps=%f bps1=%f high_freq=%f bitoffset=%d\n",
335
344
           bps, bps1, high_freq, s->byte_offset_bits);
336
345
    dprintf("use_noise_coding=%d use_exp_vlc=%d nb_block_sizes=%d\n",
337
346
           s->use_noise_coding, s->use_exp_vlc, s->nb_block_sizes);
340
349
    {
341
350
        int a, b, pos, lpos, k, block_len, i, j, n;
342
351
        const uint8_t *table;
343
 
        
 
352
 
344
353
        if (s->version == 1) {
345
354
            s->coefs_start = 3;
346
355
        } else {
355
364
                    a = wma_critical_freqs[i];
356
365
                    b = s->sample_rate;
357
366
                    pos = ((block_len * 2 * a)  + (b >> 1)) / b;
358
 
                    if (pos > block_len) 
 
367
                    if (pos > block_len)
359
368
                        pos = block_len;
360
369
                    s->exponent_bands[0][i] = pos - lpos;
361
370
                    if (pos >= block_len) {
390
399
                        b = s->sample_rate;
391
400
                        pos = ((block_len * 2 * a)  + (b << 1)) / (4 * b);
392
401
                        pos <<= 2;
393
 
                        if (pos > block_len) 
 
402
                        if (pos > block_len)
394
403
                            pos = block_len;
395
404
                        if (pos > lpos)
396
405
                            s->exponent_bands[k][j++] = pos - lpos;
405
414
            /* max number of coefs */
406
415
            s->coefs_end[k] = (s->frame_len - ((s->frame_len * 9) / 100)) >> k;
407
416
            /* high freq computation */
408
 
            s->high_band_start[k] = (int)((block_len * 2 * high_freq) / 
 
417
            s->high_band_start[k] = (int)((block_len * 2 * high_freq) /
409
418
                                          s->sample_rate + 0.5);
410
419
            n = s->exponent_sizes[k];
411
420
            j = 0;
425
434
            s->exponent_high_sizes[k] = j;
426
435
#if 0
427
436
            tprintf("%5d: coefs_end=%d high_band_start=%d nb_high_bands=%d: ",
428
 
                  s->frame_len >> k, 
 
437
                  s->frame_len >> k,
429
438
                  s->coefs_end[k],
430
439
                  s->high_band_start[k],
431
440
                  s->exponent_high_sizes[k]);
440
449
    {
441
450
        int i, j;
442
451
        for(i = 0; i < s->nb_block_sizes; i++) {
443
 
            tprintf("%5d: n=%2d:", 
444
 
                   s->frame_len >> i, 
 
452
            tprintf("%5d: n=%2d:",
 
453
                   s->frame_len >> i,
445
454
                   s->exponent_sizes[i]);
446
455
            for(j=0;j<s->exponent_sizes[i];j++)
447
456
                tprintf(" %d", s->exponent_bands[i][j]);
453
462
    /* init MDCT */
454
463
    for(i = 0; i < s->nb_block_sizes; i++)
455
464
        ff_mdct_init(&s->mdct_ctx[i], s->frame_len_bits - i + 1, 1);
456
 
    
 
465
 
457
466
    /* init MDCT windows : simple sinus window */
458
467
    for(i = 0; i < s->nb_block_sizes; i++) {
459
468
        int n, j;
468
477
    }
469
478
 
470
479
    s->reset_block_lengths = 1;
471
 
    
 
480
 
472
481
    if (s->use_noise_coding) {
473
482
 
474
483
        /* init the noise generator */
476
485
            s->noise_mult = 0.02;
477
486
        else
478
487
            s->noise_mult = 0.04;
479
 
               
 
488
 
480
489
#ifdef TRACE
481
490
        for(i=0;i<NOISE_TAB_SIZE;i++)
482
491
            s->noise_table[i] = 1.0 * s->noise_mult;
492
501
            }
493
502
        }
494
503
#endif
495
 
        init_vlc(&s->hgain_vlc, 9, sizeof(hgain_huffbits), 
 
504
        init_vlc(&s->hgain_vlc, HGAINVLCBITS, sizeof(hgain_huffbits),
496
505
                 hgain_huffbits, 1, 1,
497
506
                 hgain_huffcodes, 2, 2, 0);
498
507
    }
499
508
 
500
509
    if (s->use_exp_vlc) {
501
 
        init_vlc(&s->exp_vlc, 9, sizeof(scale_huffbits), 
 
510
        init_vlc(&s->exp_vlc, EXPVLCBITS, sizeof(scale_huffbits),
502
511
                 scale_huffbits, 1, 1,
503
512
                 scale_huffcodes, 4, 4, 0);
504
513
    } else {
572
581
}
573
582
 
574
583
static void wma_lsp_to_curve_init(WMADecodeContext *s, int frame_len)
575
 
{  
 
584
{
576
585
    float wdel, a, b;
577
586
    int i, e, m;
578
587
 
610
619
 
611
620
/* NOTE: We use the same code as Vorbis here */
612
621
/* XXX: optimize it further with SSE/3Dnow */
613
 
static void wma_lsp_to_curve(WMADecodeContext *s, 
614
 
                             float *out, float *val_max_ptr, 
 
622
static void wma_lsp_to_curve(WMADecodeContext *s,
 
623
                             float *out, float *val_max_ptr,
615
624
                             int n, float *lsp)
616
625
{
617
626
    int i, j;
661
670
    int last_exp, n, code;
662
671
    const uint16_t *ptr, *band_ptr;
663
672
    float v, *q, max_scale, *q_end;
664
 
    
 
673
 
665
674
    band_ptr = s->exponent_bands[s->frame_len_bits - s->block_len_bits];
666
675
    ptr = band_ptr;
667
676
    q = s->exponents[ch];
679
688
    }
680
689
    last_exp = 36;
681
690
    while (q < q_end) {
682
 
        code = get_vlc(&s->gb, &s->exp_vlc);
 
691
        code = get_vlc2(&s->gb, s->exp_vlc.table, EXPVLCBITS, EXPMAX);
683
692
        if (code < 0)
684
693
            return -1;
685
694
        /* NOTE: this offset is the same as MPEG4 AAC ! */
719
728
    /* compute current block length */
720
729
    if (s->use_variable_block_len) {
721
730
        n = av_log2(s->nb_block_sizes - 1) + 1;
722
 
    
 
731
 
723
732
        if (s->reset_block_lengths) {
724
733
            s->reset_block_lengths = 0;
725
734
            v = get_bits(&s->gb, n);
776
785
        if (a != 127)
777
786
            break;
778
787
    }
779
 
    
 
788
 
780
789
    if (total_gain < 15)
781
790
        coef_nb_bits = 13;
782
791
    else if (total_gain < 32)
820
829
                        if (val == (int)0x80000000) {
821
830
                            val = get_bits(&s->gb, 7) - 19;
822
831
                        } else {
823
 
                            code = get_vlc(&s->gb, &s->hgain_vlc);
 
832
                            code = get_vlc2(&s->gb, s->hgain_vlc.table, HGAINVLCBITS, HGAINMAX);
824
833
                            if (code < 0)
825
834
                                return -1;
826
835
                            val += code - 18;
831
840
            }
832
841
        }
833
842
    }
834
 
           
 
843
 
835
844
    /* exposant can be interpolated in short blocks. */
836
845
    parse_exponents = 1;
837
846
    if (s->block_len_bits != s->frame_len_bits) {
838
847
        parse_exponents = get_bits(&s->gb, 1);
839
848
    }
840
 
    
 
849
 
841
850
    if (parse_exponents) {
842
851
        for(ch = 0; ch < s->nb_channels; ch++) {
843
852
            if (s->channel_coded[ch]) {
852
861
    } else {
853
862
        for(ch = 0; ch < s->nb_channels; ch++) {
854
863
            if (s->channel_coded[ch]) {
855
 
                interpolate_array(s->exponents[ch], 1 << s->prev_block_len_bits, 
 
864
                interpolate_array(s->exponents[ch], 1 << s->prev_block_len_bits,
856
865
                                  s->block_len);
857
866
            }
858
867
        }
877
886
            eptr = ptr + nb_coefs[ch];
878
887
            memset(ptr, 0, s->block_len * sizeof(int16_t));
879
888
            for(;;) {
880
 
                code = get_vlc(&s->gb, coef_vlc);
 
889
                code = get_vlc2(&s->gb, coef_vlc->table, VLCBITS, VLCMAX);
881
890
                if (code < 0)
882
891
                    return -1;
883
892
                if (code == 1) {
910
919
            align_get_bits(&s->gb);
911
920
        }
912
921
    }
913
 
     
 
922
 
914
923
    /* normalize */
915
924
    {
916
925
        int n4 = s->block_len / 2;
940
949
                    *coefs++ = s->noise_table[s->noise_index] * (*exponents++) * mult1;
941
950
                    s->noise_index = (s->noise_index + 1) & (NOISE_TAB_SIZE - 1);
942
951
                }
943
 
                
 
952
 
944
953
                n1 = s->exponent_high_sizes[bsize];
945
954
 
946
955
                /* compute power of high bands */
947
 
                exp_ptr = exponents + 
948
 
                    s->high_band_start[bsize] - 
 
956
                exp_ptr = exponents +
 
957
                    s->high_band_start[bsize] -
949
958
                    s->coefs_start;
950
959
                last_high_band = 0; /* avoid warning */
951
960
                for(j=0;j<n1;j++) {
952
 
                    n = s->exponent_high_bands[s->frame_len_bits - 
 
961
                    n = s->exponent_high_bands[s->frame_len_bits -
953
962
                                              s->block_len_bits][j];
954
963
                    if (s->high_band_coded[ch][j]) {
955
964
                        float e2, v;
968
977
                /* main freqs and high freqs */
969
978
                for(j=-1;j<n1;j++) {
970
979
                    if (j < 0) {
971
 
                        n = s->high_band_start[bsize] - 
 
980
                        n = s->high_band_start[bsize] -
972
981
                            s->coefs_start;
973
982
                    } else {
974
 
                        n = s->exponent_high_bands[s->frame_len_bits - 
 
983
                        n = s->exponent_high_bands[s->frame_len_bits -
975
984
                                                  s->block_len_bits][j];
976
985
                    }
977
986
                    if (j >= 0 && s->high_band_coded[ch][j]) {
1026
1035
        }
1027
1036
    }
1028
1037
#endif
1029
 
    
 
1038
 
1030
1039
    if (s->ms_stereo && s->channel_coded[1]) {
1031
1040
        float a, b;
1032
1041
        int i;
1039
1048
            memset(s->coefs[0], 0, sizeof(float) * s->block_len);
1040
1049
            s->channel_coded[0] = 1;
1041
1050
        }
1042
 
        
 
1051
 
1043
1052
        for(i = 0; i < s->block_len; i++) {
1044
1053
            a = s->coefs[0][i];
1045
1054
            b = s->coefs[1][i];
1092
1101
        }
1093
1102
    }
1094
1103
 
1095
 
    
 
1104
 
1096
1105
    for(ch = 0; ch < s->nb_channels; ch++) {
1097
1106
        if (s->channel_coded[ch]) {
1098
 
            FFTSample output[BLOCK_MAX_SIZE * 2] __attribute__((aligned(16)));
 
1107
            DECLARE_ALIGNED_16(FFTSample, output[BLOCK_MAX_SIZE * 2]);
1099
1108
            float *ptr;
1100
1109
            int i, n4, index, n;
1101
1110
 
1102
1111
            n = s->block_len;
1103
1112
            n4 = s->block_len / 2;
1104
 
            ff_imdct_calc(&s->mdct_ctx[bsize], 
 
1113
            ff_imdct_calc(&s->mdct_ctx[bsize],
1105
1114
                          output, s->coefs[ch], s->mdct_tmp);
1106
1115
 
1107
1116
            /* XXX: optimize all that by build the window and
1156
1165
    s->block_pos = 0;
1157
1166
    for(;;) {
1158
1167
        ret = wma_decode_block(s);
1159
 
        if (ret < 0) 
 
1168
        if (ret < 0)
1160
1169
            return -1;
1161
1170
        if (ret)
1162
1171
            break;
1182
1191
        memmove(&s->frame_out[ch][0], &s->frame_out[ch][s->frame_len],
1183
1192
                s->frame_len * sizeof(float));
1184
1193
        /* XXX: suppress this */
1185
 
        memset(&s->frame_out[ch][s->frame_len], 0, 
 
1194
        memset(&s->frame_out[ch][s->frame_len], 0,
1186
1195
               s->frame_len * sizeof(float));
1187
1196
    }
1188
1197
 
1192
1201
    return 0;
1193
1202
}
1194
1203
 
1195
 
static int wma_decode_superframe(AVCodecContext *avctx, 
 
1204
static int wma_decode_superframe(AVCodecContext *avctx,
1196
1205
                                 void *data, int *data_size,
1197
1206
                                 uint8_t *buf, int buf_size)
1198
1207
{
1200
1209
    int nb_frames, bit_offset, i, pos, len;
1201
1210
    uint8_t *q;
1202
1211
    int16_t *samples;
1203
 
    
 
1212
 
1204
1213
    tprintf("***decode_superframe:\n");
1205
1214
 
1206
1215
    if(buf_size==0){
1207
1216
        s->last_superframe_len = 0;
1208
1217
        return 0;
1209
1218
    }
1210
 
    
 
1219
 
1211
1220
    samples = data;
1212
1221
 
1213
1222
    init_get_bits(&s->gb, buf, buf_size*8);
1214
 
    
 
1223
 
1215
1224
    if (s->use_bit_reservoir) {
1216
1225
        /* read super frame header */
1217
1226
        get_bits(&s->gb, 4); /* super frame index */
1222
1231
        if (s->last_superframe_len > 0) {
1223
1232
            //        printf("skip=%d\n", s->last_bitoffset);
1224
1233
            /* add bit_offset bits to last frame */
1225
 
            if ((s->last_superframe_len + ((bit_offset + 7) >> 3)) > 
 
1234
            if ((s->last_superframe_len + ((bit_offset + 7) >> 3)) >
1226
1235
                MAX_CODED_SUPERFRAME_SIZE)
1227
1236
                goto fail;
1228
1237
            q = s->last_superframe + s->last_superframe_len;
1234
1243
            if (len > 0) {
1235
1244
                *q++ = (get_bits)(&s->gb, len) << (8 - len);
1236
1245
            }
1237
 
            
 
1246
 
1238
1247
            /* XXX: bit_offset bits into last frame */
1239
1248
            init_get_bits(&s->gb, s->last_superframe, MAX_CODED_SUPERFRAME_SIZE*8);
1240
1249
            /* skip unused bits */
1253
1262
        len = pos & 7;
1254
1263
        if (len > 0)
1255
1264
            skip_bits(&s->gb, len);
1256
 
    
 
1265
 
1257
1266
        s->reset_block_lengths = 1;
1258
1267
        for(i=0;i<nb_frames;i++) {
1259
1268
            if (wma_decode_frame(s, samples) < 0)
1306
1315
        av_free(s->run_table[i]);
1307
1316
        av_free(s->level_table[i]);
1308
1317
    }
1309
 
    
 
1318
 
1310
1319
    return 0;
1311
1320
}
1312
1321