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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > Windows CE > 查看源码
faad.c
资源名称：tcpmp.rar　[点击查看]
上传用户：wstnjxml
上传日期：2014-04-03
资源大小：7248k
文件大小：9k
源码类别：

Windows CE

开发平台：

C/C++

faad.c：源码内容
  1. /*****************************************************************************
  2.  *
  3.  * This program is free software ; you can redistribute it and/or modify
  4.  * it under the terms of the GNU General Public License as published by
  5.  * the Free Software Foundation; either version 2 of the License, or
  6.  * (at your option) any later version.
  7.  *
  8.  * This program is distributed in the hope that it will be useful,
  9.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  11.  * GNU General Public License for more details.
  12.  *
  13.  * You should have received a copy of the GNU General Public License
  14.  * along with this program; if not, write to the Free Software
  15.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  16.  *
  17.  * $Id: faad.c 598 2006-01-18 21:27:40Z picard $
  18.  *
  19.  * The Core Pocket Media Player
  20.  * Copyright (c) 2004-2005 Gabor Kovacs
  21.  *
  22.  ****************************************************************************/
  24. #include "../common/common.h"
  25. #include "faad.h"
  26. #include "faad2/include/neaacdec.h"
  28. #if SAFETAIL < 12
  29. #error Minimum 12 bytes tail needed in buffer
  30. #endif
  32. #define STACK_SIZE 0x20000
  33. #define MAX_CHANNELS 6 
  34. #define BUFFER_NEEDED (FAAD_MIN_STREAMSIZE * MAX_CHANNELS)
  35. #define HEADER_NEEDED 16384
  37. typedef struct faad
  38. {
  39. codec Codec;
  40. buffer Buffer;
  41. NeAACDecHandle Decoder;
  42. bool_t ErrorMessage;
  43. bool_t Inited;
  44. bool_t PacketBased;
  45. tick_t NextRefTime;
  46. int FormatSet;
  47. char* Stack;
  49. } faad;
  51. static int UpdateInput( faad* p )
  52. {
  53. if (p->Decoder)
  54. {
  55.     NeAACDecClose(p->Decoder);
  56. p->Decoder = NULL;
  57. }
  59. #ifdef SWAPSP2
  60. if (p->Stack)
  61. {
  62. int i;
  63. for (i=0;i<STACK_SIZE;++i)
  64. if (p->Stack[i] != 0x11)
  65. {
  66. DebugMessage("Stack usage: %d",STACK_SIZE-i);
  67. ThreadSleep(300);
  68. break;
  69. }
  70. }
  72. free(p->Stack);
  73. p->Stack = NULL;
  74. #endif
  76. p->Inited = 0;
  77. p->ErrorMessage = 0;
  78. BufferClear(&p->Buffer);
  80. if (p->Codec.In.Format.Type == PACKET_AUDIO)
  81. {
  82.     NeAACDecConfigurationPtr Config;
  84. p->Decoder = NeAACDecOpen();
  85. Config = NeAACDecGetCurrentConfiguration(p->Decoder);
  86. Config->defObjectType = LC;
  87. Config->outputFormat = FAAD_FMT_INTERNAL;
  88. Config->downMatrix = 1; // force downmix to stereo
  89. NeAACDecSetConfiguration(p->Decoder, Config);
  91. if (p->Codec.In.Format.ExtraLength)
  92. {
  93. unsigned long SampleRate;
  94. uint8_t Channels;
  96.     if (NeAACDecInit2(p->Decoder, p->Codec.In.Format.Extra, p->Codec.In.Format.ExtraLength, 
  97. &SampleRate, &Channels) < 0)
  98. {
  99. ShowError(p->Codec.Node.Class,AACFULL_ID,FAAD_NOT_SUPPORTED);
  100. NeAACDecClose(p->Decoder);
  101. p->Decoder = NULL;
  102. return ERR_NOT_SUPPORTED;
  103. }
  105. p->Codec.In.Format.Format.Audio.SampleRate = SampleRate;
  106. p->Codec.In.Format.Format.Audio.Channels = Channels;
  107. p->Inited = 1;
  108. }
  110. PacketFormatPCM(&p->Codec.Out.Format,&p->Codec.In.Format,30);
  111. p->Codec.Out.Format.Format.Audio.Flags = PCM_PLANES;
  112. p->PacketBased = (p->Codec.In.Format.Format.Audio.Flags & PCM_PACKET_BASED) != 0;
  113. p->FormatSet = 0;
  115. #ifdef SWAPSP2
  116. p->Stack = malloc(STACK_SIZE);
  117. if (!p->Stack)
  118. return ERR_OUT_OF_MEMORY;
  119. memset(p->Stack,0x11,STACK_SIZE);
  120. #endif
  121. }
  122.  
  123. return ERR_NONE;
  124. }
  126. static NOINLINE int Process2( faad* p, const packet* Packet, const flowstate* State )
  127. {
  128. bool_t Eof = !Packet && State;
  130. if (Packet)
  131. {
  132. // set new reftime
  133. if (Packet->RefTime >= 0)
  134. {
  135. if (p->PacketBased)
  136. {
  137. p->Codec.Packet.RefTime = p->NextRefTime;
  138. p->NextRefTime = Packet->RefTime;
  139. }
  140. else
  141. {
  142. p->Codec.Packet.RefTime = Packet->RefTime;
  143. if (p->Codec.In.Format.ByteRate>0)
  144. {
  145. p->Codec.Packet.RefTime -= Scale(p->Buffer.WritePos - p->Buffer.ReadPos,TICKSPERSEC,p->Codec.In.Format.ByteRate);
  146. if (p->Codec.Packet.RefTime<0)
  147. p->Codec.Packet.RefTime=0;
  148. }
  149. }
  150. }
  152. // add new packet to buffer
  153. BufferPack(&p->Buffer,0);
  154. BufferWrite(&p->Buffer,Packet->Data[0],Packet->Length,2048);
  156. if (!p->Inited)
  157. {
  158. unsigned long SampleRate;
  159. uint8_t Channels;
  160. int Readed;
  161. uint8_t* Buffer = p->Buffer.Data + p->Buffer.ReadPos;
  162. int Length = p->Buffer.WritePos - p->Buffer.ReadPos;
  164. if (!Eof && !p->PacketBased && Length < HEADER_NEEDED)
  165. return ERR_NEED_MORE_DATA;
  167. if (memcmp(Buffer, "ADIF", 4) == 0) 
  168. {
  169. int BitRate;
  171. if (Buffer[4] & 0x80) // copyright_id present?
  172. Buffer += 9;
  174. BitRate = (((int)Buffer[4] & 0x0F) << 19) |
  175.   ((int)Buffer[5] << 11) |
  176.   ((int)Buffer[6] << 3) |
  177.   ((int)Buffer[7] & 0xE0);
  179. p->Codec.In.Format.ByteRate = BitRate/8;
  180. }
  181. else
  182. {
  183. int Trash = 0;
  184. for (Trash=0;Trash<Length-16;++Trash)
  185. if (Buffer[Trash] == 0xFF && (Buffer[Trash+1] & 0xF6)==0xF0)
  186. break;
  188. if (Trash<Length-16)
  189. {
  190. static const int SampleRates[] = {96000,88200,64000,48000,44100,32000,24000,22050,16000,12000,11025,8000,7350,0,0,0};
  191. int Samples = 0;
  192. int Bytes = 0;
  194. Buffer += Trash;
  195. Length -= Trash;
  197. SampleRate = SampleRates[(Buffer[2] & 0x3C) >> 2];
  198. // check for SBR profile, double samples ???
  200. while (Length > 7)
  201. {
  202. int n;
  204. if (Buffer[0] != 0xFF || (Buffer[1] & 0xF6)!=0xF0)
  205. break;
  207. n = (((int)Buffer[3] & 3) << 11) | (((int)Buffer[4]) << 3) | (Buffer[5] >> 5);
  209. Bytes += n;
  210. Samples += 1024; 
  212. Length -= n;
  213. Buffer += n;
  214. }
  216. p->Codec.In.Format.ByteRate = Scale(Bytes,SampleRate,Samples);
  218. if (Length < 256 || Samples >= 32*1024) // successfull
  219. p->Buffer.ReadPos += Trash;
  220.   }
  221. }
  223. Readed = NeAACDecInit(p->Decoder, p->Buffer.Data + p->Buffer.ReadPos,
  224. p->Buffer.WritePos - p->Buffer.ReadPos, &SampleRate, &Channels);
  226. if (Readed < 0)
  227. {
  228. if (!p->ErrorMessage)
  229. {
  230. ShowError(p->Codec.Node.Class,AACFULL_ID,FAAD_NOT_SUPPORTED);
  231. p->ErrorMessage = 1;
  232. }
  233. BufferDrop(&p->Buffer);
  234. return ERR_NOT_SUPPORTED;
  235. }
  237. p->Inited = 1;
  238. p->Buffer.ReadPos += Readed;
  239. }
  241. }
  242. else
  243. if (p->Inited)
  244. p->Codec.Packet.RefTime = TIME_UNKNOWN;
  246. while ((p->PacketBased && Packet) || Eof || p->Buffer.WritePos >= p->Buffer.ReadPos+BUFFER_NEEDED)
  247. {
  248.     NeAACDecFrameInfo FrameInfo;
  249.     void* Buffer[16];
  250. int Size = p->Buffer.WritePos-p->Buffer.ReadPos;
  251. if (Size <= 0)
  252. break;
  254.         NeAACDecDecode2(p->Decoder, &FrameInfo,p->Buffer.Data+p->Buffer.ReadPos,Size,Buffer,MAX_INT);
  256. if (p->PacketBased)
  257. p->Buffer.ReadPos = p->Buffer.WritePos;
  258. else
  259. p->Buffer.ReadPos += FrameInfo.bytesconsumed;
  261.         if (!FrameInfo.error && FrameInfo.samples>0)
  262. {
  263. if (p->Codec.Out.Format.Format.Audio.SampleRate != (int)FrameInfo.samplerate ||
  264. p->Codec.Out.Format.Format.Audio.Channels != (int)FrameInfo.channels)
  265. {
  266. if (p->FormatSet && (p->Codec.Out.Format.Format.Audio.Channels!=1 || FrameInfo.channels!=2)) // allow PS mono->stereo
  267. {
  268. p->FormatSet--;
  269. break; // probably a bad frame, drop it
  270. }
  271. p->Codec.In.Format.Format.Audio.SampleRate = 
  272. p->Codec.Out.Format.Format.Audio.SampleRate = FrameInfo.samplerate;
  273. p->Codec.In.Format.Format.Audio.Channels = 
  274. p->Codec.Out.Format.Format.Audio.Channels = FrameInfo.channels;
  275. ConnectionUpdate(&p->Codec.Node,CODEC_OUTPUT,p->Codec.Out.Pin.Node,p->Codec.Out.Pin.No);
  276. }
  277. p->FormatSet = 16; // reset countdown
  279. p->Codec.Packet.Length = FrameInfo.samples * sizeof(int32_t);
  280. p->Codec.Packet.Data[0] = Buffer[0];
  281. p->Codec.Packet.Data[1] = Buffer[1];
  282. return ERR_NONE;
  283. }
  285. if (FrameInfo.error==28)
  286. {
  287. BufferDrop(&p->Buffer);
  288. return ERR_OUT_OF_MEMORY;
  289. }
  291. if (p->PacketBased)
  292. break;
  294. if (!FrameInfo.bytesconsumed)
  295. p->Buffer.ReadPos++;
  296. }
  298. return ERR_NEED_MORE_DATA;
  299. }
  301. static int Process( faad* p, const packet* Packet, const flowstate* State )
  302. {
  303. int Result;
  304. #ifdef SWAPSP2
  305. void* Old = SwapSP(p->Stack+STACK_SIZE);
  306. #endif
  307. Result = Process2(p,Packet,State);
  308. #ifdef SWAPSP2
  309. SwapSP(Old);
  310. #endif
  311. return Result;
  312. }
  314. extern void *faad_malloc(size_t size);
  316. uint8_t safestack(uint8_t (*decode)(NeAACDecHandle hDecoder, void *ics),NeAACDecHandle hDecoder, void *ics, void** stack)
  317. {
  318. uint8_t ret;
  319. #ifdef SWAPSP
  320. void* old;
  321. if (!*stack)
  322. {
  323. *stack = faad_malloc(STACK_SIZE);
  324. if (!*stack)
  325. return 1;
  326. }
  327. old = SwapSP(*stack+STACK_SIZE);
  328. #endif
  329. ret = decode(hDecoder,ics);
  330. #ifdef SWAPSP
  331. SwapSP(old);
  332. #endif
  333. return ret;
  334. }
  336. static int Flush(faad* p)
  337. {
  338. p->NextRefTime = TIME_UNKNOWN;
  339. BufferDrop(&p->Buffer);
  340. if (p->Decoder)
  341. NeAACDecPostSeekReset(p->Decoder,0);
  342. return ERR_NONE;
  343. }
  345. static int Create(faad* p)
  346. {
  347. p->Codec.Process = (packetprocess)Process;
  348. p->Codec.UpdateInput = (nodefunc)UpdateInput;
  349. p->Codec.Flush = (nodefunc)Flush;
  350. return ERR_NONE;
  351. }
  353. static const nodedef FAAD = 
  354. {
  355. sizeof(faad),
  356. #ifdef AACFULL_EXPORTS
  357. AACFULL_ID,
  358. CODEC_CLASS,
  359. PRI_DEFAULT+256,
  360. #else
  361. FAAD_ID,
  362. CODEC_CLASS,
  363. PRI_DEFAULT,
  364. #endif
  365. (nodecreate)Create,
  366. };
  368. static const nodedef AAC = 
  369. {
  370. 0, //parent size
  371. AAC_ID,
  372. RAWAUDIO_CLASS,
  373. #ifdef AACFULL_EXPORTS
  374. PRI_DEFAULT-4,
  375. #else
  376. PRI_DEFAULT-5,
  377. #endif
  378. };
  380. void FAAD_Init()
  381. {
  382. NodeRegisterClass(&FAAD);
  383. NodeRegisterClass(&AAC);
  384. }
  386. void FAAD_Done()
  387. {
  388. NodeUnRegisterClass(FAAD.Class);
  389. NodeUnRegisterClass(AAC_ID);
  390. }
  392. #ifdef __SYMBIAN32__
  393. uint32_t random_int2(void)
  394. {
  395.     return rand()|(rand()<<16);
  396. }
  397. #endif