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

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

流媒体/Mpeg4/MP4

开发平台：

Visual C++

encoder.c：源码内容
  1. #include <stdlib.h>
  2. #include <stdio.h>
  3. #include <math.h>
  5. #include "encoder.h"
  6. #include "prediction/mbprediction.h"
  7. #include "global.h"
  8. #include "utils/timer.h"
  9. #include "image/image.h"
  10. #include "bitstream/cbp.h"
  11. #include "utils/mbfunctions.h"
  12. #include "bitstream/bitstream.h"
  13. #include "bitstream/mbcoding.h"
  14. #include "utils/ratecontrol.h"
  15. #include "utils/emms.h"
  16. #include "bitstream/mbcoding.h"
  17. #include "quant/adapt_quant.h"
  18. #include "quant/quant_matrix.h"
  19. #include "utils/mem_align.h"
  21. #define ENC_CHECK(X) if(!(X)) return XVID_ERR_FORMAT
  24. #ifdef MPEG4IP
  25. static int FrameCodeI(Encoder * pEnc, Bitstream * bs, uint32_t *pBits, bool vol_header);
  26. #else
  27. static int FrameCodeI(Encoder * pEnc, Bitstream * bs, uint32_t *pBits);
  28. #endif
  29. static int FrameCodeP(Encoder * pEnc, Bitstream * bs, uint32_t *pBits, bool force_inter, bool vol_header);
  31. static int DQtab[4] = 
  32. {
  33. -1, -2, 1, 2
  34. };
  36. static int iDQtab[5] = 
  37. {
  38. 1, 0, NO_CHANGE, 2, 3
  39. };
  42. int encoder_create(XVID_ENC_PARAM * pParam)
  43. {
  44. Encoder *pEnc;
  45. uint32_t i;
  47. pParam->handle = NULL;
  49. ENC_CHECK(pParam);
  51. ENC_CHECK(pParam->width > 0 && pParam->width <= 1920);
  52. ENC_CHECK(pParam->height > 0 && pParam->height <= 1280);
  53. ENC_CHECK(!(pParam->width % 2));
  54. ENC_CHECK(!(pParam->height % 2));
  56. if (pParam->fincr <= 0 || pParam->fbase <= 0)
  57. {
  58. pParam->fincr = 1;
  59. pParam->fbase = 25;
  60. }
  62. // simplify the "fincr/fbase" fraction
  63. // (neccessary, since windows supplies us with huge numbers)
  65. i = pParam->fincr;
  66. while (i > 1)
  67. {
  68. if (pParam->fincr % i == 0 && pParam->fbase % i == 0)
  69. {
  70. pParam->fincr /= i;
  71. pParam->fbase /= i;
  72. i = pParam->fincr;
  73. continue;
  74. }
  75. i--;
  76. }
  78. if (pParam->fbase > 65535)
  79. {
  80. float div = (float)pParam->fbase / 65535;
  81. pParam->fbase = (int)(pParam->fbase / div);
  82. pParam->fincr = (int)(pParam->fincr / div);
  83. }
  85. if (pParam->bitrate <= 0)
  86. pParam->bitrate = 900000;
  88. if (pParam->rc_buffersize <= 0)
  89. pParam->rc_buffersize = 16;
  91. if ((pParam->min_quantizer <= 0) || (pParam->min_quantizer > 31))
  92. pParam->min_quantizer = 1;
  94. if ((pParam->max_quantizer <= 0) || (pParam->max_quantizer > 31))
  95. pParam->max_quantizer = 31;
  97. if (pParam->max_key_interval == 0) /* 1 keyframe each 10 seconds */ 
  98. pParam->max_key_interval = 10 * pParam->fincr / pParam->fbase;
  100. if (pParam->max_quantizer < pParam->min_quantizer)
  101. pParam->max_quantizer = pParam->min_quantizer;
  103. if ((pEnc = (Encoder *) xvid_malloc(sizeof(Encoder), CACHE_LINE)) == NULL)
  104. return XVID_ERR_MEMORY;
  106. /* Fill members of Encoder structure */
  108. pEnc->mbParam.width = pParam->width;
  109. pEnc->mbParam.height = pParam->height;
  111. pEnc->mbParam.mb_width = (pEnc->mbParam.width + 15) / 16;
  112. pEnc->mbParam.mb_height = (pEnc->mbParam.height + 15) / 16;
  114. pEnc->mbParam.edged_width = 16 * pEnc->mbParam.mb_width + 2 * EDGE_SIZE;
  115. pEnc->mbParam.edged_height = 16 * pEnc->mbParam.mb_height + 2 * EDGE_SIZE;
  117. #ifdef MPEG4IP
  118. pEnc->mbParam.fincr = pParam->fincr;
  119. pEnc->mbParam.fbase = pParam->fbase;
  121. pEnc->mbParam.time_inc_bits = 1;
  122. while (pParam->fbase > (1 << pEnc->mbParam.time_inc_bits)) {
  123. pEnc->mbParam.time_inc_bits++;
  124. }
  125. #endif
  127. pEnc->sStat.fMvPrevSigma = -1;
  129. /* Fill rate control parameters */
  131. pEnc->mbParam.quant = 4;
  133. pEnc->bitrate = pParam->bitrate;
  135. pEnc->iFrameNum = 0;
  136. pEnc->iMaxKeyInterval = pParam->max_key_interval;
  138. /* try to allocate memory */
  140. pEnc->sCurrent.y = pEnc->sCurrent.u = pEnc->sCurrent.v = NULL;
  141. pEnc->sReference.y = pEnc->sReference.u = pEnc->sReference.v = NULL;
  142. pEnc->vInterH.y = pEnc->vInterH.u = pEnc->vInterH.v = NULL;
  143. pEnc->vInterV.y = pEnc->vInterV.u = pEnc->vInterV.v = NULL;
  144. pEnc->vInterVf.y = pEnc->vInterVf.u = pEnc->vInterVf.v = NULL;
  145. pEnc->vInterHV.y = pEnc->vInterHV.u = pEnc->vInterHV.v = NULL;
  146. pEnc->vInterHVf.y = pEnc->vInterHVf.u = pEnc->vInterHVf.v = NULL;
  148. pEnc->pMBs = NULL;
  150. if (image_create(&pEnc->sCurrent, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height) < 0 ||
  151. image_create(&pEnc->sReference, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height) < 0 ||
  152. image_create(&pEnc->vInterH, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height) < 0 ||
  153. image_create(&pEnc->vInterV, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height) < 0 ||
  154. image_create(&pEnc->vInterVf, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height) < 0 ||
  155. image_create(&pEnc->vInterHV, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height) < 0 ||
  156. image_create(&pEnc->vInterHVf, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height) < 0 ||
  157. #ifdef _DEBUG
  158. image_create(&pEnc->sOriginal, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height) < 0 ||
  159. #endif
  160. (pEnc->pMBs = xvid_malloc(sizeof(MACROBLOCK) * pEnc->mbParam.mb_width * pEnc->mbParam.mb_height, CACHE_LINE)) == NULL)
  161. {
  162. image_destroy(&pEnc->sCurrent, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
  163. image_destroy(&pEnc->sReference, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
  164. image_destroy(&pEnc->vInterH, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
  165. image_destroy(&pEnc->vInterV, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
  166. image_destroy(&pEnc->vInterVf, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
  167. image_destroy(&pEnc->vInterHV, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
  168. image_destroy(&pEnc->vInterHVf, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
  169. #ifdef _DEBUG
  170. image_destroy(&pEnc->sOriginal, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
  171. #endif
  172. if (pEnc)
  173. {
  174. xvid_free(pEnc);
  175. }
  176. return XVID_ERR_MEMORY;
  177. }
  179. // init macroblock array
  180. for (i = 0; i < pEnc->mbParam.mb_width * pEnc->mbParam.mb_height; i++)
  181. {
  182. pEnc->pMBs[i].dquant = NO_CHANGE;
  183. }
  185. pParam->handle = (void *)pEnc;
  187. if (pParam->bitrate)
  188. {
  189. RateControlInit(pParam->bitrate, pParam->rc_buffersize, pParam->fbase * 1000 / pParam->fincr,
  190. pParam->max_quantizer, pParam->min_quantizer);
  191. }
  193. init_timer();
  195. return XVID_ERR_OK;
  196. }
  199. int encoder_destroy(Encoder * pEnc)
  200. {
  201. ENC_CHECK(pEnc);
  202. ENC_CHECK(pEnc->sCurrent.y);
  203. ENC_CHECK(pEnc->sReference.y);
  205. xvid_free(pEnc->pMBs);
  206. image_destroy(&pEnc->sCurrent, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
  207. image_destroy(&pEnc->sReference, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
  208. image_destroy(&pEnc->vInterH, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
  209. image_destroy(&pEnc->vInterV, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
  210. image_destroy(&pEnc->vInterVf, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
  211. image_destroy(&pEnc->vInterHV, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
  212. image_destroy(&pEnc->vInterHVf, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
  213. #ifdef _DEBUG
  214. image_destroy(&pEnc->sOriginal, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
  215. #endif
  216. xvid_free(pEnc);
  218. return XVID_ERR_OK;
  219. }
  221. int encoder_encode(Encoder * pEnc, XVID_ENC_FRAME * pFrame, XVID_ENC_STATS * pResult)
  222. {
  223. uint16_t x, y;
  224. Bitstream bs;
  225. uint32_t bits;
  226. uint16_t write_vol_header = 0;
  227. #ifdef _DEBUG
  228. float psnr;
  229. uint8_t temp[100];
  230. #endif
  232. start_global_timer();
  234. ENC_CHECK(pEnc);
  235. ENC_CHECK(pFrame);
  236. ENC_CHECK(pFrame->bitstream);
  237. #ifndef MPEG4IP
  238. ENC_CHECK(pFrame->image);
  239. #endif
  241. pEnc->mbParam.global_flags = pFrame->general;
  242. pEnc->mbParam.motion_flags = pFrame->motion;
  243. pEnc->mbParam.hint = &pFrame->hint;
  245. start_timer();
  246. #ifdef MPEG4IP
  247. if (pFrame->image == NULL 
  248.   && pFrame->colorspace == XVID_CSP_I420) {
  249. ENC_CHECK(pFrame->image_y);
  250. ENC_CHECK(pFrame->image_u);
  251. ENC_CHECK(pFrame->image_v);
  252. ENC_CHECK(pFrame->stride >= pEnc->mbParam.width);
  254. if (yuv_input(&pEnc->sCurrent, 
  255.   pEnc->mbParam.width, 
  256.   pEnc->mbParam.height,
  257.   pEnc->mbParam.edged_width, 
  258.   pFrame->image_y, pFrame->image_u, pFrame->image_v,
  259.   pFrame->stride,
  260.   pFrame->colorspace)) {
  261. return XVID_ERR_FORMAT;
  262. }
  263. } else {
  264. #endif
  265. if (image_input(&pEnc->sCurrent, pEnc->mbParam.width, pEnc->mbParam.height,
  266. pEnc->mbParam.edged_width, pFrame->image, pFrame->colorspace))
  267. {
  268. return XVID_ERR_FORMAT;
  269. }
  270. #ifdef MPEG4IP
  271. }
  272. #endif
  273. stop_conv_timer();
  275. EMMS();
  277. #ifdef _DEBUG
  278. image_copy(&pEnc->sOriginal, &pEnc->sCurrent, pEnc->mbParam.edged_width, pEnc->mbParam.height);
  279. #endif
  281. BitstreamInit(&bs, pFrame->bitstream, 0);
  283. if (pFrame->quant == 0)
  284. {
  285. pEnc->mbParam.quant = RateControlGetQ(0);
  286. }
  287. else
  288. {
  289. pEnc->mbParam.quant = pFrame->quant;
  290. }
  292. if ((pEnc->mbParam.global_flags & XVID_LUMIMASKING) > 0)
  293. {
  294. int * temp_dquants = (int *) xvid_malloc(pEnc->mbParam.mb_width * pEnc->mbParam.mb_height * sizeof(int), CACHE_LINE);
  296. pEnc->mbParam.quant = adaptive_quantization(pEnc->sCurrent.y,
  297.     pEnc->mbParam.width,
  298.     temp_dquants,
  299.     pEnc->mbParam.quant,
  300.     pEnc->mbParam.quant,
  301.     2*pEnc->mbParam.quant,
  302.     pEnc->mbParam.mb_width,
  303.     pEnc->mbParam.mb_height);
  305. for (y = 0; y < pEnc->mbParam.mb_height; y++)
  306. for (x = 0; x < pEnc->mbParam.mb_width; x++)
  307. {
  308. MACROBLOCK *pMB = &pEnc->pMBs[x + y * pEnc->mbParam.mb_width];
  309. pMB->dquant = iDQtab[(temp_dquants[y * pEnc->mbParam.mb_width + x] + 2)];
  310. }
  311. xvid_free(temp_dquants);
  312. }
  314. if(pEnc->mbParam.global_flags & XVID_H263QUANT) {
  315. if(pEnc->mbParam.quant_type != H263_QUANT)
  316. write_vol_header = 1;
  317. pEnc->mbParam.quant_type = H263_QUANT;
  318. }
  319. else if(pEnc->mbParam.global_flags & XVID_MPEGQUANT) {
  320. int ret1, ret2;
  322. ret1 = ret2 = 0;
  324. if(pEnc->mbParam.quant_type != MPEG4_QUANT)
  325. write_vol_header = 1;
  327. pEnc->mbParam.quant_type = MPEG4_QUANT;
  329. if ((pEnc->mbParam.global_flags & XVID_CUSTOM_QMATRIX) > 0) {
  330. if(pFrame->quant_intra_matrix != NULL)
  331. ret1 = set_intra_matrix(pFrame->quant_intra_matrix);
  332. if(pFrame->quant_inter_matrix != NULL)
  333. ret2 = set_inter_matrix(pFrame->quant_inter_matrix);
  334. }
  335. else {
  336. ret1 = set_intra_matrix(get_default_intra_matrix());
  337. ret2 = set_inter_matrix(get_default_inter_matrix());
  338. }
  339. if(write_vol_header == 0)
  340. write_vol_header = ret1 | ret2;
  341. }
  343. #ifdef MPEG4IP
  344. if (pEnc->iFrameNum == 0) {
  345. BitstreamWriteVoshHeader(&bs);
  346. write_vol_header = 1;
  347. }
  348. #endif
  350. if (pFrame->intra < 0)
  351. {
  352. if ((pEnc->iFrameNum == 0) || ((pEnc->iMaxKeyInterval > 0) 
  353.        && (pEnc->iFrameNum >= pEnc->iMaxKeyInterval)))
  355. #ifdef MPEG4IP
  356. pFrame->intra = FrameCodeI(pEnc, &bs, &bits, write_vol_header);
  357. #else
  358. pFrame->intra = FrameCodeI(pEnc, &bs, &bits);
  359. #endif
  360. else
  361. pFrame->intra = FrameCodeP(pEnc, &bs, &bits, 0, write_vol_header);
  362. }
  363. else
  364. {
  365. if (pFrame->intra == 1)
  366. #ifdef MPEG4IP
  367. pFrame->intra = FrameCodeI(pEnc, &bs, &bits, write_vol_header);
  368. #else
  369. pFrame->intra = FrameCodeI(pEnc, &bs, &bits);
  370. #endif
  371. else
  372. pFrame->intra = FrameCodeP(pEnc, &bs, &bits, 1, write_vol_header);
  373. }
  375. BitstreamPutBits(&bs, 0xFFFF, 16);
  376. BitstreamPutBits(&bs, 0xFFFF, 16);
  377. BitstreamPad(&bs);
  378. pFrame->length = BitstreamLength(&bs);
  380. if (pResult)
  381. {
  382. pResult->quant = pEnc->mbParam.quant;
  383. pResult->hlength = pFrame->length - (pEnc->sStat.iTextBits / 8);
  384. pResult->kblks = pEnc->sStat.kblks;
  385. pResult->mblks = pEnc->sStat.mblks;
  386. pResult->ublks = pEnc->sStat.ublks;
  388. #ifdef MPEG4IP
  389. pResult->image_y = pEnc->sCurrent.y;
  390. pResult->image_u = pEnc->sCurrent.u;
  391. pResult->image_v = pEnc->sCurrent.v;
  392. pResult->stride_y = pEnc->mbParam.edged_width;
  393. pResult->stride_uv = pResult->stride_y / 2;
  394. #endif
  395. }
  396.    
  397. EMMS();
  399. if (pFrame->quant == 0)
  400. {
  401. RateControlUpdate(pEnc->mbParam.quant, pFrame->length, pFrame->intra);
  402. }
  404. #ifdef _DEBUG
  405. psnr = image_psnr(&pEnc->sOriginal, &pEnc->sCurrent, pEnc->mbParam.edged_width,
  406. pEnc->mbParam.width, pEnc->mbParam.height);
  408. sprintf(temp, "PSNR: %fn", psnr);
  409. DEBUG(temp);
  410. #endif
  412. pEnc->iFrameNum++;
  413. image_swap(&pEnc->sCurrent, &pEnc->sReference);
  415. stop_global_timer();
  416. write_timer();
  418. return XVID_ERR_OK;
  419. }
  422. static __inline void CodeIntraMB(Encoder *pEnc, MACROBLOCK *pMB) {
  424. pMB->mode = MODE_INTRA;
  426. if ((pEnc->mbParam.global_flags & XVID_LUMIMASKING) > 0) {
  427. if(pMB->dquant != NO_CHANGE)
  428. {
  429. pMB->mode = MODE_INTRA_Q;
  430. pEnc->mbParam.quant += DQtab[pMB->dquant];
  432. if (pEnc->mbParam.quant > 31) pEnc->mbParam.quant = 31;
  433. if (pEnc->mbParam.quant < 1) pEnc->mbParam.quant = 1;
  434. }
  435. }
  437. pMB->quant = pEnc->mbParam.quant;
  438. }
  441. #define FCODEBITS 3
  442. #define MODEBITS 5
  443. static
  444. void HintedMESet(Encoder * pEnc, int * intra)
  445. {
  446. HINTINFO * hint;
  447. Bitstream bs;
  448. int length, high;
  449. uint32_t x, y;
  451. hint = pEnc->mbParam.hint;
  453. if (hint->rawhints)
  454. {
  455. *intra = hint->mvhint.intra;
  456. }
  457. else
  458. {
  459. BitstreamInit(&bs, hint->hintstream, hint->hintlength);
  460. *intra = BitstreamGetBit(&bs);
  461. }
  463. if (*intra)
  464. {
  465. return;
  466. }
  468. pEnc->mbParam.fixed_code = (hint->rawhints) ? hint->mvhint.fcode : BitstreamGetBits(&bs, FCODEBITS);
  470. length = pEnc->mbParam.fixed_code + 5;
  471. high = 1 << (length - 1);
  473. for (y=0 ; y<pEnc->mbParam.mb_height ; ++y)
  474. {
  475. for (x=0 ; x<pEnc->mbParam.mb_width ; ++x)
  476. {
  477. MACROBLOCK * pMB = &pEnc->pMBs[x + y * pEnc->mbParam.mb_width];
  478. MVBLOCKHINT * bhint = &hint->mvhint.block[x + y * pEnc->mbParam.mb_width];
  479. VECTOR pred[4];
  480. VECTOR tmp;
  481. int dummy[4];
  482. int vec;
  484. pMB->mode = (hint->rawhints) ? bhint->mode : BitstreamGetBits(&bs, MODEBITS);
  486. if (pMB->mode == MODE_INTER || pMB->mode == MODE_INTER_Q)
  487. {
  488. tmp.x  = (hint->rawhints) ? bhint->mvs[0].x : BitstreamGetBits(&bs, length);
  489. tmp.y  = (hint->rawhints) ? bhint->mvs[0].y : BitstreamGetBits(&bs, length);
  490. tmp.x -= (tmp.x >= high) ? high*2 : 0;
  491. tmp.y -= (tmp.y >= high) ? high*2 : 0;
  493. get_pmvdata(pEnc->pMBs, x, y, pEnc->mbParam.mb_width, 0, pred, dummy);
  495. for (vec=0 ; vec<4 ; ++vec)
  496. {
  497. pMB->mvs[vec].x  = tmp.x;
  498. pMB->mvs[vec].y  = tmp.y;
  499. pMB->pmvs[vec].x = pMB->mvs[0].x - pred[0].x;
  500. pMB->pmvs[vec].y = pMB->mvs[0].y - pred[0].y;
  501. }
  502. }
  503. else if (pMB->mode == MODE_INTER4V)
  504. {
  505. for (vec=0 ; vec<4 ; ++vec)
  506. {
  507. tmp.x  = (hint->rawhints) ? bhint->mvs[vec].x : BitstreamGetBits(&bs, length);
  508. tmp.y  = (hint->rawhints) ? bhint->mvs[vec].y : BitstreamGetBits(&bs, length);
  509. tmp.x -= (tmp.x >= high) ? high*2 : 0;
  510. tmp.y -= (tmp.y >= high) ? high*2 : 0;
  512. get_pmvdata(pEnc->pMBs, x, y, pEnc->mbParam.mb_width, vec, pred, dummy);
  514. pMB->mvs[vec].x  = tmp.x;
  515. pMB->mvs[vec].y  = tmp.y;
  516. pMB->pmvs[vec].x = pMB->mvs[vec].x - pred[0].x;
  517. pMB->pmvs[vec].y = pMB->mvs[vec].y - pred[0].y;
  518. }
  519. }
  520. else // intra / intra_q / stuffing / not_coded
  521. {
  522. for (vec=0 ; vec<4 ; ++vec)
  523. {
  524. pMB->mvs[vec].x  = pMB->mvs[vec].y  = 0;
  525. }
  526. }
  527. }
  528. }
  529. }
  531. static
  532. void HintedMEGet(Encoder * pEnc, int intra)
  533. {
  534. HINTINFO * hint;
  535. Bitstream bs;
  536. uint32_t x, y;
  537. int length, high;
  539. hint = pEnc->mbParam.hint;
  541. if (hint->rawhints)
  542. {
  543. hint->mvhint.intra = intra;
  544. }
  545. else
  546. {
  547. BitstreamInit(&bs, hint->hintstream, 0);
  548. BitstreamPutBit(&bs, intra);
  549. }
  551. if (intra)
  552. {
  553. if (!hint->rawhints)
  554. {
  555. BitstreamPad(&bs);
  556. hint->hintlength = BitstreamLength(&bs);
  557. }
  558. return;
  559. }
  561. length = pEnc->mbParam.fixed_code + 5;
  562. high = 1 << (length - 1);
  564. if (hint->rawhints)
  565. {
  566. hint->mvhint.fcode = pEnc->mbParam.fixed_code;
  567. }
  568. else
  569. {
  570. BitstreamPutBits(&bs, pEnc->mbParam.fixed_code, FCODEBITS);
  571. }
  573. for (y=0 ; y<pEnc->mbParam.mb_height ; ++y)
  574. {
  575. for (x=0 ; x<pEnc->mbParam.mb_width ; ++x)
  576. {
  577. MACROBLOCK * pMB = &pEnc->pMBs[x + y * pEnc->mbParam.mb_width];
  578. MVBLOCKHINT * bhint = &hint->mvhint.block[x + y * pEnc->mbParam.mb_width];
  579. VECTOR tmp;
  581. if (hint->rawhints)
  582. {
  583. bhint->mode = pMB->mode;
  584. }
  585. else
  586. {
  587. BitstreamPutBits(&bs, pMB->mode, MODEBITS);
  588. }
  590. if (pMB->mode == MODE_INTER || pMB->mode == MODE_INTER_Q)
  591. {
  592. tmp.x  = pMB->mvs[0].x;
  593. tmp.y  = pMB->mvs[0].y;
  594. tmp.x += (tmp.x < 0) ? high*2 : 0;
  595. tmp.y += (tmp.y < 0) ? high*2 : 0;
  597. if (hint->rawhints)
  598. {
  599. bhint->mvs[0].x = tmp.x;
  600. bhint->mvs[0].y = tmp.y;
  601. }
  602. else
  603. {
  604. BitstreamPutBits(&bs, tmp.x, length);
  605. BitstreamPutBits(&bs, tmp.y, length);
  606. }
  607. }
  608. else if (pMB->mode == MODE_INTER4V)
  609. {
  610. int vec;
  612. for (vec=0 ; vec<4 ; ++vec)
  613. {
  614. tmp.x  = pMB->mvs[vec].x;
  615. tmp.y  = pMB->mvs[vec].y;
  616. tmp.x += (tmp.x < 0) ? high*2 : 0;
  617. tmp.y += (tmp.y < 0) ? high*2 : 0;
  619. if (hint->rawhints)
  620. {
  621. bhint->mvs[vec].x = tmp.x;
  622. bhint->mvs[vec].y = tmp.y;
  623. }
  624. else
  625. {
  626. BitstreamPutBits(&bs, tmp.x, length);
  627. BitstreamPutBits(&bs, tmp.y, length);
  628. }
  629. }
  630. }
  631. }
  632. }
  634. if (!hint->rawhints)
  635. {
  636. BitstreamPad(&bs);
  637. hint->hintlength = BitstreamLength(&bs);
  638. }
  639. }
  642. static int FrameCodeI(Encoder * pEnc, Bitstream * bs, uint32_t *pBits
  643. #ifdef MPEG4IP
  644. , bool vol_header
  645. #endif
  646. )
  647. {
  649. DECLARE_ALIGNED_MATRIX(dct_codes, 6, 64, int16_t, CACHE_LINE);
  650. DECLARE_ALIGNED_MATRIX(qcoeff,    6, 64, int16_t, CACHE_LINE);
  652. uint16_t x, y;
  654. pEnc->iFrameNum = 0;
  655. pEnc->mbParam.rounding_type = 1;
  656. pEnc->mbParam.coding_type = I_VOP;
  658. #ifdef MPEG4IP
  659. if (vol_header) {
  660. BitstreamWriteVolHeader(bs, &pEnc->mbParam);
  661. }
  662. #else
  663. BitstreamWriteVolHeader(bs, &pEnc->mbParam);
  664. #endif
  665. BitstreamWriteVopHeader(bs, &pEnc->mbParam);
  667. *pBits = BitstreamPos(bs);
  669. pEnc->sStat.iTextBits = 0;
  670. pEnc->sStat.kblks = pEnc->mbParam.mb_width * pEnc->mbParam.mb_height;
  671. pEnc->sStat.mblks = pEnc->sStat.ublks = 0;
  673. for (y = 0; y < pEnc->mbParam.mb_height; y++)
  674. for (x = 0; x < pEnc->mbParam.mb_width; x++)
  675. {
  676. MACROBLOCK *pMB = &pEnc->pMBs[x + y * pEnc->mbParam.mb_width];
  678. CodeIntraMB(pEnc, pMB);
  680. MBTransQuantIntra(&pEnc->mbParam, pMB, x, y, dct_codes, qcoeff, &pEnc->sCurrent);
  682. start_timer();
  683. MBPrediction(&pEnc->mbParam, x, y, pEnc->mbParam.mb_width, qcoeff, pEnc->pMBs);
  684. stop_prediction_timer();
  686. start_timer();
  687. MBCoding(&pEnc->mbParam, pMB, qcoeff, bs, &pEnc->sStat);
  688. stop_coding_timer();
  689. }
  691. emms();
  693. *pBits = BitstreamPos(bs) - *pBits;
  694. pEnc->sStat.fMvPrevSigma = -1;
  695. pEnc->sStat.iMvSum = 0;
  696. pEnc->sStat.iMvCount = 0;
  697. pEnc->mbParam.fixed_code = 2;
  699. if (pEnc->mbParam.global_flags & XVID_HINTEDME_GET)
  700. {
  701. HintedMEGet(pEnc, 1);
  702. }
  704. return 1;  // intra
  705. }
  708. #define INTRA_THRESHOLD 0.5
  710. static int FrameCodeP(Encoder * pEnc, Bitstream * bs, uint32_t *pBits, bool force_inter, bool vol_header)
  711. {
  712. float fSigma;
  714. DECLARE_ALIGNED_MATRIX(dct_codes, 6, 64, int16_t, CACHE_LINE);
  715. DECLARE_ALIGNED_MATRIX(qcoeff,    6, 64, int16_t, CACHE_LINE);
  717. int iLimit;
  718. uint32_t x, y;
  719. int iSearchRange;
  720. bool bIntra;
  722. IMAGE *pCurrent = &pEnc->sCurrent;
  723. IMAGE *pRef = &pEnc->sReference;
  725. start_timer();
  726. image_setedges(pRef,
  727.        pEnc->mbParam.edged_width,
  728.        pEnc->mbParam.edged_height,
  729.        pEnc->mbParam.width,
  730.        pEnc->mbParam.height,
  731.        pEnc->mbParam.global_flags & XVID_INTERLACING);
  732. stop_edges_timer();
  734. pEnc->mbParam.rounding_type = 1 - pEnc->mbParam.rounding_type;
  736. if (!force_inter)
  737. iLimit = (int)(pEnc->mbParam.mb_width * pEnc->mbParam.mb_height * INTRA_THRESHOLD);
  738. else
  739. iLimit = pEnc->mbParam.mb_width * pEnc->mbParam.mb_height + 1;
  741. if ((pEnc->mbParam.global_flags & XVID_HALFPEL) > 0) {
  742. start_timer();
  743. image_interpolate(pRef, &pEnc->vInterH, &pEnc->vInterV, &pEnc->vInterHV,
  744.   pEnc->mbParam.edged_width, pEnc->mbParam.edged_height,
  745.   pEnc->mbParam.rounding_type);
  746. stop_inter_timer();
  747. }
  749. start_timer();
  750. if (pEnc->mbParam.global_flags & XVID_HINTEDME_SET)
  751. {
  752. HintedMESet(pEnc, &bIntra);
  753. }
  754. else
  755. {
  756. bIntra = MotionEstimation(pEnc->pMBs, &pEnc->mbParam, &pEnc->sReference,
  757.   &pEnc->vInterH, &pEnc->vInterV,
  758.   &pEnc->vInterHV, &pEnc->sCurrent, iLimit);
  759. }
  760. stop_motion_timer();
  762. if (bIntra == 1)
  763. {
  764. #ifdef MPEG4IP
  765. return FrameCodeI(pEnc, bs, pBits, vol_header);
  766. #else
  767. return FrameCodeI(pEnc, bs, pBits);
  768. #endif
  769. }
  771. pEnc->mbParam.coding_type = P_VOP;
  773. if(vol_header)
  774. BitstreamWriteVolHeader(bs, &pEnc->mbParam);
  776. BitstreamWriteVopHeader(bs, &pEnc->mbParam);
  778. *pBits = BitstreamPos(bs);
  780. pEnc->sStat.iTextBits = 0;
  781. pEnc->sStat.iMvSum = 0;
  782. pEnc->sStat.iMvCount = 0;
  783. pEnc->sStat.kblks = pEnc->sStat.mblks = pEnc->sStat.ublks = 0;
  785. for(y = 0; y < pEnc->mbParam.mb_height; y++)
  786. {
  787. for(x = 0; x < pEnc->mbParam.mb_width; x++)
  788. {
  789. MACROBLOCK * pMB = &pEnc->pMBs[x + y * pEnc->mbParam.mb_width];
  791. bIntra = (pMB->mode == MODE_INTRA) || (pMB->mode == MODE_INTRA_Q);
  793. if (!bIntra)
  794. {
  795. start_timer();
  796. MBMotionCompensation(pMB,
  797.      x, y,
  798.      &pEnc->sReference,
  799.      &pEnc->vInterH,
  800.      &pEnc->vInterV,
  801.      &pEnc->vInterHV,
  802.      &pEnc->sCurrent,
  803.      dct_codes,
  804.      pEnc->mbParam.width,
  805.      pEnc->mbParam.height,
  806.      pEnc->mbParam.edged_width,
  807.      pEnc->mbParam.rounding_type);
  808. stop_comp_timer();
  810. if ((pEnc->mbParam.global_flags & XVID_LUMIMASKING) > 0) {
  811. if(pMB->dquant != NO_CHANGE) {
  812. pMB->mode = MODE_INTER_Q;
  813. pEnc->mbParam.quant += DQtab[pMB->dquant];
  814. if (pEnc->mbParam.quant > 31) pEnc->mbParam.quant = 31;
  815. else if(pEnc->mbParam.quant < 1) pEnc->mbParam.quant = 1;
  816. }
  817. }
  818. pMB->quant = pEnc->mbParam.quant;
  820. pMB->field_pred = 0;
  822. pMB->cbp = MBTransQuantInter(&pEnc->mbParam, pMB, x, y, dct_codes, qcoeff, pCurrent);
  823. }
  824. else 
  825. {
  826. CodeIntraMB(pEnc, pMB);
  827. MBTransQuantIntra(&pEnc->mbParam, pMB, x, y, dct_codes, qcoeff, pCurrent);
  828. }
  830. start_timer();
  831. MBPrediction(&pEnc->mbParam, x, y, pEnc->mbParam.mb_width, qcoeff, pEnc->pMBs);
  832. stop_prediction_timer();
  834. if (pMB->mode == MODE_INTRA || pMB->mode == MODE_INTRA_Q)
  835. {
  836. pEnc->sStat.kblks++;
  837. }
  838. else if (pMB->cbp || 
  839.  pMB->mvs[0].x || pMB->mvs[0].y ||
  840.  pMB->mvs[1].x || pMB->mvs[1].y ||
  841.  pMB->mvs[2].x || pMB->mvs[2].y ||
  842.  pMB->mvs[3].x || pMB->mvs[3].y)
  843. {
  844. pEnc->sStat.mblks++;
  845. }
  846. else
  847. {
  848. pEnc->sStat.ublks++;
  849. }
  851. start_timer();
  852. MBCoding(&pEnc->mbParam, pMB, qcoeff, bs, &pEnc->sStat);
  853. stop_coding_timer();
  854. }
  855. }
  857. emms();
  859. if (pEnc->mbParam.global_flags & XVID_HINTEDME_GET)
  860. {
  861. HintedMEGet(pEnc, 0);
  862. }
  864. if (pEnc->sStat.iMvCount == 0)
  865. pEnc->sStat.iMvCount = 1;
  867. fSigma = (float)sqrt((float) pEnc->sStat.iMvSum / pEnc->sStat.iMvCount);
  869. iSearchRange = 1 << (3 + pEnc->mbParam.fixed_code);
  871. if ((fSigma > iSearchRange / 3) 
  872.     && (pEnc->mbParam.fixed_code <= 3)) // maximum search range 128
  873. {
  874. pEnc->mbParam.fixed_code++;
  875. iSearchRange *= 2;
  876. }
  877. else if ((fSigma < iSearchRange / 6)
  878.  && (pEnc->sStat.fMvPrevSigma >= 0)
  879.  && (pEnc->sStat.fMvPrevSigma < iSearchRange / 6)
  880.  && (pEnc->mbParam.fixed_code >= 2)) // minimum search range 16
  881. {
  882. pEnc->mbParam.fixed_code--;
  883. iSearchRange /= 2;
  884. }
  886. pEnc->sStat.fMvPrevSigma = fSigma;
  887.     
  888. *pBits = BitstreamPos(bs) - *pBits;
  890. return 0;  // inter
  891. }