bsfeeder_framesize_impl.c 36 KB

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