开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 流媒体/Mpeg4/MP4 > 查看源码
slice.c
资源名称：NETVIDEO.rar　[点击查看]
上传用户：sun1608
上传日期：2007-02-02
资源大小：6116k
文件大小：21k
源码类别：

流媒体/Mpeg4/MP4

开发平台：

Visual C++

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