diff options
author | Michael Sevakis <jethead71@rockbox.org> | 2007-12-07 13:00:31 +0000 |
---|---|---|
committer | Michael Sevakis <jethead71@rockbox.org> | 2007-12-07 13:00:31 +0000 |
commit | 2b5f979d75a3d1c85b498c87ba6ae4c98c3011bc (patch) | |
tree | d9c40aa330a2bd973794eca11c86d559549422ca /apps/plugins/mpegplayer/decode.c | |
parent | 5886efabf5e4c96a8a96836d665aad935c727e31 (diff) | |
download | rockbox-2b5f979d75a3d1c85b498c87ba6ae4c98c3011bc.tar.gz rockbox-2b5f979d75a3d1c85b498c87ba6ae4c98c3011bc.zip |
Reformat and code police (tabs, trailing whitespace, annoying overuse of parentheses, etc.) in libmpeg2 so I can stomach working on it. Don't call IDCT functions through pointers - I don't feel like extracting that change just for relevance sake.
git-svn-id: svn://svn.rockbox.org/rockbox/trunk@15892 a1c6a512-1295-4272-9138-f99709370657
Diffstat (limited to 'apps/plugins/mpegplayer/decode.c')
-rw-r--r-- | apps/plugins/mpegplayer/decode.c | 490 |
1 files changed, 287 insertions, 203 deletions
diff --git a/apps/plugins/mpegplayer/decode.c b/apps/plugins/mpegplayer/decode.c index ca3d29a952..fac724c48c 100644 --- a/apps/plugins/mpegplayer/decode.c +++ b/apps/plugins/mpegplayer/decode.c | |||
@@ -33,9 +33,15 @@ extern struct plugin_api* rb; | |||
33 | 33 | ||
34 | #define BUFFER_SIZE (1194 * 1024) | 34 | #define BUFFER_SIZE (1194 * 1024) |
35 | 35 | ||
36 | #ifdef CPU_COLDFIRE | ||
37 | /* twice as large as on other targets because coldfire uses | ||
38 | * a secondary, transposed buffer for optimisation */ | ||
39 | static int16_t static_dct_block[128] IBSS_ATTR ATTR_ALIGN(16); | ||
40 | #endif | ||
41 | |||
36 | const mpeg2_info_t * mpeg2_info (mpeg2dec_t * mpeg2dec) | 42 | const mpeg2_info_t * mpeg2_info (mpeg2dec_t * mpeg2dec) |
37 | { | 43 | { |
38 | return &(mpeg2dec->info); | 44 | return &mpeg2dec->info; |
39 | } | 45 | } |
40 | 46 | ||
41 | static inline int skip_chunk (mpeg2dec_t * mpeg2dec, int bytes) | 47 | static inline int skip_chunk (mpeg2dec_t * mpeg2dec, int bytes) |
@@ -46,27 +52,34 @@ static inline int skip_chunk (mpeg2dec_t * mpeg2dec, int bytes) | |||
46 | uint8_t byte; | 52 | uint8_t byte; |
47 | 53 | ||
48 | if (!bytes) | 54 | if (!bytes) |
49 | return 0; | 55 | return 0; |
50 | 56 | ||
51 | current = mpeg2dec->buf_start; | 57 | current = mpeg2dec->buf_start; |
52 | shift = mpeg2dec->shift; | 58 | shift = mpeg2dec->shift; |
53 | limit = current + bytes; | 59 | limit = current + bytes; |
54 | 60 | ||
55 | do { | 61 | do |
56 | byte = *current++; | 62 | { |
57 | if (shift == 0x00000100) { | 63 | byte = *current++; |
58 | int skipped; | 64 | |
65 | if (shift == 0x00000100) | ||
66 | { | ||
67 | int skipped; | ||
59 | 68 | ||
60 | mpeg2dec->shift = 0xffffff00; | 69 | mpeg2dec->shift = 0xffffff00; |
61 | skipped = current - mpeg2dec->buf_start; | 70 | skipped = current - mpeg2dec->buf_start; |
62 | mpeg2dec->buf_start = current; | 71 | mpeg2dec->buf_start = current; |
63 | return skipped; | 72 | |
64 | } | 73 | return skipped; |
65 | shift = (shift | byte) << 8; | 74 | } |
66 | } while (current < limit); | 75 | |
76 | shift = (shift | byte) << 8; | ||
77 | } | ||
78 | while (current < limit); | ||
67 | 79 | ||
68 | mpeg2dec->shift = shift; | 80 | mpeg2dec->shift = shift; |
69 | mpeg2dec->buf_start = current; | 81 | mpeg2dec->buf_start = current; |
82 | |||
70 | return 0; | 83 | return 0; |
71 | } | 84 | } |
72 | 85 | ||
@@ -79,27 +92,32 @@ static inline int copy_chunk (mpeg2dec_t * mpeg2dec, int bytes) | |||
79 | uint8_t byte; | 92 | uint8_t byte; |
80 | 93 | ||
81 | if (!bytes) | 94 | if (!bytes) |
82 | return 0; | 95 | return 0; |
83 | 96 | ||
84 | current = mpeg2dec->buf_start; | 97 | current = mpeg2dec->buf_start; |
85 | shift = mpeg2dec->shift; | 98 | shift = mpeg2dec->shift; |
86 | chunk_ptr = mpeg2dec->chunk_ptr; | 99 | chunk_ptr = mpeg2dec->chunk_ptr; |
87 | limit = current + bytes; | 100 | limit = current + bytes; |
88 | 101 | ||
89 | do { | 102 | do |
90 | byte = *current++; | 103 | { |
91 | if (shift == 0x00000100) { | 104 | byte = *current++; |
92 | int copied; | 105 | |
93 | 106 | if (shift == 0x00000100) | |
94 | mpeg2dec->shift = 0xffffff00; | 107 | { |
95 | mpeg2dec->chunk_ptr = chunk_ptr + 1; | 108 | int copied; |
96 | copied = current - mpeg2dec->buf_start; | 109 | |
97 | mpeg2dec->buf_start = current; | 110 | mpeg2dec->shift = 0xffffff00; |
98 | return copied; | 111 | mpeg2dec->chunk_ptr = chunk_ptr + 1; |
99 | } | 112 | copied = current - mpeg2dec->buf_start; |
100 | shift = (shift | byte) << 8; | 113 | mpeg2dec->buf_start = current; |
101 | *chunk_ptr++ = byte; | 114 | return copied; |
102 | } while (current < limit); | 115 | } |
116 | |||
117 | shift = (shift | byte) << 8; | ||
118 | *chunk_ptr++ = byte; | ||
119 | } | ||
120 | while (current < limit); | ||
103 | 121 | ||
104 | mpeg2dec->shift = shift; | 122 | mpeg2dec->shift = shift; |
105 | mpeg2dec->buf_start = current; | 123 | mpeg2dec->buf_start = current; |
@@ -123,26 +141,39 @@ static inline mpeg2_state_t seek_chunk (mpeg2dec_t * mpeg2dec) | |||
123 | 141 | ||
124 | size = mpeg2dec->buf_end - mpeg2dec->buf_start; | 142 | size = mpeg2dec->buf_end - mpeg2dec->buf_start; |
125 | skipped = skip_chunk (mpeg2dec, size); | 143 | skipped = skip_chunk (mpeg2dec, size); |
126 | if (!skipped) { | 144 | |
127 | mpeg2dec->bytes_since_tag += size; | 145 | if (!skipped) |
128 | return STATE_BUFFER; | 146 | { |
147 | mpeg2dec->bytes_since_tag += size; | ||
148 | return STATE_BUFFER; | ||
129 | } | 149 | } |
150 | |||
130 | mpeg2dec->bytes_since_tag += skipped; | 151 | mpeg2dec->bytes_since_tag += skipped; |
131 | mpeg2dec->code = mpeg2dec->buf_start[-1]; | 152 | mpeg2dec->code = mpeg2dec->buf_start[-1]; |
153 | |||
132 | return (mpeg2_state_t)-1; | 154 | return (mpeg2_state_t)-1; |
133 | } | 155 | } |
134 | 156 | ||
135 | mpeg2_state_t mpeg2_seek_header (mpeg2dec_t * mpeg2dec) | 157 | mpeg2_state_t mpeg2_seek_header (mpeg2dec_t * mpeg2dec) |
136 | { | 158 | { |
137 | while (mpeg2dec->code != 0xb3 && | 159 | while (mpeg2dec->code != 0xb3 && |
138 | ((mpeg2dec->code != 0xb7 && mpeg2dec->code != 0xb8 && | 160 | ((mpeg2dec->code != 0xb7 && |
139 | mpeg2dec->code) || mpeg2dec->sequence.width == (unsigned)-1)) | 161 | mpeg2dec->code != 0xb8 && |
140 | if (seek_chunk (mpeg2dec) == STATE_BUFFER) | 162 | mpeg2dec->code) || |
141 | return STATE_BUFFER; | 163 | mpeg2dec->sequence.width == (unsigned)-1)) |
142 | mpeg2dec->chunk_start = mpeg2dec->chunk_ptr = mpeg2dec->chunk_buffer; | 164 | { |
165 | if (seek_chunk (mpeg2dec) == STATE_BUFFER) | ||
166 | return STATE_BUFFER; | ||
167 | } | ||
168 | |||
169 | mpeg2dec->chunk_start = | ||
170 | mpeg2dec->chunk_ptr = mpeg2dec->chunk_buffer; | ||
171 | |||
143 | mpeg2dec->user_data_len = 0; | 172 | mpeg2dec->user_data_len = 0; |
144 | return (mpeg2dec->code ? mpeg2_parse_header (mpeg2dec) : | 173 | |
145 | mpeg2_header_picture_start (mpeg2dec)); | 174 | return mpeg2dec->code ? |
175 | mpeg2_parse_header(mpeg2dec) : | ||
176 | mpeg2_header_picture_start(mpeg2dec); | ||
146 | } | 177 | } |
147 | 178 | ||
148 | #define RECEIVED(code,state) (((state) << 8) + (code)) | 179 | #define RECEIVED(code,state) (((state) << 8) + (code)) |
@@ -151,146 +182,187 @@ mpeg2_state_t mpeg2_parse (mpeg2dec_t * mpeg2dec) | |||
151 | { | 182 | { |
152 | int size_buffer, size_chunk, copied; | 183 | int size_buffer, size_chunk, copied; |
153 | 184 | ||
154 | if (mpeg2dec->action) { | 185 | if (mpeg2dec->action) |
155 | mpeg2_state_t state; | 186 | { |
187 | mpeg2_state_t state; | ||
156 | 188 | ||
157 | state = mpeg2dec->action (mpeg2dec); | 189 | state = mpeg2dec->action (mpeg2dec); |
158 | if ((int)state >= 0) | 190 | |
159 | return state; | 191 | if ((int)state >= 0) |
192 | return state; | ||
160 | } | 193 | } |
161 | 194 | ||
162 | while (1) { | 195 | while (1) |
163 | while ((unsigned) (mpeg2dec->code - mpeg2dec->first_decode_slice) < | 196 | { |
164 | mpeg2dec->nb_decode_slices) { | 197 | while ((unsigned) (mpeg2dec->code - mpeg2dec->first_decode_slice) < |
165 | size_buffer = mpeg2dec->buf_end - mpeg2dec->buf_start; | 198 | mpeg2dec->nb_decode_slices) |
166 | size_chunk = (mpeg2dec->chunk_buffer + BUFFER_SIZE - | 199 | { |
167 | mpeg2dec->chunk_ptr); | 200 | size_buffer = mpeg2dec->buf_end - mpeg2dec->buf_start; |
168 | if (size_buffer <= size_chunk) { | 201 | size_chunk = mpeg2dec->chunk_buffer + BUFFER_SIZE - |
169 | copied = copy_chunk (mpeg2dec, size_buffer); | 202 | mpeg2dec->chunk_ptr; |
170 | if (!copied) { | 203 | |
171 | mpeg2dec->bytes_since_tag += size_buffer; | 204 | if (size_buffer <= size_chunk) |
172 | mpeg2dec->chunk_ptr += size_buffer; | 205 | { |
173 | return STATE_BUFFER; | 206 | copied = copy_chunk (mpeg2dec, size_buffer); |
174 | } | 207 | |
175 | } else { | 208 | if (!copied) |
176 | copied = copy_chunk (mpeg2dec, size_chunk); | 209 | { |
177 | if (!copied) { | 210 | mpeg2dec->bytes_since_tag += size_buffer; |
178 | /* filled the chunk buffer without finding a start code */ | 211 | mpeg2dec->chunk_ptr += size_buffer; |
179 | mpeg2dec->bytes_since_tag += size_chunk; | 212 | return STATE_BUFFER; |
180 | mpeg2dec->action = seek_chunk; | 213 | } |
181 | return STATE_INVALID; | 214 | } |
182 | } | 215 | else |
216 | { | ||
217 | copied = copy_chunk (mpeg2dec, size_chunk); | ||
218 | |||
219 | if (!copied) | ||
220 | { | ||
221 | /* filled the chunk buffer without finding a start code */ | ||
222 | mpeg2dec->bytes_since_tag += size_chunk; | ||
223 | mpeg2dec->action = seek_chunk; | ||
224 | return STATE_INVALID; | ||
225 | } | ||
226 | } | ||
227 | |||
228 | mpeg2dec->bytes_since_tag += copied; | ||
229 | |||
230 | mpeg2_slice (&mpeg2dec->decoder, mpeg2dec->code, | ||
231 | mpeg2dec->chunk_start); | ||
232 | mpeg2dec->code = mpeg2dec->buf_start[-1]; | ||
233 | mpeg2dec->chunk_ptr = mpeg2dec->chunk_start; | ||
183 | } | 234 | } |
184 | mpeg2dec->bytes_since_tag += copied; | 235 | |
185 | 236 | if ((unsigned) (mpeg2dec->code - 1) >= 0xb0 - 1) | |
186 | mpeg2_slice (&(mpeg2dec->decoder), mpeg2dec->code, | 237 | break; |
187 | mpeg2dec->chunk_start); | 238 | |
188 | mpeg2dec->code = mpeg2dec->buf_start[-1]; | 239 | if (seek_chunk (mpeg2dec) == STATE_BUFFER) |
189 | mpeg2dec->chunk_ptr = mpeg2dec->chunk_start; | 240 | return STATE_BUFFER; |
190 | } | ||
191 | if ((unsigned) (mpeg2dec->code - 1) >= 0xb0 - 1) | ||
192 | break; | ||
193 | if (seek_chunk (mpeg2dec) == STATE_BUFFER) | ||
194 | return STATE_BUFFER; | ||
195 | } | 241 | } |
196 | 242 | ||
197 | switch (mpeg2dec->code) { | 243 | switch (mpeg2dec->code) |
244 | { | ||
198 | case 0x00: | 245 | case 0x00: |
199 | mpeg2dec->action = mpeg2_header_picture_start; | 246 | mpeg2dec->action = mpeg2_header_picture_start; |
200 | return mpeg2dec->state; | 247 | return mpeg2dec->state; |
201 | case 0xb7: | 248 | case 0xb7: |
202 | mpeg2dec->action = mpeg2_header_end; | 249 | mpeg2dec->action = mpeg2_header_end; |
203 | break; | 250 | break; |
204 | case 0xb3: | 251 | case 0xb3: |
205 | case 0xb8: | 252 | case 0xb8: |
206 | mpeg2dec->action = mpeg2_parse_header; | 253 | mpeg2dec->action = mpeg2_parse_header; |
207 | break; | 254 | break; |
208 | default: | 255 | default: |
209 | mpeg2dec->action = seek_chunk; | 256 | mpeg2dec->action = seek_chunk; |
210 | return STATE_INVALID; | 257 | return STATE_INVALID; |
211 | } | 258 | } |
259 | |||
212 | return (mpeg2dec->state == STATE_SLICE) ? STATE_SLICE : STATE_INVALID; | 260 | return (mpeg2dec->state == STATE_SLICE) ? STATE_SLICE : STATE_INVALID; |
213 | } | 261 | } |
214 | 262 | ||
215 | mpeg2_state_t mpeg2_parse_header (mpeg2dec_t * mpeg2dec) | 263 | mpeg2_state_t mpeg2_parse_header (mpeg2dec_t * mpeg2dec) |
216 | { | 264 | { |
217 | static int (* process_header[]) (mpeg2dec_t * mpeg2dec) = { | 265 | static int (* const process_header[9]) (mpeg2dec_t *) = |
218 | mpeg2_header_picture, mpeg2_header_extension, mpeg2_header_user_data, | 266 | { |
219 | mpeg2_header_sequence, NULL, NULL, NULL, NULL, mpeg2_header_gop | 267 | mpeg2_header_picture, |
268 | mpeg2_header_extension, | ||
269 | mpeg2_header_user_data, | ||
270 | mpeg2_header_sequence, | ||
271 | NULL, | ||
272 | NULL, | ||
273 | NULL, | ||
274 | NULL, | ||
275 | mpeg2_header_gop | ||
220 | }; | 276 | }; |
277 | |||
221 | int size_buffer, size_chunk, copied; | 278 | int size_buffer, size_chunk, copied; |
222 | 279 | ||
223 | mpeg2dec->action = mpeg2_parse_header; | 280 | mpeg2dec->action = mpeg2_parse_header; |
224 | mpeg2dec->info.user_data = NULL; mpeg2dec->info.user_data_len = 0; | 281 | mpeg2dec->info.user_data = NULL; |
225 | while (1) { | 282 | mpeg2dec->info.user_data_len = 0; |
226 | size_buffer = mpeg2dec->buf_end - mpeg2dec->buf_start; | 283 | |
227 | size_chunk = (mpeg2dec->chunk_buffer + BUFFER_SIZE - | 284 | while (1) |
228 | mpeg2dec->chunk_ptr); | 285 | { |
229 | if (size_buffer <= size_chunk) { | 286 | size_buffer = mpeg2dec->buf_end - mpeg2dec->buf_start; |
230 | copied = copy_chunk (mpeg2dec, size_buffer); | 287 | size_chunk = mpeg2dec->chunk_buffer + BUFFER_SIZE - |
231 | if (!copied) { | 288 | mpeg2dec->chunk_ptr; |
232 | mpeg2dec->bytes_since_tag += size_buffer; | 289 | |
233 | mpeg2dec->chunk_ptr += size_buffer; | 290 | if (size_buffer <= size_chunk) |
234 | return STATE_BUFFER; | 291 | { |
235 | } | 292 | copied = copy_chunk (mpeg2dec, size_buffer); |
236 | } else { | 293 | |
237 | copied = copy_chunk (mpeg2dec, size_chunk); | 294 | if (!copied) |
238 | if (!copied) { | 295 | { |
239 | /* filled the chunk buffer without finding a start code */ | 296 | mpeg2dec->bytes_since_tag += size_buffer; |
240 | mpeg2dec->bytes_since_tag += size_chunk; | 297 | mpeg2dec->chunk_ptr += size_buffer; |
241 | mpeg2dec->code = 0xb4; | 298 | return STATE_BUFFER; |
242 | mpeg2dec->action = mpeg2_seek_header; | 299 | } |
243 | return STATE_INVALID; | 300 | } |
244 | } | 301 | else |
245 | } | 302 | { |
246 | mpeg2dec->bytes_since_tag += copied; | 303 | copied = copy_chunk (mpeg2dec, size_chunk); |
247 | 304 | ||
248 | if (process_header[mpeg2dec->code & 0x0b] (mpeg2dec)) { | 305 | if (!copied) |
249 | mpeg2dec->code = mpeg2dec->buf_start[-1]; | 306 | { |
250 | mpeg2dec->action = mpeg2_seek_header; | 307 | /* filled the chunk buffer without finding a start code */ |
251 | return STATE_INVALID; | 308 | mpeg2dec->bytes_since_tag += size_chunk; |
252 | } | 309 | mpeg2dec->code = 0xb4; |
253 | 310 | mpeg2dec->action = mpeg2_seek_header; | |
254 | mpeg2dec->code = mpeg2dec->buf_start[-1]; | 311 | return STATE_INVALID; |
255 | switch (RECEIVED (mpeg2dec->code, mpeg2dec->state)) { | 312 | } |
256 | 313 | } | |
257 | /* state transition after a sequence header */ | 314 | |
258 | case RECEIVED (0x00, STATE_SEQUENCE): | 315 | mpeg2dec->bytes_since_tag += copied; |
259 | mpeg2dec->action = mpeg2_header_picture_start; | 316 | |
260 | case RECEIVED (0xb8, STATE_SEQUENCE): | 317 | if (process_header[mpeg2dec->code & 0x0b] (mpeg2dec)) |
261 | mpeg2_header_sequence_finalize (mpeg2dec); | 318 | { |
262 | break; | 319 | mpeg2dec->code = mpeg2dec->buf_start[-1]; |
263 | 320 | mpeg2dec->action = mpeg2_seek_header; | |
264 | /* other legal state transitions */ | 321 | return STATE_INVALID; |
265 | case RECEIVED (0x00, STATE_GOP): | 322 | } |
266 | mpeg2_header_gop_finalize (mpeg2dec); | 323 | |
267 | mpeg2dec->action = mpeg2_header_picture_start; | 324 | mpeg2dec->code = mpeg2dec->buf_start[-1]; |
268 | break; | 325 | |
269 | case RECEIVED (0x01, STATE_PICTURE): | 326 | switch (RECEIVED (mpeg2dec->code, mpeg2dec->state)) |
270 | case RECEIVED (0x01, STATE_PICTURE_2ND): | 327 | { |
271 | mpeg2_header_picture_finalize (mpeg2dec); | 328 | /* state transition after a sequence header */ |
272 | mpeg2dec->action = mpeg2_header_slice_start; | 329 | case RECEIVED (0x00, STATE_SEQUENCE): |
273 | break; | 330 | mpeg2dec->action = mpeg2_header_picture_start; |
274 | 331 | case RECEIVED (0xb8, STATE_SEQUENCE): | |
275 | /* legal headers within a given state */ | 332 | mpeg2_header_sequence_finalize (mpeg2dec); |
276 | case RECEIVED (0xb2, STATE_SEQUENCE): | 333 | break; |
277 | case RECEIVED (0xb2, STATE_GOP): | 334 | |
278 | case RECEIVED (0xb2, STATE_PICTURE): | 335 | /* other legal state transitions */ |
279 | case RECEIVED (0xb2, STATE_PICTURE_2ND): | 336 | case RECEIVED (0x00, STATE_GOP): |
280 | case RECEIVED (0xb5, STATE_SEQUENCE): | 337 | mpeg2_header_gop_finalize (mpeg2dec); |
281 | case RECEIVED (0xb5, STATE_PICTURE): | 338 | mpeg2dec->action = mpeg2_header_picture_start; |
282 | case RECEIVED (0xb5, STATE_PICTURE_2ND): | 339 | break; |
283 | mpeg2dec->chunk_ptr = mpeg2dec->chunk_start; | 340 | case RECEIVED (0x01, STATE_PICTURE): |
284 | continue; | 341 | case RECEIVED (0x01, STATE_PICTURE_2ND): |
285 | 342 | mpeg2_header_picture_finalize (mpeg2dec); | |
286 | default: | 343 | mpeg2dec->action = mpeg2_header_slice_start; |
287 | mpeg2dec->action = mpeg2_seek_header; | 344 | break; |
288 | return STATE_INVALID; | 345 | |
289 | } | 346 | /* legal headers within a given state */ |
290 | 347 | case RECEIVED (0xb2, STATE_SEQUENCE): | |
291 | mpeg2dec->chunk_start = mpeg2dec->chunk_ptr = mpeg2dec->chunk_buffer; | 348 | case RECEIVED (0xb2, STATE_GOP): |
292 | mpeg2dec->user_data_len = 0; | 349 | case RECEIVED (0xb2, STATE_PICTURE): |
293 | return mpeg2dec->state; | 350 | case RECEIVED (0xb2, STATE_PICTURE_2ND): |
351 | case RECEIVED (0xb5, STATE_SEQUENCE): | ||
352 | case RECEIVED (0xb5, STATE_PICTURE): | ||
353 | case RECEIVED (0xb5, STATE_PICTURE_2ND): | ||
354 | mpeg2dec->chunk_ptr = mpeg2dec->chunk_start; | ||
355 | continue; | ||
356 | |||
357 | default: | ||
358 | mpeg2dec->action = mpeg2_seek_header; | ||
359 | return STATE_INVALID; | ||
360 | } | ||
361 | |||
362 | mpeg2dec->chunk_start = mpeg2dec->chunk_ptr = mpeg2dec->chunk_buffer; | ||
363 | mpeg2dec->user_data_len = 0; | ||
364 | |||
365 | return mpeg2dec->state; | ||
294 | } | 366 | } |
295 | } | 367 | } |
296 | 368 | ||
@@ -299,33 +371,42 @@ int mpeg2_convert (mpeg2dec_t * mpeg2dec, mpeg2_convert_t convert, void * arg) | |||
299 | mpeg2_convert_init_t convert_init; | 371 | mpeg2_convert_init_t convert_init; |
300 | int error; | 372 | int error; |
301 | 373 | ||
302 | error = convert (MPEG2_CONVERT_SET, NULL, &(mpeg2dec->sequence), 0, | 374 | error = convert (MPEG2_CONVERT_SET, NULL, &mpeg2dec->sequence, 0, |
303 | arg, &convert_init); | 375 | arg, &convert_init); |
304 | if (!error) { | 376 | |
305 | mpeg2dec->convert = convert; | 377 | if (!error) |
306 | mpeg2dec->convert_arg = arg; | 378 | { |
307 | mpeg2dec->convert_id_size = convert_init.id_size; | 379 | mpeg2dec->convert = convert; |
308 | mpeg2dec->convert_stride = 0; | 380 | mpeg2dec->convert_arg = arg; |
381 | mpeg2dec->convert_id_size = convert_init.id_size; | ||
382 | mpeg2dec->convert_stride = 0; | ||
309 | } | 383 | } |
384 | |||
310 | return error; | 385 | return error; |
311 | } | 386 | } |
312 | 387 | ||
313 | int mpeg2_stride (mpeg2dec_t * mpeg2dec, int stride) | 388 | int mpeg2_stride (mpeg2dec_t * mpeg2dec, int stride) |
314 | { | 389 | { |
315 | if (!mpeg2dec->convert) { | 390 | if (!mpeg2dec->convert) |
316 | if (stride < (int) mpeg2dec->sequence.width) | 391 | { |
317 | stride = mpeg2dec->sequence.width; | 392 | if (stride < (int) mpeg2dec->sequence.width) |
318 | mpeg2dec->decoder.stride_frame = stride; | 393 | stride = mpeg2dec->sequence.width; |
319 | } else { | 394 | |
320 | mpeg2_convert_init_t convert_init; | 395 | mpeg2dec->decoder.stride_frame = stride; |
321 | 396 | } | |
322 | stride = mpeg2dec->convert (MPEG2_CONVERT_STRIDE, NULL, | 397 | else |
323 | &(mpeg2dec->sequence), stride, | 398 | { |
324 | mpeg2dec->convert_arg, | 399 | mpeg2_convert_init_t convert_init; |
325 | &convert_init); | 400 | |
326 | mpeg2dec->convert_id_size = convert_init.id_size; | 401 | stride = mpeg2dec->convert(MPEG2_CONVERT_STRIDE, NULL, |
327 | mpeg2dec->convert_stride = stride; | 402 | &mpeg2dec->sequence, stride, |
403 | mpeg2dec->convert_arg, | ||
404 | &convert_init); | ||
405 | |||
406 | mpeg2dec->convert_id_size = convert_init.id_size; | ||
407 | mpeg2dec->convert_stride = stride; | ||
328 | } | 408 | } |
409 | |||
329 | return stride; | 410 | return stride; |
330 | } | 411 | } |
331 | 412 | ||
@@ -333,21 +414,29 @@ void mpeg2_set_buf (mpeg2dec_t * mpeg2dec, uint8_t * buf[3], void * id) | |||
333 | { | 414 | { |
334 | mpeg2_fbuf_t * fbuf; | 415 | mpeg2_fbuf_t * fbuf; |
335 | 416 | ||
336 | if (mpeg2dec->custom_fbuf) { | 417 | if (mpeg2dec->custom_fbuf) |
337 | if (mpeg2dec->state == STATE_SEQUENCE) { | 418 | { |
338 | mpeg2dec->fbuf[2] = mpeg2dec->fbuf[1]; | 419 | if (mpeg2dec->state == STATE_SEQUENCE) |
339 | mpeg2dec->fbuf[1] = mpeg2dec->fbuf[0]; | 420 | { |
340 | } | 421 | mpeg2dec->fbuf[2] = mpeg2dec->fbuf[1]; |
341 | mpeg2_set_fbuf (mpeg2dec, (mpeg2dec->decoder.coding_type == | 422 | mpeg2dec->fbuf[1] = mpeg2dec->fbuf[0]; |
342 | PIC_FLAG_CODING_TYPE_B)); | 423 | } |
343 | fbuf = mpeg2dec->fbuf[0]; | 424 | |
344 | } else { | 425 | mpeg2_set_fbuf (mpeg2dec, (mpeg2dec->decoder.coding_type == |
345 | fbuf = &(mpeg2dec->fbuf_alloc[mpeg2dec->alloc_index].fbuf); | 426 | PIC_FLAG_CODING_TYPE_B)); |
346 | mpeg2dec->alloc_index_user = ++mpeg2dec->alloc_index; | 427 | |
428 | fbuf = mpeg2dec->fbuf[0]; | ||
429 | } | ||
430 | else | ||
431 | { | ||
432 | fbuf = &mpeg2dec->fbuf_alloc[mpeg2dec->alloc_index].fbuf; | ||
433 | mpeg2dec->alloc_index_user = ++mpeg2dec->alloc_index; | ||
347 | } | 434 | } |
435 | |||
348 | fbuf->buf[0] = buf[0]; | 436 | fbuf->buf[0] = buf[0]; |
349 | fbuf->buf[1] = buf[1]; | 437 | fbuf->buf[1] = buf[1]; |
350 | fbuf->buf[2] = buf[2]; | 438 | fbuf->buf[2] = buf[2]; |
439 | |||
351 | fbuf->id = id; | 440 | fbuf->id = id; |
352 | } | 441 | } |
353 | 442 | ||
@@ -390,31 +479,26 @@ void mpeg2_reset (mpeg2dec_t * mpeg2dec, int full_reset) | |||
390 | mpeg2dec->state = STATE_INVALID; | 479 | mpeg2dec->state = STATE_INVALID; |
391 | mpeg2dec->first = 1; | 480 | mpeg2dec->first = 1; |
392 | 481 | ||
393 | mpeg2_reset_info(&(mpeg2dec->info)); | 482 | mpeg2_reset_info(&mpeg2dec->info); |
394 | mpeg2dec->info.gop = NULL; | 483 | mpeg2dec->info.gop = NULL; |
395 | mpeg2dec->info.user_data = NULL; | 484 | mpeg2dec->info.user_data = NULL; |
396 | mpeg2dec->info.user_data_len = 0; | 485 | mpeg2dec->info.user_data_len = 0; |
397 | if (full_reset) { | ||
398 | mpeg2dec->info.sequence = NULL; | ||
399 | mpeg2_header_state_init (mpeg2dec); | ||
400 | } | ||
401 | 486 | ||
487 | if (full_reset) | ||
488 | { | ||
489 | mpeg2dec->info.sequence = NULL; | ||
490 | mpeg2_header_state_init (mpeg2dec); | ||
491 | } | ||
402 | } | 492 | } |
403 | 493 | ||
404 | #ifdef CPU_COLDFIRE | ||
405 | /* twice as large as on other targets because coldfire uses | ||
406 | * a secondary, transposed buffer for optimisation */ | ||
407 | static int16_t static_dct_block[128] IBSS_ATTR ATTR_ALIGN(16); | ||
408 | #endif | ||
409 | |||
410 | mpeg2dec_t * mpeg2_init (void) | 494 | mpeg2dec_t * mpeg2_init (void) |
411 | { | 495 | { |
412 | mpeg2dec_t * mpeg2dec; | 496 | mpeg2dec_t * mpeg2dec; |
413 | 497 | ||
414 | mpeg2_idct_init (); | 498 | mpeg2_idct_init (); |
415 | 499 | ||
416 | mpeg2dec = (mpeg2dec_t *) mpeg2_malloc (sizeof (mpeg2dec_t), | 500 | mpeg2dec = (mpeg2dec_t *)mpeg2_malloc(sizeof (mpeg2dec_t), |
417 | MPEG2_ALLOC_MPEG2DEC); | 501 | MPEG2_ALLOC_MPEG2DEC); |
418 | if (mpeg2dec == NULL) | 502 | if (mpeg2dec == NULL) |
419 | return NULL; | 503 | return NULL; |
420 | 504 | ||
@@ -425,8 +509,8 @@ mpeg2dec_t * mpeg2_init (void) | |||
425 | rb->memset (mpeg2dec->decoder.DCTblock, 0, 64 * sizeof (int16_t)); | 509 | rb->memset (mpeg2dec->decoder.DCTblock, 0, 64 * sizeof (int16_t)); |
426 | rb->memset (mpeg2dec->quantizer_matrix, 0, 4 * 64 * sizeof (uint8_t)); | 510 | rb->memset (mpeg2dec->quantizer_matrix, 0, 4 * 64 * sizeof (uint8_t)); |
427 | 511 | ||
428 | mpeg2dec->chunk_buffer = (uint8_t *) mpeg2_malloc (BUFFER_SIZE + 4, | 512 | mpeg2dec->chunk_buffer = (uint8_t *)mpeg2_malloc(BUFFER_SIZE + 4, |
429 | MPEG2_ALLOC_CHUNK); | 513 | MPEG2_ALLOC_CHUNK); |
430 | 514 | ||
431 | mpeg2dec->sequence.width = (unsigned)-1; | 515 | mpeg2dec->sequence.width = (unsigned)-1; |
432 | mpeg2_reset (mpeg2dec, 1); | 516 | mpeg2_reset (mpeg2dec, 1); |