?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
r123: Merged HEAD and TEST. New stuff shall be committed to HEAD from now on.
[cinelerra_cv/mob.git] / libmpeg3 / video / slice.c
blob5d66e94d734780eb72bcef246dc0bb36ff01388f
1 #include "mpeg3private.h"
2 #include "mpeg3protos.h"
3
4 #include <pthread.h>
5 #include <stdlib.h>
6
7 #define CLIP(x) ((x) >= 0 ? ((x) < 255 ? (x) : 255) : 0)
8
9 static unsigned long long MMX_128 = 0x80008000800080LL;
10
11 int mpeg3_new_slice_buffer(mpeg3_slice_buffer_t *slice_buffer)
12 {
13 pthread_mutexattr_t mutex_attr;
14
15 slice_buffer->data = malloc(1024);
16 slice_buffer->buffer_size = 0;
17 slice_buffer->buffer_allocation = 1024;
18 slice_buffer->current_position = 0;
19 slice_buffer->bits_size = 0;
20 slice_buffer->bits = 0;
21 slice_buffer->done = 0;
22 pthread_mutexattr_init(&mutex_attr);
23 // pthread_mutexattr_setkind_np(&mutex_attr, PTHREAD_MUTEX_FAST_NP);
24 pthread_mutex_init(&(slice_buffer->completion_lock), &mutex_attr);
25 return 0;
26 }
27
28 int mpeg3_delete_slice_buffer(mpeg3_slice_buffer_t *slice_buffer)
29 {
30 free(slice_buffer->data);
31 pthread_mutex_destroy(&(slice_buffer->completion_lock));
32 return 0;
33 }
34
35 int mpeg3_expand_slice_buffer(mpeg3_slice_buffer_t *slice_buffer)
36 {
37 int i;
38 unsigned char *new_buffer = malloc(slice_buffer->buffer_allocation * 2);
39 for(i = 0; i < slice_buffer->buffer_size; i++)
40 new_buffer[i] = slice_buffer->data[i];
41 free(slice_buffer->data);
42 slice_buffer->data = new_buffer;
43 slice_buffer->buffer_allocation *= 2;
44 return 0;
45 }
46
47 /* limit coefficients to -2048..2047 */
48
49 /* move/add 8x8-Block from block[comp] to refframe */
50
51 static inline int mpeg3video_addblock(mpeg3_slice_t *slice,
52 mpeg3video_t *video,
53 int comp,
54 int bx,
55 int by,
56 int dct_type,
57 int addflag)
58 {
59 int cc, i, iincr;
60 unsigned char *rfp;
61 short *bp;
62 int spar = slice->sparse[comp];
63 /* color component index */
64 cc = (comp < 4) ? 0 : (comp & 1) + 1;
65
66 if(cc == 0)
67 {
68 /* luminance */
69 if(video->pict_struct == FRAME_PICTURE)
70 {
71 if(dct_type)
72 {
73 /* field DCT coding */
74 rfp = video->newframe[0] +
75 video->coded_picture_width * (by + ((comp & 2) >> 1)) + bx + ((comp & 1) << 3);
76 iincr = (video->coded_picture_width << 1);
77 }
78 else
79 {
80 /* frame DCT coding */
81 rfp = video->newframe[0] +
82 video->coded_picture_width * (by + ((comp & 2) << 2)) + bx + ((comp & 1) << 3);
83 iincr = video->coded_picture_width;
84 }
85 }
86 else
87 {
88 /* field picture */
89 rfp = video->newframe[0] +
90 (video->coded_picture_width << 1) * (by + ((comp & 2) << 2)) + bx + ((comp & 1) << 3);
91 iincr = (video->coded_picture_width << 1);
92 }
93 }
94 else
95 {
96 /* chrominance */
97
98 /* scale coordinates */
99 if(video->chroma_format != CHROMA444) bx >>= 1;
100 if(video->chroma_format == CHROMA420) by >>= 1;
101 if(video->pict_struct == FRAME_PICTURE)
102 {
103 if(dct_type && (video->chroma_format != CHROMA420))
104 {
105 /* field DCT coding */
106 rfp = video->newframe[cc]
107 + video->chrom_width * (by + ((comp & 2) >> 1)) + bx + (comp & 8);
108 iincr = (video->chrom_width << 1);
109 }
110 else
111 {
112 /* frame DCT coding */
113 rfp = video->newframe[cc]
114 + video->chrom_width * (by + ((comp & 2) << 2)) + bx + (comp & 8);
115 iincr = video->chrom_width;
116 }
117 }
118 else
119 {
120 /* field picture */
121 rfp = video->newframe[cc]
122 + (video->chrom_width << 1) * (by + ((comp & 2) << 2)) + bx + (comp & 8);
123 iincr = (video->chrom_width << 1);
124 }
125 }
126
127 bp = slice->block[comp];
128
129 if(addflag)
130 {
131 #ifdef HAVE_MMX
132 if(video->have_mmx)
133 {
134 if(spar)
135 {
136 __asm__ __volatile__(
137 "movq (%2), %%mm6\n" /* 4 blockvals */
138 "pxor %%mm4, %%mm4\n"
139 "punpcklwd %%mm6, %%mm6\n"
140 "punpcklwd %%mm6, %%mm6\n"
141 ".align 8\n"
142 "1:"
143 "movq (%1), %%mm0\n" /* 8 rindex1 */
144 "movq %%mm0, %%mm2\n"
145 "punpcklbw %%mm4, %%mm0\n"
146 "punpckhbw %%mm4, %%mm2\n"
147 "paddw %%mm6, %%mm0\n"
148 "paddw %%mm6, %%mm2\n"
149
150 "packuswb %%mm2, %%mm0\n"
151 "movq %%mm0, (%1)\n"
152
153 "leal (%1, %3), %1\n"
154 "loop 1b\n"
155 : /* scr dest */
156 : "c" (8),"r" (rfp), "r" (bp), "r" (iincr)
157 );
158 }
159 else
160 {
161 __asm__ __volatile__(
162 "pxor %%mm4, %%mm4\n"
163
164 ".align 8\n"
165 "1:"
166 "movq (%2), %%mm0\n" /* 8 rfp 0 1 2 3 4 5 6 7*/
167 "movq (%1), %%mm6\n" /* 4 blockvals 0 1 2 3 */
168
169 "movq %%mm0, %%mm2\n"
170 "movq 8(%1), %%mm5\n" /* 4 blockvals 0 1 2 3 */
171 "punpcklbw %%mm4, %%mm0\n" /* 0 2 4 6 */
172 "punpckhbw %%mm4, %%mm2\n" /* 1 3 5 7 */
173
174 "paddw %%mm6, %%mm0\n"
175 "paddw %%mm5, %%mm2\n"
176 "packuswb %%mm2, %%mm0\n"
177
178 "addl $16, %1\n"
179 "movq %%mm0, (%2)\n"
180
181 "leal (%2,%3), %2\n"
182 "loop 1b\n"
183 : /* scr dest */
184 : "c" (8),"r" (bp), "r" (rfp), "r" (iincr)
185 );
186 }
187 }
188 else
189 #endif
190 for(i = 0; i < 8; i++)
191 {
192 rfp[0] = CLIP(bp[0] + rfp[0]);
193 rfp[1] = CLIP(bp[1] + rfp[1]);
194 rfp[2] = CLIP(bp[2] + rfp[2]);
195 rfp[3] = CLIP(bp[3] + rfp[3]);
196 rfp[4] = CLIP(bp[4] + rfp[4]);
197 rfp[5] = CLIP(bp[5] + rfp[5]);
198 rfp[6] = CLIP(bp[6] + rfp[6]);
199 rfp[7] = CLIP(bp[7] + rfp[7]);
200 rfp += iincr;
201 bp += 8;
202 }
203 }
204 else
205 {
206 #ifdef HAVE_MMX
207 if(video->have_mmx)
208 {
209 if(spar)
210 {
211 __asm__ __volatile__(
212 "movd (%2), %%mm0\n" /* " 0 0 0 v1" */
213 "punpcklwd %%mm0, %%mm0\n" /* " 0 0 v1 v1" */
214 "punpcklwd %%mm0, %%mm0\n"
215 "paddw MMX_128, %%mm0\n"
216 "packuswb %%mm0, %%mm0\n"
217 "leal (%0,%1,2), %%eax\n"
218
219 "movq %%mm0, (%0, %1)\n"
220 "movq %%mm0, (%%eax)\n"
221 "leal (%%eax,%1,2), %0\n"
222 "movq %%mm0, (%%eax, %1)\n"
223
224 "movq %%mm0, (%0)\n"
225 "leal (%0,%1,2), %%eax\n"
226 "movq %%mm0, (%0, %1)\n"
227
228 "movq %%mm0, (%%eax)\n"
229 "movq %%mm0, (%%eax, %1)\n"
230 :
231 : "D" (rfp), "c" (iincr), "b" (bp)
232 : "eax");
233 }
234 else
235 {
236 __asm__ __volatile__(
237 "movq MMX_128,%%mm4\n"
238 ".align 8\n"
239 "1:"
240 "movq (%1), %%mm0\n"
241 "movq 8(%1), %%mm1\n"
242 "paddw %%mm4, %%mm0\n"
243
244 "movq 16(%1), %%mm2\n"
245 "paddw %%mm4, %%mm1\n"
246
247 "movq 24(%1), %%mm3\n"
248 "paddw %%mm4, %%mm2\n"
249
250 "packuswb %%mm1, %%mm0\n"
251 "paddw %%mm4, %%mm3\n"
252
253 "addl $32, %1\n"
254 "packuswb %%mm3, %%mm2\n"
255
256 "movq %%mm0, (%2)\n"
257
258 "movq %%mm2, (%2,%3)\n"
259
260 "leal (%2,%3,2), %2\n"
261 "loop 1b\n"
262 :
263 : "c" (4), "r" (bp), "r" (rfp), "r" (iincr)
264 );
265 }
266 }
267 else
268 #endif
269 for(i = 0; i < 8; i++)
270 {
271 rfp[0] = CLIP(bp[0] + 128);
272 rfp[1] = CLIP(bp[1] + 128);
273 rfp[2] = CLIP(bp[2] + 128);
274 rfp[3] = CLIP(bp[3] + 128);
275 rfp[4] = CLIP(bp[4] + 128);
276 rfp[5] = CLIP(bp[5] + 128);
277 rfp[6] = CLIP(bp[6] + 128);
278 rfp[7] = CLIP(bp[7] + 128);
279 rfp+= iincr;
280 bp += 8;
281 }
282 }
283 return 0;
284 }
285
286 int mpeg3_decode_slice(mpeg3_slice_t *slice)
287 {
288 mpeg3video_t *video = slice->video;
289 int comp;
290 int mb_type, cbp, motion_type = 0, dct_type;
291 int macroblock_address, mba_inc, mba_max;
292 int slice_vert_pos_ext;
293 unsigned int code;
294 int bx, by;
295 int dc_dct_pred[3];
296 int mv_count, mv_format, mvscale;
297 int pmv[2][2][2], mv_field_sel[2][2];
298 int dmv, dmvector[2];
299 int qs;
300 int stwtype, stwclass;
301 int snr_cbp;
302 int i;
303 mpeg3_slice_buffer_t *slice_buffer = slice->slice_buffer;
304
305 /* number of macroblocks per picture */
306 mba_max = video->mb_width * video->mb_height;
307
308 /* field picture has half as many macroblocks as frame */
309 if(video->pict_struct != FRAME_PICTURE)
310 mba_max >>= 1;
311
312 /* macroblock address */
313 macroblock_address = 0;
314 /* first macroblock in slice is not skipped */
315 mba_inc = 0;
316 slice->fault = 0;
317
318 code = mpeg3slice_getbits(slice_buffer, 32);
319 /* decode slice header (may change quant_scale) */
320 slice_vert_pos_ext = mpeg3video_getslicehdr(slice, video);
321
322 /* reset all DC coefficient and motion vector predictors */
323 dc_dct_pred[0] = dc_dct_pred[1] = dc_dct_pred[2] = 0;
324 pmv[0][0][0] = pmv[0][0][1] = pmv[1][0][0] = pmv[1][0][1] = 0;
325 pmv[0][1][0] = pmv[0][1][1] = pmv[1][1][0] = pmv[1][1][1] = 0;
326
327 for(i = 0;
328 slice_buffer->current_position < slice_buffer->buffer_size;
329 i++)
330 {
331 if(mba_inc == 0)
332 {
333 /* Done */
334 if(!mpeg3slice_showbits(slice_buffer, 23)) return 0;
335 /* decode macroblock address increment */
336 mba_inc = mpeg3video_get_macroblock_address(slice);
337
338 if(slice->fault) return 1;
339
340 if(i == 0)
341 {
342 /* Get the macroblock_address */
343 macroblock_address = ((slice_vert_pos_ext << 7) + (code & 255) - 1) * video->mb_width + mba_inc - 1;
344 /* first macroblock in slice: not skipped */
345 mba_inc = 1;
346 }
347 }
348
349 if(slice->fault) return 1;
350
351 if(macroblock_address >= mba_max)
352 {
353 /* mba_inc points beyond picture dimensions */
354 /*fprintf(stderr, "mpeg3_decode_slice: too many macroblocks in picture\n"); */
355 return 1;
356 }
357
358 /* not skipped */
359 if(mba_inc == 1)
360 {
361 mpeg3video_macroblock_modes(slice,
362 video,
363 &mb_type,
364 &stwtype,
365 &stwclass,
366 &motion_type,
367 &mv_count,
368 &mv_format,
369 &dmv,
370 &mvscale,
371 &dct_type);
372
373 if(slice->fault) return 1;
374
375 if(mb_type & MB_QUANT)
376 {
377 qs = mpeg3slice_getbits(slice_buffer, 5);
378
379 if(video->mpeg2)
380 slice->quant_scale = video->qscale_type ? mpeg3_non_linear_mquant_table[qs] : (qs << 1);
381 else
382 slice->quant_scale = qs;
383
384 if(video->scalable_mode == SC_DP)
385 /* make sure quant_scale is valid */
386 slice->quant_scale = slice->quant_scale;
387 }
388
389 /* motion vectors */
390
391
392 /* decode forward motion vectors */
393 if((mb_type & MB_FORWARD) || ((mb_type & MB_INTRA) && video->conceal_mv))
394 {
395 if(video->mpeg2)
396 mpeg3video_motion_vectors(slice,
397 video,
398 pmv,
399 dmvector,
400 mv_field_sel,
401 0,
402 mv_count,
403 mv_format,
404 video->h_forw_r_size,
405 video->v_forw_r_size,
406 dmv,
407 mvscale);
408 else
409 mpeg3video_motion_vector(slice,
410 video,
411 pmv[0][0],
412 dmvector,
413 video->forw_r_size,
414 video->forw_r_size,
415 0,
416 0,
417 video->full_forw);
418 }
419 if(slice->fault) return 1;
420
421 /* decode backward motion vectors */
422 if(mb_type & MB_BACKWARD)
423 {
424 if(video->mpeg2)
425 mpeg3video_motion_vectors(slice,
426 video,
427 pmv,
428 dmvector,
429 mv_field_sel,
430 1,
431 mv_count,
432 mv_format,
433 video->h_back_r_size,
434 video->v_back_r_size,
435 0,
436 mvscale);
437 else
438 mpeg3video_motion_vector(slice,
439 video,
440 pmv[0][1],
441 dmvector,
442 video->back_r_size,
443 video->back_r_size,
444 0,
445 0,
446 video->full_back);
447 }
448
449 if(slice->fault) return 1;
450
451 /* remove marker_bit */
452 if((mb_type & MB_INTRA) && video->conceal_mv)
453 mpeg3slice_flushbit(slice_buffer);
454
455 /* macroblock_pattern */
456 if(mb_type & MB_PATTERN)
457 {
458 cbp = mpeg3video_get_cbp(slice);
459 if(video->chroma_format == CHROMA422)
460 {
461 /* coded_block_pattern_1 */
462 cbp = (cbp << 2) | mpeg3slice_getbits2(slice_buffer);
463 }
464 else
465 if(video->chroma_format == CHROMA444)
466 {
467 /* coded_block_pattern_2 */
468 cbp = (cbp << 6) | mpeg3slice_getbits(slice_buffer, 6);
469 }
470 }
471 else
472 cbp = (mb_type & MB_INTRA) ? ((1 << video->blk_cnt) - 1) : 0;
473
474 if(slice->fault) return 1;
475 /* decode blocks */
476 mpeg3video_clearblock(slice, 0, video->blk_cnt);
477 for(comp = 0; comp < video->blk_cnt; comp++)
478 {
479 if(cbp & (1 << (video->blk_cnt - comp - 1)))
480 {
481 if(mb_type & MB_INTRA)
482 {
483 if(video->mpeg2)
484 mpeg3video_getmpg2intrablock(slice, video, comp, dc_dct_pred);
485 else
486 mpeg3video_getintrablock(slice, video, comp, dc_dct_pred);
487 }
488 else
489 {
490 if(video->mpeg2)
491 mpeg3video_getmpg2interblock(slice, video, comp);
492 else
493 mpeg3video_getinterblock(slice, video, comp);
494 }
495 if(slice->fault) return 1;
496 }
497 }
498
499 /* reset intra_dc predictors */
500 if(!(mb_type & MB_INTRA))
501 dc_dct_pred[0] = dc_dct_pred[1] = dc_dct_pred[2] = 0;
502
503 /* reset motion vector predictors */
504 if((mb_type & MB_INTRA) && !video->conceal_mv)
505 {
506 /* intra mb without concealment motion vectors */
507 pmv[0][0][0] = pmv[0][0][1] = pmv[1][0][0] = pmv[1][0][1] = 0;
508 pmv[0][1][0] = pmv[0][1][1] = pmv[1][1][0] = pmv[1][1][1] = 0;
509 }
510
511 if((video->pict_type == P_TYPE) && !(mb_type & (MB_FORWARD | MB_INTRA)))
512 {
513 /* non-intra mb without forward mv in a P picture */
514 pmv[0][0][0] = pmv[0][0][1] = pmv[1][0][0] = pmv[1][0][1] = 0;
515
516 /* derive motion_type */
517 if(video->pict_struct == FRAME_PICTURE)
518 motion_type = MC_FRAME;
519 else
520 {
521 motion_type = MC_FIELD;
522 /* predict from field of same parity */
523 mv_field_sel[0][0] = (video->pict_struct == BOTTOM_FIELD);
524 }
525 }
526
527 if(stwclass == 4)
528 {
529 /* purely spatially predicted macroblock */
530 pmv[0][0][0] = pmv[0][0][1] = pmv[1][0][0] = pmv[1][0][1] = 0;
531 pmv[0][1][0] = pmv[0][1][1] = pmv[1][1][0] = pmv[1][1][1] = 0;
532 }
533 }
534 else
535 {
536 /* mba_inc!=1: skipped macroblock */
537 mpeg3video_clearblock(slice, 0, video->blk_cnt);
538
539 /* reset intra_dc predictors */
540 dc_dct_pred[0] = dc_dct_pred[1] = dc_dct_pred[2] = 0;
541
542 /* reset motion vector predictors */
543 if(video->pict_type == P_TYPE)
544 pmv[0][0][0] = pmv[0][0][1] = pmv[1][0][0] = pmv[1][0][1] = 0;
545
546 /* derive motion_type */
547 if(video->pict_struct == FRAME_PICTURE)
548 motion_type = MC_FRAME;
549 else
550 {
551 motion_type = MC_FIELD;
552 /* predict from field of same parity */
553 mv_field_sel[0][0] = mv_field_sel[0][1] = (video->pict_struct == BOTTOM_FIELD);
554 }
555
556 /* skipped I are spatial-only predicted, */
557 /* skipped P and B are temporal-only predicted */
558 stwtype = (video->pict_type == I_TYPE) ? 8 : 0;
559
560 /* clear MB_INTRA */
561 mb_type &= ~MB_INTRA;
562
563 /* no block data */
564 cbp = 0;
565 }
566
567 snr_cbp = 0;
568
569 /* pixel coordinates of top left corner of current macroblock */
570 bx = 16 * (macroblock_address % video->mb_width);
571 by = 16 * (macroblock_address / video->mb_width);
572
573 /* motion compensation */
574 if(!(mb_type & MB_INTRA))
575 mpeg3video_reconstruct(video,
576 bx,
577 by,
578 mb_type,
579 motion_type,
580 pmv,
581 mv_field_sel,
582 dmvector,
583 stwtype);
584
585 /* copy or add block data into picture */
586 for(comp = 0; comp < video->blk_cnt; comp++)
587 {
588 if((cbp | snr_cbp) & (1 << (video->blk_cnt - 1 - comp)))
589 {
590 #ifdef HAVE_MMX
591 if(video->have_mmx)
592 IDCT_mmx(slice->block[comp]);
593 else
594 #endif
595 mpeg3video_idct_conversion(slice->block[comp]);
596
597 mpeg3video_addblock(slice,
598 video,
599 comp,
600 bx,
601 by,
602 dct_type,
603 (mb_type & MB_INTRA) == 0);
604 }
605 }
606
607 /* advance to next macroblock */
608 macroblock_address++;
609 mba_inc--;
610 }
611
612 return 0;
613 }
614
615 void mpeg3_slice_loop(mpeg3_slice_t *slice)
616 {
617 mpeg3video_t *video = slice->video;
618 int result = 1;
619
620 while(!slice->done)
621 {
622 pthread_mutex_lock(&(slice->input_lock));
623
624 if(!slice->done)
625 {
626 /* Get a buffer to decode */
627 result = 1;
628 pthread_mutex_lock(&(video->slice_lock));
629 if(slice->buffer_step > 0)
630 {
631 while(slice->current_buffer <= slice->last_buffer)
632 {
633 if(!video->slice_buffers[slice->current_buffer].done &&
634 slice->current_buffer <= slice->last_buffer)
635 {
636 result = 0;
637 break;
638 }
639 slice->current_buffer += slice->buffer_step;
640 }
641 }
642 else
643 {
644 while(slice->current_buffer >= slice->last_buffer)
645 {
646 if(!video->slice_buffers[slice->current_buffer].done &&
647 slice->current_buffer >= slice->last_buffer)
648 {
649 result = 0;
650 break;
651 }
652 slice->current_buffer += slice->buffer_step;
653 }
654 }
655
656 /* Got one */
657 if(!result && slice->current_buffer >= 0 && slice->current_buffer < video->total_slice_buffers)
658 {
659 slice->slice_buffer = &(video->slice_buffers[slice->current_buffer]);
660 slice->slice_buffer->done = 1;
661 pthread_mutex_unlock(&(video->slice_lock));
662 pthread_mutex_unlock(&(slice->input_lock));
663 mpeg3_decode_slice(slice);
664 pthread_mutex_unlock(&(slice->slice_buffer->completion_lock));
665 }
666 else
667 /* Finished with all */
668 {
669 pthread_mutex_unlock(&(slice->completion_lock));
670 pthread_mutex_unlock(&(video->slice_lock));
671 }
672 }
673
674 pthread_mutex_unlock(&(slice->output_lock));
675 }
676 }
677
678 int mpeg3_new_slice_decoder(void *video, mpeg3_slice_t *slice)
679 {
680 pthread_attr_t attr;
681 pthread_mutexattr_t mutex_attr;
682
683 slice->video = video;
684 slice->done = 0;
685 pthread_mutexattr_init(&mutex_attr);
686 // pthread_mutexattr_setkind_np(&mutex_attr, PTHREAD_MUTEX_FAST_NP);
687 pthread_mutex_init(&(slice->input_lock), &mutex_attr);
688 pthread_mutex_lock(&(slice->input_lock));
689 pthread_mutex_init(&(slice->output_lock), &mutex_attr);
690 pthread_mutex_lock(&(slice->output_lock));
691 pthread_mutex_init(&(slice->completion_lock), &mutex_attr);
692 pthread_mutex_lock(&(slice->completion_lock));
693
694 pthread_attr_init(&attr);
695 pthread_create(&(slice->tid), &attr, (void*)mpeg3_slice_loop, slice);
696
697 return 0;
698 }
699
700 int mpeg3_delete_slice_decoder(mpeg3_slice_t *slice)
701 {
702 slice->done = 1;
703 pthread_mutex_unlock(&(slice->input_lock));
704 pthread_join(slice->tid, 0);
705 pthread_mutex_destroy(&(slice->input_lock));
706 pthread_mutex_destroy(&(slice->output_lock));
707 return 0;
708 }
mob repository