Mercurial > libavcodec.hg
annotate adpcm.c @ 4166:eced83504436 libavcodec
mp3 header (de)compression bitstream filter
this will make mp3 frames 4 bytes smaller, it will not give you binary identical mp3 files, but it will give you mp3 files which decode to binary identical output
this will only work in containers providing at least packet size, sample_rate and number of channels
bugreports about mp3 files for which this fails are welcome
and this is experimental (dont expect compatibility and dont even expect to be able to decompress what you compressed, hell dont even expect this to work without editing the source a little)
author | michael |
---|---|
date | Fri, 10 Nov 2006 01:41:53 +0000 |
parents | c8c591fe26f8 |
children | 05e932ddaaa9 |
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" |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
23 |
1106 | 24 /** |
25 * @file adpcm.c | |
26 * ADPCM codecs. | |
1535 | 27 * 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
|
28 * 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
|
29 * by Mike Melanson (melanson@pcisys.net) |
1535 | 30 * CD-ROM XA ADPCM codec by BERO |
1779 | 31 * EA ADPCM decoder by Robin Kay (komadori@myrealbox.com) |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
32 * |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
33 * Features and limitations: |
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 * Reference documents: |
1443
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
36 * 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
|
37 * 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
|
38 * http://openquicktime.sourceforge.net/plugins.htm |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
39 * 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
|
40 * 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
|
41 * SoX source code http://home.sprynet.com/~cbagwell/sox.html |
1535 | 42 * |
43 * CD-ROM XA: | |
44 * http://ku-www.ss.titech.ac.jp/~yatsushi/xaadpcm.html | |
45 * vagpack & depack http://homepages.compuserve.de/bITmASTER32/psx-index.html | |
46 * 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
|
47 */ |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
48 |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
49 #define BLKSIZE 1024 |
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 CLAMP_TO_SHORT(value) \ |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
52 if (value > 32767) \ |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
53 value = 32767; \ |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
54 else if (value < -32768) \ |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
55 value = -32768; \ |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
56 |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
57 /* 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
|
58 /* This is the index table: */ |
1081
18157900b434
* fixed IMA WAV decoding (though still might not be fully correct)
kabi
parents:
1064
diff
changeset
|
59 static const int index_table[16] = { |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
60 -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
|
61 -1, -1, -1, -1, 2, 4, 6, 8, |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
62 }; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
63 |
2967 | 64 /** |
1106 | 65 * 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
|
66 * this table, but such deviations are negligible: |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
67 */ |
1081
18157900b434
* fixed IMA WAV decoding (though still might not be fully correct)
kabi
parents:
1064
diff
changeset
|
68 static const int step_table[89] = { |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
69 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
|
70 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
|
71 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
|
72 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
|
73 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
|
74 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
|
75 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
|
76 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
|
77 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
|
78 }; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
79 |
1535 | 80 /* These are for MS-ADPCM */ |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
81 /* 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
|
82 static const int AdaptationTable[] = { |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
83 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
|
84 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
|
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 AdaptCoeff1[] = { |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
88 256, 512, 0, 192, 240, 460, 392 |
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 |
1081
18157900b434
* fixed IMA WAV decoding (though still might not be fully correct)
kabi
parents:
1064
diff
changeset
|
91 static const int AdaptCoeff2[] = { |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
92 0, -256, 0, 64, 0, -208, -232 |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
93 }; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
94 |
1535 | 95 /* These are for CD-ROM XA ADPCM */ |
1559 | 96 static const int xa_adpcm_table[5][2] = { |
1535 | 97 { 0, 0 }, |
98 { 60, 0 }, | |
99 { 115, -52 }, | |
100 { 98, -55 }, | |
101 { 122, -60 } | |
102 }; | |
103 | |
2753 | 104 static const int ea_adpcm_table[] = { |
1779 | 105 0, 240, 460, 392, 0, 0, -208, -220, 0, 1, |
106 3, 4, 7, 8, 10, 11, 0, -1, -3, -4 | |
107 }; | |
108 | |
2753 | 109 static const int ct_adpcm_table[8] = { |
2296
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
110 0x00E6, 0x00E6, 0x00E6, 0x00E6, |
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
111 0x0133, 0x0199, 0x0200, 0x0266 |
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
112 }; |
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
113 |
2516
9f17dd9b80c6
macromedia flavour adpcm decoding (used in flv and swf)
alex
parents:
2296
diff
changeset
|
114 // padded to zero where table size is less then 16 |
2753 | 115 static const int swf_index_tables[4][16] = { |
2516
9f17dd9b80c6
macromedia flavour adpcm decoding (used in flv and swf)
alex
parents:
2296
diff
changeset
|
116 /*2*/ { -1, 2 }, |
9f17dd9b80c6
macromedia flavour adpcm decoding (used in flv and swf)
alex
parents:
2296
diff
changeset
|
117 /*3*/ { -1, -1, 2, 4 }, |
9f17dd9b80c6
macromedia flavour adpcm decoding (used in flv and swf)
alex
parents:
2296
diff
changeset
|
118 /*4*/ { -1, -1, -1, -1, 2, 4, 6, 8 }, |
9f17dd9b80c6
macromedia flavour adpcm decoding (used in flv and swf)
alex
parents:
2296
diff
changeset
|
119 /*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
|
120 }; |
9f17dd9b80c6
macromedia flavour adpcm decoding (used in flv and swf)
alex
parents:
2296
diff
changeset
|
121 |
2794
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
122 static const int yamaha_indexscale[] = { |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
123 230, 230, 230, 230, 307, 409, 512, 614, |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
124 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
|
125 }; |
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 static const int yamaha_difflookup[] = { |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
128 1, 3, 5, 7, 9, 11, 13, 15, |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
129 -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
|
130 }; |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
131 |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
132 /* end of tables */ |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
133 |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
134 typedef struct ADPCMChannelStatus { |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
135 int predictor; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
136 short int step_index; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
137 int step; |
577
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
138 /* for encoding */ |
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
139 int prev_sample; |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
140 |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
141 /* MS version */ |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
142 short sample1; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
143 short sample2; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
144 int coeff1; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
145 int coeff2; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
146 int idelta; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
147 } ADPCMChannelStatus; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
148 |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
149 typedef struct ADPCMContext { |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
150 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
|
151 ADPCMChannelStatus status[2]; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
152 short sample_buffer[32]; /* hold left samples while waiting for right samples */ |
2516
9f17dd9b80c6
macromedia flavour adpcm decoding (used in flv and swf)
alex
parents:
2296
diff
changeset
|
153 |
9f17dd9b80c6
macromedia flavour adpcm decoding (used in flv and swf)
alex
parents:
2296
diff
changeset
|
154 /* SWF only */ |
9f17dd9b80c6
macromedia flavour adpcm decoding (used in flv and swf)
alex
parents:
2296
diff
changeset
|
155 int nb_bits; |
9f17dd9b80c6
macromedia flavour adpcm decoding (used in flv and swf)
alex
parents:
2296
diff
changeset
|
156 int nb_samples; |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
157 } ADPCMContext; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
158 |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
159 /* XXX: implement encoding */ |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
160 |
1530
3b31998fe22f
disable encoders where appropriate (patch courtesy of BERO
melanson
parents:
1491
diff
changeset
|
161 #ifdef CONFIG_ENCODERS |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
162 static int adpcm_encode_init(AVCodecContext *avctx) |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
163 { |
577
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
164 if (avctx->channels > 2) |
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
165 return -1; /* only stereo or mono =) */ |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
166 switch(avctx->codec->id) { |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
167 case CODEC_ID_ADPCM_IMA_QT: |
1611 | 168 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
|
169 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
|
170 return -1; |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
171 break; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
172 case CODEC_ID_ADPCM_IMA_WAV: |
577
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
173 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
|
174 /* 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
|
175 avctx->block_align = BLKSIZE; |
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
176 /* 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
|
177 break; |
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
178 case CODEC_ID_ADPCM_MS: |
1794 | 179 avctx->frame_size = (BLKSIZE - 7 * avctx->channels) * 2 / avctx->channels + 2; /* each 16 bits sample gives one nibble */ |
180 /* and we have 7 bytes per channel overhead */ | |
181 avctx->block_align = BLKSIZE; | |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
182 break; |
2794
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
183 case CODEC_ID_ADPCM_YAMAHA: |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
184 avctx->frame_size = BLKSIZE * avctx->channels; |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
185 avctx->block_align = BLKSIZE; |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
186 break; |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
187 default: |
577
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
188 return -1; |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
189 break; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
190 } |
925 | 191 |
192 avctx->coded_frame= avcodec_alloc_frame(); | |
193 avctx->coded_frame->key_frame= 1; | |
194 | |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
195 return 0; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
196 } |
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 static int adpcm_encode_close(AVCodecContext *avctx) |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
199 { |
925 | 200 av_freep(&avctx->coded_frame); |
201 | |
577
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
202 return 0; |
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
203 } |
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 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
|
207 { |
3334 | 208 int delta = sample - c->prev_sample; |
209 int nibble = FFMIN(7, abs(delta)*4/step_table[c->step_index]) + (delta<0)*8; | |
210 c->prev_sample = c->prev_sample + ((step_table[c->step_index] * yamaha_difflookup[nibble]) / 8); | |
577
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
211 CLAMP_TO_SHORT(c->prev_sample); |
3334 | 212 c->step_index = 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
|
213 return nibble; |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
214 } |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
215 |
1794 | 216 static inline unsigned char adpcm_ms_compress_sample(ADPCMChannelStatus *c, short sample) |
217 { | |
218 int predictor, nibble, bias; | |
219 | |
220 predictor = (((c->sample1) * (c->coeff1)) + ((c->sample2) * (c->coeff2))) / 256; | |
2967 | 221 |
1794 | 222 nibble= sample - predictor; |
223 if(nibble>=0) bias= c->idelta/2; | |
224 else bias=-c->idelta/2; | |
2967 | 225 |
1794 | 226 nibble= (nibble + bias) / c->idelta; |
227 nibble= clip(nibble, -8, 7)&0x0F; | |
2967 | 228 |
1794 | 229 predictor += (signed)((nibble & 0x08)?(nibble - 0x10):(nibble)) * c->idelta; |
230 CLAMP_TO_SHORT(predictor); | |
231 | |
232 c->sample2 = c->sample1; | |
233 c->sample1 = predictor; | |
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 |
3334 | 254 c->predictor = c->predictor + ((c->step * yamaha_difflookup[nibble]) / 8); |
2794
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
255 CLAMP_TO_SHORT(c->predictor); |
3334 | 256 c->step = (c->step * yamaha_indexscale[nibble]) >> 8; |
2794
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
257 c->step = clip(c->step, 127, 24567); |
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; | |
300 if(version == CODEC_ID_ADPCM_IMA_WAV) | |
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; | |
327 const int nmin = clip(div-range, -8, 6); | |
328 const int nmax = clip(div+range, -7, 7); | |
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;\ | |
335 CLAMP_TO_SHORT(dec_sample);\ | |
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 } | |
371 } else if(version == CODEC_ID_ADPCM_IMA_WAV) { | |
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;\ | |
375 int nmin = clip(div-range, -7, 6);\ | |
376 int nmax = clip(div+range, -6, 7);\ | |
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 } | |
384 LOOP_NODES(ima, step_table[step], clip(step + index_table[nibble], 0, 88)); | |
385 } else { //CODEC_ID_ADPCM_YAMAHA | |
386 LOOP_NODES(yamaha, step, clip((step * yamaha_indexscale[nibble]) >> 8, 127, 24567)); | |
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 */ |
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
453 *dst++ = (c->status[0].prev_sample) & 0xFF; /* little endian */ |
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
454 *dst++ = (c->status[0].prev_sample >> 8) & 0xFF; |
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
455 *dst++ = (unsigned char)c->status[0].step_index; |
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
456 *dst++ = 0; /* unknown */ |
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
457 samples++; |
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
458 if (avctx->channels == 2) { |
1559 | 459 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
|
460 /* c->status[1].step_index = 0; */ |
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
461 *dst++ = (c->status[1].prev_sample) & 0xFF; |
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
462 *dst++ = (c->status[1].prev_sample >> 8) & 0xFF; |
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
463 *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
|
464 *dst++ = 0; |
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
465 samples++; |
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
466 } |
2967 | 467 |
577
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
468 /* stereo: 4 bytes (8 samples) for left, 4 bytes for right, 4 bytes left, ... */ |
3336 | 469 if(avctx->trellis > 0) { |
470 uint8_t buf[2][n*8]; | |
471 adpcm_compress_trellis(avctx, samples, buf[0], &c->status[0], n*8); | |
472 if(avctx->channels == 2) | |
473 adpcm_compress_trellis(avctx, samples+1, buf[1], &c->status[1], n*8); | |
474 for(i=0; i<n; i++) { | |
475 *dst++ = buf[0][8*i+0] | (buf[0][8*i+1] << 4); | |
476 *dst++ = buf[0][8*i+2] | (buf[0][8*i+3] << 4); | |
477 *dst++ = buf[0][8*i+4] | (buf[0][8*i+5] << 4); | |
478 *dst++ = buf[0][8*i+6] | (buf[0][8*i+7] << 4); | |
479 if (avctx->channels == 2) { | |
480 *dst++ = buf[1][8*i+0] | (buf[1][8*i+1] << 4); | |
481 *dst++ = buf[1][8*i+2] | (buf[1][8*i+3] << 4); | |
482 *dst++ = buf[1][8*i+4] | (buf[1][8*i+5] << 4); | |
483 *dst++ = buf[1][8*i+6] | (buf[1][8*i+7] << 4); | |
484 } | |
485 } | |
486 } else | |
577
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
487 for (; n>0; n--) { |
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
488 *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
|
489 *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
|
490 dst++; |
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
491 *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
|
492 *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
|
493 dst++; |
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
494 *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
|
495 *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
|
496 dst++; |
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
497 *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
|
498 *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
|
499 dst++; |
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
500 /* right channel */ |
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
501 if (avctx->channels == 2) { |
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
502 *dst = adpcm_ima_compress_sample(&c->status[1], samples[1]); |
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[3]) << 4; |
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
504 dst++; |
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
505 *dst = adpcm_ima_compress_sample(&c->status[1], samples[5]); |
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[7]) << 4; |
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
507 dst++; |
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
508 *dst = adpcm_ima_compress_sample(&c->status[1], samples[9]); |
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[11]) << 4; |
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
510 dst++; |
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
511 *dst = adpcm_ima_compress_sample(&c->status[1], samples[13]); |
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
512 *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
|
513 dst++; |
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 samples += 8 * avctx->channels; |
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
516 } |
babaca0899f1
adpcm encoding patch by Franois Revol <revol at free dot fr>
michaelni
parents:
573
diff
changeset
|
517 break; |
1794 | 518 case CODEC_ID_ADPCM_MS: |
519 for(i=0; i<avctx->channels; i++){ | |
520 int predictor=0; | |
521 | |
522 *dst++ = predictor; | |
523 c->status[i].coeff1 = AdaptCoeff1[predictor]; | |
524 c->status[i].coeff2 = AdaptCoeff2[predictor]; | |
525 } | |
526 for(i=0; i<avctx->channels; i++){ | |
2967 | 527 if (c->status[i].idelta < 16) |
1794 | 528 c->status[i].idelta = 16; |
2967 | 529 |
1794 | 530 *dst++ = c->status[i].idelta & 0xFF; |
531 *dst++ = c->status[i].idelta >> 8; | |
532 } | |
533 for(i=0; i<avctx->channels; i++){ | |
534 c->status[i].sample1= *samples++; | |
535 | |
536 *dst++ = c->status[i].sample1 & 0xFF; | |
537 *dst++ = c->status[i].sample1 >> 8; | |
538 } | |
539 for(i=0; i<avctx->channels; i++){ | |
540 c->status[i].sample2= *samples++; | |
541 | |
542 *dst++ = c->status[i].sample2 & 0xFF; | |
543 *dst++ = c->status[i].sample2 >> 8; | |
544 } | |
545 | |
3336 | 546 if(avctx->trellis > 0) { |
547 int n = avctx->block_align - 7*avctx->channels; | |
548 uint8_t buf[2][n]; | |
549 if(avctx->channels == 1) { | |
550 n *= 2; | |
551 adpcm_compress_trellis(avctx, samples, buf[0], &c->status[0], n); | |
552 for(i=0; i<n; i+=2) | |
553 *dst++ = (buf[0][i] << 4) | buf[0][i+1]; | |
554 } else { | |
555 adpcm_compress_trellis(avctx, samples, buf[0], &c->status[0], n); | |
556 adpcm_compress_trellis(avctx, samples+1, buf[1], &c->status[1], n); | |
557 for(i=0; i<n; i++) | |
558 *dst++ = (buf[0][i] << 4) | buf[1][i]; | |
559 } | |
560 } else | |
1794 | 561 for(i=7*avctx->channels; i<avctx->block_align; i++) { |
562 int nibble; | |
563 nibble = adpcm_ms_compress_sample(&c->status[ 0], *samples++)<<4; | |
564 nibble|= adpcm_ms_compress_sample(&c->status[st], *samples++); | |
565 *dst++ = nibble; | |
566 } | |
567 break; | |
2794
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
568 case CODEC_ID_ADPCM_YAMAHA: |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
569 n = avctx->frame_size / 2; |
3336 | 570 if(avctx->trellis > 0) { |
571 uint8_t buf[2][n*2]; | |
572 n *= 2; | |
573 if(avctx->channels == 1) { | |
574 adpcm_compress_trellis(avctx, samples, buf[0], &c->status[0], n); | |
575 for(i=0; i<n; i+=2) | |
576 *dst++ = buf[0][i] | (buf[0][i+1] << 4); | |
577 } else { | |
578 adpcm_compress_trellis(avctx, samples, buf[0], &c->status[0], n); | |
579 adpcm_compress_trellis(avctx, samples+1, buf[1], &c->status[1], n); | |
580 for(i=0; i<n; i++) | |
581 *dst++ = buf[0][i] | (buf[1][i] << 4); | |
582 } | |
583 } else | |
2794
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
584 for (; n>0; n--) { |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
585 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
|
586 int nibble; |
2795
de03cac6f7c2
yamaha adpcm nibbles in the wrong order fix by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2794
diff
changeset
|
587 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
|
588 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
|
589 *dst++ = nibble; |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
590 } |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
591 samples += 2 * avctx->channels; |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
592 } |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
593 break; |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
594 default: |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
595 return -1; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
596 } |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
597 return dst - frame; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
598 } |
1530
3b31998fe22f
disable encoders where appropriate (patch courtesy of BERO
melanson
parents:
1491
diff
changeset
|
599 #endif //CONFIG_ENCODERS |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
600 |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
601 static int adpcm_decode_init(AVCodecContext * avctx) |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
602 { |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
603 ADPCMContext *c = avctx->priv_data; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
604 |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
605 c->channel = 0; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
606 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
|
607 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
|
608 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
|
609 |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
610 switch(avctx->codec->id) { |
2296
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
611 case CODEC_ID_ADPCM_CT: |
2979 | 612 c->status[0].step = c->status[1].step = 511; |
613 break; | |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
614 default: |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
615 break; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
616 } |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
617 return 0; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
618 } |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
619 |
1737 | 620 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
|
621 { |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
622 int step_index; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
623 int predictor; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
624 int sign, delta, diff, step; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
625 |
1081
18157900b434
* fixed IMA WAV decoding (though still might not be fully correct)
kabi
parents:
1064
diff
changeset
|
626 step = step_table[c->step_index]; |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
627 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
|
628 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
|
629 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
|
630 |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
631 sign = nibble & 8; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
632 delta = nibble & 7; |
1443
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
633 /* 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
|
634 * 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
|
635 * quickly enough */ |
1737 | 636 diff = ((2 * delta + 1) * step) >> shift; |
1296 | 637 predictor = c->predictor; |
638 if (sign) predictor -= diff; | |
639 else predictor += diff; | |
640 | |
641 CLAMP_TO_SHORT(predictor); | |
642 c->predictor = predictor; | |
643 c->step_index = step_index; | |
644 | |
645 return (short)predictor; | |
646 } | |
647 | |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
648 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
|
649 { |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
650 int predictor; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
651 |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
652 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
|
653 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
|
654 CLAMP_TO_SHORT(predictor); |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
655 |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
656 c->sample2 = c->sample1; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
657 c->sample1 = predictor; |
1794 | 658 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
|
659 if (c->idelta < 16) c->idelta = 16; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
660 |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
661 return (short)predictor; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
662 } |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
663 |
2296
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
664 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
|
665 { |
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
666 int predictor; |
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
667 int sign, delta, diff; |
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
668 int new_step; |
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
669 |
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
670 sign = nibble & 8; |
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
671 delta = nibble & 7; |
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
672 /* 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
|
673 * 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
|
674 * quickly enough */ |
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
675 diff = ((2 * delta + 1) * c->step) >> 3; |
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
676 predictor = c->predictor; |
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
677 /* predictor update is not so trivial: predictor is multiplied on 254/256 before updating */ |
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
678 if(sign) |
2979 | 679 predictor = ((predictor * 254) >> 8) - diff; |
2296
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
680 else |
2979 | 681 predictor = ((predictor * 254) >> 8) + diff; |
2296
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
682 /* 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
|
683 new_step = (ct_adpcm_table[nibble & 7] * c->step) >> 8; |
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
684 c->step = new_step; |
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
685 if(c->step < 511) |
2979 | 686 c->step = 511; |
2296
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
687 if(c->step > 32767) |
2979 | 688 c->step = 32767; |
2296
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
689 |
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
690 CLAMP_TO_SHORT(predictor); |
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
691 c->predictor = predictor; |
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
692 return (short)predictor; |
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
693 } |
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
694 |
3127 | 695 static inline short adpcm_sbpro_expand_nibble(ADPCMChannelStatus *c, char nibble, int size, int shift) |
696 { | |
697 int sign, delta, diff; | |
698 | |
699 sign = nibble & (1<<(size-1)); | |
700 delta = nibble & ((1<<(size-1))-1); | |
701 diff = delta << (7 + c->step + shift); | |
702 | |
703 if (sign) | |
704 c->predictor -= diff; | |
705 else | |
706 c->predictor += diff; | |
707 | |
708 /* clamp result */ | |
709 if (c->predictor > 16256) | |
710 c->predictor = 16256; | |
711 else if (c->predictor < -16384) | |
712 c->predictor = -16384; | |
713 | |
714 /* calculate new step */ | |
715 if (delta >= (2*size - 3) && c->step < 3) | |
716 c->step++; | |
717 else if (delta == 0 && c->step > 0) | |
718 c->step--; | |
719 | |
720 return (short) c->predictor; | |
721 } | |
722 | |
2794
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
723 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
|
724 { |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
725 if(!c->step) { |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
726 c->predictor = 0; |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
727 c->step = 127; |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
728 } |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
729 |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
730 c->predictor += (c->step * yamaha_difflookup[nibble]) / 8; |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
731 CLAMP_TO_SHORT(c->predictor); |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
732 c->step = (c->step * yamaha_indexscale[nibble]) >> 8; |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
733 c->step = clip(c->step, 127, 24567); |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
734 return c->predictor; |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
735 } |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
736 |
2967 | 737 static void xa_decode(short *out, const unsigned char *in, |
1535 | 738 ADPCMChannelStatus *left, ADPCMChannelStatus *right, int inc) |
739 { | |
740 int i, j; | |
741 int shift,filter,f0,f1; | |
742 int s_1,s_2; | |
743 int d,s,t; | |
744 | |
745 for(i=0;i<4;i++) { | |
746 | |
747 shift = 12 - (in[4+i*2] & 15); | |
748 filter = in[4+i*2] >> 4; | |
749 f0 = xa_adpcm_table[filter][0]; | |
750 f1 = xa_adpcm_table[filter][1]; | |
751 | |
752 s_1 = left->sample1; | |
753 s_2 = left->sample2; | |
754 | |
755 for(j=0;j<28;j++) { | |
756 d = in[16+i+j*4]; | |
757 | |
758 t = (signed char)(d<<4)>>4; | |
759 s = ( t<<shift ) + ((s_1*f0 + s_2*f1+32)>>6); | |
760 CLAMP_TO_SHORT(s); | |
761 *out = s; | |
762 out += inc; | |
763 s_2 = s_1; | |
764 s_1 = s; | |
765 } | |
766 | |
767 if (inc==2) { /* stereo */ | |
768 left->sample1 = s_1; | |
769 left->sample2 = s_2; | |
770 s_1 = right->sample1; | |
771 s_2 = right->sample2; | |
772 out = out + 1 - 28*2; | |
773 } | |
774 | |
775 shift = 12 - (in[5+i*2] & 15); | |
776 filter = in[5+i*2] >> 4; | |
777 | |
778 f0 = xa_adpcm_table[filter][0]; | |
779 f1 = xa_adpcm_table[filter][1]; | |
780 | |
781 for(j=0;j<28;j++) { | |
782 d = in[16+i+j*4]; | |
783 | |
784 t = (signed char)d >> 4; | |
785 s = ( t<<shift ) + ((s_1*f0 + s_2*f1+32)>>6); | |
786 CLAMP_TO_SHORT(s); | |
787 *out = s; | |
788 out += inc; | |
789 s_2 = s_1; | |
790 s_1 = s; | |
791 } | |
792 | |
793 if (inc==2) { /* stereo */ | |
794 right->sample1 = s_1; | |
795 right->sample2 = s_2; | |
796 out -= 1; | |
797 } else { | |
798 left->sample1 = s_1; | |
799 left->sample2 = s_2; | |
800 } | |
801 } | |
802 } | |
803 | |
804 | |
1443
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
805 /* DK3 ADPCM support macro */ |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
806 #define DK3_GET_NEXT_NIBBLE() \ |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
807 if (decode_top_nibble_next) \ |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
808 { \ |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
809 nibble = (last_byte >> 4) & 0x0F; \ |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
810 decode_top_nibble_next = 0; \ |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
811 } \ |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
812 else \ |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
813 { \ |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
814 last_byte = *src++; \ |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
815 if (src >= buf + buf_size) break; \ |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
816 nibble = last_byte & 0x0F; \ |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
817 decode_top_nibble_next = 1; \ |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
818 } |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
819 |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
820 static int adpcm_decode_frame(AVCodecContext *avctx, |
2979 | 821 void *data, int *data_size, |
822 uint8_t *buf, int buf_size) | |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
823 { |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
824 ADPCMContext *c = avctx->priv_data; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
825 ADPCMChannelStatus *cs; |
1296 | 826 int n, m, channel, i; |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
827 int block_predictor[2]; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
828 short *samples; |
1064 | 829 uint8_t *src; |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
830 int st; /* stereo */ |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
831 |
1443
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
832 /* DK3 ADPCM accounting variables */ |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
833 unsigned char last_byte = 0; |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
834 unsigned char nibble; |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
835 int decode_top_nibble_next = 0; |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
836 int diff_channel; |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
837 |
1779 | 838 /* EA ADPCM state variables */ |
839 uint32_t samples_in_chunk; | |
840 int32_t previous_left_sample, previous_right_sample; | |
841 int32_t current_left_sample, current_right_sample; | |
842 int32_t next_left_sample, next_right_sample; | |
843 int32_t coeff1l, coeff2l, coeff1r, coeff2r; | |
844 uint8_t shift_left, shift_right; | |
845 int count1, count2; | |
846 | |
1768 | 847 if (!buf_size) |
848 return 0; | |
849 | |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
850 samples = data; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
851 src = buf; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
852 |
3127 | 853 st = avctx->channels == 2 ? 1 : 0; |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
854 |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
855 switch(avctx->codec->id) { |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
856 case CODEC_ID_ADPCM_IMA_QT: |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
857 n = (buf_size - 2);/* >> 2*avctx->channels;*/ |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
858 channel = c->channel; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
859 cs = &(c->status[channel]); |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
860 /* (pppppp) (piiiiiii) */ |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
861 |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
862 /* 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
|
863 cs->predictor = (*src++) << 8; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
864 cs->predictor |= (*src & 0x80); |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
865 cs->predictor &= 0xFF80; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
866 |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
867 /* sign extension */ |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
868 if(cs->predictor & 0x8000) |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
869 cs->predictor -= 0x10000; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
870 |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
871 CLAMP_TO_SHORT(cs->predictor); |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
872 |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
873 cs->step_index = (*src++) & 0x7F; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
874 |
3157 | 875 if (cs->step_index > 88){ |
876 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index = %i\n", cs->step_index); | |
877 cs->step_index = 88; | |
878 } | |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
879 |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
880 cs->step = step_table[cs->step_index]; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
881 |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
882 if (st && channel) |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
883 samples++; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
884 |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
885 for(m=32; n>0 && m>0; n--, m--) { /* in QuickTime, IMA is encoded by chuncks of 34 bytes (=64 samples) */ |
1737 | 886 *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
|
887 samples += avctx->channels; |
1737 | 888 *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
|
889 samples += avctx->channels; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
890 src ++; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
891 } |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
892 |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
893 if(st) { /* handle stereo interlacing */ |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
894 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
|
895 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
|
896 return src - buf; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
897 } |
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 break; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
900 case CODEC_ID_ADPCM_IMA_WAV: |
1576
bc4b13ca74de
block algn patch by ("Assaf Yaari" <assafy at mobixell dot com>)
michael
parents:
1559
diff
changeset
|
901 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
|
902 buf_size = avctx->block_align; |
bc4b13ca74de
block algn patch by ("Assaf Yaari" <assafy at mobixell dot com>)
michael
parents:
1559
diff
changeset
|
903 |
3157 | 904 // samples_per_block= (block_align-4*chanels)*8 / (bits_per_sample * chanels) + 1; |
905 | |
1737 | 906 for(i=0; i<avctx->channels; i++){ |
907 cs = &(c->status[i]); | |
3157 | 908 cs->predictor = (int16_t)(src[0] + (src[1]<<8)); |
909 src+=2; | |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
910 |
2979 | 911 // 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
|
912 |
1737 | 913 cs->step_index = *src++; |
3157 | 914 if (cs->step_index > 88){ |
915 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index = %i\n", cs->step_index); | |
916 cs->step_index = 88; | |
917 } | |
918 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
|
919 } |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
920 |
3157 | 921 while(src < buf + buf_size){ |
922 for(m=0; m<4; m++){ | |
923 for(i=0; i<=st; i++) | |
924 *samples++ = adpcm_ima_expand_nibble(&c->status[i], src[4*i] & 0x0F, 3); | |
925 for(i=0; i<=st; i++) | |
926 *samples++ = adpcm_ima_expand_nibble(&c->status[i], src[4*i] >> 4 , 3); | |
927 src++; | |
2979 | 928 } |
3157 | 929 src += 4*st; |
2979 | 930 } |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
931 break; |
1296 | 932 case CODEC_ID_ADPCM_4XM: |
933 cs = &(c->status[0]); | |
934 c->status[0].predictor= (int16_t)(src[0] + (src[1]<<8)); src+=2; | |
935 if(st){ | |
936 c->status[1].predictor= (int16_t)(src[0] + (src[1]<<8)); src+=2; | |
937 } | |
938 c->status[0].step_index= (int16_t)(src[0] + (src[1]<<8)); src+=2; | |
939 if(st){ | |
940 c->status[1].step_index= (int16_t)(src[0] + (src[1]<<8)); src+=2; | |
941 } | |
1695
2d11403fde4e
initial predictors are not sent to the output in QT IMA; fix stereo QT
melanson
parents:
1611
diff
changeset
|
942 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
|
943 if (cs->step_index > 88) cs->step_index = 88; |
1296 | 944 |
945 m= (buf_size - (src - buf))>>st; | |
946 for(i=0; i<m; i++) { | |
2979 | 947 *samples++ = adpcm_ima_expand_nibble(&c->status[0], src[i] & 0x0F, 4); |
1296 | 948 if (st) |
1737 | 949 *samples++ = adpcm_ima_expand_nibble(&c->status[1], src[i+m] & 0x0F, 4); |
950 *samples++ = adpcm_ima_expand_nibble(&c->status[0], src[i] >> 4, 4); | |
2979 | 951 if (st) |
1737 | 952 *samples++ = adpcm_ima_expand_nibble(&c->status[1], src[i+m] >> 4, 4); |
2979 | 953 } |
1296 | 954 |
955 src += m<<st; | |
956 | |
957 break; | |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
958 case CODEC_ID_ADPCM_MS: |
1576
bc4b13ca74de
block algn patch by ("Assaf Yaari" <assafy at mobixell dot com>)
michael
parents:
1559
diff
changeset
|
959 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
|
960 buf_size = avctx->block_align; |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
961 n = buf_size - 7 * avctx->channels; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
962 if (n < 0) |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
963 return -1; |
1794 | 964 block_predictor[0] = clip(*src++, 0, 7); |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
965 block_predictor[1] = 0; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
966 if (st) |
1794 | 967 block_predictor[1] = clip(*src++, 0, 7); |
968 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
|
969 src+=2; |
1794 | 970 if (st){ |
971 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
|
972 src+=2; |
1794 | 973 } |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
974 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
|
975 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
|
976 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
|
977 c->status[1].coeff2 = AdaptCoeff2[block_predictor[1]]; |
2967 | 978 |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
979 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
|
980 src+=2; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
981 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
|
982 if (st) src+=2; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
983 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
|
984 src+=2; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
985 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
|
986 if (st) src+=2; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
987 |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
988 *samples++ = c->status[0].sample1; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
989 if (st) *samples++ = c->status[1].sample1; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
990 *samples++ = c->status[0].sample2; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
991 if (st) *samples++ = c->status[1].sample2; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
992 for(;n>0;n--) { |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
993 *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
|
994 *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
|
995 src ++; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
996 } |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
997 break; |
1443
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
998 case CODEC_ID_ADPCM_IMA_DK4: |
1577 | 999 if (avctx->block_align != 0 && buf_size > avctx->block_align) |
1000 buf_size = avctx->block_align; | |
1001 | |
1794 | 1002 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
|
1003 c->status[0].step_index = src[2]; |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1004 src += 4; |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1005 *samples++ = c->status[0].predictor; |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1006 if (st) { |
1794 | 1007 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
|
1008 c->status[1].step_index = src[2]; |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1009 src += 4; |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1010 *samples++ = c->status[1].predictor; |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1011 } |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1012 while (src < buf + buf_size) { |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1013 |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1014 /* take care of the top nibble (always left or mono channel) */ |
2967 | 1015 *samples++ = adpcm_ima_expand_nibble(&c->status[0], |
1737 | 1016 (src[0] >> 4) & 0x0F, 3); |
1443
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1017 |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1018 /* 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
|
1019 * stereo, or another mono sample */ |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1020 if (st) |
2967 | 1021 *samples++ = adpcm_ima_expand_nibble(&c->status[1], |
1737 | 1022 src[0] & 0x0F, 3); |
1443
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1023 else |
2967 | 1024 *samples++ = adpcm_ima_expand_nibble(&c->status[0], |
1737 | 1025 src[0] & 0x0F, 3); |
1443
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1026 |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1027 src++; |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1028 } |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1029 break; |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1030 case CODEC_ID_ADPCM_IMA_DK3: |
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[10] | (src[11] << 8)); |
1035 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
|
1036 c->status[0].step_index = src[14]; |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1037 c->status[1].step_index = src[15]; |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1038 /* sign extend the predictors */ |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1039 src += 16; |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1040 diff_channel = c->status[1].predictor; |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1041 |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1042 /* 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
|
1043 * the buffer is consumed */ |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1044 while (1) { |
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 /* 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
|
1047 * c->status[1] is the diff channel */ |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1048 |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1049 /* 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
|
1050 DK3_GET_NEXT_NIBBLE(); |
1737 | 1051 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
|
1052 |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1053 /* process the diff channel predictor */ |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1054 DK3_GET_NEXT_NIBBLE(); |
1737 | 1055 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
|
1056 |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1057 /* 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
|
1058 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
|
1059 *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
|
1060 *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
|
1061 |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1062 /* 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
|
1063 DK3_GET_NEXT_NIBBLE(); |
1737 | 1064 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
|
1065 |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1066 /* 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
|
1067 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
|
1068 *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
|
1069 *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
|
1070 } |
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1071 break; |
1491
222643544cf1
New demuxers: Sega FILM/CPK, Westwood VQA & AUD; new decoders: MS RLE &
tmmm
parents:
1443
diff
changeset
|
1072 case CODEC_ID_ADPCM_IMA_WS: |
222643544cf1
New demuxers: Sega FILM/CPK, Westwood VQA & AUD; new decoders: MS RLE &
tmmm
parents:
1443
diff
changeset
|
1073 /* 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
|
1074 while (src < buf + buf_size) { |
222643544cf1
New demuxers: Sega FILM/CPK, Westwood VQA & AUD; new decoders: MS RLE &
tmmm
parents:
1443
diff
changeset
|
1075 |
222643544cf1
New demuxers: Sega FILM/CPK, Westwood VQA & AUD; new decoders: MS RLE &
tmmm
parents:
1443
diff
changeset
|
1076 if (st) { |
2967 | 1077 *samples++ = adpcm_ima_expand_nibble(&c->status[0], |
1737 | 1078 (src[0] >> 4) & 0x0F, 3); |
2967 | 1079 *samples++ = adpcm_ima_expand_nibble(&c->status[1], |
1737 | 1080 src[0] & 0x0F, 3); |
1491
222643544cf1
New demuxers: Sega FILM/CPK, Westwood VQA & AUD; new decoders: MS RLE &
tmmm
parents:
1443
diff
changeset
|
1081 } else { |
2967 | 1082 *samples++ = adpcm_ima_expand_nibble(&c->status[0], |
1737 | 1083 (src[0] >> 4) & 0x0F, 3); |
2967 | 1084 *samples++ = adpcm_ima_expand_nibble(&c->status[0], |
1737 | 1085 src[0] & 0x0F, 3); |
1491
222643544cf1
New demuxers: Sega FILM/CPK, Westwood VQA & AUD; new decoders: MS RLE &
tmmm
parents:
1443
diff
changeset
|
1086 } |
222643544cf1
New demuxers: Sega FILM/CPK, Westwood VQA & AUD; new decoders: MS RLE &
tmmm
parents:
1443
diff
changeset
|
1087 |
222643544cf1
New demuxers: Sega FILM/CPK, Westwood VQA & AUD; new decoders: MS RLE &
tmmm
parents:
1443
diff
changeset
|
1088 src++; |
222643544cf1
New demuxers: Sega FILM/CPK, Westwood VQA & AUD; new decoders: MS RLE &
tmmm
parents:
1443
diff
changeset
|
1089 } |
222643544cf1
New demuxers: Sega FILM/CPK, Westwood VQA & AUD; new decoders: MS RLE &
tmmm
parents:
1443
diff
changeset
|
1090 break; |
1535 | 1091 case CODEC_ID_ADPCM_XA: |
2967 | 1092 c->status[0].sample1 = c->status[0].sample2 = |
1535 | 1093 c->status[1].sample1 = c->status[1].sample2 = 0; |
1094 while (buf_size >= 128) { | |
2967 | 1095 xa_decode(samples, src, &c->status[0], &c->status[1], |
1535 | 1096 avctx->channels); |
1097 src += 128; | |
1098 samples += 28 * 8; | |
1099 buf_size -= 128; | |
1100 } | |
1101 break; | |
1779 | 1102 case CODEC_ID_ADPCM_EA: |
1103 samples_in_chunk = LE_32(src); | |
1104 if (samples_in_chunk >= ((buf_size - 12) * 2)) { | |
1105 src += buf_size; | |
1106 break; | |
1107 } | |
1108 src += 4; | |
1109 current_left_sample = (int16_t)LE_16(src); | |
1110 src += 2; | |
1111 previous_left_sample = (int16_t)LE_16(src); | |
1112 src += 2; | |
1113 current_right_sample = (int16_t)LE_16(src); | |
1114 src += 2; | |
1115 previous_right_sample = (int16_t)LE_16(src); | |
1116 src += 2; | |
1117 | |
1118 for (count1 = 0; count1 < samples_in_chunk/28;count1++) { | |
1119 coeff1l = ea_adpcm_table[(*src >> 4) & 0x0F]; | |
1120 coeff2l = ea_adpcm_table[((*src >> 4) & 0x0F) + 4]; | |
1121 coeff1r = ea_adpcm_table[*src & 0x0F]; | |
1122 coeff2r = ea_adpcm_table[(*src & 0x0F) + 4]; | |
1123 src++; | |
1124 | |
1125 shift_left = ((*src >> 4) & 0x0F) + 8; | |
1126 shift_right = (*src & 0x0F) + 8; | |
1127 src++; | |
1128 | |
1129 for (count2 = 0; count2 < 28; count2++) { | |
1130 next_left_sample = (((*src & 0xF0) << 24) >> shift_left); | |
1131 next_right_sample = (((*src & 0x0F) << 28) >> shift_right); | |
1132 src++; | |
1133 | |
2967 | 1134 next_left_sample = (next_left_sample + |
1135 (current_left_sample * coeff1l) + | |
1779 | 1136 (previous_left_sample * coeff2l) + 0x80) >> 8; |
2967 | 1137 next_right_sample = (next_right_sample + |
1138 (current_right_sample * coeff1r) + | |
1779 | 1139 (previous_right_sample * coeff2r) + 0x80) >> 8; |
1140 CLAMP_TO_SHORT(next_left_sample); | |
1141 CLAMP_TO_SHORT(next_right_sample); | |
1142 | |
1143 previous_left_sample = current_left_sample; | |
1144 current_left_sample = next_left_sample; | |
1145 previous_right_sample = current_right_sample; | |
1146 current_right_sample = next_right_sample; | |
1147 *samples++ = (unsigned short)current_left_sample; | |
1148 *samples++ = (unsigned short)current_right_sample; | |
1149 } | |
1150 } | |
1151 break; | |
1152 case CODEC_ID_ADPCM_IMA_SMJPEG: | |
1153 c->status[0].predictor = *src; | |
1154 src += 2; | |
1155 c->status[0].step_index = *src++; | |
1156 src++; /* skip another byte before getting to the meat */ | |
1157 while (src < buf + buf_size) { | |
1158 *samples++ = adpcm_ima_expand_nibble(&c->status[0], | |
1159 *src & 0x0F, 3); | |
1160 *samples++ = adpcm_ima_expand_nibble(&c->status[0], | |
1161 (*src >> 4) & 0x0F, 3); | |
1162 src++; | |
1163 } | |
1164 break; | |
2296
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
1165 case CODEC_ID_ADPCM_CT: |
2979 | 1166 while (src < buf + buf_size) { |
2296
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
1167 if (st) { |
2967 | 1168 *samples++ = adpcm_ct_expand_nibble(&c->status[0], |
2296
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
1169 (src[0] >> 4) & 0x0F); |
2967 | 1170 *samples++ = adpcm_ct_expand_nibble(&c->status[1], |
2296
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
1171 src[0] & 0x0F); |
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
1172 } else { |
2967 | 1173 *samples++ = adpcm_ct_expand_nibble(&c->status[0], |
2296
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
1174 (src[0] >> 4) & 0x0F); |
2967 | 1175 *samples++ = adpcm_ct_expand_nibble(&c->status[0], |
2296
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
1176 src[0] & 0x0F); |
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
1177 } |
2979 | 1178 src++; |
2296
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
1179 } |
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
1180 break; |
3127 | 1181 case CODEC_ID_ADPCM_SBPRO_4: |
1182 case CODEC_ID_ADPCM_SBPRO_3: | |
1183 case CODEC_ID_ADPCM_SBPRO_2: | |
1184 if (!c->status[0].step_index) { | |
1185 /* the first byte is a raw sample */ | |
1186 *samples++ = 128 * (*src++ - 0x80); | |
1187 if (st) | |
1188 *samples++ = 128 * (*src++ - 0x80); | |
1189 c->status[0].step_index = 1; | |
1190 } | |
1191 if (avctx->codec->id == CODEC_ID_ADPCM_SBPRO_4) { | |
1192 while (src < buf + buf_size) { | |
1193 *samples++ = adpcm_sbpro_expand_nibble(&c->status[0], | |
1194 (src[0] >> 4) & 0x0F, 4, 0); | |
1195 *samples++ = adpcm_sbpro_expand_nibble(&c->status[st], | |
1196 src[0] & 0x0F, 4, 0); | |
1197 src++; | |
1198 } | |
1199 } else if (avctx->codec->id == CODEC_ID_ADPCM_SBPRO_3) { | |
1200 while (src < buf + buf_size) { | |
1201 *samples++ = adpcm_sbpro_expand_nibble(&c->status[0], | |
1202 (src[0] >> 5) & 0x07, 3, 0); | |
1203 *samples++ = adpcm_sbpro_expand_nibble(&c->status[0], | |
1204 (src[0] >> 2) & 0x07, 3, 0); | |
1205 *samples++ = adpcm_sbpro_expand_nibble(&c->status[0], | |
1206 src[0] & 0x03, 2, 0); | |
1207 src++; | |
1208 } | |
1209 } else { | |
1210 while (src < buf + buf_size) { | |
1211 *samples++ = adpcm_sbpro_expand_nibble(&c->status[0], | |
1212 (src[0] >> 6) & 0x03, 2, 2); | |
1213 *samples++ = adpcm_sbpro_expand_nibble(&c->status[st], | |
1214 (src[0] >> 4) & 0x03, 2, 2); | |
1215 *samples++ = adpcm_sbpro_expand_nibble(&c->status[0], | |
1216 (src[0] >> 2) & 0x03, 2, 2); | |
1217 *samples++ = adpcm_sbpro_expand_nibble(&c->status[st], | |
1218 src[0] & 0x03, 2, 2); | |
1219 src++; | |
1220 } | |
1221 } | |
1222 break; | |
2516
9f17dd9b80c6
macromedia flavour adpcm decoding (used in flv and swf)
alex
parents:
2296
diff
changeset
|
1223 case CODEC_ID_ADPCM_SWF: |
9f17dd9b80c6
macromedia flavour adpcm decoding (used in flv and swf)
alex
parents:
2296
diff
changeset
|
1224 { |
2979 | 1225 GetBitContext gb; |
1226 const int *table; | |
1227 int k0, signmask; | |
1228 int size = buf_size*8; | |
2967 | 1229 |
2979 | 1230 init_get_bits(&gb, buf, size); |
2516
9f17dd9b80c6
macromedia flavour adpcm decoding (used in flv and swf)
alex
parents:
2296
diff
changeset
|
1231 |
2979 | 1232 // first frame, read bits & inital values |
1233 if (!c->nb_bits) | |
1234 { | |
1235 c->nb_bits = get_bits(&gb, 2)+2; | |
1236 // av_log(NULL,AV_LOG_INFO,"nb_bits: %d\n", c->nb_bits); | |
1237 } | |
2967 | 1238 |
2979 | 1239 table = swf_index_tables[c->nb_bits-2]; |
1240 k0 = 1 << (c->nb_bits-2); | |
1241 signmask = 1 << (c->nb_bits-1); | |
2967 | 1242 |
2979 | 1243 while (get_bits_count(&gb) <= size) |
1244 { | |
1245 int i; | |
2516
9f17dd9b80c6
macromedia flavour adpcm decoding (used in flv and swf)
alex
parents:
2296
diff
changeset
|
1246 |
2979 | 1247 c->nb_samples++; |
1248 // wrap around at every 4096 samples... | |
1249 if ((c->nb_samples & 0xfff) == 1) | |
1250 { | |
1251 for (i = 0; i <= st; i++) | |
1252 { | |
1253 *samples++ = c->status[i].predictor = get_sbits(&gb, 16); | |
1254 c->status[i].step_index = get_bits(&gb, 6); | |
1255 } | |
1256 } | |
2516
9f17dd9b80c6
macromedia flavour adpcm decoding (used in flv and swf)
alex
parents:
2296
diff
changeset
|
1257 |
2979 | 1258 // similar to IMA adpcm |
1259 for (i = 0; i <= st; i++) | |
1260 { | |
1261 int delta = get_bits(&gb, c->nb_bits); | |
1262 int step = step_table[c->status[i].step_index]; | |
1263 long vpdiff = 0; // vpdiff = (delta+0.5)*step/4 | |
1264 int k = k0; | |
2967 | 1265 |
2979 | 1266 do { |
1267 if (delta & k) | |
1268 vpdiff += step; | |
1269 step >>= 1; | |
1270 k >>= 1; | |
1271 } while(k); | |
1272 vpdiff += step; | |
2967 | 1273 |
2979 | 1274 if (delta & signmask) |
1275 c->status[i].predictor -= vpdiff; | |
1276 else | |
1277 c->status[i].predictor += vpdiff; | |
2967 | 1278 |
2979 | 1279 c->status[i].step_index += table[delta & (~signmask)]; |
2967 | 1280 |
2979 | 1281 c->status[i].step_index = clip(c->status[i].step_index, 0, 88); |
1282 c->status[i].predictor = clip(c->status[i].predictor, -32768, 32767); | |
2967 | 1283 |
2979 | 1284 *samples++ = c->status[i].predictor; |
1285 } | |
1286 } | |
2967 | 1287 |
2979 | 1288 // src += get_bits_count(&gb)*8; |
1289 src += size; | |
2967 | 1290 |
2979 | 1291 break; |
2516
9f17dd9b80c6
macromedia flavour adpcm decoding (used in flv and swf)
alex
parents:
2296
diff
changeset
|
1292 } |
2794
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
1293 case CODEC_ID_ADPCM_YAMAHA: |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
1294 while (src < buf + buf_size) { |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
1295 if (st) { |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
1296 *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
|
1297 src[0] & 0x0F); |
2794
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
1298 *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
|
1299 (src[0] >> 4) & 0x0F); |
2794
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
1300 } else { |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
1301 *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
|
1302 src[0] & 0x0F); |
2794
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
1303 *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
|
1304 (src[0] >> 4) & 0x0F); |
2794
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
1305 } |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
1306 src++; |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
1307 } |
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
1308 break; |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1309 default: |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1310 return -1; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1311 } |
1064 | 1312 *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
|
1313 return src - buf; |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1314 } |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1315 |
1530
3b31998fe22f
disable encoders where appropriate (patch courtesy of BERO
melanson
parents:
1491
diff
changeset
|
1316 |
3b31998fe22f
disable encoders where appropriate (patch courtesy of BERO
melanson
parents:
1491
diff
changeset
|
1317 |
3b31998fe22f
disable encoders where appropriate (patch courtesy of BERO
melanson
parents:
1491
diff
changeset
|
1318 #ifdef CONFIG_ENCODERS |
3b31998fe22f
disable encoders where appropriate (patch courtesy of BERO
melanson
parents:
1491
diff
changeset
|
1319 #define ADPCM_ENCODER(id,name) \ |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1320 AVCodec name ## _encoder = { \ |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1321 #name, \ |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1322 CODEC_TYPE_AUDIO, \ |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1323 id, \ |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1324 sizeof(ADPCMContext), \ |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1325 adpcm_encode_init, \ |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1326 adpcm_encode_frame, \ |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1327 adpcm_encode_close, \ |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1328 NULL, \ |
1530
3b31998fe22f
disable encoders where appropriate (patch courtesy of BERO
melanson
parents:
1491
diff
changeset
|
1329 }; |
3b31998fe22f
disable encoders where appropriate (patch courtesy of BERO
melanson
parents:
1491
diff
changeset
|
1330 #else |
3b31998fe22f
disable encoders where appropriate (patch courtesy of BERO
melanson
parents:
1491
diff
changeset
|
1331 #define ADPCM_ENCODER(id,name) |
3b31998fe22f
disable encoders where appropriate (patch courtesy of BERO
melanson
parents:
1491
diff
changeset
|
1332 #endif |
3b31998fe22f
disable encoders where appropriate (patch courtesy of BERO
melanson
parents:
1491
diff
changeset
|
1333 |
3b31998fe22f
disable encoders where appropriate (patch courtesy of BERO
melanson
parents:
1491
diff
changeset
|
1334 #ifdef CONFIG_DECODERS |
3b31998fe22f
disable encoders where appropriate (patch courtesy of BERO
melanson
parents:
1491
diff
changeset
|
1335 #define ADPCM_DECODER(id,name) \ |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1336 AVCodec name ## _decoder = { \ |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1337 #name, \ |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1338 CODEC_TYPE_AUDIO, \ |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1339 id, \ |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1340 sizeof(ADPCMContext), \ |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1341 adpcm_decode_init, \ |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1342 NULL, \ |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1343 NULL, \ |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1344 adpcm_decode_frame, \ |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1345 }; |
1530
3b31998fe22f
disable encoders where appropriate (patch courtesy of BERO
melanson
parents:
1491
diff
changeset
|
1346 #else |
3b31998fe22f
disable encoders where appropriate (patch courtesy of BERO
melanson
parents:
1491
diff
changeset
|
1347 #define ADPCM_DECODER(id,name) |
3b31998fe22f
disable encoders where appropriate (patch courtesy of BERO
melanson
parents:
1491
diff
changeset
|
1348 #endif |
3b31998fe22f
disable encoders where appropriate (patch courtesy of BERO
melanson
parents:
1491
diff
changeset
|
1349 |
3b31998fe22f
disable encoders where appropriate (patch courtesy of BERO
melanson
parents:
1491
diff
changeset
|
1350 #define ADPCM_CODEC(id, name) \ |
3b31998fe22f
disable encoders where appropriate (patch courtesy of BERO
melanson
parents:
1491
diff
changeset
|
1351 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
|
1352 |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1353 ADPCM_CODEC(CODEC_ID_ADPCM_IMA_QT, adpcm_ima_qt); |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1354 ADPCM_CODEC(CODEC_ID_ADPCM_IMA_WAV, adpcm_ima_wav); |
1443
47f4c8a5a7fc
New fringe codecs: WC3/Xan video, Xan DPCM, DK3 & DK4 ADPCM
tmmm
parents:
1296
diff
changeset
|
1355 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
|
1356 ADPCM_CODEC(CODEC_ID_ADPCM_IMA_DK4, adpcm_ima_dk4); |
1491
222643544cf1
New demuxers: Sega FILM/CPK, Westwood VQA & AUD; new decoders: MS RLE &
tmmm
parents:
1443
diff
changeset
|
1357 ADPCM_CODEC(CODEC_ID_ADPCM_IMA_WS, adpcm_ima_ws); |
1779 | 1358 ADPCM_CODEC(CODEC_ID_ADPCM_IMA_SMJPEG, adpcm_ima_smjpeg); |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1359 ADPCM_CODEC(CODEC_ID_ADPCM_MS, adpcm_ms); |
1296 | 1360 ADPCM_CODEC(CODEC_ID_ADPCM_4XM, adpcm_4xm); |
1535 | 1361 ADPCM_CODEC(CODEC_ID_ADPCM_XA, adpcm_xa); |
1779 | 1362 ADPCM_CODEC(CODEC_ID_ADPCM_EA, adpcm_ea); |
2296
2b75dff01118
Creative ADPCM decoder, format 0x200, courtesy of Konstantin Shishkov
melanson
parents:
2028
diff
changeset
|
1363 ADPCM_CODEC(CODEC_ID_ADPCM_CT, adpcm_ct); |
2516
9f17dd9b80c6
macromedia flavour adpcm decoding (used in flv and swf)
alex
parents:
2296
diff
changeset
|
1364 ADPCM_CODEC(CODEC_ID_ADPCM_SWF, adpcm_swf); |
2794
ed1ab1566353
Add Yamaha ADPCM encoding/decoding patch by (Vidar Madsen: vidarino, gmail com)
michael
parents:
2753
diff
changeset
|
1365 ADPCM_CODEC(CODEC_ID_ADPCM_YAMAHA, adpcm_yamaha); |
3127 | 1366 ADPCM_CODEC(CODEC_ID_ADPCM_SBPRO_4, adpcm_sbpro_4); |
1367 ADPCM_CODEC(CODEC_ID_ADPCM_SBPRO_3, adpcm_sbpro_3); | |
1368 ADPCM_CODEC(CODEC_ID_ADPCM_SBPRO_2, adpcm_sbpro_2); | |
573
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1369 |
b0f52172f4c5
beos/mov/adpcm patch by Franois Revol <revol at free dot fr>
michaelni
parents:
diff
changeset
|
1370 #undef ADPCM_CODEC |