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

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

流媒体/Mpeg4/MP4

开发平台：

Visual C++

getpicture.c：源码内容
  1. #include "../mpeg3private.h"
  2. #include "mpeg3video.h"
  3. #include "vlc.h"
  5. #include <stdio.h>
  6. #include <stdlib.h>
  7. #include <string.h>
  9. int mpeg3video_get_cbp(mpeg3_slice_t *slice)
  10. {
  11.    int code;
  12. mpeg3_slice_buffer_t *slice_buffer = slice->slice_buffer;
  14.    if((code = mpeg3slice_showbits9(slice_buffer)) >= 128)
  15. {
  16.      code >>= 4;
  17.      mpeg3slice_flushbits(slice_buffer, mpeg3_CBPtab0[code].len);
  18.      return mpeg3_CBPtab0[code].val;
  19.    }
  21.    if(code >= 8)
  22. {
  23.      code >>= 1;
  24.      mpeg3slice_flushbits(slice_buffer, mpeg3_CBPtab1[code].len);
  25.      return mpeg3_CBPtab1[code].val;
  26.    }
  28.    if(code < 1)
  29. {
  30. /*     fprintf(stderr,"mpeg3video_get_cbp: invalid coded_block_pattern coden"); */
  31.      slice->fault = 1;
  32.      return 0;
  33.    }
  35.    mpeg3slice_flushbits(slice_buffer, mpeg3_CBPtab2[code].len);
  36.    return mpeg3_CBPtab2[code].val;
  37. }
  40. /* set block to zero */
  41. int mpeg3video_clearblock(mpeg3_slice_t *slice, int comp, int size)
  42. {
  43. slice->sparse[comp] = 1;
  45. /* Compiler error with 2.95 required hard coding the size to 6 */
  47. memset(slice->block[comp], 0, sizeof(short) * 64 * size);
  48. return 0;
  49. }
  51. static __inline int mpeg3video_getdclum(mpeg3_slice_buffer_t *slice_buffer)
  52. {
  53. int code, size, val;
  54. /* decode length */
  55. code = mpeg3slice_showbits5(slice_buffer);
  57. if(code < 31)
  58. {
  59.      size = mpeg3_DClumtab0[code].val;
  60.      mpeg3slice_flushbits(slice_buffer, mpeg3_DClumtab0[code].len);
  61. }
  62. else 
  63. {
  64.      code = mpeg3slice_showbits9(slice_buffer) - 0x1f0;
  65.      size = mpeg3_DClumtab1[code].val;
  66.      mpeg3slice_flushbits(slice_buffer, mpeg3_DClumtab1[code].len);
  67. }
  69. if(size == 0) val = 0;
  70. else 
  71. {
  72.      val = mpeg3slice_getbits(slice_buffer, size);
  73.      if((val & (1 << (size - 1))) == 0)  val -= (1 << size) - 1;
  74. }
  76. return val;
  77. }
  80. int mpeg3video_getdcchrom(mpeg3_slice_buffer_t *slice_buffer)
  81. {
  82. int code, size, val;
  84. /* decode length */
  85. code = mpeg3slice_showbits5(slice_buffer);
  87. if(code < 31)
  88. {
  89.      size = mpeg3_DCchromtab0[code].val;
  90.      mpeg3slice_flushbits(slice_buffer, mpeg3_DCchromtab0[code].len);
  91. }
  92. else 
  93. {
  94.      code = mpeg3slice_showbits(slice_buffer, 10) - 0x3e0;
  95.      size = mpeg3_DCchromtab1[code].val;
  96.      mpeg3slice_flushbits(slice_buffer, mpeg3_DCchromtab1[code].len);
  97. }
  99. if(size == 0) val = 0;
  100. else 
  101. {
  102.       val = mpeg3slice_getbits(slice_buffer, size);
  103.       if((val & (1 << (size - 1))) == 0) val -= (1 << size) - 1;
  104. }
  106. return val;
  107. }
  110. /* decode one intra coded MPEG-1 block */
  112. int mpeg3video_getintrablock(mpeg3_slice_t *slice, 
  113. mpeg3video_t *video,
  114. int comp, 
  115. int dc_dct_pred[])
  116. {
  117. int val, i, j, sign;
  118. unsigned int code;
  119. mpeg3_DCTtab_t *tab = 0;
  120. short *bp = slice->block[comp];
  121. mpeg3_slice_buffer_t *slice_buffer = slice->slice_buffer;
  123. /* decode DC coefficients */
  124.    if(comp < 4)         
  125.    bp[0] = (dc_dct_pred[0] += mpeg3video_getdclum(slice_buffer)) << 3;
  126.    else 
  127.    if(comp == 4)   
  128.    bp[0] = (dc_dct_pred[1] += mpeg3video_getdcchrom(slice_buffer)) << 3;
  129. else                
  130.    bp[0] = (dc_dct_pred[2] += mpeg3video_getdcchrom(slice_buffer)) << 3;
  132. #ifdef HAVE_MMX
  133. if(video->have_mmx)
  134.    bp[0] <<= 4;
  135. #endif
  137.    if(slice->fault) return 1;
  139. /* decode AC coefficients */
  140.    for(i = 1; ; i++)
  141. {
  142.      code = mpeg3slice_showbits16(slice_buffer);
  143.      if(code >= 16384)
  144. tab = &mpeg3_DCTtabnext[(code >> 12) - 4];
  145.      else 
  146. if(code >= 1024) tab = &mpeg3_DCTtab0[(code >> 8) - 4];
  147.      else 
  148. if(code >= 512) tab = &mpeg3_DCTtab1[(code >> 6) - 8];
  149.      else 
  150. if(code >= 256) tab = &mpeg3_DCTtab2[(code >> 4) - 16];
  151.      else 
  152. if(code >= 128) tab = &mpeg3_DCTtab3[(code >> 3) - 16];
  153.      else 
  154. if(code >= 64) tab = &mpeg3_DCTtab4[(code >> 2) - 16];
  155.      else 
  156. if(code >= 32) tab = &mpeg3_DCTtab5[(code >> 1) - 16];
  157.      else 
  158. if(code >= 16) tab = &mpeg3_DCTtab6[code - 16];
  159.      else 
  160. {
  161. /*        fprintf(stderr, "mpeg3video_getintrablock: invalid Huffman coden"); */
  162.         slice->fault = 1;
  163.         return 0;
  164.      }
  166.      mpeg3slice_flushbits(slice_buffer, tab->len);
  168.      if(tab->run == 64) break;  /* end_of_block */
  170.      if(tab->run == 65)
  171. {
  172. /* escape */
  173.      i += mpeg3slice_getbits(slice_buffer, 6);
  175.      if((val = mpeg3slice_getbits(slice_buffer, 8)) == 0) 
  176. val = mpeg3slice_getbits(slice_buffer, 8);
  177.      else 
  178. if(val == 128)         
  179. val = mpeg3slice_getbits(slice_buffer, 8) - 256;
  180.      else 
  181. if(val > 128)          
  182. val -= 256;
  184.      if((sign = (val < 0)) != 0) val= -val;
  185.      }
  186.      else 
  187. {
  188.      i += tab->run;
  189.      val = tab->level;
  190.      sign = mpeg3slice_getbit(slice_buffer);
  191.      }
  193. if(i < 64)
  194.      j = video->mpeg3_zigzag_scan_table[i];
  195. else
  196. {
  197.         slice->fault = 1;
  198.         return 0;
  199. }
  202. #ifdef HAVE_MMX
  203. if(video->have_mmx)
  204. {
  205.      val = (val * slice->quant_scale * video->intra_quantizer_matrix[j]) << 1;
  206.      val = (val - 16) | 16;
  207. }
  208. else
  209. #endif
  210. {
  211.      val = (val * slice->quant_scale * video->intra_quantizer_matrix[j]) >> 3;
  212.      val = (val - 1) | 1;
  213. }
  215.      bp[j] = sign ? -val : val;
  216. }
  218. if(j != 0) 
  219. {
  220. /* not a sparse matrix ! */
  221.        slice->sparse[comp] = 0;
  222. }
  223. return 0;
  224. }
  227. /* decode one non-intra coded MPEG-1 block */
  229. int mpeg3video_getinterblock(mpeg3_slice_t *slice, 
  230. mpeg3video_t *video, 
  231. int comp)
  232. {
  233. int val, i, j, sign;
  234. unsigned int code;
  235. mpeg3_DCTtab_t *tab; 
  236. short *bp = slice->block[comp];
  237. mpeg3_slice_buffer_t *slice_buffer = slice->slice_buffer;
  239. /* decode AC coefficients */
  240. for(i = 0; ; i++)
  241. {
  242.      code = mpeg3slice_showbits16(slice_buffer);
  243.      if(code >= 16384)
  244. {
  245.          if(i == 0) 
  246. tab = &mpeg3_DCTtabfirst[(code >> 12) - 4];
  247.          else      
  248. tab = &mpeg3_DCTtabnext[(code >> 12) - 4];
  249.      }
  250.      else 
  251. if(code >= 1024) tab = &mpeg3_DCTtab0[(code >> 8) - 4];
  252.      else 
  253. if(code >= 512)  tab = &mpeg3_DCTtab1[(code >> 6) - 8];
  254.      else 
  255. if(code >= 256)  tab = &mpeg3_DCTtab2[(code >> 4) - 16];
  256.      else 
  257. if(code >= 128)  tab = &mpeg3_DCTtab3[(code >> 3) - 16];
  258.      else 
  259. if(code >= 64)   tab = &mpeg3_DCTtab4[(code >> 2) - 16];
  260.      else 
  261. if(code >= 32)   tab = &mpeg3_DCTtab5[(code >> 1) - 16];
  262.      else 
  263. if(code >= 16)   tab = &mpeg3_DCTtab6[code - 16];
  264.      else 
  265. {
  266. // invalid Huffman code
  267.      slice->fault = 1;
  268.      return 1;
  269.      }
  271.      mpeg3slice_flushbits(slice_buffer, tab->len);
  273. /* end of block */
  274.      if(tab->run == 64)
  275.         break;   
  277.      if(tab->run == 65)
  278. {          
  279. /* escape  */
  280.      i += mpeg3slice_getbits(slice_buffer, 6);
  281.      if((val = mpeg3slice_getbits(slice_buffer, 8)) == 0) 
  282. val = mpeg3slice_getbits(slice_buffer, 8);
  283.      else 
  284. if(val == 128)  
  285. val = mpeg3slice_getbits(slice_buffer, 8) - 256;
  286.      else 
  287. if(val > 128) 
  288. val -= 256;
  290.      if((sign = (val < 0)) != 0) val = -val;
  291.      }
  292.      else 
  293. {
  294.      i += tab->run;
  295.      val = tab->level;
  296.      sign = mpeg3slice_getbit(slice_buffer);
  297.      }
  299.      j = video->mpeg3_zigzag_scan_table[i];
  301. #ifdef HAVE_MMX
  302. if(video->have_mmx)
  303. {
  304.      val = (((val << 1)+1) * slice->quant_scale * video->non_intra_quantizer_matrix[j]);
  305.      val = (val - 16) | 16;
  306. }
  307. else
  308. #endif
  309. {
  310.      val = (((val << 1)+1) * slice->quant_scale * video->non_intra_quantizer_matrix[j]) >> 4;
  311.      val = (val - 1) | 1;
  312. }
  314.      bp[j] = sign ? -val : val;
  315. }
  317. if(j != 0) 
  318. {
  319. /* not a sparse matrix ! */
  320.        slice->sparse[comp] = 0;
  321. }
  322. return 0;
  323. }
  326. /* decode one intra coded MPEG-2 block */
  327. int mpeg3video_getmpg2intrablock(mpeg3_slice_t *slice, 
  328. mpeg3video_t *video, 
  329. int comp, 
  330. int dc_dct_pred[])
  331. {
  332. int val, i, j, sign, nc;
  333. unsigned int code;
  334. mpeg3_DCTtab_t *tab;
  335. short *bp;
  336. int *qmat;
  337. mpeg3_slice_buffer_t *slice_buffer = slice->slice_buffer;
  339. /* with data partitioning, data always goes to base layer */
  340.    bp = slice->block[comp];
  342.    qmat = (comp < 4 || video->chroma_format == CHROMA420)
  343.          ? video->intra_quantizer_matrix
  344.          : video->chroma_intra_quantizer_matrix;
  346. /* decode DC coefficients */
  347. if(comp < 4)           
  348. val = (dc_dct_pred[0] += mpeg3video_getdclum(slice_buffer));
  349. else 
  350. if((comp & 1) == 0) 
  351. val = (dc_dct_pred[1] += mpeg3video_getdcchrom(slice_buffer));
  352. else                  
  353. val = (dc_dct_pred[2] += mpeg3video_getdcchrom(slice_buffer));
  355.    if(slice->fault) return 0;
  356. #ifdef HAVE_MMX
  357. if(video->have_mmx)
  358.    bp[0] = val << (7 - video->dc_prec);
  359. else
  360. #endif
  361.    bp[0] = val << (3 - video->dc_prec);
  363.    nc = 0;
  365. /* decode AC coefficients */
  366.    for(i = 1; ; i++)
  367. {
  368.      code = mpeg3slice_showbits16(slice_buffer);
  370.      if(code >= 16384 && !video->intravlc)
  371. tab = &mpeg3_DCTtabnext[(code >> 12) - 4];
  372.      else 
  373. if(code >= 1024)
  374. {
  375.      if(video->intravlc) 
  376. tab = &mpeg3_DCTtab0a[(code >> 8) - 4];
  377.      else 
  378. tab = &mpeg3_DCTtab0[(code >> 8) - 4];
  379.      }
  380.      else 
  381. if(code >= 512)
  382. {
  383.      if(video->intravlc)     
  384.       tab = &mpeg3_DCTtab1a[(code >> 6) - 8];
  385.      else              
  386. tab = &mpeg3_DCTtab1[(code >> 6) - 8];
  387.      }
  388.      else 
  389. if(code >= 256) tab = &mpeg3_DCTtab2[(code >> 4) - 16];
  390.      else 
  391. if(code >= 128) tab = &mpeg3_DCTtab3[(code >> 3) - 16];
  392.      else 
  393. if(code >= 64)  tab = &mpeg3_DCTtab4[(code >> 2) - 16];
  394.      else 
  395. if(code >= 32)  tab = &mpeg3_DCTtab5[(code >> 1) - 16];
  396.      else 
  397. if(code >= 16)  tab = &mpeg3_DCTtab6[code - 16];
  398.      else 
  399. {
  400. /*     fprintf(stderr,"mpeg3video_getmpg2intrablock: invalid Huffman coden"); */
  401.      slice->fault = 1;
  402.      return 1;
  403.      }
  405.      mpeg3slice_flushbits(slice_buffer, tab->len);
  407. /* end_of_block */
  408.      if(tab->run == 64)
  409.          break; 
  411.      if(tab->run == 65)
  412. {
  413. /* escape */
  414.         i += mpeg3slice_getbits(slice_buffer, 6);
  416.         val = mpeg3slice_getbits(slice_buffer, 12);
  417.         if((val & 2047) == 0)
  418. {
  419. // invalid signed_level (escape)
  420.          slice->fault = 1;
  421.          return 0;
  422.         }
  423.         if((sign = (val >= 2048)) != 0) val = 4096 - val;
  424.      }
  425.      else 
  426. {
  427.      i += tab->run;
  428.      val = tab->level;
  429.      sign = mpeg3slice_getbit(slice_buffer);
  430.      }
  432.      j = (video->altscan ? video->mpeg3_alternate_scan_table : video->mpeg3_zigzag_scan_table)[i];
  434. #ifdef HAVE_MMX
  435. if(video->have_mmx)
  436.      val = (val * slice->quant_scale * qmat[j]);
  437. else
  438. #endif
  439.      val = (val * slice->quant_scale * qmat[j]) >> 4;
  441.      bp[j] = sign ? -val : val;
  442.      nc++;
  443. }
  445. if(j != 0)
  446. {
  447. /* not a sparse matrix ! */
  448.       slice->sparse[comp] = 0;
  449. }
  450. return 1;
  451. }
  454. /* decode one non-intra coded MPEG-2 block */
  456. int mpeg3video_getmpg2interblock(mpeg3_slice_t *slice, 
  457. mpeg3video_t *video, 
  458. int comp)
  459. {
  460. int val, i, j, sign, nc;
  461. unsigned int code;
  462. mpeg3_DCTtab_t *tab;
  463. short *bp;
  464. int *qmat;
  465. mpeg3_slice_buffer_t *slice_buffer = slice->slice_buffer;
  467. /* with data partitioning, data always goes to base layer */
  468.    bp = slice->block[comp];
  470.    qmat = (comp < 4 || video->chroma_format == CHROMA420)
  471.          ? video->non_intra_quantizer_matrix
  472.          : video->chroma_non_intra_quantizer_matrix;
  474.    nc = 0;
  476. /* decode AC coefficients */
  477.    for(i = 0; ; i++)
  478. {
  479.      code = mpeg3slice_showbits16(slice_buffer);
  480.      if(code >= 16384)
  481. {
  482.        if(i == 0) tab = &mpeg3_DCTtabfirst[(code >> 12) - 4];
  483.        else      tab = &mpeg3_DCTtabnext[(code >> 12) - 4];
  484.      }
  485.      else 
  486. if(code >= 1024) tab = &mpeg3_DCTtab0[(code >> 8) - 4];
  487.      else 
  488. if(code >= 512)  tab = &mpeg3_DCTtab1[(code >> 6) - 8];
  489.      else 
  490. if(code >= 256)  tab = &mpeg3_DCTtab2[(code >> 4) - 16];
  491.      else 
  492. if(code >= 128)  tab = &mpeg3_DCTtab3[(code >> 3) - 16];
  493.      else 
  494. if(code >= 64)   tab = &mpeg3_DCTtab4[(code >> 2) - 16];
  495.      else 
  496. if(code >= 32)   tab = &mpeg3_DCTtab5[(code >> 1) - 16];
  497.      else 
  498. if(code >= 16)   tab = &mpeg3_DCTtab6[code - 16];
  499.      else 
  500. {
  501. // invalid Huffman code
  502.      slice->fault = 1;
  503.      return 0;
  504.      }
  506.      mpeg3slice_flushbits(slice_buffer, tab->len);
  508. /* end_of_block */
  509.      if(tab->run == 64)
  510.         break;          
  512.      if(tab->run == 65)
  513. {                 
  514. /* escape */
  515.      i += mpeg3slice_getbits(slice_buffer, 6);
  516.      val = mpeg3slice_getbits(slice_buffer, 12);
  517.      if((val & 2047) == 0)
  518. {
  519. /*         fprintf(stderr, "mpeg3video_getmpg2interblock: invalid signed_level (escape)n"); */
  520.          slice->fault = 1;
  521.          return 1;
  522.      }
  523.      if((sign = (val >= 2048)) != 0) val = 4096 - val;
  524.      }
  525.      else 
  526. {
  527.      i += tab->run;
  528.      val = tab->level;
  529.      sign = mpeg3slice_getbit(slice_buffer);
  530.      }
  532.      j = (video->altscan ? video->mpeg3_alternate_scan_table : video->mpeg3_zigzag_scan_table)[i];
  534. #ifdef HAVE_MMX
  535.   if(video->have_mmx)
  536.      val = (((val << 1)+1) * slice->quant_scale * qmat[j]) >> 1;
  537. else
  538. #endif
  539.       val = (((val << 1)+1) * slice->quant_scale * qmat[j]) >> 5;
  541.      bp[j] = sign ? (-val) : val ;
  542.      nc++;
  543. }
  545. if(j != 0) 
  546. {
  547.        slice->sparse[comp] = 0;
  548. }
  549. return 0;
  550. }
  553. /* decode all macroblocks of the current picture */
  554. int mpeg3video_get_macroblocks(mpeg3video_t *video, int framenum)
  555. {
  556. unsigned int code;
  557. mpeg3_slice_buffer_t *slice_buffer; /* Buffer being loaded */
  558. int i;
  559. int current_buffer;
  560. mpeg3_bits_t *vstream = video->vstream;
  562. /* Load every slice into a buffer array */
  563. video->total_slice_buffers = 0;
  564. current_buffer = 0;
  565. while(!mpeg3bits_eof(vstream) && 
  566. mpeg3bits_showbits32_noptr(vstream) >= MPEG3_SLICE_MIN_START && 
  567. mpeg3bits_showbits32_noptr(vstream) <= MPEG3_SLICE_MAX_START &&
  568. video->total_slice_buffers < MPEG3_MAX_CPUS)
  569. {
  570. /* Initialize the buffer */
  571. if(current_buffer >= video->slice_buffers_initialized)
  572. mpeg3_new_slice_buffer(&(video->slice_buffers[video->slice_buffers_initialized++]));
  573. slice_buffer = &(video->slice_buffers[current_buffer]);
  574. slice_buffer->buffer_size = 0;
  575. slice_buffer->current_position = 0;
  576. slice_buffer->bits_size = 0;
  577. slice_buffer->done = 0;
  579. /* Read the slice into the buffer including the slice start code */
  580. do
  581. {
  582. /* Expand buffer */
  583. if(slice_buffer->buffer_allocation <= slice_buffer->buffer_size)
  584. mpeg3_expand_slice_buffer(slice_buffer);
  586. /* Load 1 char into buffer */
  587. slice_buffer->data[slice_buffer->buffer_size++] = mpeg3bits_getbyte_noptr(vstream);
  588. }while(!mpeg3bits_eof(vstream) &&
  589. mpeg3bits_showbits24_noptr(vstream) != MPEG3_PACKET_START_CODE_PREFIX);
  591. /* Pad the buffer to get the last macroblock */
  592. if(slice_buffer->buffer_allocation <= slice_buffer->buffer_size + 4)
  593. mpeg3_expand_slice_buffer(slice_buffer);
  595. slice_buffer->data[slice_buffer->buffer_size++] = 0;
  596. slice_buffer->data[slice_buffer->buffer_size++] = 0;
  597. slice_buffer->data[slice_buffer->buffer_size++] = 1;
  598. slice_buffer->data[slice_buffer->buffer_size++] = 0;
  599. slice_buffer->bits_size = 0;
  601. #ifndef SDL_THREADS
  602. pthread_mutex_lock(&(slice_buffer->completion_lock));
  603. #else
  604. SDL_LockMutex(slice_buffer->completion_lock);
  605. #endif
  606. fflush(stdout);
  607. current_buffer++;
  608. video->total_slice_buffers++;
  609. }
  611. /* Run the slice decoders */
  612. if(video->total_slice_buffers > 0)
  613. {
  614. for(i = 0; i < video->total_slice_decoders; i++)
  615. {
  616. if(i == 0 && video->total_slice_decoders > 1)
  617. {
  618. video->slice_decoders[i].current_buffer = 0;
  619. video->slice_decoders[i].buffer_step = 1;
  620. video->slice_decoders[i].last_buffer = (video->total_slice_buffers - 1);
  621. }
  622. else
  623. if(i == 1)
  624. {
  625. video->slice_decoders[i].current_buffer = video->total_slice_buffers - 1;
  626. video->slice_decoders[i].buffer_step = -1;
  627. video->slice_decoders[i].last_buffer = 0;
  628. }
  629. else
  630. {
  631. video->slice_decoders[i].current_buffer = i;
  632. video->slice_decoders[i].buffer_step = 1;
  633. video->slice_decoders[i].last_buffer = video->total_slice_buffers - 1;
  634. }
  635. #ifndef SDL_THREADS
  636. pthread_mutex_unlock(&(video->slice_decoders[i].input_lock));
  637. #else
  638. SDL_UnlockMutex(video->slice_decoders[i].input_lock);
  639. #endif
  640. }
  641. }
  643. /* Wait for the slice buffers to finish */
  644. if(video->total_slice_buffers > 0)
  645. {
  646. for(i = 0; i < video->total_slice_buffers; i++)
  647. {
  648. #ifndef SDL_THREADS
  649. pthread_mutex_lock(&(video->slice_buffers[i].completion_lock));
  650. pthread_mutex_unlock(&(video->slice_buffers[i].completion_lock));
  651. #else
  652. SDL_LockMutex(video->slice_buffers[i].completion_lock);
  653. SDL_UnlockMutex(video->slice_buffers[i].completion_lock);
  654. #endif
  655. }
  657. /* Wait for decoders to finish so packages aren't overwritten */
  658. for(i = 0; i < video->total_slice_decoders; i++)
  659. {
  660. #ifndef SDL_THREADS
  661. pthread_mutex_lock(&(video->slice_decoders[i].completion_lock));
  662. #else
  663. SDL_LockMutex(video->slice_decoders[i].completion_lock);
  664. #endif
  665. }
  666. }
  667. return 0;
  668. }
  670. int mpeg3video_allocate_decoders(mpeg3video_t *video, int decoder_count)
  671. {
  672. int i;
  673. int cpus = video->cpus;
  674.   if (video->total_slice_decoders != cpus)
  675. {
  676. for(i = 0; i < video->total_slice_decoders; i++)
  677. {
  678. mpeg3_delete_slice_decoder(&(video->slice_decoders[i]));
  679. }
  681. for(i = 0; i < cpus && i < MPEG3_MAX_CPUS; i++)
  682. {
  683. mpeg3_new_slice_decoder(video, &(video->slice_decoders[i]));
  684. video->slice_decoders[i].thread_number = i;
  685. }
  687. video->total_slice_decoders = cpus;
  688. }
  689. return 0;
  690. }
  692. /* decode one frame or field picture */
  694. int mpeg3video_getpicture(mpeg3video_t *video, int framenum)
  695. {
  696. int i, result = 0;
  697. int cpus = video->cpus;
  699. if(video->pict_struct == FRAME_PICTURE && video->secondfield)
  700. {
  701. /* recover from illegal number of field pictures */
  702.      video->secondfield = 0;
  703. }
  705. if(!video->mpeg2)
  706. {
  707. video->current_repeat = video->repeat_count = 0;
  708. }
  710. mpeg3video_allocate_decoders(video, cpus);
  712.    for(i = 0; i < 3; i++)
  713. {
  714.      if(video->pict_type == B_TYPE)
  715. {
  716. video->newframe[i] = video->auxframe[i];
  717. }
  718.      else 
  719. {
  720.         if(!video->secondfield && !video->current_repeat)
  721. {
  722. /* Swap refframes for I frames */
  723.          unsigned char* tmp = video->oldrefframe[i];
  724.          video->oldrefframe[i] = video->refframe[i];
  725.          video->refframe[i] = tmp;
  726.         }
  728.        video->newframe[i] = video->refframe[i];
  729.      }
  731.      if(video->pict_struct == BOTTOM_FIELD)
  732. {
  733. /* Only used if fields are in different pictures */
  734.          video->newframe[i] += (i == 0) ? video->coded_picture_width : video->chrom_width;
  735. }
  736. }
  739. /* The problem is when a B frame lands on the first repeat and is skipped, */
  740. /* the second repeat goes for the same bitmap as the skipped repeat, */
  741. /* so it picks up a frame from 3 frames back. */
  742. /* The first repeat must consititutively read a B frame if its B frame is going to be */
  743. /* used in a later repeat. */
  744. if(!video->current_repeat)
  745. if(!(video->skip_bframes && video->pict_type == B_TYPE) || 
  746. (video->repeat_count >= 100 + 100 * video->skip_bframes))
  747.    result = mpeg3video_get_macroblocks(video, framenum);
  749. /* Set the frame to display */
  750. video->output_src = 0;
  751. if(framenum > -1 && !result)
  752. {
  753.      if(video->pict_struct == FRAME_PICTURE || video->secondfield)
  754. {
  755.          if(video->pict_type == B_TYPE)
  756. {
  757. video->output_src = video->auxframe;
  758. }
  759.          else
  760. {
  761. video->output_src = video->oldrefframe;
  762. }
  763.      }
  764.      else 
  765. {
  766. mpeg3video_display_second_field(video);
  767. }
  768. }
  770. if(video->mpeg2)
  771. {
  772. video->current_repeat += 100;
  773. }
  775.    if(video->pict_struct != FRAME_PICTURE) video->secondfield = !video->secondfield;
  776. return result;
  777. }