PageRenderTime 52ms CodeModel.GetById 16ms RepoModel.GetById 0ms app.codeStats 0ms

/amplayer/player/player_hwdec.c

https://github.com/J1nx-Hackable-Gadgets/libamplayer-m3
C | 1245 lines | 1087 code | 105 blank | 53 comment | 306 complexity | 4a0d410760ad778f5f90c6f05c87d4dd MD5 | raw file
Possible License(s): LGPL-3.0, CC-BY-SA-3.0, GPL-2.0, GPL-3.0, LGPL-2.1 
    

  1. /*****************************************
    2. 

  2.  * name : av_hwdec.c
    3. 

  3.  * function: decoder hardware relative functions
    4. 

  4.  *date      : 2010.2.4
    5. 

  5.  *****************************************/
    6. 

  6. #include <log_print.h>
    7. 

  7. #include "stream_decoder.h"
    8. 

  8. #include "player_priv.h"
    9. 

  9. #include "player_hwdec.h"
    10. 

  10. 

  11. static int check_size_in_buffer(unsigned char *p, int len)
    12. 

  12. {
    13. 

  13.     unsigned int size;
    14. 

  14.     unsigned char *q = p;
    15. 

  15.     while ((q + 4) < (p + len)) {
    16. 

  16.         size = (*q << 24) | (*(q + 1) << 16) | (*(q + 2) << 8) | (*(q + 3));
    17. 

  17.         if (size & 0xff000000) {
    18. 

  18.             return 0;
    19. 

  19.         }
    20. 

  20. 

  21.         if (q + size + 4 == p + len) {
    22. 

  22.             return 1;
    23. 

  23.         }
    24. 

  24. 

  25.         q += size + 4;
    26. 

  26.     }
    27. 

  27.     return 0;
    28. 

  28. }
    29. 

  29. 

  30. static int check_size_in_buffer3(unsigned char *p, int len)
    31. 

  31. {
    32. 

  32.     unsigned int size;
    33. 

  33.     unsigned char *q = p;
    34. 

  34.     while ((q + 3) < (p + len)) {
    35. 

  35.         size = (*q << 16) | (*(q + 1) << 8) | (*(q + 2));
    36. 

  36. 

  37.         if (q + size + 3 == p + len) {
    38. 

  38.             return 1;
    39. 

  39.         }
    40. 

  40. 

  41.         q += size + 3;
    42. 

  42.     }
    43. 

  43.     return 0;
    44. 

  44. }
    45. 

  45. 

  46. static int check_size_in_buffer2(unsigned char *p, int len)
    47. 

  47. {
    48. 

  48.     unsigned int size;
    49. 

  49.     unsigned char *q = p;
    50. 

  50.     while ((q + 2) < (p + len)) {
    51. 

  51.         size = (*q << 8) | (*(q + 1));
    52. 

  52. 

  53.         if (q + size + 2 == p + len) {
    54. 

  54.             return 1;
    55. 

  55.         }
    56. 

  56. 

  57.         q += size + 2;
    58. 

  58.     }
    59. 

  59.     return 0;
    60. 

  60. }
    61. 

  61. 

  62. static const uint32_t sample_rates[] = {
    63. 

  63.     96000, 88200, 64000, 48000, 44100, 32000,
    64. 

  64.     24000, 22050, 16000, 12000, 11025, 8000
    65. 

  65. };
    66. 

  66. 

  67. /**********************************************************************
    68. 

  68. 0: syncword 12 always: '111111111111'
    69. 

  69. 12: ID 1 0: MPEG-4, 1: MPEG-2
    70. 

  70. 13: layer 2 always: '00'
    71. 

  71. 15: protection_absent 1
    72. 

  72. 16: profile 2
    73. 

  73. 18: sampling_frequency_index 4
    74. 

  74. 22: private_bit 1
    75. 

  75. 23: channel_configuration 3
    76. 

  76. 26: original/copy 1
    77. 

  77. 27: home 1
    78. 

  78. 28: emphasis 2 only if ID == 0
    79. 

    80. 

  80. ADTS Variable header: these can change from frame to frame
    81. 

  81. 28: copyright_identification_bit 1
    82. 

  82. 29: copyright_identification_start 1
    83. 

  83. 30: aac_frame_length 13 length of the frame including header (in bytes)
    84. 

  84. 43: adts_buffer_fullness 11 0x7FF indicates VBR
    85. 

  85. 54: no_raw_data_blocks_in_frame 2
    86. 

  86. ADTS Error check
    87. 

  87. crc_check 16 only if protection_absent == 0
    88. 

  88. }
    89. 

    90. 

  90. **************************************************************************/
    91. 

  91. int extract_adts_header_info(play_para_t *para)
    92. 

  92. {
    93. 

  93.     adts_header_t hdr;
    94. 

  94.     AVCodecContext  *pCodecCtx;
    95. 

  95.     int aidx = para->astream_info.audio_index;
    96. 

  96.     uint8_t *p = NULL;
    97. 

  97.     uint8_t *buf;
    98. 

  98. 

  99.     int i;
    100. 

  100.     if (aidx == -1) {
    101. 

  101.         log_print("[%s:%d]no index found\n", __FUNCTION__, __LINE__);
    102. 

  102.         return PLAYER_ADTS_NOIDX;
    103. 

  103.     } else {
    104. 

  104.         pCodecCtx = para->pFormatCtx->streams[aidx]->codec;
    105. 

  105.         log_print("[%s:%d]aidx=%d pCodecCtx=%p\n", __FUNCTION__, __LINE__, aidx, pCodecCtx);
    106. 

  106.     }
    107. 

  107.     if (pCodecCtx->extradata) {
    108. 

  108.         p = pCodecCtx->extradata;
    109. 

  109.         hdr.profile = (*p >> 3) - 1;        // 5 bits
    110. 

  110.         hdr.sample_freq_idx = (*p & 0x7) << 1 | (*(p + 1) >> 7); // 4 bits
    111. 

  111.         hdr.channel_configuration = (*(p + 1) & 0x7f) >> 3; // 4 bits
    112. 

  112.         if ((*p >> 3) == 5/*AOT_SBR*/ || ((*p >> 3) == 29/*AOT_PS*/ &&
    113. 

  113.                                           // check for W6132 Annex YYYY draft MP3onMP4
    114. 

  114.                                           !((*(p + 1) & 0x7) & 0x03 && !(((*(p + 1) & 0x7) << 6 | (*(p + 2) >> 2)) & 0x3F)))) {
    115. 

  115.             //skip 4  bits for ex-sample-freq_idx
    116. 

  116.             hdr.profile = ((*(p + 2) & 0x7f) >> 2) - 1; // 5 bits
    117. 

  117. 

  118.         }
    119. 

  119.         log_print("extract aac insert adts header:profile %d,sr_index %d,ch_config %d\n", hdr.profile, hdr.sample_freq_idx, hdr.channel_configuration);
    120. 

  120.         log_print("extra data size %d,DATA:\n", pCodecCtx->extradata_size);
    121. 

  121.         for (i = 0; i < pCodecCtx->extradata_size; i++) {
    122. 

  122.             log_print("[0x%x]\n", p[i]);
    123. 

  123.         }
    124. 

  124.     } else {
    125. 

  125.         hdr.profile = pCodecCtx->audio_profile - 1;
    126. 

  126.         hdr.channel_configuration = pCodecCtx->channels;
    127. 

  127.         for (i = 0; i < sizeof(sample_rates) / sizeof(uint32_t); i ++) {
    128. 

  128.             if (pCodecCtx->sample_rate == sample_rates[i]) {
    129. 

  129.                 hdr.sample_freq_idx = i;
    130. 

  130.             }
    131. 

  131.         }
    132. 

  132.         log_print("aac insert adts header:profile %d,sr_index %d,ch_config %d\n", hdr.profile, hdr.sample_freq_idx, hdr.channel_configuration);
    133. 

  133.     }
    134. 

  134. 

  135.     hdr.syncword = 0xfff;
    136. 

  136.     hdr.id = 0;
    137. 

  137.     hdr.layer = 0;
    138. 

  138.     hdr.protection_absent = 1;
    139. 

  139.     hdr.private_bit = 0;
    140. 

  140.     hdr.original_copy = 0;
    141. 

  141.     hdr.home = 0;
    142. 

  142.     hdr.copyright_identification_bit = 0;
    143. 

  143.     hdr.copyright_identification_start = 0;
    144. 

  144.     hdr.aac_frame_length = 0;
    145. 

  145.     hdr.adts_buffer_fullness = 0x7ff;
    146. 

  146.     hdr.number_of_raw_data_blocks_in_frame = 0;
    147. 

  147.     buf = MALLOC(ADTS_HEADER_SIZE);
    148. 

  148.     if (buf) {
    149. 

  149.         buf[0] = (char)(hdr.syncword >> 4);
    150. 

  150.         buf[1] = (char)((hdr.syncword & 0xf << 4) |
    151. 

  151.                         (hdr.id << 3) |
    152. 

  152.                         (hdr.layer << 1) |
    153. 

  153.                         hdr.protection_absent);
    154. 

  154.         buf[2] = (char)((hdr.profile << 6) |
    155. 

  155.                         (hdr.sample_freq_idx << 2) |
    156. 

  156.                         (hdr.private_bit << 1) |
    157. 

  157.                         (hdr.channel_configuration >> 2));
    158. 

  158.         buf[3] = (char)(((hdr.channel_configuration & 0x3) << 6) |
    159. 

  159.                         (hdr.original_copy << 5) |
    160. 

  160.                         (hdr.home << 4) |
    161. 

  161.                         (hdr.copyright_identification_bit << 3) |
    162. 

  162.                         (hdr.copyright_identification_start << 2) |
    163. 

  163.                         (hdr.aac_frame_length) >> 11);
    164. 

  164.         buf[4] = (char)((hdr.aac_frame_length >> 3) & 0xff);
    165. 

  165.         buf[5] = (char)(((hdr.aac_frame_length & 0x7) << 5) |
    166. 

  166.                         (hdr.adts_buffer_fullness >> 6));
    167. 

  167.         buf[6] = (char)(((hdr.adts_buffer_fullness & 0x3f) << 2) |
    168. 

  168.                         hdr.number_of_raw_data_blocks_in_frame);
    169. 

  169.         para->astream_info.extradata = buf;
    170. 

  170.         para->astream_info.extradata_size = ADTS_HEADER_SIZE;
    171. 

  171.     } else {
    172. 

  172.         log_error("[%s:%d]no memory for extract adts header!\n", __FUNCTION__, __LINE__);
    173. 

  173.         return PLAYER_NOMEM;
    174. 

  174.     }
    175. 

  175.     return PLAYER_SUCCESS;
    176. 

  176. }
    177. 

  177. 

  178. void adts_add_header(play_para_t *para)
    179. 

  179. {
    180. 

  180.     unsigned char *buf ;
    181. 

  181.     am_packet_t *pkt = para->p_pkt;
    182. 

  182.     int i;
    183. 

  183.     int size = ADTS_HEADER_SIZE + pkt->data_size;   // 13bit valid
    184. 

  184.     size &= 0x1fff;
    185. 

  185.     buf = para->astream_info.extradata;
    186. 

  186.     uint8_t *adts_header=NULL;
    187. 

  187. 

  188.     if (pkt->avpkt && (pkt->avpkt->flags & AV_PKT_FLAG_AAC_WITH_ADTS_HEADER)) {
    189. 

  189.         //log_info("have add adts header in low level,don't add again\n");
    190. 

  190.         pkt->hdr->size = 0;
    191. 

  191.         return ; /*have added before */
    192. 

  192.     }
    193. 

  193. 	
    194. 

  194. //Some aac es stream already has adts header,need check the first ADTS_HEADER_SIZE bytes
    195. 

  195.     while (pkt->data&&pkt->data_size>=ADTS_HEADER_SIZE) {      
    196. 

  196.         adts_header = MALLOC(ADTS_HEADER_SIZE);
    197. 

  197.         if (adts_header) {
    198. 

  198.             memset(adts_header,0,ADTS_HEADER_SIZE);
    199. 

  199.             adts_header=memcpy(adts_header,pkt->data,ADTS_HEADER_SIZE);
    200. 

  200.         }
    201. 

  201.         else  break;
    202. 

  202.         if(((adts_header[0]<<4)|(adts_header[1]&0xF0)>>4)!=0xFFF)//sync code
    203. 

  203.                 break;
    204. 

  204.         if((( (*(adts_header+ 3)&0x2)<<11)|( (*(adts_header + 4)&0xFF)<<3)|( (*(adts_header + 5)&0xE0)>>5))!=pkt->data_size)//frame length
    205. 

  205.                 break;	
    206. 

  206.         //log_info(" AAC es has adts header,don't add again\n");
    207. 

  207.         pkt->hdr->size = 0;
    208. 

  208.         return;
    209. 

  209.     }
    210. 

  210.     if(adts_header){
    211. 

  211.         av_free(adts_header);
    212. 

  212.         adts_header=NULL;
    213. 

  213.     }
    214. 

  214. 	
    215. 

  215.     if (para->astream_info.extradata) {
    216. 

  216.         buf[3] = (buf[3] & 0xfc) | (size >> 11);
    217. 

  217.         buf[4] = (size >> 3) & 0xff;
    218. 

  218.         buf[5] = (buf[5] & 0x1f) | ((size & 0x7) << 5);
    219. 

  219.         if (para->astream_info.extradata_size == ADTS_HEADER_SIZE) {
    220. 

  220.             MEMCPY(pkt->hdr->data, para->astream_info.extradata, para->astream_info.extradata_size);
    221. 

  221.             pkt->hdr->size = ADTS_HEADER_SIZE;
    222. 

  222.             pkt->type = CODEC_AUDIO;
    223. 

  223.         }
    224. 

  224.     }
    225. 

  225.     //else
    226. 

  226.     //  log_error("[%s:%d]extradata NULL!\n",__FUNCTION__,__LINE__);
    227. 

  227.     return ;
    228. 

  228. }
    229. 

  229. 

  230. /*************************************************************************/
    231. 

  231. static int mjpeg_data_prefeeding(am_packet_t *pkt)
    232. 

  232. {
    233. 

  233.     const unsigned char mjpeg_addon_data[] = {
    234. 

  234.         0xff, 0xd8, 0xff, 0xc4, 0x01, 0xa2, 0x00, 0x00, 0x01, 0x05, 0x01, 0x01, 0x01,
    235. 

  235.         0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02,
    236. 

  236.         0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x01, 0x00, 0x03, 0x01,
    237. 

  237.         0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
    238. 

  238.         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x10,
    239. 

  239.         0x00, 0x02, 0x01, 0x03, 0x03, 0x02, 0x04, 0x03, 0x05, 0x05, 0x04, 0x04, 0x00,
    240. 

  240.         0x00, 0x01, 0x7d, 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12, 0x21, 0x31,
    241. 

  241.         0x41, 0x06, 0x13, 0x51, 0x61, 0x07, 0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1,
    242. 

  242.         0x08, 0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0, 0x24, 0x33, 0x62, 0x72,
    243. 

  243.         0x82, 0x09, 0x0a, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28, 0x29,
    244. 

  244.         0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47,
    245. 

  245.         0x48, 0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x63, 0x64,
    246. 

  246.         0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
    247. 

  247.         0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95,
    248. 

  248.         0x96, 0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9,
    249. 

  249.         0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4,
    250. 

  250.         0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8,
    251. 

  251.         0xd9, 0xda, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xf1,
    252. 

  252.         0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0x11, 0x00, 0x02, 0x01,
    253. 

  253.         0x02, 0x04, 0x04, 0x03, 0x04, 0x07, 0x05, 0x04, 0x04, 0x00, 0x01, 0x02, 0x77,
    254. 

  254.         0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21, 0x31, 0x06, 0x12, 0x41, 0x51,
    255. 

  255.         0x07, 0x61, 0x71, 0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91, 0xa1, 0xb1,
    256. 

  256.         0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0, 0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24,
    257. 

  257.         0x34, 0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26, 0x27, 0x28, 0x29, 0x2a,
    258. 

  258.         0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
    259. 

  259.         0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x63, 0x64, 0x65, 0x66,
    260. 

  260.         0x67, 0x68, 0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x82,
    261. 

  261.         0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96,
    262. 

  262.         0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa,
    263. 

  263.         0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5,
    264. 

  264.         0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9,
    265. 

  265.         0xda, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xf2, 0xf3, 0xf4,
    266. 

  266.         0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa
    267. 

  267.     };
    268. 

  268. 

  269.     if (pkt->hdr->data) {
    270. 

  270.         MEMCPY(pkt->hdr->data, &mjpeg_addon_data, sizeof(mjpeg_addon_data));
    271. 

  271.         pkt->hdr->size = sizeof(mjpeg_addon_data);
    272. 

  272.     } else {
    273. 

  273.         log_print("[mjpeg_data_prefeeding]No enough memory!\n");
    274. 

  274.         return PLAYER_FAILED;
    275. 

  275.     }
    276. 

  276.     return PLAYER_SUCCESS;
    277. 

  277. }
    278. 

  278. static int mjpeg_write_header(play_para_t *para)
    279. 

  279. {
    280. 

  280.     am_packet_t *pkt = para->p_pkt;
    281. 

  281.     mjpeg_data_prefeeding(pkt);
    282. 

  282.     if (para->vcodec) {
    283. 

  283.         pkt->codec = para->vcodec;
    284. 

  284.     } else {
    285. 

  285.         log_print("[mjpeg_write_header]invalid codec!");
    286. 

  286.         return PLAYER_EMPTY_P;
    287. 

  287.     }
    288. 

  288.     pkt->avpkt_newflag = 1;
    289. 

  289.     write_av_packet(para);
    290. 

  290.     return PLAYER_SUCCESS;
    291. 

  291. }
    292. 

  292. /*************************************************************************/
    293. 

  293. static int divx3_data_prefeeding(am_packet_t *pkt, unsigned w, unsigned h)
    294. 

  294. {
    295. 

  295.     unsigned i = (w << 12) | (h & 0xfff);
    296. 

  296.     unsigned char divx311_add[10] = {
    297. 

  297.         0x00, 0x00, 0x00, 0x01,
    298. 

  298.         0x20, 0x00, 0x00, 0x00,
    299. 

  299.         0x00, 0x00
    300. 

  300.     };
    301. 

  301.     divx311_add[5] = (i >> 16) & 0xff;
    302. 

  302.     divx311_add[6] = (i >> 8) & 0xff;
    303. 

  303.     divx311_add[7] = i & 0xff;
    304. 

  304. 

  305.     if (pkt->hdr->data) {
    306. 

  306.         MEMCPY(pkt->hdr->data, divx311_add, sizeof(divx311_add));
    307. 

  307.         pkt->hdr->size = sizeof(divx311_add);
    308. 

  308.     } else {
    309. 

  309.         log_print("[divx3_data_prefeeding]No enough memory!\n");
    310. 

  310.         return PLAYER_FAILED;
    311. 

  311.     }
    312. 

  312.     return PLAYER_SUCCESS;
    313. 

  313. }
    314. 

  314. 

  315. static int divx3_write_header(play_para_t *para)
    316. 

  316. {
    317. 

  317.     am_packet_t *pkt = para->p_pkt;
    318. 

  318.     divx3_data_prefeeding(pkt, para->vstream_info.video_width, para->vstream_info.video_height);
    319. 

  319.     if (para->vcodec) {
    320. 

  320.         pkt->codec = para->vcodec;
    321. 

  321.     } else {
    322. 

  322.         log_print("[divx3_write_header]invalid codec!");
    323. 

  323.         return PLAYER_EMPTY_P;
    324. 

  324.     }
    325. 

  325.     pkt->avpkt_newflag = 1;
    326. 

  326.     write_av_packet(para);
    327. 

  327.     return PLAYER_SUCCESS;
    328. 

  328. }
    329. 

  329. /*************************************************************************/
    330. 

  330. static int h264_add_header(unsigned char *buf, int size,  am_packet_t *pkt)
    331. 

  331. {
    332. 

  332.     char nal_start_code[] = {0x0, 0x0, 0x0, 0x1};
    333. 

  333.     int nalsize;
    334. 

  334.     unsigned char* p;
    335. 

  335.     int tmpi;
    336. 

  336.     unsigned char* extradata = buf;
    337. 

  337.     int header_len = 0;
    338. 

  338.     char* buffer = pkt->hdr->data;
    339. 

  339. 

  340.     p = extradata;
    341. 

  341.     if ((p[0] == 0 && p[1] == 0 && p[2] == 0 && p[3] == 1)||(p[0] == 0 && p[1] == 0 && p[2] == 1 ) && size < HDR_BUF_SIZE) {
    342. 

  342.         log_print("add 264 header in stream before header len=%d", size);
    343. 

  343.         MEMCPY(buffer, buf, size);
    344. 

  344.         pkt->hdr->size = size;
    345. 

  345.         pkt->type = CODEC_VIDEO;
    346. 

  346.         return PLAYER_SUCCESS;
    347. 

  347.     }
    348. 

  348.     if (size < 4) {
    349. 

  349.         return PLAYER_FAILED;
    350. 

  350.     }
    351. 

  351. 

  352.     if (size < 10) {
    353. 

  353.         log_print("avcC too short\n");
    354. 

  354.         return PLAYER_FAILED;
    355. 

  355.     }
    356. 

  356. 

  357.     if (*p != 1) {
    358. 

  358.         log_print(" Unkonwn avcC version %d\n", *p);
    359. 

  359.         return PLAYER_FAILED;
    360. 

  360.     }
    361. 

  361. 

  362.     int cnt = *(p + 5) & 0x1f; //number of sps
    363. 

  363.     // printf("number of sps :%d\n", cnt);
    364. 

  364.     p += 6;
    365. 

  365.     for (tmpi = 0; tmpi < cnt; tmpi++) {
    366. 

  366.         nalsize = (*p << 8) | (*(p + 1));
    367. 

  367.         MEMCPY(&(buffer[header_len]), nal_start_code, 4);
    368. 

  368.         header_len += 4;
    369. 

  369.         MEMCPY(&(buffer[header_len]), p + 2, nalsize);
    370. 

  370.         header_len += nalsize;
    371. 

  371.         p += (nalsize + 2);
    372. 

  372.     }
    373. 

  373. 

  374.     cnt = *(p++); //Number of pps
    375. 

  375.     // printf("number of pps :%d\n", cnt);
    376. 

  376.     for (tmpi = 0; tmpi < cnt; tmpi++) {
    377. 

  377.         nalsize = (*p << 8) | (*(p + 1));
    378. 

  378.         MEMCPY(&(buffer[header_len]), nal_start_code, 4);
    379. 

  379.         header_len += 4;
    380. 

  380.         MEMCPY(&(buffer[header_len]), p + 2, nalsize);
    381. 

  381.         header_len += nalsize;
    382. 

  382.         p += (nalsize + 2);
    383. 

  383.     }
    384. 

  384.     if (header_len >= HDR_BUF_SIZE) {
    385. 

  385.         log_print("header_len %d is larger than max length\n", header_len);
    386. 

  386.         return PLAYER_FAILED;
    387. 

  387.     }
    388. 

  388.     pkt->hdr->size = header_len;
    389. 

  389.     pkt->type = CODEC_VIDEO;
    390. 

  390.     return PLAYER_SUCCESS;
    391. 

  391. }
    392. 

  392. 

  393. static int h264_write_header(play_para_t *para)
    394. 

  394. {
    395. 

  395.     AVStream *pStream = NULL;
    396. 

  396.     AVCodecContext *avcodec;
    397. 

  397.     am_packet_t *pkt = para->p_pkt;
    398. 

  398.     int ret = -1;
    399. 

  399.     int index = para->vstream_info.video_index;
    400. 

  400. 

  401.     if (-1 == index) {
    402. 

  402.         return PLAYER_ERROR_PARAM;
    403. 

  403.     }
    404. 

  404. 

  405.     pStream = para->pFormatCtx->streams[index];
    406. 

  406.     avcodec = pStream->codec;
    407. 

  407.     if (avcodec->extradata) {
    408. 

  408.         ret = h264_add_header(avcodec->extradata, avcodec->extradata_size, pkt);
    409. 

  409.     }
    410. 

  410.     if (ret == PLAYER_SUCCESS) {
    411. 

  411.         if (para->vcodec) {
    412. 

  412.             pkt->codec = para->vcodec;
    413. 

  413.         } else {
    414. 

  414.             log_print("[h264_add_header]invalid video codec!\n");
    415. 

  415.             return PLAYER_EMPTY_P;
    416. 

  416.         }
    417. 

  417. 

  418.         pkt->avpkt_newflag = 1;
    419. 

  419.         ret = write_av_packet(para);
    420. 

  420.     }
    421. 

  421.     return ret;
    422. 

  422. }
    423. 

  423. static int write_stream_header(play_para_t *para)
    424. 

  424. {
    425. 

  425.     AVStream *pStream = NULL;
    426. 

  426.     AVCodecContext *avcodec;
    427. 

  427.     am_packet_t *pkt = para->p_pkt;
    428. 

  428.     int ret = -1;
    429. 

  429.     int index = para->vstream_info.video_index;
    430. 

  430. 

  431.     if (-1 == index) {
    432. 

  432.         return PLAYER_ERROR_PARAM;
    433. 

  433.     }
    434. 

  434. 

  435.     pStream = para->pFormatCtx->streams[index];
    436. 

  436.     avcodec = pStream->codec;
    437. 

  437.     ret = PLAYER_FAILED;
    438. 

  438.     if (avcodec->extradata_size < HDR_BUF_SIZE) {
    439. 

  439.         MEMCPY(pkt->hdr->data, avcodec->extradata, avcodec->extradata_size);
    440. 

  440.         pkt->hdr->size = avcodec->extradata_size;
    441. 

  441.         pkt->type = CODEC_VIDEO;
    442. 

  442.         ret = PLAYER_SUCCESS;
    443. 

  443.     }
    444. 

  444.     if (ret == PLAYER_SUCCESS) {
    445. 

  445.         if (para->vcodec) {
    446. 

  446.             pkt->codec = para->vcodec;
    447. 

  447.         } else {
    448. 

  448.             log_print("[h264_add_header]invalid video codec!\n");
    449. 

  449.             return PLAYER_EMPTY_P;
    450. 

  450.         }
    451. 

  451. 

  452.         pkt->avpkt_newflag = 1;
    453. 

  453.         ret = write_av_packet(para);
    454. 

  454.     }
    455. 

  455.     return ret;
    456. 

  456. }
    457. 

  457. 

  458. 

  459. /*************************************************************************/
    460. 

  460. static int m4s2_dx50_mp4v_add_header(unsigned char *buf, int size,  am_packet_t *pkt)
    461. 

  461. {
    462. 

  462.     if (size > pkt->hdr->size) {
    463. 

  463.         FREE(pkt->hdr->data);
    464. 

  464.         pkt->hdr->size = 0;
    465. 

  465. 

  466.         pkt->hdr->data = (char *)MALLOC(size);
    467. 

  467.         if (!pkt->hdr->data) {
    468. 

  468.             log_print("[m4s2_dx50_add_header] NOMEM!");
    469. 

  469.             return PLAYER_FAILED;
    470. 

  470.         }
    471. 

  471.     }
    472. 

  472. 

  473.     pkt->hdr->size = size;
    474. 

  474.     pkt->type = CODEC_VIDEO;
    475. 

  475.     MEMCPY(pkt->hdr->data, buf, size);
    476. 

  476. 

  477.     return PLAYER_SUCCESS;
    478. 

  478. }
    479. 

  479. 

  480. static int m4s2_dx50_mp4v_write_header(play_para_t *para)
    481. 

  481. {
    482. 

  482.     AVStream *pStream = NULL;
    483. 

  483.     AVCodecContext *avcodec;
    484. 

  484.     int ret = -1;
    485. 

  485.     int index = para->vstream_info.video_index;
    486. 

  486.     am_packet_t * pkt = para->p_pkt;
    487. 

  487. 

  488.     if (-1 == index) {
    489. 

  489.         return PLAYER_ERROR_PARAM;
    490. 

  490.     }
    491. 

  491. 

  492.     pStream = para->pFormatCtx->streams[index];
    493. 

  493.     avcodec = pStream->codec;
    494. 

  494. 

  495.     ret = m4s2_dx50_mp4v_add_header(avcodec->extradata, avcodec->extradata_size, pkt);
    496. 

  496.     if (ret == PLAYER_SUCCESS) {
    497. 

  497.         if (para->vcodec) {
    498. 

  498.             pkt->codec = para->vcodec;
    499. 

  499.         } else {
    500. 

  500.             log_print("[m4s2_dx50_mp4v_add_header]invalid video codec!\n");
    501. 

  501.             return PLAYER_EMPTY_P;
    502. 

  502.         }
    503. 

  503.         pkt->avpkt_newflag = 1;
    504. 

  504.         ret = write_av_packet(para);
    505. 

  505.     }
    506. 

  506.     return ret;
    507. 

  507. }
    508. 

  508. /*************************************************************************/
    509. 

  509. static int avi_add_seqheader(AVStream *pStream, am_packet_t *pkt)
    510. 

  510. {
    511. 

  511.     AVIStream *avi_stream = pStream->priv_data;
    512. 

  512.     int seq_size = avi_stream->sequence_head_size;
    513. 

  513. 

  514.     if (seq_size > pkt->hdr->size) {
    515. 

  515.         FREE(pkt->hdr->data);
    516. 

  516.         pkt->hdr->size = 0;
    517. 

  517. 

  518.         pkt->hdr->data = (char *)MALLOC(seq_size);
    519. 

  519.         if (!pkt->hdr->data) {
    520. 

  520.             log_print("[m4s2_dx50_add_header] NOMEM!");
    521. 

  521.             return PLAYER_FAILED;
    522. 

  522.         }
    523. 

  523.     }
    524. 

  524. 

  525.     pkt->hdr->size = seq_size;
    526. 

  526.     pkt->type = CODEC_VIDEO;
    527. 

  527.     MEMCPY(pkt->hdr->data, avi_stream->sequence_head, seq_size);
    528. 

  528. 

  529.     return PLAYER_SUCCESS;
    530. 

  530. }
    531. 

  531. 

  532. static int avi_write_header(play_para_t *para)
    533. 

  533. {
    534. 

  534.     AVStream *pStream = NULL;
    535. 

  535.     int ret = -1;
    536. 

  536.     int index = para->vstream_info.video_index;
    537. 

  537.     am_packet_t *pkt = para->p_pkt;
    538. 

  538.     AVCodecContext *avcodec;
    539. 

  539.     
    540. 

  540.     if (-1 == index) {
    541. 

  541.         return PLAYER_ERROR_PARAM;
    542. 

  542.     }
    543. 

  543. 

  544.     pStream = para->pFormatCtx->streams[index];
    545. 

  545.     avcodec = pStream->codec;
    546. 

  546.     
    547. 

  547.     AVIStream *avi_stream = pStream->priv_data;
    548. 

  548.     int seq_size = avi_stream->sequence_head_size;
    549. 

  549.     if (seq_size > 0) 
    550. 

  550.         ret = avi_add_seqheader(pStream, pkt);
    551. 

  551.     else if(avcodec->extradata_size > 4)
    552. 

  552.         ret = m4s2_dx50_mp4v_add_header(avcodec->extradata, avcodec->extradata_size, pkt);
    553. 

  553. 

  554.     if (ret == PLAYER_SUCCESS) {
    555. 

  555.         if (para->vcodec) {
    556. 

  556.             pkt->codec = para->vcodec;
    557. 

  557.         } else {
    558. 

  558.             log_print("[avi_write_header]invalid video codec!\n");
    559. 

  559.             return PLAYER_EMPTY_P;
    560. 

  560.         }
    561. 

  561.         pkt->avpkt_newflag = 1;
    562. 

  562.         ret = write_av_packet(para);
    563. 

  563.     }
    564. 

  564.     return ret;
    565. 

  565. }
    566. 

  566. /*************************************************************************/
    567. 

  567. static int mkv_write_header(play_para_t *para)
    568. 

  568. {
    569. 

  569.     int head_size = para->vstream_info.extradata_size;
    570. 

  570.     am_packet_t *pkt = para->p_pkt;
    571. 

  571. 

  572.     if (para->vcodec) {
    573. 

  573.         pkt->codec = para->vcodec;
    574. 

  574.     } else {
    575. 

  575.         log_print("[mkv_write_header]invalid codec!");
    576. 

  576.         return PLAYER_EMPTY_P;
    577. 

  577.     }
    578. 

  578. 

  579.     if (head_size > HDR_BUF_SIZE) {
    580. 

  580.         FREE(pkt->hdr->data);
    581. 

  581.         pkt->hdr->size = 0;
    582. 

  582. 

  583.         pkt->hdr->data = (char *)MALLOC(head_size);
    584. 

  584.         if (!pkt->hdr->data) {
    585. 

  585.             log_print("[mkv_write_header] NOMEM!");
    586. 

  586.             return PLAYER_FAILED;
    587. 

  587.         }
    588. 

  588.     }
    589. 

  589. 

  590.     pkt->hdr->size = head_size;
    591. 

  591.     pkt->type = CODEC_VIDEO;
    592. 

  592.     MEMCPY(pkt->hdr->data, para->vstream_info.extradata, head_size);
    593. 

  593. 

  594.     pkt->avpkt_newflag = 1;
    595. 

  595.     return write_av_packet(para);
    596. 

  596. }
    597. 

  597. /*************************************************************************/
    598. 

  598. static int wmv3_write_header(play_para_t *para)
    599. 

  599. {
    600. 

  600.     unsigned i, check_sum = 0;
    601. 

  601.     unsigned data_len = para->vstream_info.extradata_size + 4;
    602. 

  602.     int ret;
    603. 

  603.     am_packet_t *pkt = para->p_pkt;
    604. 

  604. 

  605.     pkt->hdr->data[0] = 0;
    606. 

  606.     pkt->hdr->data[1] = 0;
    607. 

  607.     pkt->hdr->data[2] = 1;
    608. 

  608.     pkt->hdr->data[3] = 0x10;
    609. 

  609. 

  610.     pkt->hdr->data[4] = 0;
    611. 

  611.     pkt->hdr->data[5] = (data_len >> 16) & 0xff;
    612. 

  612.     pkt->hdr->data[6] = 0x88;
    613. 

  613.     pkt->hdr->data[7] = (data_len >> 8) & 0xff;
    614. 

  614.     pkt->hdr->data[8] = data_len & 0xff;
    615. 

  615.     pkt->hdr->data[9] = 0x88;
    616. 

  616. 

  617.     pkt->hdr->data[10] = 0xff;
    618. 

  618.     pkt->hdr->data[11] = 0xff;
    619. 

  619.     pkt->hdr->data[12] = 0x88;
    620. 

  620.     pkt->hdr->data[13] = 0xff;
    621. 

  621.     pkt->hdr->data[14] = 0xff;
    622. 

  622.     pkt->hdr->data[15] = 0x88;
    623. 

  623. 

  624.     for (i = 4 ; i < 16 ; i++) {
    625. 

  625.         check_sum += pkt->hdr->data[i];
    626. 

  626.     }
    627. 

  627. 

  628.     pkt->hdr->data[16] = (check_sum >> 8) & 0xff;
    629. 

  629.     pkt->hdr->data[17] = check_sum & 0xff;
    630. 

  630.     pkt->hdr->data[18] = 0x88;
    631. 

  631.     pkt->hdr->data[19] = (check_sum >> 8) & 0xff;
    632. 

  632.     pkt->hdr->data[20] = check_sum & 0xff;
    633. 

  633.     pkt->hdr->data[21] = 0x88;
    634. 

  634. 

  635.     pkt->hdr->data[22] = (para->vstream_info.video_width >> 8) & 0xff;
    636. 

  636.     pkt->hdr->data[23] = para->vstream_info.video_width & 0xff;
    637. 

  637.     pkt->hdr->data[24] = (para->vstream_info.video_height >> 8) & 0xff;
    638. 

  638.     pkt->hdr->data[25] = para->vstream_info.video_height & 0xff;
    639. 

  639. 

  640.     MEMCPY(pkt->hdr->data + 26, para->vstream_info.extradata, para->vstream_info.extradata_size);
    641. 

  641.     pkt->hdr->size = para->vstream_info.extradata_size + 26;
    642. 

  642.     if (para->vcodec) {
    643. 

  643.         pkt->codec = para->vcodec;
    644. 

  644.     } else {
    645. 

  645.         log_print("[wmv3_write_header]invalid codec!");
    646. 

  646.         return PLAYER_EMPTY_P;
    647. 

  647.     }
    648. 

  648.     pkt->avpkt_newflag = 1;
    649. 

  649.     pkt->type = CODEC_VIDEO;
    650. 

  650.     ret = write_av_packet(para);
    651. 

  651.     return ret;
    652. 

  652. }
    653. 

  653. /*************************************************************************/
    654. 

  654. static int wvc1_write_header(play_para_t *para)
    655. 

  655. {
    656. 

  656.     int ret = -1;
    657. 

  657.     am_packet_t *pkt = para->p_pkt;
    658. 

  658. 

  659.     MEMCPY(pkt->hdr->data, para->vstream_info.extradata + 1, para->vstream_info.extradata_size - 1);
    660. 

  660.     pkt->hdr->size = para->vstream_info.extradata_size - 1;
    661. 

  661.     if (para->vcodec) {
    662. 

  662.         pkt->codec = para->vcodec;
    663. 

  663.     } else {
    664. 

  664.         log_print("[wvc1_write_header]invalid codec!");
    665. 

  665.         return PLAYER_EMPTY_P;
    666. 

  666.     }
    667. 

  667.     pkt->avpkt_newflag = 1;
    668. 

  668.     pkt->type = CODEC_VIDEO;
    669. 

  669.     ret = write_av_packet(para);
    670. 

  670.     return ret;
    671. 

  671. }
    672. 

  672. /*************************************************************************/
    673. 

  673. 

  674. int mpeg_check_sequence(play_para_t *para)
    675. 

  675. {
    676. 

  676. #define MPEG_PROBE_SIZE     (4096)
    677. 

  677. #define MAX_MPEG_PROBE_SIZE (0x100000)      //1M
    678. 

  678. #define SEQ_START_CODE      (0x000001b3)
    679. 

  679. #define EXT_START_CODE      (0x000001b5)
    680. 

  680.     int code = 0;
    681. 

  681.     int pos1 = 0, pos2 = 0;
    682. 

  682.     int i, j;
    683. 

  683.     int len, offset, read_size, seq_size = 0;
    684. 

  684.     int64_t cur_offset = 0;
    685. 

  685.     AVFormatContext *s = para->pFormatCtx;
    686. 

  686.     unsigned char buf[MPEG_PROBE_SIZE];
    687. 

  687.     cur_offset = avio_tell(s->pb);
    688. 

  688.     offset = 0;
    689. 

  689.     len = 0;
    690. 

  690.     for (j = 0; j < (MAX_MPEG_PROBE_SIZE / MPEG_PROBE_SIZE); j++) {
    691. 

  691.         url_fseek(s->pb, offset, SEEK_SET);
    692. 

  692.         read_size = get_buffer(s->pb, buf, MPEG_PROBE_SIZE);
    693. 

  693.         if (read_size < 0) {
    694. 

  694.             log_error("[mpeg_check_sequence:%d] read error: %d\n", __LINE__, read_size);
    695. 

  695.             avio_seek(s->pb, cur_offset, SEEK_SET);
    696. 

  696.             return read_size;
    697. 

  697.         }
    698. 

  698.         offset += read_size;
    699. 

  699.         for (i = 0; i < read_size; i++) {
    700. 

  700.             code = (code << 8) + buf[i];
    701. 

  701.             if ((code & 0xffffff00) == 0x100) {
    702. 

  702.                 //log_print("[mpeg_check_sequence:%d]code=%08x\n",__LINE__, code);
    703. 

  703.                 if (code == SEQ_START_CODE) {
    704. 

  704.                     pos1 = j * MPEG_PROBE_SIZE + i - 3;
    705. 

  705.                 } else if (code != EXT_START_CODE) {
    706. 

  706.                     pos2 = j * MPEG_PROBE_SIZE + i - 3;
    707. 

  707.                 }
    708. 

  708.                 if ((pos2 > pos1) && (pos1 > 0)) {
    709. 

  709.                     seq_size = pos2 - pos1;
    710. 

  710.                     //log_print("[mpeg_check_sequence:%d]pos1=%x pos2=%x seq_size=%d\n",__LINE__, pos1,pos2,seq_size);
    711. 

  711.                     break;
    712. 

  712.                 }
    713. 

  713.             }
    714. 

  714.         }
    715. 

  715.         if (seq_size > 0) {
    716. 

  716.             break;
    717. 

  717.         }
    718. 

  718.     }
    719. 

  719.     if (seq_size > 0) {
    720. 

  720.         url_fseek(s->pb, pos1, SEEK_SET);
    721. 

  721.         read_size = get_buffer(s->pb, buf, seq_size);
    722. 

  722.         if (read_size < 0) {
    723. 

  723.             log_error("[mpeg_check_sequence:%d] read error: %d\n", __LINE__, read_size);
    724. 

  724.             avio_seek(s->pb, cur_offset, SEEK_SET);
    725. 

  725.             return read_size;
    726. 

  726.         }
    727. 

  727. #ifdef DEBUG_MPEG_SEARCH
    728. 

  728.         for (i = 0; i < seq_size; i++) {
    729. 

  729.             log_print("%02x ", buf[i]);
    730. 

  730.             if (i % 8 == 7) {
    731. 

  731.                 log_print("\n");
    732. 

  732.             }
    733. 

  733.         }
    734. 

  734. #endif
    735. 

  735. 

  736.         para->vstream_info.extradata = MALLOC(seq_size);
    737. 

  737.         if (para->vstream_info.extradata) {
    738. 

  738.             MEMCPY(para->vstream_info.extradata, buf, seq_size);
    739. 

  739.             para->vstream_info.extradata_size = seq_size;
    740. 

  740. #ifdef DEBUG_MPEG_SEARCH
    741. 

  741.             for (i = 0; i < seq_size; i++) {
    742. 

  742.                 log_print("%02x ", para->vstream_info.extradata[i]);
    743. 

  743.                 if (i % 8 == 7) {
    744. 

  744.                     log_print("\n");
    745. 

  745.                 }
    746. 

  746.             }
    747. 

  747. #endif
    748. 

  748.         } else {
    749. 

  749.             log_error("[mpeg_check_sequece:%d] no enough memory !\n", __LINE__);
    750. 

  750.         }
    751. 

  751.     } else {
    752. 

  752.         log_error("[mpeg_check_sequence:%d]max probe size reached! not find sequence header!\n", __LINE__);
    753. 

  753.     }
    754. 

  754.     avio_seek(s->pb, cur_offset, SEEK_SET);
    755. 

  755.     return 0;
    756. 

  756. }
    757. 

  757. static int mpeg_add_header(play_para_t *para)
    758. 

  758. {
    759. 

  759. #define STUFF_BYTES_LENGTH     (256)
    760. 

  760.     int size;
    761. 

  761.     unsigned char packet_wrapper[] = {
    762. 

  762.         0x00, 0x00, 0x01, 0xe0,
    763. 

  763.         0x00, 0x00,                                /* pes packet length */
    764. 

  764.         0x81, 0xc0, 0x0d,
    765. 

  765.         0x20, 0x00, 0x00, 0x00, 0x00, /* PTS */
    766. 

  766.         0x1f, 0xff, 0xff, 0xff, 0xff, /* DTS */
    767. 

  767.         0xff, 0xff, 0xff, 0xff, 0xff, 0xff
    768. 

  768.     };
    769. 

  769.     am_packet_t *pkt = para->p_pkt;
    770. 

  770. 

  771.     size = para->vstream_info.extradata_size + sizeof(packet_wrapper);
    772. 

  772.     packet_wrapper[4] = size >> 8 ;
    773. 

  773.     packet_wrapper[5] = size & 0xff ;
    774. 

  774.     MEMCPY(pkt->hdr->data, packet_wrapper, sizeof(packet_wrapper));
    775. 

  775.     size = sizeof(packet_wrapper);
    776. 

  776.     //log_print("[mpeg_add_header:%d]wrapper size=%d\n",__LINE__,size);
    777. 

  777.     MEMCPY(pkt->hdr->data + size, para->vstream_info.extradata, para->vstream_info.extradata_size);
    778. 

  778.     size += para->vstream_info.extradata_size;
    779. 

  779.     //log_print("[mpeg_add_header:%d]wrapper+seq size=%d\n",__LINE__,size);
    780. 

  780.     MEMSET(pkt->hdr->data + size, 0xff, STUFF_BYTES_LENGTH);
    781. 

  781.     size += STUFF_BYTES_LENGTH;
    782. 

  782.     pkt->hdr->size = size;
    783. 

  783.     //log_print("[mpeg_add_header:%d]hdr_size=%d\n",__LINE__,size);
    784. 

  784.     if (para->codec) {
    785. 

  785.         pkt->codec = para->codec;
    786. 

  786.     } else {
    787. 

  787.         log_print("[mpeg_add_header]invalid codec!");
    788. 

  788.         return PLAYER_EMPTY_P;
    789. 

  789.     }
    790. 

  790. #ifdef DEBUG_MPEG_SEARCH
    791. 

  791.     int i;
    792. 

  792.     for (i = 0; i < pkt->hdr->size; i++) {
    793. 

  793.         if (i % 16 == 0) {
    794. 

  794.             log_print("\n");
    795. 

  795.         }
    796. 

  796.         log_print("%02x ", pkt->hdr->data[i]);
    797. 

  797.     }
    798. 

  798. #endif
    799. 

  799.     pkt->avpkt_newflag = 1;
    800. 

  800.     return write_av_packet(para);
    801. 

  801. }
    802. 

  802. static int generate_vorbis_header(unsigned char *extradata, unsigned extradata_size, unsigned char** header_start, unsigned *header_len)
    803. 

  803. {
    804. 

  804. #define RB16(x)             ((((const uint8_t*)(x))[0] << 8) | ((const uint8_t*)(x))[1])
    805. 

  805.     int i;
    806. 

  806.     int first_header_size = 30;
    807. 

  807.     if (extradata_size >= 6 && RB16(extradata) == first_header_size) {
    808. 

  808.         int overall_len = 6;
    809. 

  809.         for (i=0; i<3; i++) {
    810. 

  810.             header_len[i] = RB16(extradata);
    811. 

  811.             extradata += 2;
    812. 

  812.             header_start[i] = extradata;
    813. 

  813.             extradata += header_len[i];
    814. 

  814.             if (overall_len > extradata_size - header_len[i])
    815. 

  815.                 return -1;
    816. 

  816.             overall_len += header_len[i];
    817. 

  817.         }
    818. 

  818.     } else if (extradata_size >= 3 && extradata_size < INT_MAX - 0x1ff && extradata[0] == 2) {
    819. 

  819.         int overall_len = 3;
    820. 

  820.         extradata++;
    821. 

  821.         for (i=0; i<2; i++, extradata++) {
    822. 

  822.             header_len[i] = 0;
    823. 

  823.             for (; overall_len < extradata_size && *extradata==0xff; extradata++) {
    824. 

  824.                 header_len[i] += 0xff;
    825. 

  825.                 overall_len   += 0xff + 1;
    826. 

  826.             }
    827. 

  827.             header_len[i] += *extradata;
    828. 

  828.             overall_len   += *extradata;
    829. 

  829.             if (overall_len > extradata_size)
    830. 

  830.                 return -1;
    831. 

  831.         }
    832. 

  832.         header_len[2] = extradata_size - overall_len;
    833. 

  833.         header_start[0] = extradata;
    834. 

  834.         header_start[1] = header_start[0] + header_len[0];
    835. 

  835.         header_start[2] = header_start[1] + header_len[1];
    836. 

  836.     } else {
    837. 

  837.         return -1;
    838. 

  838.     }
    839. 

  839.     return 0;
    840. 

  840. }
    841. 

  841. 

  842. static int audio_add_header(play_para_t *para)
    843. 

  843. {
    844. 

  844.     unsigned ext_size = para->pFormatCtx->streams[para->astream_info.audio_index]->codec->extradata_size;
    845. 

  845.     unsigned char *extradata = para->pFormatCtx->streams[para->astream_info.audio_index]->codec->extradata;
    846. 

  846.     am_packet_t *pkt = para->p_pkt;
    847. 

  847.     if (ext_size > 0) {
    848. 

  848.         log_print("==============audio add header =======================\n");
    849. 

  849.         if (para->astream_info.audio_format ==  AFORMAT_VORBIS) {
    850. 

  850.             unsigned char* vorbis_headers[3];
    851. 

  851.             unsigned int vorbis_header_sizes[3] = {0, 0, 0};
    852. 

  852.             if (generate_vorbis_header(extradata, ext_size, vorbis_headers, vorbis_header_sizes)) {
    853. 

  853.                 log_print("general vorbis header failed,audio not support\n");
    854. 

  854.                 return PLAYER_UNSUPPORT_AUDIO;
    855. 

  855.             }
    856. 

  856.             if (pkt->hdr->data) {
    857. 

  857.                 FREE(pkt->hdr->data);
    858. 

  858.             }
    859. 

  859.             pkt->hdr->data = (char *)MALLOC(vorbis_header_sizes[0] + vorbis_header_sizes[1] + vorbis_header_sizes[2]);
    860. 

  860.             if (!pkt->hdr->data) {
    861. 

  861.                 log_print("malloc %d mem failed,at func %s,line %d\n", \
    862. 

  862.                           (vorbis_header_sizes[0] + vorbis_header_sizes[1] + vorbis_header_sizes[2]), __FUNCTION__, __LINE__);
    863. 

  863.                 return PLAYER_NOMEM;
    864. 

  864.             }
    865. 

  865.             MEMCPY(pkt->hdr->data, vorbis_headers[0], vorbis_header_sizes[0]);
    866. 

  866.             MEMCPY(pkt->hdr->data + vorbis_header_sizes[0], vorbis_headers[1], vorbis_header_sizes[1]);
    867. 

  867.             MEMCPY(pkt->hdr->data + vorbis_header_sizes[0] + vorbis_header_sizes[1], \
    868. 

  868.                    vorbis_headers[2], vorbis_header_sizes[2]);
    869. 

  869.             pkt->hdr->size = (vorbis_header_sizes[0] + vorbis_header_sizes[1] + vorbis_header_sizes[2]);
    870. 

  870. 

  871. 

  872.         } else {
    873. 

  873.             MEMCPY(pkt->hdr->data, extradata , ext_size);
    874. 

  874.             pkt->hdr->size = ext_size;
    875. 

  875.         }
    876. 

  876.         pkt->avpkt_newflag = 1;
    877. 

  877.         if (para->acodec) {
    878. 

  878.             pkt->codec = para->acodec;
    879. 

  879. 

  880.         }
    881. 

  881.         pkt->type = CODEC_AUDIO;
    882. 

  882.         if (ext_size > 4) {
    883. 

  883.             log_print("audio header first four bytes[0x%x],[0x%x],[0x%x],[0x%x]\n", extradata[0], extradata[1], extradata[2], extradata[3]);
    884. 

  884.         }
    885. 

  885.         return write_av_packet(para);
    886. 

  886.     }
    887. 

  887.     return 0;
    888. 

  888. 

  889. }
    890. 

  890. 

  891. int pre_header_feeding(play_para_t *para)
    892. 

  892. {
    893. 

  893.     int ret = -1;
    894. 

  894.     AVStream *pStream = NULL;
    895. 

  895.     AVCodecContext *avcodec;
    896. 

  896.     int index = para->vstream_info.video_index;
    897. 

  897.     am_packet_t *pkt = para->p_pkt;
    898. 

  898.     int extra_size = 0;
    899. 

  899.     if (-1 == index) {
    900. 

  900.         return PLAYER_ERROR_PARAM;
    901. 

  901.     }
    902. 

  902. 

  903.     pStream = para->pFormatCtx->streams[index];
    904. 

  904.     avcodec = pStream->codec;
    905. 

  905.     if (IS_AUIDO_NEED_PREFEED_HEADER(para->astream_info.audio_format) &&
    906. 

  906.         para->astream_info.has_audio) {
    907. 

  907.         if (pkt->hdr == NULL) {
    908. 

  908.             pkt->hdr = MALLOC(sizeof(hdr_buf_t));
    909. 

  909.             extra_size = para->pFormatCtx->streams[para->astream_info.audio_index]->codec->extradata_size;
    910. 

  910.             if (extra_size > 0) {
    911. 

  911.                 pkt->hdr->data = (char *)MALLOC(extra_size);
    912. 

  912.                 if (!pkt->hdr->data) {
    913. 

  913.                     log_print("[pre_header_feeding] NOMEM!");
    914. 

  914.                     return PLAYER_NOMEM;
    915. 

  915.                 }
    916. 

  916.             }
    917. 

  917.         }
    918. 

  918.         ret = audio_add_header(para);
    919. 

  919.         if (pkt->hdr) {
    920. 

  920.             if (pkt->hdr->data) {
    921. 

  921.                 FREE(pkt->hdr->data);
    922. 

  922.                 pkt->hdr->data = NULL;
    923. 

  923.             }
    924. 

  924.             FREE(pkt->hdr);
    925. 

  925.             pkt->hdr = NULL;
    926. 

  926.         }
    927. 

  927.         if (ret != PLAYER_SUCCESS) {
    928. 

  928.             return ret;
    929. 

  929.         }
    930. 

  930.     }
    931. 

  931. 

  932.     if (para->stream_type == STREAM_ES && para->vstream_info.has_video) {
    933. 

  933.         if (pkt->hdr == NULL) {
    934. 

  934.             pkt->hdr = MALLOC(sizeof(hdr_buf_t));
    935. 

  935.             pkt->hdr->data = (char *)MALLOC(HDR_BUF_SIZE);
    936. 

  936.             if (!pkt->hdr->data) {
    937. 

  937.                 log_print("[pre_header_feeding] NOMEM!");
    938. 

  938.                 return PLAYER_NOMEM;
    939. 

  939.             }
    940. 

  940.             pkt->hdr->size = 0;
    941. 

  941.         }
    942. 

  942. 

  943.         if (VFORMAT_MJPEG == para->vstream_info.video_format) {
    944. 

  944.             ret = mjpeg_write_header(para);
    945. 

  945.             if (ret != PLAYER_SUCCESS) {
    946. 

  946.                 return ret;
    947. 

  947.             }
    948. 

  948.         }
    949. 

  949.         if ((STREAM_FILE == para->file_type)) {
    950. 

  950.             ret = write_stream_header(para);
    951. 

  951.             if (ret != PLAYER_SUCCESS) {
    952. 

  952.                 return ret;
    953. 

  953.             }
    954. 

  954.         } else if ((VFORMAT_MPEG4 == para->vstream_info.video_format) &&
    955. 

  955.                    (VIDEO_DEC_FORMAT_MPEG4_3 == para->vstream_info.video_codec_type)) {
    956. 

  956.             ret = divx3_write_header(para);
    957. 

  957.             if (ret != PLAYER_SUCCESS) {
    958. 

  958.                 return ret;
    959. 

  959.             }
    960. 

  960.         } else if ((VFORMAT_H264 == para->vstream_info.video_format) || (VFORMAT_H264MVC == para->vstream_info.video_format)) {
    961. 

  961.             ret = h264_write_header(para);
    962. 

  962.             if (ret != PLAYER_SUCCESS) {
    963. 

  963.                 return ret;
    964. 

  964.             }
    965. 

  965.         } else if ((CODEC_TAG_M4S2 == avcodec->codec_tag) ||
    966. 

  966.                    (CODEC_TAG_DX50 == avcodec->codec_tag) ||
    967. 

  967.                    (CODEC_TAG_mp4v == avcodec->codec_tag)) {
    968. 

  968.             ret = m4s2_dx50_mp4v_write_header(para);
    969. 

  969.             if (ret != PLAYER_SUCCESS) {
    970. 

  970.                 return ret;
    971. 

  971.             }
    972. 

  972.         } else if ((AVI_FILE == para->file_type)
    973. 

  973.                    && (VIDEO_DEC_FORMAT_MPEG4_3 != para->vstream_info.video_codec_type)
    974. 

  974.                    && (VFORMAT_H264 != para->vstream_info.video_format)
    975. 

  975.                    && (VFORMAT_VC1 != para->vstream_info.video_format)) {
    976. 

  976.             ret = avi_write_header(para);
    977. 

  977.             if (ret != PLAYER_SUCCESS) {
    978. 

  978.                 return ret;
    979. 

  979.             }
    980. 

  980.         } else if (CODEC_TAG_WMV3 == avcodec->codec_tag) {
    981. 

  981.             ret = wmv3_write_header(para);
    982. 

  982.             if (ret != PLAYER_SUCCESS) {
    983. 

  983.                 return ret;
    984. 

  984.             }
    985. 

  985.         } else if ((CODEC_TAG_WVC1 == avcodec->codec_tag) || (CODEC_TAG_WMVA == avcodec->codec_tag)) {
    986. 

  986.             ret = wvc1_write_header(para);
    987. 

  987.             if (ret != PLAYER_SUCCESS) {
    988. 

  988.                 return ret;
    989. 

  989.             }
    990. 

  990.         } else if ((MKV_FILE == para->file_type)
    991. 

  991.                    && ((VFORMAT_MPEG4 == para->vstream_info.video_format) || (VFORMAT_MPEG12 == para->vstream_info.video_format))) {
    992. 

  992.             ret = mkv_write_header(para);
    993. 

  993.             if (ret != PLAYER_SUCCESS) {
    994. 

  994.                 return ret;
    995. 

  995.             }
    996. 

  996.         }
    997. 

  997. 

  998.         if (pkt->hdr) {
    999. 

  999.             if (pkt->hdr->data) {
    1000. 

  1000.                 FREE(pkt->hdr->data);
    1001. 

  1001.                 pkt->hdr->data = NULL;
    1002. 

  1002.             }
    1003. 

  1003.             FREE(pkt->hdr);
    1004. 

  1004.             pkt->hdr = NULL;
    1005. 

  1005.         }
    1006. 

  1006. 

  1007.     } else if (para->stream_type == STREAM_PS && para->vstream_info.has_video && para->playctrl_info.time_point > 0) {
    1008. 

  1008.         if (pkt->hdr == NULL) {
    1009. 

  1009.             pkt->hdr = MALLOC(sizeof(hdr_buf_t));
    1010. 

  1010.             pkt->hdr->data = (char *)MALLOC(HDR_BUF_SIZE);
    1011. 

  1011.             if (!pkt->hdr->data) {
    1012. 

  1012.                 log_print("[pre_header_feeding] NOMEM!");
    1013. 

  1013.                 return PLAYER_NOMEM;
    1014. 

  1014.             }
    1015. 

  1015.         }
    1016. 

  1016.         if ((CODEC_ID_MPEG1VIDEO == avcodec->codec_id)
    1017. 

  1017.             || (CODEC_ID_MPEG2VIDEO == avcodec->codec_id)
    1018. 

  1018.             || (CODEC_ID_MPEG2VIDEO_XVMC == avcodec->codec_id)) {
    1019. 

  1019.             ret = mpeg_add_header(para);
    1020. 

  1020.             if (ret != PLAYER_SUCCESS) {
    1021. 

  1021.                 return ret;
    1022. 

  1022.             }
    1023. 

  1023.         }
    1024. 

  1024.         if (pkt->hdr) {
    1025. 

  1025.             if (pkt->hdr->data) {
    1026. 

  1026.                 FREE(pkt->hdr->data);
    1027. 

  1027.                 pkt->hdr->data = NULL;
    1028. 

  1028.             }
    1029. 

  1029.             FREE(pkt->hdr);
    1030. 

  1030.             pkt->hdr = NULL;
    1031. 

  1031.         }
    1032. 

  1032.     }
    1033. 

  1033.     return PLAYER_SUCCESS;
    1034. 

  1034. }
    1035. 

  1035. 

  1036. int h264_update_frame_header(am_packet_t *pkt)
    1037. 

  1037. {
    1038. 

  1038.     int nalsize, size = pkt->data_size;
    1039. 

  1039.     unsigned char *data = pkt->data;
    1040. 

  1040.     unsigned char *p = data;
    1041. 

  1041.     if (p != NULL) {
    1042. 

  1042.         if (check_size_in_buffer(p, size)) {
    1043. 

  1043.             while ((p + 4) < (data + size)) {
    1044. 

  1044.                 nalsize = (*p << 24) | (*(p + 1) << 16) | (*(p + 2) << 8) | (*(p + 3));
    1045. 

  1045.                 *p = 0;
    1046. 

  1046.                 *(p + 1) = 0;
    1047. 

  1047.                 *(p + 2) = 0;
    1048. 

  1048.                 *(p + 3) = 1;
    1049. 

  1049.                 p += (nalsize + 4);
    1050. 

  1050.             }
    1051. 

  1051.             return PLAYER_SUCCESS;
    1052. 

  1052.         } else if (check_size_in_buffer3(p, size)) {
    1053. 

  1053.             while ((p + 3) < (data + size)) {
    1054. 

  1054.                 nalsize = (*p << 16) | (*(p + 1) << 8) | (*(p + 2));
    1055. 

  1055.                 *p = 0;
    1056. 

  1056.                 *(p + 1) = 0;
    1057. 

  1057.                 *(p + 2) = 1;
    1058. 

  1058.                 p += (nalsize + 3);
    1059. 

  1059.             }
    1060. 

  1060.             return PLAYER_SUCCESS;
    1061. 

  1061.         } else if (check_size_in_buffer2(p, size)) {
    1062. 

  1062.             unsigned char *new_data;
    1063. 

  1063.             int new_len = 0;
    1064. 

  1064. 

  1065.             new_data = (unsigned char *)MALLOC(size + 2 * 1024);
    1066. 

  1066.             if (!new_data) {
    1067. 

  1067.                 return PLAYER_NOMEM;
    1068. 

  1068.             }
    1069. 

  1069. 

  1070.             while ((p + 2) < (data + size)) {
    1071. 

  1071.                 nalsize = (*p << 8) | (*(p + 1));
    1072. 

  1072.                 *(new_data + new_len) = 0;
    1073. 

  1073.                 *(new_data + new_len + 1) = 0;
    1074. 

  1074.                 *(new_data + new_len + 2) = 0;
    1075. 

  1075.                 *(new_data + new_len + 3) = 1;
    1076. 

  1076.                 memcpy(new_data + new_len + 4, p + 2, nalsize);
    1077. 

  1077.                 p += (nalsize + 2);
    1078. 

  1078.                 new_len += nalsize + 4;
    1079. 

  1079.             }
    1080. 

  1080. 

  1081.             FREE(pkt->buf);
    1082. 

  1082. 

  1083.             pkt->buf = new_data;
    1084. 

  1084.             pkt->buf_size = size + 2 * 1024;
    1085. 

  1085.             pkt->data = pkt->buf;
    1086. 

  1086.             pkt->data_size = new_len;
    1087. 

  1087.         }
    1088. 

  1088.     } else {
    1089. 

  1089.         log_error("[%s]invalid pointer!\n", __FUNCTION__);
    1090. 

  1090.         return PLAYER_FAILED;
    1091. 

  1091.     }
    1092. 

  1092.     return PLAYER_SUCCESS;
    1093. 

  1093. }
    1094. 

  1094. 

  1095. int divx3_prefix(am_packet_t *pkt)
    1096. 

  1096. {
    1097. 

  1097. #define DIVX311_CHUNK_HEAD_SIZE 13
    1098. 

  1098.     const unsigned char divx311_chunk_prefix[DIVX311_CHUNK_HEAD_SIZE] = {
    1099. 

  1099.         0x00, 0x00, 0x00, 0x01, 0xb6, 'D', 'I', 'V', 'X', '3', '.', '1', '1'
    1100. 

  1100.     };
    1101. 

  1101.     if ((pkt->hdr != NULL) && (pkt->hdr->data != NULL)) {
    1102. 

  1102.         FREE(pkt->hdr->data);
    1103. 

  1103.         pkt->hdr->data = NULL;
    1104. 

  1104.     }
    1105. 

  1105. 

  1106.     if (pkt->hdr == NULL) {
    1107. 

  1107.         pkt->hdr = MALLOC(sizeof(hdr_buf_t));
    1108. 

  1108.         if (!pkt->hdr) {
    1109. 

  1109.             log_print("[divx3_prefix] NOMEM!");
    1110. 

  1110.             return PLAYER_FAILED;
    1111. 

  1111.         }
    1112. 

  1112. 

  1113.         pkt->hdr->data = NULL;
    1114. 

  1114.         pkt->hdr->size = 0;
    1115. 

  1115.     }
    1116. 

  1116. 

  1117.     pkt->hdr->data = MALLOC(DIVX311_CHUNK_HEAD_SIZE + 4);
    1118. 

  1118.     if (pkt->hdr->data == NULL) {
    1119. 

  1119.         log_print("[divx3_prefix] NOMEM!");
    1120. 

  1120.         return PLAYER_FAILED;
    1121. 

  1121.     }
    1122. 

  1122. 

  1123.     MEMCPY(pkt->hdr->data, divx311_chunk_prefix, DIVX311_CHUNK_HEAD_SIZE);
    1124. 

  1124. 

  1125.     pkt->hdr->data[DIVX311_CHUNK_HEAD_SIZE + 0] = (pkt->data_size >> 24) & 0xff;
    1126. 

  1126.     pkt->hdr->data[DIVX311_CHUNK_HEAD_SIZE + 1] = (pkt->data_size >> 16) & 0xff;
    1127. 

  1127.     pkt->hdr->data[DIVX311_CHUNK_HEAD_SIZE + 2] = (pkt->data_size >>  8) & 0xff;
    1128. 

  1128.     pkt->hdr->data[DIVX311_CHUNK_HEAD_SIZE + 3] = pkt->data_size & 0xff;
    1129. 

  1129. 

  1130.     pkt->hdr->size = DIVX311_CHUNK_HEAD_SIZE + 4;
    1131. 

  1131.     pkt->avpkt_newflag = 1;
    1132. 

  1132. 

  1133.     return PLAYER_SUCCESS;
    1134. 

  1134. }
    1135. 

  1135. 

  1136. int get_vc1_di(unsigned char *data, int length)
    1137. 

  1137. {
    1138. 

  1138.     int i, j;
    1139. 

  1139.     int profile;
    1140. 

  1140.     int interlace, FCM1;
    1141. 

  1141. 

  1142.     if (length < 22) {
    1143. 

  1143.         return 0;
    1144. 

  1144.     }
    1145. 

  1145. 

  1146.     if (data[0] == 0x00 && data[1] == 0x00 && data[2] == 0x01 && data[3] == 0x0f) {
    1147. 

  1147.         /* sequence header */
    1148. 

  1148.         profile = (data[4] >> 6) & 0x03;
    1149. 

  1149.         log_print("data[4] 0x%x, profile 0x%x\n", data[4], profile);
    1150. 

  1150.         if (profile != 3) {// not advanced profile
    1151. 

  1151.             return 0;
    1152. 

  1152.         }
    1153. 

  1153. 

  1154.         interlace = (data[9] >> 6) & 0x01;
    1155. 

  1155.         log_print("data[9] 0x%x, interlace 0x%x\n", data[9], interlace);
    1156. 

  1156.         if (interlace == 0) {
    1157. 

  1157.             return 0;
    1158. 

  1158.         }
    1159. 

  1159. 

  1160.         i = 22;
    1161. 

  1161.         j = i + 4;
    1162. 

  1162.         while (j < length) { // search key word 0x0000010d
    1163. 

  1163.             if (data[i] == 0x00 && data[i+1] == 0x00 && data[i+2] == 0x01 && data[i+3] == 0x0d) {
    1164. 

  1164.                 break;
    1165. 

  1165.             }
    1166. 

  1166. 

  1167.             i++;
    1168. 

  1168.             j++;
    1169. 

  1169.         }
    1170. 

  1170. 

  1171.         if (j >= length) {
    1172. 

  1172.             return 0;
    1173. 

  1173.         }
    1174. 

  1174. 

  1175.         FCM1 = (data[j] >> 7) & 0x01;
    1176. 

  1176.         log_print("FCM j %d, data[%d] 0x%x, FCM1 0x%x\n", j, j, data[j], FCM1);
    1177. 

  1177. 

  1178.         if (FCM1 == 1) {
    1179. 

  1179.             return 1;
    1180. 

  1180.         } else {
    1181. 

  1181.             return 0;
    1182. 

  1182.         }
    1183. 

  1183.     }
    1184. 

  1184. 

  1185.     return 0;
    1186. 

  1186. }
    1187. 

  1187. 

  1188. int h264_write_end_header(play_para_t *para)
    1189. 

  1189. {
    1190. 

  1190.     int ret;
    1191. 

  1191.     unsigned char *tmp_data = NULL;
    1192. 

  1192.     unsigned char end_header[] = {
    1193. 

  1193.         0x00, 0x00, 0x00, 0x01, 0x06, 0x05, 0xff, 0xe4, 0xdc, 0x45, 0xe9, 0xbd, 0xe6, 0xd9, 0x48, 0xb7,
    1194. 

  1194.         0x96, 0x2c, 0xd8, 0x20, 0xd9, 0x23, 0xee, 0xef, 0x78, 0x32, 0x36, 0x34, 0x20, 0x2d, 0x20, 0x63,
    1195. 

  1195.         0x6f, 0x72, 0x65, 0x20, 0x36, 0x37, 0x20, 0x72, 0x31, 0x31, 0x33, 0x30, 0x20, 0x38, 0x34, 0x37,
    1196. 

  1196.         0x35, 0x39, 0x37, 0x37, 0x20, 0x2d, 0x20, 0x48, 0x2e, 0x32, 0x36, 0x34, 0x2f, 0x4d, 0x50, 0x45,
    1197. 

  1197.         0x47, 0x2d, 0x34, 0x20, 0x41, 0x56, 0x43, 0x20, 0x63, 0x6f, 0x64, 0x65, 0x63, 0x20, 0x2d, 0x20,
    1198. 

  1198.         0x43, 0x6f, 0x70, 0x79, 0x6c, 0x65, 0x66, 0x74, 0x20, 0x32, 0x30, 0x30, 0x33, 0x2d, 0x32, 0x30,
    1199. 

  1199.         0x30, 0x39, 0x20, 0x2d, 0x20, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e,
    1200. 

  1200.         0x76, 0x69, 0x64, 0x65, 0x6f, 0x6c, 0x61, 0x6e, 0x2e, 0x6f, 0x72, 0x67, 0x2f, 0x78, 0x32, 0x36,
    1201. 

  1201.         0x34, 0x2e, 0x68, 0x74, 0x6d, 0x6c, 0x20, 0x2d, 0x20, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73,
    1202. 

  1202.         0x3a, 0x20, 0x63, 0x61, 0x62, 0x61, 0x63, 0x3d, 0x31, 0x20, 0x72, 0x65, 0x66, 0x3d, 0x31, 0x20,
    1203. 

  1203.         0x64, 0x65, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x3d, 0x31, 0x3a, 0x30, 0x3a, 0x30, 0x20, 0x61, 0x6e,
    1204. 

  1204.         0x61, 0x6c, 0x79, 0x73, 0x65, 0x3d, 0x30, 0x78, 0x31, 0x3a, 0x30, 0x78, 0x31, 0x31, 0x31, 0x20,
    1205. 

  1205.         0x6d, 0x65, 0x3d, 0x68, 0x65, 0x78, 0x20, 0x73, 0x75, 0x62, 0x6d, 0x65, 0x3d, 0x36, 0x20, 0x70,
    1206. 

  1206.         0x73, 0x79, 0x5f, 0x72, 0x64, 0x3d, 0x31, 0x2e, 0x30, 0x3a, 0x30, 0x2e, 0x30, 0x20, 0x6d, 0x69,
    1207. 

  1207.         0x78, 0x65, 0x64, 0x5f, 0x72, 0x65, 0x66, 0x3d, 0x30, 0x20, 0x6d, 0x65, 0x5f, 0x72, 0x61, 0x6e,
    1208. 

  1208.         0x67, 0x65, 0x3d, 0x31, 0x36, 0x20, 0x63, 0x68, 0x72, 0x6f, 0x6d, 0x61, 0x5f, 0x6d, 0x65, 0x3d,
    1209. 

  1209.         0x31, 0x20, 0x74, 0x72, 0x65, 0x6c, 0x6c, 0x69, 0x73, 0x3d, 0x30, 0x20, 0x38, 0x78, 0x38, 0x64,
    1210. 

  1210.         0x63, 0x74, 0x3d, 0x30, 0x20, 0x63, 0x71, 0x6d, 0x3d, 0x30, 0x20, 0x64, 0x65, 0x61, 0x64, 0x7a,
    1211. 

  1211.         0x6f, 0x6e, 0x65, 0x3d, 0x32, 0x31, 0x2c, 0x31, 0x31, 0x20, 0x63, 0x68, 0x72, 0x6f, 0x6d, 0x61,
    1212. 

  1212.         0x5f, 0x71, 0x70, 0x5f, 0x6f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x3d, 0x2d, 0x32, 0x20, 0x74, 0x68,
    1213. 

  1213.         0x72, 0x65, 0x61, 0x64, 0x73, 0x3d, 0x31, 0x20, 0x6e, 0x72, 0x3d, 0x30, 0x20, 0x64, 0x65, 0x63,
    1214. 

  1214.         0x69, 0x6d, 0x61, 0x74, 0x65, 0x3d, 0x31, 0x20, 0x6d, 0x62, 0x61, 0x66, 0x66, 0x3d, 0x30, 0x20,
    1215. 

  1215.         0x62, 0x66, 0x72, 0x61, 0x6d, 0x65, 0x73, 0x3d, 0x30, 0x20, 0x6b, 0x65, 0x79, 0x69, 0x6e, 0x74,
    1216. 

  1216.         0x3d, 0x32, 0x35, 0x30, 0x20, 0x6b, 0x65, 0x79, 0x69, 0x6e, 0x74, 0x5f, 0x6d, 0x69, 0x6e, 0x3d,
    1217. 

  1217.         0x32, 0x35, 0x20, 0x73, 0x63, 0x65, 0x6e, 0x65, 0x63, 0x75, 0x74, 0x3d, 0x34, 0x30, 0x20, 0x72,
    1218. 

  1218.         0x63, 0x3d, 0x61, 0x62, 0x72, 0x20, 0x62, 0x69, 0x74, 0x72, 0x61, 0x74, 0x65, 0x3d, 0x31, 0x30,
    1219. 

  1219.         0x20, 0x72, 0x61, 0x74, 0x65, 0x74, 0x6f, 0x6c, 0x3d, 0x31, 0x2e, 0x30, 0x20, 0x71, 0x63, 0x6f,
    1220. 

  1220.         0x6d, 0x70, 0x3d, 0x30, 0x2e, 0x36, 0x30, 0x20, 0x71, 0x70, 0x6d, 0x69, 0x6e, 0x3d, 0x31, 0x30,
    1221. 

  1221.         0x20, 0x71, 0x70, 0x6d, 0x61, 0x78, 0x3d, 0x35, 0x31, 0x20, 0x71, 0x70, 0x73, 0x74, 0x65, 0x70,
    1222. 

  1222.         0x3d, 0x34, 0x20, 0x69, 0x70, 0x5f, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x3d, 0x31, 0x2e, 0x34, 0x30,
    1223. 

  1223.         0x20, 0x61, 0x71, 0x3d, 0x31, 0x3a, 0x31, 0x2e, 0x30, 0x30, 0x00, 0x80, 0x00, 0x00, 0x00, 0x01,
    1224. 

  1224.         0x67, 0x4d, 0x40, 0x0a, 0x9a, 0x74, 0xf4, 0x20, 0x00, 0x00, 0x03, 0x00, 0x20, 0x00, 0x00, 0x06,
    1225. 

  1225.         0x51, 0xe2, 0x44, 0xd4, 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x32, 0xc8, 0x00, 0x00, 0x00, 0x01,
    1226. 

  1226.         0x65, 0x88, 0x80, 0x20, 0x00, 0x08, 0x7f, 0xea, 0x6a, 0xe2, 0x99, 0xb6, 0x57, 0xae, 0x49, 0x30,
    1227. 

  1227.         0xf5, 0xfe, 0x5e, 0x46, 0x0b, 0x72, 0x44, 0xc4, 0xe1, 0xfc, 0x62, 0xda, 0xf1, 0xfb, 0xa2, 0xdb,
    1228. 

  1228.         0xd6, 0xbe, 0x5c, 0xd7, 0x24, 0xa3, 0xf5, 0xb9, 0x2f, 0x57, 0x16, 0x49, 0x75, 0x47, 0x77, 0x09,
    1229. 

  1229.         0x5c, 0xa1, 0xb4, 0xc3, 0x4f, 0x60, 0x2b, 0xb0, 0x0c, 0xc8, 0xd6, 0x66, 0xba, 0x9b, 0x82, 0x29,
    1230. 

  1230.         0x33, 0x92, 0x26, 0x99, 0x31, 0x1c, 0x7f, 0x9b
    1231. 

  1231.     };
    1232. 

  1232.     int header_size = sizeof(end_header) / sizeof(unsigned char);
    1233. 

  1233. 

  1234.     tmp_data = MALLOC(1024);
    1235. 

  1235.     if (!tmp_data) {
    1236. 

  1236.         return 0;
    1237. 

  1237.     }
    1238. 

  1238.     MEMSET(tmp_data, 0, 1024);
    1239. 

  1239.     MEMCPY(tmp_data, &end_header, header_size);
    1240. 

  1240.     ret = codec_write(para->vcodec, (void *)tmp_data, 1024);
    1241. 

  1241.     log_print("[%s:%d]ret %d\n", __FUNCTION__, __LINE__, ret);
    1242. 

  1242.     FREE(tmp_data);
    1243. 

  1243. 

  1244.     return ret;
    1245. 

  1245. }
    1246. 

  1246.