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