clib/libmpeg2/decode.c

filter: Statementstmt 0.0% 0 / 239 Branchbran 0.0% 0 / 76 Conditioncond n/a MC/DCmcdc n/a Subroutinesub n/a Podpod n/a totaltotal 0.0% 0 / 315 CC 0 SCAR 0
CC
0
Cov
0%
CRAP 0
« clib/libmpeg2/cpu_state.c ↑ Summary clib/libmpeg2/header.c »
1 /*
2 * decode.c
3 * Copyright (C) 2000-2003 Michel Lespinasse <walken@zoy.org>
4 * Copyright (C) 1999-2000 Aaron Holtzman <aholtzma@ess.engr.uvic.ca>
5 *
6 * This file is part of mpeg2dec, a free MPEG-2 video stream decoder.
7 * See http://libmpeg2.sourceforge.net/ for updates.
8 *
9 * mpeg2dec is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
13 *
14 * mpeg2dec is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 */
23  
24 #include "config.h"
25  
26 #include <string.h> /* memcmp/memset, try to remove */
27 #include <stdlib.h>
28 #include <inttypes.h>
29  
30 #include "mpeg2.h"
31 #include "attributes.h"
32 #include "mpeg2_internal.h"
33  
34 static int mpeg2_accels = 0;
35  
36 #define BUFFER_SIZE (1194 * 1024)
37  
38 0 const mpeg2_info_t * mpeg2_info (mpeg2dec_t * mpeg2dec)
39 {
40 0 return &(mpeg2dec->info);
41 }
42  
43 0 static inline int skip_chunk (mpeg2dec_t * mpeg2dec, int bytes)
44 {
45 uint8_t * current;
46 uint32_t shift;
47 uint8_t * limit;
48 uint8_t byte;
49  
50 0 ▶ if (!bytes)
Branch: 1 branch
BranchTrueFalseTotal
if (!bytes) 0 0 0
51 0 return 0;
52  
53 0 current = mpeg2dec->buf_start;
54 0 shift = mpeg2dec->shift;
55 0 limit = current + bytes;
56  
57 do {
58 0 byte = *current++;
59 0 ▶ if (shift == 0x00000100) {
Branch: 1 branch
BranchTrueFalseTotal
if (shift == 0x00000100) { 0 0 0
60 int skipped;
61  
62 0 mpeg2dec->shift = 0xffffff00;
63 0 skipped = current - mpeg2dec->buf_start;
64 0 mpeg2dec->buf_start = current;
65 0 return skipped;
66 }
67 0 shift = (shift | byte) << 8;
68 0 ▶ } while (current < limit);
Branch: 1 branch
BranchTrueFalseTotal
} while (current < limit); 0 0 0
69  
70 0 mpeg2dec->shift = shift;
71 0 mpeg2dec->buf_start = current;
72 0 return 0;
73 }
74  
75 0 static inline int copy_chunk (mpeg2dec_t * mpeg2dec, int bytes)
76 {
77 uint8_t * current;
78 uint32_t shift;
79 uint8_t * chunk_ptr;
80 uint8_t * limit;
81 uint8_t byte;
82  
83 0 ▶ if (!bytes)
Branch: 1 branch
BranchTrueFalseTotal
if (!bytes) 0 0 0
84 0 return 0;
85  
86 0 current = mpeg2dec->buf_start;
87 0 shift = mpeg2dec->shift;
88 0 chunk_ptr = mpeg2dec->chunk_ptr;
89 0 limit = current + bytes;
90  
91 do {
92 0 byte = *current++;
93 0 ▶ if (shift == 0x00000100) {
Branch: 1 branch
BranchTrueFalseTotal
if (shift == 0x00000100) { 0 0 0
94 int copied;
95  
96 0 mpeg2dec->shift = 0xffffff00;
97 0 mpeg2dec->chunk_ptr = chunk_ptr + 1;
98 0 copied = current - mpeg2dec->buf_start;
99 0 mpeg2dec->buf_start = current;
100 0 return copied;
101 }
102 0 shift = (shift | byte) << 8;
103 0 *chunk_ptr++ = byte;
104 0 ▶ } while (current < limit);
Branch: 1 branch
BranchTrueFalseTotal
} while (current < limit); 0 0 0
105  
106 0 mpeg2dec->shift = shift;
107 0 mpeg2dec->buf_start = current;
108 0 return 0;
109 }
110  
111 0 void mpeg2_buffer (mpeg2dec_t * mpeg2dec, uint8_t * start, uint8_t * end)
112 {
113 0 mpeg2dec->buf_start = start;
114 0 mpeg2dec->buf_end = end;
115 0 }
116  
117 0 int mpeg2_getpos (mpeg2dec_t * mpeg2dec)
118 {
119 0 return mpeg2dec->buf_end - mpeg2dec->buf_start;
120 }
121  
122 0 static inline mpeg2_state_t seek_chunk (mpeg2dec_t * mpeg2dec)
123 {
124 int size, skipped;
125  
126 0 size = mpeg2dec->buf_end - mpeg2dec->buf_start;
127 0 skipped = skip_chunk (mpeg2dec, size);
128 0 ▶ if (!skipped) {
Branch: 1 branch
BranchTrueFalseTotal
if (!skipped) { 0 0 0
129 0 mpeg2dec->bytes_since_tag += size;
130 0 return STATE_BUFFER;
131 }
132 0 mpeg2dec->bytes_since_tag += skipped;
133 0 mpeg2dec->code = mpeg2dec->buf_start[-1];
134 0 return STATE_INTERNAL_NORETURN;
135 }
136  
137 0 mpeg2_state_t mpeg2_seek_header (mpeg2dec_t * mpeg2dec)
138 {
139 0 ▶ while (!(mpeg2dec->code == 0xb3 ||
Branch: 1 branch
BranchTrueFalseTotal
while (!(mpeg2dec->code == 0xb3 || 0 0 0
140 0 ▶ ((mpeg2dec->code == 0xb7 || mpeg2dec->code == 0xb8 ||
Branch: 2 branches
BranchTrueFalseTotal
((mpeg2dec->code == 0xb7 || mpeg2dec->code == 0xb8 || 0 0 0
((mpeg2dec->code == 0xb7 || mpeg2dec->code == 0xb8 || 0 0 0
141 0 ▶ !mpeg2dec->code) && mpeg2dec->sequence.width != (unsigned)-1)))
Branch: 2 branches
BranchTrueFalseTotal
!mpeg2dec->code) && mpeg2dec->sequence.width != (unsigned)-1))) 0 0 0
!mpeg2dec->code) && mpeg2dec->sequence.width != (unsigned)-1))) 0 0 0
142 0 ▶ if (seek_chunk (mpeg2dec) == STATE_BUFFER)
Branch: 1 branch
BranchTrueFalseTotal
if (seek_chunk (mpeg2dec) == STATE_BUFFER) 0 0 0
143 0 return STATE_BUFFER;
144 0 mpeg2dec->chunk_start = mpeg2dec->chunk_ptr = mpeg2dec->chunk_buffer;
145 0 mpeg2dec->user_data_len = 0;
146 0 return ((mpeg2dec->code == 0xb7) ?
147 0 ▶ mpeg2_header_end (mpeg2dec) : mpeg2_parse_header (mpeg2dec));
Branch: 1 branch
BranchTrueFalseTotal
mpeg2_header_end (mpeg2dec) : mpeg2_parse_header (mpeg2dec)); 0 0 0
148 }
149  
150 #define RECEIVED(code,state) (((state) << 8) + (code))
151  
152 0 mpeg2_state_t mpeg2_parse (mpeg2dec_t * mpeg2dec)
153 {
154 int size_buffer, size_chunk, copied;
155  
156 0 ▶ if (mpeg2dec->action) {
Branch: 1 branch
BranchTrueFalseTotal
if (mpeg2dec->action) { 0 0 0
157 mpeg2_state_t state;
158  
159 0 state = mpeg2dec->action (mpeg2dec);
160 0 ▶ if ((int)state > (int)STATE_INTERNAL_NORETURN)
Branch: 1 branch
BranchTrueFalseTotal
if ((int)state > (int)STATE_INTERNAL_NORETURN) 0 0 0
161 0 return state;
162 }
163  
164 while (1) {
165 0 while ((unsigned) (mpeg2dec->code - mpeg2dec->first_decode_slice) <
166 0 ▶ mpeg2dec->nb_decode_slices) {
Branch: 1 branch
BranchTrueFalseTotal
mpeg2dec->nb_decode_slices) { 0 0 0
167 0 size_buffer = mpeg2dec->buf_end - mpeg2dec->buf_start;
168 0 size_chunk = (mpeg2dec->chunk_buffer + BUFFER_SIZE -
169 0 mpeg2dec->chunk_ptr);
170 0 ▶ if (size_buffer <= size_chunk) {
Branch: 1 branch
BranchTrueFalseTotal
if (size_buffer <= size_chunk) { 0 0 0
171 0 copied = copy_chunk (mpeg2dec, size_buffer);
172 0 ▶ if (!copied) {
Branch: 1 branch
BranchTrueFalseTotal
if (!copied) { 0 0 0
173 0 mpeg2dec->bytes_since_tag += size_buffer;
174 0 mpeg2dec->chunk_ptr += size_buffer;
175 0 return STATE_BUFFER;
176 }
177 } else {
178 0 copied = copy_chunk (mpeg2dec, size_chunk);
179 0 ▶ if (!copied) {
Branch: 1 branch
BranchTrueFalseTotal
if (!copied) { 0 0 0
180 /* filled the chunk buffer without finding a start code */
181 0 mpeg2dec->bytes_since_tag += size_chunk;
182 0 mpeg2dec->action = seek_chunk;
183 0 return STATE_INVALID;
184 }
185 }
186 0 mpeg2dec->bytes_since_tag += copied;
187  
188 0 mpeg2_slice (&(mpeg2dec->decoder), mpeg2dec->code,
189 0 mpeg2dec->chunk_start);
190 0 mpeg2dec->code = mpeg2dec->buf_start[-1];
191 0 mpeg2dec->chunk_ptr = mpeg2dec->chunk_start;
192 }
193 0 ▶ if ((unsigned) (mpeg2dec->code - 1) >= 0xb0 - 1)
Branch: 1 branch
BranchTrueFalseTotal
if ((unsigned) (mpeg2dec->code - 1) >= 0xb0 - 1) 0 0 0
194 0 break;
195 0 ▶ if (seek_chunk (mpeg2dec) == STATE_BUFFER)
Branch: 1 branch
BranchTrueFalseTotal
if (seek_chunk (mpeg2dec) == STATE_BUFFER) 0 0 0
196 0 return STATE_BUFFER;
197 }
198  
199 0 mpeg2dec->action = mpeg2_seek_header;
200 0 switch (mpeg2dec->code) {
201 0 case 0x00:
202 0 return mpeg2dec->state;
203 0 case 0xb3:
204 case 0xb7:
205 case 0xb8:
206 0 ▶ return (mpeg2dec->state == STATE_SLICE) ? STATE_SLICE : STATE_INVALID;
Branch: 1 branch
BranchTrueFalseTotal
return (mpeg2dec->state == STATE_SLICE) ? STATE_SLICE : STATE_INVALID; 0 0 0
207 0 default:
208 0 mpeg2dec->action = seek_chunk;
209 0 return STATE_INVALID;
210 }
211 }
212  
213 0 mpeg2_state_t mpeg2_parse_header (mpeg2dec_t * mpeg2dec)
214 {
215 static int (* process_header[]) (mpeg2dec_t * mpeg2dec) = {
216 mpeg2_header_picture, mpeg2_header_extension, mpeg2_header_user_data,
217 mpeg2_header_sequence, NULL, NULL, NULL, NULL, mpeg2_header_gop
218 };
219 int size_buffer, size_chunk, copied;
220  
221 0 mpeg2dec->action = mpeg2_parse_header;
222 0 mpeg2dec->info.user_data = NULL; mpeg2dec->info.user_data_len = 0;
223 while (1) {
224 0 size_buffer = mpeg2dec->buf_end - mpeg2dec->buf_start;
225 0 size_chunk = (mpeg2dec->chunk_buffer + BUFFER_SIZE -
226 0 mpeg2dec->chunk_ptr);
227 0 ▶ if (size_buffer <= size_chunk) {
Branch: 1 branch
BranchTrueFalseTotal
if (size_buffer <= size_chunk) { 0 0 0
228 0 copied = copy_chunk (mpeg2dec, size_buffer);
229 0 ▶ if (!copied) {
Branch: 1 branch
BranchTrueFalseTotal
if (!copied) { 0 0 0
230 0 mpeg2dec->bytes_since_tag += size_buffer;
231 0 mpeg2dec->chunk_ptr += size_buffer;
232 0 return STATE_BUFFER;
233 }
234 } else {
235 0 copied = copy_chunk (mpeg2dec, size_chunk);
236 0 ▶ if (!copied) {
Branch: 1 branch
BranchTrueFalseTotal
if (!copied) { 0 0 0
237 /* filled the chunk buffer without finding a start code */
238 0 mpeg2dec->bytes_since_tag += size_chunk;
239 0 mpeg2dec->code = 0xb4;
240 0 mpeg2dec->action = mpeg2_seek_header;
241 0 return STATE_INVALID;
242 }
243 }
244 0 mpeg2dec->bytes_since_tag += copied;
245  
246 0 ▶ if (process_header[mpeg2dec->code & 0x0b] (mpeg2dec)) {
Branch: 1 branch
BranchTrueFalseTotal
if (process_header[mpeg2dec->code & 0x0b] (mpeg2dec)) { 0 0 0
247 0 mpeg2dec->code = mpeg2dec->buf_start[-1];
248 0 mpeg2dec->action = mpeg2_seek_header;
249 0 return STATE_INVALID;
250 }
251  
252 0 mpeg2dec->code = mpeg2dec->buf_start[-1];
253 0 switch (RECEIVED (mpeg2dec->code, mpeg2dec->state)) {
254  
255 /* state transition after a sequence header */
256 0 case RECEIVED (0x00, STATE_SEQUENCE):
257 case RECEIVED (0xb8, STATE_SEQUENCE):
258 0 mpeg2_header_sequence_finalize (mpeg2dec);
259 0 break;
260  
261 /* other legal state transitions */
262 0 case RECEIVED (0x00, STATE_GOP):
263 0 mpeg2_header_gop_finalize (mpeg2dec);
264 0 break;
265 0 case RECEIVED (0x01, STATE_PICTURE):
266 case RECEIVED (0x01, STATE_PICTURE_2ND):
267 0 mpeg2_header_picture_finalize (mpeg2dec, mpeg2_accels);
268 0 mpeg2dec->action = mpeg2_header_slice_start;
269 0 break;
270  
271 /* legal headers within a given state */
272 0 case RECEIVED (0xb2, STATE_SEQUENCE):
273 case RECEIVED (0xb2, STATE_GOP):
274 case RECEIVED (0xb2, STATE_PICTURE):
275 case RECEIVED (0xb2, STATE_PICTURE_2ND):
276 case RECEIVED (0xb5, STATE_SEQUENCE):
277 case RECEIVED (0xb5, STATE_PICTURE):
278 case RECEIVED (0xb5, STATE_PICTURE_2ND):
279 0 mpeg2dec->chunk_ptr = mpeg2dec->chunk_start;
280 0 continue;
281  
282 0 default:
283 0 mpeg2dec->action = mpeg2_seek_header;
284 0 return STATE_INVALID;
285 }
286  
287 0 mpeg2dec->chunk_start = mpeg2dec->chunk_ptr = mpeg2dec->chunk_buffer;
288 0 mpeg2dec->user_data_len = 0;
289 0 return mpeg2dec->state;
290 }
291 }
292  
293 0 int mpeg2_convert (mpeg2dec_t * mpeg2dec, mpeg2_convert_t convert, void * arg)
294 {
295 mpeg2_convert_init_t convert_init;
296 int error;
297  
298 0 error = convert (MPEG2_CONVERT_SET, NULL, &(mpeg2dec->sequence), 0,
299 mpeg2_accels, arg, &convert_init);
300 0 ▶ if (!error) {
Branch: 1 branch
BranchTrueFalseTotal
if (!error) { 0 0 0
301 0 mpeg2dec->convert = convert;
302 0 mpeg2dec->convert_arg = arg;
303 0 mpeg2dec->convert_id_size = convert_init.id_size;
304 0 mpeg2dec->convert_stride = 0;
305 }
306 0 return error;
307 }
308  
309 0 int mpeg2_stride (mpeg2dec_t * mpeg2dec, int stride)
310 {
311 0 ▶ if (!mpeg2dec->convert) {
Branch: 1 branch
BranchTrueFalseTotal
if (!mpeg2dec->convert) { 0 0 0
312 0 ▶ if (stride < (int) mpeg2dec->sequence.width)
Branch: 1 branch
BranchTrueFalseTotal
if (stride < (int) mpeg2dec->sequence.width) 0 0 0
313 0 stride = mpeg2dec->sequence.width;
314 0 mpeg2dec->decoder.stride_frame = stride;
315 } else {
316 mpeg2_convert_init_t convert_init;
317  
318 0 stride = mpeg2dec->convert (MPEG2_CONVERT_STRIDE, NULL,
319 0 &(mpeg2dec->sequence), stride,
320 mpeg2_accels, mpeg2dec->convert_arg,
321 &convert_init);
322 0 mpeg2dec->convert_id_size = convert_init.id_size;
323 0 mpeg2dec->convert_stride = stride;
324 }
325 0 return stride;
326 }
327  
328 0 void mpeg2_set_buf (mpeg2dec_t * mpeg2dec, uint8_t * buf[3], void * id)
329 {
330 mpeg2_fbuf_t * fbuf;
331  
332 0 ▶ if (mpeg2dec->custom_fbuf) {
Branch: 1 branch
BranchTrueFalseTotal
if (mpeg2dec->custom_fbuf) { 0 0 0
333 0 ▶ if (mpeg2dec->state == STATE_SEQUENCE) {
Branch: 1 branch
BranchTrueFalseTotal
if (mpeg2dec->state == STATE_SEQUENCE) { 0 0 0
334 0 mpeg2dec->fbuf[2] = mpeg2dec->fbuf[1];
335 0 mpeg2dec->fbuf[1] = mpeg2dec->fbuf[0];
336 }
337 0 mpeg2_set_fbuf (mpeg2dec, (mpeg2dec->decoder.coding_type ==
338 PIC_FLAG_CODING_TYPE_B));
339 0 fbuf = mpeg2dec->fbuf[0];
340 } else {
341 0 fbuf = &(mpeg2dec->fbuf_alloc[mpeg2dec->alloc_index].fbuf);
342 0 mpeg2dec->alloc_index_user = ++mpeg2dec->alloc_index;
343 }
344 0 fbuf->buf[0] = buf[0];
345 0 fbuf->buf[1] = buf[1];
346 0 fbuf->buf[2] = buf[2];
347 0 fbuf->id = id;
348 0 }
349  
350 0 void mpeg2_custom_fbuf (mpeg2dec_t * mpeg2dec, int custom_fbuf)
351 {
352 0 mpeg2dec->custom_fbuf = custom_fbuf;
353 0 }
354  
355 0 void mpeg2_skip (mpeg2dec_t * mpeg2dec, int skip)
356 {
357 0 mpeg2dec->first_decode_slice = 1;
358 0 ▶ mpeg2dec->nb_decode_slices = skip ? 0 : (0xb0 - 1);
Branch: 1 branch
BranchTrueFalseTotal
mpeg2dec->nb_decode_slices = skip ? 0 : (0xb0 - 1); 0 0 0
359 0 }
360  
361 0 void mpeg2_slice_region (mpeg2dec_t * mpeg2dec, int start, int end)
362 {
363 0 ▶ start = (start < 1) ? 1 : (start > 0xb0) ? 0xb0 : start;
Branch: 1 branch
BranchTrueFalseTotal
start = (start < 1) ? 1 : (start > 0xb0) ? 0xb0 : start; 0 0 0
364 0 ▶ end = (end < start) ? start : (end > 0xb0) ? 0xb0 : end;
Branch: 1 branch
BranchTrueFalseTotal
end = (end < start) ? start : (end > 0xb0) ? 0xb0 : end; 0 0 0
365 0 mpeg2dec->first_decode_slice = start;
366 0 mpeg2dec->nb_decode_slices = end - start;
367 0 }
368  
369 0 void mpeg2_tag_picture (mpeg2dec_t * mpeg2dec, uint32_t tag, uint32_t tag2)
370 {
371 0 mpeg2dec->tag_previous = mpeg2dec->tag_current;
372 0 mpeg2dec->tag2_previous = mpeg2dec->tag2_current;
373 0 mpeg2dec->tag_current = tag;
374 0 mpeg2dec->tag2_current = tag2;
375 0 mpeg2dec->num_tags++;
376 0 mpeg2dec->bytes_since_tag = 0;
377 0 }
378  
379 0 uint32_t mpeg2_accel (uint32_t accel)
380 {
381 0 ▶ if (!mpeg2_accels) {
Branch: 1 branch
BranchTrueFalseTotal
if (!mpeg2_accels) { 0 0 0
382 0 mpeg2_accels = mpeg2_detect_accel (accel) | MPEG2_ACCEL_DETECT;
383 0 mpeg2_cpu_state_init (mpeg2_accels);
384 0 mpeg2_idct_init (mpeg2_accels);
385 0 mpeg2_mc_init (mpeg2_accels);
386 }
387 0 return mpeg2_accels & ~MPEG2_ACCEL_DETECT;
388 }
389  
390 0 void mpeg2_reset (mpeg2dec_t * mpeg2dec, int full_reset)
391 {
392 0 mpeg2dec->buf_start = mpeg2dec->buf_end = NULL;
393 0 mpeg2dec->num_tags = 0;
394 0 mpeg2dec->shift = 0xffffff00;
395 0 mpeg2dec->code = 0xb4;
396 0 mpeg2dec->action = mpeg2_seek_header;
397 0 mpeg2dec->state = STATE_INVALID;
398 0 mpeg2dec->first = 1;
399  
400 0 mpeg2_reset_info(&(mpeg2dec->info));
401 0 mpeg2dec->info.gop = NULL;
402 0 mpeg2dec->info.user_data = NULL;
403 0 mpeg2dec->info.user_data_len = 0;
404 0 ▶ if (full_reset) {
Branch: 1 branch
BranchTrueFalseTotal
if (full_reset) { 0 0 0
405 0 mpeg2dec->info.sequence = NULL;
406 0 mpeg2_header_state_init (mpeg2dec);
407 }
408  
409 0 }
410  
411 0 mpeg2dec_t * mpeg2_init (void)
412 {
413 mpeg2dec_t * mpeg2dec;
414  
415 0 mpeg2_accel (MPEG2_ACCEL_DETECT);
416  
417 0 mpeg2dec = (mpeg2dec_t *) mpeg2_malloc (sizeof (mpeg2dec_t),
418 MPEG2_ALLOC_MPEG2DEC);
419 0 ▶ if (mpeg2dec == NULL)
Branch: 1 branch
BranchTrueFalseTotal
if (mpeg2dec == NULL) 0 0 0
420 0 return NULL;
421  
422 0 memset (mpeg2dec->decoder.DCTblock, 0, 64 * sizeof (int16_t));
423 0 memset (mpeg2dec->quantizer_matrix, 0, 4 * 64 * sizeof (uint8_t));
424  
425 0 mpeg2dec->chunk_buffer = (uint8_t *) mpeg2_malloc (BUFFER_SIZE + 4,
426 MPEG2_ALLOC_CHUNK);
427  
428 0 mpeg2dec->sequence.width = (unsigned)-1;
429 0 mpeg2_reset (mpeg2dec, 1);
430  
431 0 return mpeg2dec;
432 }
433  
434 0 void mpeg2_close (mpeg2dec_t * mpeg2dec)
435 {
436 0 mpeg2_header_state_init (mpeg2dec);
437 0 mpeg2_free (mpeg2dec->chunk_buffer);
438 0 mpeg2_free (mpeg2dec);
439 0 }
« clib/libmpeg2/cpu_state.c ↑ Summary clib/libmpeg2/header.c »