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

源码开发语言/平台
当前位置：首页 > 电子书籍 > VC书籍 > 查看源码
MP4_VLD.C
资源名称：VC++视频传输.rar　[点击查看]
上传用户：hxb_1234
上传日期：2010-03-30
资源大小：8328k
文件大小：7k
源码类别：

VC书籍

开发平台：

Visual C++

MP4_VLD.C：源码内容
  3. #include <stdio.h>
  5. #include "mp4_vars.h"
  7. #include "getbits.h"
  8. #include "mp4_vld.h"
  10. /**
  11.  * 
  12. **/
  14. /***/
  16. event_t vld_intra_dct() 
  17. {
  18. event_t event;
  19. tab_type *tab = (tab_type *) NULL;
  20. int lmax, rmax;
  22. tab = vldTableB16(showbits(12));
  23. if (!tab) { 
  24. event.run   = 
  25. event.level = 
  26. event.last  = -1;
  27. return event;
  28. } 
  30. if (tab->val != ESCAPE) {
  31. event.run   = (tab->val >>  6) & 63;
  32. event.level =  tab->val        & 63;
  33. event.last  = (tab->val >> 12) &  1;
  34. event.level = getbits(1) ? -event.level : event.level;
  35. } else {
  37. switch (showbits(2)) {
  38. case 0x0 :  
  39. case 0x1 :  
  40. flushbits(1);
  41. tab = vldTableB16(showbits(12));  
  42. if (!tab) { 
  43. event.run   = 
  44. event.level = 
  45. event.last  = -1;
  46. return event;
  47. }
  48. event.run   = (tab->val >>  6) & 63;
  49. event.level =  tab->val        & 63;
  50. event.last  = (tab->val >> 12) &  1;
  51. lmax = vldTableB19(event.last, event.run);  
  52. event.level += lmax;
  53. event.level =  getbits(1) ? -event.level : event.level;
  54. break;
  55. case 0x2 :  
  56. flushbits(2);
  57. tab = vldTableB16(showbits(12));  
  58. if (!tab) { 
  59. event.run   = 
  60. event.level = 
  61. event.last  = -1;
  62. break;
  63. }
  64. event.run   = (tab->val >>  6) & 63;
  65. event.level =  tab->val        & 63;
  66. event.last  = (tab->val >> 12) &  1;
  67. rmax = vldTableB21(event.last, event.level);  
  68. event.run = event.run + rmax + 1;
  69. event.level = getbits(1) ? -event.level : event.level;
  70. break;
  71. case 0x3 :  
  72. flushbits(2);
  73. event.last  = getbits(1);
  74. event.run   = getbits(6);  
  75. getbits(1); 
  76. event.level = getbits(12); 
  78. event.level = (event.level & 0x800) ? (event.level | (-1 ^ 0xfff)) : event.level;
  79. getbits(1); 
  80. break;
  81. }
  82. }
  84. return event;
  85. }
  87. /***/
  89. event_t vld_inter_dct() 
  90. {
  91. event_t event;
  92. tab_type *tab = (tab_type *) NULL;
  93. int lmax, rmax;
  95. tab = vldTableB17(showbits(12));
  96. if (!tab) { 
  97. event.run   = 
  98. event.level = 
  99. event.last  = -1;
  100. return event;
  101. } 
  102. if (tab->val != ESCAPE) {
  103. event.run   = (tab->val >>  4) & 255;
  104. event.level =  tab->val        & 15;
  105. event.last  = (tab->val >> 12) &  1;
  106. event.level = getbits(1) ? -event.level : event.level;
  107. } else {
  109. int mode = showbits(2);
  110. switch (mode) {
  111. case 0x0 :  
  112. case 0x1 : 
  113. flushbits(1);
  114. tab = vldTableB17(showbits(12));  
  115. if (!tab) { 
  116. event.run   = 
  117. event.level = 
  118. event.last  = -1;
  119. return event;
  120. }
  121. event.run   = (tab->val >>  4) & 255;
  122. event.level =  tab->val        & 15;
  123. event.last  = (tab->val >> 12) &  1;
  124. lmax = vldTableB20(event.last, event.run);  
  125. event.level += lmax;
  126. event.level = getbits(1) ? -event.level : event.level;
  127. break;
  128. case 0x2 :  
  129. flushbits(2);
  130. tab = vldTableB17(showbits(12));  
  131. if (!tab) { 
  132. event.run   = 
  133. event.level = 
  134. event.last  = -1;
  135. break;
  136. }
  137. event.run   = (tab->val >>  4) & 255;
  138. event.level =  tab->val        & 15;
  139. event.last  = (tab->val >> 12) &  1;
  140. rmax = vldTableB22(event.last, event.level);  
  141. event.run = event.run + rmax + 1;
  142. event.level = getbits(1) ? -event.level : event.level;
  143. break;
  144. case 0x3 : 
  145. flushbits(2);
  146. event.last  = getbits(1);
  147. event.run   = getbits(6);   
  148. getbits(1); 
  149. event.level = getbits(12); 
  151. event.level = (event.level & 0x800) ? (event.level | (-1 ^ 0xfff)) : event.level;
  152. getbits(1); 
  153. break;
  154. }
  155. }
  157. return event;
  158. }
  160. /***/
  162. event_t vld_event(int intraFlag) 
  163. {
  164. if (intraFlag) {
  165. return vld_intra_dct();
  166. } else {
  167. return vld_inter_dct();
  168. }
  169. }
  171. /***/
  174. int vldTableB19(int last, int run) {
  175. if (!last){ 
  176. if        (run ==  0) {
  177. return 27;
  178. } else if (run ==  1) {
  179. return 10;
  180. } else if (run ==  2) {
  181. return  5;
  182. } else if (run ==  3) {
  183. return  4;
  184. } else if (run <=  7) {
  185. return  3;
  186. } else if (run <=  9) {
  187. return  2;
  188. } else if (run <= 14) {
  189. return  1;
  190. } else { 
  191. return  0; 
  192. }
  193. } else {    
  194. if        (run ==  0) {
  195. return  8;
  196. } else if (run ==  1) {
  197. return  3;
  198. } else if (run <=  6) {
  199. return  2;
  200. } else if (run <= 20) {
  201. return  1;
  202. } else { 
  203. return  0; 
  204. }
  205. }
  206. }
  208. /***/
  211. int vldTableB20(int last, int run) {
  212. if (!last){ 
  213. if        (run ==  0) {
  214. return 12;
  215. } else if (run ==  1) {
  216. return  6;
  217. } else if (run ==  2) {
  218. return  4;
  219. } else if (run <=  6) {
  220. return  3;
  221. } else if (run <= 10) {
  222. return  2;
  223. } else if (run <= 26) {
  224. return  1;
  225. } else {
  226. return  0; 
  227. }
  228. } else {   
  229. if        (run ==  0) {
  230. return  3;
  231. } else if (run ==  1) {
  232. return  2;
  233. } else if (run <= 40) {
  234. return  1;
  235. } else { 
  236. return  0; 
  237. }
  238. }
  239. }
  241. /***/
  244. int vldTableB21(int last, int level) {
  245. if (!last){ 
  246. if        (level ==  1) {
  247. return 14;
  248. } else if (level ==  2) {
  249. return  9;
  250. } else if (level ==  3) {
  251. return  7;
  252. } else if (level ==  4) {
  253. return  3;
  254. } else if (level ==  5) {
  255. return  2;
  256. } else if (level <= 10) {
  257. return  1;
  258. } else if (level <= 27) {
  259. return  0;
  260. } else { 
  261. return  0; 
  262. }
  263. } else {   
  264. if        (level ==  1) {
  265. return  20;
  266. } else if (level ==  2) {
  267. return  6;
  268. } else if (level ==  3) {
  269. return  1;
  270. } else if (level <=  8) {
  271. return  0;
  272. } else { 
  273. return  0; 
  274. }
  275. }
  276. }
  278. /***/
  281. int vldTableB22(int last, int level) {
  282. if (!last){ /* LAST == 0 */
  283. if        (level ==  1) {
  284. return 26;
  285. } else if (level ==  2) {
  286. return 10;
  287. } else if (level ==  3) {
  288. return  6;
  289. } else if (level ==  4) {
  290. return  2;
  291. } else if (level <=  6) {
  292. return  1;
  293. } else if (level <= 12) {
  294. return  0;
  295. } else { 
  296. return  0; 
  297. }
  298. } else {   
  299. if        (level ==  1) {
  300. return  40;
  301. } else if (level ==  2) {
  302. return  1;
  303. } else if (level ==  3) {
  304. return  0;
  305. } else { 
  306. return  0; 
  307. }
  308. }
  309. }
  311. /***/
  313. tab_type *vldTableB16(int code) {
  314. tab_type *tab;
  316. if (code >= 512) {
  317. tab = &(mp4_tables->tableB16_1[(code >> 5) - 16]);
  318. } else if (code >= 128) {
  319. tab = &(mp4_tables->tableB16_2[(code >> 2) - 32]);
  320. } else if (code >= 8) {
  321. tab = &(mp4_tables->tableB16_3[(code >> 0) - 8]);
  322. } else {
  324. return (tab_type *) NULL;
  325. }
  326. flushbits(tab->len);
  327. return tab;
  328. }
  330. /***/
  332. tab_type *vldTableB17(int code) {
  333. tab_type *tab;
  335. if (code >= 512) {
  336. tab = &(mp4_tables->tableB17_1[(code >> 5) - 16]);
  337. } else if (code >= 128) {
  338. tab = &(mp4_tables->tableB17_2[(code >> 2) - 32]);
  339. } else if (code >= 8) {
  340. tab = &(mp4_tables->tableB17_3[(code >> 0) - 8]);
  341. } else {
  343. return (tab_type *) NULL;
  344. }
  345. flushbits(tab->len);
  346. return tab;
  347. }
  349. /***/