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