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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 多媒体编程 > 查看源码
libmpeg2.cpp
资源名称：fullMPCcode.rar　[点击查看]
上传用户：xjjlds
上传日期：2015-12-05
资源大小：22823k
文件大小：98k
源码类别：

多媒体编程

开发平台：

Visual C++

libmpeg2.cpp：源码内容
  1. /*
  2.  * Copyright (C) 2000-2003 Michel Lespinasse <walken@zoy.org>
  3.  * Copyright (C) 1999-2000 Aaron Holtzman <aholtzma@ess.engr.uvic.ca>
  4.  *
  5.  * This file is part of mpeg2dec, a free MPEG-2 video stream decoder.
  6.  * See http://libmpeg2.sourceforge.net/ for updates.
  7.  *
  8.  * mpeg2dec is free software; you can redistribute it and/or modify
  9.  * it under the terms of the GNU General Public License as published by
  10.  * the Free Software Foundation; either version 2 of the License, or
  11.  * (at your option) any later version.
  12.  *
  13.  * mpeg2dec is distributed in the hope that it will be useful,
  14.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16.  * GNU General Public License for more details.
  17.  *
  18.  * You should have received a copy of the GNU General Public License
  19.  * along with this program; if not, write to the Free Software
  20.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21.  */
  23. #include "stdafx.h"
  25. #include <stdlib.h>
  26. #include <string.h>
  27. #include <malloc.h>
  28. #include "libmpeg2.h"
  29. #include "......DSUtilvd.h"
  31. #ifndef NULL
  32. #define NULL 0
  33. #endif
  35. // decode
  37. #define SEQ_EXT 2
  38. #define SEQ_DISPLAY_EXT 4
  39. #define QUANT_MATRIX_EXT 8
  40. #define COPYRIGHT_EXT 0x10
  41. #define PIC_DISPLAY_EXT 0x80
  42. #define PIC_CODING_EXT 0x100
  44. /* default intra quant matrix, in zig-zag order */
  45. static const uint8_t default_intra_quantizer_matrix[64] = {
  46.     8,
  47.     16, 16,
  48.     19, 16, 19,
  49.     22, 22, 22, 22,
  50.     22, 22, 26, 24, 26,
  51.     27, 27, 27, 26, 26, 26,
  52.     26, 27, 27, 27, 29, 29, 29,
  53.     34, 34, 34, 29, 29, 29, 27, 27,
  54.     29, 29, 32, 32, 34, 34, 37,
  55.     38, 37, 35, 35, 34, 35,
  56.     38, 38, 40, 40, 40,
  57.     48, 48, 46, 46,
  58.     56, 56, 58,
  59.     69, 69,
  60.     83
  61. };
  63. static uint8_t mpeg2_scan_norm_2[64] = {
  64.     /* Zig-Zag scan pattern */
  65.      0,  1,  8, 16,  9,  2,  3, 10, 17, 24, 32, 25, 18, 11,  4,  5,
  66.     12, 19, 26, 33, 40, 48, 41, 34, 27, 20, 13,  6,  7, 14, 21, 28,
  67.     35, 42, 49, 56, 57, 50, 43, 36, 29, 22, 15, 23, 30, 37, 44, 51,
  68.     58, 59, 52, 45, 38, 31, 39, 46, 53, 60, 61, 54, 47, 55, 62, 63
  69. };
  71. static uint8_t mpeg2_scan_alt_2[64] = {
  72.     /* Alternate scan pattern */
  73.      0, 8,  16, 24,  1,  9,  2, 10, 17, 25, 32, 40, 48, 56, 57, 49,
  74.     41, 33, 26, 18,  3, 11,  4, 12, 19, 27, 34, 42, 50, 58, 35, 43,
  75.     51, 59, 20, 28,  5, 13,  6, 14, 21, 29, 36, 44, 52, 60, 37, 45,
  76.     53, 61, 22, 30,  7, 15, 23, 31, 38, 46, 54, 62, 39, 47, 55, 63
  77. };
  79. // dummy
  80. extern "C" uint8_t mpeg2_scan_norm[64];
  81. extern "C" uint8_t mpeg2_scan_alt[64];
  82. uint8_t mpeg2_scan_norm[64];
  83. uint8_t mpeg2_scan_alt[64];
  85. // idct (c)
  87. #define W1 2841 /* 2048 * sqrt (2) * cos (1 * pi / 16) */
  88. #define W2 2676 /* 2048 * sqrt (2) * cos (2 * pi / 16) */
  89. #define W3 2408 /* 2048 * sqrt (2) * cos (3 * pi / 16) */
  90. #define W5 1609 /* 2048 * sqrt (2) * cos (5 * pi / 16) */
  91. #define W6 1108 /* 2048 * sqrt (2) * cos (6 * pi / 16) */
  92. #define W7 565  /* 2048 * sqrt (2) * cos (7 * pi / 16) */
  94. /*
  95.  * In legal streams, the IDCT output should be between -384 and +384.
  96.  * In corrupted streams, it is possible to force the IDCT output to go
  97.  * to +-3826 - this is the worst case for a column IDCT where the
  98.  * column inputs are 16-bit values.
  99.  */
  100. static uint8_t mpeg2_clip[3840 * 2 + 256];
  101. #define CLIP(i) ((mpeg2_clip + 3840)[i])
  103. #define BUTTERFLY(t0,t1,W0,W1,d0,d1)
  104. {
  105.     int tmp = W0 * (d0 + d1);
  106.     t0 = tmp + (W1 - W0) * d1;
  107.     t1 = tmp - (W1 + W0) * d0;
  108. }
  110. static void __inline idct_row(int16_t* block)
  111. {
  112.     int d0, d1, d2, d3;
  113.     int a0, a1, a2, a3, b0, b1, b2, b3;
  114.     int t0, t1, t2, t3;
  116.     /* shortcut */
  117.     if(!(block[1] | ((int32_t *)block)[1] | ((int32_t *)block)[2] | ((int32_t *)block)[3]))
  118. {
  119. uint32_t tmp = (uint16_t) (block[0] << 3);
  120. tmp |= tmp << 16;
  121. ((int32_t *)block)[0] = tmp;
  122. ((int32_t *)block)[1] = tmp;
  123. ((int32_t *)block)[2] = tmp;
  124. ((int32_t *)block)[3] = tmp;
  125. return;
  126.     }
  128.     d0 = (block[0] << 11) + 128;
  129.     d1 = block[1];
  130.     d2 = block[2] << 11;
  131.     d3 = block[3];
  132.     t0 = d0 + d2;
  133.     t1 = d0 - d2;
  134.     BUTTERFLY(t2, t3, W6, W2, d3, d1);
  135.     a0 = t0 + t2;
  136.     a1 = t1 + t3;
  137.     a2 = t1 - t3;
  138.     a3 = t0 - t2;
  140.     d0 = block[4];
  141.     d1 = block[5];
  142.     d2 = block[6];
  143.     d3 = block[7];
  144.     BUTTERFLY(t0, t1, W7, W1, d3, d0);
  145.     BUTTERFLY(t2, t3, W3, W5, d1, d2);
  146.     b0 = t0 + t2;
  147.     b3 = t1 + t3;
  148.     t0 -= t2;
  149.     t1 -= t3;
  150.     b1 = ((t0 + t1) * 181) >> 8;
  151.     b2 = ((t0 - t1) * 181) >> 8;
  153.     block[0] = (a0 + b0) >> 8;
  154.     block[1] = (a1 + b1) >> 8;
  155.     block[2] = (a2 + b2) >> 8;
  156.     block[3] = (a3 + b3) >> 8;
  157.     block[4] = (a3 - b3) >> 8;
  158.     block[5] = (a2 - b2) >> 8;
  159.     block[6] = (a1 - b1) >> 8;
  160.     block[7] = (a0 - b0) >> 8;
  161. }
  163. static void __inline idct_col(int16_t* block)
  164. {
  165.     int d0, d1, d2, d3;
  166.     int a0, a1, a2, a3, b0, b1, b2, b3;
  167.     int t0, t1, t2, t3;
  169.     d0 = (block[8*0] << 11) + 65536;
  170.     d1 = block[8*1];
  171.     d2 = block[8*2] << 11;
  172.     d3 = block[8*3];
  173.     t0 = d0 + d2;
  174.     t1 = d0 - d2;
  175.     BUTTERFLY(t2, t3, W6, W2, d3, d1);
  176.     a0 = t0 + t2;
  177.     a1 = t1 + t3;
  178.     a2 = t1 - t3;
  179.     a3 = t0 - t2;
  181.     d0 = block[8*4];
  182.     d1 = block[8*5];
  183.     d2 = block[8*6];
  184.     d3 = block[8*7];
  185.     BUTTERFLY(t0, t1, W7, W1, d3, d0);
  186.     BUTTERFLY(t2, t3, W3, W5, d1, d2);
  187.     b0 = t0 + t2;
  188.     b3 = t1 + t3;
  189.     t0 = (t0 - t2) >> 8;
  190.     t1 = (t1 - t3) >> 8;
  191.     b1 = (t0 + t1) * 181;
  192.     b2 = (t0 - t1) * 181;
  194.     block[8*0] = (a0 + b0) >> 17;
  195.     block[8*1] = (a1 + b1) >> 17;
  196.     block[8*2] = (a2 + b2) >> 17;
  197.     block[8*3] = (a3 + b3) >> 17;
  198.     block[8*4] = (a3 - b3) >> 17;
  199.     block[8*5] = (a2 - b2) >> 17;
  200.     block[8*6] = (a1 - b1) >> 17;
  201.     block[8*7] = (a0 - b0) >> 17;
  202. }
  204. static void mpeg2_idct_copy_c(int16_t* block, uint8_t* dest, const int stride)
  205. {
  206. for(int i = 0; i < 8; i++) idct_row(block + 8 * i);
  207. for(int i = 0; i < 8; i++) idct_col(block + i);
  208.     for(int i = 0; i < 8; i++)
  209. {
  210. dest[0] = CLIP(block[0]);
  211. dest[1] = CLIP(block[1]);
  212. dest[2] = CLIP(block[2]);
  213. dest[3] = CLIP(block[3]);
  214. dest[4] = CLIP(block[4]);
  215. dest[5] = CLIP(block[5]);
  216. dest[6] = CLIP(block[6]);
  217. dest[7] = CLIP(block[7]);
  219. block[0] = 0; block[1] = 0; block[2] = 0; block[3] = 0;
  220. block[4] = 0; block[5] = 0; block[6] = 0; block[7] = 0;
  222. dest += stride;
  223. block += 8;
  224.     }
  225. }
  227. static void mpeg2_idct_add_c(const int last, int16_t* block, uint8_t* dest, const int stride)
  228. {
  229.     if(last != 129 || (block[0] & 7) == 4)
  230. {
  231. for(int i = 0; i < 8; i++) idct_row(block + 8 * i);
  232. for(int i = 0; i < 8; i++) idct_col(block + i);
  233. for(int i = 0; i < 8; i++)
  234. {
  235. dest[0] = CLIP(block[0] + dest[0]);
  236. dest[1] = CLIP(block[1] + dest[1]);
  237. dest[2] = CLIP(block[2] + dest[2]);
  238. dest[3] = CLIP(block[3] + dest[3]);
  239. dest[4] = CLIP(block[4] + dest[4]);
  240. dest[5] = CLIP(block[5] + dest[5]);
  241. dest[6] = CLIP(block[6] + dest[6]);
  242. dest[7] = CLIP(block[7] + dest[7]);
  244. block[0] = 0; block[1] = 0; block[2] = 0; block[3] = 0;
  245. block[4] = 0; block[5] = 0; block[6] = 0; block[7] = 0;
  247. dest += stride;
  248. block += 8;
  249. }
  250.     }
  251. else
  252. {
  253. int DC = (block[0] + 4) >> 3;
  254. block[0] = block[63] = 0;
  255. for(int i = 0; i < 8; i++)
  256. {
  257. dest[0] = CLIP(DC + dest[0]);
  258. dest[1] = CLIP(DC + dest[1]);
  259. dest[2] = CLIP(DC + dest[2]);
  260. dest[3] = CLIP(DC + dest[3]);
  261. dest[4] = CLIP(DC + dest[4]);
  262. dest[5] = CLIP(DC + dest[5]);
  263. dest[6] = CLIP(DC + dest[6]);
  264. dest[7] = CLIP(DC + dest[7]);
  265. dest += stride;
  266. }
  267.     }
  268. }
  270. static void mpeg2_idct_init_c()
  271. {
  272. for(int i = -3840; i < 3840 + 256; i++)
  273. {
  274. CLIP(i) = (i < 0) ? 0 : ((i > 255) ? 255 : i);
  275. }
  277. // only needed with idct_c
  279. for(int i = 0; i < 64; i++)
  280. {
  281. mpeg2_scan_norm_2[i] = ((mpeg2_scan_norm_2[i] & 0x36) >> 1) | ((mpeg2_scan_norm_2[i] & 0x09) << 2);
  282. mpeg2_scan_alt_2[i] = ((mpeg2_scan_alt_2[i] & 0x36) >> 1) | ((mpeg2_scan_alt_2[i] & 0x09) << 2);
  283. }
  284. }
  286. // mc (c)
  288. #define avg2(a,b) ((a+b+1)>>1)
  289. #define avg4(a,b,c,d) ((a+b+c+d+2)>>2)
  291. #define predict_o(i) (ref[i])
  292. #define predict_x(i) (avg2(ref[i], ref[i+1]))
  293. #define predict_y(i) (avg2(ref[i], (ref+stride)[i]))
  294. #define predict_xy(i) (avg4(ref[i], ref[i+1], (ref+stride)[i], (ref+stride)[i+1]))
  296. #define put(predictor,i) dest[i] = predictor(i)
  297. #define avg(predictor,i) dest[i] = avg2(predictor(i), dest[i])
  299. /* mc function template */
  301. #define MC_FUNC(op,xy)
  302. static void MC_##op##_##xy##_16_c (uint8_t* dest, const uint8_t* ref, const int stride, int height)
  303. {
  304.     do {
  305. op (predict_##xy, 0);
  306. op (predict_##xy, 1);
  307. op (predict_##xy, 2);
  308. op (predict_##xy, 3);
  309. op (predict_##xy, 4);
  310. op (predict_##xy, 5);
  311. op (predict_##xy, 6);
  312. op (predict_##xy, 7);
  313. op (predict_##xy, 8);
  314. op (predict_##xy, 9);
  315. op (predict_##xy, 10);
  316. op (predict_##xy, 11);
  317. op (predict_##xy, 12);
  318. op (predict_##xy, 13);
  319. op (predict_##xy, 14);
  320. op (predict_##xy, 15);
  321. ref += stride;
  322. dest += stride;
  323.     } while (--height);
  324. }
  325. static void MC_##op##_##xy##_8_c (uint8_t * dest, const uint8_t * ref, const int stride, int height)
  326. {
  327.     do {
  328. op (predict_##xy, 0);
  329. op (predict_##xy, 1);
  330. op (predict_##xy, 2);
  331. op (predict_##xy, 3);
  332. op (predict_##xy, 4);
  333. op (predict_##xy, 5);
  334. op (predict_##xy, 6);
  335. op (predict_##xy, 7);
  336. ref += stride;
  337. dest += stride;
  338.     } while (--height);
  339. }
  341. /* definitions of the actual mc functions */
  343. MC_FUNC(put,o)
  344. MC_FUNC(avg,o)
  345. MC_FUNC(put,x)
  346. MC_FUNC(avg,x)
  347. MC_FUNC(put,y)
  348. MC_FUNC(avg,y)
  349. MC_FUNC(put,xy)
  350. MC_FUNC(avg,xy)
  352. #define MPEG2_MC_EXTERN(x) mpeg2_mc_t mpeg2_mc_##x = {
  353.     {MC_put_o_16_##x, MC_put_x_16_##x, MC_put_y_16_##x, MC_put_xy_16_##x,
  354.      MC_put_o_8_##x,  MC_put_x_8_##x,  MC_put_y_8_##x,  MC_put_xy_8_##x},
  355.     {MC_avg_o_16_##x, MC_avg_x_16_##x, MC_avg_y_16_##x, MC_avg_xy_16_##x,
  356.      MC_avg_o_8_##x,  MC_avg_x_8_##x,  MC_avg_y_8_##x,  MC_avg_xy_8_##x}
  357. };
  359. MPEG2_MC_EXTERN(c)
  361. // idct (mmx)
  363. extern "C" void mpeg2_idct_copy_mmx(int16_t* block, uint8_t* dest, const int stride);
  364. extern "C" void mpeg2_idct_add_mmx(const int last, int16_t* block, uint8_t* dest, const int stride);
  366. static void mpeg2_idct_init_mmx()
  367. {
  368.     for(int i = 0; i < 64; i++)
  369. {
  370. mpeg2_scan_norm_2[i] = (mpeg2_scan_norm_2[i] & 0x38) | ((mpeg2_scan_norm_2[i] & 6) >> 1) | ((mpeg2_scan_norm_2[i] & 1) << 2);
  371. mpeg2_scan_alt_2[i] = (mpeg2_scan_alt_2[i] & 0x38) | ((mpeg2_scan_alt_2[i] & 6) >> 1) | ((mpeg2_scan_alt_2[i] & 1) << 2);
  372.     }
  373. }
  375. // mc (mmx)
  377. extern "C" mpeg2_mc_t mpeg2_mc_mmx;
  379. // idct (sse2)
  381. extern void mpeg2_idct_init_sse2();
  382. extern void mpeg2_idct_copy_sse2(int16_t* block, uint8_t* dest, const int stride);
  383. extern void mpeg2_idct_add_sse2(const int last, int16_t* block, uint8_t* dest, const int stride);
  385. // mc (sse2)
  387. extern mpeg2_mc_t mpeg2_mc_sse2;
  389. // idct (null)
  391. static void mpeg2_idct_init_null() {}
  392. static void mpeg2_idct_copy_null(int16_t* block, uint8_t* dest, const int stride) {}
  393. static void mpeg2_idct_add_null(const int last, int16_t* block, uint8_t* dest, const int stride) {}
  395. // mc (null)
  397. static void MC_null(uint8_t* dest, const uint8_t* ref, const int stride, int height) {}
  399. mpeg2_mc_t mpeg2_mc_null = 
  400. {
  401. {MC_null, MC_null, MC_null, MC_null, MC_null, MC_null, MC_null, MC_null},
  402. {MC_null, MC_null, MC_null, MC_null, MC_null, MC_null, MC_null, MC_null}
  403. };
  405. //
  407. CMpeg2Dec::CMpeg2Dec()
  408. {
  409.     m_shift = 0;
  410.     m_is_display_initialized = 0;
  411. m_action = NULL;
  412.     m_state = STATE_BUFFER;
  413.     m_ext_state = 0;
  415. m_chunk_buffer = m_chunk_start = m_chunk_ptr = NULL;
  416.     m_code = 0;
  418.     m_pts_current = m_pts_previous = 0;
  419.     m_num_pts = m_bytes_since_pts = 0;
  421.     m_first = 0;
  422.     m_alloc_index = 0;
  423.     m_first_decode_slice = m_nb_decode_slices = 0;
  425.     memset(&m_new_sequence, 0, sizeof(m_new_sequence));
  426.     memset(&m_sequence, 0, sizeof(m_sequence));
  427.     memset(&m_gop, 0, sizeof(m_gop));
  428.     memset(&m_pictures, 0, sizeof(m_pictures));
  429. m_picture = NULL;
  430.     memset(&m_fbuf, 0, sizeof(m_fbuf));
  431.     memset(&m_fbuf_alloc, 0, sizeof(m_fbuf_alloc));
  433.     m_buf_start = m_buf_end = NULL;
  435.     m_display_offset_x = m_display_offset_y = 0;
  437.     m_copy_matrix = 0;
  438.     memset(&m_intra_quantizer_matrix, 0, sizeof(m_intra_quantizer_matrix));
  439.     memset(&m_non_intra_quantizer_matrix, 0, sizeof(m_non_intra_quantizer_matrix));
  441. //
  443. mpeg2_init();
  444. }
  446. CMpeg2Dec::~CMpeg2Dec()
  447. {
  448. mpeg2_close();
  449. }
  451. void CMpeg2Dec::mpeg2_init()
  452. {
  453. m_chunk_buffer = (uint8_t*)_aligned_malloc(BUFFER_SIZE + 4, 16);
  454. m_shift = 0xffffff00;
  455. m_code = 0xb4;
  456. m_action = &CMpeg2Dec::mpeg2_seek_sequence;
  457. m_sequence.width = (unsigned)-1;
  458. }
  460. void CMpeg2Dec::mpeg2_close()
  461. {
  462. /* static uint8_t finalizer[] = {0,0,1,0xb4}; */
  463. /* mpeg2_decode_data (mpeg2dec, finalizer, finalizer+4); */
  465. mpeg2_header_state_init();
  466. _aligned_free(m_chunk_buffer);
  467. }
  469. //
  471. int CMpeg2Dec::skip_chunk(int bytes)
  472. {
  473. if(!bytes)
  474. return 0;
  476. int len = 0;
  478. uint8_t* current = m_buf_start;
  479. uint8_t* limit = current + bytes;
  481. while(current < limit)
  482. {
  483. if(m_shift == 0x00000100)
  484. {
  485. m_shift = 0xffffff00;
  486. len = ++current - m_buf_start;
  487. break;
  488. }
  490. m_shift = (m_shift | *current++) << 8;
  491. }
  493. m_buf_start = current;
  495. return len;
  496. }
  498. int CMpeg2Dec::copy_chunk(int bytes)
  499. {
  500. if(!bytes)
  501. return 0;
  503. int len = 0;
  505. // this assembly gives us a nice speed up
  506. // 36 sec down to 32 sec decoding the ts.stream.tpr test file
  507. // (idtc, mc was set to null)
  509. __asm
  510. {
  511. mov ebx, this
  512. mov esi, [ebx].m_buf_start
  513. mov edi, [ebx].m_chunk_ptr
  514. mov ecx, bytes
  515. mov edx, [ebx].m_shift
  517. copy_chunk_loop:
  519. cmp edx, 0x00000100
  520. jne copy_chunk_continue
  521. mov edx, 0xffffff00
  523. inc edi
  524. mov [ebx].m_chunk_ptr, edi
  526. inc esi
  527. mov eax, esi
  528. sub eax, [ebx].m_buf_start
  529. mov len, eax
  531. jmp copy_chunk_end
  533. copy_chunk_continue:
  535. movzx eax, byte ptr [esi]
  536. or edx, eax
  537. shl edx, 8
  538. mov byte ptr [edi], al
  539. inc esi
  540. inc edi
  541. dec ecx
  542. jnz copy_chunk_loop
  544. copy_chunk_end:
  546. mov [ebx].m_buf_start, esi
  547. mov [ebx].m_shift, edx
  548. }
  549. /*
  550. uint8_t* chunk_ptr = m_chunk_ptr;
  551. uint8_t* current = m_buf_start;
  552. uint8_t* limit = current + bytes;
  554. while(current < limit)
  555. {
  556. if(m_shift == 0x00000100)
  557. {
  558. m_shift = 0xffffff00;
  559. len = ++current - m_buf_start;
  560. m_chunk_ptr = ++chunk_ptr;
  561. break;
  562. }
  564. m_shift = (m_shift | (*chunk_ptr++ = *current++)) << 8;
  565. }
  567. m_buf_start = current;
  568. */
  569. return len;
  570. }
  572. mpeg2_state_t CMpeg2Dec::seek_chunk()
  573. {
  574. int size = m_buf_end - m_buf_start;
  576. if(int skipped = skip_chunk(size))
  577. {
  578. m_bytes_since_pts += skipped;
  579. m_code = m_buf_start[-1];
  580. return (mpeg2_state_t)-1;
  581. }
  583. m_bytes_since_pts += size;
  584. return STATE_BUFFER;
  585. }
  587. mpeg2_state_t CMpeg2Dec::seek_header()
  588. {
  589. while(m_code != 0xb3 && (m_code != 0xb7 && m_code != 0xb8 && m_code || m_sequence.width == (unsigned)-1))
  590. {
  591. if(seek_chunk() == STATE_BUFFER)
  592. return STATE_BUFFER;
  593. }
  595. m_chunk_start = m_chunk_ptr = m_chunk_buffer;
  597. return m_code 
  598. ? mpeg2_parse_header()
  599. : mpeg2_header_picture_start();
  600. }
  602. mpeg2_state_t CMpeg2Dec::seek_sequence()
  603. {
  604. mpeg2_header_state_init();
  605. m_action = &CMpeg2Dec::seek_header;
  606. return seek_header();
  607. }
  609. //
  611. void CMpeg2Dec::mpeg2_buffer(uint8_t* start, uint8_t* end)
  612. {
  613. m_buf_start = start;
  614. m_buf_end = end;
  615. }
  617. int CMpeg2Dec::mpeg2_getpos()
  618. {
  619. return m_buf_end - m_buf_start;
  620. }
  622. //
  624. mpeg2_state_t CMpeg2Dec::mpeg2_parse()
  625. {
  626. if(m_action)
  627. {
  628. mpeg2_state_t state = (this->*m_action)();
  629. if((int)state >= 0)
  630. return state;
  631. }
  633. while(1)
  634. {
  635. while((unsigned)(m_code - m_first_decode_slice) < m_nb_decode_slices)
  636. {
  637. int size_buffer = m_buf_end - m_buf_start;
  638. int size_chunk = (m_chunk_buffer + BUFFER_SIZE - m_chunk_ptr);
  639. int copied;
  641. if(size_buffer <= size_chunk)
  642. {
  643. copied = copy_chunk(size_buffer);
  644. if(!copied)
  645. {
  646. m_bytes_since_pts += size_buffer;
  647. m_chunk_ptr += size_buffer;
  648. return STATE_BUFFER;
  649. }
  650. }
  651. else
  652. {
  653. copied = copy_chunk(size_chunk);
  654. if(!copied)
  655. {
  656. /* filled the chunk buffer without finding a start code */
  657. m_bytes_since_pts += size_chunk;
  658. m_action = &CMpeg2Dec::seek_chunk;
  659. return STATE_INVALID;
  660. }
  661. }
  663. m_bytes_since_pts += copied;
  665. m_decoder.mpeg2_slice(m_code, m_chunk_start);
  666. m_code = m_buf_start[-1];
  667. m_chunk_ptr = m_chunk_start;
  668. }
  670. if((unsigned)(m_code - 1) >= 0xb0 - 1)
  671. break;
  672. if(seek_chunk() == STATE_BUFFER)
  673. return STATE_BUFFER;
  674. }
  676. switch(m_code)
  677. {
  678. case 0x00:
  679. m_action = &CMpeg2Dec::mpeg2_header_picture_start;
  680. return m_state;
  681. case 0xb7:
  682. m_action = &CMpeg2Dec::mpeg2_header_end;
  683. break;
  684. case 0xb3:
  685. case 0xb8:
  686. m_action = &CMpeg2Dec::mpeg2_parse_header;
  687. break;
  688. case 0xbe:
  689. m_action = &CMpeg2Dec::seek_chunk;
  690. return STATE_PADDING;
  691. default:
  692. m_action = &CMpeg2Dec::seek_chunk;
  693. return STATE_INVALID;
  694. }
  696. if(m_state != STATE_SLICE)
  697. m_state = STATE_INVALID;
  699. return m_state;
  700. }
  703. void CMpeg2Dec::mpeg2_skip(int skip)
  704. {
  705. m_first_decode_slice = 1;
  706. m_nb_decode_slices = skip ? 0 : (0xb0 - 1);
  707. }
  709. void CMpeg2Dec::mpeg2_slice_region(int start, int end)
  710. {
  711. start = (start < 1) ? 1 : (start > 0xb0) ? 0xb0 : start;
  712. end = (end < start) ? start : (end > 0xb0) ? 0xb0 : end;
  713. m_first_decode_slice = start;
  714. m_nb_decode_slices = end - start;
  715. }
  717. void CMpeg2Dec::mpeg2_pts(uint32_t pts)
  718. {
  719. m_pts_previous = m_pts_current;
  720. m_pts_current = pts;
  721. m_num_pts++;
  722. m_bytes_since_pts = 0;
  723. }
  725. //
  727. /* decode.c */
  729. #define RECEIVED(code,state) (((state) << 8) + (code))
  731. mpeg2_state_t CMpeg2Dec::mpeg2_seek_sequence()
  732. {
  733. mpeg2_header_state_init();
  734. m_action = &CMpeg2Dec::seek_header;
  735. return seek_header();
  736. }
  738. mpeg2_state_t CMpeg2Dec::mpeg2_parse_header()
  739. {
  740. static int (CMpeg2Dec::* process_header[]) () =
  741. {
  742. &CMpeg2Dec::mpeg2_header_picture, 
  743. &CMpeg2Dec::mpeg2_header_extension, 
  744. &CMpeg2Dec::mpeg2_header_user_data,
  745. &CMpeg2Dec::mpeg2_header_sequence, 
  746. NULL, NULL, NULL, NULL, 
  747. &CMpeg2Dec::mpeg2_header_gop
  748. };
  750. m_action = &CMpeg2Dec::mpeg2_parse_header;
  752. while(1)
  753. {
  754. int size_buffer = m_buf_end - m_buf_start;
  755. int size_chunk = (m_chunk_buffer + BUFFER_SIZE - m_chunk_ptr);
  756. int copied;
  757. if(size_buffer <= size_chunk)
  758. {
  759. copied = copy_chunk(size_buffer);
  760. if(!copied)
  761. {
  762. m_bytes_since_pts += size_buffer;
  763. m_chunk_ptr += size_buffer;
  764. return STATE_BUFFER;
  765. }
  766. }
  767. else
  768. {
  769. copied = copy_chunk(size_chunk);
  770. if(!copied)
  771. {
  772. /* filled the chunk buffer without finding a start code */
  773. m_bytes_since_pts += size_chunk;
  774. m_code = 0xb4;
  775. m_action = &CMpeg2Dec::seek_header;
  776. return STATE_INVALID;
  777. }
  778. }
  779. m_bytes_since_pts += copied;
  781. if((this->*(process_header[m_code & 0x0b]))())
  782. {
  783. m_code = m_buf_start[-1];
  784. m_action = &CMpeg2Dec::seek_header;
  785. return STATE_INVALID;
  786. }
  788. m_code = m_buf_start[-1];
  790. switch(RECEIVED(m_code, m_state))
  791. {
  792. /* state transition after a sequence header */
  793. case RECEIVED(0x00, STATE_SEQUENCE):
  794. m_action = &CMpeg2Dec::mpeg2_header_picture_start;
  795. case RECEIVED(0xb8, STATE_SEQUENCE):
  796. mpeg2_header_sequence_finalize();
  797. break;
  799. /* other legal state transitions */
  800. case RECEIVED (0x00, STATE_GOP):
  801. m_action = &CMpeg2Dec::mpeg2_header_picture_start;
  802. break;
  803. case RECEIVED (0x01, STATE_PICTURE):
  804. case RECEIVED (0x01, STATE_PICTURE_2ND):
  805. mpeg2_header_matrix_finalize();
  806. m_action = &CMpeg2Dec::mpeg2_header_slice_start;
  807. break;
  809. /* legal headers within a given state */
  810. case RECEIVED (0xb2, STATE_SEQUENCE):
  811. case RECEIVED (0xb2, STATE_GOP):
  812. case RECEIVED (0xb2, STATE_PICTURE):
  813. case RECEIVED (0xb2, STATE_PICTURE_2ND):
  814. case RECEIVED (0xb5, STATE_SEQUENCE):
  815. case RECEIVED (0xb5, STATE_PICTURE):
  816. case RECEIVED (0xb5, STATE_PICTURE_2ND):
  817. m_chunk_ptr = m_chunk_start;
  818. continue;
  820. default:
  821. m_action = &CMpeg2Dec::seek_header;
  822. return STATE_INVALID;
  823. }
  825. m_chunk_start = m_chunk_ptr = m_chunk_buffer;
  826. return m_state;
  827. }
  828. }
  830. /* header.c */
  832. void CMpeg2Dec::mpeg2_header_state_init()
  833. {
  834.     if(m_sequence.width != (unsigned)-1)
  835. {
  836. m_sequence.width = (unsigned)-1;
  837. for(int i = 0; i < m_alloc_index; i++)
  838. _aligned_free(m_fbuf_alloc[i].buf[0]);
  839.     }
  841. m_decoder.m_scan = mpeg2_scan_norm_2;
  842. m_picture = m_pictures;
  843. m_fbuf[0] = &m_fbuf_alloc[0];
  844. m_fbuf[1] = &m_fbuf_alloc[1];
  845. m_fbuf[2] = &m_fbuf_alloc[2];
  846. m_first = true;
  847. m_alloc_index = 0;
  848. m_first_decode_slice = 1;
  849. m_nb_decode_slices = 0xb0 - 1;
  850. }
  852. int CMpeg2Dec::mpeg2_header_sequence()
  853. {
  854.     uint8_t* buffer = m_chunk_start;
  855.     mpeg2_sequence_t* sequence = &m_new_sequence;
  856.     static unsigned int frame_period[9] = {0, 1126125, 1125000, 1080000, 900900, 900000, 540000, 450450, 450000};
  858.     if((buffer[6] & 0x20) != 0x20) /* missing marker_bit */
  859. return 1;
  861.     int i = (buffer[0] << 16) | (buffer[1] << 8) | buffer[2];
  862.     if(!(sequence->display_width = sequence->picture_width = i >> 12))
  863. return 1;
  864.     if(!(sequence->display_height = sequence->picture_height = i & 0xfff))
  865. return 1;
  867.     sequence->width = (sequence->picture_width + 15) & ~15;
  868.     sequence->height = (sequence->picture_height + 15) & ~15;
  869.     sequence->chroma_width = sequence->width >> 1;
  870.     sequence->chroma_height = sequence->height >> 1;
  871.     sequence->flags = (SEQ_FLAG_PROGRESSIVE_SEQUENCE | SEQ_VIDEO_FORMAT_UNSPECIFIED);
  872.     sequence->pixel_width = buffer[3] >> 4; /* aspect ratio */
  873.     sequence->frame_period = 0;
  874.     if((buffer[3] & 15) < 9) sequence->frame_period = frame_period[buffer[3] & 15];
  875.     sequence->byte_rate = (buffer[4]<<10) | (buffer[5]<<2) | (buffer[6]>>6);
  876.     sequence->vbv_buffer_size = ((buffer[6]<<16)|(buffer[7]<<8))&0x1ff800;
  877.     if(buffer[7] & 4) sequence->flags |= SEQ_FLAG_CONSTRAINED_PARAMETERS;
  879.     m_copy_matrix = 3;
  880.     if(buffer[7] & 2)
  881. {
  882. for(i = 0; i < 64; i++) 
  883. m_intra_quantizer_matrix[mpeg2_scan_norm_2[i]] = (buffer[i+7] << 7) | (buffer[i+8] >> 1);
  884. buffer += 64;
  885.     }
  886. else
  887. {
  888. for (i = 0; i < 64; i++)
  889. m_intra_quantizer_matrix[mpeg2_scan_norm_2[i]] = default_intra_quantizer_matrix[i];
  890. }
  892.     if(buffer[7] & 1)
  893. {
  894. for(i = 0; i < 64; i++)
  895.             m_non_intra_quantizer_matrix[mpeg2_scan_norm_2[i]] = buffer[i+8];
  896. }
  897.     else
  898. {
  899. for(i = 0; i < 64; i++)
  900. m_non_intra_quantizer_matrix[i] = 16;
  901. }
  903.     sequence->profile_level_id = 0x80;
  904.     sequence->colour_primaries = 0;
  905.     sequence->transfer_characteristics = 0;
  906.     sequence->matrix_coefficients = 0;
  908.     m_ext_state = SEQ_EXT;
  909.     m_state = STATE_SEQUENCE;
  910.     m_display_offset_x = m_display_offset_y = 0;
  912.     m_info.Reset();
  913.     m_info.m_gop = NULL;
  915.     return 0;
  916. }
  918. int CMpeg2Dec::mpeg2_header_gop()
  919. {
  920.     uint8_t* buffer = m_chunk_start;
  921. m_info.Reset();
  922.     if(!(buffer[1] & 8)) 
  923. return 1;
  924.     m_info.m_gop = &m_gop;
  925.     m_gop.hours = (buffer[0] >> 2) & 31;
  926.     m_gop.minutes = ((buffer[0] << 4) | (buffer[1] >> 4)) & 63;
  927.     m_gop.seconds = ((buffer[1] << 3) | (buffer[2] >> 5)) & 63;
  928.     m_gop.pictures = ((buffer[2] << 1) | (buffer[3] >> 7)) & 63;
  929.     m_gop.flags = (buffer[0] >> 7) | ((buffer[3] >> 4) & 6);
  930.     m_state = STATE_GOP;
  931.     return 0;
  932. }
  934. mpeg2_state_t CMpeg2Dec::mpeg2_header_picture_start()
  935. {
  936. {
  937. mpeg2_picture_t* picture;
  939. if(m_state != STATE_SLICE_1ST)
  940. {
  941. m_state = STATE_PICTURE;
  942. picture = m_pictures;
  943. if((m_decoder.m_coding_type != PIC_FLAG_CODING_TYPE_B) ^ (m_picture >= m_pictures + 2))
  944. picture += 2;
  945. }
  946. else
  947. {
  948. m_state = STATE_PICTURE_2ND;
  949. picture = m_picture + 1; /* second field picture */
  950. }
  952. m_picture = picture;
  953. }
  955.     m_picture->flags = 0;
  957.     if(m_num_pts)
  958. {
  959. if(m_bytes_since_pts >= 4)
  960. {
  961. m_num_pts = 0;
  962. m_picture->pts = m_pts_current;
  963. m_picture->flags = PIC_FLAG_PTS;
  964. }
  965. else if(m_num_pts > 1)
  966. {
  967.     m_num_pts = 1;
  968. m_picture->pts = m_pts_previous;
  969. m_picture->flags = PIC_FLAG_PTS;
  970. }
  971.     }
  973.     m_picture->display_offset[0].x = 
  974. m_picture->display_offset[1].x =
  975. m_picture->display_offset[2].x = m_display_offset_x;
  976.     m_picture->display_offset[0].y = 
  977. m_picture->display_offset[1].y =
  978. m_picture->display_offset[2].y = m_display_offset_y;
  980.     return mpeg2_parse_header();
  981. }
  983. int CMpeg2Dec::mpeg2_header_picture()
  984. {
  985. uint8_t* buffer = m_chunk_start;
  986. mpeg2_picture_t* picture = m_picture;
  987. int type;
  988. int low_delay;
  990. type = (buffer [1] >> 3) & 7;
  991. low_delay = m_sequence.flags & SEQ_FLAG_LOW_DELAY;
  993. if(m_state == STATE_PICTURE)
  994. {
  995. mpeg2_picture_t* other;
  997. m_decoder.m_second_field = 0;
  998. other = m_pictures;
  999. if(other == picture)
  1000. other += 2;
  1001. if(m_decoder.m_coding_type != PIC_FLAG_CODING_TYPE_B)
  1002. {
  1003. m_fbuf[2] = m_fbuf[1];
  1004. m_fbuf[1] = m_fbuf[0];
  1005. }
  1006. m_fbuf[0] = NULL;
  1007. m_info.Reset();
  1008. m_info.m_current_picture = picture;
  1009. m_info.m_display_picture = picture;
  1010. if(type != PIC_FLAG_CODING_TYPE_B)
  1011. {
  1012. if(!low_delay)
  1013. {
  1014. if(m_first) {
  1015. m_info.m_display_picture = NULL;
  1016. m_first = false;
  1017. }
  1018. else
  1019. {
  1020. m_info.m_display_picture = other;
  1021. if(other->nb_fields == 1)
  1022. m_info.m_display_picture_2nd = other + 1;
  1023. m_info.m_display_fbuf = m_fbuf[1];
  1024. }
  1025. }
  1027. if(!low_delay + !NULL/*m_convert_start*/)
  1028. m_info.m_discard_fbuf = m_fbuf[!low_delay + !NULL/*m_convert_start*/];
  1029. }
  1031. while(m_alloc_index < 3)
  1032. {
  1033. mpeg2_fbuf_t* fbuf = &m_fbuf_alloc[m_alloc_index++];
  1034. fbuf->id = NULL;
  1036. int size = m_decoder.m_width * m_decoder.m_height;
  1037. fbuf->buf[0] = (uint8_t*)_aligned_malloc(6 * size >> 2, 16);
  1038. fbuf->buf[1] = fbuf->buf[0] + size;
  1039. fbuf->buf[2] = fbuf->buf[1] + (size >> 2);
  1040. memset(fbuf->buf[0], 0x10, size);
  1041. memset(fbuf->buf[1], 0x80, size >> 2);
  1042. memset(fbuf->buf[2], 0x80, size >> 2);
  1043. }
  1044. mpeg2_set_fbuf(type);
  1045. }
  1046. else
  1047. {
  1048. m_decoder.m_second_field = 1;
  1049. m_info.m_current_picture_2nd = picture;
  1050. m_info.m_user_data = NULL; m_info.m_user_data_len = 0;
  1051. if(low_delay || type == PIC_FLAG_CODING_TYPE_B)
  1052. m_info.m_display_picture_2nd = picture;
  1053. }
  1054. m_ext_state = PIC_CODING_EXT;
  1056. picture->temporal_reference = (buffer[0] << 2) | (buffer[1] >> 6);
  1058. m_decoder.m_coding_type = type;
  1059. picture->flags |= type;
  1061. if(type == PIC_FLAG_CODING_TYPE_P || type == PIC_FLAG_CODING_TYPE_B)
  1062. {
  1063. /* forward_f_code and backward_f_code - used in mpeg1 only */
  1064. m_decoder.m_f_motion.f_code[1] = (buffer[3] >> 2) & 1;
  1065. m_decoder.m_f_motion.f_code[0] = (((buffer[3] << 1) | (buffer[4] >> 7)) & 7) - 1;
  1066. m_decoder.m_b_motion.f_code[1] = (buffer[4] >> 6) & 1;
  1067. m_decoder.m_b_motion.f_code[0] = ((buffer[4] >> 3) & 7) - 1;
  1068. }
  1070. /* XXXXXX decode extra_information_picture as well */
  1072. picture->nb_fields = 2;
  1074. m_decoder.m_intra_dc_precision = 0;
  1075. m_decoder.m_frame_pred_frame_dct = 1;
  1076. m_decoder.m_q_scale_type = 0;
  1077. m_decoder.m_concealment_motion_vectors = 0;
  1078. m_decoder.m_scan = mpeg2_scan_norm_2;
  1079. m_decoder.m_picture_structure = FRAME_PICTURE;
  1080. m_copy_matrix = 0;
  1082. return 0;
  1083. }
  1085. int CMpeg2Dec::mpeg2_header_extension()
  1086. {
  1087.     static int (CMpeg2Dec::* parser[]) () =
  1088. {
  1089. NULL, 
  1090. &CMpeg2Dec::sequence_ext, 
  1091. &CMpeg2Dec::sequence_display_ext, 
  1092. &CMpeg2Dec::quant_matrix_ext,
  1093. &CMpeg2Dec::copyright_ext, 
  1094. NULL, NULL, 
  1095. &CMpeg2Dec::picture_display_ext, 
  1096. &CMpeg2Dec::picture_coding_ext
  1097.     };
  1099.     int ext, ext_bit;
  1101.     ext = m_chunk_start[0] >> 4;
  1102.     ext_bit = 1 << ext;
  1104.     if(!(m_ext_state & ext_bit)) /* ignore illegal extensions */
  1105. return 0;
  1106.     m_ext_state &= ~ext_bit;
  1107.     return (this->*parser[ext])();
  1108. }
  1110. int CMpeg2Dec::mpeg2_header_user_data()
  1111. {
  1112.     if(!m_info.m_user_data_len) m_info.m_user_data = m_chunk_start;
  1113.     else m_info.m_user_data_len += 3;
  1115. m_info.m_user_data_len += (m_chunk_ptr - 4 - m_chunk_start);
  1116.     m_chunk_start = m_chunk_ptr - 1;
  1118.     return 0;
  1119. }
  1121. void CMpeg2Dec::mpeg2_header_matrix_finalize()
  1122. {
  1123.     if(m_copy_matrix & 1)
  1124. memcpy(m_decoder.m_intra_quantizer_matrix, m_intra_quantizer_matrix, 64);
  1126.     if(m_copy_matrix & 2)
  1127. memcpy(m_decoder.m_non_intra_quantizer_matrix, m_non_intra_quantizer_matrix, 64);
  1128. }
  1130. void mpeg2_sequence_t::finalize()
  1131. {
  1132.     int w, h;
  1134.     byte_rate *= 50;
  1136.     if(flags & SEQ_FLAG_MPEG2)
  1137. {
  1138. switch(pixel_width)
  1139. {
  1140. case 1: /* square pixels */
  1141. pixel_width = pixel_height = 1; return;
  1142. case 2: /* 4:3 aspect ratio */
  1143. w = 4; h = 3; break;
  1144. case 3: /* 16:9 aspect ratio */
  1145. w = 16; h = 9; break;
  1146. case 4: /* 2.21:1 aspect ratio */
  1147. w = 221; h = 100; break;
  1148. default: /* illegal */
  1149. pixel_width = pixel_height = 0; return;
  1150. }
  1152. w *= display_height;
  1153. h *= display_width;
  1154.     }
  1155. else 
  1156. {
  1157. if(byte_rate == 50 * 0x3ffff) 
  1158. byte_rate = 0;        /* mpeg-1 VBR */ 
  1160. switch(pixel_width)
  1161. {
  1162. case 0: case 15: /* illegal */
  1163. pixel_width = pixel_height = 0; return;
  1164. case 1: /* square pixels */
  1165. pixel_width = pixel_height = 1; return;
  1166. case 3: /* 720x576 16:9 */
  1167. pixel_width = 64; pixel_height = 45; return;
  1168. case 6: /* 720x480 16:9 */
  1169. pixel_width = 32; pixel_height = 27; return;
  1170. case 12: /* 720*480 4:3 */
  1171. pixel_width = 8; pixel_height = 9; return;
  1172. default:
  1173. h = 88 * pixel_width + 1171;
  1174. w = 2000;
  1175. }
  1176.     }
  1178.     pixel_width = w;
  1179.     pixel_height = h;
  1181. /* find greatest common divisor */
  1182.     while(w) {int tmp = w; w = h % tmp; h = tmp;}
  1184. pixel_width /= h;
  1185.     pixel_height /= h;
  1186. }
  1188. void CMpeg2Dec::mpeg2_header_sequence_finalize()
  1189. {
  1190.     mpeg2_sequence_t* sequence = &m_new_sequence;
  1192.     sequence->finalize();
  1194.     mpeg2_header_matrix_finalize();
  1196.     m_decoder.m_mpeg1 = !(sequence->flags & SEQ_FLAG_MPEG2);
  1197.     m_decoder.m_width = sequence->width;
  1198.     m_decoder.m_height = sequence->height;
  1199.     m_decoder.m_vertical_position_extension = (sequence->picture_height > 2800);
  1201.     /*
  1202.      * according to 6.1.1.6, repeat sequence headers should be
  1203.      * identical to the original. However some DVDs dont respect that
  1204.      * and have different bitrates in the repeat sequence headers. So
  1205.      * we'll ignore that in the comparison and still consider these as
  1206.      * repeat sequence headers.
  1207.      */
  1209. // EDIT: some dvds will work if we allow the last three fields to vary (which aren't needed anyway)
  1211.     m_sequence.byte_rate = sequence->byte_rate;
  1212.     if(!memcmp(&m_sequence, sequence, FIELD_OFFSET(mpeg2_sequence_t, colour_primaries) /*sizeof(mpeg2_sequence_t)*/)) 
  1213. {
  1214. m_state = STATE_SEQUENCE_REPEATED;
  1215. }
  1216.     else if(m_sequence.width != (unsigned)-1)
  1217. {
  1218. m_action = &CMpeg2Dec::mpeg2_seek_sequence;
  1219. m_state = STATE_INVALID; /* XXXX STATE_INVALID_END ? */
  1220. return;
  1221.     }
  1222.     m_sequence = *sequence;
  1224.     m_info.m_sequence = &m_sequence;
  1225. }
  1227. mpeg2_state_t CMpeg2Dec::mpeg2_header_slice_start()
  1228. {
  1229. m_info.m_user_data = NULL; 
  1230. m_info.m_user_data_len = 0;
  1231. m_state = (m_picture->nb_fields > 1 || m_state == STATE_PICTURE_2ND) ? STATE_SLICE : STATE_SLICE_1ST;
  1233. if(!m_nb_decode_slices)
  1234. {
  1235. m_picture->flags |= PIC_FLAG_SKIP;
  1236. }
  1237. else
  1238. {
  1239. int b_type = m_decoder.m_coding_type == B_TYPE;
  1240. m_decoder.mpeg2_init_fbuf(m_fbuf[0]->buf, m_fbuf[b_type + 1]->buf, m_fbuf[b_type]->buf);
  1241. }
  1243. m_action = NULL;
  1245. return (mpeg2_state_t)-1;
  1246. }
  1248. mpeg2_state_t CMpeg2Dec::mpeg2_header_end()
  1249. {
  1250. mpeg2_picture_t* picture = m_pictures;
  1252. int b_type = m_decoder.m_coding_type == B_TYPE;
  1254. if((m_picture >= picture + 2) ^ b_type)
  1255. picture = m_pictures + 2;
  1257. m_state = STATE_END;
  1258. m_info.Reset();
  1260. if(!(m_sequence.flags & SEQ_FLAG_LOW_DELAY))
  1261. {
  1262. m_info.m_display_picture = picture;
  1263. if(picture->nb_fields == 1)
  1264. m_info.m_display_picture_2nd = picture + 1;
  1265. m_info.m_display_fbuf = m_fbuf[b_type];
  1266. m_info.m_discard_fbuf = m_fbuf[b_type + 1];
  1267. }
  1268. else
  1269. {
  1270. m_info.m_discard_fbuf = m_fbuf[b_type];
  1271. }
  1273. m_action = &CMpeg2Dec::mpeg2_seek_sequence;
  1274. m_first = true;
  1276. return STATE_END;
  1277. }
  1279. void CMpeg2Dec::mpeg2_set_fbuf(int coding_type)
  1280. {
  1281.     for(int i = 0; i < 3; i++)
  1282. {
  1283. if(m_fbuf[1] != &m_fbuf_alloc[i] && m_fbuf[2] != &m_fbuf_alloc[i])
  1284. {
  1285. m_fbuf[0] = &m_fbuf_alloc[i];
  1286. m_info.m_current_fbuf = m_fbuf[0];
  1287. if(coding_type == B_TYPE || (m_sequence.flags & SEQ_FLAG_LOW_DELAY))
  1288. {
  1289. if(coding_type == B_TYPE)
  1290. m_info.m_discard_fbuf = m_fbuf[0];
  1291. m_info.m_display_fbuf = m_fbuf[0];
  1292. }
  1293. break;
  1294. }
  1295. }
  1296. }
  1298. //
  1300. int CMpeg2Dec::sequence_ext()
  1301. {
  1302. uint8_t* buffer = m_chunk_start;
  1303. mpeg2_sequence_t* sequence = &m_new_sequence;
  1305. if(!(buffer[3]&1))
  1306. return 1;
  1308. sequence->profile_level_id = (buffer[0] << 4) | (buffer[1] >> 4);
  1310. sequence->display_width = 
  1311. sequence->picture_width += ((buffer[1] << 13) | (buffer[2] << 5)) & 0x3000;
  1312. sequence->display_height = 
  1313. sequence->picture_height += (buffer[2] << 7) & 0x3000;
  1315. sequence->width = (sequence->picture_width + 15) & ~15;
  1316. sequence->height = (sequence->picture_height + 15) & ~15;
  1318. sequence->flags |= SEQ_FLAG_MPEG2;
  1320. if(!(buffer[1] & 8))
  1321. {
  1322. sequence->flags &= ~SEQ_FLAG_PROGRESSIVE_SEQUENCE;
  1323. sequence->height = (sequence->height + 31) & ~31;
  1324. }
  1326. if(buffer[5] & 0x80)
  1327. {
  1328. sequence->flags |= SEQ_FLAG_LOW_DELAY;
  1329. }
  1331. sequence->chroma_width = sequence->width;
  1332. sequence->chroma_height = sequence->height;
  1334. switch(buffer[1] & 6)
  1335. {
  1336. case 0: /* invalid */
  1337. return 1;
  1338. case 2: /* 4:2:0 */
  1339. sequence->chroma_height >>= 1;
  1340. case 4: /* 4:2:2 */
  1341. sequence->chroma_width >>= 1;
  1342. }
  1344. sequence->byte_rate += ((buffer[2]<<25) | (buffer[3]<<17)) & 0x3ffc0000;
  1346. sequence->vbv_buffer_size |= buffer[4] << 21;
  1348. sequence->frame_period = 
  1349. sequence->frame_period * ((buffer[5]&31)+1) / (((buffer[5]>>2)&3)+1);
  1351. m_ext_state = SEQ_DISPLAY_EXT;
  1353. return 0;
  1354. }
  1356. int CMpeg2Dec::sequence_display_ext()
  1357. {
  1358.     uint8_t* buffer = m_chunk_start;
  1359.     mpeg2_sequence_t* sequence = &m_new_sequence;
  1361.     uint32_t flags = (sequence->flags & ~SEQ_MASK_VIDEO_FORMAT) | ((buffer[0]<<4) & SEQ_MASK_VIDEO_FORMAT);
  1362.     if(buffer[0] & 1)
  1363. {
  1364. flags |= SEQ_FLAG_COLOUR_DESCRIPTION;
  1365. sequence->colour_primaries = buffer[1];
  1366. sequence->transfer_characteristics = buffer[2];
  1367. sequence->matrix_coefficients = buffer[3];
  1368. buffer += 3;
  1369.     }
  1371.     if(!(buffer[2] & 2)) /* missing marker_bit */
  1372. return 1;
  1374. // ???
  1375. // sequence->flags = flags;
  1377. sequence->display_width = (buffer[1] << 6) | (buffer[2] >> 2);
  1378.     sequence->display_height = ((buffer[2]& 1 ) << 13) | (buffer[3] << 5) | (buffer[4] >> 3);
  1380.     return 0;
  1381. }
  1383. int CMpeg2Dec::quant_matrix_ext()
  1384. {
  1385.     uint8_t* buffer = m_chunk_start;
  1387.     if(buffer[0] & 8)
  1388. {
  1389. for(int i = 0; i < 64; i++)
  1390. m_intra_quantizer_matrix[mpeg2_scan_norm_2[i]] = (buffer[i] << 5) | (buffer[i+1] >> 3);
  1391. m_copy_matrix |= 1;
  1392. buffer += 64;
  1393.     }
  1395.     if(buffer[0] & 4)
  1396. {
  1397. for(int i = 0; i < 64; i++)
  1398. m_non_intra_quantizer_matrix[mpeg2_scan_norm_2[i]] = (buffer[i] << 6) | (buffer[i+1] >> 2);
  1399. m_copy_matrix |= 2;
  1400.     }
  1402.     return 0;
  1403. }
  1405. int CMpeg2Dec::copyright_ext()
  1406. {
  1407.     return 0;
  1408. }
  1410. int CMpeg2Dec::picture_display_ext()
  1411. {
  1412.     uint8_t* buffer = m_chunk_start;
  1413.     mpeg2_picture_t* picture = m_picture;
  1415.     int nb_pos = picture->nb_fields;
  1416.     if(m_sequence.flags & SEQ_FLAG_PROGRESSIVE_SEQUENCE)
  1417. nb_pos >>= 1;
  1419. int i = 0;
  1421.     for(; i < nb_pos; i++)
  1422. {
  1423. int x = ((buffer[4*i] << 24) | (buffer[4*i+1] << 16) |
  1424. (buffer[4*i+2] << 8) | buffer[4*i+3]) >> (11-2*i);
  1425. int y = ((buffer[4*i+2] << 24) | (buffer[4*i+3] << 16) |
  1426. (buffer[4*i+4] << 8) | buffer[4*i+5]) >> (10-2*i);
  1427. if(!(x&y&1))
  1428. return 1;
  1430. picture->display_offset[i].x = m_display_offset_x = x >> 1;
  1431. picture->display_offset[i].y = m_display_offset_y = y >> 1;
  1432. }
  1434.     for(; i < 3; i++)
  1435. {
  1436. picture->display_offset[i].x = m_display_offset_x;
  1437. picture->display_offset[i].y = m_display_offset_y;
  1438.     }
  1440.     return 0;
  1441. }
  1443. int CMpeg2Dec::picture_coding_ext()
  1444. {
  1445.     uint8_t* buffer = m_chunk_start;
  1446.     mpeg2_picture_t* picture = m_picture;
  1448.     /* pre subtract 1 for use later in compute_motion_vector */
  1449.     m_decoder.m_f_motion.f_code[0] = (buffer[0] & 15) - 1;
  1450.     m_decoder.m_f_motion.f_code[1] = (buffer[1] >> 4) - 1;
  1451.     m_decoder.m_b_motion.f_code[0] = (buffer[1] & 15) - 1;
  1452.     m_decoder.m_b_motion.f_code[1] = (buffer[2] >> 4) - 1;
  1454.     m_decoder.m_intra_dc_precision = (buffer[2] >> 2) & 3;
  1455.     m_decoder.m_picture_structure = buffer[2] & 3;
  1456.     switch(m_decoder.m_picture_structure)
  1457. {
  1458.     case TOP_FIELD:
  1459. picture->flags |= PIC_FLAG_TOP_FIELD_FIRST;
  1460.     case BOTTOM_FIELD:
  1461. picture->nb_fields = 1;
  1462. break;
  1463.     case FRAME_PICTURE:
  1464. if(!(m_sequence.flags & SEQ_FLAG_PROGRESSIVE_SEQUENCE))
  1465. {
  1466. picture->nb_fields = (buffer[3] & 2) ? 3 : 2;
  1467. picture->flags |= (buffer[3] & 128) ? PIC_FLAG_TOP_FIELD_FIRST : 0;
  1468. }
  1469. else
  1470. {
  1471. picture->nb_fields = (buffer[3]&2) ? ((buffer[3]&128) ? 6 : 4) : 2;
  1472. }
  1473. break;
  1474.     default:
  1475. return 1;
  1476.     }
  1478.     m_decoder.m_top_field_first = buffer[3] >> 7;
  1479.     m_decoder.m_frame_pred_frame_dct = (buffer[3] >> 6) & 1;
  1480.     m_decoder.m_concealment_motion_vectors = (buffer[3] >> 5) & 1;
  1481.     m_decoder.m_q_scale_type = (buffer[3] >> 4) & 1;
  1482.     m_decoder.m_intra_vlc_format = (buffer[3] >> 3) & 1;
  1483.     m_decoder.m_scan = (buffer[3] & 4) ? mpeg2_scan_alt_2 : mpeg2_scan_norm_2;
  1485. if(buffer[3] & 2)
  1486. picture->flags |= PIC_FLAG_REPEAT_FIRST_FIELD;
  1488.     picture->flags |= (buffer[4] & 0x80) ? PIC_FLAG_PROGRESSIVE_FRAME : 0;
  1489.     if(buffer[4] & 0x40)
  1490. picture->flags |= (((buffer[4]<<26) | (buffer[5]<<18) | (buffer[6]<<10)) & PIC_MASK_COMPOSITE_DISPLAY) | PIC_FLAG_COMPOSITE_DISPLAY;
  1492.     m_ext_state = PIC_DISPLAY_EXT | COPYRIGHT_EXT | QUANT_MATRIX_EXT;
  1494.     return 0;
  1495. }
  1497. //////////////////////////////////////////////////////////////////////////////////////////////////
  1498. //////////////////////////////////////////////////////////////////////////////////////////////////
  1500. // vlc
  1502. #define GETWORD(bit_buf,shift,bit_ptr)
  1503. do {
  1504.     bit_buf |= ((bit_ptr[0] << 8) | bit_ptr[1]) << (shift);
  1505.     bit_ptr += 2;
  1506. } while (0)
  1507. /*
  1508. void bitstream_init(const uint8_t * start)
  1509. {
  1510.     m_bitstream_buf =
  1511. (start[0] << 24) | (start[1] << 16) | (start[2] << 8) | start[3];
  1512.     m_bitstream_ptr = start + 4;
  1513.     m_bitstream_bits = -16;
  1514. }
  1515. */
  1516. /* make sure that there are at least 16 valid bits in bit_buf */
  1517. #define NEEDBITS
  1518. do {
  1519.     if (bits > 0) {
  1520. GETWORD (bit_buf, bits, bit_ptr);
  1521. bits -= 16;
  1522.     }
  1523. } while (0)
  1525. /* remove num valid bits from bit_buf */
  1526. #define DUMPBITS(num)
  1527. do {
  1528.     bit_buf <<= (num);
  1529.     bits += (num);
  1530. } while (0)
  1532. /* take num bits from the high part of bit_buf and zero extend them */
  1533. #define UBITS(bit_buf,num) (((uint32_t)(bit_buf)) >> (32 - (num)))
  1535. /* take num bits from the high part of bit_buf and sign extend them */
  1536. #define SBITS(bit_buf,num) (((int32_t)(bit_buf)) >> (32 - (num)))
  1538. typedef struct {
  1539.     uint8_t modes;
  1540.     uint8_t len;
  1541. } MBtab;
  1543. typedef struct {
  1544.     uint8_t delta;
  1545.     uint8_t len;
  1546. } MVtab;
  1548. typedef struct {
  1549.     int8_t dmv;
  1550.     uint8_t len;
  1551. } DMVtab;
  1553. typedef struct {
  1554.     uint8_t cbp;
  1555.     uint8_t len;
  1556. } CBPtab;
  1558. typedef struct {
  1559.     uint8_t size;
  1560.     uint8_t len;
  1561. } DCtab;
  1563. typedef struct {
  1564.     uint8_t run;
  1565.     uint8_t level;
  1566.     uint8_t len;
  1567. } DCTtab;
  1569. typedef struct {
  1570.     uint8_t mba;
  1571.     uint8_t len;
  1572. } MBAtab;
  1575. #define INTRA MACROBLOCK_INTRA
  1576. #define QUANT MACROBLOCK_QUANT
  1578. static const MBtab MB_I [] = {
  1579.     {INTRA|QUANT, 2}, {INTRA, 1}
  1580. };
  1582. #define MC MACROBLOCK_MOTION_FORWARD
  1583. #define CODED MACROBLOCK_PATTERN
  1585. static const MBtab MB_P [] = {
  1586.     {INTRA|QUANT, 6}, {CODED|QUANT, 5}, {MC|CODED|QUANT, 5}, {INTRA,    5},
  1587.     {MC,          3}, {MC,          3}, {MC,             3}, {MC,       3},
  1588.     {CODED,       2}, {CODED,       2}, {CODED,          2}, {CODED,    2},
  1589.     {CODED,       2}, {CODED,       2}, {CODED,          2}, {CODED,    2},
  1590.     {MC|CODED,    1}, {MC|CODED,    1}, {MC|CODED,       1}, {MC|CODED, 1},
  1591.     {MC|CODED,    1}, {MC|CODED,    1}, {MC|CODED,       1}, {MC|CODED, 1},
  1592.     {MC|CODED,    1}, {MC|CODED,    1}, {MC|CODED,       1}, {MC|CODED, 1},
  1593.     {MC|CODED,    1}, {MC|CODED,    1}, {MC|CODED,       1}, {MC|CODED, 1}
  1594. };
  1596. #define FWD MACROBLOCK_MOTION_FORWARD
  1597. #define BWD MACROBLOCK_MOTION_BACKWARD
  1598. #define INTER MACROBLOCK_MOTION_FORWARD|MACROBLOCK_MOTION_BACKWARD
  1600. static const MBtab MB_B [] = {
  1601.     {0,                 0}, {INTRA|QUANT,       6},
  1602.     {BWD|CODED|QUANT,   6}, {FWD|CODED|QUANT,   6},
  1603.     {INTER|CODED|QUANT, 5}, {INTER|CODED|QUANT, 5},
  1604. {INTRA,       5}, {INTRA,       5},
  1605.     {FWD,         4}, {FWD,         4}, {FWD,         4}, {FWD,         4},
  1606.     {FWD|CODED,   4}, {FWD|CODED,   4}, {FWD|CODED,   4}, {FWD|CODED,   4},
  1607.     {BWD,         3}, {BWD,         3}, {BWD,         3}, {BWD,         3},
  1608.     {BWD,         3}, {BWD,         3}, {BWD,         3}, {BWD,         3},
  1609.     {BWD|CODED,   3}, {BWD|CODED,   3}, {BWD|CODED,   3}, {BWD|CODED,   3},
  1610.     {BWD|CODED,   3}, {BWD|CODED,   3}, {BWD|CODED,   3}, {BWD|CODED,   3},
  1611.     {INTER,       2}, {INTER,       2}, {INTER,       2}, {INTER,       2},
  1612.     {INTER,       2}, {INTER,       2}, {INTER,       2}, {INTER,       2},
  1613.     {INTER,       2}, {INTER,       2}, {INTER,       2}, {INTER,       2},
  1614.     {INTER,       2}, {INTER,       2}, {INTER,       2}, {INTER,       2},
  1615.     {INTER|CODED, 2}, {INTER|CODED, 2}, {INTER|CODED, 2}, {INTER|CODED, 2},
  1616.     {INTER|CODED, 2}, {INTER|CODED, 2}, {INTER|CODED, 2}, {INTER|CODED, 2},
  1617.     {INTER|CODED, 2}, {INTER|CODED, 2}, {INTER|CODED, 2}, {INTER|CODED, 2},
  1618.     {INTER|CODED, 2}, {INTER|CODED, 2}, {INTER|CODED, 2}, {INTER|CODED, 2}
  1619. };
  1621. #undef INTRA
  1622. #undef QUANT
  1623. #undef MC
  1624. #undef CODED
  1625. #undef FWD
  1626. #undef BWD
  1627. #undef INTER
  1630. static const MVtab MV_4 [] = {
  1631.     { 3, 6}, { 2, 4}, { 1, 3}, { 1, 3}, { 0, 2}, { 0, 2}, { 0, 2}, { 0, 2}
  1632. };
  1634. static const MVtab MV_10 [] = {
  1635.     { 0,10}, { 0,10}, { 0,10}, { 0,10}, { 0,10}, { 0,10}, { 0,10}, { 0,10},
  1636.     { 0,10}, { 0,10}, { 0,10}, { 0,10}, {15,10}, {14,10}, {13,10}, {12,10},
  1637.     {11,10}, {10,10}, { 9, 9}, { 9, 9}, { 8, 9}, { 8, 9}, { 7, 9}, { 7, 9},
  1638.     { 6, 7}, { 6, 7}, { 6, 7}, { 6, 7}, { 6, 7}, { 6, 7}, { 6, 7}, { 6, 7},
  1639.     { 5, 7}, { 5, 7}, { 5, 7}, { 5, 7}, { 5, 7}, { 5, 7}, { 5, 7}, { 5, 7},
  1640.     { 4, 7}, { 4, 7}, { 4, 7}, { 4, 7}, { 4, 7}, { 4, 7}, { 4, 7}, { 4, 7}
  1641. };
  1644. static const DMVtab DMV_2 [] = {
  1645.     { 0, 1}, { 0, 1}, { 1, 2}, {-1, 2}
  1646. };
  1649. static const CBPtab CBP_7 [] = {
  1650.     {0x22, 7}, {0x12, 7}, {0x0a, 7}, {0x06, 7},
  1651.     {0x21, 7}, {0x11, 7}, {0x09, 7}, {0x05, 7},
  1652.     {0x3f, 6}, {0x3f, 6}, {0x03, 6}, {0x03, 6},
  1653.     {0x24, 6}, {0x24, 6}, {0x18, 6}, {0x18, 6},
  1654.     {0x3e, 5}, {0x3e, 5}, {0x3e, 5}, {0x3e, 5},
  1655.     {0x02, 5}, {0x02, 5}, {0x02, 5}, {0x02, 5},
  1656.     {0x3d, 5}, {0x3d, 5}, {0x3d, 5}, {0x3d, 5},
  1657.     {0x01, 5}, {0x01, 5}, {0x01, 5}, {0x01, 5},
  1658.     {0x38, 5}, {0x38, 5}, {0x38, 5}, {0x38, 5},
  1659.     {0x34, 5}, {0x34, 5}, {0x34, 5}, {0x34, 5},
  1660.     {0x2c, 5}, {0x2c, 5}, {0x2c, 5}, {0x2c, 5},
  1661.     {0x1c, 5}, {0x1c, 5}, {0x1c, 5}, {0x1c, 5},
  1662.     {0x28, 5}, {0x28, 5}, {0x28, 5}, {0x28, 5},
  1663.     {0x14, 5}, {0x14, 5}, {0x14, 5}, {0x14, 5},
  1664.     {0x30, 5}, {0x30, 5}, {0x30, 5}, {0x30, 5},
  1665.     {0x0c, 5}, {0x0c, 5}, {0x0c, 5}, {0x0c, 5},
  1666.     {0x20, 4}, {0x20, 4}, {0x20, 4}, {0x20, 4},
  1667.     {0x20, 4}, {0x20, 4}, {0x20, 4}, {0x20, 4},
  1668.     {0x10, 4}, {0x10, 4}, {0x10, 4}, {0x10, 4},
  1669.     {0x10, 4}, {0x10, 4}, {0x10, 4}, {0x10, 4},
  1670.     {0x08, 4}, {0x08, 4}, {0x08, 4}, {0x08, 4},
  1671.     {0x08, 4}, {0x08, 4}, {0x08, 4}, {0x08, 4},
  1672.     {0x04, 4}, {0x04, 4}, {0x04, 4}, {0x04, 4},
  1673.     {0x04, 4}, {0x04, 4}, {0x04, 4}, {0x04, 4},
  1674.     {0x3c, 3}, {0x3c, 3}, {0x3c, 3}, {0x3c, 3},
  1675.     {0x3c, 3}, {0x3c, 3}, {0x3c, 3}, {0x3c, 3},
  1676.     {0x3c, 3}, {0x3c, 3}, {0x3c, 3}, {0x3c, 3},
  1677.     {0x3c, 3}, {0x3c, 3}, {0x3c, 3}, {0x3c, 3}
  1678. };
  1680. static const CBPtab CBP_9 [] = {
  1681.     {0,    0}, {0x00, 9}, {0x27, 9}, {0x1b, 9},
  1682.     {0x3b, 9}, {0x37, 9}, {0x2f, 9}, {0x1f, 9},
  1683.     {0x3a, 8}, {0x3a, 8}, {0x36, 8}, {0x36, 8},
  1684.     {0x2e, 8}, {0x2e, 8}, {0x1e, 8}, {0x1e, 8},
  1685.     {0x39, 8}, {0x39, 8}, {0x35, 8}, {0x35, 8},
  1686.     {0x2d, 8}, {0x2d, 8}, {0x1d, 8}, {0x1d, 8},
  1687.     {0x26, 8}, {0x26, 8}, {0x1a, 8}, {0x1a, 8},
  1688.     {0x25, 8}, {0x25, 8}, {0x19, 8}, {0x19, 8},
  1689.     {0x2b, 8}, {0x2b, 8}, {0x17, 8}, {0x17, 8},
  1690.     {0x33, 8}, {0x33, 8}, {0x0f, 8}, {0x0f, 8},
  1691.     {0x2a, 8}, {0x2a, 8}, {0x16, 8}, {0x16, 8},
  1692.     {0x32, 8}, {0x32, 8}, {0x0e, 8}, {0x0e, 8},
  1693.     {0x29, 8}, {0x29, 8}, {0x15, 8}, {0x15, 8},
  1694.     {0x31, 8}, {0x31, 8}, {0x0d, 8}, {0x0d, 8},
  1695.     {0x23, 8}, {0x23, 8}, {0x13, 8}, {0x13, 8},
  1696.     {0x0b, 8}, {0x0b, 8}, {0x07, 8}, {0x07, 8}
  1697. };
  1700. static const DCtab DC_lum_5 [] = {
  1701.     {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2},
  1702.     {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2},
  1703.     {0, 3}, {0, 3}, {0, 3}, {0, 3}, {3, 3}, {3, 3}, {3, 3}, {3, 3},
  1704.     {4, 3}, {4, 3}, {4, 3}, {4, 3}, {5, 4}, {5, 4}, {6, 5}
  1705. };
  1707. static const DCtab DC_chrom_5 [] = {
  1708.     {0, 2}, {0, 2}, {0, 2}, {0, 2}, {0, 2}, {0, 2}, {0, 2}, {0, 2},
  1709.     {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2},
  1710.     {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2},
  1711.     {3, 3}, {3, 3}, {3, 3}, {3, 3}, {4, 4}, {4, 4}, {5, 5}
  1712. };
  1714. static const DCtab DC_long [] = {
  1715.     {6, 5}, {6, 5}, {6, 5}, {6, 5}, {6, 5}, {6, 5}, { 6, 5}, { 6, 5},
  1716.     {6, 5}, {6, 5}, {6, 5}, {6, 5}, {6, 5}, {6, 5}, { 6, 5}, { 6, 5},
  1717.     {7, 6}, {7, 6}, {7, 6}, {7, 6}, {7, 6}, {7, 6}, { 7, 6}, { 7, 6},
  1718.     {8, 7}, {8, 7}, {8, 7}, {8, 7}, {9, 8}, {9, 8}, {10, 9}, {11, 9}
  1719. };
  1722. static const DCTtab DCT_16 [] = {
  1723.     {129, 0, 0}, {129, 0, 0}, {129, 0, 0}, {129, 0, 0},
  1724.     {129, 0, 0}, {129, 0, 0}, {129, 0, 0}, {129, 0, 0},
  1725.     {129, 0, 0}, {129, 0, 0}, {129, 0, 0}, {129, 0, 0},
  1726.     {129, 0, 0}, {129, 0, 0}, {129, 0, 0}, {129, 0, 0},
  1727.     {  2,18, 0}, {  2,17, 0}, {  2,16, 0}, {  2,15, 0},
  1728.     {  7, 3, 0}, { 17, 2, 0}, { 16, 2, 0}, { 15, 2, 0},
  1729.     { 14, 2, 0}, { 13, 2, 0}, { 12, 2, 0}, { 32, 1, 0},
  1730.     { 31, 1, 0}, { 30, 1, 0}, { 29, 1, 0}, { 28, 1, 0}
  1731. };
  1733. static const DCTtab DCT_15 [] = {
  1734.     {  1,40,15}, {  1,39,15}, {  1,38,15}, {  1,37,15},
  1735.     {  1,36,15}, {  1,35,15}, {  1,34,15}, {  1,33,15},
  1736.     {  1,32,15}, {  2,14,15}, {  2,13,15}, {  2,12,15},
  1737.     {  2,11,15}, {  2,10,15}, {  2, 9,15}, {  2, 8,15},
  1738.     {  1,31,14}, {  1,31,14}, {  1,30,14}, {  1,30,14},
  1739.     {  1,29,14}, {  1,29,14}, {  1,28,14}, {  1,28,14},
  1740.     {  1,27,14}, {  1,27,14}, {  1,26,14}, {  1,26,14},
  1741.     {  1,25,14}, {  1,25,14}, {  1,24,14}, {  1,24,14},
  1742.     {  1,23,14}, {  1,23,14}, {  1,22,14}, {  1,22,14},
  1743.     {  1,21,14}, {  1,21,14}, {  1,20,14}, {  1,20,14},
  1744.     {  1,19,14}, {  1,19,14}, {  1,18,14}, {  1,18,14},
  1745.     {  1,17,14}, {  1,17,14}, {  1,16,14}, {  1,16,14}
  1746. };
  1748. static const DCTtab DCT_13 [] = {
  1749.     { 11, 2,13}, { 10, 2,13}, {  6, 3,13}, {  4, 4,13},
  1750.     {  3, 5,13}, {  2, 7,13}, {  2, 6,13}, {  1,15,13},
  1751.     {  1,14,13}, {  1,13,13}, {  1,12,13}, { 27, 1,13},
  1752.     { 26, 1,13}, { 25, 1,13}, { 24, 1,13}, { 23, 1,13},
  1753.     {  1,11,12}, {  1,11,12}, {  9, 2,12}, {  9, 2,12},
  1754.     {  5, 3,12}, {  5, 3,12}, {  1,10,12}, {  1,10,12},
  1755.     {  3, 4,12}, {  3, 4,12}, {  8, 2,12}, {  8, 2,12},
  1756.     { 22, 1,12}, { 22, 1,12}, { 21, 1,12}, { 21, 1,12},
  1757.     {  1, 9,12}, {  1, 9,12}, { 20, 1,12}, { 20, 1,12},
  1758.     { 19, 1,12}, { 19, 1,12}, {  2, 5,12}, {  2, 5,12},
  1759.     {  4, 3,12}, {  4, 3,12}, {  1, 8,12}, {  1, 8,12},
  1760.     {  7, 2,12}, {  7, 2,12}, { 18, 1,12}, { 18, 1,12}
  1761. };
  1763. static const DCTtab DCT_B14_10 [] = {
  1764.     { 17, 1,10}, {  6, 2,10}, {  1, 7,10}, {  3, 3,10},
  1765.     {  2, 4,10}, { 16, 1,10}, { 15, 1,10}, {  5, 2,10}
  1766. };
  1768. static const DCTtab DCT_B14_8 [] = {
  1769.     { 65, 0, 6}, { 65, 0, 6}, { 65, 0, 6}, { 65, 0, 6},
  1770.     {  3, 2, 7}, {  3, 2, 7}, { 10, 1, 7}, { 10, 1, 7},
  1771.     {  1, 4, 7}, {  1, 4, 7}, {  9, 1, 7}, {  9, 1, 7},
  1772.     {  8, 1, 6}, {  8, 1, 6}, {  8, 1, 6}, {  8, 1, 6},
  1773.     {  7, 1, 6}, {  7, 1, 6}, {  7, 1, 6}, {  7, 1, 6},
  1774.     {  2, 2, 6}, {  2, 2, 6}, {  2, 2, 6}, {  2, 2, 6},
  1775.     {  6, 1, 6}, {  6, 1, 6}, {  6, 1, 6}, {  6, 1, 6},
  1776.     { 14, 1, 8}, {  1, 6, 8}, { 13, 1, 8}, { 12, 1, 8},
  1777.     {  4, 2, 8}, {  2, 3, 8}, {  1, 5, 8}, { 11, 1, 8}
  1778. };
  1780. static const DCTtab DCT_B14AC_5 [] = {
  1781.  {  1, 3, 5}, {  5, 1, 5}, {  4, 1, 5},
  1782.     {  1, 2, 4}, {  1, 2, 4}, {  3, 1, 4}, {  3, 1, 4},
  1783.     {  2, 1, 3}, {  2, 1, 3}, {  2, 1, 3}, {  2, 1, 3},
  1784.     {129, 0, 2}, {129, 0, 2}, {129, 0, 2}, {129, 0, 2},
  1785.     {129, 0, 2}, {129, 0, 2}, {129, 0, 2}, {129, 0, 2},
  1786.     {  1, 1, 2}, {  1, 1, 2}, {  1, 1, 2}, {  1, 1, 2},
  1787.     {  1, 1, 2}, {  1, 1, 2}, {  1, 1, 2}, {  1, 1, 2}
  1788. };
  1790. static const DCTtab DCT_B14DC_5 [] = {
  1791.  {  1, 3, 5}, {  5, 1, 5}, {  4, 1, 5},
  1792.     {  1, 2, 4}, {  1, 2, 4}, {  3, 1, 4}, {  3, 1, 4},
  1793.     {  2, 1, 3}, {  2, 1, 3}, {  2, 1, 3}, {  2, 1, 3},
  1794.     {  1, 1, 1}, {  1, 1, 1}, {  1, 1, 1}, {  1, 1, 1},
  1795.     {  1, 1, 1}, {  1, 1, 1}, {  1, 1, 1}, {  1, 1, 1},
  1796.     {  1, 1, 1}, {  1, 1, 1}, {  1, 1, 1}, {  1, 1, 1},
  1797.     {  1, 1, 1}, {  1, 1, 1}, {  1, 1, 1}, {  1, 1, 1}
  1798. };
  1800. static const DCTtab DCT_B15_10 [] = {
  1801.     {  6, 2, 9}, {  6, 2, 9}, { 15, 1, 9}, { 15, 1, 9},
  1802.     {  3, 4,10}, { 17, 1,10}, { 16, 1, 9}, { 16, 1, 9}
  1803. };
  1805. static const DCTtab DCT_B15_8 [] = {
  1806.     { 65, 0, 6}, { 65, 0, 6}, { 65, 0, 6}, { 65, 0, 6},
  1807.     {  8, 1, 7}, {  8, 1, 7}, {  9, 1, 7}, {  9, 1, 7},
  1808.     {  7, 1, 7}, {  7, 1, 7}, {  3, 2, 7}, {  3, 2, 7},
  1809.     {  1, 7, 6}, {  1, 7, 6}, {  1, 7, 6}, {  1, 7, 6},
  1810.     {  1, 6, 6}, {  1, 6, 6}, {  1, 6, 6}, {  1, 6, 6},
  1811.     {  5, 1, 6}, {  5, 1, 6}, {  5, 1, 6}, {  5, 1, 6},
  1812.     {  6, 1, 6}, {  6, 1, 6}, {  6, 1, 6}, {  6, 1, 6},
  1813.     {  2, 5, 8}, { 12, 1, 8}, {  1,11, 8}, {  1,10, 8},
  1814.     { 14, 1, 8}, { 13, 1, 8}, {  4, 2, 8}, {  2, 4, 8},
  1815.     {  3, 1, 5}, {  3, 1, 5}, {  3, 1, 5}, {  3, 1, 5},
  1816.     {  3, 1, 5}, {  3, 1, 5}, {  3, 1, 5}, {  3, 1, 5},
  1817.     {  2, 2, 5}, {  2, 2, 5}, {  2, 2, 5}, {  2, 2, 5},
  1818.     {  2, 2, 5}, {  2, 2, 5}, {  2, 2, 5}, {  2, 2, 5},
  1819.     {  4, 1, 5}, {  4, 1, 5}, {  4, 1, 5}, {  4, 1, 5},
  1820.     {  4, 1, 5}, {  4, 1, 5}, {  4, 1, 5}, {  4, 1, 5},
  1821.     {  2, 1, 3}, {  2, 1, 3}, {  2, 1, 3}, {  2, 1, 3},
  1822.     {  2, 1, 3}, {  2, 1, 3}, {  2, 1, 3}, {  2, 1, 3},
  1823.     {  2, 1, 3}, {  2, 1, 3}, {  2, 1, 3}, {  2, 1, 3},
  1824.     {  2, 1, 3}, {  2, 1, 3}, {  2, 1, 3}, {  2, 1, 3},
  1825.     {  2, 1, 3}, {  2, 1, 3}, {  2, 1, 3}, {  2, 1, 3},
  1826.     {  2, 1, 3}, {  2, 1, 3}, {  2, 1, 3}, {  2, 1, 3},
  1827.     {  2, 1, 3}, {  2, 1, 3}, {  2, 1, 3}, {  2, 1, 3},
  1828.     {  2, 1, 3}, {  2, 1, 3}, {  2, 1, 3}, {  2, 1, 3},
  1829.     {129, 0, 4}, {129, 0, 4}, {129, 0, 4}, {129, 0, 4},
  1830.     {129, 0, 4}, {129, 0, 4}, {129, 0, 4}, {129, 0, 4},
  1831.     {129, 0, 4}, {129, 0, 4}, {129, 0, 4}, {129, 0, 4},
  1832.     {129, 0, 4}, {129, 0, 4}, {129, 0, 4}, {129, 0, 4},
  1833.     {  1, 3, 4}, {  1, 3, 4}, {  1, 3, 4}, {  1, 3, 4},
  1834.     {  1, 3, 4}, {  1, 3, 4}, {  1, 3, 4}, {  1, 3, 4},
  1835.     {  1, 3, 4}, {  1, 3, 4}, {  1, 3, 4}, {  1, 3, 4},
  1836.     {  1, 3, 4}, {  1, 3, 4}, {  1, 3, 4}, {  1, 3, 4},
  1837.     {  1, 1, 2}, {  1, 1, 2}, {  1, 1, 2}, {  1, 1, 2},
  1838.     {  1, 1, 2}, {  1, 1, 2}, {  1, 1, 2}, {  1, 1, 2},
  1839.     {  1, 1, 2}, {  1, 1, 2}, {  1, 1, 2}, {  1, 1, 2},
  1840.     {  1, 1, 2}, {  1, 1, 2}, {  1, 1, 2}, {  1, 1, 2},
  1841.     {  1, 1, 2}, {  1, 1, 2}, {  1, 1, 2}, {  1, 1, 2},
  1842.     {  1, 1, 2}, {  1, 1, 2}, {  1, 1, 2}, {  1, 1, 2},
  1843.     {  1, 1, 2}, {  1, 1, 2}, {  1, 1, 2}, {  1, 1, 2},
  1844.     {  1, 1, 2}, {  1, 1, 2}, {  1, 1, 2}, {  1, 1, 2},
  1845.     {  1, 1, 2}, {  1, 1, 2}, {  1, 1, 2}, {  1, 1, 2},
  1846.     {  1, 1, 2}, {  1, 1, 2}, {  1, 1, 2}, {  1, 1, 2},
  1847.     {  1, 1, 2}, {  1, 1, 2}, {  1, 1, 2}, {  1, 1, 2},
  1848.     {  1, 1, 2}, {  1, 1, 2}, {  1, 1, 2}, {  1, 1, 2},
  1849.     {  1, 1, 2}, {  1, 1, 2}, {  1, 1, 2}, {  1, 1, 2},
  1850.     {  1, 1, 2}, {  1, 1, 2}, {  1, 1, 2}, {  1, 1, 2},
  1851.     {  1, 1, 2}, {  1, 1, 2}, {  1, 1, 2}, {  1, 1, 2},
  1852.     {  1, 1, 2}, {  1, 1, 2}, {  1, 1, 2}, {  1, 1, 2},
  1853.     {  1, 2, 3}, {  1, 2, 3}, {  1, 2, 3}, {  1, 2, 3},
  1854.     {  1, 2, 3}, {  1, 2, 3}, {  1, 2, 3}, {  1, 2, 3},
  1855.     {  1, 2, 3}, {  1, 2, 3}, {  1, 2, 3}, {  1, 2, 3},
  1856.     {  1, 2, 3}, {  1, 2, 3}, {  1, 2, 3}, {  1, 2, 3},
  1857.     {  1, 2, 3}, {  1, 2, 3}, {  1, 2, 3}, {  1, 2, 3},
  1858.     {  1, 2, 3}, {  1, 2, 3}, {  1, 2, 3}, {  1, 2, 3},
  1859.     {  1, 2, 3}, {  1, 2, 3}, {  1, 2, 3}, {  1, 2, 3},
  1860.     {  1, 2, 3}, {  1, 2, 3}, {  1, 2, 3}, {  1, 2, 3},
  1861.     {  1, 4, 5}, {  1, 4, 5}, {  1, 4, 5}, {  1, 4, 5},
  1862.     {  1, 4, 5}, {  1, 4, 5}, {  1, 4, 5}, {  1, 4, 5},
  1863.     {  1, 5, 5}, {  1, 5, 5}, {  1, 5, 5}, {  1, 5, 5},
  1864.     {  1, 5, 5}, {  1, 5, 5}, {  1, 5, 5}, {  1, 5, 5},
  1865.     { 10, 1, 7}, { 10, 1, 7}, {  2, 3, 7}, {  2, 3, 7},
  1866.     { 11, 1, 7}, { 11, 1, 7}, {  1, 8, 7}, {  1, 8, 7},
  1867.     {  1, 9, 7}, {  1, 9, 7}, {  1,12, 8}, {  1,13, 8},
  1868.     {  3, 3, 8}, {  5, 2, 8}, {  1,14, 8}, {  1,15, 8}
  1869. };
  1872. static const MBAtab MBA_5 [] = {
  1873.     {6, 5}, {5, 5}, {4, 4}, {4, 4}, {3, 4}, {3, 4},
  1874.     {2, 3}, {2, 3}, {2, 3}, {2, 3}, {1, 3}, {1, 3}, {1, 3}, {1, 3},
  1875.     {0, 1}, {0, 1}, {0, 1}, {0, 1}, {0, 1}, {0, 1}, {0, 1}, {0, 1},
  1876.     {0, 1}, {0, 1}, {0, 1}, {0, 1}, {0, 1}, {0, 1}, {0, 1}, {0, 1}
  1877. };
  1879. static const MBAtab MBA_11 [] = {
  1880.     {32, 11}, {31, 11}, {30, 11}, {29, 11},
  1881.     {28, 11}, {27, 11}, {26, 11}, {25, 11},
  1882.     {24, 11}, {23, 11}, {22, 11}, {21, 11},
  1883.     {20, 10}, {20, 10}, {19, 10}, {19, 10},
  1884.     {18, 10}, {18, 10}, {17, 10}, {17, 10},
  1885.     {16, 10}, {16, 10}, {15, 10}, {15, 10},
  1886.     {14,  8}, {14,  8}, {14,  8}, {14,  8},
  1887.     {14,  8}, {14,  8}, {14,  8}, {14,  8},
  1888.     {13,  8}, {13,  8}, {13,  8}, {13,  8},
  1889.     {13,  8}, {13,  8}, {13,  8}, {13,  8},
  1890.     {12,  8}, {12,  8}, {12,  8}, {12,  8},
  1891.     {12,  8}, {12,  8}, {12,  8}, {12,  8},
  1892.     {11,  8}, {11,  8}, {11,  8}, {11,  8},
  1893.     {11,  8}, {11,  8}, {11,  8}, {11,  8},
  1894.     {10,  8}, {10,  8}, {10,  8}, {10,  8},
  1895.     {10,  8}, {10,  8}, {10,  8}, {10,  8},
  1896.     { 9,  8}, { 9,  8}, { 9,  8}, { 9,  8},
  1897.     { 9,  8}, { 9,  8}, { 9,  8}, { 9,  8},
  1898.     { 8,  7}, { 8,  7}, { 8,  7}, { 8,  7},
  1899.     { 8,  7}, { 8,  7}, { 8,  7}, { 8,  7},
  1900.     { 8,  7}, { 8,  7}, { 8,  7}, { 8,  7},
  1901.     { 8,  7}, { 8,  7}, { 8,  7}, { 8,  7},
  1902.     { 7,  7}, { 7,  7}, { 7,  7}, { 7,  7},
  1903.     { 7,  7}, { 7,  7}, { 7,  7}, { 7,  7},
  1904.     { 7,  7}, { 7,  7}, { 7,  7}, { 7,  7},
  1905.     { 7,  7}, { 7,  7}, { 7,  7}, { 7,  7}
  1906. };
  1908. //////////////////////////////////////////////////////////////////////////////////////////////////
  1909. //////////////////////////////////////////////////////////////////////////////////////////////////
  1911. static int non_linear_quantizer_scale [] = {
  1912.      0,  1,  2,  3,  4,  5,   6,   7,
  1913.      8, 10, 12, 14, 16, 18,  20,  22,
  1914.     24, 28, 32, 36, 40, 44,  48,  52,
  1915.     56, 64, 72, 80, 88, 96, 104, 112
  1916. };
  1918. bool CMpeg2Decoder::m_idct_initialized = false;
  1920. CMpeg2Decoder::CMpeg2Decoder()
  1921. {
  1922. memset(&m_b_motion, 0, sizeof(m_b_motion));
  1923. memset(&m_f_motion, 0, sizeof(m_f_motion));
  1925. m_DCTblock = (int16_t*)_aligned_malloc(64*sizeof(int16_t), 16);
  1926. memset(m_DCTblock, 0, 64*sizeof(int16_t));
  1928.     m_bitstream_buf = 0;
  1929.     m_bitstream_bits = 0;
  1930.     m_bitstream_ptr = NULL;
  1931.     
  1932. memset(&m_dest, 0, sizeof(m_dest));
  1933. memset(&m_picture_dest, 0, sizeof(m_picture_dest));
  1935.     m_offset = m_stride = m_uv_stride = 0;
  1936.     m_limit_x = m_limit_y_16 = m_limit_y_8 = m_limit_y = 0;
  1938. memset(&m_dc_dct_pred, 0, sizeof(m_dc_dct_pred));
  1940.     m_quantizer_scale = m_dmv_offset = 0;
  1941.     m_v_offset = 0;
  1943. memset(&m_intra_quantizer_matrix, 0, sizeof(m_intra_quantizer_matrix));
  1944. memset(&m_non_intra_quantizer_matrix, 0, sizeof(m_non_intra_quantizer_matrix));
  1946.     m_width = m_height = 0;
  1947.     m_vertical_position_extension = 0;
  1949.     m_coding_type = 0;
  1951.     m_intra_dc_precision = 0;
  1952.     m_picture_structure = 0;
  1953. m_frame_pred_frame_dct = 0;
  1954.     m_concealment_motion_vectors = 0;
  1955.     m_q_scale_type = 0;
  1956.     m_intra_vlc_format = 0;
  1957.     m_top_field_first = 0;
  1959. m_scan = NULL;
  1961.     m_second_field = 0;
  1963. m_mpeg1 = 0;
  1965. //
  1967. if(g_cpuid.m_flags&CCpuID::sse2)
  1968. {
  1969. m_idct_init = mpeg2_idct_init_sse2;
  1970. m_idct_copy = mpeg2_idct_copy_sse2;
  1971. m_idct_add = mpeg2_idct_add_sse2;
  1972. m_mc = &mpeg2_mc_sse2;
  1973. }
  1974. else if(g_cpuid.m_flags&CCpuID::mmx)
  1975. {
  1976. m_idct_init = mpeg2_idct_init_mmx;
  1977. m_idct_copy = mpeg2_idct_copy_mmx;
  1978. m_idct_add = mpeg2_idct_add_mmx;
  1979. m_mc = &mpeg2_mc_mmx;
  1980. }
  1981. else
  1982. {
  1983. m_idct_init = mpeg2_idct_init_c;
  1984. m_idct_copy = mpeg2_idct_copy_c;
  1985. m_idct_add = mpeg2_idct_add_c;
  1986. m_mc = &mpeg2_mc_c;
  1987. }
  1988. /*
  1989. m_idct_init = mpeg2_idct_init_null;
  1990. m_idct_copy = mpeg2_idct_copy_null;
  1991. m_idct_add = mpeg2_idct_add_null;
  1992. m_mc = &mpeg2_mc_null;
  1993. */
  1994. if(!m_idct_initialized)
  1995. {
  1996. m_idct_init();
  1997. m_idct_initialized = true;
  1998. }
  1999. }
  2001. CMpeg2Decoder::~CMpeg2Decoder()
  2002. {
  2003. if(m_DCTblock) _aligned_free(m_DCTblock);
  2004. }
  2006. #define bit_buf (m_bitstream_buf)
  2007. #define bits (m_bitstream_bits)
  2008. #define bit_ptr (m_bitstream_ptr)
  2010. int CMpeg2Decoder::get_macroblock_modes()
  2011. {
  2012. int macroblock_modes;
  2013.     const MBtab* tab;
  2015.     switch(m_coding_type)
  2016. {
  2017. case P_TYPE:
  2018. tab = MB_P + UBITS(bit_buf, 5);
  2019. DUMPBITS(tab->len);
  2020. macroblock_modes = tab->modes;
  2022. if(m_picture_structure != FRAME_PICTURE)
  2023. {
  2024. if(macroblock_modes & MACROBLOCK_MOTION_FORWARD)
  2025. {
  2026. macroblock_modes |= UBITS(bit_buf, 2) * MOTION_TYPE_BASE;
  2027. DUMPBITS(2);
  2028. }
  2030. return macroblock_modes;
  2031. }
  2032. else if(m_frame_pred_frame_dct)
  2033. {
  2034. if(macroblock_modes & MACROBLOCK_MOTION_FORWARD)
  2035. macroblock_modes |= MC_FRAME;
  2037. return macroblock_modes;
  2038. }
  2040. if(macroblock_modes & MACROBLOCK_MOTION_FORWARD)
  2041. {
  2042. macroblock_modes |= UBITS(bit_buf, 2) * MOTION_TYPE_BASE;
  2043. DUMPBITS(2);
  2044. }
  2046. if(macroblock_modes & (MACROBLOCK_INTRA|MACROBLOCK_PATTERN))
  2047. {
  2048. macroblock_modes |= UBITS(bit_buf, 1) * DCT_TYPE_INTERLACED;
  2049. DUMPBITS(1);
  2050. }
  2052. return macroblock_modes;
  2054. case B_TYPE:
  2055. tab = MB_B + UBITS(bit_buf, 6);
  2056. DUMPBITS(tab->len);
  2057. macroblock_modes = tab->modes;
  2059. if(m_picture_structure != FRAME_PICTURE)
  2060. {
  2061. if(!(macroblock_modes & MACROBLOCK_INTRA))
  2062. {
  2063. macroblock_modes |= UBITS(bit_buf, 2) * MOTION_TYPE_BASE;
  2064. DUMPBITS(2);
  2065. }
  2067. return macroblock_modes;
  2068. }
  2069. else if(m_frame_pred_frame_dct)
  2070. {
  2071. // if(!(macroblock_modes & MACROBLOCK_INTRA))
  2072. macroblock_modes |= MC_FRAME;
  2074. return macroblock_modes;
  2075. }
  2076. /*
  2077. if(macroblock_modes & MACROBLOCK_INTRA)
  2078. goto intra;
  2080. macroblock_modes |= UBITS(bit_buf, 2) * MOTION_TYPE_BASE;
  2081. DUMPBITS(2);
  2083. if(macroblock_modes & (MACROBLOCK_INTRA|MACROBLOCK_PATTERN))
  2084. {
  2085. intra:
  2086. macroblock_modes |= UBITS(bit_buf, 1) * DCT_TYPE_INTERLACED;
  2087. DUMPBITS(1);
  2088. }
  2089. */
  2090. if(!(macroblock_modes & MACROBLOCK_INTRA))
  2091. {
  2092. macroblock_modes |= UBITS(bit_buf, 2) * MOTION_TYPE_BASE;
  2093. DUMPBITS(2);
  2094. }
  2096. if(macroblock_modes & (MACROBLOCK_INTRA|MACROBLOCK_PATTERN))
  2097. {
  2098. macroblock_modes |= UBITS(bit_buf, 1) * DCT_TYPE_INTERLACED;
  2099. DUMPBITS(1);
  2100. }
  2102. return macroblock_modes;
  2104.     case I_TYPE:
  2105. tab = MB_I + UBITS(bit_buf, 1);
  2106. DUMPBITS(tab->len);
  2107. macroblock_modes = tab->modes;
  2109. if(!m_frame_pred_frame_dct && m_picture_structure == FRAME_PICTURE)
  2110. {
  2111. macroblock_modes |= UBITS(bit_buf, 1) * DCT_TYPE_INTERLACED;
  2112. DUMPBITS(1);
  2113. }
  2115. return macroblock_modes;
  2117. case D_TYPE:
  2119. DUMPBITS(1);
  2120. return MACROBLOCK_INTRA;
  2121. }
  2122.     
  2123. return 0;
  2124. }
  2126. int CMpeg2Decoder::get_quantizer_scale()
  2127. {
  2128.     int quantizer_scale_code = UBITS(bit_buf, 5);
  2129.     DUMPBITS(5);
  2131.     return m_q_scale_type 
  2132. ? non_linear_quantizer_scale[quantizer_scale_code]
  2133. : (quantizer_scale_code << 1);
  2134. }
  2136. int CMpeg2Decoder::get_motion_delta(const int f_code)
  2137. {
  2138.     int delta;
  2139.     int sign;
  2140.     const MVtab* tab;
  2142.     if(bit_buf & 0x80000000)
  2143. {
  2144. DUMPBITS(1);
  2145. return 0;
  2146.     }
  2147. else if(bit_buf >= 0x0c000000)
  2148. {
  2149. tab = MV_4 + UBITS(bit_buf, 4);
  2150. delta = (tab->delta << f_code) + 1;
  2151. bits += tab->len + f_code + 1;
  2152. bit_buf <<= tab->len;
  2154. sign = SBITS(bit_buf, 1);
  2155. bit_buf <<= 1;
  2157. if(f_code)
  2158. {
  2159. delta += UBITS(bit_buf, f_code);
  2160. }
  2162. bit_buf <<= f_code;
  2164. return (delta ^ sign) - sign;
  2165.     }
  2166. else
  2167. {
  2168. tab = MV_10 + UBITS(bit_buf, 10);
  2169. delta = (tab->delta << f_code) + 1;
  2170. bits += tab->len + 1;
  2171. bit_buf <<= tab->len;
  2173. sign = SBITS(bit_buf, 1);
  2174. bit_buf <<= 1;
  2176. if(f_code)
  2177. {
  2178.     NEEDBITS;
  2179. delta += UBITS(bit_buf, f_code);
  2180. DUMPBITS(f_code);
  2181. }
  2183. return (delta ^ sign) - sign;
  2184.     }
  2185. }
  2187. int CMpeg2Decoder::bound_motion_vector(const int vector, const int f_code)
  2188. {
  2189.     return ((int32_t)vector << (27 - f_code)) >> (27 - f_code);
  2190. }
  2192. int CMpeg2Decoder::get_dmv()
  2193. {
  2194.     const DMVtab* tab = DMV_2 + UBITS(bit_buf, 2);
  2195.     DUMPBITS(tab->len);
  2196.     return tab->dmv;
  2197. }
  2199. int CMpeg2Decoder::get_coded_block_pattern()
  2200. {
  2201.     const CBPtab* tab;
  2203.     NEEDBITS;
  2205.     if(bit_buf >= 0x20000000)
  2206. {
  2207. tab = CBP_7 + (UBITS(bit_buf, 7) - 16);
  2208. DUMPBITS(tab->len);
  2209. return tab->cbp;
  2210.     }
  2211. else
  2212. {
  2213. tab = CBP_9 + UBITS(bit_buf, 9);
  2214. DUMPBITS(tab->len);
  2215. return tab->cbp;
  2216.     }
  2217. }
  2219. int CMpeg2Decoder::get_luma_dc_dct_diff()
  2220. {
  2221.     const DCtab* tab;
  2222.     int size;
  2223.     int dc_diff;
  2225.     if(bit_buf < 0xf8000000)
  2226. {
  2227. tab = DC_lum_5 + UBITS(bit_buf, 5);
  2228. size = tab->size;
  2229. if(size)
  2230. {
  2231. bits += tab->len + size;
  2232. bit_buf <<= tab->len;
  2233. dc_diff = UBITS(bit_buf, size) - UBITS(SBITS(~bit_buf, 1), size);
  2234. bit_buf <<= size;
  2235. return dc_diff;
  2236. }
  2237. else
  2238. {
  2239. DUMPBITS(3);
  2240. return 0;
  2241. }
  2242. }
  2243. else
  2244. {
  2245. tab = DC_long + (UBITS(bit_buf, 9) - 0x1e0);
  2246. size = tab->size;
  2247. DUMPBITS(tab->len);
  2248. NEEDBITS;
  2249. dc_diff = UBITS(bit_buf, size) - UBITS(SBITS(~bit_buf, 1), size);
  2250. DUMPBITS(size);
  2251. return dc_diff;
  2252. }
  2253. }
  2255. int CMpeg2Decoder::get_chroma_dc_dct_diff()
  2256. {
  2257.     const DCtab* tab;
  2258.     int size;
  2259.     int dc_diff;
  2261.     if(bit_buf < 0xf8000000)
  2262. {
  2263. tab = DC_chrom_5 + UBITS(bit_buf, 5);
  2264. size = tab->size;
  2266. if(size)
  2267. {
  2268. bits += tab->len + size;
  2269. bit_buf <<= tab->len;
  2270. dc_diff = UBITS(bit_buf, size) - UBITS(SBITS(~bit_buf, 1), size);
  2271. bit_buf <<= size;
  2272. return dc_diff;
  2273. }
  2274. else
  2275. {
  2276. DUMPBITS(2);
  2277. return 0;
  2278. }
  2279. }
  2280. else
  2281. {
  2282. tab = DC_long + (UBITS(bit_buf, 10) - 0x3e0);
  2283. size = tab->size;
  2284. DUMPBITS(tab->len + 1);
  2285. NEEDBITS;
  2286. dc_diff = UBITS(bit_buf, size) - UBITS(SBITS(~bit_buf, 1), size);
  2287. DUMPBITS(size);
  2288. return dc_diff;
  2289. }
  2290. }
  2292. #undef bit_buf
  2293. #undef bits
  2294. #undef bit_ptr
  2296. #define SATURATE(val)
  2297. do {
  2298.     if((uint32_t)(val + 2048) > 4095)
  2299. val = SBITS(val, 1) ^ 2047;
  2300. } while (0)
  2302. void CMpeg2Decoder::get_intra_block_B14()
  2303. {
  2304.     int i, j;
  2305.     int val;
  2306.     const uint8_t* scan = m_scan;
  2307.     const uint8_t* quant_matrix = m_intra_quantizer_matrix;
  2308.     int quantizer_scale = m_quantizer_scale;
  2309.     int mismatch;
  2310.     const DCTtab* tab;
  2311.     uint32_t bit_buf;
  2312.     int bits;
  2313.     const uint8_t* bit_ptr;
  2314.     int16_t* dest;
  2316.     dest = m_DCTblock;
  2317.     i = 0;
  2318.     mismatch = ~dest[0];
  2320.     bit_buf = m_bitstream_buf;
  2321.     bits = m_bitstream_bits;
  2322.     bit_ptr = m_bitstream_ptr;
  2324.     NEEDBITS;
  2326.     while(1)
  2327. {
  2328. if(bit_buf >= 0x28000000)
  2329. {
  2330. tab = DCT_B14AC_5 + (UBITS(bit_buf, 5) - 5);
  2332. i += tab->run;
  2333. if(i >= 64)
  2334. break; /* end of block */
  2336. normal_code:
  2337. j = scan[i];
  2338. bit_buf <<= tab->len;
  2339. bits += tab->len + 1;
  2340. val = (tab->level * quantizer_scale * quant_matrix[j]) >> 4;
  2342. // if(bitstream_get (1)) val = -val;
  2343. val = (val ^ SBITS(bit_buf, 1)) - SBITS(bit_buf, 1);
  2345. SATURATE(val);
  2346. dest[j] = val;
  2347. mismatch ^= val;
  2349. bit_buf <<= 1;
  2350. NEEDBITS;
  2352. continue;
  2353. }
  2354. else if(bit_buf >= 0x04000000)
  2355. {
  2356. tab = DCT_B14_8 + (UBITS(bit_buf, 8) - 4);
  2358. i += tab->run;
  2359. if(i < 64)
  2360. goto normal_code;
  2362. /* escape code */
  2364. i += UBITS(bit_buf << 6, 6) - 64;
  2365. if(i >= 64)
  2366. break; /* illegal, check needed to avoid buffer overflow */
  2368. j = scan[i];
  2370. DUMPBITS(12);
  2371. NEEDBITS;
  2372. val = (SBITS(bit_buf, 12) * quantizer_scale * quant_matrix[j]) / 16;
  2374. SATURATE(val);
  2375. dest[j] = val;
  2376. mismatch ^= val;
  2378. DUMPBITS(12);
  2379. NEEDBITS;
  2381. continue;
  2382. }
  2383. else if(bit_buf >= 0x02000000)
  2384. {
  2385. tab = DCT_B14_10 + (UBITS(bit_buf, 10) - 8);
  2386. i += tab->run;
  2387. if(i < 64)
  2388. goto normal_code;
  2389. }
  2390. else if(bit_buf >= 0x00800000)
  2391. {
  2392. tab = DCT_13 + (UBITS(bit_buf, 13) - 16);
  2393. i += tab->run;
  2394. if(i < 64)
  2395. goto normal_code;
  2396. }
  2397. else if(bit_buf >= 0x00200000)
  2398. {
  2399. tab = DCT_15 + (UBITS(bit_buf, 15) - 16);
  2400. i += tab->run;
  2401. if(i < 64)
  2402. goto normal_code;
  2403. }
  2404. else
  2405. {
  2406. tab = DCT_16 + UBITS(bit_buf, 16);
  2407. bit_buf <<= 16;
  2408. GETWORD (bit_buf, bits + 16, bit_ptr);
  2409. i += tab->run;
  2410. if(i < 64)
  2411. goto normal_code;
  2412. }
  2414. break; /* illegal, check needed to avoid buffer overflow */
  2415. }
  2417. dest[63] ^= mismatch & 1;
  2418. DUMPBITS(2); /* dump end of block code */
  2419. m_bitstream_buf = bit_buf;
  2420. m_bitstream_bits = bits;
  2421. m_bitstream_ptr = bit_ptr;
  2422. }
  2424. void CMpeg2Decoder::get_intra_block_B15()
  2425. {
  2426.     int i, j;
  2427.     int val;
  2428.     const uint8_t* scan = m_scan;
  2429.     const uint8_t* quant_matrix = m_intra_quantizer_matrix;
  2430.     int quantizer_scale = m_quantizer_scale;
  2431.     int mismatch;
  2432.     const DCTtab* tab;
  2433.     uint32_t bit_buf;
  2434.     int bits;
  2435.     const uint8_t* bit_ptr;
  2436.     int16_t* dest;
  2438.     dest = m_DCTblock;
  2439.     i = 0;
  2440.     mismatch = ~dest[0];
  2442.     bit_buf = m_bitstream_buf;
  2443.     bits = m_bitstream_bits;
  2444.     bit_ptr = m_bitstream_ptr;
  2446.     NEEDBITS;
  2448. while(1)
  2449. {
  2450. if(bit_buf >= 0x04000000)
  2451. {
  2452. tab = DCT_B15_8 + (UBITS(bit_buf, 8) - 4);
  2454. i += tab->run;
  2455. if(i < 64)
  2456. {
  2457. normal_code:
  2458. j = scan[i];
  2459. bit_buf <<= tab->len;
  2460. bits += tab->len + 1;
  2461. val = (tab->level * quantizer_scale * quant_matrix[j]) >> 4;
  2463. // if(bitstream_get (1)) val = -val;
  2464. val = (val ^ SBITS(bit_buf, 1)) - SBITS(bit_buf, 1);
  2466. SATURATE(val);
  2467. dest[j] = val;
  2468. mismatch ^= val;
  2470. bit_buf <<= 1;
  2471. NEEDBITS;
  2473. continue;
  2474. }
  2475. else
  2476. {
  2477. /* end of block. I commented out this code because if we */
  2478. /* dont exit here we will still exit at the later test :) */
  2480. /* if(i >= 128) break; */ /* end of block */
  2482. /* escape code */
  2484. i += UBITS(bit_buf << 6, 6) - 64;
  2485. if(i >= 64)
  2486. break; /* illegal, check against buffer overflow */
  2488. j = scan[i];
  2490. DUMPBITS(12);
  2491. NEEDBITS;
  2492. val = (SBITS(bit_buf, 12) *
  2493. quantizer_scale * quant_matrix[j]) / 16;
  2495. SATURATE(val);
  2496. dest[j] = val;
  2497. mismatch ^= val;
  2499. DUMPBITS(12);
  2500. NEEDBITS;
  2502. continue;
  2503. }
  2504. }
  2505. else if(bit_buf >= 0x02000000)
  2506. {
  2507. tab = DCT_B15_10 + (UBITS(bit_buf, 10) - 8);
  2508. i += tab->run;
  2509. if(i < 64)
  2510. goto normal_code;
  2511. }
  2512. else if(bit_buf >= 0x00800000)
  2513. {
  2514. tab = DCT_13 + (UBITS(bit_buf, 13) - 16);
  2515. i += tab->run;
  2516. if(i < 64)
  2517. goto normal_code;
  2518. }
  2519. else if(bit_buf >= 0x00200000)
  2520. {
  2521. tab = DCT_15 + (UBITS(bit_buf, 15) - 16);
  2522. i += tab->run;
  2523. if(i < 64)
  2524. goto normal_code;
  2525. }
  2526. else
  2527. {
  2528. tab = DCT_16 + UBITS(bit_buf, 16);
  2529. bit_buf <<= 16;
  2530. GETWORD(bit_buf, bits + 16, bit_ptr);
  2531. i += tab->run;
  2532. if(i < 64)
  2533. goto normal_code;
  2534. }
  2536. break; /* illegal, check needed to avoid buffer overflow */
  2537. }
  2539. dest[63] ^= mismatch & 1;
  2540. DUMPBITS(4); /* dump end of block code */
  2541. m_bitstream_buf = bit_buf;
  2542. m_bitstream_bits = bits;
  2543. m_bitstream_ptr = bit_ptr;
  2544. }
  2546. int CMpeg2Decoder::get_non_intra_block()
  2547. {
  2548.     int i, j;
  2549.     int val;
  2550.     const uint8_t* scan = m_scan;
  2551.     const uint8_t* quant_matrix = m_non_intra_quantizer_matrix;
  2552.     int quantizer_scale = m_quantizer_scale;
  2553.     int mismatch;
  2554.     const DCTtab* tab;
  2555.     uint32_t bit_buf;
  2556.     int bits;
  2557.     const uint8_t* bit_ptr;
  2558.     int16_t* dest;
  2560.     i = -1;
  2561.     mismatch = 1;
  2562.     dest = m_DCTblock;
  2564.     bit_buf = m_bitstream_buf;
  2565.     bits = m_bitstream_bits;
  2566.     bit_ptr = m_bitstream_ptr;
  2568.     NEEDBITS;
  2569.     if(bit_buf >= 0x28000000)
  2570. {
  2571. tab = DCT_B14DC_5 + (UBITS(bit_buf, 5) - 5);
  2572. goto entry_1;
  2573.     }
  2574. else
  2575. {
  2576. goto entry_2;
  2577. }
  2579.     while(1)
  2580. {
  2581. if(bit_buf >= 0x28000000)
  2582. {
  2583. tab = DCT_B14AC_5 + (UBITS(bit_buf, 5) - 5);
  2584. entry_1:
  2585. i += tab->run;
  2586. if(i >= 64)
  2587. break; /* end of block */
  2588. normal_code:
  2589. j = scan[i];
  2590. bit_buf <<= tab->len;
  2591. bits += tab->len + 1;
  2592. val = ((2*tab->level+1) * quantizer_scale * quant_matrix[j]) >> 5;
  2594. /* if(bitstream_get (1)) val = -val; */
  2595. val = (val ^ SBITS(bit_buf, 1)) - SBITS(bit_buf, 1);
  2597. SATURATE(val);
  2598. dest[j] = val;
  2599. mismatch ^= val;
  2601. bit_buf <<= 1;
  2602. NEEDBITS;
  2604. continue;
  2605. }
  2607. entry_2:
  2608. if(bit_buf >= 0x04000000)
  2609. {
  2610. tab = DCT_B14_8 + (UBITS(bit_buf, 8) - 4);
  2612. i += tab->run;
  2613. if(i < 64)
  2614. goto normal_code;
  2616. /* escape code */
  2618. i += UBITS(bit_buf << 6, 6) - 64;
  2619. if(i >= 64)
  2620. break; /* illegal, check needed to avoid buffer overflow */
  2622. j = scan[i];
  2624. DUMPBITS(12);
  2625. NEEDBITS;
  2626. val = 2 * (SBITS(bit_buf, 12) + SBITS(bit_buf, 1)) + 1;
  2627. val = (val * quantizer_scale * quant_matrix[j]) / 32;
  2629. SATURATE(val);
  2630. dest[j] = val;
  2631. mismatch ^= val;
  2633. DUMPBITS(12);
  2634. NEEDBITS;
  2636. continue;
  2637. }
  2638. else if(bit_buf >= 0x02000000)
  2639. {
  2640. tab = DCT_B14_10 + (UBITS(bit_buf, 10) - 8);
  2641. i += tab->run;
  2642. if(i < 64)
  2643. goto normal_code;
  2644. }
  2645. else if(bit_buf >= 0x00800000)
  2646. {
  2647. tab = DCT_13 + (UBITS(bit_buf, 13) - 16);
  2648. i += tab->run;
  2649. if(i < 64)
  2650. goto normal_code;
  2651. }
  2652. else if(bit_buf >= 0x00200000)
  2653. {
  2654. tab = DCT_15 + (UBITS(bit_buf, 15) - 16);
  2655. i += tab->run;
  2656. if(i < 64)
  2657. goto normal_code;
  2658. }
  2659. else
  2660. {
  2661. tab = DCT_16 + UBITS(bit_buf, 16);
  2662. bit_buf <<= 16;
  2663. GETWORD (bit_buf, bits + 16, bit_ptr);
  2664. i += tab->run;
  2665. if(i < 64)
  2666. goto normal_code;
  2667. }
  2669. break; /* illegal, check needed to avoid buffer overflow */
  2670. }
  2672. dest[63] ^= mismatch & 1;
  2673. DUMPBITS(2); /* dump end of block code */
  2674. m_bitstream_buf = bit_buf;
  2675. m_bitstream_bits = bits;
  2676. m_bitstream_ptr = bit_ptr;
  2678. return i;
  2679. }
  2681. void CMpeg2Decoder::get_mpeg1_intra_block()
  2682. {
  2683.     int i, j;
  2684.     int val;
  2685.     const uint8_t* scan = m_scan;
  2686.     const uint8_t* quant_matrix = m_intra_quantizer_matrix;
  2687.     int quantizer_scale = m_quantizer_scale;
  2688.     const DCTtab* tab;
  2689.     uint32_t bit_buf;
  2690.     int bits;
  2691.     const uint8_t* bit_ptr;
  2692.     int16_t* dest;
  2694.     i = 0;
  2695.     dest = m_DCTblock;
  2697.     bit_buf = m_bitstream_buf;
  2698.     bits = m_bitstream_bits;
  2699.     bit_ptr = m_bitstream_ptr;
  2701.     NEEDBITS;
  2703.     while(1)
  2704. {
  2705. if(bit_buf >= 0x28000000)
  2706. {
  2707. tab = DCT_B14AC_5 + (UBITS(bit_buf, 5) - 5);
  2709. i += tab->run;
  2710. if(i >= 64)
  2711. break; /* end of block */
  2712. normal_code:
  2713. j = scan[i];
  2714. bit_buf <<= tab->len;
  2715. bits += tab->len + 1;
  2716. val = (tab->level * quantizer_scale * quant_matrix[j]) >> 4;
  2718. /* oddification */
  2719. val = (val - 1) | 1;
  2721. /* if(bitstream_get (1)) val = -val; */
  2722. val = (val ^ SBITS(bit_buf, 1)) - SBITS(bit_buf, 1);
  2724. SATURATE(val);
  2725. dest[j] = val;
  2727. bit_buf <<= 1;
  2728. NEEDBITS;
  2730. continue;
  2731. }
  2732. else if(bit_buf >= 0x04000000)
  2733. {
  2734. tab = DCT_B14_8 + (UBITS(bit_buf, 8) - 4);
  2736. i += tab->run;
  2737. if(i < 64)
  2738. goto normal_code;
  2740. /* escape code */
  2742. i += UBITS(bit_buf << 6, 6) - 64;
  2743. if(i >= 64)
  2744. break; /* illegal, check needed to avoid buffer overflow */
  2746. j = scan[i];
  2748. DUMPBITS(12);
  2749. NEEDBITS;
  2750. val = SBITS(bit_buf, 8);
  2751. if(!(val & 0x7f))
  2752. {
  2753. DUMPBITS(8);
  2754. val = UBITS(bit_buf, 8) + 2 * val;
  2755. }
  2756. val = (val * quantizer_scale * quant_matrix[j]) / 16;
  2758. /* oddification */
  2759. val = (val + ~SBITS(val, 1)) | 1;
  2761. SATURATE(val);
  2762. dest[j] = val;
  2764. DUMPBITS(8);
  2765. NEEDBITS;
  2767. continue;
  2768. }
  2769. else if(bit_buf >= 0x02000000)
  2770. {
  2771. tab = DCT_B14_10 + (UBITS(bit_buf, 10) - 8);
  2772. i += tab->run;
  2773. if(i < 64)
  2774. goto normal_code;
  2775. }
  2776. else if(bit_buf >= 0x00800000)
  2777. {
  2778. tab = DCT_13 + (UBITS(bit_buf, 13) - 16);
  2779. i += tab->run;
  2780. if(i < 64)
  2781. goto normal_code;
  2782. }
  2783. else if(bit_buf >= 0x00200000)
  2784. {
  2785. tab = DCT_15 + (UBITS(bit_buf, 15) - 16);
  2786. i += tab->run;
  2787. if(i < 64)
  2788. goto normal_code;
  2789. }
  2790. else
  2791. {
  2792. tab = DCT_16 + UBITS(bit_buf, 16);
  2793. bit_buf <<= 16;
  2794. GETWORD(bit_buf, bits + 16, bit_ptr);
  2795. i += tab->run;
  2796. if(i < 64)
  2797. goto normal_code;
  2798. }
  2800. break; /* illegal, check needed to avoid buffer overflow */
  2801. }
  2803. DUMPBITS(2); /* dump end of block code */
  2804. m_bitstream_buf = bit_buf;
  2805. m_bitstream_bits = bits;
  2806. m_bitstream_ptr = bit_ptr;
  2807. }
  2809. int CMpeg2Decoder::get_mpeg1_non_intra_block()
  2810. {
  2811.     int i, j;
  2812.     int val;
  2813.     const uint8_t* scan = m_scan;
  2814.     const uint8_t* quant_matrix = m_non_intra_quantizer_matrix;
  2815.     int quantizer_scale = m_quantizer_scale;
  2816.     const DCTtab* tab;
  2817.     uint32_t bit_buf;
  2818.     int bits;
  2819.     const uint8_t* bit_ptr;
  2820.     int16_t* dest;
  2822.     i = -1;
  2823.     dest = m_DCTblock;
  2825.     bit_buf = m_bitstream_buf;
  2826.     bits = m_bitstream_bits;
  2827.     bit_ptr = m_bitstream_ptr;
  2829.     NEEDBITS;
  2830.     if(bit_buf >= 0x28000000)
  2831. {
  2832. tab = DCT_B14DC_5 + (UBITS(bit_buf, 5) - 5);
  2833. goto entry_1;
  2834. }
  2835. else
  2836. {
  2837. goto entry_2;
  2838. }
  2840. while(1)
  2841. {
  2842. if(bit_buf >= 0x28000000)
  2843. {
  2844. tab = DCT_B14AC_5 + (UBITS(bit_buf, 5) - 5);
  2845. entry_1:
  2846. i += tab->run;
  2847. if(i >= 64)
  2848. break; /* end of block */
  2849. normal_code:
  2850. j = scan[i];
  2851. bit_buf <<= tab->len;
  2852. bits += tab->len + 1;
  2853. val = ((2*tab->level+1) * quantizer_scale * quant_matrix[j]) >> 5;
  2855. /* oddification */
  2856. val = (val - 1) | 1;
  2858. /* if(bitstream_get (1)) val = -val; */
  2859. val = (val ^ SBITS(bit_buf, 1)) - SBITS(bit_buf, 1);
  2861. SATURATE(val);
  2862. dest[j] = val;
  2864. bit_buf <<= 1;
  2865. NEEDBITS;
  2867. continue;
  2868. }
  2870. entry_2:
  2871. if(bit_buf >= 0x04000000)
  2872. {
  2873. tab = DCT_B14_8 + (UBITS(bit_buf, 8) - 4);
  2875. i += tab->run;
  2876. if(i < 64)
  2877. goto normal_code;
  2879. /* escape code */
  2881. i += UBITS(bit_buf << 6, 6) - 64;
  2882. if(i >= 64)
  2883. break; /* illegal, check needed to avoid buffer overflow */
  2885. j = scan[i];
  2887. DUMPBITS(12);
  2888. NEEDBITS;
  2889. val = SBITS(bit_buf, 8);
  2890. if(!(val & 0x7f))
  2891. {
  2892. DUMPBITS(8);
  2893. val = UBITS(bit_buf, 8) + 2 * val;
  2894. }
  2895. val = 2 * (val + SBITS(val, 1)) + 1;
  2896. val = (val * quantizer_scale * quant_matrix[j]) / 32;
  2898. /* oddification */
  2899. val = (val + ~SBITS(val, 1)) | 1;
  2901. SATURATE(val);
  2902. dest[j] = val;
  2904. DUMPBITS(8);
  2905. NEEDBITS;
  2907. continue;
  2908. }
  2909. else if(bit_buf >= 0x02000000)
  2910. {
  2911. tab = DCT_B14_10 + (UBITS(bit_buf, 10) - 8);
  2912. i += tab->run;
  2913. if(i < 64)
  2914. goto normal_code;
  2915. }
  2916. else if(bit_buf >= 0x00800000)
  2917. {
  2918. tab = DCT_13 + (UBITS(bit_buf, 13) - 16);
  2919. i += tab->run;
  2920. if(i < 64)
  2921. goto normal_code;
  2922. }
  2923. else if(bit_buf >= 0x00200000)
  2924. {
  2925. tab = DCT_15 + (UBITS(bit_buf, 15) - 16);
  2926. i += tab->run;
  2927. if(i < 64)
  2928. goto normal_code;
  2929. }
  2930. else
  2931. {
  2932. tab = DCT_16 + UBITS(bit_buf, 16);
  2933. bit_buf <<= 16;
  2934. GETWORD (bit_buf, bits + 16, bit_ptr);
  2935. i += tab->run;
  2936. if(i < 64)
  2937. goto normal_code;
  2938. }
  2940. break; /* illegal, check needed to avoid buffer overflow */
  2941. }
  2943. DUMPBITS(2); /* dump end of block code */
  2944. m_bitstream_buf = bit_buf;
  2945. m_bitstream_bits = bits;
  2946. m_bitstream_ptr = bit_ptr;
  2948. return i;
  2949. }
  2951. #define bit_buf (m_bitstream_buf)
  2952. #define bits (m_bitstream_bits)
  2953. #define bit_ptr (m_bitstream_ptr)
  2955. void CMpeg2Decoder::slice_intra_DCT(const int cc, uint8_t* dest, int stride)
  2956. {
  2957.     NEEDBITS;
  2959.     /* Get the intra DC coefficient and inverse quantize it */
  2960. m_dc_dct_pred[cc] += (cc == 0)
  2961. ? get_luma_dc_dct_diff()
  2962. : get_chroma_dc_dct_diff();
  2963.     
  2964. m_DCTblock[0] = m_dc_dct_pred[cc] << (3 - m_intra_dc_precision);
  2966.     if(m_mpeg1)
  2967. {
  2968. if(m_coding_type != D_TYPE)
  2969. get_mpeg1_intra_block();
  2970.     }
  2971. else if(m_intra_vlc_format)
  2972. {
  2973. get_intra_block_B15();
  2974. }
  2975.     else
  2976. {
  2977. get_intra_block_B14();
  2978. }
  2980.     m_idct_copy(m_DCTblock, dest, stride);
  2981. }
  2983. void CMpeg2Decoder::slice_non_intra_DCT(uint8_t* dest, int stride)
  2984. {
  2985.     int last = m_mpeg1 
  2986. ? get_mpeg1_non_intra_block()
  2987. : get_non_intra_block ();
  2988.     
  2989. m_idct_add(last, m_DCTblock, dest, stride);
  2990. }
  2992. #define MOTION(table,ref,motion_x,motion_y,size,y)       
  2993.     pos_x = 2 * m_offset + motion_x;       
  2994.     pos_y = 2 * m_v_offset + motion_y + 2 * y;       
  2995.     if(pos_x > m_limit_x) {       
  2996. pos_x = ((int)pos_x < 0) ? 0 : m_limit_x;       
  2997. motion_x = pos_x - 2 * m_offset;       
  2998.     }       
  2999.     if(pos_y > m_limit_y_ ## size) {       
  3000. pos_y = ((int)pos_y < 0) ? 0 : m_limit_y_ ## size;       
  3001. motion_y = pos_y - 2 * m_v_offset - 2 * y;       
  3002.     }       
  3003.     xy_half = ((pos_y & 1) << 1) | (pos_x & 1);       
  3004.     table[xy_half] (m_dest[0] + y * m_stride + m_offset, 
  3005.     ref[0] + (pos_x >> 1) + (pos_y >> 1) * m_stride,   
  3006.     m_stride, size);       
  3007.     motion_x /= 2; motion_y /= 2;       
  3008.     xy_half = ((motion_y & 1) << 1) | (motion_x & 1);       
  3009.     offset = (((m_offset + motion_x) >> 1) +       
  3010.       ((((m_v_offset + motion_y) >> 1) + y/2) *       
  3011.        m_uv_stride));       
  3012.     table[4+xy_half] (m_dest[1] + y/2 * m_uv_stride +       
  3013.       (m_offset >> 1), ref[1] + offset,       
  3014.       m_uv_stride, size/2);       
  3015.     table[4+xy_half] (m_dest[2] + y/2 * m_uv_stride +       
  3016.       (m_offset >> 1), ref[2] + offset,       
  3017.       m_uv_stride, size/2)
  3019. #define MOTION_FIELD(table,ref,motion_x,motion_y,dest_field,op,src_field)     
  3020.     pos_x = 2 * m_offset + motion_x;       
  3021.     pos_y = m_v_offset + motion_y;       
  3022.     if(pos_x > m_limit_x) {       
  3023. pos_x = ((int)pos_x < 0) ? 0 : m_limit_x;       
  3024. motion_x = pos_x - 2 * m_offset;       
  3025.     }       
  3026.     if(pos_y > m_limit_y) {       
  3027. pos_y = ((int)pos_y < 0) ? 0 : m_limit_y;       
  3028. motion_y = pos_y - m_v_offset;       
  3029.     }       
  3030.     xy_half = ((pos_y & 1) << 1) | (pos_x & 1);       
  3031.     table[xy_half] (m_dest[0] + dest_field * m_stride +       
  3032.     m_offset,       
  3033.     (ref[0] + (pos_x >> 1) +       
  3034.      ((pos_y op) + src_field) * m_stride),       
  3035.     2 * m_stride, 8);       
  3036.     motion_x /= 2; motion_y /= 2;       
  3037.     xy_half = ((motion_y & 1) << 1) | (motion_x & 1);       
  3038.     offset = (((m_offset + motion_x) >> 1) +       
  3039.       (((m_v_offset >> 1) + (motion_y op) + src_field) *       
  3040.        m_uv_stride));       
  3041.     table[4+xy_half] (m_dest[1] + dest_field * m_uv_stride +    
  3042.       (m_offset >> 1), ref[1] + offset,       
  3043.       2 * m_uv_stride, 4);       
  3044.     table[4+xy_half] (m_dest[2] + dest_field * m_uv_stride +    
  3045.       (m_offset >> 1), ref[2] + offset,       
  3046.       2 * m_uv_stride, 4)
  3048. void CMpeg2Decoder::motion_mp1(motion_t* motion, mpeg2_mc_fct * const * const table)
  3049. {
  3050.     int motion_x, motion_y;
  3051.     unsigned int pos_x, pos_y, xy_half, offset;
  3053.     NEEDBITS;
  3054.     motion_x = motion->pmv[0][0] + (get_motion_delta(motion->f_code[0]) << motion->f_code[1]);
  3055.     motion_x = bound_motion_vector(motion_x, motion->f_code[0] + motion->f_code[1]);
  3056.     motion->pmv[0][0] = motion_x;
  3058.     NEEDBITS;
  3059.     motion_y = motion->pmv[0][1] + (get_motion_delta(motion->f_code[0]) << motion->f_code[1]);
  3060.     motion_y = bound_motion_vector(motion_y, motion->f_code[0] + motion->f_code[1]);
  3061.     motion->pmv[0][1] = motion_y;
  3063.     MOTION(table, motion->ref[0], motion_x, motion_y, 16, 0);
  3064. }
  3066. void CMpeg2Decoder::motion_fr_frame(motion_t* motion, mpeg2_mc_fct * const * const table)
  3067. {
  3068.     int motion_x, motion_y;
  3069.     unsigned int pos_x, pos_y, xy_half, offset;
  3071.     NEEDBITS;
  3072.     motion_x = motion->pmv[0][0] + get_motion_delta(motion->f_code[0]);
  3073.     motion_x = bound_motion_vector(motion_x, motion->f_code[0]);
  3074.     motion->pmv[1][0] = motion->pmv[0][0] = motion_x;
  3076.     NEEDBITS;
  3077.     motion_y = motion->pmv[0][1] + get_motion_delta(motion->f_code[1]);
  3078.     motion_y = bound_motion_vector (motion_y, motion->f_code[1]);
  3079.     motion->pmv[1][1] = motion->pmv[0][1] = motion_y;
  3081.     MOTION(table, motion->ref[0], motion_x, motion_y, 16, 0);
  3082. }
  3084. void CMpeg2Decoder::motion_fr_field(motion_t* motion, mpeg2_mc_fct * const * const table)
  3085. {
  3086.     int motion_x, motion_y, field;
  3087.     unsigned int pos_x, pos_y, xy_half, offset;
  3089.     NEEDBITS;
  3090.     field = UBITS(bit_buf, 1);
  3091.     DUMPBITS(1);
  3093.     motion_x = motion->pmv[0][0] + get_motion_delta(motion->f_code[0]);
  3094.     motion_x = bound_motion_vector(motion_x, motion->f_code[0]);
  3095.     motion->pmv[0][0] = motion_x;
  3097.     NEEDBITS;
  3098.     motion_y = (motion->pmv[0][1] >> 1) + get_motion_delta(motion->f_code[1]);
  3099.     /* motion_y = bound_motion_vector(motion_y, motion->f_code[1]); */
  3100.     motion->pmv[0][1] = motion_y << 1;
  3102.     MOTION_FIELD(table, motion->ref[0], motion_x, motion_y, 0, & ~1, field);
  3104.     NEEDBITS;
  3105.     field = UBITS(bit_buf, 1);
  3106.     DUMPBITS(1);
  3108.     motion_x = motion->pmv[1][0] + get_motion_delta(motion->f_code[0]);
  3109.     motion_x = bound_motion_vector(motion_x, motion->f_code[0]);
  3110.     motion->pmv[1][0] = motion_x;
  3112.     NEEDBITS;
  3113.     motion_y = (motion->pmv[1][1] >> 1) + get_motion_delta(motion->f_code[1]);
  3114.     /* motion_y = bound_motion_vector(motion_y, motion->f_code[1]); */
  3115.     motion->pmv[1][1] = motion_y << 1;
  3117.     MOTION_FIELD(table, motion->ref[0], motion_x, motion_y, 1, & ~1, field);
  3118. }
  3120. void CMpeg2Decoder::motion_fr_dmv(motion_t* motion, mpeg2_mc_fct * const * const table)
  3121. {
  3122.     int motion_x, motion_y, dmv_x, dmv_y, m, other_x, other_y;
  3123.     unsigned int pos_x, pos_y, xy_half, offset;
  3125.     NEEDBITS;
  3126.     motion_x = motion->pmv[0][0] + get_motion_delta(motion->f_code[0]);
  3127.     motion_x = bound_motion_vector(motion_x, motion->f_code[0]);
  3128.     motion->pmv[1][0] = motion->pmv[0][0] = motion_x;
  3129.     NEEDBITS;
  3130.     dmv_x = get_dmv();
  3132.     motion_y = (motion->pmv[0][1] >> 1) + get_motion_delta(motion->f_code[1]);
  3133.     /* motion_y = bound_motion_vector (motion_y, motion->f_code[1]); */
  3134.     motion->pmv[1][1] = motion->pmv[0][1] = motion_y << 1;
  3135.     dmv_y = get_dmv();
  3137.     m = m_top_field_first ? 1 : 3;
  3138.     other_x = ((motion_x * m + (motion_x > 0)) >> 1) + dmv_x;
  3139.     other_y = ((motion_y * m + (motion_y > 0)) >> 1) + dmv_y - 1;
  3140.     MOTION_FIELD(m_mc->put, motion->ref[0], other_x, other_y, 0, | 1, 0);
  3142.     m = m_top_field_first ? 3 : 1;
  3143.     other_x = ((motion_x * m + (motion_x > 0)) >> 1) + dmv_x;
  3144.     other_y = ((motion_y * m + (motion_y > 0)) >> 1) + dmv_y + 1;
  3145.     MOTION_FIELD(m_mc->put, motion->ref[0], other_x, other_y, 1, & ~1, 0);
  3147.     pos_x = 2 * m_offset + motion_x;
  3148.     pos_y = m_v_offset + motion_y;
  3149.     if(pos_x > m_limit_x)
  3150. {
  3151. pos_x = ((int)pos_x < 0) ? 0 : m_limit_x;
  3152. motion_x = pos_x - 2 * m_offset;
  3153.     }
  3154.     if(pos_y > m_limit_y)
  3155. {
  3156. pos_y = ((int)pos_y < 0) ? 0 : m_limit_y;
  3157. motion_y = pos_y - m_v_offset;
  3158.     }
  3159.     xy_half = ((pos_y & 1) << 1) | (pos_x & 1);
  3160.     offset = (pos_x >> 1) + (pos_y & ~1) * m_stride;
  3161.     m_mc->avg[xy_half](m_dest[0] + m_offset, motion->ref[0][0] + offset, 2 * m_stride, 8);
  3162.     m_mc->avg[xy_half](m_dest[0] + m_stride + m_offset, motion->ref[0][0] + m_stride + offset, 2 * m_stride, 8);
  3163.     motion_x /= 2; 
  3164. motion_y /= 2;
  3165.     xy_half = ((motion_y & 1) << 1) | (motion_x & 1);
  3166.     offset = ((m_offset + motion_x) >> 1) + ((m_v_offset >> 1) + (motion_y & ~1)) * m_uv_stride;
  3167.     m_mc->avg[4+xy_half](m_dest[1] + (m_offset >> 1), motion->ref[0][1] + offset, 2 * m_uv_stride, 4);
  3168.     m_mc->avg[4+xy_half](m_dest[1] + m_uv_stride + (m_offset >> 1), motion->ref[0][1] + m_uv_stride + offset, 2 * m_uv_stride, 4);
  3169.     m_mc->avg[4+xy_half](m_dest[2] + (m_offset >> 1), motion->ref[0][2] + offset, 2 * m_uv_stride, 4);
  3170.     m_mc->avg[4+xy_half](m_dest[2] + m_uv_stride + (m_offset >> 1), motion->ref[0][2] + m_uv_stride + offset, 2 * m_uv_stride, 4);
  3171. }
  3173. void CMpeg2Decoder::motion_reuse(motion_t* motion, mpeg2_mc_fct * const * const table)
  3174. {
  3175.     int motion_x, motion_y;
  3176.     unsigned int pos_x, pos_y, xy_half, offset;
  3178.     motion_x = motion->pmv[0][0];
  3179.     motion_y = motion->pmv[0][1];
  3181.     MOTION(table, motion->ref[0], motion_x, motion_y, 16, 0);
  3182. }
  3184. void CMpeg2Decoder::motion_zero(motion_t* motion, mpeg2_mc_fct * const * const table)
  3185. {
  3186.     unsigned int offset;
  3188.     table[0](m_dest[0] + m_offset, motion->ref[0][0] + m_offset + m_v_offset * m_stride, m_stride, 16);
  3189.     offset = (m_offset >> 1) + (m_v_offset >> 1) * m_uv_stride;
  3190.     table[4](m_dest[1] + (m_offset >> 1), motion->ref[0][1] + offset, m_uv_stride, 8);
  3191.     table[4](m_dest[2] + (m_offset >> 1), motion->ref[0][2] + offset, m_uv_stride, 8);
  3192. }
  3194. /* like motion_frame, but parsing without actual motion compensation */
  3195. void CMpeg2Decoder::motion_fr_conceal()
  3196. {
  3197.     int tmp;
  3199.     NEEDBITS;
  3200.     tmp = (m_f_motion.pmv[0][0] + get_motion_delta(m_f_motion.f_code[0]));
  3201.     tmp = bound_motion_vector(tmp, m_f_motion.f_code[0]);
  3202.     m_f_motion.pmv[1][0] = m_f_motion.pmv[0][0] = tmp;
  3204.     NEEDBITS;
  3205.     tmp = m_f_motion.pmv[0][1] + get_motion_delta(m_f_motion.f_code[1]);
  3206.     tmp = bound_motion_vector(tmp, m_f_motion.f_code[1]);
  3207.     m_f_motion.pmv[1][1] = m_f_motion.pmv[0][1] = tmp;
  3209.     DUMPBITS(1); /* remove marker_bit */
  3210. }
  3212. void CMpeg2Decoder::motion_fi_field(motion_t * motion, mpeg2_mc_fct * const * const table)
  3213. {
  3214.     int motion_x, motion_y;
  3215.     uint8_t** ref_field;
  3216.     unsigned int pos_x, pos_y, xy_half, offset;
  3218.     NEEDBITS;
  3219.     ref_field = motion->ref2[UBITS(bit_buf, 1)];
  3220.     DUMPBITS(1);
  3222.     motion_x = motion->pmv[0][0] + get_motion_delta(motion->f_code[0]);
  3223.     motion_x = bound_motion_vector (motion_x, motion->f_code[0]);
  3224.     motion->pmv[1][0] = motion->pmv[0][0] = motion_x;
  3226.     NEEDBITS;
  3227.     motion_y = motion->pmv[0][1] + get_motion_delta(motion->f_code[1]);
  3228.     motion_y = bound_motion_vector(motion_y, motion->f_code[1]);
  3229.     motion->pmv[1][1] = motion->pmv[0][1] = motion_y;
  3231.     MOTION(table, ref_field, motion_x, motion_y, 16, 0);
  3232. }
  3234. void CMpeg2Decoder::motion_fi_16x8(motion_t* motion, mpeg2_mc_fct * const * const table)
  3235. {
  3236.     int motion_x, motion_y;
  3237.     uint8_t** ref_field;
  3238.     unsigned int pos_x, pos_y, xy_half, offset;
  3240.     NEEDBITS;
  3241.     ref_field = motion->ref2[UBITS(bit_buf, 1)];
  3242.     DUMPBITS(1);
  3244.     motion_x = motion->pmv[0][0] + get_motion_delta(motion->f_code[0]);
  3245.     motion_x = bound_motion_vector(motion_x, motion->f_code[0]);
  3246.     motion->pmv[0][0] = motion_x;
  3248.     NEEDBITS;
  3249.     motion_y = motion->pmv[0][1] + get_motion_delta(motion->f_code[1]);
  3250.     motion_y = bound_motion_vector(motion_y, motion->f_code[1]);
  3251.     motion->pmv[0][1] = motion_y;
  3253.     MOTION(table, ref_field, motion_x, motion_y, 8, 0);
  3255.     NEEDBITS;
  3256.     ref_field = motion->ref2[UBITS(bit_buf, 1)];
  3257.     DUMPBITS(1);
  3259.     motion_x = motion->pmv[1][0] + get_motion_delta(motion->f_code[0]);
  3260.     motion_x = bound_motion_vector (motion_x, motion->f_code[0]);
  3261.     motion->pmv[1][0] = motion_x;
  3263.     NEEDBITS;
  3264.     motion_y = motion->pmv[1][1] + get_motion_delta(motion->f_code[1]);
  3265.     motion_y = bound_motion_vector(motion_y, motion->f_code[1]);
  3266.     motion->pmv[1][1] = motion_y;
  3268.     MOTION(table, ref_field, motion_x, motion_y, 8, 8);
  3269. }
  3271. void CMpeg2Decoder::motion_fi_dmv(motion_t* motion, mpeg2_mc_fct * const * const table)
  3272. {
  3273.     int motion_x, motion_y, other_x, other_y;
  3274.     unsigned int pos_x, pos_y, xy_half, offset;
  3276.     NEEDBITS;
  3277.     motion_x = motion->pmv[0][0] + get_motion_delta(motion->f_code[0]);
  3278.     motion_x = bound_motion_vector(motion_x, motion->f_code[0]);
  3279.     motion->pmv[1][0] = motion->pmv[0][0] = motion_x;
  3280.     NEEDBITS;
  3281.     other_x = ((motion_x + (motion_x > 0)) >> 1) + get_dmv();
  3283.     motion_y = motion->pmv[0][1] + get_motion_delta(motion->f_code[1]);
  3284.     motion_y = bound_motion_vector(motion_y, motion->f_code[1]);
  3285.     motion->pmv[1][1] = motion->pmv[0][1] = motion_y;
  3286.     other_y = ((motion_y + (motion_y > 0)) >> 1) + get_dmv () + m_dmv_offset;
  3288.     MOTION(m_mc->put, motion->ref[0], motion_x, motion_y, 16, 0);
  3289.     MOTION(m_mc->avg, motion->ref[1], other_x, other_y, 16, 0);
  3290. }
  3292. void CMpeg2Decoder::motion_fi_conceal()
  3293. {
  3294.     int tmp;
  3296.     NEEDBITS;
  3297.     DUMPBITS(1); /* remove field_select */
  3299.     tmp = m_f_motion.pmv[0][0] + get_motion_delta (m_f_motion.f_code[0]);
  3300.     tmp = bound_motion_vector(tmp, m_f_motion.f_code[0]);
  3301.     m_f_motion.pmv[1][0] = m_f_motion.pmv[0][0] = tmp;
  3303.     NEEDBITS;
  3304.     tmp = m_f_motion.pmv[0][1] + get_motion_delta(m_f_motion.f_code[1]);
  3305.     tmp = bound_motion_vector(tmp, m_f_motion.f_code[1]);
  3306.     m_f_motion.pmv[1][1] = m_f_motion.pmv[0][1] = tmp;
  3308.     DUMPBITS(1); /* remove marker_bit */
  3309. }
  3311. #define MOTION_CALL(routine, direction)
  3312. do {
  3313.     if((direction) & MACROBLOCK_MOTION_FORWARD)
  3314. routine(&m_f_motion, m_mc->put);
  3315.     if((direction) & MACROBLOCK_MOTION_BACKWARD)
  3316. routine(&m_b_motion, (direction & MACROBLOCK_MOTION_FORWARD) ? m_mc->avg : m_mc->put);
  3317. } while (0)
  3319. #define NEXT_MACROBLOCK
  3320. do {
  3321.     m_offset += 16;
  3322.     if(m_offset == m_width) {
  3323.     m_dest[0] += 16 * m_stride;
  3324.     m_dest[1] += 4 * m_stride;
  3325.     m_dest[2] += 4 * m_stride;
  3326. m_v_offset += 16;
  3327. if(m_v_offset > m_limit_y)
  3328. return;
  3329. m_offset = 0;
  3330.     }
  3331. } while (0)
  3333. void CMpeg2Decoder::mpeg2_init_fbuf(uint8_t* current_fbuf[3], uint8_t* forward_fbuf[3], uint8_t* backward_fbuf[3])
  3334. {
  3335.     int offset, stride, height, bottom_field;
  3337.     stride = m_width;
  3338.     bottom_field = (m_picture_structure == BOTTOM_FIELD);
  3339.     offset = bottom_field ? stride : 0;
  3340.     height = m_height;
  3342.     m_picture_dest[0] = current_fbuf[0] + offset;
  3343.     m_picture_dest[1] = current_fbuf[1] + (offset >> 1);
  3344.     m_picture_dest[2] = current_fbuf[2] + (offset >> 1);
  3346.     m_f_motion.ref[0][0] = forward_fbuf[0] + offset;
  3347.     m_f_motion.ref[0][1] = forward_fbuf[1] + (offset >> 1);
  3348.     m_f_motion.ref[0][2] = forward_fbuf[2] + (offset >> 1);
  3350.     m_b_motion.ref[0][0] = backward_fbuf[0] + offset;
  3351.     m_b_motion.ref[0][1] = backward_fbuf[1] + (offset >> 1);
  3352.     m_b_motion.ref[0][2] = backward_fbuf[2] + (offset >> 1);
  3354.     if(m_picture_structure != FRAME_PICTURE)
  3355. {
  3356. m_dmv_offset = bottom_field ? 1 : -1;
  3357. m_f_motion.ref2[0] = m_f_motion.ref[bottom_field];
  3358. m_f_motion.ref2[1] = m_f_motion.ref[!bottom_field];
  3359. m_b_motion.ref2[0] = m_b_motion.ref[bottom_field];
  3360. m_b_motion.ref2[1] = m_b_motion.ref[!bottom_field];
  3361. offset = stride - offset;
  3363. if(m_second_field && (m_coding_type != B_TYPE))
  3364. forward_fbuf = current_fbuf;
  3366. m_f_motion.ref[1][0] = forward_fbuf[0] + offset;
  3367. m_f_motion.ref[1][1] = forward_fbuf[1] + (offset >> 1);
  3368. m_f_motion.ref[1][2] = forward_fbuf[2] + (offset >> 1);
  3370. m_b_motion.ref[1][0] = backward_fbuf[0] + offset;
  3371. m_b_motion.ref[1][1] = backward_fbuf[1] + (offset >> 1);
  3372. m_b_motion.ref[1][2] = backward_fbuf[2] + (offset >> 1);
  3374. stride <<= 1;
  3375. height >>= 1;
  3376. }
  3378. m_stride = stride;
  3379. m_uv_stride = stride >> 1;
  3380. m_limit_x = 2 * m_width - 32;
  3381. m_limit_y_16 = 2 * height - 32;
  3382. m_limit_y_8 = 2 * height - 16;
  3383. m_limit_y = height - 16;
  3384. }
  3386. int CMpeg2Decoder::slice_init(int code)
  3387. {
  3388.     int offset;
  3389.     const MBAtab* mba;
  3391.     m_dc_dct_pred[0] = m_dc_dct_pred[1] =
  3392. m_dc_dct_pred[2] = 128 << m_intra_dc_precision;
  3394.     m_f_motion.pmv[0][0] = m_f_motion.pmv[0][1] = 0;
  3395.     m_f_motion.pmv[1][0] = m_f_motion.pmv[1][1] = 0;
  3396.     m_b_motion.pmv[0][0] = m_b_motion.pmv[0][1] = 0;
  3397.     m_b_motion.pmv[1][0] = m_b_motion.pmv[1][1] = 0;
  3399.     if(m_vertical_position_extension)
  3400. {
  3401. code += UBITS(bit_buf, 3) << 7;
  3402. DUMPBITS(3);
  3403.     }
  3405.     m_v_offset = (code - 1) * 16;
  3406.     offset = (code - 1) * m_stride * 4;
  3408.     m_dest[0] = m_picture_dest[0] + offset * 4;
  3409.     m_dest[1] = m_picture_dest[1] + offset;
  3410.     m_dest[2] = m_picture_dest[2] + offset;
  3412.     m_quantizer_scale = get_quantizer_scale();
  3414.     /* ignore intra_slice and all the extra data */
  3415.     while(bit_buf & 0x80000000)
  3416. {
  3417. DUMPBITS(9);
  3418. NEEDBITS;
  3419.     }
  3421.     /* decode initial macroblock address increment */
  3422.     offset = 0;
  3423.     while(1)
  3424. {
  3425. if(bit_buf >= 0x08000000)
  3426. {
  3427. mba = MBA_5 + (UBITS(bit_buf, 6) - 2);
  3428. break;
  3429. }
  3430. else if(bit_buf >= 0x01800000)
  3431. {
  3432. mba = MBA_11 + (UBITS(bit_buf, 12) - 24);
  3433. break;
  3434. }
  3435. else 
  3436. {
  3437. switch(UBITS(bit_buf, 12))
  3438. {
  3439. case 8: /* macroblock_escape */
  3440. offset += 33;
  3441. DUMPBITS(11);
  3442. NEEDBITS;
  3443. continue;
  3444. case 15: /* macroblock_stuffing (MPEG1 only) */
  3445. bit_buf &= 0xfffff;
  3446. DUMPBITS(11);
  3447. NEEDBITS;
  3448. continue;
  3449. default: /* error */
  3450. return 1;
  3451. }
  3452. }
  3453. }
  3455. DUMPBITS(mba->len + 1);
  3456. m_offset = (offset + mba->mba) << 4;
  3458. while(m_offset - m_width >= 0)
  3459. {
  3460. m_offset -= m_width;
  3461. m_dest[0] += 16 * m_stride;
  3462. m_dest[1] += 4 * m_stride;
  3463. m_dest[2] += 4 * m_stride;
  3464. m_v_offset += 16;
  3465. }
  3467. if(m_v_offset > m_limit_y)
  3468. return 1;
  3470. return 0;
  3471. }
  3473. void CMpeg2Decoder::mpeg2_slice(int code, const uint8_t* buffer)
  3474. {
  3475.     m_bitstream_buf = (buffer[0] << 24) | (buffer[1] << 16) | (buffer[2] << 8) | buffer[3];
  3476.     m_bitstream_ptr = buffer + 4;
  3477.     m_bitstream_bits = -16;
  3479.     if(slice_init(code))
  3480. return;
  3482. while(1)
  3483. {
  3484. int macroblock_modes;
  3485. int mba_inc;
  3486. const MBAtab * mba;
  3488. NEEDBITS;
  3490. macroblock_modes = get_macroblock_modes();
  3492. /* maybe integrate MACROBLOCK_QUANT test into get_macroblock_modes ? */
  3493. if(macroblock_modes & MACROBLOCK_QUANT)
  3494. m_quantizer_scale = get_quantizer_scale();
  3496. if(macroblock_modes & MACROBLOCK_INTRA)
  3497. {
  3498. int DCT_offset, DCT_stride;
  3499. int offset;
  3500. uint8_t* dest_y;
  3502. if(m_concealment_motion_vectors)
  3503. {
  3504. if(m_picture_structure == FRAME_PICTURE) motion_fr_conceal();
  3505. else motion_fi_conceal();
  3506. }
  3507. else
  3508. {
  3509. m_f_motion.pmv[0][0] = m_f_motion.pmv[0][1] = 0;
  3510. m_f_motion.pmv[1][0] = m_f_motion.pmv[1][1] = 0;
  3511. m_b_motion.pmv[0][0] = m_b_motion.pmv[0][1] = 0;
  3512. m_b_motion.pmv[1][0] = m_b_motion.pmv[1][1] = 0;
  3513. }
  3515. if(macroblock_modes & DCT_TYPE_INTERLACED)
  3516. {
  3517. DCT_offset = m_stride;
  3518. DCT_stride = m_stride * 2;
  3519. }
  3520. else
  3521. {
  3522. DCT_offset = m_stride * 8;
  3523. DCT_stride = m_stride;
  3524. }
  3526. offset = m_offset;
  3527. dest_y = m_dest[0] + offset;
  3528. slice_intra_DCT(0, dest_y, DCT_stride);
  3529. slice_intra_DCT(0, dest_y + 8, DCT_stride);
  3530. slice_intra_DCT(0, dest_y + DCT_offset, DCT_stride);
  3531. slice_intra_DCT(0, dest_y + DCT_offset + 8, DCT_stride);
  3532. slice_intra_DCT(1, m_dest[1] + (offset >> 1), m_uv_stride);
  3533. slice_intra_DCT (2, m_dest[2] + (offset >> 1), m_uv_stride);
  3535. if(m_coding_type == D_TYPE)
  3536. {
  3537. NEEDBITS;
  3538. DUMPBITS(1);
  3539. }
  3540. }
  3541. else
  3542. {
  3543. if(m_picture_structure == FRAME_PICTURE)
  3544. {
  3545. switch(macroblock_modes & MOTION_TYPE_MASK)
  3546. {
  3547. case MC_FRAME:
  3548. if(m_mpeg1) MOTION_CALL(motion_mp1, macroblock_modes);
  3549. else MOTION_CALL (motion_fr_frame, macroblock_modes);
  3550. break;
  3552. case MC_FIELD:
  3553. MOTION_CALL(motion_fr_field, macroblock_modes);
  3554. break;
  3556. case MC_DMV:
  3557. MOTION_CALL(motion_fr_dmv, MACROBLOCK_MOTION_FORWARD);
  3558. break;
  3560. case 0:
  3561. /* non-intra mb without forward mv in a P picture */
  3562. m_f_motion.pmv[0][0] = 0;
  3563. m_f_motion.pmv[0][1] = 0;
  3564. m_f_motion.pmv[1][0] = 0;
  3565. m_f_motion.pmv[1][1] = 0;
  3566. MOTION_CALL(motion_zero, MACROBLOCK_MOTION_FORWARD);
  3567. break;
  3568. }
  3569. }
  3570. else
  3571. {
  3572. switch (macroblock_modes & MOTION_TYPE_MASK)
  3573. {
  3574. case MC_FIELD:
  3575. MOTION_CALL(motion_fi_field, macroblock_modes);
  3576. break;
  3578. case MC_16X8:
  3579. MOTION_CALL(motion_fi_16x8, macroblock_modes);
  3580. break;
  3582. case MC_DMV:
  3583. MOTION_CALL(motion_fi_dmv, MACROBLOCK_MOTION_FORWARD);
  3584. break;
  3586. case 0:
  3587. /* non-intra mb without forward mv in a P picture */
  3588. m_f_motion.pmv[0][0] = 0;
  3589. m_f_motion.pmv[0][1] = 0;
  3590. m_f_motion.pmv[1][0] = 0;
  3591. m_f_motion.pmv[1][1] = 0;
  3592. MOTION_CALL(motion_zero, MACROBLOCK_MOTION_FORWARD);
  3593. break;
  3594. }
  3595. }
  3597. if(macroblock_modes & MACROBLOCK_PATTERN)
  3598. {
  3599. int coded_block_pattern;
  3600. int DCT_offset, DCT_stride;
  3601. int offset;
  3602. uint8_t* dest_y;
  3604. if(macroblock_modes & DCT_TYPE_INTERLACED)
  3605. {
  3606. DCT_offset = m_stride;
  3607. DCT_stride = m_stride * 2;
  3608. }
  3609. else
  3610. {
  3611. DCT_offset = m_stride * 8;
  3612. DCT_stride = m_stride;
  3613. }
  3615. coded_block_pattern = get_coded_block_pattern();
  3617. offset = m_offset;
  3618. dest_y = m_dest[0] + offset;
  3620. if(coded_block_pattern & 0x20)
  3621. slice_non_intra_DCT(dest_y, DCT_stride);
  3622. if(coded_block_pattern & 0x10)
  3623. slice_non_intra_DCT(dest_y + 8, DCT_stride);
  3624. if(coded_block_pattern & 0x08)
  3625. slice_non_intra_DCT(dest_y + DCT_offset, DCT_stride);
  3626. if(coded_block_pattern & 0x04)
  3627. slice_non_intra_DCT(dest_y + DCT_offset + 8, DCT_stride);
  3628. if(coded_block_pattern & 0x2)
  3629. slice_non_intra_DCT(m_dest[1] + (offset >> 1), m_uv_stride);
  3630. if(coded_block_pattern & 0x1)
  3631. slice_non_intra_DCT(m_dest[2] + (offset >> 1), m_uv_stride);
  3632. }
  3634. m_dc_dct_pred[0] = 
  3635. m_dc_dct_pred[1] = 
  3636. m_dc_dct_pred[2] = 128 << m_intra_dc_precision;
  3637. }
  3639. NEXT_MACROBLOCK;
  3641. NEEDBITS;
  3642. mba_inc = 0;
  3643. while(1)
  3644. {
  3645. if(bit_buf >= 0x10000000)
  3646. {
  3647. mba = MBA_5 + (UBITS(bit_buf, 5) - 2);
  3648. break;
  3649. }
  3650. else if(bit_buf >= 0x03000000)
  3651. {
  3652. mba = MBA_11 + (UBITS(bit_buf, 11) - 24);
  3653. break;
  3654. }
  3655. else
  3656. {
  3657. switch(UBITS(bit_buf, 11))
  3658. {
  3659. case 8: /* macroblock_escape */
  3660. mba_inc += 33;
  3661. /* pass through */
  3662. case 15: /* macroblock_stuffing (MPEG1 only) */
  3663. DUMPBITS(11);
  3664. NEEDBITS;
  3665. continue;
  3666. default: /* end of slice, or error */
  3667. return;
  3668. }
  3669. }
  3670. }
  3672. DUMPBITS(mba->len);
  3673. mba_inc += mba->mba;
  3675. if(mba_inc)
  3676. {
  3677. m_dc_dct_pred[0] = 
  3678. m_dc_dct_pred[1] =
  3679. m_dc_dct_pred[2] = 128 << m_intra_dc_precision;
  3681. if(m_coding_type == P_TYPE)
  3682. {
  3683. m_f_motion.pmv[0][0] = m_f_motion.pmv[0][1] = 0;
  3684. m_f_motion.pmv[1][0] = m_f_motion.pmv[1][1] = 0;
  3686. do {
  3687. MOTION_CALL(motion_zero, MACROBLOCK_MOTION_FORWARD);
  3688. NEXT_MACROBLOCK;
  3689. } while(--mba_inc);
  3690. }
  3691. else
  3692. {
  3693. do {
  3694. MOTION_CALL (motion_reuse, macroblock_modes);
  3695. NEXT_MACROBLOCK;
  3696. } while(--mba_inc);
  3697. }
  3698. }
  3699. }
  3700. }
  3702. #undef bit_buf
  3703. #undef bits
  3704. #undef bit_ptr
  3706. ///////////////////////////////////////////////////////////////////////////////////////////
  3707. ///////////////////////////////////////////////////////////////////////////////////////////
  3709. CMpeg2Info::CMpeg2Info()
  3710. {
  3711. m_sequence = NULL;
  3712.     m_gop = NULL;
  3713. Reset();
  3714. }
  3716. CMpeg2Info::~CMpeg2Info()
  3717. {
  3718. }
  3720. void CMpeg2Info::Reset()
  3721. {
  3722.     m_current_picture = m_current_picture_2nd = NULL;
  3723.     m_display_picture = m_display_picture_2nd = NULL;
  3724.     m_current_fbuf = m_display_fbuf = m_discard_fbuf = NULL;
  3725.     m_user_data = NULL;
  3726. m_user_data_len = 0;
  3727. }