Mercurial > mplayer.hg

comparison libmpeg2/decode.c @ 9857:89b48bc6c441

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Importing libmpeg2 from mpeg2dec-0.3.1
author arpi
date Sun, 06 Apr 2003 16:41:49 +0000
parents
children 9af61fc7955c
comparison
equal deleted inserted replaced
9856:08496327b7ec 9857:89b48bc6c441
1 /*
2 * decode.c
3 * Copyright (C) 2000-2002 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 "mpeg2_internal.h"
32 #include "convert.h"
33
34 static int mpeg2_accels = 0;
35
36 #define BUFFER_SIZE (1194 * 1024)
37
38 const mpeg2_info_t * mpeg2_info (mpeg2dec_t * mpeg2dec)
39 {
40 return &(mpeg2dec->info);
41 }
42
43 static inline int skip_chunk (mpeg2dec_t * mpeg2dec, int bytes)
44 {
45 uint8_t * current;
46 uint32_t shift;
47 uint8_t * chunk_ptr;
48 uint8_t * limit;
49 uint8_t byte;
50
51 if (!bytes)
52 return 0;
53
54 current = mpeg2dec->buf_start;
55 shift = mpeg2dec->shift;
56 chunk_ptr = mpeg2dec->chunk_ptr;
57 limit = current + bytes;
58
59 do {
60 byte = *current++;
61 if (shift == 0x00000100) {
62 int skipped;
63
64 mpeg2dec->shift = 0xffffff00;
65 skipped = current - mpeg2dec->buf_start;
66 mpeg2dec->buf_start = current;
67 return skipped;
68 }
69 shift = (shift | byte) << 8;
70 } while (current < limit);
71
72 mpeg2dec->shift = shift;
73 mpeg2dec->buf_start = current;
74 return 0;
75 }
76
77 static inline int copy_chunk (mpeg2dec_t * mpeg2dec, int bytes)
78 {
79 uint8_t * current;
80 uint32_t shift;
81 uint8_t * chunk_ptr;
82 uint8_t * limit;
83 uint8_t byte;
84
85 if (!bytes)
86 return 0;
87
88 current = mpeg2dec->buf_start;
89 shift = mpeg2dec->shift;
90 chunk_ptr = mpeg2dec->chunk_ptr;
91 limit = current + bytes;
92
93 do {
94 byte = *current++;
95 if (shift == 0x00000100) {
96 int copied;
97
98 mpeg2dec->shift = 0xffffff00;
99 mpeg2dec->chunk_ptr = chunk_ptr + 1;
100 copied = current - mpeg2dec->buf_start;
101 mpeg2dec->buf_start = current;
102 return copied;
103 }
104 shift = (shift | byte) << 8;
105 *chunk_ptr++ = byte;
106 } while (current < limit);
107
108 mpeg2dec->shift = shift;
109 mpeg2dec->buf_start = current;
110 return 0;
111 }
112
113 void mpeg2_buffer (mpeg2dec_t * mpeg2dec, uint8_t * start, uint8_t * end)
114 {
115 mpeg2dec->buf_start = start;
116 mpeg2dec->buf_end = end;
117 }
118
119 static inline int seek_chunk (mpeg2dec_t * mpeg2dec)
120 {
121 int size, skipped;
122
123 size = mpeg2dec->buf_end - mpeg2dec->buf_start;
124 skipped = skip_chunk (mpeg2dec, size);
125 if (!skipped) {
126 mpeg2dec->bytes_since_pts += size;
127 return -1;
128 }
129 mpeg2dec->bytes_since_pts += skipped;
130 mpeg2dec->code = mpeg2dec->buf_start[-1];
131 return 0;
132 }
133
134 int mpeg2_seek_header (mpeg2dec_t * mpeg2dec)
135 {
136 while (mpeg2dec->code != 0xb3 &&
137 ((mpeg2dec->code != 0xb7 && mpeg2dec->code != 0xb8 &&
138 mpeg2dec->code) || mpeg2dec->sequence.width == -1))
139 if (seek_chunk (mpeg2dec))
140 return -1;
141 mpeg2dec->chunk_start = mpeg2dec->chunk_ptr = mpeg2dec->chunk_buffer;
142 return mpeg2_parse_header (mpeg2dec);
143 }
144
145 int mpeg2_seek_sequence (mpeg2dec_t * mpeg2dec)
146 {
147 mpeg2dec->sequence.width = -1;
148 return mpeg2_seek_header (mpeg2dec);
149 }
150
151 #define RECEIVED(code,state) (((state) << 8) + (code))
152
153 int mpeg2_parse (mpeg2dec_t * mpeg2dec)
154 {
155 int size_buffer, size_chunk, copied;
156
157 if (mpeg2dec->action) {
158 int state;
159
160 state = mpeg2dec->action (mpeg2dec);
161 if (state)
162 return state;
163 }
164
165 while (1) {
166 while ((unsigned) (mpeg2dec->code - mpeg2dec->first_decode_slice) <
167 mpeg2dec->nb_decode_slices) {
168 size_buffer = mpeg2dec->buf_end - mpeg2dec->buf_start;
169 size_chunk = (mpeg2dec->chunk_buffer + BUFFER_SIZE -
170 mpeg2dec->chunk_ptr);
171 if (size_buffer <= size_chunk) {
172 copied = copy_chunk (mpeg2dec, size_buffer);
173 if (!copied) {
174 mpeg2dec->bytes_since_pts += size_buffer;
175 mpeg2dec->chunk_ptr += size_buffer;
176 return -1;
177 }
178 } else {
179 copied = copy_chunk (mpeg2dec, size_chunk);
180 if (!copied) {
181 /* filled the chunk buffer without finding a start code */
182 mpeg2dec->bytes_since_pts += size_chunk;
183 mpeg2dec->action = seek_chunk;
184 return STATE_INVALID;
185 }
186 }
187 mpeg2dec->bytes_since_pts += copied;
188
189 mpeg2_slice (&(mpeg2dec->decoder), mpeg2dec->code,
190 mpeg2dec->chunk_start);
191 mpeg2dec->code = mpeg2dec->buf_start[-1];
192 mpeg2dec->chunk_ptr = mpeg2dec->chunk_start;
193 }
194 if ((unsigned) (mpeg2dec->code - 1) >= 0xb0 - 1)
195 break;
196 if (seek_chunk (mpeg2dec))
197 return -1;
198 }
199
200 switch (RECEIVED (mpeg2dec->code, mpeg2dec->state)) {
201 case RECEIVED (0x00, STATE_SLICE_1ST):
202 case RECEIVED (0x00, STATE_SLICE):
203 mpeg2dec->action = mpeg2_header_picture_start;
204 break;
205 case RECEIVED (0xb7, STATE_SLICE):
206 mpeg2dec->action = mpeg2_header_end;
207 break;
208 case RECEIVED (0xb3, STATE_SLICE):
209 case RECEIVED (0xb8, STATE_SLICE):
210 mpeg2dec->action = mpeg2_parse_header;
211 break;
212 default:
213 mpeg2dec->action = mpeg2_seek_header;
214 return STATE_INVALID;
215 }
216 return mpeg2dec->state;
217 }
218
219 int mpeg2_parse_header (mpeg2dec_t * mpeg2dec)
220 {
221 static int (* process_header[]) (mpeg2dec_t * mpeg2dec) = {
222 mpeg2_header_picture, mpeg2_header_extension, mpeg2_header_user_data,
223 mpeg2_header_sequence, NULL, NULL, NULL, NULL, mpeg2_header_gop
224 };
225 int size_buffer, size_chunk, copied;
226
227 mpeg2dec->action = mpeg2_parse_header;
228 while (1) {
229 size_buffer = mpeg2dec->buf_end - mpeg2dec->buf_start;
230 size_chunk = (mpeg2dec->chunk_buffer + BUFFER_SIZE -
231 mpeg2dec->chunk_ptr);
232 if (size_buffer <= size_chunk) {
233 copied = copy_chunk (mpeg2dec, size_buffer);
234 if (!copied) {
235 mpeg2dec->bytes_since_pts += size_buffer;
236 mpeg2dec->chunk_ptr += size_buffer;
237 return -1;
238 }
239 } else {
240 copied = copy_chunk (mpeg2dec, size_chunk);
241 if (!copied) {
242 /* filled the chunk buffer without finding a start code */
243 mpeg2dec->bytes_since_pts += size_chunk;
244 mpeg2dec->code = 0xb4;
245 mpeg2dec->action = mpeg2_seek_header;
246 return STATE_INVALID;
247 }
248 }
249 mpeg2dec->bytes_since_pts += copied;
250
251 if (process_header[mpeg2dec->code & 0x0b] (mpeg2dec)) {
252 mpeg2dec->code = mpeg2dec->buf_start[-1];
253 mpeg2dec->action = mpeg2_seek_header;
254 return STATE_INVALID;
255 }
256
257 mpeg2dec->code = mpeg2dec->buf_start[-1];
258 switch (RECEIVED (mpeg2dec->code, mpeg2dec->state)) {
259
260 /* state transition after a sequence header */
261 case RECEIVED (0x00, STATE_SEQUENCE):
262 mpeg2dec->action = mpeg2_header_picture_start;
263 case RECEIVED (0xb8, STATE_SEQUENCE):
264 mpeg2_header_sequence_finalize (mpeg2dec);
265 break;
266
267 /* other legal state transitions */
268 case RECEIVED (0x00, STATE_GOP):
269 mpeg2dec->action = mpeg2_header_picture_start;
270 break;
271 case RECEIVED (0x01, STATE_PICTURE):
272 case RECEIVED (0x01, STATE_PICTURE_2ND):
273 mpeg2dec->action = mpeg2_header_slice_start;
274 break;
275
276 /* legal headers within a given state */
277 case RECEIVED (0xb2, STATE_SEQUENCE):
278 case RECEIVED (0xb2, STATE_GOP):
279 case RECEIVED (0xb2, STATE_PICTURE):
280 case RECEIVED (0xb2, STATE_PICTURE_2ND):
281 case RECEIVED (0xb5, STATE_SEQUENCE):
282 case RECEIVED (0xb5, STATE_PICTURE):
283 case RECEIVED (0xb5, STATE_PICTURE_2ND):
284 mpeg2dec->chunk_ptr = mpeg2dec->chunk_start;
285 continue;
286
287 default:
288 mpeg2dec->action = mpeg2_seek_header;
289 return STATE_INVALID;
290 }
291
292 mpeg2dec->chunk_start = mpeg2dec->chunk_ptr = mpeg2dec->chunk_buffer;
293 return mpeg2dec->state;
294 }
295 }
296
297 void mpeg2_convert (mpeg2dec_t * mpeg2dec,
298 void (* convert) (int, int, uint32_t, void *,
299 struct convert_init_s *), void * arg)
300 {
301 convert_init_t convert_init;
302 int size;
303
304 convert_init.id = NULL;
305 convert (mpeg2dec->decoder.width, mpeg2dec->decoder.height,
306 mpeg2_accels, arg, &convert_init);
307 if (convert_init.id_size) {
308 convert_init.id = mpeg2dec->convert_id =
309 mpeg2_malloc (convert_init.id_size, ALLOC_CONVERT_ID);
310 convert (mpeg2dec->decoder.width, mpeg2dec->decoder.height,
311 mpeg2_accels, arg, &convert_init);
312 }
313 mpeg2dec->convert_size[0] = size = convert_init.buf_size[0];
314 mpeg2dec->convert_size[1] = size += convert_init.buf_size[1];
315 mpeg2dec->convert_size[2] = size += convert_init.buf_size[2];
316 mpeg2dec->convert_start = convert_init.start;
317 mpeg2dec->convert_copy = convert_init.copy;
318
319 size = mpeg2dec->decoder.width * mpeg2dec->decoder.height >> 2;
320 mpeg2dec->yuv_buf[0][0] = (uint8_t *) mpeg2_malloc (6 * size, ALLOC_YUV);
321 mpeg2dec->yuv_buf[0][1] = mpeg2dec->yuv_buf[0][0] + 4 * size;
322 mpeg2dec->yuv_buf[0][2] = mpeg2dec->yuv_buf[0][0] + 5 * size;
323 mpeg2dec->yuv_buf[1][0] = (uint8_t *) mpeg2_malloc (6 * size, ALLOC_YUV);
324 mpeg2dec->yuv_buf[1][1] = mpeg2dec->yuv_buf[1][0] + 4 * size;
325 mpeg2dec->yuv_buf[1][2] = mpeg2dec->yuv_buf[1][0] + 5 * size;
326 size = mpeg2dec->decoder.width * 8;
327 mpeg2dec->yuv_buf[2][0] = (uint8_t *) mpeg2_malloc (6 * size, ALLOC_YUV);
328 mpeg2dec->yuv_buf[2][1] = mpeg2dec->yuv_buf[2][0] + 4 * size;
329 mpeg2dec->yuv_buf[2][2] = mpeg2dec->yuv_buf[2][0] + 5 * size;
330 }
331
332 void mpeg2_set_buf (mpeg2dec_t * mpeg2dec, uint8_t * buf[3], void * id)
333 {
334 fbuf_t * fbuf;
335
336 if (mpeg2dec->custom_fbuf) {
337 mpeg2_set_fbuf (mpeg2dec, mpeg2dec->decoder.coding_type);
338 fbuf = mpeg2dec->fbuf[0];
339 if (mpeg2dec->state == STATE_SEQUENCE) {
340 mpeg2dec->fbuf[2] = mpeg2dec->fbuf[1];
341 mpeg2dec->fbuf[1] = mpeg2dec->fbuf[0];
342 }
343 } else {
344 fbuf = &(mpeg2dec->fbuf_alloc[mpeg2dec->alloc_index].fbuf);
345 mpeg2dec->alloc_index_user = ++mpeg2dec->alloc_index;
346 }
347 fbuf->buf[0] = buf[0];
348 fbuf->buf[1] = buf[1];
349 fbuf->buf[2] = buf[2];
350 fbuf->id = id;
351 }
352
353 void mpeg2_custom_fbuf (mpeg2dec_t * mpeg2dec, int custom_fbuf)
354 {
355 mpeg2dec->custom_fbuf = custom_fbuf;
356 }
357
358 void mpeg2_skip (mpeg2dec_t * mpeg2dec, int skip)
359 {
360 mpeg2dec->first_decode_slice = 1;
361 mpeg2dec->nb_decode_slices = skip ? 0 : (0xb0 - 1);
362 }
363
364 void mpeg2_slice_region (mpeg2dec_t * mpeg2dec, int start, int end)
365 {
366 start = (start < 1) ? 1 : (start > 0xb0) ? 0xb0 : start;
367 end = (end < start) ? start : (end > 0xb0) ? 0xb0 : end;
368 mpeg2dec->first_decode_slice = start;
369 mpeg2dec->nb_decode_slices = end - start;
370 }
371
372 void mpeg2_pts (mpeg2dec_t * mpeg2dec, uint32_t pts)
373 {
374 mpeg2dec->pts_previous = mpeg2dec->pts_current;
375 mpeg2dec->pts_current = pts;
376 mpeg2dec->num_pts++;
377 mpeg2dec->bytes_since_pts = 0;
378 }
379
380 uint32_t mpeg2_accel (uint32_t accel)
381 {
382 if (!mpeg2_accels) {
383 if (accel & MPEG2_ACCEL_DETECT)
384 accel |= mpeg2_detect_accel ();
385 mpeg2_accels = accel |= MPEG2_ACCEL_DETECT;
386 mpeg2_cpu_state_init (accel);
387 mpeg2_idct_init (accel);
388 mpeg2_mc_init (accel);
389 }
390 return mpeg2_accels & ~MPEG2_ACCEL_DETECT;
391 }
392
393 mpeg2dec_t * mpeg2_init (void)
394 {
395 mpeg2dec_t * mpeg2dec;
396
397 mpeg2_accel (MPEG2_ACCEL_DETECT);
398
399 mpeg2dec = (mpeg2dec_t *) mpeg2_malloc (sizeof (mpeg2dec_t),
400 ALLOC_MPEG2DEC);
401 if (mpeg2dec == NULL)
402 return NULL;
403
404 memset (mpeg2dec, 0, sizeof (mpeg2dec_t));
405
406 mpeg2dec->chunk_buffer = (uint8_t *) mpeg2_malloc (BUFFER_SIZE + 4,
407 ALLOC_CHUNK);
408
409 mpeg2dec->shift = 0xffffff00;
410 mpeg2dec->action = mpeg2_seek_sequence;
411 mpeg2dec->code = 0xb4;
412 mpeg2dec->first_decode_slice = 1;
413 mpeg2dec->nb_decode_slices = 0xb0 - 1;
414 mpeg2dec->convert_id = NULL;
415
416 /* initialize substructures */
417 mpeg2_header_state_init (mpeg2dec);
418
419 return mpeg2dec;
420 }
421
422 void mpeg2_close (mpeg2dec_t * mpeg2dec)
423 {
424 int i;
425
426 /* static uint8_t finalizer[] = {0,0,1,0xb4}; */
427 /* mpeg2_decode_data (mpeg2dec, finalizer, finalizer+4); */
428
429 mpeg2_free (mpeg2dec->chunk_buffer);
430 if (!mpeg2dec->custom_fbuf)
431 for (i = mpeg2dec->alloc_index_user; i < mpeg2dec->alloc_index; i++)
432 mpeg2_free (mpeg2dec->fbuf_alloc[i].fbuf.buf[0]);
433 if (mpeg2dec->convert_start)
434 for (i = 0; i < 3; i++)
435 mpeg2_free (mpeg2dec->yuv_buf[i][0]);
436 if (mpeg2dec->convert_id)
437 mpeg2_free (mpeg2dec->convert_id);
438 mpeg2_free (mpeg2dec);
439 }