├── README.md ├── mp4.c ├── mp4.h ├── mp4parser.c ├── stdafx.h ├── stream.c └── stream.h /README.md: -------------------------------------------------------------------------------- 1 | ###项目介绍 2 | 3 | 这个项目fork自[Jackarain]([https://github.com/Jackarain/mpfour),感谢。主要功能是解析MP4文件，获取各个box内容，在其上做了一些修改，兼容标准的MP4文件格式 4 | 5 | 1. 使能够运行在linux平台下，修改了输出日志代码 6 | 2. 增加mmpu,hint，mmth，muli box解析 7 | 3. 增加box搜索功能（这个地方运行会有内存错误，待完善） 8 | 9 | 10 | ###使用说明 11 | 12 | #####编译： 13 | 14 | 我测试的环境是在ubuntu下用eclipse开发，语音是c，编译的时候可能需要添加math库，即加上 -lm 15 | #####添加box： 16 | 如果里面没有添加你需要的box，你可以自行添加，，添加的方法，修改mp4.c和mp4.h文件，找一个类比参考（如ftyp，mmpu）修改相应的部分，stream.c里面有你需要的获取流数据的函数 17 | ##### 获取box： 18 | 使用函数root = MP4_BoxGetRoot(s)，会获取整个MP4结构，通过first和next指针找到你所需要的box或container，root是一个二叉树，正在准备完善搜索 19 | -------------------------------------------------------------------------------- /mp4.h: -------------------------------------------------------------------------------- 1 | #ifndef __MP4_H__ 2 | #define __MP4_H__ 3 | 4 | #include "stream.h" 5 | 6 | 7 | #define MP4_FOURCC( a, b, c, d ) \ 8 | ( ((uint32_t)a) | ( ((uint32_t)b) << 8 ) \ 9 | | ( ((uint32_t)c) << 16 ) | ( ((uint32_t)d) << 24 ) ) 10 | 11 | #define ATOM_root MP4_FOURCC( 'r', 'o', 'o', 't' ) 12 | #define ATOM_uuid MP4_FOURCC( 'u', 'u', 'i', 'd' ) 13 | 14 | #define ATOM_ftyp MP4_FOURCC( 'f', 't', 'y', 'p' ) 15 | #define ATOM_mmpu MP4_FOURCC( 'm', 'm', 'p', 'u' ) 16 | #define ATOM_tfdt MP4_FOURCC( 't', 'f', 'd', 't' ) 17 | #define ATOM_moov MP4_FOURCC( 'm', 'o', 'o', 'v' ) 18 | #define ATOM_foov MP4_FOURCC( 'f', 'o', 'o', 'v' ) 19 | #define ATOM_cmov MP4_FOURCC( 'c', 'm', 'o', 'v' ) 20 | #define ATOM_dcom MP4_FOURCC( 'd', 'c', 'o', 'm' ) 21 | #define ATOM_cmvd MP4_FOURCC( 'c', 'm', 'v', 'd' ) 22 | 23 | #define ATOM_moof MP4_FOURCC( 'm', 'o', 'o', 'f' ) 24 | #define ATOM_mdat MP4_FOURCC( 'm', 'd', 'a', 't' ) 25 | #define ATOM_skip MP4_FOURCC( 's', 'k', 'i', 'p' ) 26 | #define ATOM_free MP4_FOURCC( 'f', 'r', 'e', 'e' ) 27 | #define ATOM_udta MP4_FOURCC( 'u', 'd', 't', 'a' ) 28 | #define ATOM_wide MP4_FOURCC( 'w', 'i', 'd', 'e' ) 29 | 30 | #define ATOM_data MP4_FOURCC( 'd', 'a', 't', 'a' ) 31 | 32 | #define ATOM_trak MP4_FOURCC( 't', 'r', 'a', 'k' ) 33 | #define ATOM_mvhd MP4_FOURCC( 'm', 'v', 'h', 'd' ) 34 | #define ATOM_tkhd MP4_FOURCC( 't', 'k', 'h', 'd' ) 35 | #define ATOM_hint MP4_FOURCC( 'h', 'i', 'n', 't' ) 36 | #define ATOM_tref MP4_FOURCC( 't', 'r', 'e', 'f' ) 37 | #define ATOM_mdia MP4_FOURCC( 'm', 'd', 'i', 'a' ) 38 | #define ATOM_mdhd MP4_FOURCC( 'm', 'd', 'h', 'd' ) 39 | #define ATOM_hdlr MP4_FOURCC( 'h', 'd', 'l', 'r' ) 40 | #define ATOM_minf MP4_FOURCC( 'm', 'i', 'n', 'f' ) 41 | #define ATOM_vmhd MP4_FOURCC( 'v', 'm', 'h', 'd' ) 42 | #define ATOM_smhd MP4_FOURCC( 's', 'm', 'h', 'd' ) 43 | #define ATOM_hmhd MP4_FOURCC( 'h', 'm', 'h', 'd' ) 44 | #define ATOM_dinf MP4_FOURCC( 'd', 'i', 'n', 'f' ) 45 | #define ATOM_url MP4_FOURCC( 'u', 'r', 'l', ' ' ) 46 | #define ATOM_urn MP4_FOURCC( 'u', 'r', 'n', ' ' ) 47 | #define ATOM_dref MP4_FOURCC( 'd', 'r', 'e', 'f' ) 48 | #define ATOM_stbl MP4_FOURCC( 's', 't', 'b', 'l' ) 49 | #define ATOM_stts MP4_FOURCC( 's', 't', 't', 's' ) 50 | #define ATOM_ctts MP4_FOURCC( 'c', 't', 't', 's' ) 51 | #define ATOM_stsd MP4_FOURCC( 's', 't', 's', 'd' ) 52 | #define ATOM_stsz MP4_FOURCC( 's', 't', 's', 'z' ) 53 | #define ATOM_stz2 MP4_FOURCC( 's', 't', 'z', '2' ) 54 | #define ATOM_stsc MP4_FOURCC( 's', 't', 's', 'c' ) 55 | #define ATOM_stco MP4_FOURCC( 's', 't', 'c', 'o' ) 56 | #define ATOM_co64 MP4_FOURCC( 'c', 'o', '6', '4' ) 57 | #define ATOM_stss MP4_FOURCC( 's', 't', 's', 's' ) 58 | #define ATOM_stsh MP4_FOURCC( 's', 't', 's', 'h' ) 59 | #define ATOM_stdp MP4_FOURCC( 's', 't', 'd', 'p' ) 60 | #define ATOM_padb MP4_FOURCC( 'p', 'a', 'd', 'b' ) 61 | #define ATOM_edts MP4_FOURCC( 'e', 'd', 't', 's' ) 62 | #define ATOM_elst MP4_FOURCC( 'e', 'l', 's', 't' ) 63 | #define ATOM_mvex MP4_FOURCC( 'm', 'v', 'e', 'x' ) 64 | #define ATOM_sdtp MP4_FOURCC( 's', 'd', 't', 'p' ) 65 | #define ATOM_trex MP4_FOURCC( 't', 'r', 'e', 'x' ) 66 | #define ATOM_mehd MP4_FOURCC( 'm', 'e', 'h', 'd' ) 67 | #define ATOM_mfhd MP4_FOURCC( 'm', 'f', 'h', 'd' ) 68 | #define ATOM_traf MP4_FOURCC( 't', 'r', 'a', 'f' ) 69 | #define ATOM_tfhd MP4_FOURCC( 't', 'f', 'h', 'd' ) 70 | #define ATOM_trun MP4_FOURCC( 't', 'r', 'u', 'n' ) 71 | #define ATOM_cprt MP4_FOURCC( 'c', 'p', 'r', 't' ) 72 | #define ATOM_iods MP4_FOURCC( 'i', 'o', 'd', 's' ) 73 | #define ATOM_pasp MP4_FOURCC( 'p', 'a', 's', 'p' ) 74 | #define ATOM_mfra MP4_FOURCC( 'm', 'f', 'r', 'a' ) 75 | #define ATOM_mfro MP4_FOURCC( 'm', 'f', 'r', 'o' ) 76 | #define ATOM_tfra MP4_FOURCC( 't', 'f', 'r', 'a' ) 77 | 78 | #define ATOM_nmhd MP4_FOURCC( 'n', 'm', 'h', 'd' ) 79 | #define ATOM_mp2v MP4_FOURCC( 'm', 'p', '2', 'v' ) 80 | #define ATOM_mp4v MP4_FOURCC( 'm', 'p', '4', 'v' ) 81 | #define ATOM_mp4a MP4_FOURCC( 'm', 'p', '4', 'a' ) 82 | #define ATOM_mp4s MP4_FOURCC( 'm', 'p', '4', 's' ) 83 | #define ATOM_vide MP4_FOURCC( 'v', 'i', 'd', 'e' ) 84 | #define ATOM_soun MP4_FOURCC( 's', 'o', 'u', 'n' ) 85 | #define ATOM_mmth MP4_FOURCC( 'm', 'm', 't', 'h' ) 86 | #define ATOM_hint MP4_FOURCC( 'h', 'i', 'n', 't' ) 87 | #define ATOM_hdv2 MP4_FOURCC( 'h', 'd', 'v', '2' ) 88 | 89 | #define ATOM_dpnd MP4_FOURCC( 'd', 'p', 'n', 'd' ) 90 | #define ATOM_ipir MP4_FOURCC( 'i', 'p', 'i', 'r' ) 91 | #define ATOM_mpod MP4_FOURCC( 'm', 'p', 'o', 'd' ) 92 | #define ATOM_hnti MP4_FOURCC( 'h', 'n', 't', 'i' ) 93 | #define ATOM_rtp MP4_FOURCC( 'r', 't', 'p', ' ' ) 94 | 95 | #define ATOM_isom MP4_FOURCC( 'i', 's', 'o', 'm' ) 96 | #define ATOM_3gp4 MP4_FOURCC( '3', 'g', 'p', '4' ) 97 | #define ATOM_esds MP4_FOURCC( 'e', 's', 'd', 's' ) 98 | 99 | #define ATOM__mp3 MP4_FOURCC( '.', 'm', 'p', '3' ) 100 | #define ATOM_ms02 MP4_FOURCC( 'm', 's', 0x0, 0x02 ) 101 | #define ATOM_ms11 MP4_FOURCC( 'm', 's', 0x0, 0x11 ) 102 | #define ATOM_ms55 MP4_FOURCC( 'm', 's', 0x0, 0x55 ) 103 | #define ATOM_twos MP4_FOURCC( 't', 'w', 'o', 's' ) 104 | #define ATOM_sowt MP4_FOURCC( 's', 'o', 'w', 't' ) 105 | #define ATOM_QDMC MP4_FOURCC( 'Q', 'D', 'M', 'C' ) 106 | #define ATOM_QDM2 MP4_FOURCC( 'Q', 'D', 'M', '2' ) 107 | #define ATOM_ima4 MP4_FOURCC( 'i', 'm', 'a', '4' ) 108 | #define ATOM_IMA4 MP4_FOURCC( 'I', 'M', 'A', '4' ) 109 | #define ATOM_dvi MP4_FOURCC( 'd', 'v', 'i', ' ' ) 110 | #define ATOM_MAC3 MP4_FOURCC( 'M', 'A', 'C', '3' ) 111 | #define ATOM_MAC6 MP4_FOURCC( 'M', 'A', 'C', '6' ) 112 | #define ATOM_alaw MP4_FOURCC( 'a', 'l', 'a', 'w' ) 113 | #define ATOM_ulaw MP4_FOURCC( 'u', 'l', 'a', 'w' ) 114 | #define ATOM_Qclp MP4_FOURCC( 'Q', 'c', 'l', 'p' ) 115 | #define ATOM_samr MP4_FOURCC( 's', 'a', 'm', 'r' ) 116 | #define ATOM_sawb MP4_FOURCC( 's', 'a', 'w', 'b' ) 117 | #define ATOM_OggS MP4_FOURCC( 'O', 'g', 'g', 'S' ) 118 | #define ATOM_alac MP4_FOURCC( 'a', 'l', 'a', 'c' ) 119 | #define ATOM_dac3 MP4_FOURCC( 'd', 'a', 'c', '3' ) 120 | #define ATOM_dec3 MP4_FOURCC( 'd', 'e', 'c', '3' ) 121 | #define ATOM_enda MP4_FOURCC( 'e', 'n', 'd', 'a' ) 122 | #define ATOM_gnre MP4_FOURCC( 'g', 'n', 'r', 'e' ) 123 | #define ATOM_trkn MP4_FOURCC( 't', 'r', 'k', 'n' ) 124 | 125 | #define ATOM_zlib MP4_FOURCC( 'z', 'l', 'i', 'b' ) 126 | #define ATOM_SVQ1 MP4_FOURCC( 'S', 'V', 'Q', '1' ) 127 | #define ATOM_SVQ3 MP4_FOURCC( 'S', 'V', 'Q', '3' ) 128 | #define ATOM_ZyGo MP4_FOURCC( 'Z', 'y', 'G', 'o' ) 129 | #define ATOM_3IV1 MP4_FOURCC( '3', 'I', 'V', '1' ) 130 | #define ATOM_3iv1 MP4_FOURCC( '3', 'i', 'v', '1' ) 131 | #define ATOM_3IV2 MP4_FOURCC( '3', 'I', 'V', '2' ) 132 | #define ATOM_3iv2 MP4_FOURCC( '3', 'i', 'v', '2' ) 133 | #define ATOM_3IVD MP4_FOURCC( '3', 'I', 'V', 'D' ) 134 | #define ATOM_3ivd MP4_FOURCC( '3', 'i', 'v', 'd' ) 135 | #define ATOM_3VID MP4_FOURCC( '3', 'V', 'I', 'D' ) 136 | #define ATOM_3vid MP4_FOURCC( '3', 'v', 'i', 'd' ) 137 | #define ATOM_h263 MP4_FOURCC( 'h', '2', '6', '3' ) 138 | #define ATOM_s263 MP4_FOURCC( 's', '2', '6', '3' ) 139 | #define ATOM_DIVX MP4_FOURCC( 'D', 'I', 'V', 'X' ) 140 | #define ATOM_XVID MP4_FOURCC( 'X', 'V', 'I', 'D' ) 141 | #define ATOM_cvid MP4_FOURCC( 'c', 'v', 'i', 'd' ) 142 | #define ATOM_mjpa MP4_FOURCC( 'm', 'j', 'p', 'a' ) 143 | #define ATOM_mjpb MP4_FOURCC( 'm', 'j', 'q', 't' ) 144 | #define ATOM_mjqt MP4_FOURCC( 'm', 'j', 'h', 't' ) 145 | #define ATOM_mjht MP4_FOURCC( 'm', 'j', 'p', 'b' ) 146 | #define ATOM_VP31 MP4_FOURCC( 'V', 'P', '3', '1' ) 147 | #define ATOM_vp31 MP4_FOURCC( 'v', 'p', '3', '1' ) 148 | #define ATOM_h264 MP4_FOURCC( 'h', '2', '6', '4' ) 149 | #define ATOM_qdrw MP4_FOURCC( 'q', 'd', 'r', 'w' ) 150 | 151 | #define ATOM_avc1 MP4_FOURCC( 'a', 'v', 'c', '1' ) 152 | #define ATOM_avcC MP4_FOURCC( 'a', 'v', 'c', 'C' ) 153 | #define ATOM_m4ds MP4_FOURCC( 'm', '4', 'd', 's' ) 154 | 155 | #define ATOM_dvc MP4_FOURCC( 'd', 'v', 'c', ' ' ) 156 | #define ATOM_dvp MP4_FOURCC( 'd', 'v', 'p', ' ' ) 157 | #define ATOM_dv5n MP4_FOURCC( 'd', 'v', '5', 'n' ) 158 | #define ATOM_dv5p MP4_FOURCC( 'd', 'v', '5', 'p' ) 159 | #define ATOM_raw MP4_FOURCC( 'r', 'a', 'w', ' ' ) 160 | 161 | #define ATOM_jpeg MP4_FOURCC( 'j', 'p', 'e', 'g' ) 162 | 163 | #define ATOM_yv12 MP4_FOURCC( 'y', 'v', '1', '2' ) 164 | #define ATOM_yuv2 MP4_FOURCC( 'y', 'u', 'v', '2' ) 165 | 166 | #define ATOM_rmra MP4_FOURCC( 'r', 'm', 'r', 'a' ) 167 | #define ATOM_rmda MP4_FOURCC( 'r', 'm', 'd', 'a' ) 168 | #define ATOM_rdrf MP4_FOURCC( 'r', 'd', 'r', 'f' ) 169 | #define ATOM_rmdr MP4_FOURCC( 'r', 'm', 'd', 'r' ) 170 | #define ATOM_rmvc MP4_FOURCC( 'r', 'm', 'v', 'c' ) 171 | #define ATOM_rmcd MP4_FOURCC( 'r', 'm', 'c', 'd' ) 172 | #define ATOM_rmqu MP4_FOURCC( 'r', 'm', 'q', 'u' ) 173 | #define ATOM_alis MP4_FOURCC( 'a', 'l', 'i', 's' ) 174 | 175 | #define ATOM_gmhd MP4_FOURCC( 'g', 'm', 'h', 'd' ) 176 | #define ATOM_wave MP4_FOURCC( 'w', 'a', 'v', 'e' ) 177 | 178 | #define ATOM_drms MP4_FOURCC( 'd', 'r', 'm', 's' ) 179 | #define ATOM_sinf MP4_FOURCC( 's', 'i', 'n', 'f' ) 180 | #define ATOM_schi MP4_FOURCC( 's', 'c', 'h', 'i' ) 181 | #define ATOM_user MP4_FOURCC( 'u', 's', 'e', 'r' ) 182 | #define ATOM_key MP4_FOURCC( 'k', 'e', 'y', ' ' ) 183 | #define ATOM_iviv MP4_FOURCC( 'i', 'v', 'i', 'v' ) 184 | #define ATOM_name MP4_FOURCC( 'n', 'a', 'm', 'e' ) 185 | #define ATOM_priv MP4_FOURCC( 'p', 'r', 'i', 'v' ) 186 | #define ATOM_drmi MP4_FOURCC( 'd', 'r', 'm', 'i' ) 187 | #define ATOM_frma MP4_FOURCC( 'f', 'r', 'm', 'a' ) 188 | #define ATOM_skcr MP4_FOURCC( 's', 'k', 'c', 'r' ) 189 | 190 | #define ATOM_text MP4_FOURCC( 't', 'e', 'x', 't' ) 191 | #define ATOM_tx3g MP4_FOURCC( 't', 'x', '3', 'g' ) 192 | #define ATOM_subp MP4_FOURCC( 's', 'u', 'b', 'p' ) 193 | #define ATOM_sbtl MP4_FOURCC( 's', 'b', 't', 'l' ) 194 | 195 | #define ATOM_0xa9nam MP4_FOURCC( 0xa9, 'n', 'a', 'm' ) 196 | #define ATOM_0xa9aut MP4_FOURCC( 0xa9, 'a', 'u', 't' ) 197 | #define ATOM_0xa9cpy MP4_FOURCC( 0xa9, 'c', 'p', 'y' ) 198 | #define ATOM_0xa9inf MP4_FOURCC( 0xa9, 'i', 'n', 'f' ) 199 | #define ATOM_0xa9ART MP4_FOURCC( 0xa9, 'A', 'R', 'T' ) 200 | #define ATOM_0xa9des MP4_FOURCC( 0xa9, 'd', 'e', 's' ) 201 | #define ATOM_0xa9dir MP4_FOURCC( 0xa9, 'd', 'i', 'r' ) 202 | #define ATOM_0xa9cmt MP4_FOURCC( 0xa9, 'c', 'm', 't' ) 203 | #define ATOM_0xa9req MP4_FOURCC( 0xa9, 'r', 'e', 'q' ) 204 | #define ATOM_0xa9day MP4_FOURCC( 0xa9, 'd', 'a', 'y' ) 205 | #define ATOM_0xa9fmt MP4_FOURCC( 0xa9, 'f', 'm', 't' ) 206 | #define ATOM_0xa9prd MP4_FOURCC( 0xa9, 'p', 'r', 'd' ) 207 | #define ATOM_0xa9prf MP4_FOURCC( 0xa9, 'p', 'r', 'f' ) 208 | #define ATOM_0xa9src MP4_FOURCC( 0xa9, 's', 'r', 'c' ) 209 | #define ATOM_0xa9alb MP4_FOURCC( 0xa9, 'a', 'l', 'b' ) 210 | #define ATOM_0xa9dis MP4_FOURCC( 0xa9, 'd', 'i', 's' ) 211 | #define ATOM_0xa9enc MP4_FOURCC( 0xa9, 'e', 'n', 'c' ) 212 | #define ATOM_0xa9trk MP4_FOURCC( 0xa9, 't', 'r', 'k' ) 213 | #define ATOM_0xa9url MP4_FOURCC( 0xa9, 'u', 'r', 'l' ) 214 | #define ATOM_0xa9dsa MP4_FOURCC( 0xa9, 'd', 's', 'a' ) 215 | #define ATOM_0xa9hst MP4_FOURCC( 0xa9, 'h', 's', 't' ) 216 | #define ATOM_0xa9ope MP4_FOURCC( 0xa9, 'o', 'p', 'e' ) 217 | #define ATOM_0xa9wrt MP4_FOURCC( 0xa9, 'w', 'r', 't' ) 218 | #define ATOM_0xa9com MP4_FOURCC( 0xa9, 'c', 'o', 'm' ) 219 | #define ATOM_0xa9gen MP4_FOURCC( 0xa9, 'g', 'e', 'n' ) 220 | #define ATOM_0xa9too MP4_FOURCC( 0xa9, 't', 'o', 'o' ) 221 | #define ATOM_0xa9wrn MP4_FOURCC( 0xa9, 'w', 'r', 'n' ) 222 | #define ATOM_0xa9swr MP4_FOURCC( 0xa9, 's', 'w', 'r' ) 223 | #define ATOM_0xa9mak MP4_FOURCC( 0xa9, 'm', 'a', 'k' ) 224 | #define ATOM_0xa9mod MP4_FOURCC( 0xa9, 'm', 'o', 'd' ) 225 | #define ATOM_0xa9PRD MP4_FOURCC( 0xa9, 'P', 'R', 'D' ) 226 | #define ATOM_0xa9grp MP4_FOURCC( 0xa9, 'g', 'r', 'p' ) 227 | #define ATOM_0xa9lyr MP4_FOURCC( 0xa9, 'g', 'r', 'p' ) 228 | #define ATOM_chpl MP4_FOURCC( 'c', 'h', 'p', 'l' ) 229 | #define ATOM_WLOC MP4_FOURCC( 'W', 'L', 'O', 'C' ) 230 | 231 | #define ATOM_meta MP4_FOURCC( 'm', 'e', 't', 'a' ) 232 | #define ATOM_ilst MP4_FOURCC( 'i', 'l', 's', 't' ) 233 | 234 | #define ATOM_chap MP4_FOURCC( 'c', 'h', 'a', 'p' ) 235 | 236 | 237 | 238 | typedef struct uuid_s 239 | { 240 | uint8_t b[16]; 241 | } uuid_t; 242 | 243 | /* specific structure for all boxes */ 244 | typedef struct mp4_box_data_ftyp_s 245 | { 246 | uint32_t major_brand; 247 | uint32_t minor_version; 248 | 249 | uint32_t compatible_brands_count; 250 | uint32_t *compatible_brands; 251 | 252 | } mp4_box_data_ftyp_t; 253 | 254 | typedef struct mp4_box_data_mmpu_s 255 | { 256 | uint8_t version; 257 | uint32_t flags; 258 | uint8_t is_complete; 259 | uint8_t reserved; 260 | uint32_t mpu_sequence_number; 261 | uint32_t asset_id_scheme; 262 | uint32_t asset_id_length; 263 | char *asset_id_value; 264 | 265 | } mp4_box_data_mmpu_t; 266 | 267 | typedef struct mp4_box_data_tfdt_s 268 | { 269 | uint8_t version; 270 | uint32_t flags; 271 | uint64_t baseMediaDecodeTime; 272 | 273 | } mp4_box_data_tfdt_t; 274 | 275 | typedef struct mp4_box_data_mvhd_s 276 | { 277 | uint8_t version; 278 | uint32_t flags; 279 | 280 | uint64_t creation_time; 281 | uint64_t modification_time; 282 | uint32_t timescale; 283 | uint64_t duration; 284 | 285 | int32_t rate; 286 | int16_t volume; 287 | int16_t reserved1; 288 | uint32_t reserved2[2]; 289 | int32_t matrix[9]; 290 | uint32_t predefined[6]; 291 | uint32_t next_track_id; 292 | 293 | } mp4_box_data_mvhd_t; 294 | 295 | #define MP4_TRACK_ENABLED 0x000001 296 | #define MP4_TRACK_IN_MOVIE 0x000002 297 | #define MP4_TRACK_IN_PREVIEW 0x000004 298 | 299 | typedef struct mp4_box_data_tkhd_s 300 | { 301 | uint8_t version; 302 | uint32_t flags; 303 | 304 | uint64_t creation_time; 305 | uint64_t modification_time; 306 | uint32_t track_id; 307 | uint32_t reserved; 308 | uint64_t duration; 309 | 310 | uint32_t reserved2[2]; 311 | int16_t layer; 312 | int16_t predefined; 313 | 314 | int16_t volume; 315 | uint16_t reserved3; 316 | int32_t matrix[9]; 317 | int32_t width; 318 | int32_t height; 319 | 320 | } mp4_box_data_tkhd_t; 321 | 322 | typedef struct mp4_box_data_hint_s 323 | { 324 | 325 | uint32_t track_IDs; 326 | 327 | } mp4_box_data_hint_t; 328 | 329 | typedef struct mp4_box_data_mdhd_s 330 | { 331 | uint8_t version; 332 | uint32_t flags; 333 | 334 | uint64_t creation_time; 335 | uint64_t modification_time; 336 | uint32_t timescale; 337 | uint64_t duration; 338 | 339 | /* one bit for pad */ 340 | uint16_t language_code; 341 | /* unsigned int(5)[3] language difference with 0x60*/ 342 | unsigned char language[3]; 343 | uint16_t predefined; 344 | 345 | } mp4_box_data_mdhd_t; 346 | 347 | typedef struct mp4_box_data_hdlr_s 348 | { 349 | uint8_t version; 350 | uint32_t flags; 351 | 352 | uint32_t predefined; 353 | uint32_t handler_type; /* "vide" "soun" "hint" "odsm" "crsm" "sdsm" "m7sm" "ocsm" "ipsm" "mjsm" */ 354 | 355 | unsigned char *psz_name; /* in UTF-8 */ 356 | 357 | } mp4_box_data_hdlr_t; 358 | 359 | typedef struct mp4_box_data_vmhd_s 360 | { 361 | uint8_t version; 362 | uint32_t flags; 363 | 364 | int16_t graphics_mode; 365 | int16_t opcolor[3]; 366 | 367 | } mp4_box_data_vmhd_t; 368 | 369 | typedef struct mp4_box_data_smhd_s 370 | { 371 | uint8_t version; 372 | uint32_t flags; 373 | 374 | int16_t balance; 375 | int16_t reserved; 376 | 377 | } mp4_box_data_smhd_t; 378 | 379 | typedef struct mp4_box_data_hmhd_s 380 | { 381 | uint8_t version; 382 | uint32_t flags; 383 | 384 | uint16_t max_PDU_size; 385 | uint16_t avg_PDU_size; 386 | uint32_t max_bitrate; 387 | uint32_t avg_bitrate; 388 | uint32_t reserved; 389 | 390 | } mp4_box_data_hmhd_t; 391 | 392 | typedef struct mp4_box_data_url_s 393 | { 394 | uint8_t version; 395 | uint32_t flags; 396 | 397 | char *psz_location; 398 | 399 | } mp4_box_data_url_t; 400 | 401 | typedef struct mp4_box_data_urn_s 402 | { 403 | uint8_t version; 404 | uint32_t flags; 405 | 406 | char *psz_name; 407 | char *psz_location; 408 | 409 | } mp4_box_data_urn_t; 410 | 411 | typedef struct mp4_box_data_dref_s 412 | { 413 | uint8_t version; 414 | uint32_t flags; 415 | 416 | uint32_t entry_count; 417 | /* XXX it's also a container with entry_count entry */ 418 | } mp4_box_data_dref_t; 419 | 420 | typedef struct mp4_box_data_stts_s 421 | { 422 | uint8_t version; 423 | uint32_t flags; 424 | 425 | uint32_t entry_count; 426 | uint32_t *sample_count; /* these are array */ 427 | int32_t *sample_delta; 428 | 429 | } mp4_box_data_stts_t; 430 | 431 | typedef struct mp4_box_data_ctts_s 432 | { 433 | uint8_t version; 434 | uint32_t flags; 435 | 436 | uint32_t entry_count; 437 | 438 | uint32_t *sample_count; /* these are array */ 439 | int32_t *sample_offset; 440 | 441 | } mp4_box_data_ctts_t; 442 | 443 | 444 | typedef struct mp4_box_data_sample_soun_s 445 | { 446 | uint8_t reserved1[6]; 447 | uint16_t data_reference_index; 448 | 449 | //uint32_t reserved2[2]; 450 | uint16_t qt_version; 451 | uint16_t qt_revision_level; 452 | uint32_t qt_vendor; 453 | 454 | uint16_t channelcount; 455 | uint16_t samplesize; 456 | uint16_t predefined; 457 | uint16_t reserved3; 458 | uint16_t sampleratehi; /* timescale of track */ 459 | uint16_t sampleratelo; 460 | 461 | /* for version 1 (reserved1[0] == 1) */ 462 | uint32_t sample_per_packet; 463 | uint32_t bytes_per_packet; 464 | uint32_t bytes_per_frame; 465 | uint32_t bytes_per_sample; 466 | 467 | /* XXX hack */ 468 | int qt_description; 469 | uint8_t *p_qt_description; 470 | 471 | void *drms; 472 | 473 | } mp4_box_data_sample_soun_t; 474 | 475 | typedef struct mp4_box_data_sample_vide_s 476 | { 477 | uint8_t reserved1[6]; 478 | uint16_t data_reference_index; 479 | 480 | uint16_t qt_version; 481 | uint16_t qt_revision_level; 482 | uint32_t qt_vendor; 483 | 484 | uint32_t qt_temporal_quality; 485 | uint32_t qt_spatial_quality; 486 | 487 | int16_t width; 488 | int16_t height; 489 | 490 | uint32_t horizresolution; 491 | uint32_t vertresolution; 492 | 493 | uint32_t qt_data_size; 494 | uint16_t qt_frame_count; 495 | 496 | uint8_t compressorname[32]; 497 | int16_t depth; 498 | 499 | int16_t qt_color_table; 500 | 501 | /* XXX hack ImageDescription */ 502 | int qt_image_description; 503 | uint8_t *p_qt_image_description; 504 | 505 | void *drms; 506 | 507 | } mp4_box_data_sample_vide_t; 508 | 509 | typedef struct mp4_box_data_sample_mmth_s 510 | { 511 | uint8_t reserved1[6]; 512 | uint16_t data_reference_index; 513 | 514 | uint16_t hinttrackversion; 515 | uint16_t highestcompatibleversion; 516 | uint16_t packet_id; 517 | uint8_t has_mfus_flag; 518 | uint8_t is_timed; 519 | uint8_t reserved; 520 | /*uint32_t asset_id_scheme; 521 | uint32_t asset_id_length; 522 | char *asset_id_value;*/ 523 | 524 | } mp4_box_data_sample_mmth_t; 525 | 526 | typedef struct mp4_box_data_mmthsample_s 527 | { 528 | uint32_t sequence_number; 529 | uint8_t trackrefindex; 530 | uint32_t moviefragmentsequencenumber; 531 | uint32_t samplenumber; 532 | uint8_t priority; 533 | uint8_t dependency_counter; 534 | uint32_t offset; 535 | uint32_t length; 536 | uint16_t item_ID; 537 | 538 | } mp4_box_data_mmthsample_t; 539 | 540 | typedef struct mp4_box_data_muli_s 541 | { 542 | uint8_t multilayer_flag:1; 543 | uint8_t reserved0:7; 544 | uint8_t dependency_id:3; 545 | uint8_t depth_flag:1; 546 | uint8_t reserved1:4; 547 | uint8_t temporal_id:3; 548 | uint8_t reserved2:1; 549 | uint8_t quality_id:4; 550 | uint8_t priority_id:6; 551 | uint16_t view_id:10; 552 | 553 | uint8_t layer_id:6; 554 | //uint8_t temporal_id:3; 555 | uint8_t reserved3:7; 556 | 557 | } mp4_box_data_muli_t; 558 | 559 | 560 | 561 | #define MP4_TEXT_DISPLAY_FLAG_DONT_DISPLAY (1<<0) 562 | #define MP4_TEXT_DISPLAY_FLAG_AUTO_SCALE (1<<1) 563 | #define MP4_TEXT_DISPLAY_FLAG_CLIP_TO_TEXT_BOX (1<<2) 564 | #define MP4_TEXT_DISPLAY_FLAG_USE_MOVIE_BG_COLOR (1<<3) 565 | #define MP4_TEXT_DISPLAY_FLAG_SHRINK_TEXT_BOX_TO_FIT (1<<4) 566 | #define MP4_TEXT_DISPLAY_FLAG_SCROLL_IN (1<<5) 567 | #define MP4_TEXT_DISPLAY_FLAG_SCROLL_OUT (1<<6) 568 | #define MP4_TEXT_DISPLAY_FLAG_HORIZONTAL_SCROLL (1<<7) 569 | #define MP4_TEXT_DISPLAY_FLAG_REVERSE_SCROLL (1<<8) 570 | #define MP4_TEXT_DISPLAY_FLAG_CONTINUOUS_SCROLL (1<<9) 571 | #define MP4_TEXT_DISPLAY_FLAG_FLOW_HORIZONTAL (1<<10) 572 | #define MP4_TEXT_DISPLAY_FLAG_CONTINUOUS_KARAOKE (1<<11) 573 | #define MP4_TEXT_DISPLAY_FLAG_DROP_SHADOW (1<<12) 574 | #define MP4_TEXT_DISPLAY_FLAG_ANTI_ALIAS (1<<13) 575 | #define MP4_TEXT_DISPLAY_FLAG_KEYED_TEXT (1<<14) 576 | #define MP4_TEXT_DISPLAY_FLAG_INVERSE_HILITE (1<<15) 577 | #define MP4_TEXT_DISPLAY_FLAG_COLOR_HILITE (1<<16) 578 | #define MP4_TEXT_DISPLAY_FLAG_WRITE_VERTICALLY (1<<17) 579 | 580 | typedef struct 581 | { 582 | uint32_t reserved1; 583 | uint16_t reserved2; 584 | 585 | uint16_t data_reference_index; 586 | 587 | uint32_t display_flags; // TextDescription and Tx3gDescription 588 | 589 | int8_t justification_horizontal; // left(0), centered(1), right(-1) 590 | int8_t justification_vertical; // top(0), centered(1), bottom(-1) 591 | 592 | uint16_t background_color[4]; 593 | 594 | uint16_t text_box_top; 595 | uint16_t text_box_left; 596 | uint16_t text_box_bottom; 597 | uint16_t text_box_right; 598 | 599 | // TODO to complete 600 | } mp4_box_data_sample_text_t; 601 | 602 | typedef struct mp4_box_data_sample_hint_s 603 | { 604 | uint8_t reserved1[6]; 605 | uint16_t data_reference_index; 606 | 607 | uint8_t *data; 608 | 609 | } mp4_box_data_sample_hint_t; 610 | 611 | typedef struct mp4_box_data_moviehintinformation_rtp_s 612 | { 613 | uint32_t description_format; 614 | unsigned char *psz_text; 615 | 616 | } mp4_box_data_moviehintinformation_rtp_t; 617 | 618 | 619 | 620 | typedef struct mp4_box_data_stsd_s 621 | { 622 | uint8_t version; 623 | uint32_t flags; 624 | 625 | uint32_t entry_count; 626 | 627 | /* it contains SampleEntry handled as if it was Box */ 628 | 629 | } mp4_box_data_stsd_t; 630 | 631 | 632 | typedef struct mp4_box_data_stsz_s 633 | { 634 | uint8_t version; 635 | uint32_t flags; 636 | 637 | uint32_t sample_size; 638 | uint32_t sample_count; 639 | 640 | uint32_t *entry_size; /* array , empty if sample_size != 0 */ 641 | 642 | } mp4_box_data_stsz_t; 643 | 644 | typedef struct mp4_box_data_stz2_s 645 | { 646 | uint8_t version; 647 | uint32_t flags; 648 | 649 | uint32_t sample_size; /* 24 bits */ 650 | uint8_t field_size; 651 | uint32_t sample_count; 652 | 653 | uint32_t *entry_size; /* array: unsigned int(field_size) entry_size */ 654 | 655 | } mp4_box_data_stz2_t; 656 | 657 | typedef struct mp4_box_data_stsc_s 658 | { 659 | uint8_t version; 660 | uint32_t flags; 661 | 662 | uint32_t entry_count; 663 | 664 | uint32_t *first_chunk; /* theses are arrays */ 665 | uint32_t *samples_per_chunk; 666 | uint32_t *sample_description_index; 667 | 668 | } mp4_box_data_stsc_t; 669 | 670 | 671 | typedef struct mp4_box_data_co64_s 672 | { 673 | uint8_t version; 674 | uint32_t flags; 675 | 676 | uint32_t entry_count; 677 | 678 | uint64_t *chunk_offset; 679 | 680 | } mp4_box_data_co64_t; 681 | 682 | 683 | typedef struct mp4_box_data_stss_s 684 | { 685 | uint8_t version; 686 | uint32_t flags; 687 | 688 | uint32_t entry_count; 689 | 690 | uint32_t *sample_number; 691 | 692 | } mp4_box_data_stss_t; 693 | 694 | typedef struct mp4_box_data_stsh_s 695 | { 696 | uint8_t version; 697 | uint32_t flags; 698 | 699 | uint32_t entry_count; 700 | 701 | uint32_t *shadowed_sample_number; 702 | uint32_t *sync_sample_number; 703 | 704 | } mp4_box_data_stsh_t; 705 | 706 | typedef struct mp4_box_data_stdp_s 707 | { 708 | uint8_t version; 709 | uint32_t flags; 710 | 711 | uint16_t *priority; 712 | 713 | } mp4_box_data_stdp_t; 714 | 715 | typedef struct mp4_box_data_padb_s 716 | { 717 | uint8_t version; 718 | uint32_t flags; 719 | 720 | uint32_t sample_count; 721 | 722 | uint16_t *reserved1; /* 1bit */ 723 | uint16_t *pad2; /* 3bits */ 724 | uint16_t *reserved2; /* 1bit */ 725 | uint16_t *pad1; /* 3bits */ 726 | 727 | 728 | } mp4_box_data_padb_t; 729 | 730 | 731 | typedef struct mp4_box_data_elst_s 732 | { 733 | uint8_t version; 734 | uint32_t flags; 735 | 736 | uint32_t entry_count; 737 | 738 | uint64_t *segment_duration; 739 | int64_t *media_time; 740 | uint16_t *media_rate_integer; 741 | uint16_t *media_rate_fraction; 742 | 743 | 744 | } mp4_box_data_elst_t; 745 | 746 | typedef struct mp4_box_data_cprt_s 747 | { 748 | uint8_t version; 749 | uint32_t flags; 750 | /* 1 pad bit */ 751 | unsigned char language[3]; 752 | 753 | char *psz_notice; 754 | } mp4_box_data_cprt_t; 755 | 756 | 757 | /* DecoderConfigDescriptor */ 758 | typedef struct mp4_descriptor_decoder_config_s 759 | { 760 | uint8_t objectTypeIndication; 761 | uint8_t streamType; 762 | int b_upStream; 763 | int buffer_sizeDB; 764 | int max_bitrate; 765 | int avg_bitrate; 766 | 767 | int decoder_specific_info_len; 768 | uint8_t *decoder_specific_info; 769 | /* some other stuff */ 770 | 771 | } mp4_descriptor_decoder_config_t; 772 | 773 | typedef struct mp4_descriptor_SL_config_s 774 | { 775 | 776 | int dummy; /* ANSI C forbids empty structures */ 777 | 778 | } mp4_descriptor_SL_config_t; 779 | 780 | 781 | typedef struct mp4_descriptor_ES_s 782 | { 783 | uint16_t ES_ID; 784 | int b_stream_dependence; 785 | int b_url; 786 | int b_OCRstream; 787 | int stream_priority; 788 | 789 | int depend_on_ES_ID; /* if b_stream_dependence set */ 790 | 791 | unsigned char *psz_URL; 792 | 793 | uint16_t OCR_ES_ID; /* if b_OCRstream */ 794 | mp4_descriptor_decoder_config_t *decConfigDescr; 795 | 796 | mp4_descriptor_SL_config_t *slConfigDescr; 797 | 798 | /* some other stuff ... */ 799 | 800 | } mp4_descriptor_ES_t; 801 | 802 | /* ES descriptor */ 803 | typedef struct mp4_box_data_esds_s 804 | { 805 | uint8_t version; 806 | uint32_t flags; 807 | 808 | mp4_descriptor_ES_t es_descriptor; 809 | 810 | } mp4_box_data_esds_t; 811 | 812 | 813 | typedef struct mp4_box_data_dcom_s 814 | { 815 | uint32_t algorithm; /* fourcc */ 816 | 817 | } mp4_box_data_dcom_t; 818 | 819 | typedef struct mp4_box_data_cmvd_s 820 | { 821 | uint32_t uncompressed_size; 822 | uint32_t compressed_size; 823 | 824 | int b_compressed; /* Set to 1 if compressed data, 0 if uncompressed */ 825 | uint8_t *data; 826 | 827 | } mp4_box_data_cmvd_t; 828 | 829 | typedef struct mp4_box_data_cmov_s 830 | { 831 | struct mp4_box_s *moov; /* uncompressed moov */ 832 | 833 | } mp4_box_data_cmov_t; 834 | 835 | typedef struct 836 | { 837 | uint32_t type; 838 | } mp4_box_data_frma_t; 839 | 840 | typedef struct 841 | { 842 | uint32_t init; 843 | uint32_t encr; 844 | uint32_t decr; 845 | } mp4_box_data_skcr_t; 846 | 847 | typedef struct 848 | { 849 | uint8_t version; 850 | uint32_t flags; 851 | 852 | uint32_t ref_type; 853 | char *psz_ref; 854 | 855 | } mp4_box_data_rdrf_t; 856 | 857 | typedef struct 858 | { 859 | uint8_t version; 860 | uint32_t flags; 861 | 862 | uint32_t rate; 863 | 864 | } mp4_box_data_rmdr_t; 865 | 866 | typedef struct 867 | { 868 | uint8_t version; 869 | uint32_t flags; 870 | 871 | uint32_t gestaltType; 872 | uint32_t val1; 873 | uint32_t val2; 874 | uint16_t checkType; /* 0: val1 is version min 875 | 1: gestalt value & val2 == val1 */ 876 | 877 | } mp4_box_data_rmvc_t; 878 | 879 | typedef struct 880 | { 881 | uint8_t version; 882 | uint32_t flags; 883 | 884 | 885 | } mp4_box_data_rmcd_t; 886 | 887 | typedef struct 888 | { 889 | uint32_t quality; 890 | 891 | } mp4_box_data_rmqu_t; 892 | 893 | typedef struct mp4_box_data_mfhd_s 894 | { 895 | uint32_t sequence_number; 896 | 897 | uint8_t *vendor_extension; 898 | 899 | } mp4_box_data_mfhd_t; 900 | 901 | #define MP4_TFHD_BASE_DATA_OFFSET (1LL<<0) 902 | #define MP4_TFHD_SAMPLE_DESC_INDEX (1LL<<1) 903 | #define MP4_TFHD_DFLT_SAMPLE_DURATION (1LL<<3) 904 | #define MP4_TFHD_DFLT_SAMPLE_SIZE (1LL<<4) 905 | #define MP4_TFHD_DFLT_SAMPLE_FLAGS (1LL<<5) 906 | typedef struct mp4_box_data_tfhd_s 907 | { 908 | uint8_t version; 909 | uint32_t flags; 910 | uint32_t track_ID; 911 | 912 | /* optional fields */ 913 | uint64_t base_data_offset; 914 | uint32_t sample_description_index; 915 | uint32_t default_sample_duration; 916 | uint32_t default_sample_size; 917 | uint32_t default_sample_flags; 918 | 919 | } mp4_box_data_tfhd_t; 920 | 921 | #define MP4_TRUN_DATA_OFFSET (1<<0) 922 | #define MP4_TRUN_FIRST_FLAGS (1<<2) 923 | #define MP4_TRUN_SAMPLE_DURATION (1<<8) 924 | #define MP4_TRUN_SAMPLE_SIZE (1<<9) 925 | #define MP4_TRUN_SAMPLE_FLAGS (1<<10) 926 | #define MP4_TRUN_SAMPLE_TIME_OFFSET (1<<11) 927 | typedef struct mp4_descriptor_trun_sample_t 928 | { 929 | uint32_t duration; 930 | uint32_t size; 931 | uint32_t flags; 932 | uint32_t composition_time_offset; 933 | } mp4_descriptor_trun_sample_t; 934 | 935 | typedef struct mp4_box_data_trun_s 936 | { 937 | uint8_t version; 938 | uint32_t flags; 939 | uint32_t sample_count; 940 | 941 | /* optional fields */ 942 | uint32_t data_offset; 943 | uint32_t first_sample_flags; 944 | 945 | mp4_descriptor_trun_sample_t *samples; 946 | 947 | } mp4_box_data_trun_t; 948 | 949 | 950 | 951 | typedef struct mp4_box_data_0xa9xxx_s 952 | { 953 | char *psz_text; 954 | 955 | } mp4_box_data_0xa9xxx_t; 956 | 957 | typedef struct mp4_box_data_name_s 958 | { 959 | char *psz_text; 960 | 961 | } mp4_box_data_name_t; 962 | 963 | typedef struct mp4_box_data_tref_generic_s 964 | { 965 | uint32_t entry_count; 966 | uint32_t *track_ID; 967 | 968 | } mp4_box_data_tref_generic_t; 969 | 970 | typedef struct mp4_box_data_chpl_s 971 | { 972 | uint8_t version; 973 | uint32_t flags; 974 | 975 | uint8_t chapter; 976 | struct 977 | { 978 | char *psz_name; 979 | int64_t start; 980 | } p_chapter[256]; 981 | } mp4_box_data_chpl_t; 982 | 983 | typedef struct mp4_box_data_avcC_s 984 | { 985 | uint8_t version; 986 | uint8_t profile; 987 | uint8_t profile_compatibility; 988 | uint8_t level; 989 | 990 | uint8_t reserved1; /* 6 bits */ 991 | uint8_t length_size; 992 | 993 | uint8_t reserved2; /* 3 bits */ 994 | uint8_t sps; 995 | uint16_t *sps_length; 996 | uint8_t **p_sps; 997 | 998 | uint8_t pps; 999 | uint16_t *pps_length; 1000 | uint8_t **p_pps; 1001 | 1002 | /* XXX: Hack raw avcC atom payload */ 1003 | int avcC; 1004 | uint8_t *p_avcC; 1005 | 1006 | } mp4_box_data_avcC_t; 1007 | 1008 | typedef struct mp4_box_data_dac3_s 1009 | { 1010 | uint8_t fscod; 1011 | uint8_t bsid; 1012 | uint8_t bsmod; 1013 | uint8_t acmod; 1014 | uint8_t lfeon; 1015 | uint8_t bitrate_code; 1016 | 1017 | } mp4_box_data_dac3_t; 1018 | 1019 | typedef struct mp4_box_data_enda_s 1020 | { 1021 | uint16_t little_endian; 1022 | 1023 | } mp4_box_data_enda_t; 1024 | 1025 | typedef struct mp4_box_data_gnre_s 1026 | { 1027 | uint16_t genre; 1028 | 1029 | } mp4_box_data_gnre_t; 1030 | 1031 | typedef struct mp4_box_data_trkn_s 1032 | { 1033 | uint32_t track_number; 1034 | uint32_t track_total; 1035 | 1036 | } mp4_box_data_trkn_t; 1037 | 1038 | typedef struct mp4_box_data_iods_s 1039 | { 1040 | uint8_t version; 1041 | uint32_t flags; 1042 | 1043 | uint16_t object_descriptor; 1044 | uint8_t OD_profile_level; 1045 | uint8_t scene_profile_level; 1046 | uint8_t audio_profile_level; 1047 | uint8_t visual_profile_level; 1048 | uint8_t graphics_profile_level; 1049 | 1050 | } mp4_box_data_iods_t; 1051 | 1052 | typedef struct mp4_box_data_pasp_s 1053 | { 1054 | uint32_t horizontal_spacing; 1055 | uint32_t vertical_spacing; 1056 | } mp4_box_data_pasp_t; 1057 | 1058 | typedef struct mp4_box_data_mehd_s 1059 | { 1060 | uint8_t version; 1061 | uint32_t flags; 1062 | 1063 | uint64_t fragment_duration; 1064 | } mp4_box_data_mehd_t; 1065 | 1066 | typedef struct mp4_box_data_trex_s 1067 | { 1068 | uint8_t version; 1069 | uint32_t flags; 1070 | 1071 | uint32_t track_ID; 1072 | uint32_t default_sample_description_index; 1073 | uint32_t default_sample_duration; 1074 | uint32_t default_sample_size; 1075 | uint32_t default_sample_flags; 1076 | } mp4_box_data_trex_t; 1077 | 1078 | typedef struct mp4_box_data_sdtp_s 1079 | { 1080 | uint8_t version; 1081 | uint32_t flags; 1082 | 1083 | uint8_t *sample_table; 1084 | } mp4_box_data_sdtp_t; 1085 | 1086 | typedef struct mp4_box_data_mfro_s 1087 | { 1088 | uint8_t version; 1089 | uint32_t flags; 1090 | 1091 | uint32_t size; 1092 | } mp4_box_data_mfro_t; 1093 | 1094 | typedef struct mp4_box_data_tfra_s 1095 | { 1096 | uint8_t version; 1097 | uint32_t flags; 1098 | 1099 | uint32_t track_ID; 1100 | uint32_t number_of_entries; 1101 | 1102 | uint8_t length_size_of_traf_num; 1103 | uint8_t length_size_of_trun_num; 1104 | uint8_t length_size_of_sample_num; 1105 | 1106 | uint32_t *time; 1107 | uint32_t *moof_offset; 1108 | uint8_t *traf_number; 1109 | uint8_t *trun_number; 1110 | uint8_t *sample_number; 1111 | } mp4_box_data_tfra_t; 1112 | 1113 | typedef union mp4_box_data_s 1114 | { 1115 | mp4_box_data_ftyp_t *p_ftyp; 1116 | mp4_box_data_mmpu_t *p_mmpu; 1117 | mp4_box_data_tfdt_t *p_tfdt; 1118 | mp4_box_data_mvhd_t *p_mvhd; 1119 | mp4_box_data_mfhd_t *p_mfhd; 1120 | mp4_box_data_tfhd_t *p_tfhd; 1121 | mp4_box_data_trun_t *p_trun; 1122 | mp4_box_data_tkhd_t *p_tkhd; 1123 | mp4_box_data_hint_t *p_hint; 1124 | mp4_box_data_mdhd_t *p_mdhd; 1125 | mp4_box_data_hdlr_t *p_hdlr; 1126 | mp4_box_data_vmhd_t *p_vmhd; 1127 | mp4_box_data_smhd_t *p_smhd; 1128 | mp4_box_data_hmhd_t *p_hmhd; 1129 | mp4_box_data_url_t *p_url; 1130 | mp4_box_data_urn_t *p_urn; 1131 | mp4_box_data_dref_t *p_dref; 1132 | mp4_box_data_stts_t *p_stts; 1133 | mp4_box_data_ctts_t *p_ctts; 1134 | mp4_box_data_stsd_t *p_stsd; 1135 | mp4_box_data_sample_vide_t *p_sample_vide; 1136 | mp4_box_data_sample_soun_t *p_sample_soun; 1137 | mp4_box_data_sample_text_t *p_sample_text; 1138 | mp4_box_data_sample_hint_t *p_sample_hint; 1139 | mp4_box_data_sample_mmth_t *p_sample_mmth; 1140 | 1141 | mp4_box_data_esds_t *p_esds; 1142 | mp4_box_data_avcC_t *p_avcC; 1143 | mp4_box_data_dac3_t *p_dac3; 1144 | mp4_box_data_enda_t *p_enda; 1145 | mp4_box_data_gnre_t *p_gnre; 1146 | mp4_box_data_trkn_t *p_trkn; 1147 | mp4_box_data_iods_t *p_iods; 1148 | mp4_box_data_pasp_t *p_pasp; 1149 | mp4_box_data_trex_t *p_trex; 1150 | mp4_box_data_mehd_t *p_mehd; 1151 | mp4_box_data_sdtp_t *p_sdtp; 1152 | 1153 | mp4_box_data_tfra_t *p_tfra; 1154 | mp4_box_data_mfro_t *p_mfro; 1155 | 1156 | mp4_box_data_stsz_t *p_stsz; 1157 | mp4_box_data_stz2_t *p_stz2; 1158 | mp4_box_data_stsc_t *p_stsc; 1159 | mp4_box_data_co64_t *p_co64; 1160 | mp4_box_data_stss_t *p_stss; 1161 | mp4_box_data_stsh_t *p_stsh; 1162 | mp4_box_data_stdp_t *p_stdp; 1163 | mp4_box_data_padb_t *p_padb; 1164 | mp4_box_data_elst_t *p_elst; 1165 | mp4_box_data_cprt_t *p_cprt; 1166 | 1167 | mp4_box_data_dcom_t *p_dcom; 1168 | mp4_box_data_cmvd_t *p_cmvd; 1169 | mp4_box_data_cmov_t *p_cmov; 1170 | 1171 | mp4_box_data_moviehintinformation_rtp_t p_moviehintinformation_rtp; 1172 | 1173 | mp4_box_data_frma_t *p_frma; 1174 | mp4_box_data_skcr_t *p_skcr; 1175 | 1176 | mp4_box_data_rdrf_t *p_rdrf; 1177 | mp4_box_data_rmdr_t *p_rmdr; 1178 | mp4_box_data_rmqu_t *p_rmqu; 1179 | mp4_box_data_rmvc_t *p_rmvc; 1180 | 1181 | mp4_box_data_0xa9xxx_t *p_0xa9xxx; 1182 | mp4_box_data_chpl_t *p_chpl; 1183 | mp4_box_data_tref_generic_t *p_tref_generic; 1184 | mp4_box_data_name_t *p_name; 1185 | void *p_data; 1186 | } mp4_box_data_t; 1187 | 1188 | typedef struct mp4_box_s 1189 | { 1190 | int64_t i_pos; 1191 | uint32_t i_type; 1192 | uint32_t i_shortsize; 1193 | uuid_t i_uuid; 1194 | uint64_t i_size; 1195 | mp4_box_data_t data; 1196 | struct mp4_box_s* p_father; 1197 | struct mp4_box_s* p_first; 1198 | struct mp4_box_s* p_last; 1199 | struct mp4_box_s* p_next; 1200 | } mp4_box_t; 1201 | 1202 | mp4_box_t *MP4_BoxGetRoot(stream_t * s); 1203 | mp4_box_t *MP4_BoxGetRootFromBuffer(stream_t * s, unsigned long filesize); 1204 | void MP4_BoxFree( mp4_box_t *box ); 1205 | void MP4_BoxFreeFromBuffer( mp4_box_t *box ); 1206 | static mp4_box_t *MP4_ReadBox(stream_t *s, mp4_box_t *father); 1207 | static mp4_box_t *MP4_ReadBoxFromBuffer(stream_t *s, mp4_box_t *father); 1208 | mp4_box_t *MP4_BoxGet(mp4_box_t *p_box, const char *psz_fmt, ...); 1209 | mp4_box_t * MP4_BoxSearchBox(mp4_box_t *p_head, uint32_t i_type); 1210 | 1211 | #endif // __MP4_H__ 1212 | -------------------------------------------------------------------------------- /mp4parser.c: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Tangxuguo/MP4parser/d9dddc5772934942a650c085b5c9caf6acf69247/mp4parser.c -------------------------------------------------------------------------------- /stdafx.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Tangxuguo/MP4parser/d9dddc5772934942a650c085b5c9caf6acf69247/stdafx.h -------------------------------------------------------------------------------- /stream.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include "stream.h" 7 | #define max(a,b) a>b?a:b 8 | #define min(a,b) a>b?b:a 9 | void* file_open(stream_t *stream_s, const char* filename, int mode) 10 | { 11 | FILE* file = NULL; 12 | const char* mode_fopen = NULL; 13 | if ((mode & MODE_READWRITEFILTER) == MODE_READ) 14 | mode_fopen = "rb"; 15 | else 16 | if (mode & MODE_EXISTING) 17 | mode_fopen = "r+b"; 18 | else 19 | if (mode & MODE_CREATE) 20 | mode_fopen = "wb"; 21 | if ((filename != NULL) && (mode_fopen != NULL)) 22 | file = fopen(filename, mode_fopen); 23 | stream_s->opaque = (void*)file; 24 | 25 | return file; 26 | } 27 | 28 | int file_read(stream_t *stream_s, void* buf, int size) 29 | { 30 | FILE* file = (FILE*)stream_s->opaque; 31 | return fread(buf, 1, size, file); 32 | } 33 | 34 | int file_write(stream_t *stream_s, void *buf, int size) 35 | { 36 | FILE* file = (FILE*)stream_s->opaque; 37 | return fwrite(buf, 1, size, file); 38 | } 39 | 40 | int file_peek(stream_t *stream_s, void* buf, int size) 41 | { 42 | uint32_t offset = file_tell(stream_s); 43 | int ret = file_read(stream_s, buf, size); 44 | file_seek(stream_s, offset, SEEK_SET); 45 | return ret; 46 | } 47 | 48 | uint64_t file_seek(stream_t *stream_s, int64_t offset, int whence) 49 | { 50 | FILE* file = (FILE*)stream_s->opaque; 51 | return fseek(file, offset, whence); 52 | } 53 | 54 | uint64_t file_tell(stream_t *stream_s) 55 | { 56 | FILE* file = (FILE*)stream_s->opaque; 57 | return ftell(file); 58 | } 59 | 60 | int file_close(stream_t *stream_s) 61 | { 62 | FILE* file = (FILE*)stream_s->opaque; 63 | return fclose(file); 64 | } 65 | 66 | void* buffer_open(stream_t *stream_s, BUFFER_t *buffer) 67 | { 68 | stream_s->opaque = (void *)buffer; 69 | 70 | return buffer; 71 | } 72 | 73 | int buffer_read(stream_t *stream_s, void* buf, int size) 74 | { 75 | BUFFER_t *buffer = (BUFFER_t *)stream_s->opaque; 76 | memcpy(buf,buffer->buf,size); 77 | return size; 78 | } 79 | 80 | int buffer_write(stream_t *stream_s, void *buf, int size) 81 | { 82 | BUFFER_t *buffer = (BUFFER_t *)stream_s->opaque; 83 | memcpy(buffer->buf,buf,size); 84 | return size; 85 | } 86 | 87 | int buffer_peek(stream_t *stream_s, void* buf, int size) 88 | { 89 | uint32_t offset = buffer_tell(stream_s); 90 | int ret = buffer_read(stream_s, buf, size); 91 | return ret; 92 | } 93 | 94 | uint64_t buffer_seek(stream_t *stream_s, int64_t offset,\ 95 | int whence) 96 | { 97 | BUFFER_t *buffer = (BUFFER_t *)stream_s->opaque; 98 | (*buffer).offset = whence + offset; 99 | memcpy(buffer->buf,buffer->begin_addr + (*buffer).offset,\ 100 | (*buffer).filesize - (*buffer).offset ); 101 | return 0; 102 | } 103 | 104 | uint64_t buffer_tell(stream_t *stream_s) 105 | { 106 | BUFFER_t *buffer = (BUFFER_t *)stream_s->opaque; 107 | return (*buffer).offset; 108 | } 109 | 110 | int buffer_close(stream_t *stream_s) 111 | { 112 | BUFFER_t *buffer = (BUFFER_t *)stream_s->opaque; 113 | free(buffer->buf); 114 | free(buffer->begin_addr); 115 | free(buffer); 116 | return 0; 117 | } 118 | 119 | stream_t* create_file_stream() 120 | { 121 | stream_t* s = malloc(sizeof(stream_t)); 122 | s->open = file_open; 123 | s->read = file_read; 124 | s->write = file_write; 125 | s->peek = file_peek; 126 | s->seek = file_seek; 127 | s->tell = file_tell; 128 | s->close = file_close; 129 | return s; 130 | } 131 | 132 | void destory_file_stream(stream_t* stream_s) 133 | { 134 | free(stream_s); 135 | } 136 | 137 | stream_t* create_buffer_stream() 138 | { 139 | stream_t* s = malloc(sizeof(stream_t)); 140 | s->open = buffer_open; 141 | s->read = buffer_read; 142 | s->write = buffer_write; 143 | s->peek = buffer_peek; 144 | s->seek = buffer_seek; 145 | s->tell = buffer_tell; 146 | s->close = buffer_close; 147 | return s; 148 | } 149 | 150 | void destory_buffer_stream(stream_t* stream_s) 151 | { 152 | free(stream_s); 153 | } 154 | 155 | stream_t* create_buf_file_stream() 156 | { 157 | buf_stream_t* s = malloc(sizeof(buf_stream_t)); 158 | stream_t* file_s = create_file_stream(); 159 | s->s = *file_s; 160 | destory_file_stream(file_s); 161 | s->s.read = buf_file_read; 162 | s->s.write = buf_file_write; 163 | s->s.peek = buf_file_peek; 164 | s->s.seek = buf_file_seek; 165 | s->s.close = buf_file_close; 166 | s->read_buf_s.buf = malloc(READ_BUFFER_SIZE); 167 | s->read_buf_s.bufsize = -1; 168 | s->read_buf_s.offset = 0; 169 | s->write_buf_s.buf = malloc(WRITE_BUFFER_SIZE); 170 | s->write_buf_s.bufsize = 0; 171 | s->write_buf_s.offset = 0; 172 | s->offset = 0; 173 | return (stream_t*)s; 174 | } 175 | 176 | void destory_buf_file_stream(stream_t* stream_s) 177 | { 178 | buf_stream_t* s = (buf_stream_t*)stream_s; 179 | free(s->read_buf_s.buf); 180 | free(s->write_buf_s.buf); 181 | free(stream_s); 182 | } 183 | 184 | int buf_file_read(stream_t *stream_s, void* buf, int size) 185 | { 186 | buf_stream_t* s = (buf_stream_t*)stream_s; 187 | int length = 0, remainder = 0, position = 0; 188 | 189 | while (size > 0) 190 | { 191 | int read_bytes = 0; 192 | if (s->read_buf_s.offset > s->offset || 193 | s->read_buf_s.offset + s->read_buf_s.bufsize <= s->offset || 194 | s->read_buf_s.bufsize == -1) 195 | { 196 | int read_bytes, ret; 197 | // �ȶ�λ��offset, �ٽ��ж�����. 198 | ret = file_seek(stream_s, s->offset, SEEK_SET); 199 | if (ret != 0) 200 | { 201 | assert(0); 202 | return ret; // ERROR!!! 203 | } 204 | read_bytes = file_read(stream_s, s->read_buf_s.buf, READ_BUFFER_SIZE); 205 | if (read_bytes < 0) 206 | return read_bytes; // ERROR!!! 207 | if (read_bytes == 0) 208 | return length; 209 | if (s->read_buf_s.bufsize == -1) 210 | s->read_buf_s.offset = s->offset; 211 | else 212 | s->read_buf_s.offset += s->read_buf_s.bufsize; 213 | s->read_buf_s.bufsize = read_bytes; 214 | } 215 | 216 | position = s->offset - s->read_buf_s.offset; 217 | remainder = s->read_buf_s.bufsize - position; 218 | read_bytes = min(size, remainder); 219 | 220 | memcpy((char*)buf + length, 221 | (char*)s->read_buf_s.buf + position, read_bytes); 222 | 223 | length += read_bytes; 224 | position += read_bytes; 225 | size -= read_bytes; 226 | remainder -= read_bytes; 227 | s->offset += read_bytes; 228 | } 229 | 230 | return length; 231 | } 232 | 233 | int buf_file_write(stream_t *stream_s, void *buf, int size) 234 | { 235 | buf_stream_t* s = (buf_stream_t*)stream_s; 236 | int write_bytes = 0; 237 | 238 | if (s->write_buf_s.offset + s->write_buf_s.bufsize == s->offset && 239 | s->write_buf_s.bufsize + size < WRITE_BUFFER_SIZE) 240 | { 241 | memcpy((char*)s->write_buf_s.buf + s->write_buf_s.bufsize, buf, size); 242 | s->write_buf_s.bufsize += size; 243 | s->offset += size; 244 | return size; 245 | } 246 | 247 | if (s->write_buf_s.bufsize != 0) 248 | { 249 | int ret = file_seek(stream_s, s->write_buf_s.offset, SEEK_SET); 250 | if (ret != 0) 251 | return ret; 252 | write_bytes = 0; 253 | while (write_bytes != s->write_buf_s.bufsize) 254 | { 255 | int n = file_write(stream_s, (char*)s->write_buf_s.buf + write_bytes, 256 | s->write_buf_s.bufsize - write_bytes); 257 | if (n < 0) 258 | return n; 259 | write_bytes += n; 260 | } 261 | s->write_buf_s.bufsize = 0; 262 | } 263 | 264 | if (size > WRITE_BUFFER_SIZE) 265 | { 266 | int ret = file_seek(stream_s, s->offset, SEEK_SET); 267 | if (ret != 0) 268 | return ret; 269 | write_bytes = 0; 270 | while (write_bytes != size) 271 | { 272 | int n = file_write(stream_s, (char*)buf + write_bytes, size - write_bytes); 273 | if (n < 0) 274 | return n; 275 | write_bytes += n; 276 | } 277 | s->offset += size; 278 | return write_bytes; 279 | } 280 | else 281 | { 282 | memcpy(s->write_buf_s.buf, buf, size); 283 | s->write_buf_s.offset = s->offset; 284 | s->offset += size; 285 | s->write_buf_s.bufsize = size; 286 | return size; 287 | } 288 | } 289 | 290 | int buf_file_peek(stream_t *stream_s, void* buf, int size) 291 | { 292 | buf_stream_t* s = (buf_stream_t*)stream_s; 293 | int ret = 0; 294 | int len = 0; 295 | 296 | ret = file_seek(stream_s, s->offset, SEEK_SET); 297 | if (ret != 0) 298 | return ret; 299 | 300 | len = file_read(stream_s, buf, size); 301 | ret = file_seek(stream_s, s->offset, SEEK_SET); 302 | if (ret != 0) 303 | return ret; 304 | 305 | return len; 306 | } 307 | 308 | uint64_t buf_file_seek(stream_t *stream_s, int64_t offset, int whence) 309 | { 310 | buf_stream_t* s = (buf_stream_t*)stream_s; 311 | uint64_t ret = 0; 312 | ret = file_seek(stream_s, s->offset, SEEK_SET); 313 | if (ret != 0) 314 | return ret; 315 | ret = file_seek(stream_s, offset, whence); 316 | if (ret != 0) 317 | return ret; 318 | s->offset = file_tell(stream_s); 319 | if (s->read_buf_s.offset > s->offset || 320 | s->read_buf_s.offset + s->read_buf_s.bufsize <= s->offset) 321 | s->read_buf_s.bufsize = -1; 322 | else 323 | s->read_buf_s.offset = s->offset; 324 | return ret; 325 | } 326 | 327 | int buf_file_close(stream_t *stream_s) 328 | { 329 | buf_stream_t* s = (buf_stream_t*)stream_s; 330 | int write_bytes = 0; 331 | 332 | if (s->write_buf_s.bufsize != 0) 333 | { 334 | int ret = file_seek(stream_s, s->write_buf_s.offset, SEEK_SET); 335 | if (ret != 0) 336 | return ret; 337 | write_bytes = 0; 338 | while (write_bytes != s->write_buf_s.bufsize) 339 | { 340 | int n = file_write(stream_s, (char*)s->write_buf_s.buf + write_bytes, 341 | s->write_buf_s.bufsize - write_bytes); 342 | if (n < 0) 343 | return n; 344 | write_bytes += n; 345 | } 346 | s->write_buf_s.bufsize = 0; 347 | } 348 | 349 | return file_close(stream_s); 350 | } 351 | 352 | 353 | 354 | uint16_t Swap16(uint16_t x) 355 | { 356 | return ((x<<8)|(x>>8)); 357 | } 358 | 359 | uint32_t Swap32(uint32_t x) 360 | { 361 | return((x<<24)|((x<<8)&0x00FF0000)|((x>>8)&0x0000FF00)|(x>>24)); 362 | } 363 | 364 | uint64_t Swap64(uint64_t x) 365 | { 366 | uint32_t hi, lo; 367 | 368 | /* Separate into high and low 32-bit values and swap them */ 369 | lo = (uint32_t)(x & 0xFFFFFFFF); 370 | x >>= 32; 371 | hi = (uint32_t)(x & 0xFFFFFFFF); 372 | x = Swap32(lo); 373 | x <<= 32; 374 | x |= Swap32(hi); 375 | return(x); 376 | } 377 | 378 | uint16_t read_le16(stream_t *src) 379 | { 380 | uint16_t value; 381 | 382 | stream_read(src, &value, sizeof(value)); 383 | return(SwapLE16(value)); 384 | } 385 | 386 | uint16_t read_be16(stream_t *src) 387 | { 388 | uint16_t value; 389 | 390 | stream_read(src, &value, sizeof(value)); 391 | return(SwapBE16(value)); 392 | } 393 | 394 | uint32_t read_le32(stream_t *src) 395 | { 396 | uint32_t value; 397 | 398 | stream_read(src, &value, sizeof(value)); 399 | return(SwapLE32(value)); 400 | } 401 | 402 | uint32_t read_be32(stream_t *src) 403 | { 404 | uint32_t value; 405 | 406 | stream_read(src, &value, sizeof(value)); 407 | return(SwapBE32(value)); 408 | } 409 | 410 | uint64_t read_le64(stream_t *src) 411 | { 412 | uint64_t value; 413 | 414 | stream_read(src, &value, sizeof(value)); 415 | return(SwapLE64(value)); 416 | } 417 | 418 | uint64_t read_be64(stream_t *src) 419 | { 420 | uint64_t value; 421 | 422 | stream_read(src, &value, sizeof(value)); 423 | return(SwapBE64(value)); 424 | } 425 | 426 | int write_le16(stream_t *dst, uint16_t value) 427 | { 428 | value = SwapLE16(value); 429 | return(stream_write(dst, &value, sizeof(value))); 430 | } 431 | 432 | int write_be16(stream_t *dst, uint16_t value) 433 | { 434 | value = SwapBE16(value); 435 | return(stream_write(dst, &value, sizeof(value))); 436 | } 437 | 438 | int write_le32(stream_t *dst, uint32_t value) 439 | { 440 | value = SwapLE32(value); 441 | return(stream_write(dst, &value, sizeof(value))); 442 | } 443 | 444 | int write_be32(stream_t *dst, uint32_t value) 445 | { 446 | value = SwapBE32(value); 447 | return(stream_write(dst, &value, sizeof(value))); 448 | } 449 | 450 | int write_le64(stream_t *dst, uint64_t value) 451 | { 452 | value = SwapLE64(value); 453 | return(stream_write(dst, &value, sizeof(value))); 454 | } 455 | 456 | int write_be64(stream_t *dst, uint64_t value) 457 | { 458 | value = SwapBE64(value); 459 | return(stream_write(dst, &value, sizeof(value))); 460 | } 461 | -------------------------------------------------------------------------------- /stream.h: -------------------------------------------------------------------------------- 1 | #ifndef __STREAM_H__ 2 | #define __STREAM_H__ 3 | 4 | // ���Ͷ���. 5 | #ifndef _STDINT_H 6 | typedef signed char int8_t; 7 | typedef unsigned char uint8_t; 8 | typedef short int16_t; 9 | typedef unsigned short uint16_t; 10 | typedef int int32_t; 11 | typedef unsigned uint32_t; 12 | typedef long long int64_t; 13 | typedef unsigned long long uint64_t; 14 | //typedef unsigned long size_t; 15 | #endif 16 | 17 | // �򿪷�ʽ. 18 | #define MODE_READ (1) 19 | #define MODE_WRITE (2) 20 | #define MODE_READWRITEFILTER (3) 21 | #define MODE_EXISTING (4) 22 | #define MODE_CREATE (8) 23 | 24 | // ��д�ṹ����. 25 | typedef struct stream { 26 | void* (*open)(struct stream *stream_s, const char* filename, int mode); 27 | int (*read)(struct stream *stream_s, void* buf, int size); 28 | int (*write)(struct stream *stream_s, void *buf, int size); 29 | int (*peek)(struct stream *stream_s, void* buf, int size); 30 | uint64_t (*seek)(struct stream *stream_s, int64_t offset, int whence); 31 | uint64_t (*tell)(struct stream *stream_s); 32 | int (*close)(struct stream *stream_s); 33 | void* opaque; 34 | } stream_t; 35 | 36 | // ��д�궨��. 37 | #define stream_open(s, filename, mode) ((stream_t*)s)->open(((stream_t*)s), filename, mode) 38 | #define stream_read(s, buf, size) ((stream_t*)s)->read(((stream_t*)s), buf, size) 39 | #define stream_write(s, buf, size) ((stream_t*)s)->write(((stream_t*)s), buf, size) 40 | #define stream_peek(s, buf, size) ((stream_t*)s)->peek(((stream_t*)s), buf, size) 41 | #define stream_seek(s, offset, whence) ((stream_t*)s)->seek(((stream_t*)s), offset, whence) 42 | #define stream_tell(s) ((stream_t*)s)->tell(((stream_t*)s)) 43 | #define stream_close(s) ((stream_t*)s)->close(((stream_t*)s)) 44 | 45 | // �ļ���д. 46 | void* file_open(stream_t *stream_s, const char* filename, int mode); 47 | int file_read(stream_t *stream_s, void* buf, int size); 48 | int file_write(stream_t *stream_s, void *buf, int size); 49 | int file_peek(stream_t *stream_s, void* buf, int size); 50 | uint64_t file_seek(stream_t *stream_s, int64_t offset, int whence); 51 | uint64_t file_tell(stream_t *stream_s); 52 | int file_close(stream_t *stream_s); 53 | 54 | // �����ļ���д��. 55 | stream_t* create_file_stream(); 56 | void destory_file_stream(stream_t* stream_s); 57 | 58 | typedef struct BUFFER { 59 | unsigned char *buf; 60 | unsigned char *begin_addr; 61 | unsigned long offset; 62 | unsigned long filesize; 63 | }BUFFER_t; 64 | 65 | //read data form buffer,not binary file 66 | void* buffer_open(stream_t *stream_s, BUFFER_t *buffer); 67 | int buffer_read(stream_t *stream_s, void* buf, int size); 68 | int buffer_write(stream_t *stream_s, void *buf, int size); 69 | int buffer_peek(stream_t *stream_s, void* buf, int size); 70 | uint64_t buffer_seek(stream_t *stream_s, int64_t offset, int whence); 71 | uint64_t buffer_tell(stream_t *stream_s); 72 | int buffer_close(stream_t *stream_s); 73 | 74 | stream_t* create_buffer_stream(); 75 | void destory_buffer_stream(stream_t* stream_s); 76 | 77 | // һ�����д������ļ�streamʵ��. 78 | #define READ_BUFFER_SIZE 10485760 79 | #define WRITE_BUFFER_SIZE 10485760 80 | 81 | typedef struct buf_stream { 82 | stream_t s; 83 | 84 | struct read_buf { 85 | void* buf; // ������. 86 | int64_t bufsize; // �����С. 87 | int64_t offset; // ���ļ��е�offset. 88 | } read_buf_s; 89 | 90 | struct write_buf { 91 | void* buf; // д����. 92 | int64_t bufsize; // �����С. 93 | int64_t offset; // д�ļ���offset. 94 | } write_buf_s; 95 | 96 | uint64_t offset; // ��ǰ��дָ�����ļ��е�offset. 97 | 98 | } buf_stream_t; 99 | 100 | // ���Ķ�дʵ��. 101 | int buf_file_read(stream_t *stream_s, void* buf, int size); 102 | int buf_file_write(stream_t *stream_s, void *buf, int size); 103 | int buf_file_peek(stream_t *stream_s, void* buf, int size); 104 | uint64_t buf_file_seek(stream_t *stream_s, int64_t offset, int whence); 105 | int buf_file_close(stream_t *stream_s); 106 | 107 | // ���������ļ���д��. 108 | stream_t* create_buf_file_stream(); 109 | void destory_buf_file_stream(stream_t* stream_s); 110 | 111 | // ��С�˶�д����ʵ��. 112 | #define LIL_ENDIAN 1234 113 | #define BIG_ENDIAN 4321 114 | /* #define BYTEORDER 1234 ? ���������ϵͳ�����жϴ�С��. */ 115 | 116 | #ifndef BYTEORDER 117 | #if defined(__hppa__) || \ 118 | defined(__m68k__) || defined(mc68000) || defined(_M_M68K) || \ 119 | (defined(__MIPS__) && defined(__MISPEB__)) || \ 120 | defined(__ppc__) || defined(__POWERPC__) || defined(_M_PPC) || \ 121 | defined(__sparc__) 122 | #define BYTEORDER BIG_ENDIAN 123 | #else 124 | #define BYTEORDER LIL_ENDIAN 125 | #endif 126 | #endif /* !BYTEORDER */ 127 | 128 | uint16_t Swap16(uint16_t x); 129 | uint32_t Swap32(uint32_t x); 130 | uint64_t Swap64(uint64_t x); 131 | 132 | #if BYTEORDER == LIL_ENDIAN 133 | #define SwapLE16(X) (X) 134 | #define SwapLE32(X) (X) 135 | #define SwapLE64(X) (X) 136 | #define SwapBE16(X) Swap16(X) 137 | #define SwapBE32(X) Swap32(X) 138 | #define SwapBE64(X) Swap64(X) 139 | #else 140 | #define SwapLE16(X) Swap16(X) 141 | #define SwapLE32(X) Swap32(X) 142 | #define SwapLE64(X) Swap64(X) 143 | #define SwapBE16(X) (X) 144 | #define SwapBE32(X) (X) 145 | #define SwapBE64(X) (X) 146 | #endif 147 | 148 | uint16_t read_le16(stream_t *src); 149 | uint16_t read_be16(stream_t *src); 150 | uint32_t read_le32(stream_t *src); 151 | uint32_t read_be32(stream_t *src); 152 | uint64_t read_le64(stream_t *src); 153 | uint64_t read_be64(stream_t *src); 154 | 155 | int write_le16(stream_t *dst, uint16_t value); 156 | int write_be16(stream_t *dst, uint16_t value); 157 | int write_le32(stream_t *dst, uint32_t value); 158 | int write_be32(stream_t *dst, uint32_t value); 159 | int write_le64(stream_t *dst, uint64_t value); 160 | int write_be64(stream_t *dst, uint64_t value); 161 | 162 | #endif // __STREAM_H__ 163 | --------------------------------------------------------------------------------