Mercurial > libavcodec.hg
annotate adpcm.c @ 6920:d02af7474bff libavcodec
Prevent 128*1<<trellis from becoming 0 and creating 0 sized arrays.
fixes CID84 RUN2
CID85 RUN2
CID86 RUN2
CID87 RUN2
CID88 RUN2
CID89 RUN2
CID90 RUN2
CID91 RUN2
CID92 RUN2
CID93 RUN2
CID94 RUN2
CID95 RUN2
CID96 RUN2
CID97 RUN2
CID98 RUN2
CID99 RUN2
CID100 RUN2
CID101 RUN2
CID102 RUN2
CID103 RUN2
CID104 RUN2
CID105 RUN2
CID106 RUN2
author | michael |
---|---|
date | Wed, 28 May 2008 11:59:41 +0000 |
parents | 999e8762799a |
children | e943e1409077 |
rev | line source |
---|---|
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1 /* |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
2 * ADPCM codecs |
1443
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
3 * Copyright (c) 2001-2003 The ffmpeg Project |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
4 * |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3445
diff
changeset
|
5 * This file is part of FFmpeg. |
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3445
diff
changeset
|
6 * |
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3445
diff
changeset
|
7 * FFmpeg is free software; you can redistribute it and/or |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
8 * modify it under the terms of the GNU Lesser General Public |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
9 * License as published by the Free Software Foundation; either |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3445
diff
changeset
|
10 * version 2.1 of the License, or (at your option) any later version. |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
11 * |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3445
diff
changeset
|
12 * FFmpeg is distributed in the hope that it will be useful, |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
15 * Lesser General Public License for more details. |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
16 * |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
17 * You should have received a copy of the GNU Lesser General Public |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3445
diff
changeset
|
18 * License along with FFmpeg; if not, write to the Free Software |
3036
0b546eab515d
Update licensing information: The FSF changed postal address.
diego
parents:
2979
diff
changeset
|
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
20 */ |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
21 #include "avcodec.h" |
2516
9f17dd9b80c6
macromedia flavour adpcm decoding (used in flv and swf)
alex
parents:
2296
diff
changeset
|
22 #include "bitstream.h" |
4810
0066256e99da
use bytestream reader instead of bitstream for THP
michael
parents:
4809
diff
changeset
|
23 #include "bytestream.h" |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
24 |
1106 | 25 /** |
26 * @file adpcm.c | |
27 * ADPCM codecs. | |
1535 | 28 * First version by Francois Revol (revol@free.fr) |
1491
222643544cf1
New demuxers: Sega FILM/CPK, Westwood VQA & AUD; new decoders: MS RLE &
tmmm
parents:
1443
diff
changeset
|
29 * Fringe ADPCM codecs (e.g., DK3, DK4, Westwood) |
1443
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
30 * by Mike Melanson (melanson@pcisys.net) |
1535 | 31 * CD-ROM XA ADPCM codec by BERO |
1779 | 32 * EA ADPCM decoder by Robin Kay (komadori@myrealbox.com) |
5851 | 33 * EA ADPCM R1/R2/R3 decoder by Peter Ross (pross@xvid.org) |
5854 | 34 * EA IMA EACS decoder by Peter Ross (pross@xvid.org) |
5853 | 35 * EA IMA SEAD decoder by Peter Ross (pross@xvid.org) |
5870 | 36 * EA ADPCM XAS decoder by Peter Ross (pross@xvid.org) |
6596 | 37 * MAXIS EA ADPCM decoder by Robert Marston (rmarston@gmail.com) |
4800 | 38 * THP ADPCM decoder by Marco Gerards (mgerards@xs4all.nl) |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
39 * |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
40 * Features and limitations: |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
41 * |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
42 * Reference documents: |
1443
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
43 * http://www.pcisys.net/~melanson/codecs/simpleaudio.html |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
44 * http://www.geocities.com/SiliconValley/8682/aud3.txt |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
45 * http://openquicktime.sourceforge.net/plugins.htm |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
46 * XAnim sources (xa_codec.c) http://www.rasnaimaging.com/people/lapus/download.html |
577
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
47 * http://www.cs.ucla.edu/~leec/mediabench/applications.html |
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
48 * SoX source code http://home.sprynet.com/~cbagwell/sox.html |
1535 | 49 * |
50 * CD-ROM XA: | |
51 * http://ku-www.ss.titech.ac.jp/~yatsushi/xaadpcm.html | |
52 * vagpack & depack http://homepages.compuserve.de/bITmASTER32/psx-index.html | |
53 * readstr http://www.geocities.co.jp/Playtown/2004/ | |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
54 */ |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
55 |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
56 #define BLKSIZE 1024 |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
57 |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
58 /* step_table[] and index_table[] are from the ADPCM reference source */ |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
59 /* This is the index table: */ |
1081
18157900b434
* fixed IMA WAV decoding (though still might not be fully correct)
kabi
parents:
1064
diff
changeset
|
60 static const int index_table[16] = { |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
61 -1, -1, -1, -1, 2, 4, 6, 8, |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
62 -1, -1, -1, -1, 2, 4, 6, 8, |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
63 }; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
64 |
2967 | 65 /** |
1106 | 66 * This is the step table. Note that many programs use slight deviations from |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
67 * this table, but such deviations are negligible: |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
68 */ |
1081
18157900b434
* fixed IMA WAV decoding (though still might not be fully correct)
kabi
parents:
1064
diff
changeset
|
69 static const int step_table[89] = { |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
70 7, 8, 9, 10, 11, 12, 13, 14, 16, 17, |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
71 19, 21, 23, 25, 28, 31, 34, 37, 41, 45, |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
72 50, 55, 60, 66, 73, 80, 88, 97, 107, 118, |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
73 130, 143, 157, 173, 190, 209, 230, 253, 279, 307, |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
74 337, 371, 408, 449, 494, 544, 598, 658, 724, 796, |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
75 876, 963, 1060, 1166, 1282, 1411, 1552, 1707, 1878, 2066, |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
76 2272, 2499, 2749, 3024, 3327, 3660, 4026, 4428, 4871, 5358, |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
77 5894, 6484, 7132, 7845, 8630, 9493, 10442, 11487, 12635, 13899, |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
78 15289, 16818, 18500, 20350, 22385, 24623, 27086, 29794, 32767 |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
79 }; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
80 |
1535 | 81 /* These are for MS-ADPCM */ |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
82 /* AdaptationTable[], AdaptCoeff1[], and AdaptCoeff2[] are from libsndfile */ |
1081
18157900b434
* fixed IMA WAV decoding (though still might not be fully correct)
kabi
parents:
1064
diff
changeset
|
83 static const int AdaptationTable[] = { |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
84 230, 230, 230, 230, 307, 409, 512, 614, |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
85 768, 614, 512, 409, 307, 230, 230, 230 |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
86 }; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
87 |
1081
18157900b434
* fixed IMA WAV decoding (though still might not be fully correct)
kabi
parents:
1064
diff
changeset
|
88 static const int AdaptCoeff1[] = { |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
89 256, 512, 0, 192, 240, 460, 392 |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
90 }; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
91 |
1081
18157900b434
* fixed IMA WAV decoding (though still might not be fully correct)
kabi
parents:
1064
diff
changeset
|
92 static const int AdaptCoeff2[] = { |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
93 0, -256, 0, 64, 0, -208, -232 |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
94 }; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
95 |
1535 | 96 /* These are for CD-ROM XA ADPCM */ |
1559 | 97 static const int xa_adpcm_table[5][2] = { |
1535 | 98 { 0, 0 }, |
99 { 60, 0 }, | |
100 { 115, -52 }, | |
101 { 98, -55 }, | |
102 { 122, -60 } | |
103 }; | |
104 | |
2753 | 105 static const int ea_adpcm_table[] = { |
1779 | 106 0, 240, 460, 392, 0, 0, -208, -220, 0, 1, |
107 3, 4, 7, 8, 10, 11, 0, -1, -3, -4 | |
108 }; | |
109 | |
2753 | 110 static const int ct_adpcm_table[8] = { |
2296
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
111 0x00E6, 0x00E6, 0x00E6, 0x00E6, |
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
112 0x0133, 0x0199, 0x0200, 0x0266 |
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
113 }; |
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
114 |
2516
9f17dd9b80c6
macromedia flavour adpcm decoding (used in flv and swf)
alex
parents:
2296
diff
changeset
|
115 // padded to zero where table size is less then 16 |
2753 | 116 static const int swf_index_tables[4][16] = { |
2516
9f17dd9b80c6
macromedia flavour adpcm decoding (used in flv and swf)
alex
parents:
2296
diff
changeset
|
117 /*2*/ { -1, 2 }, |
9f17dd9b80c6
macromedia flavour adpcm decoding (used in flv and swf)
alex
parents:
2296
diff
changeset
|
118 /*3*/ { -1, -1, 2, 4 }, |
9f17dd9b80c6
macromedia flavour adpcm decoding (used in flv and swf)
alex
parents:
2296
diff
changeset
|
119 /*4*/ { -1, -1, -1, -1, 2, 4, 6, 8 }, |
9f17dd9b80c6
macromedia flavour adpcm decoding (used in flv and swf)
alex
parents:
2296
diff
changeset
|
120 /*5*/ { -1, -1, -1, -1, -1, -1, -1, -1, 1, 2, 4, 6, 8, 10, 13, 16 } |
9f17dd9b80c6
macromedia flavour adpcm decoding (used in flv and swf)
alex
parents:
2296
diff
changeset
|
121 }; |
9f17dd9b80c6
macromedia flavour adpcm decoding (used in flv and swf)
alex
parents:
2296
diff
changeset
|
122 |
2794
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
123 static const int yamaha_indexscale[] = { |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
124 230, 230, 230, 230, 307, 409, 512, 614, |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
125 230, 230, 230, 230, 307, 409, 512, 614 |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
126 }; |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
127 |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
128 static const int yamaha_difflookup[] = { |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
129 1, 3, 5, 7, 9, 11, 13, 15, |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
130 -1, -3, -5, -7, -9, -11, -13, -15 |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
131 }; |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
132 |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
133 /* end of tables */ |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
134 |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
135 typedef struct ADPCMChannelStatus { |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
136 int predictor; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
137 short int step_index; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
138 int step; |
577
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
139 /* for encoding */ |
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
140 int prev_sample; |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
141 |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
142 /* MS version */ |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
143 short sample1; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
144 short sample2; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
145 int coeff1; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
146 int coeff2; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
147 int idelta; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
148 } ADPCMChannelStatus; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
149 |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
150 typedef struct ADPCMContext { |
5851 | 151 ADPCMChannelStatus status[6]; |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
152 } ADPCMContext; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
153 |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
154 /* XXX: implement encoding */ |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
155 |
1530
3b31998fe22f
disable encoders where appropriate (patch courtesy of BERO
melanson
parents:
1491
diff
changeset
|
156 #ifdef CONFIG_ENCODERS |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
157 static int adpcm_encode_init(AVCodecContext *avctx) |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
158 { |
577
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
159 if (avctx->channels > 2) |
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
160 return -1; /* only stereo or mono =) */ |
6920
d02af7474bff
Prevent 128*1<<trellis from becoming 0 and creating 0 sized arrays.
michael
parents:
6813
diff
changeset
|
161 |
d02af7474bff
Prevent 128*1<<trellis from becoming 0 and creating 0 sized arrays.
michael
parents:
6813
diff
changeset
|
162 if(avctx->trellis && (unsigned)avctx->trellis > 16U){ |
d02af7474bff
Prevent 128*1<<trellis from becoming 0 and creating 0 sized arrays.
michael
parents:
6813
diff
changeset
|
163 av_log(avctx, AV_LOG_ERROR, "invalid trellis size\n"); |
d02af7474bff
Prevent 128*1<<trellis from becoming 0 and creating 0 sized arrays.
michael
parents:
6813
diff
changeset
|
164 return -1; |
d02af7474bff
Prevent 128*1<<trellis from becoming 0 and creating 0 sized arrays.
michael
parents:
6813
diff
changeset
|
165 } |
d02af7474bff
Prevent 128*1<<trellis from becoming 0 and creating 0 sized arrays.
michael
parents:
6813
diff
changeset
|
166 |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
167 switch(avctx->codec->id) { |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
168 case CODEC_ID_ADPCM_IMA_WAV: |
577
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
169 avctx->frame_size = (BLKSIZE - 4 * avctx->channels) * 8 / (4 * avctx->channels) + 1; /* each 16 bits sample gives one nibble */ |
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
170 /* and we have 4 bytes per channel overhead */ |
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
171 avctx->block_align = BLKSIZE; |
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
172 /* seems frame_size isn't taken into account... have to buffer the samples :-( */ |
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
173 break; |
6461 | 174 case CODEC_ID_ADPCM_IMA_QT: |
175 avctx->frame_size = 64; | |
176 avctx->block_align = 34 * avctx->channels; | |
177 break; | |
577
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
178 case CODEC_ID_ADPCM_MS: |
1794 | 179 avctx->frame_size = (BLKSIZE - 7 * avctx->channels) * 2 / avctx->channels + 2; /* each 16 bits sample gives one nibble */ |
180 /* and we have 7 bytes per channel overhead */ | |
181 avctx->block_align = BLKSIZE; | |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
182 break; |
2794
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
183 case CODEC_ID_ADPCM_YAMAHA: |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
184 avctx->frame_size = BLKSIZE * avctx->channels; |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
185 avctx->block_align = BLKSIZE; |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
186 break; |
4840 | 187 case CODEC_ID_ADPCM_SWF: |
5370
bbb982818ce7
Calculate the correct blocksize for flash adpcm. Patch by Baptiste
banan
parents:
5129
diff
changeset
|
188 if (avctx->sample_rate != 11025 && |
bbb982818ce7
Calculate the correct blocksize for flash adpcm. Patch by Baptiste
banan
parents:
5129
diff
changeset
|
189 avctx->sample_rate != 22050 && |
bbb982818ce7
Calculate the correct blocksize for flash adpcm. Patch by Baptiste
banan
parents:
5129
diff
changeset
|
190 avctx->sample_rate != 44100) { |
bbb982818ce7
Calculate the correct blocksize for flash adpcm. Patch by Baptiste
banan
parents:
5129
diff
changeset
|
191 av_log(avctx, AV_LOG_ERROR, "Sample rate must be 11025, 22050 or 44100\n"); |
bbb982818ce7
Calculate the correct blocksize for flash adpcm. Patch by Baptiste
banan
parents:
5129
diff
changeset
|
192 return -1; |
bbb982818ce7
Calculate the correct blocksize for flash adpcm. Patch by Baptiste
banan
parents:
5129
diff
changeset
|
193 } |
bbb982818ce7
Calculate the correct blocksize for flash adpcm. Patch by Baptiste
banan
parents:
5129
diff
changeset
|
194 avctx->frame_size = 512 * (avctx->sample_rate / 11025); |
4840 | 195 break; |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
196 default: |
577
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
197 return -1; |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
198 break; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
199 } |
925 | 200 |
201 avctx->coded_frame= avcodec_alloc_frame(); | |
202 avctx->coded_frame->key_frame= 1; | |
203 | |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
204 return 0; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
205 } |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
206 |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
207 static int adpcm_encode_close(AVCodecContext *avctx) |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
208 { |
925 | 209 av_freep(&avctx->coded_frame); |
210 | |
577
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
211 return 0; |
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
212 } |
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
213 |
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
214 |
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
215 static inline unsigned char adpcm_ima_compress_sample(ADPCMChannelStatus *c, short sample) |
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
216 { |
3334 | 217 int delta = sample - c->prev_sample; |
218 int nibble = FFMIN(7, abs(delta)*4/step_table[c->step_index]) + (delta<0)*8; | |
5525
bc4791868c52
various simplifications around recent av_clip_int16() usage
aurel
parents:
5523
diff
changeset
|
219 c->prev_sample += ((step_table[c->step_index] * yamaha_difflookup[nibble]) / 8); |
5523 | 220 c->prev_sample = av_clip_int16(c->prev_sample); |
4594 | 221 c->step_index = av_clip(c->step_index + index_table[nibble], 0, 88); |
577
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
222 return nibble; |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
223 } |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
224 |
1794 | 225 static inline unsigned char adpcm_ms_compress_sample(ADPCMChannelStatus *c, short sample) |
226 { | |
227 int predictor, nibble, bias; | |
228 | |
229 predictor = (((c->sample1) * (c->coeff1)) + ((c->sample2) * (c->coeff2))) / 256; | |
2967 | 230 |
1794 | 231 nibble= sample - predictor; |
232 if(nibble>=0) bias= c->idelta/2; | |
233 else bias=-c->idelta/2; | |
2967 | 234 |
1794 | 235 nibble= (nibble + bias) / c->idelta; |
4594 | 236 nibble= av_clip(nibble, -8, 7)&0x0F; |
2967 | 237 |
1794 | 238 predictor += (signed)((nibble & 0x08)?(nibble - 0x10):(nibble)) * c->idelta; |
239 | |
240 c->sample2 = c->sample1; | |
5525
bc4791868c52
various simplifications around recent av_clip_int16() usage
aurel
parents:
5523
diff
changeset
|
241 c->sample1 = av_clip_int16(predictor); |
1794 | 242 |
243 c->idelta = (AdaptationTable[(int)nibble] * c->idelta) >> 8; | |
244 if (c->idelta < 16) c->idelta = 16; | |
245 | |
246 return nibble; | |
247 } | |
248 | |
2794
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
249 static inline unsigned char adpcm_yamaha_compress_sample(ADPCMChannelStatus *c, short sample) |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
250 { |
3334 | 251 int nibble, delta; |
2794
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
252 |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
253 if(!c->step) { |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
254 c->predictor = 0; |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
255 c->step = 127; |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
256 } |
3334 | 257 |
258 delta = sample - c->predictor; | |
2794
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
259 |
3334 | 260 nibble = FFMIN(7, abs(delta)*4/c->step) + (delta<0)*8; |
2794
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
261 |
5525
bc4791868c52
various simplifications around recent av_clip_int16() usage
aurel
parents:
5523
diff
changeset
|
262 c->predictor += ((c->step * yamaha_difflookup[nibble]) / 8); |
5523 | 263 c->predictor = av_clip_int16(c->predictor); |
3334 | 264 c->step = (c->step * yamaha_indexscale[nibble]) >> 8; |
4594 | 265 c->step = av_clip(c->step, 127, 24567); |
2794
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
266 |
3334 | 267 return nibble; |
2794
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
268 } |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
269 |
3336 | 270 typedef struct TrellisPath { |
271 int nibble; | |
272 int prev; | |
273 } TrellisPath; | |
274 | |
275 typedef struct TrellisNode { | |
276 uint32_t ssd; | |
277 int path; | |
278 int sample1; | |
279 int sample2; | |
280 int step; | |
281 } TrellisNode; | |
282 | |
283 static void adpcm_compress_trellis(AVCodecContext *avctx, const short *samples, | |
284 uint8_t *dst, ADPCMChannelStatus *c, int n) | |
285 { | |
286 #define FREEZE_INTERVAL 128 | |
287 //FIXME 6% faster if frontier is a compile-time constant | |
288 const int frontier = 1 << avctx->trellis; | |
289 const int stride = avctx->channels; | |
290 const int version = avctx->codec->id; | |
291 const int max_paths = frontier*FREEZE_INTERVAL; | |
292 TrellisPath paths[max_paths], *p; | |
293 TrellisNode node_buf[2][frontier]; | |
294 TrellisNode *nodep_buf[2][frontier]; | |
295 TrellisNode **nodes = nodep_buf[0]; // nodes[] is always sorted by .ssd | |
296 TrellisNode **nodes_next = nodep_buf[1]; | |
297 int pathn = 0, froze = -1, i, j, k; | |
298 | |
299 assert(!(max_paths&(max_paths-1))); | |
300 | |
301 memset(nodep_buf, 0, sizeof(nodep_buf)); | |
302 nodes[0] = &node_buf[1][0]; | |
303 nodes[0]->ssd = 0; | |
304 nodes[0]->path = 0; | |
305 nodes[0]->step = c->step_index; | |
306 nodes[0]->sample1 = c->sample1; | |
307 nodes[0]->sample2 = c->sample2; | |
6461 | 308 if((version == CODEC_ID_ADPCM_IMA_WAV) || (version == CODEC_ID_ADPCM_IMA_QT) || (version == CODEC_ID_ADPCM_SWF)) |
3336 | 309 nodes[0]->sample1 = c->prev_sample; |
310 if(version == CODEC_ID_ADPCM_MS) | |
311 nodes[0]->step = c->idelta; | |
312 if(version == CODEC_ID_ADPCM_YAMAHA) { | |
313 if(c->step == 0) { | |
314 nodes[0]->step = 127; | |
315 nodes[0]->sample1 = 0; | |
316 } else { | |
317 nodes[0]->step = c->step; | |
318 nodes[0]->sample1 = c->predictor; | |
319 } | |
320 } | |
321 | |
322 for(i=0; i<n; i++) { | |
323 TrellisNode *t = node_buf[i&1]; | |
324 TrellisNode **u; | |
325 int sample = samples[i*stride]; | |
326 memset(nodes_next, 0, frontier*sizeof(TrellisNode*)); | |
327 for(j=0; j<frontier && nodes[j]; j++) { | |
328 // higher j have higher ssd already, so they're unlikely to use a suboptimal next sample too | |
329 const int range = (j < frontier/2) ? 1 : 0; | |
330 const int step = nodes[j]->step; | |
331 int nidx; | |
332 if(version == CODEC_ID_ADPCM_MS) { | |
333 const int predictor = ((nodes[j]->sample1 * c->coeff1) + (nodes[j]->sample2 * c->coeff2)) / 256; | |
334 const int div = (sample - predictor) / step; | |
4594 | 335 const int nmin = av_clip(div-range, -8, 6); |
336 const int nmax = av_clip(div+range, -7, 7); | |
3336 | 337 for(nidx=nmin; nidx<=nmax; nidx++) { |
338 const int nibble = nidx & 0xf; | |
339 int dec_sample = predictor + nidx * step; | |
340 #define STORE_NODE(NAME, STEP_INDEX)\ | |
341 int d;\ | |
342 uint32_t ssd;\ | |
5523 | 343 dec_sample = av_clip_int16(dec_sample);\ |
3336 | 344 d = sample - dec_sample;\ |
345 ssd = nodes[j]->ssd + d*d;\ | |
346 if(nodes_next[frontier-1] && ssd >= nodes_next[frontier-1]->ssd)\ | |
347 continue;\ | |
348 /* Collapse any two states with the same previous sample value. \ | |
349 * One could also distinguish states by step and by 2nd to last | |
350 * sample, but the effects of that are negligible. */\ | |
351 for(k=0; k<frontier && nodes_next[k]; k++) {\ | |
352 if(dec_sample == nodes_next[k]->sample1) {\ | |
353 assert(ssd >= nodes_next[k]->ssd);\ | |
354 goto next_##NAME;\ | |
355 }\ | |
356 }\ | |
357 for(k=0; k<frontier; k++) {\ | |
358 if(!nodes_next[k] || ssd < nodes_next[k]->ssd) {\ | |
359 TrellisNode *u = nodes_next[frontier-1];\ | |
360 if(!u) {\ | |
361 assert(pathn < max_paths);\ | |
362 u = t++;\ | |
363 u->path = pathn++;\ | |
364 }\ | |
365 u->ssd = ssd;\ | |
366 u->step = STEP_INDEX;\ | |
367 u->sample2 = nodes[j]->sample1;\ | |
368 u->sample1 = dec_sample;\ | |
369 paths[u->path].nibble = nibble;\ | |
370 paths[u->path].prev = nodes[j]->path;\ | |
371 memmove(&nodes_next[k+1], &nodes_next[k], (frontier-k-1)*sizeof(TrellisNode*));\ | |
372 nodes_next[k] = u;\ | |
373 break;\ | |
374 }\ | |
375 }\ | |
376 next_##NAME:; | |
377 STORE_NODE(ms, FFMAX(16, (AdaptationTable[nibble] * step) >> 8)); | |
378 } | |
6461 | 379 } else if((version == CODEC_ID_ADPCM_IMA_WAV)|| (version == CODEC_ID_ADPCM_IMA_QT)|| (version == CODEC_ID_ADPCM_SWF)) { |
3336 | 380 #define LOOP_NODES(NAME, STEP_TABLE, STEP_INDEX)\ |
381 const int predictor = nodes[j]->sample1;\ | |
382 const int div = (sample - predictor) * 4 / STEP_TABLE;\ | |
4594 | 383 int nmin = av_clip(div-range, -7, 6);\ |
384 int nmax = av_clip(div+range, -6, 7);\ | |
3336 | 385 if(nmin<=0) nmin--; /* distinguish -0 from +0 */\ |
386 if(nmax<0) nmax--;\ | |
387 for(nidx=nmin; nidx<=nmax; nidx++) {\ | |
388 const int nibble = nidx<0 ? 7-nidx : nidx;\ | |
389 int dec_sample = predictor + (STEP_TABLE * yamaha_difflookup[nibble]) / 8;\ | |
390 STORE_NODE(NAME, STEP_INDEX);\ | |
391 } | |
4594 | 392 LOOP_NODES(ima, step_table[step], av_clip(step + index_table[nibble], 0, 88)); |
3336 | 393 } else { //CODEC_ID_ADPCM_YAMAHA |
4594 | 394 LOOP_NODES(yamaha, step, av_clip((step * yamaha_indexscale[nibble]) >> 8, 127, 24567)); |
3336 | 395 #undef LOOP_NODES |
396 #undef STORE_NODE | |
397 } | |
398 } | |
399 | |
400 u = nodes; | |
401 nodes = nodes_next; | |
402 nodes_next = u; | |
403 | |
404 // prevent overflow | |
405 if(nodes[0]->ssd > (1<<28)) { | |
406 for(j=1; j<frontier && nodes[j]; j++) | |
407 nodes[j]->ssd -= nodes[0]->ssd; | |
408 nodes[0]->ssd = 0; | |
409 } | |
410 | |
411 // merge old paths to save memory | |
412 if(i == froze + FREEZE_INTERVAL) { | |
413 p = &paths[nodes[0]->path]; | |
414 for(k=i; k>froze; k--) { | |
415 dst[k] = p->nibble; | |
416 p = &paths[p->prev]; | |
417 } | |
418 froze = i; | |
419 pathn = 0; | |
420 // other nodes might use paths that don't coincide with the frozen one. | |
421 // checking which nodes do so is too slow, so just kill them all. | |
422 // this also slightly improves quality, but I don't know why. | |
423 memset(nodes+1, 0, (frontier-1)*sizeof(TrellisNode*)); | |
424 } | |
425 } | |
426 | |
427 p = &paths[nodes[0]->path]; | |
428 for(i=n-1; i>froze; i--) { | |
429 dst[i] = p->nibble; | |
430 p = &paths[p->prev]; | |
431 } | |
432 | |
433 c->predictor = nodes[0]->sample1; | |
434 c->sample1 = nodes[0]->sample1; | |
435 c->sample2 = nodes[0]->sample2; | |
436 c->step_index = nodes[0]->step; | |
437 c->step = nodes[0]->step; | |
438 c->idelta = nodes[0]->step; | |
439 } | |
440 | |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
441 static int adpcm_encode_frame(AVCodecContext *avctx, |
2979 | 442 unsigned char *frame, int buf_size, void *data) |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
443 { |
1794 | 444 int n, i, st; |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
445 short *samples; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
446 unsigned char *dst; |
577
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
447 ADPCMContext *c = avctx->priv_data; |
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
448 |
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
449 dst = frame; |
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
450 samples = (short *)data; |
1794 | 451 st= avctx->channels == 2; |
577
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
452 /* n = (BLKSIZE - 4 * avctx->channels) / (2 * 8 * avctx->channels); */ |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
453 |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
454 switch(avctx->codec->id) { |
577
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
455 case CODEC_ID_ADPCM_IMA_WAV: |
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
456 n = avctx->frame_size / 8; |
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
457 c->status[0].prev_sample = (signed short)samples[0]; /* XXX */ |
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
458 /* c->status[0].step_index = 0; *//* XXX: not sure how to init the state machine */ |
5089 | 459 bytestream_put_le16(&dst, c->status[0].prev_sample); |
577
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
460 *dst++ = (unsigned char)c->status[0].step_index; |
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
461 *dst++ = 0; /* unknown */ |
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
462 samples++; |
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
463 if (avctx->channels == 2) { |
5877
aea495619138
fix predictor initialization for adpcm-ima encoder not to lose first sample
benoit
parents:
5870
diff
changeset
|
464 c->status[1].prev_sample = (signed short)samples[0]; |
577
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
465 /* c->status[1].step_index = 0; */ |
5089 | 466 bytestream_put_le16(&dst, c->status[1].prev_sample); |
577
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
467 *dst++ = (unsigned char)c->status[1].step_index; |
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
468 *dst++ = 0; |
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
469 samples++; |
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
470 } |
2967 | 471 |
577
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
472 /* stereo: 4 bytes (8 samples) for left, 4 bytes for right, 4 bytes left, ... */ |
3336 | 473 if(avctx->trellis > 0) { |
474 uint8_t buf[2][n*8]; | |
475 adpcm_compress_trellis(avctx, samples, buf[0], &c->status[0], n*8); | |
476 if(avctx->channels == 2) | |
477 adpcm_compress_trellis(avctx, samples+1, buf[1], &c->status[1], n*8); | |
478 for(i=0; i<n; i++) { | |
479 *dst++ = buf[0][8*i+0] | (buf[0][8*i+1] << 4); | |
480 *dst++ = buf[0][8*i+2] | (buf[0][8*i+3] << 4); | |
481 *dst++ = buf[0][8*i+4] | (buf[0][8*i+5] << 4); | |
482 *dst++ = buf[0][8*i+6] | (buf[0][8*i+7] << 4); | |
483 if (avctx->channels == 2) { | |
484 *dst++ = buf[1][8*i+0] | (buf[1][8*i+1] << 4); | |
485 *dst++ = buf[1][8*i+2] | (buf[1][8*i+3] << 4); | |
486 *dst++ = buf[1][8*i+4] | (buf[1][8*i+5] << 4); | |
487 *dst++ = buf[1][8*i+6] | (buf[1][8*i+7] << 4); | |
488 } | |
489 } | |
490 } else | |
577
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
491 for (; n>0; n--) { |
5834
1edffbe7d57d
Remove unnecessary guarding &=0x0f around adpcm_ima_compress_sample().
diego
parents:
5775
diff
changeset
|
492 *dst = adpcm_ima_compress_sample(&c->status[0], samples[0]); |
1edffbe7d57d
Remove unnecessary guarding &=0x0f around adpcm_ima_compress_sample().
diego
parents:
5775
diff
changeset
|
493 *dst |= adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels]) << 4; |
577
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
494 dst++; |
5834
1edffbe7d57d
Remove unnecessary guarding &=0x0f around adpcm_ima_compress_sample().
diego
parents:
5775
diff
changeset
|
495 *dst = adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels * 2]); |
1edffbe7d57d
Remove unnecessary guarding &=0x0f around adpcm_ima_compress_sample().
diego
parents:
5775
diff
changeset
|
496 *dst |= adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels * 3]) << 4; |
577
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
497 dst++; |
5834
1edffbe7d57d
Remove unnecessary guarding &=0x0f around adpcm_ima_compress_sample().
diego
parents:
5775
diff
changeset
|
498 *dst = adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels * 4]); |
1edffbe7d57d
Remove unnecessary guarding &=0x0f around adpcm_ima_compress_sample().
diego
parents:
5775
diff
changeset
|
499 *dst |= adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels * 5]) << 4; |
577
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
500 dst++; |
5834
1edffbe7d57d
Remove unnecessary guarding &=0x0f around adpcm_ima_compress_sample().
diego
parents:
5775
diff
changeset
|
501 *dst = adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels * 6]); |
1edffbe7d57d
Remove unnecessary guarding &=0x0f around adpcm_ima_compress_sample().
diego
parents:
5775
diff
changeset
|
502 *dst |= adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels * 7]) << 4; |
577
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
503 dst++; |
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
504 /* right channel */ |
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
505 if (avctx->channels == 2) { |
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
506 *dst = adpcm_ima_compress_sample(&c->status[1], samples[1]); |
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
507 *dst |= adpcm_ima_compress_sample(&c->status[1], samples[3]) << 4; |
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
508 dst++; |
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
509 *dst = adpcm_ima_compress_sample(&c->status[1], samples[5]); |
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
510 *dst |= adpcm_ima_compress_sample(&c->status[1], samples[7]) << 4; |
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
511 dst++; |
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
512 *dst = adpcm_ima_compress_sample(&c->status[1], samples[9]); |
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
513 *dst |= adpcm_ima_compress_sample(&c->status[1], samples[11]) << 4; |
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
514 dst++; |
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
515 *dst = adpcm_ima_compress_sample(&c->status[1], samples[13]); |
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
516 *dst |= adpcm_ima_compress_sample(&c->status[1], samples[15]) << 4; |
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
517 dst++; |
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
518 } |
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
519 samples += 8 * avctx->channels; |
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
520 } |
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
521 break; |
6461 | 522 case CODEC_ID_ADPCM_IMA_QT: |
523 { | |
524 int ch, i; | |
525 PutBitContext pb; | |
526 init_put_bits(&pb, dst, buf_size*8); | |
527 | |
528 for(ch=0; ch<avctx->channels; ch++){ | |
529 put_bits(&pb, 9, (c->status[ch].prev_sample + 0x10000) >> 7); | |
530 put_bits(&pb, 7, c->status[ch].step_index); | |
531 if(avctx->trellis > 0) { | |
532 uint8_t buf[64]; | |
533 adpcm_compress_trellis(avctx, samples+ch, buf, &c->status[ch], 64); | |
534 for(i=0; i<64; i++) | |
535 put_bits(&pb, 4, buf[i^1]); | |
536 c->status[ch].prev_sample = c->status[ch].predictor & ~0x7F; | |
537 } else { | |
538 for (i=0; i<64; i+=2){ | |
539 int t1, t2; | |
540 t1 = adpcm_ima_compress_sample(&c->status[ch], samples[avctx->channels*(i+0)+ch]); | |
541 t2 = adpcm_ima_compress_sample(&c->status[ch], samples[avctx->channels*(i+1)+ch]); | |
542 put_bits(&pb, 4, t2); | |
543 put_bits(&pb, 4, t1); | |
544 } | |
545 c->status[ch].prev_sample &= ~0x7F; | |
546 } | |
547 } | |
548 | |
549 dst += put_bits_count(&pb)>>3; | |
550 break; | |
551 } | |
4840 | 552 case CODEC_ID_ADPCM_SWF: |
553 { | |
554 int i; | |
555 PutBitContext pb; | |
556 init_put_bits(&pb, dst, buf_size*8); | |
557 | |
5549 | 558 n = avctx->frame_size-1; |
559 | |
4840 | 560 //Store AdpcmCodeSize |
561 put_bits(&pb, 2, 2); //Set 4bits flash adpcm format | |
562 | |
563 //Init the encoder state | |
564 for(i=0; i<avctx->channels; i++){ | |
5371
74680ec68fd1
Set the step index correctly for flash adpcm. Patch by Baptiste
banan
parents:
5370
diff
changeset
|
565 c->status[i].step_index = av_clip(c->status[i].step_index, 0, 63); // clip step so it fits 6 bits |
4840 | 566 put_bits(&pb, 16, samples[i] & 0xFFFF); |
5371
74680ec68fd1
Set the step index correctly for flash adpcm. Patch by Baptiste
banan
parents:
5370
diff
changeset
|
567 put_bits(&pb, 6, c->status[i].step_index); |
4840 | 568 c->status[i].prev_sample = (signed short)samples[i]; |
569 } | |
570 | |
5549 | 571 if(avctx->trellis > 0) { |
572 uint8_t buf[2][n]; | |
573 adpcm_compress_trellis(avctx, samples+2, buf[0], &c->status[0], n); | |
574 if (avctx->channels == 2) | |
575 adpcm_compress_trellis(avctx, samples+3, buf[1], &c->status[1], n); | |
576 for(i=0; i<n; i++) { | |
577 put_bits(&pb, 4, buf[0][i]); | |
578 if (avctx->channels == 2) | |
579 put_bits(&pb, 4, buf[1][i]); | |
580 } | |
581 } else { | |
5550 | 582 for (i=1; i<avctx->frame_size; i++) { |
5834
1edffbe7d57d
Remove unnecessary guarding &=0x0f around adpcm_ima_compress_sample().
diego
parents:
5775
diff
changeset
|
583 put_bits(&pb, 4, adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels*i])); |
5550 | 584 if (avctx->channels == 2) |
5834
1edffbe7d57d
Remove unnecessary guarding &=0x0f around adpcm_ima_compress_sample().
diego
parents:
5775
diff
changeset
|
585 put_bits(&pb, 4, adpcm_ima_compress_sample(&c->status[1], samples[2*i+1])); |
5549 | 586 } |
4840 | 587 } |
5370
bbb982818ce7
Calculate the correct blocksize for flash adpcm. Patch by Baptiste
banan
parents:
5129
diff
changeset
|
588 flush_put_bits(&pb); |
bbb982818ce7
Calculate the correct blocksize for flash adpcm. Patch by Baptiste
banan
parents:
5129
diff
changeset
|
589 dst += put_bits_count(&pb)>>3; |
4840 | 590 break; |
591 } | |
1794 | 592 case CODEC_ID_ADPCM_MS: |
593 for(i=0; i<avctx->channels; i++){ | |
594 int predictor=0; | |
595 | |
596 *dst++ = predictor; | |
597 c->status[i].coeff1 = AdaptCoeff1[predictor]; | |
598 c->status[i].coeff2 = AdaptCoeff2[predictor]; | |
599 } | |
600 for(i=0; i<avctx->channels; i++){ | |
2967 | 601 if (c->status[i].idelta < 16) |
1794 | 602 c->status[i].idelta = 16; |
2967 | 603 |
5089 | 604 bytestream_put_le16(&dst, c->status[i].idelta); |
1794 | 605 } |
606 for(i=0; i<avctx->channels; i++){ | |
607 c->status[i].sample1= *samples++; | |
608 | |
5089 | 609 bytestream_put_le16(&dst, c->status[i].sample1); |
1794 | 610 } |
611 for(i=0; i<avctx->channels; i++){ | |
612 c->status[i].sample2= *samples++; | |
613 | |
5089 | 614 bytestream_put_le16(&dst, c->status[i].sample2); |
1794 | 615 } |
616 | |
3336 | 617 if(avctx->trellis > 0) { |
618 int n = avctx->block_align - 7*avctx->channels; | |
619 uint8_t buf[2][n]; | |
620 if(avctx->channels == 1) { | |
621 n *= 2; | |
622 adpcm_compress_trellis(avctx, samples, buf[0], &c->status[0], n); | |
623 for(i=0; i<n; i+=2) | |
624 *dst++ = (buf[0][i] << 4) | buf[0][i+1]; | |
625 } else { | |
626 adpcm_compress_trellis(avctx, samples, buf[0], &c->status[0], n); | |
627 adpcm_compress_trellis(avctx, samples+1, buf[1], &c->status[1], n); | |
628 for(i=0; i<n; i++) | |
629 *dst++ = (buf[0][i] << 4) | buf[1][i]; | |
630 } | |
631 } else | |
1794 | 632 for(i=7*avctx->channels; i<avctx->block_align; i++) { |
633 int nibble; | |
634 nibble = adpcm_ms_compress_sample(&c->status[ 0], *samples++)<<4; | |
635 nibble|= adpcm_ms_compress_sample(&c->status[st], *samples++); | |
636 *dst++ = nibble; | |
637 } | |
638 break; | |
2794
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
639 case CODEC_ID_ADPCM_YAMAHA: |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
640 n = avctx->frame_size / 2; |
3336 | 641 if(avctx->trellis > 0) { |
642 uint8_t buf[2][n*2]; | |
643 n *= 2; | |
644 if(avctx->channels == 1) { | |
645 adpcm_compress_trellis(avctx, samples, buf[0], &c->status[0], n); | |
646 for(i=0; i<n; i+=2) | |
647 *dst++ = buf[0][i] | (buf[0][i+1] << 4); | |
648 } else { | |
649 adpcm_compress_trellis(avctx, samples, buf[0], &c->status[0], n); | |
650 adpcm_compress_trellis(avctx, samples+1, buf[1], &c->status[1], n); | |
651 for(i=0; i<n; i++) | |
652 *dst++ = buf[0][i] | (buf[1][i] << 4); | |
653 } | |
654 } else | |
2794
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
655 for (; n>0; n--) { |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
656 for(i = 0; i < avctx->channels; i++) { |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
657 int nibble; |
2795
de03cac6f7c2
yamaha adpcm nibbles in the wrong order fix by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2794
diff
changeset
|
658 nibble = adpcm_yamaha_compress_sample(&c->status[i], samples[i]); |
de03cac6f7c2
yamaha adpcm nibbles in the wrong order fix by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2794
diff
changeset
|
659 nibble |= adpcm_yamaha_compress_sample(&c->status[i], samples[i+avctx->channels]) << 4; |
2794
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
660 *dst++ = nibble; |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
661 } |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
662 samples += 2 * avctx->channels; |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
663 } |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
664 break; |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
665 default: |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
666 return -1; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
667 } |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
668 return dst - frame; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
669 } |
1530
3b31998fe22f
disable encoders where appropriate (patch courtesy of BERO
melanson
parents:
1491
diff
changeset
|
670 #endif //CONFIG_ENCODERS |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
671 |
6517
48759bfbd073
Apply 'cold' attribute to init/uninit functions in libavcodec
zuxy
parents:
6461
diff
changeset
|
672 static av_cold int adpcm_decode_init(AVCodecContext * avctx) |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
673 { |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
674 ADPCMContext *c = avctx->priv_data; |
6678 | 675 unsigned int max_channels = 2; |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
676 |
5851 | 677 switch(avctx->codec->id) { |
678 case CODEC_ID_ADPCM_EA_R1: | |
679 case CODEC_ID_ADPCM_EA_R2: | |
680 case CODEC_ID_ADPCM_EA_R3: | |
681 max_channels = 6; | |
682 break; | |
683 } | |
684 if(avctx->channels > max_channels){ | |
4461
c95e0df9841f
some (probably exploitable) out of array write fixes
michael
parents:
4364
diff
changeset
|
685 return -1; |
c95e0df9841f
some (probably exploitable) out of array write fixes
michael
parents:
4364
diff
changeset
|
686 } |
c95e0df9841f
some (probably exploitable) out of array write fixes
michael
parents:
4364
diff
changeset
|
687 |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
688 switch(avctx->codec->id) { |
2296
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
689 case CODEC_ID_ADPCM_CT: |
2979 | 690 c->status[0].step = c->status[1].step = 511; |
691 break; | |
4809 | 692 case CODEC_ID_ADPCM_IMA_WS: |
693 if (avctx->extradata && avctx->extradata_size == 2 * 4) { | |
694 c->status[0].predictor = AV_RL32(avctx->extradata); | |
695 c->status[1].predictor = AV_RL32(avctx->extradata + 4); | |
696 } | |
697 break; | |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
698 default: |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
699 break; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
700 } |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
701 return 0; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
702 } |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
703 |
1737 | 704 static inline short adpcm_ima_expand_nibble(ADPCMChannelStatus *c, char nibble, int shift) |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
705 { |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
706 int step_index; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
707 int predictor; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
708 int sign, delta, diff, step; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
709 |
1081
18157900b434
* fixed IMA WAV decoding (though still might not be fully correct)
kabi
parents:
1064
diff
changeset
|
710 step = step_table[c->step_index]; |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
711 step_index = c->step_index + index_table[(unsigned)nibble]; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
712 if (step_index < 0) step_index = 0; |
1081
18157900b434
* fixed IMA WAV decoding (though still might not be fully correct)
kabi
parents:
1064
diff
changeset
|
713 else if (step_index > 88) step_index = 88; |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
714 |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
715 sign = nibble & 8; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
716 delta = nibble & 7; |
1443
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
717 /* perform direct multiplication instead of series of jumps proposed by |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
718 * the reference ADPCM implementation since modern CPUs can do the mults |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
719 * quickly enough */ |
1737 | 720 diff = ((2 * delta + 1) * step) >> shift; |
1296 | 721 predictor = c->predictor; |
722 if (sign) predictor -= diff; | |
723 else predictor += diff; | |
724 | |
5525
bc4791868c52
various simplifications around recent av_clip_int16() usage
aurel
parents:
5523
diff
changeset
|
725 c->predictor = av_clip_int16(predictor); |
1296 | 726 c->step_index = step_index; |
727 | |
5525
bc4791868c52
various simplifications around recent av_clip_int16() usage
aurel
parents:
5523
diff
changeset
|
728 return (short)c->predictor; |
1296 | 729 } |
730 | |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
731 static inline short adpcm_ms_expand_nibble(ADPCMChannelStatus *c, char nibble) |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
732 { |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
733 int predictor; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
734 |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
735 predictor = (((c->sample1) * (c->coeff1)) + ((c->sample2) * (c->coeff2))) / 256; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
736 predictor += (signed)((nibble & 0x08)?(nibble - 0x10):(nibble)) * c->idelta; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
737 |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
738 c->sample2 = c->sample1; |
5525
bc4791868c52
various simplifications around recent av_clip_int16() usage
aurel
parents:
5523
diff
changeset
|
739 c->sample1 = av_clip_int16(predictor); |
1794 | 740 c->idelta = (AdaptationTable[(int)nibble] * c->idelta) >> 8; |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
741 if (c->idelta < 16) c->idelta = 16; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
742 |
5525
bc4791868c52
various simplifications around recent av_clip_int16() usage
aurel
parents:
5523
diff
changeset
|
743 return c->sample1; |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
744 } |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
745 |
2296
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
746 static inline short adpcm_ct_expand_nibble(ADPCMChannelStatus *c, char nibble) |
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
747 { |
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
748 int sign, delta, diff; |
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
749 int new_step; |
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
750 |
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
751 sign = nibble & 8; |
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
752 delta = nibble & 7; |
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
753 /* perform direct multiplication instead of series of jumps proposed by |
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
754 * the reference ADPCM implementation since modern CPUs can do the mults |
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
755 * quickly enough */ |
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
756 diff = ((2 * delta + 1) * c->step) >> 3; |
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
757 /* predictor update is not so trivial: predictor is multiplied on 254/256 before updating */ |
5526 | 758 c->predictor = ((c->predictor * 254) >> 8) + (sign ? -diff : diff); |
759 c->predictor = av_clip_int16(c->predictor); | |
2296
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
760 /* calculate new step and clamp it to range 511..32767 */ |
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
761 new_step = (ct_adpcm_table[nibble & 7] * c->step) >> 8; |
5527 | 762 c->step = av_clip(new_step, 511, 32767); |
2296
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
763 |
5525
bc4791868c52
various simplifications around recent av_clip_int16() usage
aurel
parents:
5523
diff
changeset
|
764 return (short)c->predictor; |
2296
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
765 } |
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
766 |
3127 | 767 static inline short adpcm_sbpro_expand_nibble(ADPCMChannelStatus *c, char nibble, int size, int shift) |
768 { | |
769 int sign, delta, diff; | |
770 | |
771 sign = nibble & (1<<(size-1)); | |
772 delta = nibble & ((1<<(size-1))-1); | |
773 diff = delta << (7 + c->step + shift); | |
774 | |
775 /* clamp result */ | |
5527 | 776 c->predictor = av_clip(c->predictor + (sign ? -diff : diff), -16384,16256); |
3127 | 777 |
778 /* calculate new step */ | |
779 if (delta >= (2*size - 3) && c->step < 3) | |
780 c->step++; | |
781 else if (delta == 0 && c->step > 0) | |
782 c->step--; | |
783 | |
784 return (short) c->predictor; | |
785 } | |
786 | |
2794
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
787 static inline short adpcm_yamaha_expand_nibble(ADPCMChannelStatus *c, unsigned char nibble) |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
788 { |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
789 if(!c->step) { |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
790 c->predictor = 0; |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
791 c->step = 127; |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
792 } |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
793 |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
794 c->predictor += (c->step * yamaha_difflookup[nibble]) / 8; |
5523 | 795 c->predictor = av_clip_int16(c->predictor); |
2794
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
796 c->step = (c->step * yamaha_indexscale[nibble]) >> 8; |
4594 | 797 c->step = av_clip(c->step, 127, 24567); |
2794
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
798 return c->predictor; |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
799 } |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
800 |
2967 | 801 static void xa_decode(short *out, const unsigned char *in, |
1535 | 802 ADPCMChannelStatus *left, ADPCMChannelStatus *right, int inc) |
803 { | |
804 int i, j; | |
805 int shift,filter,f0,f1; | |
806 int s_1,s_2; | |
807 int d,s,t; | |
808 | |
809 for(i=0;i<4;i++) { | |
810 | |
811 shift = 12 - (in[4+i*2] & 15); | |
812 filter = in[4+i*2] >> 4; | |
813 f0 = xa_adpcm_table[filter][0]; | |
814 f1 = xa_adpcm_table[filter][1]; | |
815 | |
816 s_1 = left->sample1; | |
817 s_2 = left->sample2; | |
818 | |
819 for(j=0;j<28;j++) { | |
820 d = in[16+i+j*4]; | |
821 | |
822 t = (signed char)(d<<4)>>4; | |
823 s = ( t<<shift ) + ((s_1*f0 + s_2*f1+32)>>6); | |
5525
bc4791868c52
various simplifications around recent av_clip_int16() usage
aurel
parents:
5523
diff
changeset
|
824 s_2 = s_1; |
bc4791868c52
various simplifications around recent av_clip_int16() usage
aurel
parents:
5523
diff
changeset
|
825 s_1 = av_clip_int16(s); |
bc4791868c52
various simplifications around recent av_clip_int16() usage
aurel
parents:
5523
diff
changeset
|
826 *out = s_1; |
1535 | 827 out += inc; |
828 } | |
829 | |
830 if (inc==2) { /* stereo */ | |
831 left->sample1 = s_1; | |
832 left->sample2 = s_2; | |
833 s_1 = right->sample1; | |
834 s_2 = right->sample2; | |
835 out = out + 1 - 28*2; | |
836 } | |
837 | |
838 shift = 12 - (in[5+i*2] & 15); | |
839 filter = in[5+i*2] >> 4; | |
840 | |
841 f0 = xa_adpcm_table[filter][0]; | |
842 f1 = xa_adpcm_table[filter][1]; | |
843 | |
844 for(j=0;j<28;j++) { | |
845 d = in[16+i+j*4]; | |
846 | |
847 t = (signed char)d >> 4; | |
848 s = ( t<<shift ) + ((s_1*f0 + s_2*f1+32)>>6); | |
5525
bc4791868c52
various simplifications around recent av_clip_int16() usage
aurel
parents:
5523
diff
changeset
|
849 s_2 = s_1; |
bc4791868c52
various simplifications around recent av_clip_int16() usage
aurel
parents:
5523
diff
changeset
|
850 s_1 = av_clip_int16(s); |
bc4791868c52
various simplifications around recent av_clip_int16() usage
aurel
parents:
5523
diff
changeset
|
851 *out = s_1; |
1535 | 852 out += inc; |
853 } | |
854 | |
855 if (inc==2) { /* stereo */ | |
856 right->sample1 = s_1; | |
857 right->sample2 = s_2; | |
858 out -= 1; | |
859 } else { | |
860 left->sample1 = s_1; | |
861 left->sample2 = s_2; | |
862 } | |
863 } | |
864 } | |
865 | |
866 | |
1443
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
867 /* DK3 ADPCM support macro */ |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
868 #define DK3_GET_NEXT_NIBBLE() \ |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
869 if (decode_top_nibble_next) \ |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
870 { \ |
6586 | 871 nibble = last_byte >> 4; \ |
1443
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
872 decode_top_nibble_next = 0; \ |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
873 } \ |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
874 else \ |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
875 { \ |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
876 last_byte = *src++; \ |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
877 if (src >= buf + buf_size) break; \ |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
878 nibble = last_byte & 0x0F; \ |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
879 decode_top_nibble_next = 1; \ |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
880 } |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
881 |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
882 static int adpcm_decode_frame(AVCodecContext *avctx, |
2979 | 883 void *data, int *data_size, |
6259 | 884 const uint8_t *buf, int buf_size) |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
885 { |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
886 ADPCMContext *c = avctx->priv_data; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
887 ADPCMChannelStatus *cs; |
1296 | 888 int n, m, channel, i; |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
889 int block_predictor[2]; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
890 short *samples; |
4461
c95e0df9841f
some (probably exploitable) out of array write fixes
michael
parents:
4364
diff
changeset
|
891 short *samples_end; |
6259 | 892 const uint8_t *src; |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
893 int st; /* stereo */ |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
894 |
1443
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
895 /* DK3 ADPCM accounting variables */ |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
896 unsigned char last_byte = 0; |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
897 unsigned char nibble; |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
898 int decode_top_nibble_next = 0; |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
899 int diff_channel; |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
900 |
1779 | 901 /* EA ADPCM state variables */ |
902 uint32_t samples_in_chunk; | |
903 int32_t previous_left_sample, previous_right_sample; | |
904 int32_t current_left_sample, current_right_sample; | |
905 int32_t next_left_sample, next_right_sample; | |
906 int32_t coeff1l, coeff2l, coeff1r, coeff2r; | |
907 uint8_t shift_left, shift_right; | |
908 int count1, count2; | |
6596 | 909 int coeff[2][2], shift[2];//used in EA MAXIS ADPCM |
1779 | 910 |
1768 | 911 if (!buf_size) |
912 return 0; | |
913 | |
4461
c95e0df9841f
some (probably exploitable) out of array write fixes
michael
parents:
4364
diff
changeset
|
914 //should protect all 4bit ADPCM variants |
c95e0df9841f
some (probably exploitable) out of array write fixes
michael
parents:
4364
diff
changeset
|
915 //8 is needed for CODEC_ID_ADPCM_IMA_WAV with 2 channels |
c95e0df9841f
some (probably exploitable) out of array write fixes
michael
parents:
4364
diff
changeset
|
916 // |
c95e0df9841f
some (probably exploitable) out of array write fixes
michael
parents:
4364
diff
changeset
|
917 if(*data_size/4 < buf_size + 8) |
c95e0df9841f
some (probably exploitable) out of array write fixes
michael
parents:
4364
diff
changeset
|
918 return -1; |
c95e0df9841f
some (probably exploitable) out of array write fixes
michael
parents:
4364
diff
changeset
|
919 |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
920 samples = data; |
4461
c95e0df9841f
some (probably exploitable) out of array write fixes
michael
parents:
4364
diff
changeset
|
921 samples_end= samples + *data_size/2; |
c95e0df9841f
some (probably exploitable) out of array write fixes
michael
parents:
4364
diff
changeset
|
922 *data_size= 0; |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
923 src = buf; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
924 |
3127 | 925 st = avctx->channels == 2 ? 1 : 0; |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
926 |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
927 switch(avctx->codec->id) { |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
928 case CODEC_ID_ADPCM_IMA_QT: |
6677
abb1f01ca0db
remove ima qt decoding hack, decode whole frame at once
bcoudurier
parents:
6676
diff
changeset
|
929 n = buf_size - 2*avctx->channels; |
abb1f01ca0db
remove ima qt decoding hack, decode whole frame at once
bcoudurier
parents:
6676
diff
changeset
|
930 for (channel = 0; channel < avctx->channels; channel++) { |
6680 | 931 cs = &(c->status[channel]); |
932 /* (pppppp) (piiiiiii) */ | |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
933 |
6680 | 934 /* Bits 15-7 are the _top_ 9 bits of the 16-bit initial predictor value */ |
935 cs->predictor = (*src++) << 8; | |
936 cs->predictor |= (*src & 0x80); | |
937 cs->predictor &= 0xFF80; | |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
938 |
6680 | 939 /* sign extension */ |
940 if(cs->predictor & 0x8000) | |
941 cs->predictor -= 0x10000; | |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
942 |
6680 | 943 cs->predictor = av_clip_int16(cs->predictor); |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
944 |
6680 | 945 cs->step_index = (*src++) & 0x7F; |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
946 |
6680 | 947 if (cs->step_index > 88){ |
948 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index = %i\n", cs->step_index); | |
949 cs->step_index = 88; | |
950 } | |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
951 |
6680 | 952 cs->step = step_table[cs->step_index]; |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
953 |
6680 | 954 samples = (short*)data + channel; |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
955 |
6680 | 956 for(m=32; n>0 && m>0; n--, m--) { /* in QuickTime, IMA is encoded by chuncks of 34 bytes (=64 samples) */ |
957 *samples = adpcm_ima_expand_nibble(cs, src[0] & 0x0F, 3); | |
958 samples += avctx->channels; | |
959 *samples = adpcm_ima_expand_nibble(cs, src[0] >> 4 , 3); | |
960 samples += avctx->channels; | |
961 src ++; | |
962 } | |
6677
abb1f01ca0db
remove ima qt decoding hack, decode whole frame at once
bcoudurier
parents:
6676
diff
changeset
|
963 } |
abb1f01ca0db
remove ima qt decoding hack, decode whole frame at once
bcoudurier
parents:
6676
diff
changeset
|
964 if (st) |
6676
36d091f338ca
fix adpcm ima qt decoding, channel at init is 0, correct stereo out since samples += avctx->channels
bcoudurier
parents:
6637
diff
changeset
|
965 samples--; |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
966 break; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
967 case CODEC_ID_ADPCM_IMA_WAV: |
1576
bc4b13ca74de
block algn patch by ("Assaf Yaari" <assafy at mobixell dot com>)
michael
parents:
1559
diff
changeset
|
968 if (avctx->block_align != 0 && buf_size > avctx->block_align) |
bc4b13ca74de
block algn patch by ("Assaf Yaari" <assafy at mobixell dot com>)
michael
parents:
1559
diff
changeset
|
969 buf_size = avctx->block_align; |
bc4b13ca74de
block algn patch by ("Assaf Yaari" <assafy at mobixell dot com>)
michael
parents:
1559
diff
changeset
|
970 |
3157 | 971 // samples_per_block= (block_align-4*chanels)*8 / (bits_per_sample * chanels) + 1; |
972 | |
1737 | 973 for(i=0; i<avctx->channels; i++){ |
974 cs = &(c->status[i]); | |
5877
aea495619138
fix predictor initialization for adpcm-ima encoder not to lose first sample
benoit
parents:
5870
diff
changeset
|
975 cs->predictor = *samples++ = (int16_t)(src[0] + (src[1]<<8)); |
3157 | 976 src+=2; |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
977 |
1737 | 978 cs->step_index = *src++; |
3157 | 979 if (cs->step_index > 88){ |
980 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index = %i\n", cs->step_index); | |
981 cs->step_index = 88; | |
982 } | |
983 if (*src++) av_log(avctx, AV_LOG_ERROR, "unused byte should be null but is %d!!\n", src[-1]); /* unused */ | |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
984 } |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
985 |
3157 | 986 while(src < buf + buf_size){ |
987 for(m=0; m<4; m++){ | |
988 for(i=0; i<=st; i++) | |
989 *samples++ = adpcm_ima_expand_nibble(&c->status[i], src[4*i] & 0x0F, 3); | |
990 for(i=0; i<=st; i++) | |
991 *samples++ = adpcm_ima_expand_nibble(&c->status[i], src[4*i] >> 4 , 3); | |
992 src++; | |
2979 | 993 } |
3157 | 994 src += 4*st; |
2979 | 995 } |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
996 break; |
1296 | 997 case CODEC_ID_ADPCM_4XM: |
998 cs = &(c->status[0]); | |
999 c->status[0].predictor= (int16_t)(src[0] + (src[1]<<8)); src+=2; | |
1000 if(st){ | |
1001 c->status[1].predictor= (int16_t)(src[0] + (src[1]<<8)); src+=2; | |
1002 } | |
1003 c->status[0].step_index= (int16_t)(src[0] + (src[1]<<8)); src+=2; | |
1004 if(st){ | |
1005 c->status[1].step_index= (int16_t)(src[0] + (src[1]<<8)); src+=2; | |
1006 } | |
1695
2d11403fde4e
initial predictors are not sent to the output in QT IMA; fix stereo QT
melanson
parents:
1611
diff
changeset
|
1007 if (cs->step_index < 0) cs->step_index = 0; |
2d11403fde4e
initial predictors are not sent to the output in QT IMA; fix stereo QT
melanson
parents:
1611
diff
changeset
|
1008 if (cs->step_index > 88) cs->step_index = 88; |
1296 | 1009 |
1010 m= (buf_size - (src - buf))>>st; | |
1011 for(i=0; i<m; i++) { | |
2979 | 1012 *samples++ = adpcm_ima_expand_nibble(&c->status[0], src[i] & 0x0F, 4); |
1296 | 1013 if (st) |
1737 | 1014 *samples++ = adpcm_ima_expand_nibble(&c->status[1], src[i+m] & 0x0F, 4); |
1015 *samples++ = adpcm_ima_expand_nibble(&c->status[0], src[i] >> 4, 4); | |
2979 | 1016 if (st) |
1737 | 1017 *samples++ = adpcm_ima_expand_nibble(&c->status[1], src[i+m] >> 4, 4); |
2979 | 1018 } |
1296 | 1019 |
1020 src += m<<st; | |
1021 | |
1022 break; | |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1023 case CODEC_ID_ADPCM_MS: |
1576
bc4b13ca74de
block algn patch by ("Assaf Yaari" <assafy at mobixell dot com>)
michael
parents:
1559
diff
changeset
|
1024 if (avctx->block_align != 0 && buf_size > avctx->block_align) |
bc4b13ca74de
block algn patch by ("Assaf Yaari" <assafy at mobixell dot com>)
michael
parents:
1559
diff
changeset
|
1025 buf_size = avctx->block_align; |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1026 n = buf_size - 7 * avctx->channels; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1027 if (n < 0) |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1028 return -1; |
4594 | 1029 block_predictor[0] = av_clip(*src++, 0, 7); |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1030 block_predictor[1] = 0; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1031 if (st) |
4594 | 1032 block_predictor[1] = av_clip(*src++, 0, 7); |
1794 | 1033 c->status[0].idelta = (int16_t)((*src & 0xFF) | ((src[1] << 8) & 0xFF00)); |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1034 src+=2; |
1794 | 1035 if (st){ |
1036 c->status[1].idelta = (int16_t)((*src & 0xFF) | ((src[1] << 8) & 0xFF00)); | |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1037 src+=2; |
1794 | 1038 } |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1039 c->status[0].coeff1 = AdaptCoeff1[block_predictor[0]]; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1040 c->status[0].coeff2 = AdaptCoeff2[block_predictor[0]]; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1041 c->status[1].coeff1 = AdaptCoeff1[block_predictor[1]]; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1042 c->status[1].coeff2 = AdaptCoeff2[block_predictor[1]]; |
2967 | 1043 |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1044 c->status[0].sample1 = ((*src & 0xFF) | ((src[1] << 8) & 0xFF00)); |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1045 src+=2; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1046 if (st) c->status[1].sample1 = ((*src & 0xFF) | ((src[1] << 8) & 0xFF00)); |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1047 if (st) src+=2; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1048 c->status[0].sample2 = ((*src & 0xFF) | ((src[1] << 8) & 0xFF00)); |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1049 src+=2; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1050 if (st) c->status[1].sample2 = ((*src & 0xFF) | ((src[1] << 8) & 0xFF00)); |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1051 if (st) src+=2; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1052 |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1053 *samples++ = c->status[0].sample1; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1054 if (st) *samples++ = c->status[1].sample1; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1055 *samples++ = c->status[0].sample2; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1056 if (st) *samples++ = c->status[1].sample2; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1057 for(;n>0;n--) { |
6586 | 1058 *samples++ = adpcm_ms_expand_nibble(&c->status[0 ], src[0] >> 4 ); |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1059 *samples++ = adpcm_ms_expand_nibble(&c->status[st], src[0] & 0x0F); |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1060 src ++; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1061 } |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1062 break; |
1443
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1063 case CODEC_ID_ADPCM_IMA_DK4: |
1577 | 1064 if (avctx->block_align != 0 && buf_size > avctx->block_align) |
1065 buf_size = avctx->block_align; | |
1066 | |
1794 | 1067 c->status[0].predictor = (int16_t)(src[0] | (src[1] << 8)); |
1443
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1068 c->status[0].step_index = src[2]; |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1069 src += 4; |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1070 *samples++ = c->status[0].predictor; |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1071 if (st) { |
1794 | 1072 c->status[1].predictor = (int16_t)(src[0] | (src[1] << 8)); |
1443
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1073 c->status[1].step_index = src[2]; |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1074 src += 4; |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1075 *samples++ = c->status[1].predictor; |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1076 } |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1077 while (src < buf + buf_size) { |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1078 |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1079 /* take care of the top nibble (always left or mono channel) */ |
2967 | 1080 *samples++ = adpcm_ima_expand_nibble(&c->status[0], |
6586 | 1081 src[0] >> 4, 3); |
1443
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1082 |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1083 /* take care of the bottom nibble, which is right sample for |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1084 * stereo, or another mono sample */ |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1085 if (st) |
2967 | 1086 *samples++ = adpcm_ima_expand_nibble(&c->status[1], |
1737 | 1087 src[0] & 0x0F, 3); |
1443
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1088 else |
2967 | 1089 *samples++ = adpcm_ima_expand_nibble(&c->status[0], |
1737 | 1090 src[0] & 0x0F, 3); |
1443
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1091 |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1092 src++; |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1093 } |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1094 break; |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1095 case CODEC_ID_ADPCM_IMA_DK3: |
1577 | 1096 if (avctx->block_align != 0 && buf_size > avctx->block_align) |
1097 buf_size = avctx->block_align; | |
1098 | |
4461
c95e0df9841f
some (probably exploitable) out of array write fixes
michael
parents:
4364
diff
changeset
|
1099 if(buf_size + 16 > (samples_end - samples)*3/8) |
c95e0df9841f
some (probably exploitable) out of array write fixes
michael
parents:
4364
diff
changeset
|
1100 return -1; |
c95e0df9841f
some (probably exploitable) out of array write fixes
michael
parents:
4364
diff
changeset
|
1101 |
1794 | 1102 c->status[0].predictor = (int16_t)(src[10] | (src[11] << 8)); |
1103 c->status[1].predictor = (int16_t)(src[12] | (src[13] << 8)); | |
1443
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1104 c->status[0].step_index = src[14]; |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1105 c->status[1].step_index = src[15]; |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1106 /* sign extend the predictors */ |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1107 src += 16; |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1108 diff_channel = c->status[1].predictor; |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1109 |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1110 /* the DK3_GET_NEXT_NIBBLE macro issues the break statement when |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1111 * the buffer is consumed */ |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1112 while (1) { |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1113 |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1114 /* for this algorithm, c->status[0] is the sum channel and |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1115 * c->status[1] is the diff channel */ |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1116 |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1117 /* process the first predictor of the sum channel */ |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1118 DK3_GET_NEXT_NIBBLE(); |
1737 | 1119 adpcm_ima_expand_nibble(&c->status[0], nibble, 3); |
1443
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1120 |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1121 /* process the diff channel predictor */ |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1122 DK3_GET_NEXT_NIBBLE(); |
1737 | 1123 adpcm_ima_expand_nibble(&c->status[1], nibble, 3); |
1443
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1124 |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1125 /* process the first pair of stereo PCM samples */ |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1126 diff_channel = (diff_channel + c->status[1].predictor) / 2; |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1127 *samples++ = c->status[0].predictor + c->status[1].predictor; |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1128 *samples++ = c->status[0].predictor - c->status[1].predictor; |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1129 |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1130 /* process the second predictor of the sum channel */ |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1131 DK3_GET_NEXT_NIBBLE(); |
1737 | 1132 adpcm_ima_expand_nibble(&c->status[0], nibble, 3); |
1443
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1133 |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1134 /* process the second pair of stereo PCM samples */ |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1135 diff_channel = (diff_channel + c->status[1].predictor) / 2; |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1136 *samples++ = c->status[0].predictor + c->status[1].predictor; |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1137 *samples++ = c->status[0].predictor - c->status[1].predictor; |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1138 } |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1139 break; |
1491
222643544cf1
New demuxers: Sega FILM/CPK, Westwood VQA & AUD; new decoders: MS RLE &
tmmm
parents:
1443
diff
changeset
|
1140 case CODEC_ID_ADPCM_IMA_WS: |
222643544cf1
New demuxers: Sega FILM/CPK, Westwood VQA & AUD; new decoders: MS RLE &
tmmm
parents:
1443
diff
changeset
|
1141 /* no per-block initialization; just start decoding the data */ |
222643544cf1
New demuxers: Sega FILM/CPK, Westwood VQA & AUD; new decoders: MS RLE &
tmmm
parents:
1443
diff
changeset
|
1142 while (src < buf + buf_size) { |
222643544cf1
New demuxers: Sega FILM/CPK, Westwood VQA & AUD; new decoders: MS RLE &
tmmm
parents:
1443
diff
changeset
|
1143 |
222643544cf1
New demuxers: Sega FILM/CPK, Westwood VQA & AUD; new decoders: MS RLE &
tmmm
parents:
1443
diff
changeset
|
1144 if (st) { |
2967 | 1145 *samples++ = adpcm_ima_expand_nibble(&c->status[0], |
6586 | 1146 src[0] >> 4 , 3); |
2967 | 1147 *samples++ = adpcm_ima_expand_nibble(&c->status[1], |
1737 | 1148 src[0] & 0x0F, 3); |
1491
222643544cf1
New demuxers: Sega FILM/CPK, Westwood VQA & AUD; new decoders: MS RLE &
tmmm
parents:
1443
diff
changeset
|
1149 } else { |
2967 | 1150 *samples++ = adpcm_ima_expand_nibble(&c->status[0], |
6586 | 1151 src[0] >> 4 , 3); |
2967 | 1152 *samples++ = adpcm_ima_expand_nibble(&c->status[0], |
1737 | 1153 src[0] & 0x0F, 3); |
1491
222643544cf1
New demuxers: Sega FILM/CPK, Westwood VQA & AUD; new decoders: MS RLE &
tmmm
parents:
1443
diff
changeset
|
1154 } |
222643544cf1
New demuxers: Sega FILM/CPK, Westwood VQA & AUD; new decoders: MS RLE &
tmmm
parents:
1443
diff
changeset
|
1155 |
222643544cf1
New demuxers: Sega FILM/CPK, Westwood VQA & AUD; new decoders: MS RLE &
tmmm
parents:
1443
diff
changeset
|
1156 src++; |
222643544cf1
New demuxers: Sega FILM/CPK, Westwood VQA & AUD; new decoders: MS RLE &
tmmm
parents:
1443
diff
changeset
|
1157 } |
222643544cf1
New demuxers: Sega FILM/CPK, Westwood VQA & AUD; new decoders: MS RLE &
tmmm
parents:
1443
diff
changeset
|
1158 break; |
1535 | 1159 case CODEC_ID_ADPCM_XA: |
1160 while (buf_size >= 128) { | |
2967 | 1161 xa_decode(samples, src, &c->status[0], &c->status[1], |
1535 | 1162 avctx->channels); |
1163 src += 128; | |
1164 samples += 28 * 8; | |
1165 buf_size -= 128; | |
1166 } | |
1167 break; | |
5854 | 1168 case CODEC_ID_ADPCM_IMA_EA_EACS: |
1169 samples_in_chunk = bytestream_get_le32(&src) >> (1-st); | |
1170 | |
1171 if (samples_in_chunk > buf_size-4-(8<<st)) { | |
1172 src += buf_size - 4; | |
1173 break; | |
1174 } | |
1175 | |
1176 for (i=0; i<=st; i++) | |
1177 c->status[i].step_index = bytestream_get_le32(&src); | |
1178 for (i=0; i<=st; i++) | |
1179 c->status[i].predictor = bytestream_get_le32(&src); | |
1180 | |
1181 for (; samples_in_chunk; samples_in_chunk--, src++) { | |
1182 *samples++ = adpcm_ima_expand_nibble(&c->status[0], *src>>4, 3); | |
1183 *samples++ = adpcm_ima_expand_nibble(&c->status[st], *src&0x0F, 3); | |
1184 } | |
1185 break; | |
5853 | 1186 case CODEC_ID_ADPCM_IMA_EA_SEAD: |
1187 for (; src < buf+buf_size; src++) { | |
1188 *samples++ = adpcm_ima_expand_nibble(&c->status[0], src[0] >> 4, 6); | |
1189 *samples++ = adpcm_ima_expand_nibble(&c->status[st],src[0]&0x0F, 6); | |
1190 } | |
1191 break; | |
1779 | 1192 case CODEC_ID_ADPCM_EA: |
4364 | 1193 samples_in_chunk = AV_RL32(src); |
1779 | 1194 if (samples_in_chunk >= ((buf_size - 12) * 2)) { |
1195 src += buf_size; | |
1196 break; | |
1197 } | |
1198 src += 4; | |
4364 | 1199 current_left_sample = (int16_t)AV_RL16(src); |
1779 | 1200 src += 2; |
4364 | 1201 previous_left_sample = (int16_t)AV_RL16(src); |
1779 | 1202 src += 2; |
4364 | 1203 current_right_sample = (int16_t)AV_RL16(src); |
1779 | 1204 src += 2; |
4364 | 1205 previous_right_sample = (int16_t)AV_RL16(src); |
1779 | 1206 src += 2; |
1207 | |
1208 for (count1 = 0; count1 < samples_in_chunk/28;count1++) { | |
6586 | 1209 coeff1l = ea_adpcm_table[ *src >> 4 ]; |
1210 coeff2l = ea_adpcm_table[(*src >> 4 ) + 4]; | |
1779 | 1211 coeff1r = ea_adpcm_table[*src & 0x0F]; |
1212 coeff2r = ea_adpcm_table[(*src & 0x0F) + 4]; | |
1213 src++; | |
1214 | |
6586 | 1215 shift_left = (*src >> 4 ) + 8; |
1779 | 1216 shift_right = (*src & 0x0F) + 8; |
1217 src++; | |
1218 | |
1219 for (count2 = 0; count2 < 28; count2++) { | |
6592 | 1220 next_left_sample = (int32_t)((*src & 0xF0) << 24) >> shift_left; |
1221 next_right_sample = (int32_t)((*src & 0x0F) << 28) >> shift_right; | |
1779 | 1222 src++; |
1223 | |
2967 | 1224 next_left_sample = (next_left_sample + |
1225 (current_left_sample * coeff1l) + | |
1779 | 1226 (previous_left_sample * coeff2l) + 0x80) >> 8; |
2967 | 1227 next_right_sample = (next_right_sample + |
1228 (current_right_sample * coeff1r) + | |
1779 | 1229 (previous_right_sample * coeff2r) + 0x80) >> 8; |
1230 | |
1231 previous_left_sample = current_left_sample; | |
5525
bc4791868c52
various simplifications around recent av_clip_int16() usage
aurel
parents:
5523
diff
changeset
|
1232 current_left_sample = av_clip_int16(next_left_sample); |
1779 | 1233 previous_right_sample = current_right_sample; |
5525
bc4791868c52
various simplifications around recent av_clip_int16() usage
aurel
parents:
5523
diff
changeset
|
1234 current_right_sample = av_clip_int16(next_right_sample); |
1779 | 1235 *samples++ = (unsigned short)current_left_sample; |
1236 *samples++ = (unsigned short)current_right_sample; | |
1237 } | |
1238 } | |
1239 break; | |
6596 | 1240 case CODEC_ID_ADPCM_EA_MAXIS_XA: |
1241 for(channel = 0; channel < avctx->channels; channel++) { | |
1242 for (i=0; i<2; i++) | |
1243 coeff[channel][i] = ea_adpcm_table[(*src >> 4) + 4*i]; | |
1244 shift[channel] = (*src & 0x0F) + 8; | |
1245 src++; | |
1246 } | |
1247 for (count1 = 0; count1 < (buf_size - avctx->channels) / avctx->channels; count1++) { | |
1248 for(i = 4; i >= 0; i-=4) { /* Pairwise samples LL RR (st) or LL LL (mono) */ | |
1249 for(channel = 0; channel < avctx->channels; channel++) { | |
1250 int32_t sample = (int32_t)(((*(src+channel) >> i) & 0x0F) << 0x1C) >> shift[channel]; | |
1251 sample = (sample + | |
1252 c->status[channel].sample1 * coeff[channel][0] + | |
1253 c->status[channel].sample2 * coeff[channel][1] + 0x80) >> 8; | |
1254 c->status[channel].sample2 = c->status[channel].sample1; | |
1255 c->status[channel].sample1 = av_clip_int16(sample); | |
1256 *samples++ = c->status[channel].sample1; | |
1257 } | |
1258 } | |
1259 src+=avctx->channels; | |
1260 } | |
1261 break; | |
5851 | 1262 case CODEC_ID_ADPCM_EA_R1: |
1263 case CODEC_ID_ADPCM_EA_R2: | |
1264 case CODEC_ID_ADPCM_EA_R3: { | |
1265 /* channel numbering | |
1266 2chan: 0=fl, 1=fr | |
1267 4chan: 0=fl, 1=rl, 2=fr, 3=rr | |
1268 6chan: 0=fl, 1=c, 2=fr, 3=rl, 4=rr, 5=sub */ | |
1269 const int big_endian = avctx->codec->id == CODEC_ID_ADPCM_EA_R3; | |
1270 int32_t previous_sample, current_sample, next_sample; | |
1271 int32_t coeff1, coeff2; | |
1272 uint8_t shift; | |
1273 unsigned int channel; | |
1274 uint16_t *samplesC; | |
6259 | 1275 const uint8_t *srcC; |
5851 | 1276 |
1277 samples_in_chunk = (big_endian ? bytestream_get_be32(&src) | |
1278 : bytestream_get_le32(&src)) / 28; | |
1279 if (samples_in_chunk > UINT32_MAX/(28*avctx->channels) || | |
1280 28*samples_in_chunk*avctx->channels > samples_end-samples) { | |
1281 src += buf_size - 4; | |
1282 break; | |
1283 } | |
1284 | |
1285 for (channel=0; channel<avctx->channels; channel++) { | |
1286 srcC = src + (big_endian ? bytestream_get_be32(&src) | |
1287 : bytestream_get_le32(&src)) | |
1288 + (avctx->channels-channel-1) * 4; | |
1289 samplesC = samples + channel; | |
1290 | |
1291 if (avctx->codec->id == CODEC_ID_ADPCM_EA_R1) { | |
1292 current_sample = (int16_t)bytestream_get_le16(&srcC); | |
1293 previous_sample = (int16_t)bytestream_get_le16(&srcC); | |
1294 } else { | |
1295 current_sample = c->status[channel].predictor; | |
1296 previous_sample = c->status[channel].prev_sample; | |
1297 } | |
1298 | |
1299 for (count1=0; count1<samples_in_chunk; count1++) { | |
1300 if (*srcC == 0xEE) { /* only seen in R2 and R3 */ | |
1301 srcC++; | |
1302 current_sample = (int16_t)bytestream_get_be16(&srcC); | |
1303 previous_sample = (int16_t)bytestream_get_be16(&srcC); | |
1304 | |
1305 for (count2=0; count2<28; count2++) { | |
1306 *samplesC = (int16_t)bytestream_get_be16(&srcC); | |
1307 samplesC += avctx->channels; | |
1308 } | |
1309 } else { | |
6586 | 1310 coeff1 = ea_adpcm_table[ *srcC>>4 ]; |
1311 coeff2 = ea_adpcm_table[(*srcC>>4) + 4]; | |
5851 | 1312 shift = (*srcC++ & 0x0F) + 8; |
1313 | |
1314 for (count2=0; count2<28; count2++) { | |
1315 if (count2 & 1) | |
6592 | 1316 next_sample = (int32_t)((*srcC++ & 0x0F) << 28) >> shift; |
5851 | 1317 else |
6592 | 1318 next_sample = (int32_t)((*srcC & 0xF0) << 24) >> shift; |
5851 | 1319 |
1320 next_sample += (current_sample * coeff1) + | |
1321 (previous_sample * coeff2); | |
1322 next_sample = av_clip_int16(next_sample >> 8); | |
1323 | |
1324 previous_sample = current_sample; | |
1325 current_sample = next_sample; | |
1326 *samplesC = current_sample; | |
1327 samplesC += avctx->channels; | |
1328 } | |
1329 } | |
1330 } | |
1331 | |
1332 if (avctx->codec->id != CODEC_ID_ADPCM_EA_R1) { | |
1333 c->status[channel].predictor = current_sample; | |
1334 c->status[channel].prev_sample = previous_sample; | |
1335 } | |
1336 } | |
1337 | |
1338 src = src + buf_size - (4 + 4*avctx->channels); | |
1339 samples += 28 * samples_in_chunk * avctx->channels; | |
1340 break; | |
1341 } | |
5870 | 1342 case CODEC_ID_ADPCM_EA_XAS: |
1343 if (samples_end-samples < 32*4*avctx->channels | |
1344 || buf_size < (4+15)*4*avctx->channels) { | |
1345 src += buf_size; | |
1346 break; | |
1347 } | |
1348 for (channel=0; channel<avctx->channels; channel++) { | |
1349 int coeff[2][4], shift[4]; | |
1350 short *s2, *s = &samples[channel]; | |
1351 for (n=0; n<4; n++, s+=32*avctx->channels) { | |
1352 for (i=0; i<2; i++) | |
1353 coeff[i][n] = ea_adpcm_table[(src[0]&0x0F)+4*i]; | |
1354 shift[n] = (src[2]&0x0F) + 8; | |
1355 for (s2=s, i=0; i<2; i++, src+=2, s2+=avctx->channels) | |
1356 s2[0] = (src[0]&0xF0) + (src[1]<<8); | |
1357 } | |
1358 | |
1359 for (m=2; m<32; m+=2) { | |
1360 s = &samples[m*avctx->channels + channel]; | |
1361 for (n=0; n<4; n++, src++, s+=32*avctx->channels) { | |
1362 for (s2=s, i=0; i<8; i+=4, s2+=avctx->channels) { | |
6592 | 1363 int level = (int32_t)((*src & (0xF0>>i)) << (24+i)) >> shift[n]; |
5870 | 1364 int pred = s2[-1*avctx->channels] * coeff[0][n] |
1365 + s2[-2*avctx->channels] * coeff[1][n]; | |
1366 s2[0] = av_clip_int16((level + pred + 0x80) >> 8); | |
1367 } | |
1368 } | |
1369 } | |
1370 } | |
1371 samples += 32*4*avctx->channels; | |
1372 break; | |
5726 | 1373 case CODEC_ID_ADPCM_IMA_AMV: |
1779 | 1374 case CODEC_ID_ADPCM_IMA_SMJPEG: |
5775
38f220befc32
Replace "signed short" typecast with "int16_t" as suggested by
voroshil
parents:
5766
diff
changeset
|
1375 c->status[0].predictor = (int16_t)bytestream_get_le16(&src); |
5766
ad8345572a2e
Fix audio clicks in ADPCM IMA AMV by casting predictor as "signed short"
voroshil
parents:
5726
diff
changeset
|
1376 c->status[0].step_index = bytestream_get_le16(&src); |
5726 | 1377 |
1378 if (avctx->codec->id == CODEC_ID_ADPCM_IMA_AMV) | |
1379 src+=4; | |
1380 | |
1779 | 1381 while (src < buf + buf_size) { |
5726 | 1382 char hi, lo; |
1383 lo = *src & 0x0F; | |
6586 | 1384 hi = *src >> 4; |
5726 | 1385 |
1386 if (avctx->codec->id == CODEC_ID_ADPCM_IMA_AMV) | |
1387 FFSWAP(char, hi, lo); | |
1388 | |
1779 | 1389 *samples++ = adpcm_ima_expand_nibble(&c->status[0], |
5726 | 1390 lo, 3); |
1779 | 1391 *samples++ = adpcm_ima_expand_nibble(&c->status[0], |
5726 | 1392 hi, 3); |
1779 | 1393 src++; |
1394 } | |
1395 break; | |
2296
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
1396 case CODEC_ID_ADPCM_CT: |
2979 | 1397 while (src < buf + buf_size) { |
2296
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
1398 if (st) { |
2967 | 1399 *samples++ = adpcm_ct_expand_nibble(&c->status[0], |
6586 | 1400 src[0] >> 4); |
2967 | 1401 *samples++ = adpcm_ct_expand_nibble(&c->status[1], |
2296
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
1402 src[0] & 0x0F); |
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
1403 } else { |
2967 | 1404 *samples++ = adpcm_ct_expand_nibble(&c->status[0], |
6586 | 1405 src[0] >> 4); |
2967 | 1406 *samples++ = adpcm_ct_expand_nibble(&c->status[0], |
2296
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
1407 src[0] & 0x0F); |
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
1408 } |
2979 | 1409 src++; |
2296
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
1410 } |
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
1411 break; |
3127 | 1412 case CODEC_ID_ADPCM_SBPRO_4: |
1413 case CODEC_ID_ADPCM_SBPRO_3: | |
1414 case CODEC_ID_ADPCM_SBPRO_2: | |
1415 if (!c->status[0].step_index) { | |
1416 /* the first byte is a raw sample */ | |
1417 *samples++ = 128 * (*src++ - 0x80); | |
1418 if (st) | |
1419 *samples++ = 128 * (*src++ - 0x80); | |
1420 c->status[0].step_index = 1; | |
1421 } | |
1422 if (avctx->codec->id == CODEC_ID_ADPCM_SBPRO_4) { | |
1423 while (src < buf + buf_size) { | |
1424 *samples++ = adpcm_sbpro_expand_nibble(&c->status[0], | |
6586 | 1425 src[0] >> 4, 4, 0); |
3127 | 1426 *samples++ = adpcm_sbpro_expand_nibble(&c->status[st], |
1427 src[0] & 0x0F, 4, 0); | |
1428 src++; | |
1429 } | |
1430 } else if (avctx->codec->id == CODEC_ID_ADPCM_SBPRO_3) { | |
4461
c95e0df9841f
some (probably exploitable) out of array write fixes
michael
parents:
4364
diff
changeset
|
1431 while (src < buf + buf_size && samples + 2 < samples_end) { |
3127 | 1432 *samples++ = adpcm_sbpro_expand_nibble(&c->status[0], |
6586 | 1433 src[0] >> 5 , 3, 0); |
3127 | 1434 *samples++ = adpcm_sbpro_expand_nibble(&c->status[0], |
1435 (src[0] >> 2) & 0x07, 3, 0); | |
1436 *samples++ = adpcm_sbpro_expand_nibble(&c->status[0], | |
1437 src[0] & 0x03, 2, 0); | |
1438 src++; | |
1439 } | |
1440 } else { | |
4461
c95e0df9841f
some (probably exploitable) out of array write fixes
michael
parents:
4364
diff
changeset
|
1441 while (src < buf + buf_size && samples + 3 < samples_end) { |
3127 | 1442 *samples++ = adpcm_sbpro_expand_nibble(&c->status[0], |
6586 | 1443 src[0] >> 6 , 2, 2); |
3127 | 1444 *samples++ = adpcm_sbpro_expand_nibble(&c->status[st], |
1445 (src[0] >> 4) & 0x03, 2, 2); | |
1446 *samples++ = adpcm_sbpro_expand_nibble(&c->status[0], | |
1447 (src[0] >> 2) & 0x03, 2, 2); | |
1448 *samples++ = adpcm_sbpro_expand_nibble(&c->status[st], | |
1449 src[0] & 0x03, 2, 2); | |
1450 src++; | |
1451 } | |
1452 } | |
1453 break; | |
2516
9f17dd9b80c6
macromedia flavour adpcm decoding (used in flv and swf)
alex
parents:
2296
diff
changeset
|
1454 case CODEC_ID_ADPCM_SWF: |
9f17dd9b80c6
macromedia flavour adpcm decoding (used in flv and swf)
alex
parents:
2296
diff
changeset
|
1455 { |
2979 | 1456 GetBitContext gb; |
1457 const int *table; | |
5494
c2512a13877e
fix decoding of adpcm swf big frames, fix RamboMJPEGAVP6_1Mbps.swf
bcoudurier
parents:
5371
diff
changeset
|
1458 int k0, signmask, nb_bits, count; |
2979 | 1459 int size = buf_size*8; |
2967 | 1460 |
2979 | 1461 init_get_bits(&gb, buf, size); |
2516
9f17dd9b80c6
macromedia flavour adpcm decoding (used in flv and swf)
alex
parents:
2296
diff
changeset
|
1462 |
5129 | 1463 //read bits & initial values |
4614 | 1464 nb_bits = get_bits(&gb, 2)+2; |
1465 //av_log(NULL,AV_LOG_INFO,"nb_bits: %d\n", nb_bits); | |
1466 table = swf_index_tables[nb_bits-2]; | |
1467 k0 = 1 << (nb_bits-2); | |
1468 signmask = 1 << (nb_bits-1); | |
1469 | |
5494
c2512a13877e
fix decoding of adpcm swf big frames, fix RamboMJPEGAVP6_1Mbps.swf
bcoudurier
parents:
5371
diff
changeset
|
1470 while (get_bits_count(&gb) <= size - 22*avctx->channels) { |
5500 | 1471 for (i = 0; i < avctx->channels; i++) { |
1472 *samples++ = c->status[i].predictor = get_sbits(&gb, 16); | |
1473 c->status[i].step_index = get_bits(&gb, 6); | |
1474 } | |
2967 | 1475 |
5500 | 1476 for (count = 0; get_bits_count(&gb) <= size - nb_bits*avctx->channels && count < 4095; count++) { |
1477 int i; | |
2516
9f17dd9b80c6
macromedia flavour adpcm decoding (used in flv and swf)
alex
parents:
2296
diff
changeset
|
1478 |
5500 | 1479 for (i = 0; i < avctx->channels; i++) { |
1480 // similar to IMA adpcm | |
1481 int delta = get_bits(&gb, nb_bits); | |
1482 int step = step_table[c->status[i].step_index]; | |
1483 long vpdiff = 0; // vpdiff = (delta+0.5)*step/4 | |
1484 int k = k0; | |
2967 | 1485 |
5500 | 1486 do { |
1487 if (delta & k) | |
1488 vpdiff += step; | |
1489 step >>= 1; | |
1490 k >>= 1; | |
1491 } while(k); | |
1492 vpdiff += step; | |
2967 | 1493 |
5500 | 1494 if (delta & signmask) |
1495 c->status[i].predictor -= vpdiff; | |
1496 else | |
1497 c->status[i].predictor += vpdiff; | |
2967 | 1498 |
5500 | 1499 c->status[i].step_index += table[delta & (~signmask)]; |
2967 | 1500 |
5500 | 1501 c->status[i].step_index = av_clip(c->status[i].step_index, 0, 88); |
5523 | 1502 c->status[i].predictor = av_clip_int16(c->status[i].predictor); |
2967 | 1503 |
5500 | 1504 *samples++ = c->status[i].predictor; |
1505 if (samples >= samples_end) { | |
1506 av_log(avctx, AV_LOG_ERROR, "allocated output buffer is too small\n"); | |
1507 return -1; | |
1508 } | |
4614 | 1509 } |
2979 | 1510 } |
1511 } | |
4614 | 1512 src += buf_size; |
2979 | 1513 break; |
2516
9f17dd9b80c6
macromedia flavour adpcm decoding (used in flv and swf)
alex
parents:
2296
diff
changeset
|
1514 } |
2794
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
1515 case CODEC_ID_ADPCM_YAMAHA: |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
1516 while (src < buf + buf_size) { |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
1517 if (st) { |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
1518 *samples++ = adpcm_yamaha_expand_nibble(&c->status[0], |
2795
de03cac6f7c2
yamaha adpcm nibbles in the wrong order fix by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2794
diff
changeset
|
1519 src[0] & 0x0F); |
2794
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
1520 *samples++ = adpcm_yamaha_expand_nibble(&c->status[1], |
6586 | 1521 src[0] >> 4 ); |
2794
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
1522 } else { |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
1523 *samples++ = adpcm_yamaha_expand_nibble(&c->status[0], |
2795
de03cac6f7c2
yamaha adpcm nibbles in the wrong order fix by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2794
diff
changeset
|
1524 src[0] & 0x0F); |
2794
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
1525 *samples++ = adpcm_yamaha_expand_nibble(&c->status[0], |
6586 | 1526 src[0] >> 4 ); |
2794
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
1527 } |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
1528 src++; |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
1529 } |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
1530 break; |
4800 | 1531 case CODEC_ID_ADPCM_THP: |
4821 | 1532 { |
4804
39975b6c49bb
table[index][ch] -> table[ch][index] (might be faster ...)
michael
parents:
4800
diff
changeset
|
1533 int table[2][16]; |
4800 | 1534 unsigned int samplecnt; |
4807 | 1535 int prev[2][2]; |
4800 | 1536 int ch; |
1537 | |
1538 if (buf_size < 80) { | |
1539 av_log(avctx, AV_LOG_ERROR, "frame too small\n"); | |
1540 return -1; | |
1541 } | |
1542 | |
4810
0066256e99da
use bytestream reader instead of bitstream for THP
michael
parents:
4809
diff
changeset
|
1543 src+=4; |
0066256e99da
use bytestream reader instead of bitstream for THP
michael
parents:
4809
diff
changeset
|
1544 samplecnt = bytestream_get_be32(&src); |
4800 | 1545 |
4806 | 1546 for (i = 0; i < 32; i++) |
4810
0066256e99da
use bytestream reader instead of bitstream for THP
michael
parents:
4809
diff
changeset
|
1547 table[0][i] = (int16_t)bytestream_get_be16(&src); |
4800 | 1548 |
1549 /* Initialize the previous sample. */ | |
4808 | 1550 for (i = 0; i < 4; i++) |
4810
0066256e99da
use bytestream reader instead of bitstream for THP
michael
parents:
4809
diff
changeset
|
1551 prev[0][i] = (int16_t)bytestream_get_be16(&src); |
4800 | 1552 |
1553 if (samplecnt >= (samples_end - samples) / (st + 1)) { | |
1554 av_log(avctx, AV_LOG_ERROR, "allocated output buffer is too small\n"); | |
1555 return -1; | |
1556 } | |
1557 | |
1558 for (ch = 0; ch <= st; ch++) { | |
1559 samples = (unsigned short *) data + ch; | |
1560 | |
1561 /* Read in every sample for this channel. */ | |
1562 for (i = 0; i < samplecnt / 14; i++) { | |
4810
0066256e99da
use bytestream reader instead of bitstream for THP
michael
parents:
4809
diff
changeset
|
1563 int index = (*src >> 4) & 7; |
0066256e99da
use bytestream reader instead of bitstream for THP
michael
parents:
4809
diff
changeset
|
1564 unsigned int exp = 28 - (*src++ & 15); |
4804
39975b6c49bb
table[index][ch] -> table[ch][index] (might be faster ...)
michael
parents:
4800
diff
changeset
|
1565 int factor1 = table[ch][index * 2]; |
39975b6c49bb
table[index][ch] -> table[ch][index] (might be faster ...)
michael
parents:
4800
diff
changeset
|
1566 int factor2 = table[ch][index * 2 + 1]; |
4800 | 1567 |
1568 /* Decode 14 samples. */ | |
1569 for (n = 0; n < 14; n++) { | |
4810
0066256e99da
use bytestream reader instead of bitstream for THP
michael
parents:
4809
diff
changeset
|
1570 int32_t sampledat; |
0066256e99da
use bytestream reader instead of bitstream for THP
michael
parents:
4809
diff
changeset
|
1571 if(n&1) sampledat= *src++ <<28; |
0066256e99da
use bytestream reader instead of bitstream for THP
michael
parents:
4809
diff
changeset
|
1572 else sampledat= (*src&0xF0)<<24; |
4800 | 1573 |
4835
ae2f8c9bc25d
Fix an underflow/overflow that was causing some crackles when playing
diego
parents:
4821
diff
changeset
|
1574 sampledat = ((prev[ch][0]*factor1 |
4810
0066256e99da
use bytestream reader instead of bitstream for THP
michael
parents:
4809
diff
changeset
|
1575 + prev[ch][1]*factor2) >> 11) + (sampledat>>exp); |
5525
bc4791868c52
various simplifications around recent av_clip_int16() usage
aurel
parents:
5523
diff
changeset
|
1576 *samples = av_clip_int16(sampledat); |
4807 | 1577 prev[ch][1] = prev[ch][0]; |
1578 prev[ch][0] = *samples++; | |
4800 | 1579 |
1580 /* In case of stereo, skip one sample, this sample | |
1581 is for the other channel. */ | |
1582 samples += st; | |
1583 } | |
1584 } | |
1585 } | |
1586 | |
1587 /* In the previous loop, in case stereo is used, samples is | |
1588 increased exactly one time too often. */ | |
1589 samples -= st; | |
1590 break; | |
4821 | 1591 } |
4800 | 1592 |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1593 default: |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1594 return -1; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1595 } |
1064 | 1596 *data_size = (uint8_t *)samples - (uint8_t *)data; |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1597 return src - buf; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1598 } |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1599 |
1530
3b31998fe22f
disable encoders where appropriate (patch courtesy of BERO
melanson
parents:
1491
diff
changeset
|
1600 |
3b31998fe22f
disable encoders where appropriate (patch courtesy of BERO
melanson
parents:
1491
diff
changeset
|
1601 |
3b31998fe22f
disable encoders where appropriate (patch courtesy of BERO
melanson
parents:
1491
diff
changeset
|
1602 #ifdef CONFIG_ENCODERS |
6801
047a6a80dca4
ADPCM codec long names by Stefano Sabatini, stefano.sabatini-lala poste it
diego
parents:
6680
diff
changeset
|
1603 #define ADPCM_ENCODER(id,name,long_name_) \ |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1604 AVCodec name ## _encoder = { \ |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1605 #name, \ |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1606 CODEC_TYPE_AUDIO, \ |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1607 id, \ |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1608 sizeof(ADPCMContext), \ |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1609 adpcm_encode_init, \ |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1610 adpcm_encode_frame, \ |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1611 adpcm_encode_close, \ |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1612 NULL, \ |
6801
047a6a80dca4
ADPCM codec long names by Stefano Sabatini, stefano.sabatini-lala poste it
diego
parents:
6680
diff
changeset
|
1613 .long_name = long_name_, \ |
1530
3b31998fe22f
disable encoders where appropriate (patch courtesy of BERO
melanson
parents:
1491
diff
changeset
|
1614 }; |
3b31998fe22f
disable encoders where appropriate (patch courtesy of BERO
melanson
parents:
1491
diff
changeset
|
1615 #else |
6801
047a6a80dca4
ADPCM codec long names by Stefano Sabatini, stefano.sabatini-lala poste it
diego
parents:
6680
diff
changeset
|
1616 #define ADPCM_ENCODER(id,name,long_name_) |
1530
3b31998fe22f
disable encoders where appropriate (patch courtesy of BERO
melanson
parents:
1491
diff
changeset
|
1617 #endif |
3b31998fe22f
disable encoders where appropriate (patch courtesy of BERO
melanson
parents:
1491
diff
changeset
|
1618 |
3b31998fe22f
disable encoders where appropriate (patch courtesy of BERO
melanson
parents:
1491
diff
changeset
|
1619 #ifdef CONFIG_DECODERS |
6801
047a6a80dca4
ADPCM codec long names by Stefano Sabatini, stefano.sabatini-lala poste it
diego
parents:
6680
diff
changeset
|
1620 #define ADPCM_DECODER(id,name,long_name_) \ |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1621 AVCodec name ## _decoder = { \ |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1622 #name, \ |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1623 CODEC_TYPE_AUDIO, \ |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1624 id, \ |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1625 sizeof(ADPCMContext), \ |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1626 adpcm_decode_init, \ |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1627 NULL, \ |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1628 NULL, \ |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1629 adpcm_decode_frame, \ |
6801
047a6a80dca4
ADPCM codec long names by Stefano Sabatini, stefano.sabatini-lala poste it
diego
parents:
6680
diff
changeset
|
1630 .long_name = long_name_, \ |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1631 }; |
1530
3b31998fe22f
disable encoders where appropriate (patch courtesy of BERO
melanson
parents:
1491
diff
changeset
|
1632 #else |
6801
047a6a80dca4
ADPCM codec long names by Stefano Sabatini, stefano.sabatini-lala poste it
diego
parents:
6680
diff
changeset
|
1633 #define ADPCM_DECODER(id,name,long_name_) |
1530
3b31998fe22f
disable encoders where appropriate (patch courtesy of BERO
melanson
parents:
1491
diff
changeset
|
1634 #endif |
3b31998fe22f
disable encoders where appropriate (patch courtesy of BERO
melanson
parents:
1491
diff
changeset
|
1635 |
6801
047a6a80dca4
ADPCM codec long names by Stefano Sabatini, stefano.sabatini-lala poste it
diego
parents:
6680
diff
changeset
|
1636 #define ADPCM_CODEC(id,name,long_name_) \ |
047a6a80dca4
ADPCM codec long names by Stefano Sabatini, stefano.sabatini-lala poste it
diego
parents:
6680
diff
changeset
|
1637 ADPCM_ENCODER(id,name,long_name_) ADPCM_DECODER(id,name,long_name_) |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1638 |
6801
047a6a80dca4
ADPCM codec long names by Stefano Sabatini, stefano.sabatini-lala poste it
diego
parents:
6680
diff
changeset
|
1639 ADPCM_DECODER(CODEC_ID_ADPCM_4XM, adpcm_4xm, "4X Movie ADPCM"); |
047a6a80dca4
ADPCM codec long names by Stefano Sabatini, stefano.sabatini-lala poste it
diego
parents:
6680
diff
changeset
|
1640 ADPCM_DECODER(CODEC_ID_ADPCM_CT, adpcm_ct, "Creative Technology ADPCM"); |
047a6a80dca4
ADPCM codec long names by Stefano Sabatini, stefano.sabatini-lala poste it
diego
parents:
6680
diff
changeset
|
1641 ADPCM_DECODER(CODEC_ID_ADPCM_EA, adpcm_ea, "Electronic Arts ADPCM"); |
047a6a80dca4
ADPCM codec long names by Stefano Sabatini, stefano.sabatini-lala poste it
diego
parents:
6680
diff
changeset
|
1642 ADPCM_DECODER(CODEC_ID_ADPCM_EA_MAXIS_XA, adpcm_ea_maxis_xa, "Electronic Arts Maxis CDROM XA ADPCM"); |
047a6a80dca4
ADPCM codec long names by Stefano Sabatini, stefano.sabatini-lala poste it
diego
parents:
6680
diff
changeset
|
1643 ADPCM_DECODER(CODEC_ID_ADPCM_EA_R1, adpcm_ea_r1, "Electronic Arts R1 ADPCM"); |
047a6a80dca4
ADPCM codec long names by Stefano Sabatini, stefano.sabatini-lala poste it
diego
parents:
6680
diff
changeset
|
1644 ADPCM_DECODER(CODEC_ID_ADPCM_EA_R2, adpcm_ea_r2, "Electronic Arts R2 ADPCM"); |
047a6a80dca4
ADPCM codec long names by Stefano Sabatini, stefano.sabatini-lala poste it
diego
parents:
6680
diff
changeset
|
1645 ADPCM_DECODER(CODEC_ID_ADPCM_EA_R3, adpcm_ea_r3, "Electronic Arts R3 ADPCM"); |
047a6a80dca4
ADPCM codec long names by Stefano Sabatini, stefano.sabatini-lala poste it
diego
parents:
6680
diff
changeset
|
1646 ADPCM_DECODER(CODEC_ID_ADPCM_EA_XAS, adpcm_ea_xas, "Electronic Arts XAS ADPCM"); |
047a6a80dca4
ADPCM codec long names by Stefano Sabatini, stefano.sabatini-lala poste it
diego
parents:
6680
diff
changeset
|
1647 ADPCM_DECODER(CODEC_ID_ADPCM_IMA_AMV, adpcm_ima_amv, "IMA AMV ADPCM"); |
047a6a80dca4
ADPCM codec long names by Stefano Sabatini, stefano.sabatini-lala poste it
diego
parents:
6680
diff
changeset
|
1648 ADPCM_DECODER(CODEC_ID_ADPCM_IMA_DK3, adpcm_ima_dk3, "IMA Duck DK3 ADPCM"); |
047a6a80dca4
ADPCM codec long names by Stefano Sabatini, stefano.sabatini-lala poste it
diego
parents:
6680
diff
changeset
|
1649 ADPCM_DECODER(CODEC_ID_ADPCM_IMA_DK4, adpcm_ima_dk4, "IMA Duck DK4 ADPCM"); |
047a6a80dca4
ADPCM codec long names by Stefano Sabatini, stefano.sabatini-lala poste it
diego
parents:
6680
diff
changeset
|
1650 ADPCM_DECODER(CODEC_ID_ADPCM_IMA_EA_EACS, adpcm_ima_ea_eacs, "IMA Electronic Arts EACS ADPCM"); |
047a6a80dca4
ADPCM codec long names by Stefano Sabatini, stefano.sabatini-lala poste it
diego
parents:
6680
diff
changeset
|
1651 ADPCM_DECODER(CODEC_ID_ADPCM_IMA_EA_SEAD, adpcm_ima_ea_sead, "IMA Electronic Arts SEAD ADPCM"); |
047a6a80dca4
ADPCM codec long names by Stefano Sabatini, stefano.sabatini-lala poste it
diego
parents:
6680
diff
changeset
|
1652 ADPCM_CODEC (CODEC_ID_ADPCM_IMA_QT, adpcm_ima_qt, "IMA QuickTime ADPCM"); |
047a6a80dca4
ADPCM codec long names by Stefano Sabatini, stefano.sabatini-lala poste it
diego
parents:
6680
diff
changeset
|
1653 ADPCM_DECODER(CODEC_ID_ADPCM_IMA_SMJPEG, adpcm_ima_smjpeg, "IMA Loki SDL MJPEG ADPCM"); |
047a6a80dca4
ADPCM codec long names by Stefano Sabatini, stefano.sabatini-lala poste it
diego
parents:
6680
diff
changeset
|
1654 ADPCM_CODEC (CODEC_ID_ADPCM_IMA_WAV, adpcm_ima_wav, "IMA Wav ADPCM"); |
047a6a80dca4
ADPCM codec long names by Stefano Sabatini, stefano.sabatini-lala poste it
diego
parents:
6680
diff
changeset
|
1655 ADPCM_DECODER(CODEC_ID_ADPCM_IMA_WS, adpcm_ima_ws, "IMA Westwood ADPCM"); |
047a6a80dca4
ADPCM codec long names by Stefano Sabatini, stefano.sabatini-lala poste it
diego
parents:
6680
diff
changeset
|
1656 ADPCM_CODEC (CODEC_ID_ADPCM_MS, adpcm_ms, "Microsoft ADPCM"); |
6813 | 1657 ADPCM_DECODER(CODEC_ID_ADPCM_SBPRO_2, adpcm_sbpro_2, "Sound Blaster Pro 2-bit ADPCM"); |
1658 ADPCM_DECODER(CODEC_ID_ADPCM_SBPRO_3, adpcm_sbpro_3, "Sound Blaster Pro 2.6-bit ADPCM"); | |
1659 ADPCM_DECODER(CODEC_ID_ADPCM_SBPRO_4, adpcm_sbpro_4, "Sound Blaster Pro 4-bit ADPCM"); | |
6801
047a6a80dca4
ADPCM codec long names by Stefano Sabatini, stefano.sabatini-lala poste it
diego
parents:
6680
diff
changeset
|
1660 ADPCM_CODEC (CODEC_ID_ADPCM_SWF, adpcm_swf, "Shockwave Flash ADPCM"); |
047a6a80dca4
ADPCM codec long names by Stefano Sabatini, stefano.sabatini-lala poste it
diego
parents:
6680
diff
changeset
|
1661 ADPCM_DECODER(CODEC_ID_ADPCM_THP, adpcm_thp, "Nintendo Gamecube THP ADPCM"); |
047a6a80dca4
ADPCM codec long names by Stefano Sabatini, stefano.sabatini-lala poste it
diego
parents:
6680
diff
changeset
|
1662 ADPCM_DECODER(CODEC_ID_ADPCM_XA, adpcm_xa, "CDROM XA ADPCM"); |
047a6a80dca4
ADPCM codec long names by Stefano Sabatini, stefano.sabatini-lala poste it
diego
parents:
6680
diff
changeset
|
1663 ADPCM_CODEC (CODEC_ID_ADPCM_YAMAHA, adpcm_yamaha, "Yamaha ADPCM"); |