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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 流媒体/Mpeg4/MP4 > 查看源码
common.c
资源名称：rtsp-1.0.1.tar.gz　[点击查看]
上传用户：sy_wanhua
上传日期：2013-07-25
资源大小：3048k
文件大小：10k
源码类别：

流媒体/Mpeg4/MP4

开发平台：

C/C++

common.c：源码内容
  1. /*
  2. ** Copyright (C) 1999-2000 Erik de Castro Lopo <erikd@zip.com.au>
  3. **  
  4. ** This program is free software; you can redistribute it and/or modify
  5. ** it under the terms of the GNU Lesser General Public License as published by
  6. ** the Free Software Foundation; either version 2.1 of the License, or
  7. ** (at your option) any later version.
  8. ** 
  9. ** This program is distributed in the hope that it will be useful,
  10. ** but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12. ** GNU Lesser General Public License for more details.
  13. ** 
  14. ** You should have received a copy of the GNU Lesser General Public License
  15. ** along with this program; if not, write to the Free Software 
  16. ** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  17. */
  19. #include <stdarg.h>
  20. #include <string.h>
  22. #include "sndfile.h"
  23. #include "sfendian.h"
  24. #include "common.h"
  26. /*-----------------------------------------------------------------------------------------------
  27.  */
  29. void endswap_short_array (short *ptr, int len)
  30. { int k ;
  31. for (k = 0 ; k < len ; k++)
  32. ptr[k] = ((((ptr[k])>>8)&0xFF)|(((ptr[k])&0xFF)<<8)) ;
  33. } /* endswap_short_array */
  35. void endswap_int_array (int *ptr, int len)
  36. { int k ;
  37. for (k = 0 ; k < len ; k++)
  38. ptr[k] = ((((ptr[k])>>24)&0xFF)|(((ptr[k])>>8)&0xFF00)|
  39. (((ptr[k])&0xFF00)<<8)|(((ptr[k])&0xFF)<<24)) ;
  40. } /* endswap_int_array */
  42. /*-----------------------------------------------------------------------------------------------
  43.  */
  45. #define psf_putchar(a,b)
  46. if ((a)->strindex < SF_BUFFER_LEN - 1)
  47. { (a)->strbuffer [(a)->strindex++] = (b) ;
  48. (a)->strbuffer [(a)->strindex] = 0 ;
  49. } ;
  51. void psf_sprintf (SF_PRIVATE *psf, char *format, ...)
  52. { va_list ap ;
  53. int     d, tens, shift ;
  54. char    c, *strptr, istr [5] ;
  56. va_start(ap, format);
  58. /* printf ("psf_sprintf : %sn", format) ; */
  60. while ((c = *format++))
  61. { if (c != '%')
  62. { psf_putchar (psf, c) ;
  63. continue ;
  64. } ;
  66. switch((c = *format++)) 
  67. { case 's': /* string */
  68. strptr = va_arg (ap, char *) ;
  69. while (*strptr)
  70. psf_putchar (psf, *strptr++) ;
  71. break;
  72.     
  73. case 'd': /* int */
  74. d = va_arg (ap, int) ;
  76. if (d == 0)
  77. { psf_putchar (psf, '0') ;
  78. break ;
  79. } 
  80. if (d < 0)
  81. { psf_putchar (psf, '-') ;
  82. d = -d ;
  83. } ;
  84. tens = 1 ;
  85. while (d / tens >= 10) 
  86. tens *= 10 ;
  87. while (tens > 0)
  88. { psf_putchar (psf, '0' + d / tens) ;
  89. d %= tens ;
  90. tens /= 10 ;
  91. } ;
  92. break;
  94. case 'X': /* hex */
  95. d = va_arg (ap, int) ;
  97. if (d == 0)
  98. { psf_putchar (psf, '0') ;
  99. break ;
  100. } ;
  101. shift = 28 ;
  102. while (! ((0xF << shift) & d))
  103. shift -= 4 ;
  104. while (shift >= 0)
  105. { c = (d >> shift) & 0xF ;
  106. psf_putchar (psf, (c > 9) ? c + 'A' - 10 : c + '0') ;
  107. shift -= 4 ;
  108. } ;
  109. break;
  111. case 'c': /* char */
  112. c = va_arg (ap, int) & 0xFF ;
  113. psf_putchar (psf, c);
  114. break;
  116. case 'D': /* int2str */
  117. d = va_arg (ap, int);
  118. if (CPU_IS_LITTLE_ENDIAN)
  119. { istr [0] = d & 0xFF ;
  120. istr [1] = (d >> 8) & 0xFF ;
  121. istr [2] = (d >> 16) & 0xFF ;
  122. istr [3] = (d >> 24) & 0xFF ;
  123. }
  124. else
  125. { istr [3] = d & 0xFF ;
  126. istr [2] = (d >> 8) & 0xFF ;
  127. istr [1] = (d >> 16) & 0xFF ;
  128. istr [0] = (d >> 24) & 0xFF ;
  129. } ;
  130. istr [4] = 0 ;
  131. strptr = istr ;
  132. while (*strptr)
  133. { c = *strptr++ ;
  134. psf_putchar (psf, c) ;
  135. } ;
  136. break;
  138. default :
  139. psf_putchar (psf, '?') ;
  140. psf_putchar (psf, c) ;
  141. psf_putchar (psf, '?') ;
  142. break ;
  143. } /* switch */
  144. } /* while */
  146. va_end(ap);
  147. return ;
  148. } /* psf_sprintf */
  150. /*------------------------------------------------------------------------------
  151. **  Format specifiers for psf_hprintf are as follows
  152. ** m - marker - four bytes - no endian problems
  153. ** w - two byte value - little endian
  154. ** W - two byte value - big endian
  155. ** l - four byte value - little endian
  156. ** L - four byte value - big endian
  157. ** s   - string preceded by a little endian four byte length
  158. ** S   - string preceded by a big endian four byte length
  159. ** b - binary data (see below)
  160. **
  161. ** To write a word followed by a long (both little endian) use:
  162. ** psf_hprintf ("wl", wordval, longval) ;
  163. **
  164. ** To write binary data use:
  165. ** psf_hprintf ("b", &bindata, sizeof (bindata)) ;
  166. */
  168. /* These macros may seem a bit messy but do prevent problems with processors which 
  169. ** seg. fault when asked to write an int or short to a non-int/short aligned address.
  170. */
  172. #if (CPU_IS_BIG_ENDIAN == 1)
  173. #define put_int(psf,x) { (psf)->header [(psf)->headindex++] = ((x) >> 24) & 0xFF ;
  174. (psf)->header [(psf)->headindex++] = ((x) >> 16) & 0xFF ;
  175. (psf)->header [(psf)->headindex++] = ((x) >>  8) & 0xFF ;
  176. (psf)->header [(psf)->headindex++] = (x) & 0xFF ;   }
  177.                                                                         
  178. #define put_short(psf,x) { (psf)->header [(psf)->headindex++] = ((x) >> 8) & 0xFF ;
  179. (psf)->header [(psf)->headindex++] = (x) & 0xFF ;   }
  180. #elif (CPU_IS_LITTLE_ENDIAN == 1)
  181. #define put_int(psf,x) { (psf)->header [(psf)->headindex++] = (x) & 0xFF ;
  182. (psf)->header [(psf)->headindex++] = ((x) >>  8) & 0xFF ;
  183. (psf)->header [(psf)->headindex++] = ((x) >> 16) & 0xFF ;
  184. (psf)->header [(psf)->headindex++] = ((x) >> 24) & 0xFF ;   }
  185.                                                                         
  186. #define put_short(psf,x) { (psf)->header [(psf)->headindex++] = (x) & 0xFF ;
  187. (psf)->header [(psf)->headindex++] = ((x) >> 8) & 0xFF ;   }
  189. #else
  190. #       error "Cannot determine endian-ness of processor."
  191. #endif
  193. void psf_hprintf (SF_PRIVATE *psf, char *format, ...)
  194. { va_list argptr ;
  195. unsigned int  longdata ;
  196. unsigned short worddata ;
  197. void *bindata ;
  198. size_t size ;
  199. char    c, *strptr ;
  201. va_start(argptr, format);
  203. while ((c = *format++))
  204. { switch (c)
  205. { case 'm' : 
  206. longdata = va_arg (argptr, unsigned int) ;
  207. put_int (psf, longdata) ;
  208. break ;
  210. case 'l' :
  211. longdata = va_arg (argptr, unsigned int) ;
  212. longdata = H2LE_INT (longdata) ;
  213. put_int (psf, longdata) ;
  214. break ;
  216. case 'L' :
  217. longdata = va_arg (argptr, unsigned int) ;
  218. longdata = H2BE_INT (longdata) ;
  219. put_int (psf, longdata) ;
  220. break ;
  222. case 'w' :
  223. worddata = va_arg (argptr, int) & 0xFFFF ;
  224. worddata = H2LE_SHORT (worddata) ;
  225. put_short (psf, worddata) ;
  226. break ;
  228. case 'W' :
  229. worddata = va_arg (argptr, int) & 0xFFFF ;
  230. worddata = H2BE_SHORT (worddata) ;
  231. put_short (psf, worddata) ;
  232. break ;
  234. case 'b' :
  235. bindata = va_arg (argptr, void *) ;
  236. size    = va_arg (argptr, size_t) ;
  237. memcpy (&(psf->header [psf->headindex]), bindata, size) ;
  238. psf->headindex += size ;
  239. break ;
  241. case 's' :
  242. strptr = va_arg (argptr, char *) ;
  243. size    = strlen (strptr) + 1 ;
  244. size   += (size & 1) ;
  245. longdata = H2LE_INT (size) ;
  246. put_int (psf, longdata) ;
  247. memcpy (&(psf->header [psf->headindex]), strptr, size) ;
  248. psf->headindex += size ;
  249. break ;
  251. case 'S' :
  252. strptr = va_arg (argptr, char *) ;
  253. size    = strlen (strptr) + 1 ;
  254. size   += (size & 1) ;
  255. longdata = H2BE_INT (size) ;
  256. put_int (psf, longdata) ;
  257. memcpy (&(psf->header [psf->headindex]), strptr, size) ;
  258. psf->headindex += size ;
  259. break ;
  261. default : break ;
  262. } ;
  263. } ;
  265. va_end(argptr);
  266. return ;
  267. } /* psf_hprintf */
  270. /*-----------------------------------------------------------------------------------------------
  271. */
  273. void psf_hsetf (SF_PRIVATE *psf, unsigned int marker, char *format, ...)
  274. { va_list argptr ;
  275. unsigned int  longdata, oldheadindex ;
  276. unsigned short worddata ;
  277. void *bindata ;
  278. size_t size ;
  279. char    c, *strptr ;
  281. /* Save old head index. */
  282. oldheadindex = psf->headindex ;
  283. psf->headindex = 0 ;
  285. /* Find the marker. */
  286. while (psf->headindex < oldheadindex)
  287. { if (*((unsigned int*) &(psf->header[psf->headindex])) == marker)
  288. break ;
  289. psf->headindex += 4 ;
  290. } ;
  292. /* If not found return. */
  293. if (psf->headindex >= oldheadindex)
  294. return ;
  296. /* Move past marker. */
  297. psf->headindex += 4 ;
  299. va_start(argptr, format);
  301. while ((c = *format++))
  302. { switch (c)
  303. { case 'm' : 
  304. longdata = va_arg (argptr, unsigned int) ;
  305. put_int (psf, longdata) ;
  306. break ;
  308. case 'l' :
  309. longdata = va_arg (argptr, unsigned int) ;
  310. longdata = H2LE_INT (longdata) ;
  311. put_int (psf, longdata) ;
  312. break ;
  314. case 'L' :
  315. longdata = va_arg (argptr, unsigned int) ;
  316. longdata = H2BE_INT (longdata) ;
  317. put_int (psf, longdata) ;
  318. break ;
  320. case 'w' :
  321. worddata = va_arg (argptr, int) & 0xFFFF ;
  322. worddata = H2LE_SHORT (worddata) ;
  323. put_short (psf, worddata) ;
  324. break ;
  326. case 'W' :
  327. worddata = va_arg (argptr, int) & 0xFFFF ;
  328. worddata = H2BE_SHORT (worddata) ;
  329. put_short (psf, worddata) ;
  330. break ;
  332. case 'b' :
  333. bindata = va_arg (argptr, void *) ;
  334. size    = va_arg (argptr, size_t) ;
  335. memcpy (&(psf->header [psf->headindex]), bindata, size) ;
  336. psf->headindex += size ;
  337. break ;
  339. case 's' :
  340. strptr = va_arg (argptr, char *) ;
  341. size    = strlen (strptr) + 1 ;
  342. size   += (size & 1) ;
  343. longdata = H2LE_INT (size) ;
  344. put_int (psf, longdata) ;
  345. memcpy (&(psf->header [psf->headindex]), strptr, size) ;
  346. psf->headindex += size ;
  347. break ;
  349. case 'S' :
  350. strptr = va_arg (argptr, char *) ;
  351. size    = strlen (strptr) + 1 ;
  352. size   += (size & 1) ;
  353. longdata = H2BE_INT (size) ;
  354. put_int (psf, longdata) ;
  355. memcpy (&(psf->header [psf->headindex]), strptr, size) ;
  356. psf->headindex += size ;
  357. break ;
  359. default : break ;
  360. } ;
  361. } ;
  363. va_end(argptr);
  365. psf->headindex = oldheadindex ;
  366. return ;
  367. } /* psf_hsetf */