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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 多媒体编程 > 查看源码
Ap4Utils.cpp
资源名称：fullMPCcode.rar　[点击查看]
上传用户：xjjlds
上传日期：2015-12-05
资源大小：22823k
文件大小：11k
源码类别：

多媒体编程

开发平台：

Visual C++

Ap4Utils.cpp：源码内容
  1. /*****************************************************************
  2. |
  3. |    AP4 - Utilities
  4. |
  5. |    Copyright 2002 Gilles Boccon-Gibod
  6. |
  7. |
  8. |    This file is part of Bento4/AP4 (MP4 Atom Processing Library).
  9. |
  10. |    Unless you have obtained Bento4 under a difference license,
  11. |    this version of Bento4 is Bento4|GPL.
  12. |    Bento4|GPL is free software; you can redistribute it and/or modify
  13. |    it under the terms of the GNU General Public License as published by
  14. |    the Free Software Foundation; either version 2, or (at your option)
  15. |    any later version.
  16. |
  17. |    Bento4|GPL is distributed in the hope that it will be useful,
  18. |    but WITHOUT ANY WARRANTY; without even the implied warranty of
  19. |    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20. |    GNU General Public License for more details.
  21. |
  22. |    You should have received a copy of the GNU General Public License
  23. |    along with Bento4|GPL; see the file COPYING.  If not, write to the
  24. |    Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  25. |    02111-1307, USA.
  26. |
  27.  ****************************************************************/
  29. /*----------------------------------------------------------------------
  30. |       includes
  31. +---------------------------------------------------------------------*/
  32. #include "Ap4.h"
  33. #include "Ap4Utils.h"
  35. /*----------------------------------------------------------------------
  36. |       AP4_BytesToUInt64BE
  37. +---------------------------------------------------------------------*/
  38. unsigned long long 
  39. AP4_BytesToUInt64BE(const unsigned char* bytes)
  40. {
  41.     return 
  42.         ( ((unsigned long long)bytes[0])<<56 ) |
  43.         ( ((unsigned long long)bytes[1])<<48 ) |
  44.         ( ((unsigned long long)bytes[2])<<40 ) |
  45.         ( ((unsigned long long)bytes[3])<<32 ) |
  46.         ( ((unsigned long long)bytes[4])<<24 ) |
  47.         ( ((unsigned long long)bytes[5])<<16 ) |
  48.         ( ((unsigned long long)bytes[6])<<8  ) |
  49.         ( ((unsigned long long)bytes[7])     );    
  50. }
  52. /*----------------------------------------------------------------------
  53. |       AP4_BytesToUInt32BE
  54. +---------------------------------------------------------------------*/
  55. unsigned long 
  56. AP4_BytesToUInt32BE(const unsigned char* bytes)
  57. {
  58.     return 
  59.         ( ((unsigned long)bytes[0])<<24 ) |
  60.         ( ((unsigned long)bytes[1])<<16 ) |
  61.         ( ((unsigned long)bytes[2])<<8  ) |
  62.         ( ((unsigned long)bytes[3])     );    
  63. }
  65. /*----------------------------------------------------------------------
  66. |       AP4_BytesToUInt24BE
  67. +---------------------------------------------------------------------*/
  68. unsigned long
  69. AP4_BytesToUInt24BE(const unsigned char* bytes)
  70. {
  71.     return 
  72.         ( ((unsigned long)bytes[0])<<16 ) |
  73.         ( ((unsigned long)bytes[1])<<8  ) |
  74.         ( ((unsigned long)bytes[2])     );    
  75. }
  77. /*----------------------------------------------------------------------
  78. |       AP4_BytesToUInt16BE
  79. +---------------------------------------------------------------------*/
  80. unsigned short
  81. AP4_BytesToUInt16BE(const unsigned char* bytes)
  82. {
  83.     return 
  84.         ( ((unsigned short)bytes[0])<<8  ) |
  85.         ( ((unsigned short)bytes[1])     );    
  86. }
  88. /*----------------------------------------------------------------------
  89. |       AP4_BytesFromUInt64BE
  90. +---------------------------------------------------------------------*/
  91. void
  92. AP4_BytesFromUInt64BE(unsigned char* bytes, unsigned long long value)
  93. {
  94.     bytes[0] = (unsigned char)(value >> 56);
  95.     bytes[1] = (unsigned char)(value >> 48);
  96.     bytes[2] = (unsigned char)(value >> 40);
  97.     bytes[3] = (unsigned char)(value >> 32);
  98.     bytes[4] = (unsigned char)(value >> 24);
  99.     bytes[5] = (unsigned char)(value >> 16);
  100.     bytes[6] = (unsigned char)(value >>  8);
  101.     bytes[7] = (unsigned char)(value      );
  102. }
  104. /*----------------------------------------------------------------------
  105. |       AP4_BytesFromUInt32BE
  106. +---------------------------------------------------------------------*/
  107. void
  108. AP4_BytesFromUInt32BE(unsigned char* bytes, unsigned long value)
  109. {
  110.     bytes[0] = (unsigned char)(value >> 24);
  111.     bytes[1] = (unsigned char)(value >> 16);
  112.     bytes[2] = (unsigned char)(value >>  8);
  113.     bytes[3] = (unsigned char)(value      );
  114. }
  116. /*----------------------------------------------------------------------
  117. |       AP4_BytesFromUInt24BE
  118. +---------------------------------------------------------------------*/
  119. void
  120. AP4_BytesFromUInt24BE(unsigned char* bytes, unsigned long value)
  121. {
  122.     bytes[0] = (unsigned char)(value >> 16);
  123.     bytes[1] = (unsigned char)(value >>  8);
  124.     bytes[2] = (unsigned char)(value      );
  125. }
  127. /*----------------------------------------------------------------------
  128. |       AP4_BytesFromUInt16BE
  129. +---------------------------------------------------------------------*/
  130. void
  131. AP4_BytesFromUInt16BE(unsigned char* bytes, unsigned short value)
  132. {
  133.     bytes[0] = (unsigned char)(value >> 8);
  134.     bytes[1] = (unsigned char)(value     );
  135. }
  137. /*----------------------------------------------------------------------
  138. |       AP4_MakePrefixString
  139. +---------------------------------------------------------------------*/
  140. static void
  141. AP4_MakePrefixString(AP4_Offset indent, char* prefix, AP4_Size size)
  142. {
  143.     if (size == 0) return;
  144.     if (indent >= size-1) indent = size-1;
  145.     for (unsigned int i=0; i<indent; i++) {
  146.         prefix[i] = ' ';
  147.     }
  148.     prefix[indent] = '';    
  149. }
  151. /*----------------------------------------------------------------------
  152. |       AP4_DurationMsFromUnits
  153. +---------------------------------------------------------------------*/
  154. unsigned long
  155. AP4_DurationMsFromUnits(unsigned long units, unsigned long units_per_second)
  156. {
  157. if (units_per_second == 0) return 0;
  158. return (unsigned long)(((float)units*1000.0f)/(float)units_per_second);
  159. }
  161. /*----------------------------------------------------------------------
  162. |       AP4_ConvertTime
  163. +---------------------------------------------------------------------*/
  164. unsigned long 
  165. AP4_ConvertTime(unsigned long time_value,
  166.                 unsigned long from_time_scale,
  167.                 unsigned long to_time_scale)
  168. {
  169.     if (from_time_scale == 0) return 0;
  170.     float ratio = (float)to_time_scale/(float)from_time_scale;
  171.     return ((unsigned long)((float)time_value*ratio));
  172. }
  174. /*----------------------------------------------------------------------
  175. |       AP4_FormatFourChars
  176. +---------------------------------------------------------------------*/
  177. void
  178. AP4_FormatFourChars(char* str, AP4_UI32 value) {
  179.     str[0] = (value >> 24) & 0xFF;
  180.     str[1] = (value >> 16) & 0xFF;
  181.     str[2] = (value >>  8) & 0xFF;
  182.     str[3] = (value      ) & 0xFF;
  183.     str[4] = '';
  184. }
  186. /*----------------------------------------------------------------------
  187. |       AP4_SplitArgs
  188. +---------------------------------------------------------------------*/
  189. AP4_Result
  190. AP4_SplitArgs(char* arg, char*& arg0, char*& arg1)
  191. {
  192.     arg0 = arg;
  193.     char* c = arg;
  194.     while (*c != 0 && *c != ':') {
  195.         c++;
  196.     }
  197.     if (*c == ':') {
  198.         *c++ = '';
  199.         arg1 = c;
  200.         return AP4_SUCCESS;
  201.     } else {
  202.         return AP4_FAILURE;
  203.     }
  204. }
  206. /*----------------------------------------------------------------------
  207. |       AP4_SplitArgs
  208. +---------------------------------------------------------------------*/
  209. AP4_Result
  210. AP4_SplitArgs(char* arg, char*& arg0, char*& arg1, char*& arg2)
  211. {
  212.     AP4_Result result = AP4_SplitArgs(arg, arg0, arg1);
  213.     if (AP4_FAILED(result)) return result;
  214.     return AP4_SplitArgs(arg1, arg1, arg2);
  215. }
  217. /*----------------------------------------------------------------------
  218. |       AP4_HexNibble
  219. +---------------------------------------------------------------------*/
  220. static unsigned char
  221. AP4_HexNibble(char c)
  222. {
  223.     switch (c) {
  224.         case '0': return 0;
  225.         case '1': return 1;
  226.         case '2': return 2;
  227.         case '3': return 3;
  228.         case '4': return 4;
  229.         case '5': return 5;
  230.         case '6': return 6;
  231.         case '7': return 7;
  232.         case '8': return 8;
  233.         case '9': return 9;
  234.         case 'a': case 'A': return 10;
  235.         case 'b': case 'B': return 11;
  236.         case 'c': case 'C': return 12;
  237.         case 'd': case 'D': return 13;
  238.         case 'e': case 'E': return 14;
  239.         case 'f': case 'F': return 15;
  240.         default: return 0;
  241.     }
  242. }
  244. /*----------------------------------------------------------------------
  245. |       AP4_ParseHex
  246. +---------------------------------------------------------------------*/
  247. AP4_Result
  248. AP4_ParseHex(const char* hex, unsigned char* bytes, unsigned int count)
  249. {
  250.     if (strlen(hex) != 2*count) return AP4_ERROR_INVALID_PARAMETERS;
  251.     for (unsigned int i=0; i<count; i++) {
  252.         bytes[i] = (AP4_HexNibble(hex[2*i]) << 4) | (AP4_HexNibble(hex[2*i+1]));
  253.     }
  254.     return AP4_SUCCESS;
  255. }
  257. /*----------------------------------------------------------------------
  258. |       AP4_PrintInspector::AP4_PrintInspector
  259. +---------------------------------------------------------------------*/
  260. AP4_PrintInspector::AP4_PrintInspector(AP4_ByteStream& stream) :
  261.     m_Stream(&stream),
  262.     m_Indent(0)
  263. {
  264.     m_Stream->AddReference();
  265. }
  267. /*----------------------------------------------------------------------
  268. |       AP4_PrintInspector::~AP4_PrintInspector
  269. +---------------------------------------------------------------------*/
  270. AP4_PrintInspector::~AP4_PrintInspector()
  271. {
  272.     m_Stream->Release();
  273. }
  275. /*----------------------------------------------------------------------
  276. |       AP4_PrintInspector::StartElement
  277. +---------------------------------------------------------------------*/
  278. void
  279. AP4_PrintInspector::StartElement(const char* name, const char* info)
  280. {
  281.     char prefix[256];
  282.     AP4_MakePrefixString(m_Indent, prefix, sizeof(prefix));
  283.     m_Stream->WriteString(prefix);
  284.     m_Stream->WriteString(name);
  285.     if (info) {
  286.         m_Stream->Write(" ", 1);
  287.         m_Stream->WriteString(info);
  288.     }
  289.     m_Stream->Write("n", 1);
  291.     m_Indent += 2;
  292. }
  294. /*----------------------------------------------------------------------
  295. |       AP4_PrintInspector::EndElement
  296. +---------------------------------------------------------------------*/
  297. void
  298. AP4_PrintInspector::EndElement()
  299. {
  300.     m_Indent -= 2;
  301. }
  303. /*----------------------------------------------------------------------
  304. |       AP4_PrintInspector::AddField
  305. +---------------------------------------------------------------------*/
  306. void
  307. AP4_PrintInspector::AddField(const char* name, const char* value, FormatHint hint)
  308. {
  309.     char prefix[256];
  310.     AP4_MakePrefixString(m_Indent, prefix, sizeof(prefix));
  311.     m_Stream->WriteString(prefix);
  312.     
  313.     m_Stream->WriteString(name);
  314.     m_Stream->WriteString(" = ");
  315.     m_Stream->WriteString(value);
  316.     m_Stream->Write("n", 1);
  317. }
  319. /*----------------------------------------------------------------------
  320. |       AP4_PrintInspector::AddField
  321. +---------------------------------------------------------------------*/
  322. void
  323. AP4_PrintInspector::AddField(const char* name, AP4_UI32 value, FormatHint hint)
  324. {
  325.     char prefix[256];
  326.     AP4_MakePrefixString(m_Indent, prefix, sizeof(prefix));
  327.     m_Stream->WriteString(prefix);
  329.     char str[32];
  330.     AP4_StringFormat(str, sizeof(str), "%d", value);
  331.     m_Stream->WriteString(name);
  332.     m_Stream->WriteString(" = ");
  333.     m_Stream->WriteString(str);
  334.     m_Stream->Write("n", 1);
  335. }