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