theora_parser.c 21 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735
  1. // SPDX-License-Identifier: LGPL-2.1 OR BSD-3-Clause
  2. //--=========================================================================--
  3. // This file is a part of BlackBird Video Codec Modeling project
  4. //-----------------------------------------------------------------------------
  5. //
  6. // This confidential and proprietary software may be used only
  7. // as authorized by a licensing agreement from Chips&Media Inc.
  8. // In the event of publication, the following notice is applicable:
  9. //
  10. // (C) COPYRIGHT 2010 CHIPS&MEDIA INC.
  11. // ALL RIGHTS RESERVED
  12. //
  13. // The entire notice above must be reproduced on all authorized
  14. // copies.
  15. //
  16. //-----------------------------------------------------------------------------
  17. //--=========================================================================--
  18. #include <stdio.h>
  19. #include <stdlib.h>
  20. #include <string.h>
  21. #include "state.h"
  22. #include "decint.h"
  23. #include "theora_parser.h"
  24. #include "theoradec.h"
  25. #define THO_SEQ_HEADER_LEN 32
  26. #define THO_PIC_INFO_LEN 20
  27. #define THO_PIC_DATA_OFFSET 16
  28. #define THO_SIZE_INFO_LEN 8
  29. #define THO_SIZE_SKIP_FRAME 16
  30. #define OFFSET_NOMV_MB 12
  31. #define OFFSET_MV_MB 22
  32. #define MEMORY_SWAP 1
  33. #define THO_MB_FIXED_SIZE 12 // fixed mb data size(12byte) except mv, qcm
  34. #define THO_MB_MV_SIZE 10 // MV buffer size(10byte)
  35. #define THO_QMAT_SIZE 768 //(3*2*64*sizeof(short)
  36. enum {
  37. THO_INTRA_FRAME = 0,
  38. THO_INTER_FRAME = 1
  39. };
  40. enum {
  41. THO_SEQ_INIT = 1,
  42. THO_SEQ_END = 2,
  43. THO_PIC_RUN = 3,
  44. THO_SET_FRAME_BUF = 4,
  45. };
  46. enum
  47. {
  48. MV_X =0,
  49. MV_Y
  50. };
  51. enum
  52. {
  53. LUMA_BLK_0 = 0,
  54. LUMA_BLK_1 = 1,
  55. LUMA_BLK_2 = 2,
  56. LUMA_BLK_3 = 3,
  57. CHROMA_BLK_0 = 4,
  58. CHROMA_BLK_1 = 5
  59. };
  60. typedef enum CODED__IDX
  61. {
  62. CR_CUR = 5, // Cr, current block
  63. CB_CUR = 4, // Cb, current block
  64. LU_CUR3 = 3, // luma, current MB block #3
  65. LU_CUR2 = 2, // luma, current MB block #2
  66. LU_CUR1 = 1, // luma, current MB block #1
  67. LU_CUR0 = 0 // luma, current MB block #0
  68. } CODED__IDX;
  69. typedef enum {
  70. VDI_LITTLE_ENDIAN = 0,
  71. VDI_BIG_ENDIAN,
  72. VDI_32BIT_LITTLE_ENDIAN,
  73. VDI_32BIT_BIG_ENDIAN,
  74. } EndianMode;
  75. #ifndef PUT_BYTE
  76. #define PUT_BYTE(_p, _b) \
  77. *_p++ = (unsigned char)_b;
  78. #endif
  79. #ifndef PUT_BUFFER
  80. #define PUT_BUFFER(_p, _buf, _len) \
  81. memcpy(_p, _buf, _len); \
  82. _p += _len;
  83. #endif
  84. #ifndef PUT_LE64
  85. #define PUT_LE64(_p, _var) \
  86. *_p++ = (unsigned char)((_var)>>0); \
  87. *_p++ = (unsigned char)((_var)>>8); \
  88. *_p++ = (unsigned char)((_var)>>16); \
  89. *_p++ = (unsigned char)((_var)>>24); \
  90. *_p++ = (unsigned char)((_var)>>32); \
  91. *_p++ = (unsigned char)((_var)>>40); \
  92. *_p++ = (unsigned char)((_var)>>48); \
  93. *_p++ = (unsigned char)((_var)>>56);
  94. #endif
  95. #ifndef PUT_LE32
  96. #define PUT_LE32(_p, _var) \
  97. *_p++ = (unsigned char)((_var)>>0); \
  98. *_p++ = (unsigned char)((_var)>>8); \
  99. *_p++ = (unsigned char)((_var)>>16); \
  100. *_p++ = (unsigned char)((_var)>>24);
  101. #endif
  102. #ifndef PUT_BE32
  103. #define PUT_BE32(_p, _var) \
  104. *_p++ = (unsigned char)((_var)>>24); \
  105. *_p++ = (unsigned char)((_var)>>16); \
  106. *_p++ = (unsigned char)((_var)>>8); \
  107. *_p++ = (unsigned char)((_var)>>0);
  108. #endif
  109. #ifndef PUT_LE16
  110. #define PUT_LE16(_p, _var) \
  111. *_p++ = (unsigned char)((_var)>>0); \
  112. *_p++ = (unsigned char)((_var)>>8);
  113. #endif
  114. #ifndef PUT_BE16
  115. #define PUT_BE16(_p, _var) \
  116. *_p++ = (unsigned char)((_var)>>8); \
  117. *_p++ = (unsigned char)((_var)>>0);
  118. #endif
  119. #ifndef AV_RB16
  120. # define AV_RB16(x) \
  121. ((((const uint8_t*)(x))[0] << 8) | \
  122. ((const uint8_t*)(x))[1])
  123. #endif
  124. #ifndef AV_WB16
  125. # define AV_WB16(p, d) do { \
  126. ((uint8_t*)(p))[1] = (d); \
  127. ((uint8_t*)(p))[0] = (d)>>8; \
  128. } while(0)
  129. #endif
  130. const unsigned char OC_MB_MAP_RASTER[6]=
  131. {
  132. 0,1,2,3,4,8
  133. };
  134. const unsigned char OC_BLOCK_CODED_IDXS[6]=
  135. {
  136. LU_CUR0,LU_CUR1,LU_CUR2,LU_CUR3,CB_CUR,CR_CUR
  137. };
  138. struct mb_mv_t
  139. {
  140. uint16_t mb_size; // total macro-block data size
  141. uint8_t mb_mode; // one of eight mode(4bit)
  142. uint8_t bcoded; // coded info of block
  143. uint16_t qii_arr; // LSB part is qii_arr[0] - 2bit per entry, total 6 entry
  144. uint8_t eob_pos_c[2]; // eob position of each chroma blocks
  145. uint8_t eob_pos_l[4]; // eob position of each luma blocks
  146. int16_t mvxy[5]; // except it when mb_mode is intra mode or no-mv mode
  147. int16_t qcm[384]; // zig-zag(decoded) order
  148. };
  149. struct mb_nomv_t
  150. {
  151. uint16_t mb_size; // total macro-block data size
  152. uint8_t mb_mode; // one of eight mode(4bit)
  153. uint8_t bcoded; // coded info of block
  154. uint16_t qii_arr; // LSB part is qii_arr[0] - 2bit per entry, total 6 entry
  155. uint8_t eob_pos_c[2]; // eob position of each chroma blocks
  156. uint8_t eob_pos_l[4]; // eob position of each luma blocks
  157. int16_t qcm[384]; // zig-zag(decoded) order
  158. } ;
  159. static int32_t get_mb_nomv(oc_theora_state *state, void *data,
  160. uint8_t mb_mode, uint16_t *mb_fragis)
  161. {
  162. uint16_t qi, bi, fragi;
  163. uint16_t cb_not_coded=0;
  164. uint16_t qcm_addr = 0;
  165. uint8_t quota;
  166. uint8_t *pos;
  167. uint8_t coded, bcoded = 0;
  168. int16_t dc;
  169. int32_t eob_pos;
  170. int32_t qcm_cnt = 0;
  171. int16_t *out_qcm;
  172. const unsigned char *map_idxs;
  173. oc_mb_map *mb_maps;
  174. oc_qcm *frag_qcm;
  175. uint8_t *frag_eob;
  176. oc_fragment *frags;
  177. struct mb_nomv_t *mb_nomv;
  178. frags = state->frags;
  179. frag_qcm = state->frag_qcm;
  180. frag_eob = state->frag_eob;
  181. mb_maps = state->mb_maps_rater_order;
  182. map_idxs = OC_MB_MAP_RASTER;
  183. mb_nomv = (struct mb_nomv_t *)data;
  184. out_qcm = mb_nomv->qcm;
  185. memset(mb_nomv, 0, sizeof(struct mb_nomv_t));
  186. for(bi=0;bi<6;bi++)
  187. {
  188. fragi = mb_fragis[bi];
  189. coded = frags[fragi].coded;
  190. coded = frags[fragi].coded;
  191. //mb_mode
  192. if(coded)
  193. {
  194. int16_t *in_qcm;
  195. // update eob_pos
  196. eob_pos = frag_eob[fragi];
  197. dc = frags[fragi].dc;
  198. //have only dc value from dc precitor
  199. if(eob_pos == 0 && dc)
  200. eob_pos = 1;
  201. // balance dc value from dc predictor
  202. if(eob_pos == 1 && dc == 0)
  203. eob_pos = 0;
  204. pos = (bi<4) ? &(mb_nomv->eob_pos_l[bi]) : &(mb_nomv->eob_pos_c[bi - CHROMA_BLK_0]);
  205. *pos = eob_pos;
  206. // update qcm
  207. in_qcm = frag_qcm[fragi];
  208. quota = eob_pos&(~3);
  209. for(qi=0; qi<quota;qi+=4)
  210. {
  211. *out_qcm++ = *in_qcm; *in_qcm++ = 0;
  212. *out_qcm++ = *in_qcm; *in_qcm++ = 0;
  213. *out_qcm++ = *in_qcm; *in_qcm++ = 0;
  214. *out_qcm++ = *in_qcm; *in_qcm++ = 0;
  215. }
  216. for(;qi<eob_pos;qi++)
  217. {
  218. *out_qcm++ = *in_qcm; *in_qcm++ = 0;
  219. }
  220. qcm_cnt += eob_pos;
  221. }
  222. else
  223. {
  224. pos = (bi<4) ? &(mb_nomv->eob_pos_l[bi]) : &(mb_nomv->eob_pos_c[bi - CHROMA_BLK_0]);
  225. *pos = 0;
  226. }
  227. //coded info for each block
  228. bcoded |= coded*(1<<bi);
  229. //qii for each block
  230. mb_nomv->qii_arr |= (frags[fragi].qii) << (bi*2);
  231. }
  232. //update mb info
  233. mb_nomv->mb_size = THO_MB_FIXED_SIZE
  234. + (qcm_cnt << 1);
  235. mb_nomv->mb_mode = mb_mode;
  236. mb_nomv->bcoded = bcoded;
  237. // mb_size must be 8byte alligned
  238. // we should get padding byte
  239. mb_nomv->mb_size = (mb_nomv->mb_size + 7) & (~0x7);
  240. return mb_nomv->mb_size;
  241. }
  242. static int32_t get_mb_mv(oc_theora_state *state, void *data,
  243. uint8_t mb_mode, uint16_t *mb_fragis)
  244. {
  245. uint16_t qi, bi, fragi;
  246. uint16_t cb_not_coded = 0;
  247. uint16_t qcm_addr = 0;
  248. uint8_t quota;
  249. uint8_t *pos;
  250. uint8_t coded, bcoded = 0, qii_arr=0;
  251. int16_t dc;
  252. int32_t qcm_cnt = 0;
  253. int16_t *out_qcm;
  254. oc_mv *frag_mvs;
  255. oc_qcm *frag_qcm;
  256. uint8_t *frag_eob;
  257. oc_fragment *frags;
  258. signed char *mb_modes;
  259. struct mb_mv_t *mb_mv;
  260. frags = state->frags;
  261. frag_mvs = state->frag_mvs;
  262. frag_qcm = state->frag_qcm;
  263. frag_eob = state->frag_eob;
  264. mb_modes = state->mb_modes;
  265. mb_mv = (struct mb_mv_t *)data;
  266. out_qcm = mb_mv->qcm;
  267. memset(mb_mv, 0, sizeof(struct mb_mv_t));
  268. for(bi=0;bi<6;bi++)
  269. {
  270. fragi = mb_fragis[bi];
  271. coded = frags[fragi].coded;
  272. //mb_mode
  273. if(coded)
  274. {
  275. int16_t *in_qcm;
  276. int16_t mv;
  277. int32_t eob_pos;
  278. // update mb_mode
  279. mv = frag_mvs[fragi];
  280. // mv of cr block should not be sent to bpu
  281. if(bi!=5)
  282. {
  283. // sign flag of mv_y should be reversed
  284. // because origin position is differnce to otber standard codec
  285. // mvx : lsb 8bit, mvy : msb 8bit
  286. mb_mv->mvxy[bi] = (OC_MV_X(mv)&0xff) | (OC_MV_Y(mv)*(-1)<<8);
  287. }
  288. //cr_mv is write, if cb is not coded
  289. else if(cb_not_coded)
  290. {
  291. mb_mv->mvxy[CHROMA_BLK_0] = (OC_MV_X(mv)&0xff) | (OC_MV_Y(mv)*(-1)<<8);
  292. }
  293. // update eob_pos
  294. eob_pos = frag_eob[fragi];
  295. dc = frags[fragi].dc;
  296. //have only dc value from dc precitor
  297. if(eob_pos == 0 && dc)
  298. eob_pos = 1;
  299. // balance dc value from dc predictor
  300. if(eob_pos == 1 && dc == 0)
  301. eob_pos = 0;
  302. pos = (bi<4) ? &(mb_mv->eob_pos_l[bi]) : &(mb_mv->eob_pos_c[bi - CHROMA_BLK_0]);
  303. *pos = eob_pos;
  304. // update qcm
  305. in_qcm = frag_qcm[fragi];
  306. quota = eob_pos&(~3);
  307. for(qi=0; qi<quota;qi+=4)
  308. {
  309. *out_qcm++ = *in_qcm; *in_qcm++ = 0;
  310. *out_qcm++ = *in_qcm; *in_qcm++ = 0;
  311. *out_qcm++ = *in_qcm; *in_qcm++ = 0;
  312. *out_qcm++ = *in_qcm; *in_qcm++ = 0;
  313. }
  314. for(;qi<eob_pos;qi++)
  315. {
  316. *out_qcm++ = *in_qcm; *in_qcm++ = 0;
  317. }
  318. qcm_cnt += eob_pos;
  319. }
  320. else
  321. {
  322. pos = (bi<4) ? &(mb_mv->eob_pos_l[bi]) : &(mb_mv->eob_pos_c[bi - CHROMA_BLK_0]);
  323. *pos = 0;
  324. //mv of cr block is sent, if cb block is not coded
  325. if(bi==CHROMA_BLK_0)
  326. {
  327. cb_not_coded = 1;
  328. continue;
  329. }
  330. if(bi!=CHROMA_BLK_1)
  331. mb_mv->mvxy[bi] = 0;
  332. }
  333. //coded info for each block
  334. bcoded |= coded*(1<<bi);
  335. //qii info for each block
  336. mb_mv->qii_arr |= (frags[fragi].qii) << (bi*2);
  337. }
  338. //update mb info
  339. mb_mv->mb_size = THO_MB_FIXED_SIZE
  340. + THO_MB_MV_SIZE
  341. + (qcm_cnt<<1);
  342. mb_mv->mb_mode = mb_mode;
  343. mb_mv->bcoded = bcoded;
  344. // mb_size must be 8byte alligned
  345. // we should get padding byte
  346. mb_mv->mb_size = (mb_mv->mb_size + 7) & (~0x7);
  347. return mb_mv->mb_size;
  348. }
  349. int32_t theora_make_mb_data(oc_theora_state *state, unsigned char* pMbData)
  350. {
  351. const unsigned char *mapIdxs;
  352. int32_t nmbs, mbi;
  353. int32_t mbsSize = 0;
  354. oc_mb_map *mb_maps = state->mb_maps_rater_order;
  355. oc_fragment *frags = state->frags;
  356. oc_fragment_plane *fplanes = &state->fplanes[0];
  357. unsigned char *pData = pMbData;
  358. nmbs = (fplanes->nvfrags>>1)*(fplanes->nhfrags>>1);
  359. mapIdxs = OC_MB_MAP_RASTER;
  360. for(mbi=0; mbi< nmbs;mbi++)
  361. {
  362. /*Loop through the macro blocks in each super block in display order.*/
  363. uint8_t mb_mode;
  364. uint16_t bytes;
  365. uint16_t mb_fragi[6];
  366. int32_t *mb_map = (int32_t *)mb_maps[mbi];
  367. // block 0
  368. mb_fragi[0] = mb_map[0]; mb_mode =frags[mb_fragi[0]].mb_mode;
  369. // block 1
  370. mb_fragi[1] = mb_map[1]; mb_mode |=frags[mb_fragi[1]].mb_mode;
  371. // block 2
  372. mb_fragi[2] = mb_map[2]; mb_mode |=frags[mb_fragi[2]].mb_mode;
  373. // block 3
  374. mb_fragi[3] = mb_map[3]; mb_mode |=frags[mb_fragi[3]].mb_mode;
  375. // block 4
  376. mb_fragi[4] = mb_map[4]; mb_mode |=frags[mb_fragi[4]].mb_mode;
  377. // block 5
  378. mb_fragi[5] = mb_map[8]; mb_mode |=frags[mb_fragi[5]].mb_mode;
  379. if(mb_mode != OC_MODE_INTER_NOMV
  380. && mb_mode != OC_MODE_INTRA
  381. && mb_mode != OC_MODE_GOLDEN_NOMV)
  382. {
  383. bytes = get_mb_mv(state, pData, mb_mode, mb_fragi);
  384. }
  385. else
  386. bytes = get_mb_nomv(state, pData, mb_mode, mb_fragi);
  387. mbsSize += bytes;
  388. pData += bytes;
  389. }
  390. return mbsSize;
  391. }
  392. // mem swap 64bit little endian to 64bit big endian
  393. int32_t tho_swap_endian(unsigned char *data, int32_t len, int32_t swap_flag)
  394. {
  395. uint32_t *p;
  396. uint32_t v1, v2, v3;
  397. int32_t i;
  398. p = (uint32_t *)data;
  399. if (swap_flag)
  400. {
  401. for (i=0; i<len/4; i+=2)
  402. {
  403. v1 = p[i];
  404. v2 = ( v1 >> 24) & 0xFF;
  405. v2 |= ((v1 >> 16) & 0xFF) << 8;
  406. v2 |= ((v1 >> 8) & 0xFF) << 16;
  407. v2 |= ((v1 >> 0) & 0xFF) << 24;
  408. v3 = v2;
  409. v1 = p[i+1];
  410. v2 = ( v1 >> 24) & 0xFF;
  411. v2 |= ((v1 >> 16) & 0xFF) << 8;
  412. v2 |= ((v1 >> 8) & 0xFF) << 16;
  413. v2 |= ((v1 >> 0) & 0xFF) << 24;
  414. p[i] = v2;
  415. p[i+1] = v3;
  416. }
  417. }
  418. return 0;
  419. }
  420. int32_t theora_parser_init(void **parser)
  421. {
  422. tho_ctx *ctx;
  423. tho_parser_t *tho;
  424. tho = calloc(1, sizeof(tho_parser_t));
  425. ctx = calloc(1, sizeof(tho_ctx));
  426. tho->open = theora_parser_open;
  427. tho->close = theora_parser_end;
  428. tho->read_frame = theora_parser_frame;
  429. tho->handle = (void*)ctx;
  430. *parser = (void**)tho;
  431. return 1;
  432. }
  433. int32_t theora_parser_end(void *parser)
  434. {
  435. tho_parser_t *tho = (tho_parser_t *)parser;
  436. tho_ctx *ctx = (tho_ctx *)tho->handle;
  437. th_info *ti = &ctx->ti;
  438. th_comment *tc = &ctx->tc;
  439. th_dec_ctx *td = ctx->td;
  440. if(tho)
  441. {
  442. if(ctx)
  443. {
  444. th_decodesys_mem_free(td);
  445. th_comment_clear(tc);
  446. th_info_clear(ti);
  447. free(ctx);
  448. }
  449. free(tho);
  450. }
  451. return 1;
  452. }
  453. int32_t theora_parser_open(void *handle, unsigned char *header, int32_t header_size, int32_t* scaleInfo)
  454. {
  455. int32_t ret;
  456. tho_ctx *ctx = (tho_ctx *)handle;
  457. th_info *ti = &ctx->ti;
  458. th_comment *tc = &ctx->tc;
  459. th_setup_info *ts = NULL;
  460. th_dec_ctx *td = NULL;
  461. /* init supporting Theora structures needed in header parsing */
  462. th_comment_init(tc);
  463. th_info_init(ti);
  464. ret = th_decode_headerin(ti, tc, &ts, header, header_size);
  465. /* and now we have it all. initialize decoders */
  466. if(ret == 0)
  467. {
  468. // decode alloc
  469. td = th_decode_alloc(ti, ts);
  470. ctx->td = td;
  471. ctx->ts = ts;
  472. }else{
  473. /* tear down the partial theora setup */
  474. th_info_clear(ti);
  475. th_comment_clear(tc);
  476. }
  477. /*Either way, we're done with the codec setup data.*/
  478. th_setupsys_mem_free(ts);
  479. /* return scale infomation for display*/
  480. scaleInfo[0] = ti->frame_width;
  481. scaleInfo[1] = ti->frame_height;
  482. scaleInfo[2] = ti->pic_width;
  483. scaleInfo[3] = ti->pic_height;
  484. scaleInfo[4] = ti->pic_x;
  485. scaleInfo[5] = ti->pic_y;
  486. return 1;
  487. }
  488. int32_t theora_parser_frame(void *handle, unsigned char * chunkData, int32_t chunkSize)
  489. {
  490. int32_t ret=0;
  491. tho_ctx *ctx = (tho_ctx *)handle;
  492. th_dec_ctx *td = ctx->td;
  493. ret = th_decode_packetin(td,chunkData, chunkSize, NULL);
  494. if(ret == 2)
  495. ctx->frame_skip_mode = 1;
  496. else
  497. ctx->frame_skip_mode = 0;
  498. return 1;
  499. }
  500. // Return generated frame size
  501. int32_t theora_make_stream(void *handle, unsigned char *stream, int32_t run_cmd)
  502. {
  503. int32_t size;
  504. tho_ctx *ctx = (tho_ctx *)handle;
  505. switch(run_cmd)
  506. {
  507. case THO_SEQ_INIT:
  508. {
  509. unsigned char *header;
  510. th_info *ti = &ctx->ti;
  511. // signature : 4Byte
  512. header = stream;
  513. PUT_BYTE(header, 'C');
  514. PUT_BYTE(header, 'N');
  515. PUT_BYTE(header, 'M');
  516. PUT_BYTE(header, 'V');
  517. // version : 2Byte
  518. PUT_LE16(header, 0);
  519. // header length: 2Byte
  520. PUT_LE16(header, THO_SEQ_HEADER_LEN);
  521. // FourCC : 4Byte
  522. PUT_BYTE(header, 'V');
  523. PUT_BYTE(header, 'P');
  524. PUT_BYTE(header, '3');
  525. PUT_BYTE(header, '0');
  526. // Size Info : 4Byte
  527. PUT_LE16(header, ti->frame_width); // Picture Width
  528. PUT_LE16(header, ti->frame_height); // Picture Height
  529. // Etc : 16Byte
  530. PUT_LE32(header, 0); // Frame Rate
  531. PUT_LE32(header, 0); // Time Scale
  532. PUT_LE32(header, 0); // Frame Number
  533. PUT_LE32(header, 0); // Reserved
  534. size = THO_SEQ_HEADER_LEN;
  535. }
  536. break;
  537. case THO_PIC_RUN:
  538. {
  539. unsigned char *header;
  540. uint32_t qi;
  541. uint32_t picChunkSize;
  542. uint64_t mbsSize, qmatSize;
  543. unsigned char *pData;
  544. oc_theora_state *state = &ctx->td->state;
  545. oc_mb_map *mbMaps = state->mb_maps_rater_order;
  546. oc_fragment *frags = state->frags;
  547. oc_fragment_plane *fplanes = &state->fplanes[0];
  548. // get quantization matrix
  549. if(ctx->frame_skip_mode)
  550. {
  551. /*
  552. /* Set Picture Header
  553. */
  554. header = stream;
  555. PUT_LE32(header, 4); // Chunk Size
  556. PUT_LE32(header, 0); // Time Stamp
  557. PUT_LE32(header, 0); // Time Stamp
  558. PUT_BYTE(header, 1); // skip frame flag
  559. PUT_BYTE(header, 0); // aligned zero bit
  560. PUT_BYTE(header, 0); // aligned zero bit
  561. PUT_BYTE(header, 0); // aligned zero bit
  562. size = THO_SIZE_SKIP_FRAME;
  563. }
  564. else
  565. {
  566. /************************/
  567. /* STORE QMAT DATA */
  568. /* **********************/
  569. header = stream + THO_PIC_DATA_OFFSET;
  570. pData = stream + THO_PIC_DATA_OFFSET + THO_SIZE_INFO_LEN;
  571. qmatSize = (state->nqis*THO_QMAT_SIZE);
  572. for(qi=0; qi<state->nqis; qi++)
  573. {
  574. uint16_t *dst = (uint16_t*)&pData[qi*3*2*64*2];
  575. uint16_t *src = (uint16_t*)&state->dequant_tables[state->qis[qi]][0][0][0];
  576. memcpy(dst,src, sizeof(uint16_t)*64*3*2);
  577. }
  578. // To set Quantization Matrix Size
  579. PUT_LE64(header, qmatSize);
  580. // swap 64bit little endian to 64bit big endian
  581. tho_swap_endian(pData, (int32_t)qmatSize, MEMORY_SWAP);
  582. /*************************/
  583. /* STORE MB DATA */
  584. /*************************/
  585. header = pData + qmatSize;
  586. pData += (qmatSize + THO_SIZE_INFO_LEN);
  587. mbsSize = theora_make_mb_data(state, pData);
  588. // To set MB data size
  589. PUT_LE64(header, mbsSize);
  590. // swap 64bit little endia to 64bit big endian
  591. tho_swap_endian(pData, (int32_t)mbsSize, MEMORY_SWAP);
  592. picChunkSize = (uint32_t)(THO_PIC_INFO_LEN + mbsSize + qmatSize);
  593. /*************************/
  594. /* Set Picture Header
  595. /*************************/
  596. header = stream;
  597. PUT_LE32(header, picChunkSize); // frame size
  598. PUT_LE32(header, 0); // time stamp
  599. PUT_LE32(header, 0); // time stamp
  600. PUT_BYTE(header, 0); // skip frame flag
  601. PUT_BYTE(header, state->frame_type); // frame type
  602. PUT_BYTE(header, state->nqis); // nqis
  603. PUT_BYTE(header, state->loop_filter_limits[state->qis[0]]); // limits-value
  604. size = picChunkSize + 12;
  605. }
  606. }
  607. break;
  608. }
  609. return size;
  610. }