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

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

Windows CE

开发平台：

C/C++

ffmpeg.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: ffmpeg.c 603 2006-01-19 13:00:33Z picard $
  18.  *
  19.  * The Core Pocket Media Player
  20.  * Copyright (c) 2004-2005 Gabor Kovacs
  21.  *
  22.  ****************************************************************************/
  24. #include "../common/common.h"
  25. #include "ffmpeg.h"
  27. #undef malloc
  28. #undef realloc
  29. #undef free
  30. #include "libavcodec/avcodec.h"
  32. typedef struct ffmpeg_video
  33. {
  34. codec Codec;
  35. buffer Buffer;
  36.     AVCodecContext *Context;
  37.     AVFrame *Picture;
  38. AVRational Aspect;
  39. int PixelFormat;
  40. int SkipToKey;
  41. int DropToKey;
  42. bool_t Dropping;
  43. int CodecId;
  44. tick_t FrameTime;
  45.     AVPaletteControl Palette;
  47. } ffmpeg_video;
  49. typedef struct codecinfo
  50. {
  51. int Id;
  52. int CodecId;
  53. const tchar_t* Name;
  54. const tchar_t* ContentType;
  56. } codecinfo;
  58. #define FFMPEG_VIDEO_CLASS FOURCC('F','F','M','V')
  60. static const codecinfo Info[] = 
  61. {
  62. {FOURCC('F','C','I','N'),CODEC_ID_CINEPAK,T("FFmpeg Cinepak"),
  63. T("vcodec/cvid")},
  64. {FOURCC('F','T','S','C'),CODEC_ID_TSCC,T("FFmpeg TSCC"),
  65. T("vcodec/tscc")},
  66. {FOURCC('F','M','S','0'),CODEC_ID_MSVIDEO1,T("FFmpeg Microsoft Video 1"),
  67. T("vcodec/cram,vcodec/msvc")},
  68. {FOURCC('F','M','P','G'),CODEC_ID_MPEG2VIDEO,T("FFmpeg MPEG1/2"),
  69. T("vcodec/mpeg,vcodec/mpg1")},
  70. {FOURCC('F','2','6','3'),CODEC_ID_H263,T("FFmpeg h.263"),
  71. T("vcodec/h263,vcodec/u263,vcodec/x263,vcodec/s263")},
  72. {FOURCC('F','A','V','C'),CODEC_ID_H264,T("FFmpeg AVC"),
  73. T("vcodec/avc1,vcodec/h264,vcodec/x264,vcodec/vssh")},
  74. {FOURCC('F','W','V','1'),CODEC_ID_WMV1,T("FFmpeg WMV1"),
  75. T("vcodec/wmv1")},
  76. {FOURCC('F','W','V','2'),CODEC_ID_WMV2,T("FFmpeg WMV2"),
  77. T("vcodec/wmv2")},
  78. // {FOURCC('F','W','V','3'),CODEC_ID_WMV3,T("FFmpeg WMV3"),
  79. // T("vcodec/wmv3")},
  80. // {FOURCC('F','S','V','1'),CODEC_ID_SVQ1,T("FFmpeg SVQ1"),
  81. // T("vcodec/svq1")},
  82. {FOURCC('F','S','V','3'),CODEC_ID_SVQ3,T("FFmpeg SVQ3"),
  83. T("vcodec/svq3")},
  84. {FOURCC('F','M','S','1'),CODEC_ID_MSMPEG4V1,T("FFmpeg MSMPEG1"),
  85. T("vcodec/mpg4,vcodec/mp41,vcodec/div1")},
  86. {FOURCC('F','M','S','2'),CODEC_ID_MSMPEG4V2,T("FFmpeg MSMPEG2"),
  87. T("vcodec/mp42,vcodec/div2")},
  88. {FOURCC('F','M','S','3'),CODEC_ID_MSMPEG4V3,T("FFmpeg MSMPEG3"),
  89. T("vcodec/mp43,vcodec/mpg3,vcodec/div3,vcodec/div4,vcodec/div5,vcodec/div6,vcodec/ap41,vcodec/col0,vcodec/col1,vcodec/3ivd")},
  90. {FOURCC('F','M','P','4'),CODEC_ID_MPEG4,T("FFmpeg MPEG4"),
  91. T("vcodec/divx,vcodec/dx50,vcodec/xvid,vcodec/mrs2,vcodec/3iv2,vcodec/mp4s,vcodec/pm4v,vcodec/blz0,vcodec/ump4,vcodec/m4s2,vcodec/mp4v,vcodec/fmp4")},
  93. {0},
  94. };
  96. static bool_t BuildOutputFormat(ffmpeg_video* p)
  97. {
  98. int pix_fmt = p->Context->pix_fmt;
  99. if (pix_fmt<0)
  100. pix_fmt = PIX_FMT_YUV420P; // is this needed?
  102. PacketFormatClear(&p->Codec.Out.Format);
  103. p->Codec.Out.Format.Type = PACKET_VIDEO;
  105. switch (pix_fmt)
  106. {
  107. case PIX_FMT_YUV410P:
  108. p->Codec.Out.Format.Format.Video.Pixel.Flags = PF_YUV410;
  109. break;
  110. case PIX_FMT_YUV420P:
  111. p->Codec.Out.Format.Format.Video.Pixel.Flags = PF_YUV420;
  112. break;
  113. case PIX_FMT_BGR24:
  114. DefaultRGB(&p->Codec.Out.Format.Format.Video.Pixel,24,8,8,8,0,0,0);
  115. break;
  116. case PIX_FMT_RGBA32:
  117. DefaultRGB(&p->Codec.Out.Format.Format.Video.Pixel,32,8,8,8,0,0,0);
  118. break;
  119. case PIX_FMT_RGB555:
  120. DefaultRGB(&p->Codec.Out.Format.Format.Video.Pixel,16,5,5,5,0,0,0);
  121. break;
  122. case PIX_FMT_PAL8:
  123. p->Codec.Out.Format.Format.Video.Pixel.Flags = PF_PALETTE;
  124. p->Codec.Out.Format.Format.Video.Pixel.BitCount = 8;
  125. p->Codec.Out.Format.Format.Video.Pixel.Palette = p->Codec.In.Format.Format.Video.Pixel.Palette;
  126. break;
  127. default:
  128. return 0;
  129. }
  131. p->Aspect = p->Context->sample_aspect_ratio;
  132. p->Codec.Out.Format.Format.Video.Aspect = p->Codec.In.Format.Format.Video.Aspect;
  133. if (p->Context->sample_aspect_ratio.num>0 && !p->Codec.Out.Format.Format.Video.Aspect)
  134. p->Codec.Out.Format.Format.Video.Aspect = Scale(ASPECT_ONE,p->Context->sample_aspect_ratio.num,p->Context->sample_aspect_ratio.den);
  136. p->Codec.In.Format.Format.Video.Width = p->Codec.Out.Format.Format.Video.Width = p->Context->width;
  137. p->Codec.In.Format.Format.Video.Height = p->Codec.Out.Format.Format.Video.Height = p->Context->height;
  139. if (p->Picture->linesize[0])
  140. p->Codec.Out.Format.Format.Video.Pitch = p->Picture->linesize[0];
  141. else
  142. DefaultPitch(&p->Codec.Out.Format.Format.Video);
  144. p->PixelFormat = p->Context->pix_fmt;
  146. if (p->Context->bit_rate > 0 && p->Context->bit_rate < 100000000)
  147. p->Codec.In.Format.ByteRate = p->Context->bit_rate/8;
  148. if (p->Context->time_base.num > 0)
  149. {
  150. p->Codec.In.Format.PacketRate.Num = p->Context->time_base.den;
  151. p->Codec.In.Format.PacketRate.Den = p->Context->time_base.num;
  152. p->FrameTime = Scale(TICKSPERSEC,p->Codec.In.Format.PacketRate.Den,p->Codec.In.Format.PacketRate.Num);
  153. }
  154. else
  155. p->FrameTime = TIME_UNKNOWN;
  157. //ShowMessage("","%d %d %d",p->Context->pix_fmt,p->Context->width,p->Context->height);
  158. return 1;
  159. }
  161. static void UpdateSettings(ffmpeg_video* p)
  162. {
  163. p->Context->skip_loop_filter = QueryAdvanced(ADVANCED_NODEBLOCKING)? AVDISCARD_ALL : AVDISCARD_DEFAULT;
  164. }
  166. static int UpdateInput( ffmpeg_video* p )
  167. {
  168. if (p->Context)
  169. avcodec_close(p->Context);
  170.     av_free(p->Context);
  171.     av_free(p->Picture);
  172. p->Context = NULL;
  173. p->Picture = NULL;
  174. BufferClear(&p->Buffer);
  176. if (p->Codec.In.Format.Type == PACKET_VIDEO)
  177. {
  178.     AVCodec *Codec;
  180. const codecinfo *i;
  181. for (i=Info;i->Id;++i)
  182. if (i->Id == p->Codec.Node.Class)
  183. break;
  184. if (!i->Id)
  185. return ERR_INVALID_DATA;
  187. Codec = avcodec_find_decoder(i->CodecId);
  188. if (!Codec)
  189. return ERR_INVALID_DATA;
  191. p->Context = avcodec_alloc_context();
  192. p->Picture = avcodec_alloc_frame();
  194. if (!p->Context || !p->Picture)
  195. return ERR_OUT_OF_MEMORY;
  197.     if ((p->Codec.In.Format.Format.Video.Pixel.Flags & PF_FRAGMENTED) && 
  198. (Codec->capabilities & CODEC_CAP_TRUNCATED))
  199. p->Context->flags|= CODEC_FLAG_TRUNCATED;
  201. UpdateSettings(p);
  202. p->Context->palctrl = NULL;
  203.     p->Context->bit_rate = 0;
  204. p->Context->extradata = p->Codec.In.Format.Extra;
  205. p->Context->extradata_size = p->Codec.In.Format.ExtraLength;
  206. p->Context->width = p->Codec.In.Format.Format.Video.Width;
  207. p->Context->height = p->Codec.In.Format.Format.Video.Height;
  208. p->Context->bits_per_sample = p->Codec.In.Format.Format.Video.Pixel.BitCount;
  209. if (p->Codec.In.Format.Format.Video.Pixel.Palette && 
  210. p->Codec.In.Format.Format.Video.Pixel.BitCount<=8)
  211. {
  212. int i,n = 1 << p->Codec.In.Format.Format.Video.Pixel.BitCount;
  213. for (i=0;i<n;++i)
  214. p->Palette.palette[i] = INT32LE(p->Codec.In.Format.Format.Video.Pixel.Palette[i].v);
  215. p->Palette.palette_changed = 1;
  216. p->Context->palctrl = &p->Palette;
  217. }
  219. p->CodecId = i->CodecId;
  221.     if (avcodec_open(p->Context,Codec)<0)
  222. {
  223. // avoid calling avcodec_close at next UpdateInput
  224.     av_free(p->Context);
  225. p->Context = NULL;
  226. return ERR_INVALID_DATA;
  227. }
  229. if (!BuildOutputFormat(p))
  230. return ERR_INVALID_DATA;
  232. p->SkipToKey = 1;
  233. p->DropToKey = 1;
  234. p->Dropping = 0;
  235. }
  237. return ERR_NONE;
  238. }
  240. static INLINE bool_t SupportDrop( ffmpeg_video* p )
  241. {
  242. return p->CodecId != CODEC_ID_H264 && (!p->Context->has_b_frames || p->CodecId != CODEC_ID_SVQ3);
  243. }
  245. static int Process( ffmpeg_video* p, const packet* Packet, const flowstate* State )
  246. {
  247. int Picture;
  248. int Len;
  250. if (Packet)
  251. {
  252. if (State->DropLevel)
  253. {
  254. if (State->DropLevel>1)
  255. {
  256. p->SkipToKey = 1;
  257. p->DropToKey = 1;
  258. p->Dropping = 1;
  259. p->Context->hurry_up = 5;
  260. }
  261. else
  262. p->Context->hurry_up = 1;
  263. if (!SupportDrop(p))
  264. p->Context->hurry_up = 0;
  265. }
  266. else
  267. p->Context->hurry_up = 0;
  269. if (!Packet->Key && p->DropToKey)
  270. {
  271. if (p->Dropping)
  272. {
  273. flowstate DropState;
  274. DropState.CurrTime = TIME_UNKNOWN;
  275. DropState.DropLevel = 1;
  276. p->Codec.Out.Process(p->Codec.Out.Pin.Node,NULL,&DropState);
  277. }
  278. if (SupportDrop(p))
  279. avcodec_flush_buffers(p->Context);
  280. return ERR_DROPPING;
  281. }
  283. if (p->DropToKey)
  284. p->DropToKey = 0;
  286. if (Packet->RefTime >= 0)
  287. p->Codec.Packet.RefTime = Packet->RefTime;
  289. BufferPack(&p->Buffer,0);
  290. BufferWrite(&p->Buffer,Packet->Data[0],Packet->Length,2048);
  291. }
  292. else
  293. {
  294. if (p->FrameTime<0)
  295. p->Codec.Packet.RefTime = TIME_UNKNOWN;
  296. else
  297. if (!State)
  298. p->Codec.Packet.RefTime += p->FrameTime;
  300. if (!State && p->Buffer.WritePos == p->Buffer.ReadPos)
  301. return ERR_NEED_MORE_DATA;
  302. }
  304. if (p->SkipToKey)
  305. p->Picture->pict_type = 0;
  307. Len = avcodec_decode_video(p->Context, p->Picture, &Picture, p->Buffer.Data + p->Buffer.ReadPos, 
  308. p->Buffer.WritePos - p->Buffer.ReadPos);
  310. if (Len < 0)
  311. {
  312. BufferDrop(&p->Buffer);
  313. return ERR_INVALID_DATA;
  314. }
  316. p->Buffer.ReadPos += Len;
  318. if (!Picture)
  319. {
  320. if (p->SkipToKey>1 && p->Picture->pict_type)
  321. --p->SkipToKey;
  323. return ERR_NEED_MORE_DATA;
  324. }
  326. if (p->SkipToKey>0)
  327. {
  328. if ((!p->Picture->key_frame && p->Picture->pict_type) || p->SkipToKey>1)
  329. {
  330. if (p->SkipToKey>1)
  331. --p->SkipToKey;
  332. if (p->Dropping)
  333. {
  334. flowstate DropState;
  335. DropState.CurrTime = TIME_UNKNOWN;
  336. DropState.DropLevel = 1;
  337. p->Codec.Out.Process(p->Codec.Out.Pin.Node,NULL,&DropState);
  338. }
  339. return ERR_DROPPING;
  340. }
  341. p->SkipToKey = 0;
  342. }
  344. if (p->Context->pix_fmt != p->PixelFormat ||
  345. p->Context->sample_aspect_ratio.num != p->Aspect.num ||
  346. p->Context->sample_aspect_ratio.den != p->Aspect.den ||
  347. p->Context->width != p->Codec.Out.Format.Format.Video.Width ||
  348. p->Context->height != p->Codec.Out.Format.Format.Video.Height ||
  349. p->Picture->linesize[0] != p->Codec.Out.Format.Format.Video.Pitch)
  350. {
  351. if (!BuildOutputFormat(p))
  352. return ERR_INVALID_DATA;
  354. ConnectionUpdate(&p->Codec.Node,CODEC_OUTPUT,p->Codec.Out.Pin.Node,p->Codec.Out.Pin.No);
  355. }
  357. p->Codec.Packet.Data[0] = p->Picture->data[0];
  358. p->Codec.Packet.Data[1] = p->Picture->data[1];
  359. p->Codec.Packet.Data[2] = p->Picture->data[2];
  360. return ERR_NONE;
  361. }
  363. static int ReSend( ffmpeg_video* p )
  364. {
  365. flowstate State;
  367. if (p->SkipToKey || !p->Codec.Out.Pin.Node || !p->Picture->data[0])
  368. return ERR_NEED_MORE_DATA;
  370. State.CurrTime = TIME_RESEND;
  371. State.DropLevel = 0;
  373. p->Codec.Packet.RefTime = TIME_UNKNOWN;
  374. p->Codec.Packet.Data[0] = p->Picture->data[0];
  375. p->Codec.Packet.Data[1] = p->Picture->data[1];
  376. p->Codec.Packet.Data[2] = p->Picture->data[2];
  378. return p->Codec.Out.Process(p->Codec.Out.Pin.Node,&p->Codec.Packet,&State);
  379. }
  381. static int Flush( ffmpeg_video* p )
  382. {
  383. p->SkipToKey = 1;
  384. p->DropToKey = 1;
  385. p->Dropping = 0;
  386. if (p->Context)
  387. {
  388. if (SupportDrop(p))
  389. avcodec_flush_buffers(p->Context);
  390. if (p->Context->has_b_frames && p->Context->frame_number>0)
  391. p->SkipToKey = 2;
  392. }
  393. BufferDrop(&p->Buffer);
  394. return ERR_NONE;
  395. }
  397. static int Set(ffmpeg_video* p, int No, const void* Data, int Size)
  398. {
  399. int Result = CodecSet(&p->Codec,No,Data,Size);
  400. switch (No)
  401. {
  402. case NODE_SETTINGSCHANGED: 
  403. if (p->Context)
  404. UpdateSettings(p);
  405. break;
  406. }
  407. return Result;
  408. }
  410. static int Create( ffmpeg_video* p )
  411. {
  412. p->Codec.Node.Set = (nodeset)Set;
  413. p->Codec.Process = (packetprocess)Process;
  414. p->Codec.UpdateInput = (nodefunc)UpdateInput;
  415. p->Codec.Flush = (nodefunc)Flush;
  416. p->Codec.ReSend = (nodefunc)ReSend;
  417. p->Codec.NoHardDropping = 1;
  418. return ERR_NONE;
  419. }
  421. static const nodedef FFMPEGVideo =
  422. {
  423. sizeof(ffmpeg_video)|CF_ABSTRACT,
  424. FFMPEG_VIDEO_CLASS,
  425. CODEC_CLASS,
  426. PRI_DEFAULT,
  427. (nodecreate)Create,
  428. NULL,
  429. };
  431. void FFMPEG_Init()
  432. {
  433. nodedef Def;
  434. const codecinfo* i;
  436. avcodec_init();
  437. register_avcodec(&mpeg1video_decoder);
  438. register_avcodec(&mpeg2video_decoder);
  439. register_avcodec(&mpegvideo_decoder);
  440. // register_avcodec(&svq1_decoder);
  441. register_avcodec(&svq3_decoder);
  442. register_avcodec(&h263_decoder);
  443. register_avcodec(&mpeg4_decoder);
  444. register_avcodec(&msmpeg4v1_decoder);
  445. register_avcodec(&msmpeg4v2_decoder);
  446. register_avcodec(&msmpeg4v3_decoder);
  447. register_avcodec(&wmv1_decoder);
  448. register_avcodec(&wmv2_decoder);
  449. // register_avcodec(&wmv3_decoder);
  450. register_avcodec(&h264_decoder);
  451. register_avcodec(&cinepak_decoder);
  452. register_avcodec(&msvideo1_decoder);
  453. register_avcodec(&tscc_decoder);
  455. NodeRegisterClass(&FFMPEGVideo);
  456. memset(&Def,0,sizeof(Def));
  458. for (i=Info;i->Id;++i)
  459. {
  460. StringAdd(1,i->Id,NODE_NAME,i->Name);
  461. StringAdd(1,i->Id,NODE_CONTENTTYPE,i->ContentType);
  463. Def.Class = i->Id;
  464. Def.ParentClass = FFMPEG_VIDEO_CLASS;
  465. Def.Priority = PRI_DEFAULT-10; // do not override ARM optimized codecs by default
  466. Def.Flags = 0; // parent size
  468. if ((i->CodecId == CODEC_ID_WMV1 && QueryPlatform(PLATFORM_WMPVERSION)!=10) || //WMP10 RGB only output -> prefer ffmpeg
  469. i->CodecId == CODEC_ID_WMV2 ||
  470. i->CodecId == CODEC_ID_WMV3)
  471. Def.Priority -= 100; // prefer DMO, WMV2 J-frames are not supported by ffmpeg, WMMX support by MS codecs are faster
  473. NodeRegisterClass(&Def);
  474. }
  476. NodeRegisterClass(&WMVF);
  477. }
  479. void FFMPEG_Done()
  480. {
  481. NodeUnRegisterClass(FFMPEG_VIDEO_CLASS);
  482. NodeUnRegisterClass(WMVF_ID);
  483. av_free_static();
  484. }
  486. //only function needed from imgconvert.c
  487. void avcodec_get_chroma_sub_sample(int pix_fmt, int *h_shift, int *v_shift)
  488. {
  489. switch (pix_fmt)
  490. {
  491.     case PIX_FMT_YUV420P:
  492.     case PIX_FMT_YUVJ420P:
  493. *h_shift = 1;
  494. *v_shift = 1;
  495. break;
  496.     case PIX_FMT_YUVJ422P:
  497.     case PIX_FMT_YUV422P:
  498.     case PIX_FMT_YUV422:
  499.     case PIX_FMT_UYVY422:
  500. *h_shift = 1;
  501. *v_shift = 0;
  502. break;
  503.     case PIX_FMT_YUV410P:
  504. *h_shift = 2;
  505. *v_shift = 2;
  506. break;
  507.     case PIX_FMT_YUV411P:
  508.     case PIX_FMT_UYVY411:
  509. *h_shift = 2;
  510. *v_shift = 0;
  511. break;
  512. default:
  513. *h_shift = 0;
  514. *v_shift = 0;
  515. break;
  516. }
  517. }
  519. int avpicture_fill(AVPicture *picture, uint8_t *ptr, int pix_fmt, int width, int height)
  520. {
  521. int h,v;
  522.     int size = width*height;
  523.     int sizeuv;
  525.     switch (pix_fmt) 
  526. {
  527.     case PIX_FMT_YUV410P:
  528.     case PIX_FMT_YUV411P:
  529.     case PIX_FMT_YUV420P:
  530.     case PIX_FMT_YUV422P:
  531.     case PIX_FMT_YUV444P:
  532. avcodec_get_chroma_sub_sample(pix_fmt,&h,&v);
  533.         sizeuv = RSHIFT_ROUND(width,h)*RSHIFT_ROUND(height,v);
  534.         picture->data[0] = ptr;
  535.         picture->data[1] = ptr + size;
  536.         picture->data[2] = ptr + size + sizeuv;
  537.         picture->linesize[0] = width;
  538.         picture->linesize[1] = RSHIFT_ROUND(width,h);
  539.         picture->linesize[2] = RSHIFT_ROUND(width,h);
  540.         return size + 2*sizeuv;
  541. default:
  542. assert(0);
  543. return -1;
  544.     }
  545. }
  547. int avpicture_get_size(int pix_fmt, int width, int height)
  548. {
  549.     AVPicture i;
  550.     return avpicture_fill(&i, NULL, pix_fmt, width, height);
  551. }