Mercurial > mplayer.hg
annotate libfaad2/bits.c @ 16805:50fb26acbcba
processing audio is sometimes essential for a/v sync, so 1000l to
whoever made rawvideo muxer disable audio!!
with this patch, audio is processed but simply thrown away by the
muxer. various 'error' conditions in rawvideo muxer are removed to
make it work. feel free to re-add them if they can be done without
breaking anything, but do not use printf !!!!
btw old behavior can be obtained by manually specifying -nosound.
author | rfelker |
---|---|
date | Wed, 19 Oct 2005 05:44:27 +0000 |
parents | 2ae5ab4331ca |
children | 59b6fa5b4201 |
rev | line source |
---|---|
10725 | 1 /* |
2 ** FAAD2 - Freeware Advanced Audio (AAC) Decoder including SBR decoding | |
12527 | 3 ** Copyright (C) 2003-2004 M. Bakker, Ahead Software AG, http://www.nero.com |
10725 | 4 ** |
5 ** This program is free software; you can redistribute it and/or modify | |
6 ** it under the terms of the GNU General Public License as published by | |
7 ** the Free Software Foundation; either version 2 of the License, or | |
8 ** (at your option) any later version. | |
9 ** | |
10 ** This program is distributed in the hope that it will be useful, | |
11 ** but WITHOUT ANY WARRANTY; without even the implied warranty of | |
12 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
13 ** GNU General Public License for more details. | |
14 ** | |
15 ** You should have received a copy of the GNU General Public License | |
16 ** along with this program; if not, write to the Free Software | |
17 ** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. | |
18 ** | |
19 ** Any non-GPL usage of this software or parts of this software is strictly | |
20 ** forbidden. | |
21 ** | |
22 ** Commercial non-GPL licensing of this software is possible. | |
23 ** For more info contact Ahead Software through Mpeg4AAClicense@nero.com. | |
24 ** | |
14727
2ae5ab4331ca
Remove modification notice from files that have not been locally modified.
diego
parents:
12625
diff
changeset
|
25 ** $Id: bits.c,v 1.37 2004/02/26 09:29:26 menno Exp $ |
10725 | 26 **/ |
27 | |
28 #include "common.h" | |
29 #include "structs.h" | |
30 | |
31 #include <stdlib.h> | |
32 #include <string.h> | |
33 #include "bits.h" | |
34 | |
35 /* initialize buffer, call once before first getbits or showbits */ | |
12527 | 36 void faad_initbits(bitfile *ld, const void *_buffer, const uint32_t buffer_size) |
10725 | 37 { |
38 uint32_t tmp; | |
39 | |
10989 | 40 if (ld == NULL) |
41 return; | |
42 | |
43 memset(ld, 0, sizeof(bitfile)); | |
44 | |
45 if (buffer_size == 0 || _buffer == NULL) | |
46 { | |
47 ld->error = 1; | |
48 ld->no_more_reading = 1; | |
49 return; | |
50 } | |
51 | |
12527 | 52 ld->buffer = faad_malloc((buffer_size+12)*sizeof(uint8_t)); |
10725 | 53 memset(ld->buffer, 0, (buffer_size+12)*sizeof(uint8_t)); |
54 memcpy(ld->buffer, _buffer, buffer_size*sizeof(uint8_t)); | |
55 | |
56 ld->buffer_size = buffer_size; | |
57 | |
58 tmp = getdword((uint32_t*)ld->buffer); | |
59 ld->bufa = tmp; | |
60 | |
61 tmp = getdword((uint32_t*)ld->buffer + 1); | |
62 ld->bufb = tmp; | |
63 | |
64 ld->start = (uint32_t*)ld->buffer; | |
65 ld->tail = ((uint32_t*)ld->buffer + 2); | |
66 | |
67 ld->bits_left = 32; | |
68 | |
69 ld->bytes_used = 0; | |
70 ld->no_more_reading = 0; | |
71 ld->error = 0; | |
72 } | |
73 | |
74 void faad_endbits(bitfile *ld) | |
75 { | |
76 if (ld) | |
12527 | 77 { |
78 if (ld->buffer) | |
79 { | |
80 faad_free(ld->buffer); | |
81 ld->buffer = NULL; | |
82 } | |
83 } | |
10725 | 84 } |
85 | |
86 uint32_t faad_get_processed_bits(bitfile *ld) | |
87 { | |
10989 | 88 return (uint32_t)(8 * (4*(ld->tail - ld->start) - 4) - (ld->bits_left)); |
10725 | 89 } |
90 | |
91 uint8_t faad_byte_align(bitfile *ld) | |
92 { | |
93 uint8_t remainder = (uint8_t)((32 - ld->bits_left) % 8); | |
94 | |
95 if (remainder) | |
96 { | |
97 faad_flushbits(ld, 8 - remainder); | |
98 return (8 - remainder); | |
99 } | |
100 return 0; | |
101 } | |
102 | |
10989 | 103 void faad_flushbits_ex(bitfile *ld, uint32_t bits) |
104 { | |
105 uint32_t tmp; | |
106 | |
107 ld->bufa = ld->bufb; | |
12527 | 108 if (ld->no_more_reading == 0) |
109 { | |
110 tmp = getdword(ld->tail); | |
111 ld->tail++; | |
112 } else { | |
113 tmp = 0; | |
114 } | |
10989 | 115 ld->bufb = tmp; |
116 ld->bits_left += (32 - bits); | |
117 ld->bytes_used += 4; | |
118 if (ld->bytes_used == ld->buffer_size) | |
119 ld->no_more_reading = 1; | |
120 if (ld->bytes_used > ld->buffer_size) | |
121 ld->error = 1; | |
122 } | |
123 | |
10725 | 124 /* rewind to beginning */ |
125 void faad_rewindbits(bitfile *ld) | |
126 { | |
127 uint32_t tmp; | |
128 | |
129 tmp = ld->start[0]; | |
130 #ifndef ARCH_IS_BIG_ENDIAN | |
131 BSWAP(tmp); | |
132 #endif | |
133 ld->bufa = tmp; | |
134 | |
135 tmp = ld->start[1]; | |
136 #ifndef ARCH_IS_BIG_ENDIAN | |
137 BSWAP(tmp); | |
138 #endif | |
139 ld->bufb = tmp; | |
140 ld->bits_left = 32; | |
141 ld->tail = &ld->start[2]; | |
142 ld->bytes_used = 0; | |
143 ld->no_more_reading = 0; | |
144 } | |
145 | |
146 uint8_t *faad_getbitbuffer(bitfile *ld, uint32_t bits | |
147 DEBUGDEC) | |
148 { | |
149 uint16_t i; | |
150 uint8_t temp; | |
151 uint16_t bytes = (uint16_t)bits / 8; | |
152 uint8_t remainder = (uint8_t)bits % 8; | |
153 | |
12527 | 154 uint8_t *buffer = (uint8_t*)faad_malloc((bytes+1)*sizeof(uint8_t)); |
10725 | 155 |
156 for (i = 0; i < bytes; i++) | |
157 { | |
158 buffer[i] = (uint8_t)faad_getbits(ld, 8 DEBUGVAR(print,var,dbg)); | |
159 } | |
160 | |
161 if (remainder) | |
162 { | |
163 temp = (uint8_t)faad_getbits(ld, remainder DEBUGVAR(print,var,dbg)) << (8-remainder); | |
164 | |
165 buffer[bytes] = temp; | |
166 } | |
167 | |
168 return buffer; | |
169 } | |
170 | |
12527 | 171 #ifdef DRM |
172 /* return the original data buffer */ | |
173 void *faad_origbitbuffer(bitfile *ld) | |
174 { | |
175 return (void*)ld->start; | |
176 } | |
177 | |
178 /* return the original data buffer size */ | |
179 uint32_t faad_origbitbuffer_size(bitfile *ld) | |
180 { | |
181 return ld->buffer_size; | |
182 } | |
183 #endif | |
184 | |
10725 | 185 /* reversed bit reading routines, used for RVLC and HCR */ |
186 void faad_initbits_rev(bitfile *ld, void *buffer, | |
187 uint32_t bits_in_buffer) | |
188 { | |
189 uint32_t tmp; | |
190 int32_t index; | |
191 | |
192 ld->buffer_size = bit2byte(bits_in_buffer); | |
193 | |
194 index = (bits_in_buffer+31)/32 - 1; | |
195 | |
196 ld->start = (uint32_t*)buffer + index - 2; | |
197 | |
198 tmp = getdword((uint32_t*)buffer + index); | |
199 ld->bufa = tmp; | |
200 | |
201 tmp = getdword((uint32_t*)buffer + index - 1); | |
202 ld->bufb = tmp; | |
203 | |
204 ld->tail = (uint32_t*)buffer + index; | |
205 | |
206 ld->bits_left = bits_in_buffer % 32; | |
207 if (ld->bits_left == 0) | |
208 ld->bits_left = 32; | |
209 | |
210 ld->bytes_used = 0; | |
211 ld->no_more_reading = 0; | |
212 ld->error = 0; | |
213 } |