Mercurial > libavcodec.hg
annotate adpcm.c @ 12197:fbf4d5b1b664 libavcodec
Remove FF_MM_SSE2/3 flags for CPUs where this is generally not faster than
regular MMX code. Examples of this are the Core1 CPU. Instead, set a new flag,
FF_MM_SSE2/3SLOW, which can be checked for particular SSE2/3 functions that
have been checked specifically on such CPUs and are actually faster than
their MMX counterparts.
In addition, use this flag to enable particular VP8 and LPC SSE2 functions
that are faster than their MMX counterparts.
Based on a patch by Loren Merritt <lorenm AT u washington edu>.
author | rbultje |
---|---|
date | Mon, 19 Jul 2010 22:38:23 +0000 |
parents | db5c3a602ddd |
children | 40d7fc8c7850 |
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 | |
581 dst += put_bits_count(&pb)>>3; | |
582 break; | |
583 } | |
4840 | 584 case CODEC_ID_ADPCM_SWF: |
585 { | |
586 int i; | |
587 PutBitContext pb; | |
588 init_put_bits(&pb, dst, buf_size*8); | |
589 | |
5549 | 590 n = avctx->frame_size-1; |
591 | |
4840 | 592 //Store AdpcmCodeSize |
593 put_bits(&pb, 2, 2); //Set 4bits flash adpcm format | |
594 | |
595 //Init the encoder state | |
596 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
|
597 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
|
598 put_sbits(&pb, 16, samples[i]); |
5371
74680ec68fd1
Set the step index correctly for flash adpcm. Patch by Baptiste
banan
parents:
5370
diff
changeset
|
599 put_bits(&pb, 6, c->status[i].step_index); |
4840 | 600 c->status[i].prev_sample = (signed short)samples[i]; |
601 } | |
602 | |
5549 | 603 if(avctx->trellis > 0) { |
11978 | 604 FF_ALLOC_OR_GOTO(avctx, buf, 2*n, error); |
605 adpcm_compress_trellis(avctx, samples+2, buf, &c->status[0], n); | |
5549 | 606 if (avctx->channels == 2) |
11978 | 607 adpcm_compress_trellis(avctx, samples+3, buf+n, &c->status[1], n); |
5549 | 608 for(i=0; i<n; i++) { |
11978 | 609 put_bits(&pb, 4, buf[i]); |
5549 | 610 if (avctx->channels == 2) |
11978 | 611 put_bits(&pb, 4, buf[n+i]); |
5549 | 612 } |
11978 | 613 av_free(buf); |
5549 | 614 } else { |
5550 | 615 for (i=1; i<avctx->frame_size; i++) { |
5834
1edffbe7d57d
Remove unnecessary guarding &=0x0f around adpcm_ima_compress_sample().
diego
parents:
5775
diff
changeset
|
616 put_bits(&pb, 4, adpcm_ima_compress_sample(&c->status[0], samples[avctx->channels*i])); |
5550 | 617 if (avctx->channels == 2) |
5834
1edffbe7d57d
Remove unnecessary guarding &=0x0f around adpcm_ima_compress_sample().
diego
parents:
5775
diff
changeset
|
618 put_bits(&pb, 4, adpcm_ima_compress_sample(&c->status[1], samples[2*i+1])); |
5549 | 619 } |
4840 | 620 } |
5370
bbb982818ce7
Calculate the correct blocksize for flash adpcm. Patch by Baptiste
banan
parents:
5129
diff
changeset
|
621 flush_put_bits(&pb); |
bbb982818ce7
Calculate the correct blocksize for flash adpcm. Patch by Baptiste
banan
parents:
5129
diff
changeset
|
622 dst += put_bits_count(&pb)>>3; |
4840 | 623 break; |
624 } | |
1794 | 625 case CODEC_ID_ADPCM_MS: |
626 for(i=0; i<avctx->channels; i++){ | |
627 int predictor=0; | |
628 | |
629 *dst++ = predictor; | |
630 c->status[i].coeff1 = AdaptCoeff1[predictor]; | |
631 c->status[i].coeff2 = AdaptCoeff2[predictor]; | |
632 } | |
633 for(i=0; i<avctx->channels; i++){ | |
2967 | 634 if (c->status[i].idelta < 16) |
1794 | 635 c->status[i].idelta = 16; |
2967 | 636 |
5089 | 637 bytestream_put_le16(&dst, c->status[i].idelta); |
1794 | 638 } |
639 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
|
640 c->status[i].sample2= *samples++; |
9b836800690a
Fix MS ADPCM de- and encoding: first and second sample are swapped.
reimar
parents:
7247
diff
changeset
|
641 } |
9b836800690a
Fix MS ADPCM de- and encoding: first and second sample are swapped.
reimar
parents:
7247
diff
changeset
|
642 for(i=0; i<avctx->channels; i++){ |
1794 | 643 c->status[i].sample1= *samples++; |
644 | |
5089 | 645 bytestream_put_le16(&dst, c->status[i].sample1); |
1794 | 646 } |
7257
9b836800690a
Fix MS ADPCM de- and encoding: first and second sample are swapped.
reimar
parents:
7247
diff
changeset
|
647 for(i=0; i<avctx->channels; i++) |
5089 | 648 bytestream_put_le16(&dst, c->status[i].sample2); |
1794 | 649 |
3336 | 650 if(avctx->trellis > 0) { |
651 int n = avctx->block_align - 7*avctx->channels; | |
11978 | 652 FF_ALLOC_OR_GOTO(avctx, buf, 2*n, error); |
3336 | 653 if(avctx->channels == 1) { |
11978 | 654 adpcm_compress_trellis(avctx, samples, buf, &c->status[0], n); |
3336 | 655 for(i=0; i<n; i+=2) |
11978 | 656 *dst++ = (buf[i] << 4) | buf[i+1]; |
3336 | 657 } else { |
11978 | 658 adpcm_compress_trellis(avctx, samples, buf, &c->status[0], n); |
659 adpcm_compress_trellis(avctx, samples+1, buf+n, &c->status[1], n); | |
3336 | 660 for(i=0; i<n; i++) |
11978 | 661 *dst++ = (buf[i] << 4) | buf[n+i]; |
3336 | 662 } |
11978 | 663 av_free(buf); |
3336 | 664 } else |
1794 | 665 for(i=7*avctx->channels; i<avctx->block_align; i++) { |
666 int nibble; | |
667 nibble = adpcm_ms_compress_sample(&c->status[ 0], *samples++)<<4; | |
668 nibble|= adpcm_ms_compress_sample(&c->status[st], *samples++); | |
669 *dst++ = nibble; | |
670 } | |
671 break; | |
2794
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
672 case CODEC_ID_ADPCM_YAMAHA: |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
673 n = avctx->frame_size / 2; |
3336 | 674 if(avctx->trellis > 0) { |
11978 | 675 FF_ALLOC_OR_GOTO(avctx, buf, 2*n*2, error); |
3336 | 676 n *= 2; |
677 if(avctx->channels == 1) { | |
11978 | 678 adpcm_compress_trellis(avctx, samples, buf, &c->status[0], n); |
3336 | 679 for(i=0; i<n; i+=2) |
11978 | 680 *dst++ = buf[i] | (buf[i+1] << 4); |
3336 | 681 } else { |
11978 | 682 adpcm_compress_trellis(avctx, samples, buf, &c->status[0], n); |
683 adpcm_compress_trellis(avctx, samples+1, buf+n, &c->status[1], n); | |
3336 | 684 for(i=0; i<n; i++) |
11978 | 685 *dst++ = buf[i] | (buf[n+i] << 4); |
3336 | 686 } |
11978 | 687 av_free(buf); |
3336 | 688 } else |
9874 | 689 for (n *= avctx->channels; n>0; n--) { |
690 int nibble; | |
691 nibble = adpcm_yamaha_compress_sample(&c->status[ 0], *samples++); | |
692 nibble |= adpcm_yamaha_compress_sample(&c->status[st], *samples++) << 4; | |
693 *dst++ = nibble; | |
694 } | |
2794
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
695 break; |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
696 default: |
11978 | 697 error: |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
698 return -1; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
699 } |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
700 return dst - frame; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
701 } |
1530
3b31998fe22f
disable encoders where appropriate (patch courtesy of BERO
melanson
parents:
1491
diff
changeset
|
702 #endif //CONFIG_ENCODERS |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
703 |
6517
48759bfbd073
Apply 'cold' attribute to init/uninit functions in libavcodec
zuxy
parents:
6461
diff
changeset
|
704 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
|
705 { |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
706 ADPCMContext *c = avctx->priv_data; |
6678 | 707 unsigned int max_channels = 2; |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
708 |
5851 | 709 switch(avctx->codec->id) { |
710 case CODEC_ID_ADPCM_EA_R1: | |
711 case CODEC_ID_ADPCM_EA_R2: | |
712 case CODEC_ID_ADPCM_EA_R3: | |
713 max_channels = 6; | |
714 break; | |
715 } | |
716 if(avctx->channels > max_channels){ | |
4461
c95e0df9841f
some (probably exploitable) out of array write fixes
michael
parents:
4364
diff
changeset
|
717 return -1; |
c95e0df9841f
some (probably exploitable) out of array write fixes
michael
parents:
4364
diff
changeset
|
718 } |
c95e0df9841f
some (probably exploitable) out of array write fixes
michael
parents:
4364
diff
changeset
|
719 |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
720 switch(avctx->codec->id) { |
2296
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
721 case CODEC_ID_ADPCM_CT: |
2979 | 722 c->status[0].step = c->status[1].step = 511; |
723 break; | |
4809 | 724 case CODEC_ID_ADPCM_IMA_WS: |
725 if (avctx->extradata && avctx->extradata_size == 2 * 4) { | |
726 c->status[0].predictor = AV_RL32(avctx->extradata); | |
727 c->status[1].predictor = AV_RL32(avctx->extradata + 4); | |
728 } | |
729 break; | |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
730 default: |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
731 break; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
732 } |
7451
85ab7655ad4d
Modify all codecs to report their supported input and output sample format(s).
pross
parents:
7260
diff
changeset
|
733 avctx->sample_fmt = SAMPLE_FMT_S16; |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
734 return 0; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
735 } |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
736 |
1737 | 737 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
|
738 { |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
739 int step_index; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
740 int predictor; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
741 int sign, delta, diff, step; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
742 |
1081
18157900b434
* fixed IMA WAV decoding (though still might not be fully correct)
kabi
parents:
1064
diff
changeset
|
743 step = step_table[c->step_index]; |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
744 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
|
745 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
|
746 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
|
747 |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
748 sign = nibble & 8; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
749 delta = nibble & 7; |
1443
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
750 /* 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
|
751 * 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
|
752 * quickly enough */ |
1737 | 753 diff = ((2 * delta + 1) * step) >> shift; |
1296 | 754 predictor = c->predictor; |
755 if (sign) predictor -= diff; | |
756 else predictor += diff; | |
757 | |
5525
bc4791868c52
various simplifications around recent av_clip_int16() usage
aurel
parents:
5523
diff
changeset
|
758 c->predictor = av_clip_int16(predictor); |
1296 | 759 c->step_index = step_index; |
760 | |
5525
bc4791868c52
various simplifications around recent av_clip_int16() usage
aurel
parents:
5523
diff
changeset
|
761 return (short)c->predictor; |
1296 | 762 } |
763 | |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
764 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
|
765 { |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
766 int predictor; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
767 |
7246 | 768 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
|
769 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
|
770 |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
771 c->sample2 = c->sample1; |
5525
bc4791868c52
various simplifications around recent av_clip_int16() usage
aurel
parents:
5523
diff
changeset
|
772 c->sample1 = av_clip_int16(predictor); |
1794 | 773 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
|
774 if (c->idelta < 16) c->idelta = 16; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
775 |
5525
bc4791868c52
various simplifications around recent av_clip_int16() usage
aurel
parents:
5523
diff
changeset
|
776 return c->sample1; |
573
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 |
2296
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
779 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
|
780 { |
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
781 int sign, delta, diff; |
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
782 int new_step; |
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
783 |
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
784 sign = nibble & 8; |
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
785 delta = nibble & 7; |
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
786 /* 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
|
787 * 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
|
788 * quickly enough */ |
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
789 diff = ((2 * delta + 1) * c->step) >> 3; |
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
790 /* predictor update is not so trivial: predictor is multiplied on 254/256 before updating */ |
5526 | 791 c->predictor = ((c->predictor * 254) >> 8) + (sign ? -diff : diff); |
792 c->predictor = av_clip_int16(c->predictor); | |
2296
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
793 /* calculate new step and clamp it to range 511..32767 */ |
8696 | 794 new_step = (AdaptationTable[nibble & 7] * c->step) >> 8; |
5527 | 795 c->step = av_clip(new_step, 511, 32767); |
2296
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
796 |
5525
bc4791868c52
various simplifications around recent av_clip_int16() usage
aurel
parents:
5523
diff
changeset
|
797 return (short)c->predictor; |
2296
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
798 } |
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
799 |
3127 | 800 static inline short adpcm_sbpro_expand_nibble(ADPCMChannelStatus *c, char nibble, int size, int shift) |
801 { | |
802 int sign, delta, diff; | |
803 | |
804 sign = nibble & (1<<(size-1)); | |
805 delta = nibble & ((1<<(size-1))-1); | |
806 diff = delta << (7 + c->step + shift); | |
807 | |
808 /* clamp result */ | |
5527 | 809 c->predictor = av_clip(c->predictor + (sign ? -diff : diff), -16384,16256); |
3127 | 810 |
811 /* calculate new step */ | |
812 if (delta >= (2*size - 3) && c->step < 3) | |
813 c->step++; | |
814 else if (delta == 0 && c->step > 0) | |
815 c->step--; | |
816 | |
817 return (short) c->predictor; | |
818 } | |
819 | |
2794
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
820 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
|
821 { |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
822 if(!c->step) { |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
823 c->predictor = 0; |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
824 c->step = 127; |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
825 } |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
826 |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
827 c->predictor += (c->step * yamaha_difflookup[nibble]) / 8; |
5523 | 828 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
|
829 c->step = (c->step * yamaha_indexscale[nibble]) >> 8; |
4594 | 830 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
|
831 return c->predictor; |
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 |
2967 | 834 static void xa_decode(short *out, const unsigned char *in, |
1535 | 835 ADPCMChannelStatus *left, ADPCMChannelStatus *right, int inc) |
836 { | |
837 int i, j; | |
838 int shift,filter,f0,f1; | |
839 int s_1,s_2; | |
840 int d,s,t; | |
841 | |
842 for(i=0;i<4;i++) { | |
843 | |
844 shift = 12 - (in[4+i*2] & 15); | |
845 filter = in[4+i*2] >> 4; | |
846 f0 = xa_adpcm_table[filter][0]; | |
847 f1 = xa_adpcm_table[filter][1]; | |
848 | |
849 s_1 = left->sample1; | |
850 s_2 = left->sample2; | |
851 | |
852 for(j=0;j<28;j++) { | |
853 d = in[16+i+j*4]; | |
854 | |
855 t = (signed char)(d<<4)>>4; | |
856 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
|
857 s_2 = s_1; |
bc4791868c52
various simplifications around recent av_clip_int16() usage
aurel
parents:
5523
diff
changeset
|
858 s_1 = av_clip_int16(s); |
bc4791868c52
various simplifications around recent av_clip_int16() usage
aurel
parents:
5523
diff
changeset
|
859 *out = s_1; |
1535 | 860 out += inc; |
861 } | |
862 | |
863 if (inc==2) { /* stereo */ | |
864 left->sample1 = s_1; | |
865 left->sample2 = s_2; | |
866 s_1 = right->sample1; | |
867 s_2 = right->sample2; | |
868 out = out + 1 - 28*2; | |
869 } | |
870 | |
871 shift = 12 - (in[5+i*2] & 15); | |
872 filter = in[5+i*2] >> 4; | |
873 | |
874 f0 = xa_adpcm_table[filter][0]; | |
875 f1 = xa_adpcm_table[filter][1]; | |
876 | |
877 for(j=0;j<28;j++) { | |
878 d = in[16+i+j*4]; | |
879 | |
880 t = (signed char)d >> 4; | |
881 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
|
882 s_2 = s_1; |
bc4791868c52
various simplifications around recent av_clip_int16() usage
aurel
parents:
5523
diff
changeset
|
883 s_1 = av_clip_int16(s); |
bc4791868c52
various simplifications around recent av_clip_int16() usage
aurel
parents:
5523
diff
changeset
|
884 *out = s_1; |
1535 | 885 out += inc; |
886 } | |
887 | |
888 if (inc==2) { /* stereo */ | |
889 right->sample1 = s_1; | |
890 right->sample2 = s_2; | |
891 out -= 1; | |
892 } else { | |
893 left->sample1 = s_1; | |
894 left->sample2 = s_2; | |
895 } | |
896 } | |
897 } | |
898 | |
899 | |
1443
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
900 /* DK3 ADPCM support macro */ |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
901 #define DK3_GET_NEXT_NIBBLE() \ |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
902 if (decode_top_nibble_next) \ |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
903 { \ |
6586 | 904 nibble = last_byte >> 4; \ |
1443
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
905 decode_top_nibble_next = 0; \ |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
906 } \ |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
907 else \ |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
908 { \ |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
909 last_byte = *src++; \ |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
910 if (src >= buf + buf_size) break; \ |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
911 nibble = last_byte & 0x0F; \ |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
912 decode_top_nibble_next = 1; \ |
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 |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
915 static int adpcm_decode_frame(AVCodecContext *avctx, |
2979 | 916 void *data, int *data_size, |
9355
54bc8a2727b0
Implement avcodec_decode_video2(), _audio3() and _subtitle2() which takes an
rbultje
parents:
9087
diff
changeset
|
917 AVPacket *avpkt) |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
918 { |
9355
54bc8a2727b0
Implement avcodec_decode_video2(), _audio3() and _subtitle2() which takes an
rbultje
parents:
9087
diff
changeset
|
919 const uint8_t *buf = avpkt->data; |
54bc8a2727b0
Implement avcodec_decode_video2(), _audio3() and _subtitle2() which takes an
rbultje
parents:
9087
diff
changeset
|
920 int buf_size = avpkt->size; |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
921 ADPCMContext *c = avctx->priv_data; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
922 ADPCMChannelStatus *cs; |
1296 | 923 int n, m, channel, i; |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
924 int block_predictor[2]; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
925 short *samples; |
4461
c95e0df9841f
some (probably exploitable) out of array write fixes
michael
parents:
4364
diff
changeset
|
926 short *samples_end; |
6259 | 927 const uint8_t *src; |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
928 int st; /* stereo */ |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
929 |
1443
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
930 /* DK3 ADPCM accounting variables */ |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
931 unsigned char last_byte = 0; |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
932 unsigned char nibble; |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
933 int decode_top_nibble_next = 0; |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
934 int diff_channel; |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
935 |
1779 | 936 /* EA ADPCM state variables */ |
937 uint32_t samples_in_chunk; | |
938 int32_t previous_left_sample, previous_right_sample; | |
939 int32_t current_left_sample, current_right_sample; | |
940 int32_t next_left_sample, next_right_sample; | |
941 int32_t coeff1l, coeff2l, coeff1r, coeff2r; | |
942 uint8_t shift_left, shift_right; | |
943 int count1, count2; | |
6596 | 944 int coeff[2][2], shift[2];//used in EA MAXIS ADPCM |
1779 | 945 |
1768 | 946 if (!buf_size) |
947 return 0; | |
948 | |
4461
c95e0df9841f
some (probably exploitable) out of array write fixes
michael
parents:
4364
diff
changeset
|
949 //should protect all 4bit ADPCM variants |
c95e0df9841f
some (probably exploitable) out of array write fixes
michael
parents:
4364
diff
changeset
|
950 //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
|
951 // |
c95e0df9841f
some (probably exploitable) out of array write fixes
michael
parents:
4364
diff
changeset
|
952 if(*data_size/4 < buf_size + 8) |
c95e0df9841f
some (probably exploitable) out of array write fixes
michael
parents:
4364
diff
changeset
|
953 return -1; |
c95e0df9841f
some (probably exploitable) out of array write fixes
michael
parents:
4364
diff
changeset
|
954 |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
955 samples = data; |
4461
c95e0df9841f
some (probably exploitable) out of array write fixes
michael
parents:
4364
diff
changeset
|
956 samples_end= samples + *data_size/2; |
c95e0df9841f
some (probably exploitable) out of array write fixes
michael
parents:
4364
diff
changeset
|
957 *data_size= 0; |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
958 src = buf; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
959 |
3127 | 960 st = avctx->channels == 2 ? 1 : 0; |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
961 |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
962 switch(avctx->codec->id) { |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
963 case CODEC_ID_ADPCM_IMA_QT: |
6677
abb1f01ca0db
remove ima qt decoding hack, decode whole frame at once
bcoudurier
parents:
6676
diff
changeset
|
964 n = buf_size - 2*avctx->channels; |
abb1f01ca0db
remove ima qt decoding hack, decode whole frame at once
bcoudurier
parents:
6676
diff
changeset
|
965 for (channel = 0; channel < avctx->channels; channel++) { |
6680 | 966 cs = &(c->status[channel]); |
967 /* (pppppp) (piiiiiii) */ | |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
968 |
6680 | 969 /* Bits 15-7 are the _top_ 9 bits of the 16-bit initial predictor value */ |
970 cs->predictor = (*src++) << 8; | |
971 cs->predictor |= (*src & 0x80); | |
972 cs->predictor &= 0xFF80; | |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
973 |
6680 | 974 /* sign extension */ |
975 if(cs->predictor & 0x8000) | |
976 cs->predictor -= 0x10000; | |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
977 |
6680 | 978 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
|
979 |
6680 | 980 cs->step_index = (*src++) & 0x7F; |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
981 |
6680 | 982 if (cs->step_index > 88){ |
983 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index = %i\n", cs->step_index); | |
984 cs->step_index = 88; | |
985 } | |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
986 |
6680 | 987 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
|
988 |
6680 | 989 samples = (short*)data + channel; |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
990 |
6680 | 991 for(m=32; n>0 && m>0; n--, m--) { /* in QuickTime, IMA is encoded by chuncks of 34 bytes (=64 samples) */ |
992 *samples = adpcm_ima_expand_nibble(cs, src[0] & 0x0F, 3); | |
993 samples += avctx->channels; | |
994 *samples = adpcm_ima_expand_nibble(cs, src[0] >> 4 , 3); | |
995 samples += avctx->channels; | |
996 src ++; | |
997 } | |
6677
abb1f01ca0db
remove ima qt decoding hack, decode whole frame at once
bcoudurier
parents:
6676
diff
changeset
|
998 } |
abb1f01ca0db
remove ima qt decoding hack, decode whole frame at once
bcoudurier
parents:
6676
diff
changeset
|
999 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
|
1000 samples--; |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1001 break; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1002 case CODEC_ID_ADPCM_IMA_WAV: |
1576
bc4b13ca74de
block algn patch by ("Assaf Yaari" <assafy at mobixell dot com>)
michael
parents:
1559
diff
changeset
|
1003 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
|
1004 buf_size = avctx->block_align; |
bc4b13ca74de
block algn patch by ("Assaf Yaari" <assafy at mobixell dot com>)
michael
parents:
1559
diff
changeset
|
1005 |
3157 | 1006 // samples_per_block= (block_align-4*chanels)*8 / (bits_per_sample * chanels) + 1; |
1007 | |
1737 | 1008 for(i=0; i<avctx->channels; i++){ |
1009 cs = &(c->status[i]); | |
7258
48c9043b1372
Use bytestream and AV_RL* functions in ADPCM code where possible
reimar
parents:
7257
diff
changeset
|
1010 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
|
1011 |
1737 | 1012 cs->step_index = *src++; |
3157 | 1013 if (cs->step_index > 88){ |
1014 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index = %i\n", cs->step_index); | |
1015 cs->step_index = 88; | |
1016 } | |
1017 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
|
1018 } |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1019 |
3157 | 1020 while(src < buf + buf_size){ |
1021 for(m=0; m<4; m++){ | |
1022 for(i=0; i<=st; i++) | |
1023 *samples++ = adpcm_ima_expand_nibble(&c->status[i], src[4*i] & 0x0F, 3); | |
1024 for(i=0; i<=st; i++) | |
1025 *samples++ = adpcm_ima_expand_nibble(&c->status[i], src[4*i] >> 4 , 3); | |
1026 src++; | |
2979 | 1027 } |
3157 | 1028 src += 4*st; |
2979 | 1029 } |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1030 break; |
1296 | 1031 case CODEC_ID_ADPCM_4XM: |
1032 cs = &(c->status[0]); | |
7258
48c9043b1372
Use bytestream and AV_RL* functions in ADPCM code where possible
reimar
parents:
7257
diff
changeset
|
1033 c->status[0].predictor= (int16_t)bytestream_get_le16(&src); |
1296 | 1034 if(st){ |
7258
48c9043b1372
Use bytestream and AV_RL* functions in ADPCM code where possible
reimar
parents:
7257
diff
changeset
|
1035 c->status[1].predictor= (int16_t)bytestream_get_le16(&src); |
1296 | 1036 } |
7258
48c9043b1372
Use bytestream and AV_RL* functions in ADPCM code where possible
reimar
parents:
7257
diff
changeset
|
1037 c->status[0].step_index= (int16_t)bytestream_get_le16(&src); |
1296 | 1038 if(st){ |
7258
48c9043b1372
Use bytestream and AV_RL* functions in ADPCM code where possible
reimar
parents:
7257
diff
changeset
|
1039 c->status[1].step_index= (int16_t)bytestream_get_le16(&src); |
1296 | 1040 } |
1695
2d11403fde4e
initial predictors are not sent to the output in QT IMA; fix stereo QT
melanson
parents:
1611
diff
changeset
|
1041 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
|
1042 if (cs->step_index > 88) cs->step_index = 88; |
1296 | 1043 |
1044 m= (buf_size - (src - buf))>>st; | |
1045 for(i=0; i<m; i++) { | |
2979 | 1046 *samples++ = adpcm_ima_expand_nibble(&c->status[0], src[i] & 0x0F, 4); |
1296 | 1047 if (st) |
1737 | 1048 *samples++ = adpcm_ima_expand_nibble(&c->status[1], src[i+m] & 0x0F, 4); |
1049 *samples++ = adpcm_ima_expand_nibble(&c->status[0], src[i] >> 4, 4); | |
2979 | 1050 if (st) |
1737 | 1051 *samples++ = adpcm_ima_expand_nibble(&c->status[1], src[i+m] >> 4, 4); |
2979 | 1052 } |
1296 | 1053 |
1054 src += m<<st; | |
1055 | |
1056 break; | |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1057 case CODEC_ID_ADPCM_MS: |
1576
bc4b13ca74de
block algn patch by ("Assaf Yaari" <assafy at mobixell dot com>)
michael
parents:
1559
diff
changeset
|
1058 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
|
1059 buf_size = avctx->block_align; |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1060 n = buf_size - 7 * avctx->channels; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1061 if (n < 0) |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1062 return -1; |
7259
9de4bc7d4938
clip MS ADPCM predictor range to correct [0..6] range, not [0..7]
reimar
parents:
7258
diff
changeset
|
1063 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
|
1064 block_predictor[1] = 0; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1065 if (st) |
7259
9de4bc7d4938
clip MS ADPCM predictor range to correct [0..6] range, not [0..7]
reimar
parents:
7258
diff
changeset
|
1066 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
|
1067 c->status[0].idelta = (int16_t)bytestream_get_le16(&src); |
1794 | 1068 if (st){ |
7258
48c9043b1372
Use bytestream and AV_RL* functions in ADPCM code where possible
reimar
parents:
7257
diff
changeset
|
1069 c->status[1].idelta = (int16_t)bytestream_get_le16(&src); |
1794 | 1070 } |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1071 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
|
1072 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
|
1073 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
|
1074 c->status[1].coeff2 = AdaptCoeff2[block_predictor[1]]; |
2967 | 1075 |
7258
48c9043b1372
Use bytestream and AV_RL* functions in ADPCM code where possible
reimar
parents:
7257
diff
changeset
|
1076 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
|
1077 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
|
1078 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
|
1079 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
|
1080 |
7257
9b836800690a
Fix MS ADPCM de- and encoding: first and second sample are swapped.
reimar
parents:
7247
diff
changeset
|
1081 *samples++ = c->status[0].sample2; |
9b836800690a
Fix MS ADPCM de- and encoding: first and second sample are swapped.
reimar
parents:
7247
diff
changeset
|
1082 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
|
1083 *samples++ = c->status[0].sample1; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1084 if (st) *samples++ = c->status[1].sample1; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1085 for(;n>0;n--) { |
6586 | 1086 *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
|
1087 *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
|
1088 src ++; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1089 } |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1090 break; |
1443
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1091 case CODEC_ID_ADPCM_IMA_DK4: |
1577 | 1092 if (avctx->block_align != 0 && buf_size > avctx->block_align) |
1093 buf_size = avctx->block_align; | |
1094 | |
7258
48c9043b1372
Use bytestream and AV_RL* functions in ADPCM code where possible
reimar
parents:
7257
diff
changeset
|
1095 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
|
1096 c->status[0].step_index = *src++; |
48c9043b1372
Use bytestream and AV_RL* functions in ADPCM code where possible
reimar
parents:
7257
diff
changeset
|
1097 src++; |
1443
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1098 *samples++ = c->status[0].predictor; |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1099 if (st) { |
7258
48c9043b1372
Use bytestream and AV_RL* functions in ADPCM code where possible
reimar
parents:
7257
diff
changeset
|
1100 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
|
1101 c->status[1].step_index = *src++; |
48c9043b1372
Use bytestream and AV_RL* functions in ADPCM code where possible
reimar
parents:
7257
diff
changeset
|
1102 src++; |
1443
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1103 *samples++ = c->status[1].predictor; |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1104 } |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1105 while (src < buf + buf_size) { |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1106 |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1107 /* take care of the top nibble (always left or mono channel) */ |
2967 | 1108 *samples++ = adpcm_ima_expand_nibble(&c->status[0], |
6586 | 1109 src[0] >> 4, 3); |
1443
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1110 |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1111 /* 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
|
1112 * stereo, or another mono sample */ |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1113 if (st) |
2967 | 1114 *samples++ = adpcm_ima_expand_nibble(&c->status[1], |
1737 | 1115 src[0] & 0x0F, 3); |
1443
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1116 else |
2967 | 1117 *samples++ = adpcm_ima_expand_nibble(&c->status[0], |
1737 | 1118 src[0] & 0x0F, 3); |
1443
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1119 |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1120 src++; |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1121 } |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1122 break; |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1123 case CODEC_ID_ADPCM_IMA_DK3: |
1577 | 1124 if (avctx->block_align != 0 && buf_size > avctx->block_align) |
1125 buf_size = avctx->block_align; | |
1126 | |
4461
c95e0df9841f
some (probably exploitable) out of array write fixes
michael
parents:
4364
diff
changeset
|
1127 if(buf_size + 16 > (samples_end - samples)*3/8) |
c95e0df9841f
some (probably exploitable) out of array write fixes
michael
parents:
4364
diff
changeset
|
1128 return -1; |
c95e0df9841f
some (probably exploitable) out of array write fixes
michael
parents:
4364
diff
changeset
|
1129 |
7258
48c9043b1372
Use bytestream and AV_RL* functions in ADPCM code where possible
reimar
parents:
7257
diff
changeset
|
1130 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
|
1131 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
|
1132 c->status[0].step_index = src[14]; |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1133 c->status[1].step_index = src[15]; |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1134 /* sign extend the predictors */ |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1135 src += 16; |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1136 diff_channel = c->status[1].predictor; |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1137 |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1138 /* 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
|
1139 * the buffer is consumed */ |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1140 while (1) { |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1141 |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1142 /* 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
|
1143 * c->status[1] is the diff channel */ |
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 /* 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
|
1146 DK3_GET_NEXT_NIBBLE(); |
1737 | 1147 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
|
1148 |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1149 /* process the diff channel predictor */ |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1150 DK3_GET_NEXT_NIBBLE(); |
1737 | 1151 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
|
1152 |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1153 /* 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
|
1154 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
|
1155 *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
|
1156 *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
|
1157 |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1158 /* 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
|
1159 DK3_GET_NEXT_NIBBLE(); |
1737 | 1160 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
|
1161 |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1162 /* 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
|
1163 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
|
1164 *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
|
1165 *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
|
1166 } |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1167 break; |
8615 | 1168 case CODEC_ID_ADPCM_IMA_ISS: |
1169 c->status[0].predictor = (int16_t)AV_RL16(src + 0); | |
1170 c->status[0].step_index = src[2]; | |
1171 src += 4; | |
1172 if(st) { | |
1173 c->status[1].predictor = (int16_t)AV_RL16(src + 0); | |
1174 c->status[1].step_index = src[2]; | |
1175 src += 4; | |
1176 } | |
1177 | |
1178 while (src < buf + buf_size) { | |
1179 | |
1180 if (st) { | |
1181 *samples++ = adpcm_ima_expand_nibble(&c->status[0], | |
1182 src[0] >> 4 , 3); | |
1183 *samples++ = adpcm_ima_expand_nibble(&c->status[1], | |
1184 src[0] & 0x0F, 3); | |
1185 } else { | |
1186 *samples++ = adpcm_ima_expand_nibble(&c->status[0], | |
1187 src[0] & 0x0F, 3); | |
1188 *samples++ = adpcm_ima_expand_nibble(&c->status[0], | |
1189 src[0] >> 4 , 3); | |
1190 } | |
1191 | |
1192 src++; | |
1193 } | |
1194 break; | |
1491
222643544cf1
New demuxers: Sega FILM/CPK, Westwood VQA & AUD; new decoders: MS RLE &
tmmm
parents:
1443
diff
changeset
|
1195 case CODEC_ID_ADPCM_IMA_WS: |
222643544cf1
New demuxers: Sega FILM/CPK, Westwood VQA & AUD; new decoders: MS RLE &
tmmm
parents:
1443
diff
changeset
|
1196 /* 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
|
1197 while (src < buf + buf_size) { |
222643544cf1
New demuxers: Sega FILM/CPK, Westwood VQA & AUD; new decoders: MS RLE &
tmmm
parents:
1443
diff
changeset
|
1198 |
222643544cf1
New demuxers: Sega FILM/CPK, Westwood VQA & AUD; new decoders: MS RLE &
tmmm
parents:
1443
diff
changeset
|
1199 if (st) { |
2967 | 1200 *samples++ = adpcm_ima_expand_nibble(&c->status[0], |
6586 | 1201 src[0] >> 4 , 3); |
2967 | 1202 *samples++ = adpcm_ima_expand_nibble(&c->status[1], |
1737 | 1203 src[0] & 0x0F, 3); |
1491
222643544cf1
New demuxers: Sega FILM/CPK, Westwood VQA & AUD; new decoders: MS RLE &
tmmm
parents:
1443
diff
changeset
|
1204 } else { |
2967 | 1205 *samples++ = adpcm_ima_expand_nibble(&c->status[0], |
6586 | 1206 src[0] >> 4 , 3); |
2967 | 1207 *samples++ = adpcm_ima_expand_nibble(&c->status[0], |
1737 | 1208 src[0] & 0x0F, 3); |
1491
222643544cf1
New demuxers: Sega FILM/CPK, Westwood VQA & AUD; new decoders: MS RLE &
tmmm
parents:
1443
diff
changeset
|
1209 } |
222643544cf1
New demuxers: Sega FILM/CPK, Westwood VQA & AUD; new decoders: MS RLE &
tmmm
parents:
1443
diff
changeset
|
1210 |
222643544cf1
New demuxers: Sega FILM/CPK, Westwood VQA & AUD; new decoders: MS RLE &
tmmm
parents:
1443
diff
changeset
|
1211 src++; |
222643544cf1
New demuxers: Sega FILM/CPK, Westwood VQA & AUD; new decoders: MS RLE &
tmmm
parents:
1443
diff
changeset
|
1212 } |
222643544cf1
New demuxers: Sega FILM/CPK, Westwood VQA & AUD; new decoders: MS RLE &
tmmm
parents:
1443
diff
changeset
|
1213 break; |
1535 | 1214 case CODEC_ID_ADPCM_XA: |
1215 while (buf_size >= 128) { | |
2967 | 1216 xa_decode(samples, src, &c->status[0], &c->status[1], |
1535 | 1217 avctx->channels); |
1218 src += 128; | |
1219 samples += 28 * 8; | |
1220 buf_size -= 128; | |
1221 } | |
1222 break; | |
5854 | 1223 case CODEC_ID_ADPCM_IMA_EA_EACS: |
1224 samples_in_chunk = bytestream_get_le32(&src) >> (1-st); | |
1225 | |
1226 if (samples_in_chunk > buf_size-4-(8<<st)) { | |
1227 src += buf_size - 4; | |
1228 break; | |
1229 } | |
1230 | |
1231 for (i=0; i<=st; i++) | |
1232 c->status[i].step_index = bytestream_get_le32(&src); | |
1233 for (i=0; i<=st; i++) | |
1234 c->status[i].predictor = bytestream_get_le32(&src); | |
1235 | |
1236 for (; samples_in_chunk; samples_in_chunk--, src++) { | |
1237 *samples++ = adpcm_ima_expand_nibble(&c->status[0], *src>>4, 3); | |
1238 *samples++ = adpcm_ima_expand_nibble(&c->status[st], *src&0x0F, 3); | |
1239 } | |
1240 break; | |
5853 | 1241 case CODEC_ID_ADPCM_IMA_EA_SEAD: |
1242 for (; src < buf+buf_size; src++) { | |
1243 *samples++ = adpcm_ima_expand_nibble(&c->status[0], src[0] >> 4, 6); | |
1244 *samples++ = adpcm_ima_expand_nibble(&c->status[st],src[0]&0x0F, 6); | |
1245 } | |
1246 break; | |
1779 | 1247 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
|
1248 if (buf_size < 4 || AV_RL32(src) >= ((buf_size - 12) * 2)) { |
1779 | 1249 src += buf_size; |
1250 break; | |
1251 } | |
9577
0b4ee8aa4c11
Check if there is enough bytes before reading the buffer in the EA ADPCM
vitor
parents:
9576
diff
changeset
|
1252 samples_in_chunk = AV_RL32(src); |
1779 | 1253 src += 4; |
7258
48c9043b1372
Use bytestream and AV_RL* functions in ADPCM code where possible
reimar
parents:
7257
diff
changeset
|
1254 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
|
1255 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
|
1256 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
|
1257 previous_right_sample = (int16_t)bytestream_get_le16(&src); |
1779 | 1258 |
1259 for (count1 = 0; count1 < samples_in_chunk/28;count1++) { | |
6586 | 1260 coeff1l = ea_adpcm_table[ *src >> 4 ]; |
1261 coeff2l = ea_adpcm_table[(*src >> 4 ) + 4]; | |
1779 | 1262 coeff1r = ea_adpcm_table[*src & 0x0F]; |
1263 coeff2r = ea_adpcm_table[(*src & 0x0F) + 4]; | |
1264 src++; | |
1265 | |
6586 | 1266 shift_left = (*src >> 4 ) + 8; |
1779 | 1267 shift_right = (*src & 0x0F) + 8; |
1268 src++; | |
1269 | |
1270 for (count2 = 0; count2 < 28; count2++) { | |
6592 | 1271 next_left_sample = (int32_t)((*src & 0xF0) << 24) >> shift_left; |
1272 next_right_sample = (int32_t)((*src & 0x0F) << 28) >> shift_right; | |
1779 | 1273 src++; |
1274 | |
2967 | 1275 next_left_sample = (next_left_sample + |
1276 (current_left_sample * coeff1l) + | |
1779 | 1277 (previous_left_sample * coeff2l) + 0x80) >> 8; |
2967 | 1278 next_right_sample = (next_right_sample + |
1279 (current_right_sample * coeff1r) + | |
1779 | 1280 (previous_right_sample * coeff2r) + 0x80) >> 8; |
1281 | |
1282 previous_left_sample = current_left_sample; | |
5525
bc4791868c52
various simplifications around recent av_clip_int16() usage
aurel
parents:
5523
diff
changeset
|
1283 current_left_sample = av_clip_int16(next_left_sample); |
1779 | 1284 previous_right_sample = current_right_sample; |
5525
bc4791868c52
various simplifications around recent av_clip_int16() usage
aurel
parents:
5523
diff
changeset
|
1285 current_right_sample = av_clip_int16(next_right_sample); |
1779 | 1286 *samples++ = (unsigned short)current_left_sample; |
1287 *samples++ = (unsigned short)current_right_sample; | |
1288 } | |
1289 } | |
9576 | 1290 |
1291 if (src - buf == buf_size - 2) | |
1292 src += 2; // Skip terminating 0x0000 | |
1293 | |
1779 | 1294 break; |
6596 | 1295 case CODEC_ID_ADPCM_EA_MAXIS_XA: |
1296 for(channel = 0; channel < avctx->channels; channel++) { | |
1297 for (i=0; i<2; i++) | |
1298 coeff[channel][i] = ea_adpcm_table[(*src >> 4) + 4*i]; | |
1299 shift[channel] = (*src & 0x0F) + 8; | |
1300 src++; | |
1301 } | |
1302 for (count1 = 0; count1 < (buf_size - avctx->channels) / avctx->channels; count1++) { | |
1303 for(i = 4; i >= 0; i-=4) { /* Pairwise samples LL RR (st) or LL LL (mono) */ | |
1304 for(channel = 0; channel < avctx->channels; channel++) { | |
1305 int32_t sample = (int32_t)(((*(src+channel) >> i) & 0x0F) << 0x1C) >> shift[channel]; | |
1306 sample = (sample + | |
1307 c->status[channel].sample1 * coeff[channel][0] + | |
1308 c->status[channel].sample2 * coeff[channel][1] + 0x80) >> 8; | |
1309 c->status[channel].sample2 = c->status[channel].sample1; | |
1310 c->status[channel].sample1 = av_clip_int16(sample); | |
1311 *samples++ = c->status[channel].sample1; | |
1312 } | |
1313 } | |
1314 src+=avctx->channels; | |
1315 } | |
1316 break; | |
5851 | 1317 case CODEC_ID_ADPCM_EA_R1: |
1318 case CODEC_ID_ADPCM_EA_R2: | |
1319 case CODEC_ID_ADPCM_EA_R3: { | |
1320 /* channel numbering | |
1321 2chan: 0=fl, 1=fr | |
1322 4chan: 0=fl, 1=rl, 2=fr, 3=rr | |
1323 6chan: 0=fl, 1=c, 2=fr, 3=rl, 4=rr, 5=sub */ | |
1324 const int big_endian = avctx->codec->id == CODEC_ID_ADPCM_EA_R3; | |
1325 int32_t previous_sample, current_sample, next_sample; | |
1326 int32_t coeff1, coeff2; | |
1327 uint8_t shift; | |
1328 unsigned int channel; | |
1329 uint16_t *samplesC; | |
6259 | 1330 const uint8_t *srcC; |
8734 | 1331 const uint8_t *src_end = buf + buf_size; |
5851 | 1332 |
1333 samples_in_chunk = (big_endian ? bytestream_get_be32(&src) | |
1334 : bytestream_get_le32(&src)) / 28; | |
1335 if (samples_in_chunk > UINT32_MAX/(28*avctx->channels) || | |
1336 28*samples_in_chunk*avctx->channels > samples_end-samples) { | |
1337 src += buf_size - 4; | |
1338 break; | |
1339 } | |
1340 | |
1341 for (channel=0; channel<avctx->channels; channel++) { | |
8734 | 1342 int32_t offset = (big_endian ? bytestream_get_be32(&src) |
1343 : bytestream_get_le32(&src)) | |
1344 + (avctx->channels-channel-1) * 4; | |
1345 | |
1346 if ((offset < 0) || (offset >= src_end - src - 4)) break; | |
1347 srcC = src + offset; | |
5851 | 1348 samplesC = samples + channel; |
1349 | |
1350 if (avctx->codec->id == CODEC_ID_ADPCM_EA_R1) { | |
1351 current_sample = (int16_t)bytestream_get_le16(&srcC); | |
1352 previous_sample = (int16_t)bytestream_get_le16(&srcC); | |
1353 } else { | |
1354 current_sample = c->status[channel].predictor; | |
1355 previous_sample = c->status[channel].prev_sample; | |
1356 } | |
1357 | |
1358 for (count1=0; count1<samples_in_chunk; count1++) { | |
1359 if (*srcC == 0xEE) { /* only seen in R2 and R3 */ | |
1360 srcC++; | |
8734 | 1361 if (srcC > src_end - 30*2) break; |
5851 | 1362 current_sample = (int16_t)bytestream_get_be16(&srcC); |
1363 previous_sample = (int16_t)bytestream_get_be16(&srcC); | |
1364 | |
1365 for (count2=0; count2<28; count2++) { | |
1366 *samplesC = (int16_t)bytestream_get_be16(&srcC); | |
1367 samplesC += avctx->channels; | |
1368 } | |
1369 } else { | |
6586 | 1370 coeff1 = ea_adpcm_table[ *srcC>>4 ]; |
1371 coeff2 = ea_adpcm_table[(*srcC>>4) + 4]; | |
5851 | 1372 shift = (*srcC++ & 0x0F) + 8; |
1373 | |
8734 | 1374 if (srcC > src_end - 14) break; |
5851 | 1375 for (count2=0; count2<28; count2++) { |
1376 if (count2 & 1) | |
6592 | 1377 next_sample = (int32_t)((*srcC++ & 0x0F) << 28) >> shift; |
5851 | 1378 else |
6592 | 1379 next_sample = (int32_t)((*srcC & 0xF0) << 24) >> shift; |
5851 | 1380 |
1381 next_sample += (current_sample * coeff1) + | |
1382 (previous_sample * coeff2); | |
1383 next_sample = av_clip_int16(next_sample >> 8); | |
1384 | |
1385 previous_sample = current_sample; | |
1386 current_sample = next_sample; | |
1387 *samplesC = current_sample; | |
1388 samplesC += avctx->channels; | |
1389 } | |
1390 } | |
1391 } | |
1392 | |
1393 if (avctx->codec->id != CODEC_ID_ADPCM_EA_R1) { | |
1394 c->status[channel].predictor = current_sample; | |
1395 c->status[channel].prev_sample = previous_sample; | |
1396 } | |
1397 } | |
1398 | |
1399 src = src + buf_size - (4 + 4*avctx->channels); | |
1400 samples += 28 * samples_in_chunk * avctx->channels; | |
1401 break; | |
1402 } | |
5870 | 1403 case CODEC_ID_ADPCM_EA_XAS: |
1404 if (samples_end-samples < 32*4*avctx->channels | |
1405 || buf_size < (4+15)*4*avctx->channels) { | |
1406 src += buf_size; | |
1407 break; | |
1408 } | |
1409 for (channel=0; channel<avctx->channels; channel++) { | |
1410 int coeff[2][4], shift[4]; | |
1411 short *s2, *s = &samples[channel]; | |
1412 for (n=0; n<4; n++, s+=32*avctx->channels) { | |
1413 for (i=0; i<2; i++) | |
1414 coeff[i][n] = ea_adpcm_table[(src[0]&0x0F)+4*i]; | |
1415 shift[n] = (src[2]&0x0F) + 8; | |
1416 for (s2=s, i=0; i<2; i++, src+=2, s2+=avctx->channels) | |
1417 s2[0] = (src[0]&0xF0) + (src[1]<<8); | |
1418 } | |
1419 | |
1420 for (m=2; m<32; m+=2) { | |
1421 s = &samples[m*avctx->channels + channel]; | |
1422 for (n=0; n<4; n++, src++, s+=32*avctx->channels) { | |
1423 for (s2=s, i=0; i<8; i+=4, s2+=avctx->channels) { | |
6592 | 1424 int level = (int32_t)((*src & (0xF0>>i)) << (24+i)) >> shift[n]; |
5870 | 1425 int pred = s2[-1*avctx->channels] * coeff[0][n] |
1426 + s2[-2*avctx->channels] * coeff[1][n]; | |
1427 s2[0] = av_clip_int16((level + pred + 0x80) >> 8); | |
1428 } | |
1429 } | |
1430 } | |
1431 } | |
1432 samples += 32*4*avctx->channels; | |
1433 break; | |
5726 | 1434 case CODEC_ID_ADPCM_IMA_AMV: |
1779 | 1435 case CODEC_ID_ADPCM_IMA_SMJPEG: |
5775
38f220befc32
Replace "signed short" typecast with "int16_t" as suggested by
voroshil
parents:
5766
diff
changeset
|
1436 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
|
1437 c->status[0].step_index = bytestream_get_le16(&src); |
5726 | 1438 |
1439 if (avctx->codec->id == CODEC_ID_ADPCM_IMA_AMV) | |
1440 src+=4; | |
1441 | |
1779 | 1442 while (src < buf + buf_size) { |
5726 | 1443 char hi, lo; |
1444 lo = *src & 0x0F; | |
6586 | 1445 hi = *src >> 4; |
5726 | 1446 |
1447 if (avctx->codec->id == CODEC_ID_ADPCM_IMA_AMV) | |
1448 FFSWAP(char, hi, lo); | |
1449 | |
1779 | 1450 *samples++ = adpcm_ima_expand_nibble(&c->status[0], |
5726 | 1451 lo, 3); |
1779 | 1452 *samples++ = adpcm_ima_expand_nibble(&c->status[0], |
5726 | 1453 hi, 3); |
1779 | 1454 src++; |
1455 } | |
1456 break; | |
2296
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
1457 case CODEC_ID_ADPCM_CT: |
2979 | 1458 while (src < buf + buf_size) { |
2296
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
1459 if (st) { |
2967 | 1460 *samples++ = adpcm_ct_expand_nibble(&c->status[0], |
6586 | 1461 src[0] >> 4); |
2967 | 1462 *samples++ = adpcm_ct_expand_nibble(&c->status[1], |
2296
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
1463 src[0] & 0x0F); |
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
1464 } else { |
2967 | 1465 *samples++ = adpcm_ct_expand_nibble(&c->status[0], |
6586 | 1466 src[0] >> 4); |
2967 | 1467 *samples++ = adpcm_ct_expand_nibble(&c->status[0], |
2296
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
1468 src[0] & 0x0F); |
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
1469 } |
2979 | 1470 src++; |
2296
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
1471 } |
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
1472 break; |
3127 | 1473 case CODEC_ID_ADPCM_SBPRO_4: |
1474 case CODEC_ID_ADPCM_SBPRO_3: | |
1475 case CODEC_ID_ADPCM_SBPRO_2: | |
1476 if (!c->status[0].step_index) { | |
1477 /* the first byte is a raw sample */ | |
1478 *samples++ = 128 * (*src++ - 0x80); | |
1479 if (st) | |
1480 *samples++ = 128 * (*src++ - 0x80); | |
1481 c->status[0].step_index = 1; | |
1482 } | |
1483 if (avctx->codec->id == CODEC_ID_ADPCM_SBPRO_4) { | |
1484 while (src < buf + buf_size) { | |
1485 *samples++ = adpcm_sbpro_expand_nibble(&c->status[0], | |
6586 | 1486 src[0] >> 4, 4, 0); |
3127 | 1487 *samples++ = adpcm_sbpro_expand_nibble(&c->status[st], |
1488 src[0] & 0x0F, 4, 0); | |
1489 src++; | |
1490 } | |
1491 } 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
|
1492 while (src < buf + buf_size && samples + 2 < samples_end) { |
3127 | 1493 *samples++ = adpcm_sbpro_expand_nibble(&c->status[0], |
6586 | 1494 src[0] >> 5 , 3, 0); |
3127 | 1495 *samples++ = adpcm_sbpro_expand_nibble(&c->status[0], |
1496 (src[0] >> 2) & 0x07, 3, 0); | |
1497 *samples++ = adpcm_sbpro_expand_nibble(&c->status[0], | |
1498 src[0] & 0x03, 2, 0); | |
1499 src++; | |
1500 } | |
1501 } else { | |
4461
c95e0df9841f
some (probably exploitable) out of array write fixes
michael
parents:
4364
diff
changeset
|
1502 while (src < buf + buf_size && samples + 3 < samples_end) { |
3127 | 1503 *samples++ = adpcm_sbpro_expand_nibble(&c->status[0], |
6586 | 1504 src[0] >> 6 , 2, 2); |
3127 | 1505 *samples++ = adpcm_sbpro_expand_nibble(&c->status[st], |
1506 (src[0] >> 4) & 0x03, 2, 2); | |
1507 *samples++ = adpcm_sbpro_expand_nibble(&c->status[0], | |
1508 (src[0] >> 2) & 0x03, 2, 2); | |
1509 *samples++ = adpcm_sbpro_expand_nibble(&c->status[st], | |
1510 src[0] & 0x03, 2, 2); | |
1511 src++; | |
1512 } | |
1513 } | |
1514 break; | |
2516
9f17dd9b80c6
macromedia flavour adpcm decoding (used in flv and swf)
alex
parents:
2296
diff
changeset
|
1515 case CODEC_ID_ADPCM_SWF: |
9f17dd9b80c6
macromedia flavour adpcm decoding (used in flv and swf)
alex
parents:
2296
diff
changeset
|
1516 { |
2979 | 1517 GetBitContext gb; |
1518 const int *table; | |
5494
c2512a13877e
fix decoding of adpcm swf big frames, fix RamboMJPEGAVP6_1Mbps.swf
bcoudurier
parents:
5371
diff
changeset
|
1519 int k0, signmask, nb_bits, count; |
2979 | 1520 int size = buf_size*8; |
2967 | 1521 |
2979 | 1522 init_get_bits(&gb, buf, size); |
2516
9f17dd9b80c6
macromedia flavour adpcm decoding (used in flv and swf)
alex
parents:
2296
diff
changeset
|
1523 |
5129 | 1524 //read bits & initial values |
4614 | 1525 nb_bits = get_bits(&gb, 2)+2; |
1526 //av_log(NULL,AV_LOG_INFO,"nb_bits: %d\n", nb_bits); | |
1527 table = swf_index_tables[nb_bits-2]; | |
1528 k0 = 1 << (nb_bits-2); | |
1529 signmask = 1 << (nb_bits-1); | |
1530 | |
5494
c2512a13877e
fix decoding of adpcm swf big frames, fix RamboMJPEGAVP6_1Mbps.swf
bcoudurier
parents:
5371
diff
changeset
|
1531 while (get_bits_count(&gb) <= size - 22*avctx->channels) { |
5500 | 1532 for (i = 0; i < avctx->channels; i++) { |
1533 *samples++ = c->status[i].predictor = get_sbits(&gb, 16); | |
1534 c->status[i].step_index = get_bits(&gb, 6); | |
1535 } | |
2967 | 1536 |
5500 | 1537 for (count = 0; get_bits_count(&gb) <= size - nb_bits*avctx->channels && count < 4095; count++) { |
1538 int i; | |
2516
9f17dd9b80c6
macromedia flavour adpcm decoding (used in flv and swf)
alex
parents:
2296
diff
changeset
|
1539 |
5500 | 1540 for (i = 0; i < avctx->channels; i++) { |
1541 // similar to IMA adpcm | |
1542 int delta = get_bits(&gb, nb_bits); | |
1543 int step = step_table[c->status[i].step_index]; | |
1544 long vpdiff = 0; // vpdiff = (delta+0.5)*step/4 | |
1545 int k = k0; | |
2967 | 1546 |
5500 | 1547 do { |
1548 if (delta & k) | |
1549 vpdiff += step; | |
1550 step >>= 1; | |
1551 k >>= 1; | |
1552 } while(k); | |
1553 vpdiff += step; | |
2967 | 1554 |
5500 | 1555 if (delta & signmask) |
1556 c->status[i].predictor -= vpdiff; | |
1557 else | |
1558 c->status[i].predictor += vpdiff; | |
2967 | 1559 |
5500 | 1560 c->status[i].step_index += table[delta & (~signmask)]; |
2967 | 1561 |
5500 | 1562 c->status[i].step_index = av_clip(c->status[i].step_index, 0, 88); |
5523 | 1563 c->status[i].predictor = av_clip_int16(c->status[i].predictor); |
2967 | 1564 |
5500 | 1565 *samples++ = c->status[i].predictor; |
1566 if (samples >= samples_end) { | |
1567 av_log(avctx, AV_LOG_ERROR, "allocated output buffer is too small\n"); | |
1568 return -1; | |
1569 } | |
4614 | 1570 } |
2979 | 1571 } |
1572 } | |
4614 | 1573 src += buf_size; |
2979 | 1574 break; |
2516
9f17dd9b80c6
macromedia flavour adpcm decoding (used in flv and swf)
alex
parents:
2296
diff
changeset
|
1575 } |
2794
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
1576 case CODEC_ID_ADPCM_YAMAHA: |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
1577 while (src < buf + buf_size) { |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
1578 if (st) { |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
1579 *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
|
1580 src[0] & 0x0F); |
2794
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
1581 *samples++ = adpcm_yamaha_expand_nibble(&c->status[1], |
6586 | 1582 src[0] >> 4 ); |
2794
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
1583 } else { |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
1584 *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
|
1585 src[0] & 0x0F); |
2794
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], |
6586 | 1587 src[0] >> 4 ); |
2794
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
1588 } |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
1589 src++; |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
1590 } |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
1591 break; |
4800 | 1592 case CODEC_ID_ADPCM_THP: |
4821 | 1593 { |
4804
39975b6c49bb
table[index][ch] -> table[ch][index] (might be faster ...)
michael
parents:
4800
diff
changeset
|
1594 int table[2][16]; |
4800 | 1595 unsigned int samplecnt; |
4807 | 1596 int prev[2][2]; |
4800 | 1597 int ch; |
1598 | |
1599 if (buf_size < 80) { | |
1600 av_log(avctx, AV_LOG_ERROR, "frame too small\n"); | |
1601 return -1; | |
1602 } | |
1603 | |
4810
0066256e99da
use bytestream reader instead of bitstream for THP
michael
parents:
4809
diff
changeset
|
1604 src+=4; |
0066256e99da
use bytestream reader instead of bitstream for THP
michael
parents:
4809
diff
changeset
|
1605 samplecnt = bytestream_get_be32(&src); |
4800 | 1606 |
4806 | 1607 for (i = 0; i < 32; i++) |
4810
0066256e99da
use bytestream reader instead of bitstream for THP
michael
parents:
4809
diff
changeset
|
1608 table[0][i] = (int16_t)bytestream_get_be16(&src); |
4800 | 1609 |
1610 /* Initialize the previous sample. */ | |
4808 | 1611 for (i = 0; i < 4; i++) |
4810
0066256e99da
use bytestream reader instead of bitstream for THP
michael
parents:
4809
diff
changeset
|
1612 prev[0][i] = (int16_t)bytestream_get_be16(&src); |
4800 | 1613 |
1614 if (samplecnt >= (samples_end - samples) / (st + 1)) { | |
1615 av_log(avctx, AV_LOG_ERROR, "allocated output buffer is too small\n"); | |
1616 return -1; | |
1617 } | |
1618 | |
1619 for (ch = 0; ch <= st; ch++) { | |
1620 samples = (unsigned short *) data + ch; | |
1621 | |
1622 /* Read in every sample for this channel. */ | |
1623 for (i = 0; i < samplecnt / 14; i++) { | |
4810
0066256e99da
use bytestream reader instead of bitstream for THP
michael
parents:
4809
diff
changeset
|
1624 int index = (*src >> 4) & 7; |
0066256e99da
use bytestream reader instead of bitstream for THP
michael
parents:
4809
diff
changeset
|
1625 unsigned int exp = 28 - (*src++ & 15); |
4804
39975b6c49bb
table[index][ch] -> table[ch][index] (might be faster ...)
michael
parents:
4800
diff
changeset
|
1626 int factor1 = table[ch][index * 2]; |
39975b6c49bb
table[index][ch] -> table[ch][index] (might be faster ...)
michael
parents:
4800
diff
changeset
|
1627 int factor2 = table[ch][index * 2 + 1]; |
4800 | 1628 |
1629 /* Decode 14 samples. */ | |
1630 for (n = 0; n < 14; n++) { | |
4810
0066256e99da
use bytestream reader instead of bitstream for THP
michael
parents:
4809
diff
changeset
|
1631 int32_t sampledat; |
0066256e99da
use bytestream reader instead of bitstream for THP
michael
parents:
4809
diff
changeset
|
1632 if(n&1) sampledat= *src++ <<28; |
0066256e99da
use bytestream reader instead of bitstream for THP
michael
parents:
4809
diff
changeset
|
1633 else sampledat= (*src&0xF0)<<24; |
4800 | 1634 |
4835
ae2f8c9bc25d
Fix an underflow/overflow that was causing some crackles when playing
diego
parents:
4821
diff
changeset
|
1635 sampledat = ((prev[ch][0]*factor1 |
4810
0066256e99da
use bytestream reader instead of bitstream for THP
michael
parents:
4809
diff
changeset
|
1636 + prev[ch][1]*factor2) >> 11) + (sampledat>>exp); |
5525
bc4791868c52
various simplifications around recent av_clip_int16() usage
aurel
parents:
5523
diff
changeset
|
1637 *samples = av_clip_int16(sampledat); |
4807 | 1638 prev[ch][1] = prev[ch][0]; |
1639 prev[ch][0] = *samples++; | |
4800 | 1640 |
1641 /* In case of stereo, skip one sample, this sample | |
1642 is for the other channel. */ | |
1643 samples += st; | |
1644 } | |
1645 } | |
1646 } | |
1647 | |
1648 /* In the previous loop, in case stereo is used, samples is | |
1649 increased exactly one time too often. */ | |
1650 samples -= st; | |
1651 break; | |
4821 | 1652 } |
4800 | 1653 |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1654 default: |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1655 return -1; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1656 } |
1064 | 1657 *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
|
1658 return src - buf; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1659 } |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1660 |
1530
3b31998fe22f
disable encoders where appropriate (patch courtesy of BERO
melanson
parents:
1491
diff
changeset
|
1661 |
3b31998fe22f
disable encoders where appropriate (patch courtesy of BERO
melanson
parents:
1491
diff
changeset
|
1662 |
8590 | 1663 #if CONFIG_ENCODERS |
6801
047a6a80dca4
ADPCM codec long names by Stefano Sabatini, stefano.sabatini-lala poste it
diego
parents:
6680
diff
changeset
|
1664 #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
|
1665 AVCodec name ## _encoder = { \ |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1666 #name, \ |
11560
8a4984c5cacc
Define AVMediaType enum, and use it instead of enum CodecType, which
stefano
parents:
11027
diff
changeset
|
1667 AVMEDIA_TYPE_AUDIO, \ |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1668 id, \ |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1669 sizeof(ADPCMContext), \ |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1670 adpcm_encode_init, \ |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1671 adpcm_encode_frame, \ |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1672 adpcm_encode_close, \ |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1673 NULL, \ |
10145
7955db355703
Make sample_fmts and channel_layouts compound literals const to reduce size of
reimar
parents:
9900
diff
changeset
|
1674 .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
|
1675 .long_name = NULL_IF_CONFIG_SMALL(long_name_), \ |
1530
3b31998fe22f
disable encoders where appropriate (patch courtesy of BERO
melanson
parents:
1491
diff
changeset
|
1676 }; |
3b31998fe22f
disable encoders where appropriate (patch courtesy of BERO
melanson
parents:
1491
diff
changeset
|
1677 #else |
6801
047a6a80dca4
ADPCM codec long names by Stefano Sabatini, stefano.sabatini-lala poste it
diego
parents:
6680
diff
changeset
|
1678 #define ADPCM_ENCODER(id,name,long_name_) |
1530
3b31998fe22f
disable encoders where appropriate (patch courtesy of BERO
melanson
parents:
1491
diff
changeset
|
1679 #endif |
3b31998fe22f
disable encoders where appropriate (patch courtesy of BERO
melanson
parents:
1491
diff
changeset
|
1680 |
8590 | 1681 #if CONFIG_DECODERS |
6801
047a6a80dca4
ADPCM codec long names by Stefano Sabatini, stefano.sabatini-lala poste it
diego
parents:
6680
diff
changeset
|
1682 #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
|
1683 AVCodec name ## _decoder = { \ |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1684 #name, \ |
11560
8a4984c5cacc
Define AVMediaType enum, and use it instead of enum CodecType, which
stefano
parents:
11027
diff
changeset
|
1685 AVMEDIA_TYPE_AUDIO, \ |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1686 id, \ |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1687 sizeof(ADPCMContext), \ |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1688 adpcm_decode_init, \ |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1689 NULL, \ |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1690 NULL, \ |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1691 adpcm_decode_frame, \ |
7040
e943e1409077
Make AVCodec long_names definition conditional depending on CONFIG_SMALL.
stefano
parents:
6920
diff
changeset
|
1692 .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
|
1693 }; |
1530
3b31998fe22f
disable encoders where appropriate (patch courtesy of BERO
melanson
parents:
1491
diff
changeset
|
1694 #else |
6801
047a6a80dca4
ADPCM codec long names by Stefano Sabatini, stefano.sabatini-lala poste it
diego
parents:
6680
diff
changeset
|
1695 #define ADPCM_DECODER(id,name,long_name_) |
1530
3b31998fe22f
disable encoders where appropriate (patch courtesy of BERO
melanson
parents:
1491
diff
changeset
|
1696 #endif |
3b31998fe22f
disable encoders where appropriate (patch courtesy of BERO
melanson
parents:
1491
diff
changeset
|
1697 |
6801
047a6a80dca4
ADPCM codec long names by Stefano Sabatini, stefano.sabatini-lala poste it
diego
parents:
6680
diff
changeset
|
1698 #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
|
1699 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
|
1700 |
7197
54f8d960f15b
Add a note to remind people that new PCM/ADPCM formats need to be added to
diego
parents:
7040
diff
changeset
|
1701 /* 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
|
1702 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
|
1703 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
|
1704 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
|
1705 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
|
1706 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
|
1707 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
|
1708 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
|
1709 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
|
1710 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
|
1711 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
|
1712 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
|
1713 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
|
1714 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
|
1715 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
|
1716 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
|
1717 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
|
1718 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
|
1719 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
|
1720 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
|
1721 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
|
1722 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
|
1723 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
|
1724 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
|
1725 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
|
1726 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
|
1727 ADPCM_CODEC (CODEC_ID_ADPCM_YAMAHA, adpcm_yamaha, "ADPCM Yamaha"); |