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