bsfeeder_framesize_impl.c 33 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062
  1. //--=========================================================================--
  2. // This file is a part of QC Tool project
  3. //-----------------------------------------------------------------------------
  4. //
  5. // This confidential and proprietary software may be used only
  6. // as authorized by a licensing agreement from Chips&Media Inc.
  7. // In the event of publication, the following notice is applicable:
  8. //
  9. // (C) COPYRIGHT 2004 - 2011 CHIPS&MEDIA INC.
  10. // ALL RIGHTS RESERVED
  11. //
  12. // The entire notice above must be reproduced on all authorized
  13. // copies.
  14. //
  15. //--=========================================================================--
  16. #include "main_helper.h"
  17. #ifdef SUPPORT_FFMPEG_DEMUX
  18. #include "theora_parser.h"
  19. #include <libavformat/avformat.h>
  20. #define RCV_V2
  21. #define IS_VP9_SUPERFRAME(__header) ((__header & 0xe0) == 0xc0)
  22. #define MAX_VP9_SUPERFRAME_INDEX_SIZE 34
  23. #define VP9_MAX_SUBFRAMES 8
  24. typedef struct VP9Superframe {
  25. Uint32 nframes;
  26. Uint32 frameSize[VP9_MAX_SUBFRAMES];
  27. void* frames[VP9_MAX_SUBFRAMES]; /* A superframe has multiple frames up to 8 frames. */
  28. Uint32 currentIndex;
  29. } VP9Superframe;
  30. typedef struct ReaderContext {
  31. AVFormatContext* avContext;
  32. BOOL isFirstPacket;
  33. Uint32 videoIndex;
  34. Uint32 standard;
  35. Uint32 mp4ClassId;
  36. tho_parser_t* theora;
  37. Uint8* tempBuffer;
  38. Uint32 tempRdPtr;
  39. Uint32 tempWrPtr;
  40. Uint32 seqWidth;
  41. Uint32 seqHeight;
  42. VP9Superframe superframe;
  43. } ReaderContext;
  44. static Uint32 u_bytes(
  45. Uint8* data,
  46. Uint32 len
  47. )
  48. {
  49. Uint32 i;
  50. Uint32 val=0;
  51. for (i=0; i<len; i++) {
  52. val |= data[i] << (i*8);
  53. }
  54. return val;
  55. }
  56. static BOOL VP9ParseSuperframe(
  57. void* chunk,
  58. Uint32 size,
  59. VP9Superframe* superframe
  60. )
  61. {
  62. Uint32 startPos;
  63. Uint32 frameSizeLength = 0;
  64. Uint32 numFrames, totalSubframeSize = 0;
  65. Uint32 i;
  66. Uint8* pData = NULL, superframeMarker;
  67. startPos = size - 1;
  68. pData = (Uint8*)chunk;
  69. pData = &pData[startPos];
  70. superframeMarker = *pData;
  71. frameSizeLength = ((*pData>>3) & 0x03) + 1;
  72. numFrames = (*pData&0x07) + 1;
  73. pData -= frameSizeLength * numFrames + 1;
  74. /* Check first SUPERFRAME_MARKER */
  75. if (*pData != superframeMarker) {
  76. VLOG(ERR, "INVALID POST SUPERFRAME_MARKER\n");
  77. return FALSE;
  78. }
  79. pData++;
  80. for (i=0; i<numFrames; i++) {
  81. superframe->frameSize[i] = u_bytes(pData, frameSizeLength);
  82. pData += frameSizeLength;
  83. }
  84. /* Check size */
  85. for (i=0; i<numFrames; i++) {
  86. totalSubframeSize += superframe->frameSize[i];
  87. }
  88. if (totalSubframeSize >= size) {
  89. VLOG(ERR, "TOTAL SIZE OF SUBFRAMES IS BIGGER THAN CHUNK SIZE\n");
  90. return FALSE;
  91. }
  92. pData = (Uint8*)chunk;
  93. for (i=0; i<numFrames; i++) {
  94. superframe->frames[i] = (void*)osal_malloc(superframe->frameSize[i]);
  95. osal_memcpy(superframe->frames[i], (void*)pData, superframe->frameSize[i]);
  96. pData += superframe->frameSize[i];
  97. }
  98. superframe->currentIndex = 0;
  99. superframe->nframes = numFrames;
  100. return TRUE;
  101. }
  102. static Int32 BuildSeqHeader(
  103. Uint8* pbHeader,
  104. const CodStd codStd,
  105. const AVStream* st,
  106. Int32* sizelength
  107. )
  108. {
  109. /*lint -save -e438 */
  110. AVCodecContext* avc = st->codec;
  111. Uint8* pbMetaData = avc->extradata;
  112. Int32 nMetaData = avc->extradata_size;
  113. Uint8* p = pbMetaData;
  114. Uint8 *a = p + 4 - ((long) p & 3);
  115. Uint8* t = pbHeader;
  116. Int32 size;
  117. Int32 fourcc;
  118. Int32 sps, pps, i, nal;
  119. Int32 frameRate = 0;
  120. fourcc = avc->codec_tag;
  121. if (!fourcc)
  122. fourcc = ConvCodecIdToFourcc(avc->codec_id);
  123. if (st->avg_frame_rate.den && st->avg_frame_rate.num)
  124. frameRate = (Int32)((double)st->avg_frame_rate.num/(double)st->avg_frame_rate.den);
  125. size = 0;
  126. *sizelength = 4; // default size length(in bytes) = 4
  127. if (codStd == STD_AVC || codStd == STD_AVS) {
  128. if (nMetaData > 1 && pbMetaData && pbMetaData[0] == 0x01) {
  129. // check mov/mo4 file format stream
  130. p += 4;
  131. *sizelength = (*p++ & 0x3) + 1;
  132. sps = (*p & 0x1f); // Number of sps
  133. p++;
  134. for (i = 0; i < sps; i++) {
  135. nal = (*p << 8) + *(p + 1) + 2;
  136. PUT_BYTE(t, 0x00);
  137. PUT_BYTE(t, 0x00);
  138. PUT_BYTE(t, 0x00);
  139. PUT_BYTE(t, 0x01);
  140. PUT_BUFFER(t, p+2, nal-2);
  141. p += nal;
  142. size += (nal - 2 + 4); // 4 => length of start code to be inserted
  143. }
  144. pps = *(p++); // number of pps
  145. for (i = 0; i < pps; i++)
  146. {
  147. nal = (*p << 8) + *(p + 1) + 2;
  148. PUT_BYTE(t, 0x00);
  149. PUT_BYTE(t, 0x00);
  150. PUT_BYTE(t, 0x00);
  151. PUT_BYTE(t, 0x01);
  152. PUT_BUFFER(t, p+2, nal-2);
  153. p += nal;
  154. size += (nal - 2 + 4); // 4 => length of start code to be inserted
  155. }
  156. }
  157. else if(nMetaData > 3) {
  158. size = -1;// return to meaning of invalid stream data;
  159. for (; p < a; p++) {
  160. if (p[0] == 0 && p[1] == 0 && p[2] == 1) {
  161. // find startcode
  162. size = avc->extradata_size;
  163. PUT_BUFFER(pbHeader, pbMetaData, size);
  164. break;
  165. }
  166. }
  167. }
  168. }
  169. else if (codStd == STD_HEVC) {
  170. if (nMetaData > 1 && pbMetaData && pbMetaData[0] == 0x01) {
  171. static const Uint8 nalu_header[4] = { 0, 0, 0, 1 };
  172. Int32 numOfArrays = 0;
  173. Uint16 numNalus = 0;
  174. Uint16 nalUnitLength = 0;
  175. Uint32 offset = 0;
  176. p += 21;
  177. *sizelength = (*p++ & 0x3) + 1;
  178. numOfArrays = *p++;
  179. while(numOfArrays--) {
  180. p++; // NAL type
  181. numNalus = (*p << 8) + *(p + 1);
  182. p+=2;
  183. for(i = 0;i < numNalus;i++)
  184. {
  185. nalUnitLength = (*p << 8) + *(p + 1);
  186. p+=2;
  187. //if(i == 0)
  188. {
  189. osal_memcpy(pbHeader + offset, nalu_header, 4);
  190. offset += 4;
  191. osal_memcpy(pbHeader + offset, p, nalUnitLength);
  192. offset += nalUnitLength;
  193. }
  194. p += nalUnitLength;
  195. }
  196. }
  197. size = offset;
  198. }
  199. else if(nMetaData > 3)
  200. {
  201. size = -1;// return to meaning of invalid stream data;
  202. for (; p < a; p++)
  203. {
  204. if (p[0] == 0 && p[1] == 0 && p[2] == 1) // find startcode
  205. {
  206. size = avc->extradata_size;
  207. PUT_BUFFER(pbHeader, pbMetaData, size);
  208. break;
  209. }
  210. }
  211. }
  212. }
  213. else if (codStd == STD_VC1)
  214. {
  215. if (!fourcc)
  216. return -1;
  217. if (fourcc == MKTAG('W', 'V', 'C', '1') || fourcc == MKTAG('W', 'M', 'V', 'A')) //VC AP
  218. {
  219. size = nMetaData;
  220. PUT_BUFFER(pbHeader, pbMetaData, size);
  221. //if there is no seq startcode in pbMetatData. VPU will be failed at seq_init stage.
  222. }
  223. else
  224. {
  225. #ifdef RCV_V2
  226. PUT_LE32(pbHeader, ((0xC5 << 24)|0));
  227. size += 4; //version
  228. PUT_LE32(pbHeader, nMetaData);
  229. size += 4;
  230. PUT_BUFFER(pbHeader, pbMetaData, nMetaData);
  231. size += nMetaData;
  232. PUT_LE32(pbHeader, avc->height);
  233. size += 4;
  234. PUT_LE32(pbHeader, avc->width);
  235. size += 4;
  236. PUT_LE32(pbHeader, 12);
  237. size += 4;
  238. PUT_LE32(pbHeader, 2 << 29 | 1 << 28 | 0x80 << 24 | 1 << 0);
  239. size += 4; // STRUCT_B_FRIST (LEVEL:3|CBR:1:RESERVE:4:HRD_BUFFER|24)
  240. PUT_LE32(pbHeader, avc->bit_rate);
  241. size += 4; // hrd_rate
  242. PUT_LE32(pbHeader, frameRate);
  243. size += 4; // frameRate
  244. #else //RCV_V1
  245. PUT_LE32(pbHeader, (0x85 << 24) | 0x00);
  246. size += 4; //frames count will be here
  247. PUT_LE32(pbHeader, nMetaData);
  248. size += 4;
  249. PUT_BUFFER(pbHeader, pbMetaData, nMetaData);
  250. size += nMetaData;
  251. PUT_LE32(pbHeader, avc->height);
  252. size += 4;
  253. PUT_LE32(pbHeader, avc->width);
  254. size += 4;
  255. #endif
  256. }
  257. }
  258. else if (codStd == STD_RV)
  259. {
  260. Int32 st_size =0;
  261. if (!fourcc)
  262. return -1;
  263. if (fourcc != MKTAG('R','V','3','0') && fourcc != MKTAG('R','V','4','0'))
  264. return -1;
  265. size = 26 + nMetaData;
  266. PUT_BE32(pbHeader, size); //Length
  267. PUT_LE32(pbHeader, MKTAG('V', 'I', 'D', 'O')); //MOFTag
  268. PUT_LE32(pbHeader, fourcc); //SubMOFTagl
  269. PUT_BE16(pbHeader, avc->width);
  270. PUT_BE16(pbHeader, avc->height);
  271. PUT_BE16(pbHeader, 0x0c); //BitCount;
  272. PUT_BE16(pbHeader, 0x00); //PadWidth;
  273. PUT_BE16(pbHeader, 0x00); //PadHeight;
  274. PUT_LE32(pbHeader, frameRate);
  275. PUT_BUFFER(pbHeader, pbMetaData, nMetaData); //OpaqueDatata
  276. size += st_size; //add for startcode pattern.
  277. }
  278. else if (codStd == STD_DIV3) {
  279. // not implemented yet
  280. if (!nMetaData) {
  281. PUT_LE32(pbHeader, MKTAG('C', 'N', 'M', 'V')); //signature 'CNMV'
  282. PUT_LE16(pbHeader, 0x00); //version
  283. PUT_LE16(pbHeader, 0x20); //length of header in bytes
  284. PUT_LE32(pbHeader, MKTAG('D', 'I', 'V', '3')); //codec FourCC
  285. PUT_LE16(pbHeader, avc->width); //width
  286. PUT_LE16(pbHeader, avc->height); //height
  287. PUT_LE32(pbHeader, st->avg_frame_rate.num); //frame rate
  288. PUT_LE32(pbHeader, st->avg_frame_rate.den); //time scale(?)
  289. PUT_LE32(pbHeader, st->nb_index_entries); //number of frames in file
  290. PUT_LE32(pbHeader, 0); //unused
  291. size += 32;
  292. return size;
  293. }
  294. PUT_BE32(pbHeader, nMetaData);
  295. size += 4;
  296. PUT_BUFFER(pbHeader, pbMetaData, nMetaData);
  297. size += nMetaData;
  298. }
  299. else if (codStd == STD_VP8) {
  300. PUT_LE32(pbHeader, MKTAG('D', 'K', 'I', 'F')); //signature 'DKIF'
  301. PUT_LE16(pbHeader, 0x00); //version
  302. PUT_LE16(pbHeader, 0x20); //length of header in bytes
  303. PUT_LE32(pbHeader, MKTAG('V', 'P', '8', '0')); //codec FourCC
  304. PUT_LE16(pbHeader, avc->width); //width
  305. PUT_LE16(pbHeader, avc->height); //height
  306. PUT_LE32(pbHeader, st->avg_frame_rate.num); //frame rate
  307. PUT_LE32(pbHeader, st->avg_frame_rate.den); //time scale(?)
  308. PUT_LE32(pbHeader, st->nb_index_entries); //number of frames in file
  309. PUT_LE32(pbHeader, 0); //unused
  310. size += 32;
  311. }
  312. else if (codStd == STD_VP9) {
  313. PUT_LE32(pbHeader, MKTAG('D', 'K', 'I', 'F')); //signature 'DKIF'
  314. PUT_LE16(pbHeader, 0x00); //version
  315. PUT_LE16(pbHeader, 0x20); //length of header in bytes
  316. PUT_LE32(pbHeader, MKTAG('V', 'P', '9', '0')); //codec FourCC
  317. PUT_LE16(pbHeader, avc->width); //width
  318. PUT_LE16(pbHeader, avc->height); //height
  319. PUT_LE32(pbHeader, st->avg_frame_rate.num); //frame rate
  320. PUT_LE32(pbHeader, st->avg_frame_rate.den); //time scale(?)
  321. PUT_LE32(pbHeader, st->nb_index_entries); //number of frames in file
  322. PUT_LE32(pbHeader, 0); //unused
  323. size += 32;
  324. }
  325. else {
  326. PUT_BUFFER(pbHeader, pbMetaData, nMetaData);
  327. size = nMetaData;
  328. }
  329. return size;
  330. /*lint -restore */
  331. }
  332. static Int32 BuildPicHeader(
  333. Uint8* pbHeader,
  334. const CodStd codStd,
  335. const AVStream* st,
  336. const AVPacket* pkt,
  337. Int32 sizelength
  338. )
  339. {
  340. AVCodecContext* avc = st->codec;
  341. Uint8* pbChunk = pkt->data;
  342. Int32 size = 0;
  343. Int32 fourcc;
  344. Int32 cSlice, nSlice;
  345. Int32 i, val, offset;
  346. BOOL hasStartCode = 0;
  347. size = 0;
  348. offset = 0;
  349. fourcc = avc->codec_tag;
  350. if (!fourcc)
  351. fourcc = ConvCodecIdToFourcc(avc->codec_id);
  352. if (codStd == STD_VC1) {
  353. if (!fourcc)
  354. return -1;
  355. if (fourcc == MKTAG('W', 'V', 'C', '1') || fourcc == MKTAG('W', 'M', 'V', 'A')) {
  356. if (pbChunk[0] != 0 || pbChunk[1] != 0 || pbChunk[2] != 1) {
  357. // check start code as prefix (0x00, 0x00, 0x01)
  358. pbHeader[0] = 0x00;
  359. pbHeader[1] = 0x00;
  360. pbHeader[2] = 0x01;
  361. pbHeader[3] = 0x0D; // replace to the correct picture header to indicate as frame
  362. size += 4;
  363. }
  364. }
  365. else {
  366. PUT_LE32(pbHeader, pkt->size | ((pkt->flags & AV_PKT_FLAG_KEY) ? 0x80000000 : 0));
  367. size += 4;
  368. #ifdef RCV_V2
  369. if (AV_NOPTS_VALUE == pkt->pts) {
  370. PUT_LE32(pbHeader, 0);
  371. }
  372. else {
  373. PUT_LE32(pbHeader, (int)((double)(pkt->pts/st->time_base.den))); // milli_sec
  374. }
  375. size += 4;
  376. #endif
  377. }
  378. }
  379. else if (codStd == STD_HEVC) {
  380. if(pkt->size < 5)
  381. return 0;
  382. if (!(avc->extradata_size > 1 && avc->extradata && avc->extradata[0] == 0x01))
  383. {
  384. const Uint8 *pbEnd = pbChunk + 4 - ((intptr_t)pbChunk & 3);
  385. for (; pbChunk < pbEnd ; pbChunk++) {
  386. if (pbChunk[0] == 0 && pbChunk[1] == 0 && pbChunk[2] == 1) {
  387. hasStartCode = TRUE;
  388. break;
  389. }
  390. }
  391. }
  392. if ((!hasStartCode && avc->extradata[0] == 0x01) ||
  393. (avc->extradata_size > 1 && avc->extradata && avc->extradata[0] == 0x01)) {
  394. // check sequence metadata if the stream is mov/mo4 file format.
  395. pbChunk = pkt->data;
  396. while (offset < pkt->size) {
  397. if(sizelength == 3) {
  398. nSlice = pbChunk[offset] << 16 | pbChunk[offset+1] << 8 | pbChunk[offset+2];
  399. pbChunk[offset] = 0x00;
  400. pbChunk[offset+1] = 0x00;
  401. pbChunk[offset+2] = 0x01;
  402. offset += 3;
  403. }
  404. else {// sizeLength = 4
  405. nSlice = pbChunk[offset] << 24 | pbChunk[offset+1] << 16 | pbChunk[offset+2] << 8 | pbChunk[offset+3];
  406. pbChunk[offset] = 0x00;
  407. pbChunk[offset+1] = 0x00;
  408. pbChunk[offset+2] = 0x00;
  409. pbChunk[offset+3] = 0x01; //replace size to startcode
  410. offset += 4;
  411. }
  412. switch ((pbChunk[offset]&0x7E)>>1) { /* NAL unit */
  413. case 39: /* PREFIX SEI */
  414. case 40: /* SUFFIX SEI */
  415. case 32: /* VPS */
  416. case 33: /* SPS */
  417. case 34: /* PPS */
  418. /* check next */
  419. break;
  420. }
  421. offset += nSlice;
  422. }
  423. }
  424. }
  425. else if (codStd == STD_RV) {
  426. int st_size = 0;
  427. if (!fourcc)
  428. return -1;
  429. if (fourcc != MKTAG('R','V','3','0') && fourcc != MKTAG('R','V','4','0')) // RV version 8, 9 , 10
  430. return -1;
  431. cSlice = pbChunk[0] + 1;
  432. nSlice = pkt->size - 1 - (cSlice * 8);
  433. size = 20 + (cSlice*8);
  434. PUT_BE32(pbHeader, nSlice);
  435. if (AV_NOPTS_VALUE == pkt->pts) {
  436. PUT_LE32(pbHeader, 0);
  437. }
  438. else {
  439. PUT_LE32(pbHeader, (int)((double)(pkt->pts/st->time_base.den))); // milli_sec
  440. }
  441. PUT_BE16(pbHeader, avc->frame_number);
  442. PUT_BE16(pbHeader, 0x02); //Flags
  443. PUT_BE32(pbHeader, 0x00); //LastPacket
  444. PUT_BE32(pbHeader, cSlice); //NumSegments
  445. offset = 1;
  446. for (i = 0; i < (int) cSlice; i++)
  447. {
  448. val = (pbChunk[offset+3] << 24) | (pbChunk[offset+2] << 16) | (pbChunk[offset+1] << 8) | pbChunk[offset];
  449. PUT_BE32(pbHeader, val); //isValid
  450. offset += 4;
  451. val = (pbChunk[offset+3] << 24) | (pbChunk[offset+2] << 16) | (pbChunk[offset+1] << 8) | pbChunk[offset];
  452. PUT_BE32(pbHeader, val); //Offset
  453. offset += 4;
  454. }
  455. size += st_size;
  456. }
  457. else if (codStd == STD_AVC) {
  458. if(pkt->size < 5)
  459. return 0;
  460. if (!(avc->extradata_size > 1 && avc->extradata && avc->extradata[0] == 0x01)) {
  461. const Uint8 *pbEnd = pbChunk + 4 - ((intptr_t)pbChunk & 3);
  462. for (; pbChunk < pbEnd ; pbChunk++) {
  463. if (pbChunk[0] == 0 && pbChunk[1] == 0 && pbChunk[2] == 1) {
  464. hasStartCode = 1;
  465. break;
  466. }
  467. }
  468. }
  469. if ((!hasStartCode && avc->extradata[0] == 0x01) ||
  470. (avc->extradata_size > 1 && avc->extradata && avc->extradata[0] == 0x01)) {
  471. // check sequence metadata if the stream is mov/mo4 file format.
  472. pbChunk = pkt->data;
  473. while (offset < pkt->size) {
  474. if(sizelength == 3) {
  475. nSlice = pbChunk[offset] << 16 | pbChunk[offset+1] << 8 | pbChunk[offset+2];
  476. pbChunk[offset] = 0x00;
  477. pbChunk[offset+1] = 0x00;
  478. pbChunk[offset+2] = 0x01;
  479. offset += 3;
  480. }
  481. else { // size length = 4
  482. nSlice = pbChunk[offset] << 24 | pbChunk[offset+1] << 16 | pbChunk[offset+2] << 8 | pbChunk[offset+3];
  483. pbChunk[offset] = 0x00;
  484. pbChunk[offset+1] = 0x00;
  485. pbChunk[offset+2] = 0x00;
  486. pbChunk[offset+3] = 0x01; //replace size to startcode
  487. offset += 4;
  488. }
  489. switch (pbChunk[offset]&0x1f) { /* NAL unit */
  490. case 6: /* SEI */
  491. case 7: /* SPS */
  492. case 8: /* PPS */
  493. case 9: /* AU */
  494. /* check next */
  495. break;
  496. }
  497. offset += nSlice;
  498. }
  499. }
  500. }
  501. else if(codStd == STD_AVS) {
  502. const Uint8* pbEnd;
  503. if(pkt->size < 5)
  504. return 0;
  505. pbEnd = pbChunk + 4 - ((intptr_t)pbChunk & 3);
  506. for (; pbChunk < pbEnd ; pbChunk++) {
  507. if (pbChunk[0] == 0 && pbChunk[1] == 0 && pbChunk[2] == 1) {
  508. hasStartCode = 1;
  509. break;
  510. }
  511. }
  512. if(hasStartCode == 0) {
  513. pbChunk = pkt->data;
  514. while (offset < pkt->size) {
  515. nSlice = pbChunk[offset] << 24 | pbChunk[offset+1] << 16 | pbChunk[offset+2] << 8 | pbChunk[offset+3];
  516. pbChunk[offset] = 0x00;
  517. pbChunk[offset+1] = 0x00;
  518. pbChunk[offset+2] = 0x00;
  519. pbChunk[offset+3] = 0x00; //replace size to startcode
  520. pbChunk[offset+4] = 0x01;
  521. offset += 4;
  522. switch (pbChunk[offset]&0x1f) /* NAL unit */
  523. {
  524. case 6: /* SEI */
  525. case 7: /* SPS */
  526. case 8: /* PPS */
  527. case 9: /* AU */
  528. /* check next */
  529. break;
  530. }
  531. offset += nSlice;
  532. }
  533. }
  534. }
  535. else if (codStd == STD_DIV3 || codStd == STD_VP8 || codStd == STD_VP9) {
  536. PUT_LE32(pbHeader,pkt->size);
  537. PUT_LE32(pbHeader,0);
  538. PUT_LE32(pbHeader,0);
  539. size += 12;
  540. }
  541. return size;
  542. }
  543. static Int32 MakeupTheoraPacket(
  544. tho_parser_t* theora,
  545. BSChunk* packet,
  546. AVPacket* avPacket,
  547. Uint32 seqSize
  548. )
  549. {
  550. size_t size;
  551. Int32 ret;
  552. Uint8* stream = (Uint8*)packet->data;
  553. ret = theora->read_frame(theora->handle, avPacket->data, avPacket->size);
  554. if (ret < 0) {
  555. VLOG(ERR, "%s:%d failed to read theora frame\n", __FUNCTION__, __LINE__);
  556. return -1;
  557. }
  558. size = theora_make_stream(theora->handle, stream+seqSize, PIC_RUN);
  559. return (size + seqSize);
  560. }
  561. void* BSFeederFrameSize_Create(
  562. const char* path,
  563. CodStd codecId,
  564. CodStd* retCodecId,
  565. Uint32* retMp4ClassId,
  566. Uint32* retSeqWidth,
  567. Uint32* retSeqHeight
  568. )
  569. {
  570. /*lint -esym(438, avContext) */
  571. ReaderContext* ffmpegReader = NULL;
  572. AVFormatContext* avContext = NULL;
  573. AVCodecContext* codec = NULL;
  574. AVInputFormat* fmt = NULL;
  575. Int32 error;
  576. Int32 videoIndex;
  577. Uint32 mp4ClassId;
  578. Int32 standard;
  579. av_register_all();
  580. if ((avContext=avformat_alloc_context()) == NULL) {
  581. return NULL;
  582. }
  583. avContext->flags |= CODEC_FLAG_TRUNCATED;
  584. if ((error=avformat_open_input(&avContext, path, fmt, NULL))) {
  585. VLOG(ERR, "%s:%d failed to av_open_input_file error(%d), %s\n",
  586. __FILE__, __LINE__, error, path);
  587. goto __failed_to_end;
  588. }
  589. if ((error=avformat_find_stream_info(avContext, NULL)) < 0) {
  590. VLOG(ERR, "%s:%d failed to avformat_find_stream_info. error(%d)\n",
  591. __FUNCTION__, __LINE__, error);
  592. goto __failed_to_end;
  593. }
  594. videoIndex = av_find_best_stream(avContext, AVMEDIA_TYPE_VIDEO, -1, -1, NULL, 0);
  595. if (videoIndex < 0) {
  596. VLOG(ERR, "%s:%d failed to av_find_best_stream.\n", __FUNCTION__, __LINE__);
  597. goto __failed_to_end;
  598. }
  599. codec = avContext->streams[videoIndex]->codec;
  600. standard = ConvFOURCCToCodStd(codec->codec_tag);
  601. if (standard == -1)
  602. standard = ConvCodecIdToCodStd(codec->codec_id);
  603. mp4ClassId = ConvFOURCCToMp4Class(codec->codec_tag);
  604. if (mp4ClassId == -1)
  605. mp4ClassId = ConvCodecIdToMp4Class(codec->codec_id);
  606. if (standard != STD_MPEG4) {
  607. mp4ClassId = 0;
  608. }
  609. if (retCodecId != NULL) {
  610. *retCodecId = (CodStd)standard;
  611. }
  612. if (retMp4ClassId != NULL) {
  613. *retMp4ClassId = mp4ClassId;
  614. }
  615. if (retSeqWidth != NULL && retSeqHeight != NULL) {
  616. *retSeqWidth = codec->width;
  617. *retSeqHeight = codec->height;
  618. }
  619. if ((ffmpegReader=(ReaderContext*)osal_malloc(sizeof(ReaderContext))) == NULL)
  620. goto __failed_to_end;
  621. ffmpegReader->standard = standard;
  622. ffmpegReader->mp4ClassId = mp4ClassId;
  623. ffmpegReader->avContext = avContext;
  624. ffmpegReader->videoIndex = videoIndex;
  625. ffmpegReader->isFirstPacket = TRUE;
  626. ffmpegReader->tempBuffer = NULL;
  627. ffmpegReader->tempRdPtr = 0;
  628. ffmpegReader->tempWrPtr = 0;
  629. ffmpegReader->theora = NULL;
  630. osal_memset((void*)&ffmpegReader->superframe, 0x00, sizeof(VP9Superframe));
  631. if (standard == STD_THO || standard == STD_VP3) {
  632. theora_parser_init((void**)&ffmpegReader->theora);
  633. fuck
  634. }
  635. return (void*)ffmpegReader;
  636. __failed_to_end:
  637. if (avContext) {
  638. avformat_free_context(avContext);
  639. avContext = NULL;
  640. }
  641. if (ffmpegReader) {
  642. if (ffmpegReader->theora)
  643. ffmpegReader->theora->close(ffmpegReader->theora);
  644. osal_free(ffmpegReader);
  645. }
  646. return NULL;
  647. /*lint +esym(438, avContext) */
  648. }
  649. BOOL BSFeederFrameSize_Destroy(
  650. void* feeder
  651. )
  652. {
  653. ReaderContext* ctx = (ReaderContext*)feeder;
  654. Uint32 i;
  655. if (ctx == NULL) {
  656. VLOG(ERR, "%s:%d Invalid handle\n", __FUNCTION__, __LINE__);
  657. return FALSE;
  658. }
  659. if (ctx->avContext)
  660. avformat_close_input(&ctx->avContext);
  661. if (ctx->theora)
  662. ctx->theora->close(ctx->theora);
  663. for (i=0; i<ctx->superframe.nframes; i++) {
  664. if (ctx->superframe.frames[i] != NULL) {
  665. free(ctx->superframe.frames[i]);
  666. }
  667. }
  668. osal_free(ctx);
  669. return TRUE;
  670. }
  671. Int32 BSFeederFrameSize_Act(
  672. void* feeder,
  673. BSChunk* packet
  674. )
  675. {
  676. ReaderContext* ffmpegReader = (ReaderContext*)feeder;
  677. AVFormatContext* avFormatContext = ffmpegReader->avContext;
  678. AVPacket avpacket;
  679. Int32 error;
  680. Uint8* seqHeader = NULL;
  681. Uint8* picHeader = NULL;
  682. Uint8* ptr;
  683. Int32 seqHeaderSize;
  684. Int32 picHeaderSize;
  685. Uint32 vindex, size, thoSeqSize;
  686. Int32 retSize = -1;
  687. Int32 packetSize = -1;
  688. if (ffmpegReader->tempBuffer) {
  689. goto __consume_tempBuffer;
  690. }
  691. if (ffmpegReader->standard == STD_VP9) {
  692. VP9Superframe* superframe = &ffmpegReader->superframe;
  693. if (superframe->nframes > 0) {
  694. Uint32 index = superframe->currentIndex;
  695. if (index < superframe->nframes) {
  696. osal_memcpy(packet->data, superframe->frames[index], superframe->frameSize[index]);
  697. packet->size = superframe->frameSize[index];
  698. superframe->currentIndex++;
  699. return packet->size;
  700. }
  701. else {
  702. Uint32 i;
  703. for (i=0; i<VP9_MAX_SUBFRAMES; i++) {
  704. if (superframe->frames[i] != NULL) {
  705. osal_free(superframe->frames[i]);
  706. }
  707. }
  708. osal_memset((void*)superframe, 0x00, sizeof(VP9Superframe));
  709. }
  710. }
  711. }
  712. seqHeaderSize = 0;
  713. picHeaderSize = 0;
  714. thoSeqSize = 0;
  715. av_init_packet(&avpacket);
  716. while (TRUE) {
  717. error = av_read_frame(avFormatContext, &avpacket);
  718. if (error < 0) {
  719. if (error == AVERROR_EOF || avFormatContext->pb->eof_reached == TRUE) {
  720. packet->eos = TRUE;
  721. return 0;
  722. }
  723. else {
  724. VLOG(ERR, "%s:%d failed to av_read_frame error(0x%08x)\n",
  725. __FUNCTION__, __LINE__, error);
  726. goto __end_read;
  727. }
  728. }
  729. if (avpacket.stream_index != ffmpegReader->videoIndex)
  730. continue;
  731. break;
  732. }
  733. if (avpacket.size == 0)
  734. return 0;
  735. if (avpacket.size >= (signed)packet->size )
  736. {
  737. VLOG(ERR, "one packet size(%d) is bigger than STREAM_BUF_SIZE(%d)\n", avpacket.size, packet->size);
  738. return -1;
  739. }
  740. osal_memset(packet->data, 0x00, packet->size);
  741. vindex = ffmpegReader->videoIndex;
  742. if (ffmpegReader->isFirstPacket) {
  743. AVCodecContext* codec;
  744. tho_parser_t* theora = ffmpegReader->theora;
  745. Int32 ret;
  746. struct {
  747. int frameWidth ;
  748. int frameHeight ;
  749. int picWidth ;
  750. int picHeight ;
  751. int picOffsetX ;
  752. int picOffsetY ;
  753. } theoraScaleInfo;
  754. codec = ffmpegReader->avContext->streams[vindex]->codec;
  755. seqHeader = (Uint8*)osal_malloc(codec->extradata_size + 1024);
  756. if (seqHeader == NULL) {
  757. goto __end_read;
  758. }
  759. osal_memset((void*)seqHeader, 0x00, codec->extradata_size + 1024);
  760. seqHeaderSize = BuildSeqHeader(seqHeader, (CodStd)ffmpegReader->standard,
  761. ffmpegReader->avContext->streams[vindex], &retSize);
  762. if (seqHeaderSize < 0) {
  763. VLOG(ERR, "%s:%d Can't make sequence header!\n", __FUNCTION__, __LINE__);
  764. packetSize = -1;
  765. goto __end_read;
  766. }
  767. if (ffmpegReader->standard == STD_THO || ffmpegReader->standard == STD_VP3) {
  768. size = seqHeaderSize;
  769. if (ffmpegReader->standard == STD_VP3) {
  770. size = 0;
  771. }
  772. ret = theora->open(theora->handle, seqHeader, size, (Int32*)&theoraScaleInfo);
  773. if (ret < 0) {
  774. VLOG(ERR, "%s:%d failed to open theora parser error(%d)\n", __FUNCTION__, __LINE__, ret);
  775. goto __end_read;
  776. }
  777. thoSeqSize = theora_make_stream(theora->handle, (Uint8*)packet->data, DEC_SEQ_INIT);
  778. osal_free(seqHeader);
  779. seqHeader = NULL;
  780. seqHeaderSize = 0;
  781. }
  782. ffmpegReader->isFirstPacket = FALSE;
  783. }
  784. picHeader = (Uint8*)osal_malloc(1024);
  785. picHeaderSize = BuildPicHeader(picHeader, (CodStd)ffmpegReader->standard,
  786. ffmpegReader->avContext->streams[vindex], &avpacket, 0);
  787. if (picHeaderSize < 0) {
  788. VLOG(ERR, "%s:%d failed to build picture header\n", __FUNCTION__, __LINE__);
  789. goto __end_read;
  790. }
  791. ptr = avpacket.data;
  792. size = avpacket.size;
  793. switch (ffmpegReader->standard) {
  794. case STD_RV:
  795. if (seqHeaderSize)
  796. osal_memcpy((char*)packet->data, seqHeader, seqHeaderSize);
  797. if (picHeaderSize)
  798. osal_memcpy((char*)packet->data+seqHeaderSize, picHeader, picHeaderSize);
  799. if (ffmpegReader->standard == STD_RV) {
  800. int cSlice = ptr[0] + 1;
  801. int nSlice = avpacket.size - 1 - (cSlice*8);
  802. ptr += (1+(cSlice*8));
  803. size = nSlice;
  804. }
  805. osal_memcpy((char*)packet->data+seqHeaderSize+picHeaderSize, ptr, size);
  806. packetSize = seqHeaderSize + picHeaderSize + size;
  807. break;
  808. case STD_THO:
  809. case STD_VP3:
  810. packetSize = MakeupTheoraPacket(ffmpegReader->theora, packet, &avpacket, thoSeqSize);
  811. break;
  812. case STD_VP9:
  813. packet->size = size;
  814. osal_memcpy((char *)packet->data, ptr, size);
  815. packetSize = size;
  816. break;
  817. default:
  818. if (picHeaderSize)
  819. osal_memcpy((char*)packet->data, picHeader, picHeaderSize);
  820. osal_memcpy((char*)packet->data+picHeaderSize, ptr, size);
  821. packetSize = picHeaderSize + size;
  822. break;
  823. }
  824. if (avFormatContext->pb->eof_reached && avFormatContext->packet_buffer == NULL) {
  825. packet->eos = TRUE;
  826. }
  827. // Sequence header data should be only one chunk data unit.
  828. // In case of RV, 1st chunk should be Sequence header + 1st frame.
  829. if (ffmpegReader->standard != STD_VP9 && ffmpegReader->standard != STD_RV) {
  830. if (seqHeaderSize > 0) {
  831. ffmpegReader->tempBuffer = (Uint8*)osal_malloc(packetSize);
  832. ffmpegReader->tempWrPtr = packetSize;
  833. osal_memcpy(ffmpegReader->tempBuffer, (Uint8*)(packet->data), packetSize);
  834. osal_memcpy(packet->data, seqHeader, seqHeaderSize);
  835. packetSize = seqHeaderSize;
  836. goto __end_read;
  837. }
  838. }
  839. else if (ffmpegReader->standard == STD_VP9) {
  840. Uint8* pData = (Uint8*)packet->data;
  841. Uint32 lastIndex = packet->size - 1;
  842. if (IS_VP9_SUPERFRAME(pData[lastIndex]) == TRUE) {
  843. VP9Superframe* superframe = &ffmpegReader->superframe;
  844. if (VP9ParseSuperframe(pData, packet->size, superframe) == TRUE) {
  845. osal_memcpy(packet->data, superframe->frames[0], superframe->frameSize[0]);
  846. packet->size = superframe->frameSize[0];
  847. packetSize = packet->size;
  848. superframe->currentIndex++;
  849. }
  850. }
  851. }
  852. __end_read:
  853. av_free_packet(&avpacket);
  854. if (picHeader)
  855. osal_free(picHeader);
  856. if (seqHeader)
  857. osal_free(seqHeader);
  858. return packetSize;
  859. __consume_tempBuffer:
  860. if (ffmpegReader->tempBuffer != NULL) {
  861. osal_memcpy(packet->data, ffmpegReader->tempBuffer, ffmpegReader->tempWrPtr);
  862. packetSize = ffmpegReader->tempWrPtr;
  863. osal_free(ffmpegReader->tempBuffer);
  864. ffmpegReader->tempBuffer = NULL;
  865. ffmpegReader->tempWrPtr = 0;
  866. ffmpegReader->tempRdPtr = 0;
  867. }
  868. return packetSize;
  869. }
  870. BOOL BSFeederFrameSize_Rewind(
  871. void* feeder
  872. )
  873. {
  874. ReaderContext* ffmpegReader = (ReaderContext*)feeder;
  875. AVFormatContext* avFormatContext = ffmpegReader->avContext;
  876. Int32 ret;
  877. if ((ret=av_seek_frame(avFormatContext, ffmpegReader->videoIndex, 0, 0)) < 0) {
  878. VLOG(ERR, "%s:%d Failed to av_seek_frame:(ret:%d)\n", __FUNCTION__, __LINE__, ret);
  879. return FALSE;
  880. }
  881. return TRUE;
  882. }
  883. #else
  884. void* BSFeederFrameSize_Create(
  885. const char* path,
  886. CodStd codecId,
  887. CodStd* retCodecId,
  888. Uint32* retMp4ClassId,
  889. Uint32* retSeqWidth,
  890. Uint32* retSeqHeight
  891. )
  892. {
  893. UNREFERENCED_PARAMETER(path);
  894. UNREFERENCED_PARAMETER(codecId);
  895. UNREFERENCED_PARAMETER(retCodecId);
  896. UNREFERENCED_PARAMETER(retMp4ClassId);
  897. UNREFERENCED_PARAMETER(retSeqWidth);
  898. UNREFERENCED_PARAMETER(retSeqHeight);
  899. VLOG(ERR, "PLEASE PORT THIS %s ON YOUR ANDROID SYSTEM\n", __FUNCTION__);
  900. return NULL;
  901. }
  902. BOOL BSFeederFrameSize_Destroy(
  903. void* feeder
  904. )
  905. {
  906. UNREFERENCED_PARAMETER(feeder);
  907. VLOG(ERR, "PLEASE PORT THIS %s ON YOUR ANDROID SYSTEM\n", __FUNCTION__);
  908. return FALSE;
  909. }
  910. Int32 BSFeederFrameSize_Act(
  911. void* feeder,
  912. BSChunk* packet
  913. )
  914. {
  915. UNREFERENCED_PARAMETER(feeder);
  916. UNREFERENCED_PARAMETER(packet);
  917. VLOG(ERR, "PLEASE PORT THIS %s ON YOUR ANDROID SYSTEM\n", __FUNCTION__);
  918. return -1;
  919. }
  920. #endif /* SUPPORT_FFMPEG_DEMUX */