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

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

流媒体/Mpeg4/MP4

开发平台：

Visual C++

bitstream.c：源码内容
  1.  /******************************************************************************
  2.   *                                                                            *
  3.   *  This file is part of XviD, a free MPEG-4 video encoder/decoder            *
  4.   *                                                                            *
  5.   *  XviD is an implementation of a part of one or more MPEG-4 Video tools     *
  6.   *  as specified in ISO/IEC 14496-2 standard.  Those intending to use this    *
  7.   *  software module in hardware or software products are advised that its     *
  8.   *  use may infringe existing patents or copyrights, and any such use         *
  9.   *  would be at such party's own risk.  The original developer of this        *
  10.   *  software module and his/her company, and subsequent editors and their     *
  11.   *  companies, will have no liability for use of this software or             *
  12.   *  modifications or derivatives thereof.                                     *
  13.   *                                                                            *
  14.   *  XviD is free software; you can redistribute it and/or modify it           *
  15.   *  under the terms of the GNU General Public License as published by         *
  16.   *  the Free Software Foundation; either version 2 of the License, or         *
  17.   *  (at your option) any later version.                                       *
  18.   *                                                                            *
  19.   *  XviD is distributed in the hope that it will be useful, but               *
  20.   *  WITHOUT ANY WARRANTY; without even the implied warranty of                *
  21.   *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the             *
  22.   *  GNU General Public License for more details.                              *
  23.   *                                                                            *
  24.   *  You should have received a copy of the GNU General Public License         *
  25.   *  along with this program; if not, write to the Free Software               *
  26.   *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA  *
  27.   *                                                                            *
  28.   ******************************************************************************/
  30.  /******************************************************************************
  31.   *                                                                            *
  32.   *  bitstream.c                                                               *
  33.   *                                                                            *
  34.   *  Copyright (C) 2001 - Peter Ross <pross@cs.rmit.edu.au>                    *
  35.   *                                                                            *
  36.   *  For more information visit the XviD homepage: http://www.xvid.org         *
  37.   *                                                                            *
  38.   ******************************************************************************/
  40.  /******************************************************************************
  41.   *    *
  42.   *  Revision history:                                                         *
  43.   *                                                                            *
  44.   *  26.03.2002 interlacing support
  45.   *  03.03.2002 qmatrix writing    *
  46.   *  03.03.2002 merged BITREADER and BITWRITER    *
  47.   *  30.02.2002 intra_dc_threshold support    *
  48.   *  04.12.2001 support for additional headers    *
  49.   *  16.12.2001 inital version                                               *
  50.   *    *
  51.   ******************************************************************************/
  54. #include "bitstream.h"
  55. #include "zigzag.h"
  56. #include "../quant/quant_matrix.h"
  58. static int __inline log2bin(int value)
  59. {
  60. int n = 0;
  61. while (value)
  62. {
  63. value >>= 1;
  64. n++;
  65. }
  66. return n;
  67. }
  70. static const uint32_t intra_dc_threshold_table[] =
  71. {
  72. 32, /* never use */
  73. 13,
  74. 15,
  75. 17,
  76. 19,
  77. 21,
  78. 23,
  79. 1,
  80. };
  83. void bs_get_matrix(Bitstream * bs, uint8_t * matrix) 
  84. { 
  85. int i = 0; 
  86.     int last, value = 0; 
  87.     
  88.     do 
  89. { 
  90. last = value; 
  91.         value = BitstreamGetBits(bs, 8); 
  92.         matrix[ scan_tables[0][i++] ]  = value; 
  93.     } 
  94.     while (value != 0 && i < 64); 
  95.     
  96. while (i < 64) 
  97. { 
  98. matrix[ scan_tables[0][i++] ]  = last; 
  99. } 
  100. } 
  102. /*
  103. decode headers
  104. returns coding_type, or -1 if error
  105. */
  107. int BitstreamReadHeaders(Bitstream * bs, DECODER * dec, uint32_t * rounding, 
  108.  uint32_t * quant, uint32_t * fcode, uint32_t * intra_dc_threshold,
  109.  int findvol)
  110. {
  111. uint32_t vol_ver_id;
  112. uint32_t time_inc_resolution;
  113. uint32_t coding_type;
  114. uint32_t start_code;
  116. do
  117. {
  118. BitstreamByteAlign(bs);
  119. start_code = BitstreamShowBits(bs, 32);
  121. if (start_code == VISOBJSEQ_START_CODE)
  122. {
  123. // DEBUG("visual_object_sequence");
  124. BitstreamSkip(bs, 32); // visual_object_sequence_start_code
  125. BitstreamSkip(bs, 8); // profile_and_level_indication
  126. }
  127. else if (start_code == VISOBJSEQ_STOP_CODE)
  128. {
  129. BitstreamSkip(bs, 32); // visual_object_sequence_stop_code
  130. }
  131. else if (start_code == VISOBJ_START_CODE)
  132. {
  133. // DEBUG("visual_object");
  134. BitstreamSkip(bs,32); // visual_object_start_code
  135. if (BitstreamGetBit(bs)) // is_visual_object_identified
  136. {
  137. vol_ver_id = BitstreamGetBits(bs,4); // visual_object_ver_id
  138. BitstreamSkip(bs, 3); // visual_object_priority
  139. }
  140. else
  141. {
  142. vol_ver_id = 1;
  143. }
  145. if (BitstreamShowBits(bs, 4) != VISOBJ_TYPE_VIDEO) // visual_object_type
  146. {
  147. DEBUG("visual_object_type != video");
  148. return -1;
  149. }
  150. BitstreamSkip(bs, 4);
  152. // video_signal_type
  154. if (BitstreamGetBit(bs)) // video_signal_type
  155. {
  156. DEBUG("+ video_signal_type");
  157. BitstreamSkip(bs, 3); // video_format
  158. BitstreamSkip(bs, 1); // video_range
  159. if (BitstreamGetBit(bs)) // color_description
  160. {
  161. DEBUG("+ color_description");
  162. BitstreamSkip(bs, 8); // color_primaries
  163. BitstreamSkip(bs, 8); // transfer_characteristics
  164. BitstreamSkip(bs, 8); // matrix_coefficients
  165. }
  166. }
  167. }
  168. else if ((start_code & ~0x1f) == VIDOBJ_START_CODE)
  169. {
  170. BitstreamSkip(bs, 32); // video_object_start_code
  171. } 
  172. else if ((start_code & ~0xf) == VIDOBJLAY_START_CODE)
  173. {
  174. // DEBUG("video_object_layer");
  175. BitstreamSkip(bs, 32); // video_object_layer_start_code
  177. BitstreamSkip(bs, 1); // random_accessible_vol
  179. // video_object_type_indication
  180. if (BitstreamShowBits(bs, 8) != VIDOBJLAY_TYPE_SIMPLE &&
  181. BitstreamShowBits(bs, 8) != VIDOBJLAY_TYPE_CORE &&
  182. BitstreamShowBits(bs, 8) != VIDOBJLAY_TYPE_MAIN &&
  183. BitstreamShowBits(bs, 8) != 0) // BUGGY DIVX
  184. {
  185. DEBUG1("video_object_type_indication not supported", BitstreamShowBits(bs, 8));
  186. return -1;
  187. }
  188. BitstreamSkip(bs, 8);
  191. if (BitstreamGetBit(bs)) // is_object_layer_identifier
  192. {
  193. DEBUG("+ is_object_layer_identifier");
  194. vol_ver_id = BitstreamGetBits(bs,4); // video_object_layer_verid
  195. BitstreamSkip(bs, 3); // video_object_layer_priority
  196. }
  197. else
  198. {
  199. vol_ver_id = 1;
  200. }
  201. //DEBUGI("vol_ver_id", vol_ver_id);
  203. if (BitstreamGetBits(bs, 4) == VIDOBJLAY_AR_EXTPAR) // aspect_ratio_info
  204. {
  205. DEBUG("+ aspect_ratio_info");
  206. BitstreamSkip(bs, 8); // par_width
  207. BitstreamSkip(bs, 8); // par_height
  208. }
  210. if (BitstreamGetBit(bs)) // vol_control_parameters
  211. {
  212. DEBUG("+ vol_control_parameters");
  213. BitstreamSkip(bs, 2); // chroma_format
  214. BitstreamSkip(bs, 1); // low_delay
  215. if (BitstreamGetBit(bs)) // vbv_parameters
  216. {
  217. DEBUG("+ vbv_parameters");
  218. BitstreamSkip(bs, 15); // first_half_bitrate
  219. READ_MARKER();
  220. BitstreamSkip(bs, 15); // latter_half_bitrate
  221. READ_MARKER();
  222. BitstreamSkip(bs, 15); // first_half_vbv_buffer_size
  223. READ_MARKER();
  224. BitstreamSkip(bs, 3); // latter_half_vbv_buffer_size
  225. BitstreamSkip(bs, 11); // first_half_vbv_occupancy
  226. READ_MARKER();
  227. BitstreamSkip(bs, 15); // latter_half_vbv_occupancy
  228. READ_MARKER();
  230. }
  231. }
  233. dec->shape = BitstreamGetBits(bs, 2); // video_object_layer_shape
  234. // DEBUG1("shape", dec->shape);
  236. if (dec->shape == VIDOBJLAY_SHAPE_GRAYSCALE && vol_ver_id != 1)
  237. {
  238. BitstreamSkip(bs, 4); // video_object_layer_shape_extension
  239. }
  241. READ_MARKER();
  243. time_inc_resolution = BitstreamGetBits(bs, 16); // vop_time_increment_resolution
  244. time_inc_resolution--;
  245. if (time_inc_resolution > 0)
  246. {
  247. dec->time_inc_bits = log2bin(time_inc_resolution);
  248. }
  249. else
  250. {
  251. // dec->time_inc_bits = 0;
  253. // for "old" xvid compatibility, set time_inc_bits = 1
  254. dec->time_inc_bits = 1;
  255. }
  257. READ_MARKER();
  259. if (BitstreamGetBit(bs)) // fixed_vop_rate
  260. {
  261. BitstreamSkip(bs, dec->time_inc_bits); // fixed_vop_time_increment
  262. }
  264. if (dec->shape != VIDOBJLAY_SHAPE_BINARY_ONLY)
  265. {
  267. if (dec->shape == VIDOBJLAY_SHAPE_RECTANGULAR)
  268. {
  269. uint32_t width, height;
  271. READ_MARKER();
  272. width = BitstreamGetBits(bs, 13); // video_object_layer_width
  273. //DEBUGI("width", width);
  274. READ_MARKER();
  275. height = BitstreamGetBits(bs, 13); // video_object_layer_height
  276. //DEBUGI("height", height);
  277. READ_MARKER();
  279. if (findvol == 0) {
  280.   if (width != dec->width || height != dec->height)
  281.     {
  282.       DEBUG("FATAL: video dimension discrepancy ***");
  283.       DEBUG2("bitstream width/height", width, height);
  284.       DEBUG2("param width/height", dec->width, dec->height);
  285.       return -1;
  286.     }
  287. } else {
  288.   dec->width = width;
  289.   dec->height = height;
  290. }
  292. }
  294. if ((dec->interlacing = BitstreamGetBit(bs)))
  295. {
  296. DEBUG("vol: interlacing");
  297. }
  299. if (!BitstreamGetBit(bs)) // obmc_disable
  300. {
  301. DEBUG("IGNORED/TODO: !obmc_disable");
  302. // TODO
  303. // fucking divx4.02 has this enabled
  304. }
  306. if (BitstreamGetBits(bs, (vol_ver_id == 1 ? 1 : 2)))  // sprite_enable
  307. {
  308. DEBUG("sprite_enable; not supported");
  309. return -1;
  310. }
  312. if (vol_ver_id != 1 && dec->shape != VIDOBJLAY_SHAPE_RECTANGULAR)
  313. {
  314. BitstreamSkip(bs, 1); // sadct_disable
  315. }
  317. if (BitstreamGetBit(bs)) // not_8_bit
  318. {
  319. DEBUG("+ not_8_bit [IGNORED/TODO]");
  320. dec->quant_bits = BitstreamGetBits(bs, 4); // quant_precision
  321. BitstreamSkip(bs, 4); // bits_per_pixel
  322. }
  323. else
  324. {
  325. dec->quant_bits = 5;
  326. }
  328. if (dec->shape == VIDOBJLAY_SHAPE_GRAYSCALE)
  329. {
  330. BitstreamSkip(bs, 1); // no_gray_quant_update
  331. BitstreamSkip(bs, 1); // composition_method
  332. BitstreamSkip(bs, 1); // linear_composition
  333. }
  335. dec->quant_type = BitstreamGetBit(bs); // quant_type
  336. // DEBUG1("**** quant_type", dec->quant_type);
  338. if (dec->quant_type)
  339. {
  340. if (BitstreamGetBit(bs)) // load_intra_quant_mat
  341. {
  342. uint8_t matrix[64];
  343. bs_get_matrix(bs, matrix);
  344. set_intra_matrix(matrix);
  345. }
  346. else
  347. set_intra_matrix(get_default_intra_matrix());
  349. if (BitstreamGetBit(bs)) // load_inter_quant_mat
  350. {
  351. uint8_t matrix[64]; 
  352. bs_get_matrix(bs, matrix);
  353. set_inter_matrix(matrix);
  354. }
  355. else
  356. set_inter_matrix(get_default_inter_matrix());
  358. if (dec->shape == VIDOBJLAY_SHAPE_GRAYSCALE)
  359. {
  360. // TODO
  361. DEBUG("TODO: grayscale matrix stuff");
  362. return -1;
  363. }
  365. }
  368. if (vol_ver_id != 1)
  369. {
  370. dec->quarterpel = BitstreamGetBit(bs); // quarter_sampe
  371. if (dec->quarterpel)
  372. {
  373. DEBUG("IGNORED/TODO: quarter_sample");
  374. }
  375. }
  376. else
  377. {
  378. dec->quarterpel = 0;
  379. }
  381. if (!BitstreamGetBit(bs)) // complexity_estimation_disable
  382. {
  383. DEBUG("TODO: complexity_estimation header");
  384. // TODO
  385. return -1;
  386. }
  388. if (!BitstreamGetBit(bs)) // resync_marker_disable
  389. {
  390. DEBUG("IGNORED/TODO: !resync_marker_disable");
  391. // TODO
  392. }
  394. if (BitstreamGetBit(bs)) // data_partitioned
  395. {
  396. DEBUG("+ data_partitioned");
  397. BitstreamSkip(bs, 1); // reversible_vlc
  398. }
  400. if (vol_ver_id != 1)
  401. {
  402. if (BitstreamGetBit(bs)) // newpred_enable
  403. {
  404. DEBUG("+ newpred_enable");
  405. BitstreamSkip(bs, 2); // requested_upstream_message_type
  406. BitstreamSkip(bs, 1); // newpred_segment_type
  407. }
  408. if (BitstreamGetBit(bs)) // reduced_resolution_vop_enable
  409. {
  410. DEBUG("TODO: reduced_resolution_vop_enable");
  411. // TODO
  412. return -1;
  413. }
  414. }
  416. if (BitstreamGetBit(bs)) // scalability
  417. {
  418. // TODO
  419. DEBUG("TODO: scalability");
  420. return -1;
  421. }
  422. }
  423. else // dec->shape == BINARY_ONLY
  424. {
  425. if (vol_ver_id != 1)
  426. {
  427. if (BitstreamGetBit(bs)) // scalability
  428. {
  429. // TODO
  430. DEBUG("TODO: scalability");
  431. return -1;
  432. }
  433. }
  434. BitstreamSkip(bs, 1); // resync_marker_disable
  436. }
  437. if (findvol != 0) return 1;
  438. }
  439. else if (start_code == GRPOFVOP_START_CODE)
  440. {
  441. // DEBUG("group_of_vop");
  442. BitstreamSkip(bs, 32);
  443. {
  444. int hours, minutes, seconds;
  445. hours = BitstreamGetBits(bs, 5);
  446. minutes = BitstreamGetBits(bs, 6);
  447. READ_MARKER();
  448. seconds = BitstreamGetBits(bs, 6);
  449. // DEBUG3("hms", hours, minutes, seconds);
  450. }
  451. BitstreamSkip(bs, 1); // closed_gov
  452. BitstreamSkip(bs, 1); // broken_link
  453. }
  454. else if (start_code == VOP_START_CODE)
  455. {
  456.   if (findvol != 0) return -1;
  457. // DEBUG("vop_start_code");
  458. BitstreamSkip(bs, 32); // vop_start_code
  460. coding_type = BitstreamGetBits(bs, 2); // vop_coding_type
  461. //DEBUG1("coding_type", coding_type);
  463. while (BitstreamGetBit(bs) != 0) ; // time_base
  465. READ_MARKER();
  466.  
  467. //DEBUG1("time_inc_bits", dec->time_inc_bits);
  468. //DEBUG1("vop_time_incr", BitstreamShowBits(bs, dec->time_inc_bits));
  469. if (dec->time_inc_bits)
  470. {
  471. BitstreamSkip(bs, dec->time_inc_bits); // vop_time_increment
  472. }
  474. READ_MARKER();
  476. if (!BitstreamGetBit(bs)) // vop_coded
  477. {
  478. return N_VOP;
  479. }
  481. /* if (newpred_enable)
  482. {
  483. }
  484. */
  486. if (coding_type != I_VOP)
  487. {
  488. *rounding = BitstreamGetBit(bs); // rounding_type
  489. //DEBUG1("rounding", *rounding);
  490. }
  492. /* if (reduced_resolution_enable)
  493. {
  494. }
  495. */
  497. if (dec->shape != VIDOBJLAY_SHAPE_RECTANGULAR)
  498. {
  499. uint32_t width, height;
  500. uint32_t horiz_mc_ref, vert_mc_ref;
  502. width = BitstreamGetBits(bs, 13);
  503. READ_MARKER();
  504. height = BitstreamGetBits(bs, 13);
  505. READ_MARKER();
  506. horiz_mc_ref = BitstreamGetBits(bs, 13);
  507. READ_MARKER();
  508. vert_mc_ref = BitstreamGetBits(bs, 13);
  509. READ_MARKER();
  511. // DEBUG2("vop_width/height", width, height);
  512. // DEBUG2("ref             ", horiz_mc_ref, vert_mc_ref);
  514. BitstreamSkip(bs, 1); // change_conv_ratio_disable
  515. if (BitstreamGetBit(bs)) // vop_constant_alpha
  516. {
  517. BitstreamSkip(bs, 8); // vop_constant_alpha_value
  518. }
  519. }
  522. if (dec->shape != VIDOBJLAY_SHAPE_BINARY_ONLY)
  523. {
  524. // intra_dc_vlc_threshold
  525. *intra_dc_threshold = intra_dc_threshold_table[ BitstreamGetBits(bs,3) ];
  527. if (dec->interlacing)
  528. {
  529. if ((dec->top_field_first = BitstreamGetBit(bs)))
  530. {
  531. DEBUG("vop: top_field_first");
  532. }
  533. if ((dec->alternate_vertical_scan = BitstreamGetBit(bs)))
  534. {
  535. DEBUG("vop: alternate_vertical_scan");
  536. }
  537. }
  538. }
  540. *quant = BitstreamGetBits(bs, dec->quant_bits); // vop_quant
  541. //DEBUG1("quant", *quant);
  543. if (coding_type != I_VOP)
  544. {
  545. *fcode = BitstreamGetBits(bs, 3); // fcode_forward
  546. }
  548. if (coding_type == B_VOP)
  549. {
  550. // *fcode_backward = BitstreamGetBits(bs, 3); // fcode_backward
  551. }
  552. return coding_type;
  553. }
  554. else if (start_code == USERDATA_START_CODE)
  555. {
  556. // DEBUG("user_data");
  557. BitstreamSkip(bs, 32); // user_data_start_code
  558. }
  559. else  // start_code == ?
  560. {
  561. if (BitstreamShowBits(bs, 24) == 0x000001)
  562. {
  563. DEBUG1("*** WARNING: unknown start_code", BitstreamShowBits(bs, 32));
  564. }
  565. BitstreamSkip(bs, 8);
  566. }
  567. }
  568. while ((BitstreamPos(bs) >> 3) < bs->length);
  570. DEBUG("*** WARNING: no vop_start_code found");
  571. if (findvol != 0) return 0;
  572. return -1; /* ignore it */
  573. }
  576. /* write custom quant matrix */
  578. static void bs_put_matrix(Bitstream * bs, const int16_t *matrix)
  579. {
  580. int i, j;
  581. const int last = matrix[scan_tables[0][63]];
  583. for (j = 63; j >= 0 && matrix[scan_tables[0][j - 1]] == last; j--) ;
  585. for (i = 0; i <= j; i++)
  586. {
  587. BitstreamPutBits(bs, matrix[scan_tables[0][i]], 8);
  588. }
  590. if (j < 63)
  591. {
  592. BitstreamPutBits(bs, 0, 8);
  593. }
  594. }
  596. #ifdef MPEG4IP
  597. /*
  598. write vosh header
  599. */
  600. void BitstreamWriteVoshHeader(Bitstream * const bs)
  601. {
  602.     BitstreamPad(bs);
  604. BitstreamPutBits(bs, VISOBJSEQ_START_CODE, 32);
  605. BitstreamPutBits(bs, 3, 8); // Simple Profile @ L3
  607. // video object_start_code
  608. BitstreamPutBits(bs, VISOBJ_START_CODE, 32);
  609. // no verid, priority, or signal type
  610.     BitstreamPutBits(bs, 0x08, 8);
  612. // video object_start_code & vo_id
  613. BitstreamPutBits(bs, VO_START_CODE, 27);
  614.     BitstreamPutBits(bs, 0, 5);
  615. }
  616. #endif
  618. /*
  619. write vol header
  620. */
  621. void BitstreamWriteVolHeader(Bitstream * const bs,
  622. const MBParam * pParam)
  623. {
  624.     BitstreamPad(bs);
  626. #ifndef MPEG4IP
  627. // video object_start_code & vo_id
  628. BitstreamPutBits(bs, VO_START_CODE, 27);
  629.     BitstreamPutBits(bs, 0, 5);
  630. #endif
  632. // video_object_layer_start_code & vol_id
  633. BitstreamPutBits(bs, VOL_START_CODE, 28);
  634. BitstreamPutBits(bs, 0, 4);
  636. BitstreamPutBit(bs, 0); // random_accessible_vol
  637. #ifdef MPEG4IP
  638. BitstreamPutBits(bs, 1, 8); // video_object_type_indication
  639. // 1 == simple profile
  640. BitstreamPutBit(bs, 1); // is_object_layer_identified 
  641. BitstreamPutBits(bs, 2, 4); // visual object layer ver id = 2 
  642. BitstreamPutBits(bs, 1, 3); // visual object layer priority = 1 
  643. #else
  644. BitstreamPutBits(bs, 0, 8); // video_object_type_indication
  645. BitstreamPutBit(bs, 0); // is_object_layer_identified (0=not given)
  646. #endif
  647. BitstreamPutBits(bs, 1, 4); // aspect_ratio_info (1=1:1)
  648. BitstreamPutBit(bs, 0); // vol_control_parameters (0=not given)
  649. BitstreamPutBits(bs, 0, 2); // video_object_layer_shape (0=rectangular)
  651. WRITE_MARKER();
  652.     
  653. /* time_increment_resolution; ignored by current decore versions
  654. eg. 2fps res=2 inc=1
  655. 25fps res=25 inc=1
  656. 29.97fps res=30000 inc=1001
  657. */
  658. #ifdef MPEG4IP
  659. BitstreamPutBits(bs, pParam->fbase, 16);
  660. #else
  661. BitstreamPutBits(bs, 2, 16);
  662. #endif
  664. WRITE_MARKER();
  666. // fixed_vop_rate
  667. // MPEG4IP - above comment is incorrect, 0 signals variable rate
  668. BitstreamPutBit(bs, 0);
  670. // fixed_time_increment: value=nth_of_sec, nbits = log2(resolution)
  671. // BitstreamPutBits(bs, 0, 15);
  673. WRITE_MARKER();
  674. BitstreamPutBits(bs, pParam->width, 13); // width
  675. WRITE_MARKER();
  676. BitstreamPutBits(bs, pParam->height, 13); // height
  677. WRITE_MARKER();
  679. BitstreamPutBit(bs, pParam->global_flags & XVID_INTERLACING); // interlace
  680. BitstreamPutBit(bs, 1); // obmc_disable (overlapped block motion compensation)
  681. #ifdef MPEG4IP
  682. BitstreamPutBits(bs, 0, 2); // sprite_usage
  683. #else
  684. BitstreamPutBit(bs, 0); // sprite_enable
  685. #endif
  686. BitstreamPutBit(bs, 0); // not_in_bit
  688. // quant_type   0=h.263  1=mpeg4(quantizer tables)
  689. BitstreamPutBit(bs, pParam->quant_type);
  691. if (pParam->quant_type)
  692. {
  693. BitstreamPutBit(bs, get_intra_matrix_status()); // load_intra_quant_mat
  694. if (get_intra_matrix_status())
  695. {
  696. bs_put_matrix(bs, get_intra_matrix());
  697. }
  699. BitstreamPutBit(bs, get_inter_matrix_status()); // load_inter_quant_mat
  700. if (get_inter_matrix_status())
  701. {
  702. bs_put_matrix(bs, get_inter_matrix());
  703. }
  705. }
  707. #ifdef MPEG4IP
  708. BitstreamPutBit(bs, 0); // quarter pixel
  709. #endif
  710. BitstreamPutBit(bs, 1); // complexity_estimation_disable
  711. BitstreamPutBit(bs, 1); // resync_marker_disable
  712. BitstreamPutBit(bs, 0); // data_partitioned
  713. #ifdef MPEG4IP
  714. BitstreamPutBit(bs, 0); // newpred
  715. BitstreamPutBit(bs, 0); // reduced resolution vop
  716. #endif
  717. BitstreamPutBit(bs, 0); // scalability
  718. }
  721. /*
  722.   write vop header
  724.   NOTE: doesnt handle bother with time_base & time_inc
  725.   time_base = n seconds since last resync (eg. last iframe)
  726.   time_inc = nth of a second since last resync
  727.   (decoder uses these values to determine precise time since last resync)
  728. */
  729. void BitstreamWriteVopHeader(Bitstream * const bs,
  730. const MBParam * pParam)
  731. {
  732.     BitstreamPad(bs);
  733.     BitstreamPutBits(bs, VOP_START_CODE, 32);
  735.     BitstreamPutBits(bs, pParam->coding_type, 2);
  736.     
  737. // time_base = 0  write n x PutBit(1), PutBit(0)
  738. BitstreamPutBits(bs, 0, 1);
  740. WRITE_MARKER();
  742. // time_increment: value=nth_of_sec, nbits = log2(resolution)
  743. #ifdef MPEG4IP
  744. BitstreamPutBits(bs, pParam->fincr, pParam->time_inc_bits);
  745. #else
  746. BitstreamPutBits(bs, 1, 1);
  747. #endif
  749. WRITE_MARKER();
  751. BitstreamPutBits(bs, 1, 1); // vop_coded
  753. if (pParam->coding_type != I_VOP)
  754. BitstreamPutBits(bs, pParam->rounding_type, 1);
  755.     
  756. BitstreamPutBits(bs, 0, 3); // intra_dc_vlc_threshold
  758. if (pParam->global_flags & XVID_INTERLACING)
  759. {
  760. BitstreamPutBit(bs, 1); // top field first
  761. BitstreamPutBit(bs, 0); // alternate vertical scan
  762. }
  764.   BitstreamPutBits(bs, pParam->quant, 5); // quantizer
  766. if (pParam->coding_type != I_VOP)
  767. BitstreamPutBits(bs, pParam->fixed_code, 3); // fixed_code = [1,4]
  768. }