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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 流媒体/Mpeg4/MP4 > 查看源码
file_utils.cpp
资源名称：NETVIDEO.rar　[点击查看]
上传用户：sun1608
上传日期：2007-02-02
资源大小：6116k
文件大小：11k
源码类别：

流媒体/Mpeg4/MP4

开发平台：

Visual C++

file_utils.cpp：源码内容
  1. /*
  2.  * The contents of this file are subject to the Mozilla Public
  3.  * License Version 1.1 (the "License"); you may not use this file
  4.  * except in compliance with the License. You may obtain a copy of
  5.  * the License at http://www.mozilla.org/MPL/
  6.  * 
  7.  * Software distributed under the License is distributed on an "AS
  8.  * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
  9.  * implied. See the License for the specific language governing
  10.  * rights and limitations under the License.
  11.  * 
  12.  * The Original Code is MPEG4IP.
  13.  * 
  14.  * The Initial Developer of the Original Code is Cisco Systems Inc.
  15.  * Portions created by Cisco Systems Inc. are
  16.  * Copyright (C) Cisco Systems Inc. 2000-2002.  All Rights Reserved.
  17.  * 
  18.  * Contributor(s): 
  19.  *  Bill May        wmay@cisco.com
  20.  *  Dave Mackie  dmackie@cisco.com
  21.  */
  23. #include "mp4live.h"
  24. #include "mp4live_gui.h"
  26. #include <mp4.h>
  27. #include <libmpeg3.h>
  29. GtkWidget* CreateFileCombo(char* entryText)
  30. {
  31. GList* list = NULL;
  33. list = g_list_append(list, entryText);
  35. for (int i = 0; i < NUM_FILE_HISTORY; i++) {
  36. char* fileName =
  37. MyConfig->GetStringValue(CONFIG_APP_FILE_0 + i);
  38. if (fileName == NULL || fileName[0] == ''
  39.   || !strcmp(fileName, entryText)) {
  40. continue;
  41. }
  42. list = g_list_append(list, fileName);
  43. }
  45. GtkWidget* combo = gtk_combo_new();
  46. gtk_combo_set_popdown_strings(GTK_COMBO(combo), list);
  47. gtk_combo_set_use_arrows_always(GTK_COMBO(combo), 1);
  49. GtkWidget* entry = GTK_COMBO(combo)->entry;
  50. gtk_entry_set_text(GTK_ENTRY(entry), entryText);
  51. return combo;
  52. }
  54. static GtkWidget* FileSelection;
  55. static GtkWidget* FileEntry;
  56. static GtkSignalFunc FileOkFunc;
  58. static void on_filename_selected(
  59. GtkFileSelection *widget, 
  60. gpointer data)
  61. {
  62. const gchar *name =
  63. gtk_file_selection_get_filename(GTK_FILE_SELECTION(FileSelection));
  65. gtk_entry_set_text(GTK_ENTRY(FileEntry), name);
  66. gtk_widget_show(FileEntry);
  68. gtk_grab_remove(FileSelection);
  69. gtk_widget_destroy(FileSelection);
  71. if (FileOkFunc) {
  72. (*FileOkFunc)();
  73. }
  74. }
  76. void FileBrowser(
  77. GtkWidget* fileEntry, 
  78. GtkSignalFunc okFunc)
  79. {
  80. FileEntry = fileEntry;
  81. FileOkFunc = okFunc;
  83. FileSelection = gtk_file_selection_new("Select File");
  84. gtk_file_selection_hide_fileop_buttons(
  85. GTK_FILE_SELECTION(FileSelection));
  87. gtk_signal_connect(
  88. GTK_OBJECT(GTK_FILE_SELECTION(FileSelection)->ok_button),
  89. "clicked",
  90. GTK_SIGNAL_FUNC(on_filename_selected),
  91. FileSelection);
  93. gtk_signal_connect_object(
  94. GTK_OBJECT(GTK_FILE_SELECTION(FileSelection)->cancel_button),
  95. "clicked",
  96. GTK_SIGNAL_FUNC(gtk_widget_destroy),
  97. GTK_OBJECT(FileSelection));
  99. gtk_widget_show(FileSelection);
  100. gtk_grab_add(FileSelection);
  101. }
  103. bool IsDevice(const char* fileName)
  104. {
  105. // LATER might also want to stat()
  106. return !strncmp(fileName, "/dev/", 5);
  107. }
  109. bool IsUrl(const char* name)
  110. {
  111. return (strchr(name, ':') != NULL);
  112. }
  114. bool IsMp4File(const char* fileName)
  115. {
  116. if (IsUrl(fileName)) {
  117. return false;
  118. }
  119. if (strlen(fileName) <= 4) {
  120. return false;
  121. } 
  122. return !strcmp(&fileName[strlen(fileName) - 4], ".mp4");
  123. }
  125. bool IsMpeg2File(const char* fileName)
  126. {
  127. if (IsUrl(fileName)) {
  128. return false;
  129. }
  130. if (strlen(fileName) <= 4) {
  131. return false;
  132. } 
  134. const char* ext3 = &fileName[strlen(fileName) - 4];
  136. return !strcmp(ext3, ".mpg")
  137. || !strcmp(ext3, ".vob");
  138. }
  140. int32_t Mp4FileDefaultAudio(char* fileName)
  141. {
  142. MP4FileHandle mp4File = MP4Read(fileName);
  144. if (mp4File == MP4_INVALID_FILE_HANDLE) {
  145. return -1;
  146. }
  148. MP4TrackId trackId = 
  149. MP4FindTrackId(mp4File, 0, MP4_AUDIO_TRACK_TYPE);
  151. MP4Close(mp4File);
  153. if (trackId == MP4_INVALID_TRACK_ID) {
  154. return -1;
  155. }
  156. return trackId;
  157. }
  159. int32_t Mpeg2FileDefaultAudio(char* fileName)
  160. {
  161. mpeg3_t* mpeg2File = mpeg3_open(fileName);
  163. if (!mpeg2File) {
  164. return -1;
  165. }
  167. int32_t audioTracks = mpeg3_total_astreams(mpeg2File);
  169. mpeg3_close(mpeg2File);
  171. if (audioTracks <= 0) {
  172. return -1;
  173. }
  174. return 0; 
  175. }
  177. int32_t FileDefaultAudio(char* fileName)
  178. {
  179. if (IsMp4File(fileName)) {
  180. return Mp4FileDefaultAudio(fileName);
  181. } else if (IsMpeg2File(fileName)) {
  182. return Mpeg2FileDefaultAudio(fileName);
  183. } else {
  184. return 0;
  185. }
  186. }
  188. static char** trackNames;
  189. static u_int32_t* pTrackIndex;
  191. static void on_track_menu_activate(GtkWidget *widget, gpointer data)
  192. {
  193. *pTrackIndex = ((unsigned int)data) & 0xFF;
  194. }
  196. static GtkWidget* CreateNullTrackMenu(
  197. GtkWidget* menu,
  198. char type,
  199. char* source,
  200. u_int32_t* pIndex,
  201. u_int32_t* pNumber,
  202. u_int32_t** ppValues)
  203. {
  204. u_int32_t* newTrackValues = 
  205. (u_int32_t*)malloc(sizeof(u_int32_t));
  206. newTrackValues[0] = 0;
  208. char** newTrackNames = 
  209. (char**)malloc(sizeof(char*));
  210. newTrackNames[0] = stralloc("");
  212. // (re)create the menu
  213. menu = CreateOptionMenu(
  214. menu,
  215. newTrackNames, 
  216. 1,
  217. 0,
  218. GTK_SIGNAL_FUNC(on_track_menu_activate));
  220. // free up old names
  221. for (u_int8_t i = 0; i < *pNumber; i++) {
  222. free(trackNames[i]);
  223. }
  224. free(*ppValues);
  225. free(trackNames);
  227. *pIndex = 0;
  228. *pNumber = 1;
  229. *ppValues = newTrackValues;
  230. trackNames = newTrackNames;
  232. return menu;
  233. }
  235. static GtkWidget* CreateMp4TrackMenu(
  236. GtkWidget* menu,
  237. char type,
  238. char* source,
  239. u_int32_t* pIndex,
  240. u_int32_t* pNumber,
  241. u_int32_t** ppValues)
  242. {
  243. *pIndex = 0;
  245. u_int32_t newTrackNumber = 1;
  247. MP4FileHandle mp4File = MP4Read(source);
  249. char* trackType = NULL;
  251. if (mp4File) {
  252. if (type == 'V') {
  253. trackType = MP4_VIDEO_TRACK_TYPE;
  254. } else {
  255. trackType = MP4_AUDIO_TRACK_TYPE;
  256. }
  257. newTrackNumber = 
  258. MP4GetNumberOfTracks(mp4File, trackType);
  259. }
  261. u_int32_t* newTrackValues = 
  262. (u_int32_t*)malloc(sizeof(u_int32_t) * newTrackNumber);
  264. char** newTrackNames = 
  265. (char**)malloc(sizeof(char*) * newTrackNumber);
  267. if (!mp4File) {
  268. newTrackValues[0] = 0;
  269. newTrackNames[0] = stralloc("");
  270. } else {
  271. for (u_int8_t i = 0; i < newTrackNumber; i++) {
  272. MP4TrackId trackId =
  273. MP4FindTrackId(mp4File, i, trackType);
  275. char* trackName = "Unknown";
  276. char buf[64];
  278. if (trackType == MP4_VIDEO_TRACK_TYPE) {
  279. u_int8_t videoType =
  280. MP4GetTrackVideoType(mp4File, trackId);
  282. switch (videoType) {
  283. case MP4_MPEG1_VIDEO_TYPE:
  284. trackName = "MPEG1";
  285. break;
  286. case MP4_MPEG2_SIMPLE_VIDEO_TYPE:
  287. case MP4_MPEG2_MAIN_VIDEO_TYPE:
  288. case MP4_MPEG2_SNR_VIDEO_TYPE:
  289. case MP4_MPEG2_SPATIAL_VIDEO_TYPE:
  290. case MP4_MPEG2_HIGH_VIDEO_TYPE:
  291. case MP4_MPEG2_442_VIDEO_TYPE:
  292. trackName = "MPEG2";
  293. break;
  294. case MP4_MPEG4_VIDEO_TYPE:
  295. trackName = "MPEG4";
  296. break;
  297. case MP4_YUV12_VIDEO_TYPE:
  298. trackName = "YUV12";
  299. break;
  300. case MP4_H26L_VIDEO_TYPE:
  301. trackName = "H26L";
  302. break;
  303. }
  305. snprintf(buf, sizeof(buf), 
  306. "%u - %s %u x %u %.2f fps %u kbps", 
  307. trackId, 
  308. trackName,
  309. MP4GetTrackVideoWidth(mp4File, trackId),
  310. MP4GetTrackVideoHeight(mp4File, trackId),
  311. MP4GetTrackVideoFrameRate(mp4File, trackId),
  312. (MP4GetTrackBitRate(mp4File, trackId) + 500) / 1000);
  314. } else { // audio
  315. u_int8_t audioType =
  316. MP4GetTrackAudioType(mp4File, trackId);
  318. switch (audioType) {
  319. case MP4_MPEG1_AUDIO_TYPE:
  320. case MP4_MPEG2_AUDIO_TYPE:
  321. trackName = "MPEG (MP3)";
  322. break;
  323. case MP4_MPEG2_AAC_MAIN_AUDIO_TYPE:
  324. case MP4_MPEG2_AAC_LC_AUDIO_TYPE:
  325. case MP4_MPEG2_AAC_SSR_AUDIO_TYPE:
  326. case MP4_MPEG4_AUDIO_TYPE:
  327. trackName = "AAC";
  328. break;
  329. case MP4_PCM16_AUDIO_TYPE:
  330. trackName = "PCM16";
  331. break;
  332. case MP4_AC3_AUDIO_TYPE:
  333. trackName = "AC3";
  334. break;
  335. case MP4_VORBIS_AUDIO_TYPE:
  336. trackName = "Ogg Vorbis";
  337. break;
  338. }
  340. snprintf(buf, sizeof(buf), 
  341. "%u - %s %u kbps", 
  342. trackId, 
  343. trackName,
  344. (MP4GetTrackBitRate(mp4File, trackId) + 500) / 1000);
  345. }
  347. newTrackValues[i] = trackId;
  348. newTrackNames[i] = stralloc(buf);
  349. }
  351. MP4Close(mp4File);
  352. }
  354. // (re)create the menu
  355. menu = CreateOptionMenu(
  356. menu,
  357. newTrackNames, 
  358. newTrackNumber,
  359. *pIndex,
  360. GTK_SIGNAL_FUNC(on_track_menu_activate));
  362. // free up old names
  363. for (u_int8_t i = 0; i < *pNumber; i++) {
  364. free(trackNames[i]);
  365. }
  366. free(trackNames);
  367. free(*ppValues);
  369. *pNumber = newTrackNumber;
  370. trackNames = newTrackNames;
  371. *ppValues = newTrackValues;
  373. return menu;
  374. }
  376. static GtkWidget* CreateMpeg2TrackMenu(
  377. GtkWidget* menu,
  378. char type,
  379. char* source,
  380. u_int32_t* pIndex,
  381. u_int32_t* pNumber,
  382. u_int32_t** ppValues)
  383. {
  384. *pIndex = 0;
  386. u_int32_t newTrackNumber = 1;
  388. mpeg3_t* mpeg2File = mpeg3_open(source);
  390. if (mpeg2File) {
  391. if (type == 'V') {
  392. newTrackNumber = mpeg3_total_vstreams(mpeg2File);
  393. } else {
  394. newTrackNumber = mpeg3_total_astreams(mpeg2File);
  395. }
  396. }
  398. u_int32_t* newTrackValues = 
  399. (u_int32_t*)malloc(sizeof(u_int32_t) * newTrackNumber);
  401. char** newTrackNames = 
  402. (char**)malloc(sizeof(char*) * newTrackNumber);
  404. if (!mpeg2File) {
  405. newTrackValues[0] = 0;
  406. newTrackNames[0] = stralloc("");
  407. } else {
  408. for (u_int8_t i = 0; i < newTrackNumber; i++) {
  409. newTrackValues[i] = i;
  411. char buf[64];
  412. if (type == 'V') {
  413. snprintf(buf, sizeof(buf), 
  414. "%u - %u x %u @ %.2f fps", 
  415. i + 1,
  416. mpeg3_video_width(mpeg2File, i),
  417. mpeg3_video_height(mpeg2File, i),
  418. mpeg3_frame_rate(mpeg2File, i));
  419. } else {
  420. char* afmt =
  421. mpeg3_audio_format(mpeg2File, i);
  423. // use more familar though less accurate name
  424. if (!strcasecmp(afmt, "MPEG")) {
  425. afmt = "MP3";
  426. }
  428. snprintf(buf, sizeof(buf), 
  429. "%u - %s  %u channels @ %u Hz", 
  430. i + 1,
  431. afmt,
  432. mpeg3_audio_channels(mpeg2File, i),
  433. mpeg3_sample_rate(mpeg2File, i));
  434. }
  435. newTrackNames[i] = stralloc(buf);
  436. }
  437. mpeg3_close(mpeg2File);
  438. }
  440. // (re)create the menu
  441. menu = CreateOptionMenu(
  442. menu,
  443. newTrackNames, 
  444. newTrackNumber,
  445. *pIndex,
  446. GTK_SIGNAL_FUNC(on_track_menu_activate));
  448. // free up old names
  449. for (u_int8_t i = 0; i < *pNumber; i++) {
  450. free(trackNames[i]);
  451. }
  452. free(trackNames);
  453. free(*ppValues);
  455. *pNumber = newTrackNumber;
  456. trackNames = newTrackNames;
  457. *ppValues = newTrackValues;
  458. return menu;
  459. }
  461. GtkWidget* CreateTrackMenu(
  462. GtkWidget* menu,
  463. char type, 
  464. char* source,
  465. u_int32_t* pMenuIndex,
  466. u_int32_t* pMenuNumber,
  467. u_int32_t** ppMenuValues)
  468. {
  469. pTrackIndex = pMenuIndex;
  471. if (IsMp4File(source)) {
  472. return CreateMp4TrackMenu(
  473. menu, type, source, pMenuIndex, pMenuNumber, ppMenuValues);
  475. } else if (IsMpeg2File(source)) {
  476. return CreateMpeg2TrackMenu(
  477. menu, type, source, pMenuIndex, pMenuNumber, ppMenuValues);
  479. } else {
  480. return CreateNullTrackMenu(
  481. menu, type, source, pMenuIndex, pMenuNumber, ppMenuValues);
  482. }
  483. }