使用mp4v2将h264和aac封装成mp4

admin

1. #include<stdio.h>
   
2. #include<stdint.h>
   
3. #include "mp4v2/mp4v2.h"
   
4. #include"AacADTSHeader.h"
   
5. #include"NaluParse.h"
   
6. uint16_t  GetDecoderSpecificInfo(uint8_t audioObjectType, uint8_t sampleRateIndex, uint8_t channelNumber)
   
7. {
   
8.         uint16_t decoderSpecificInfo = 0;
   
9.         uint8_t* p = (uint8_t*)&decoderSpecificInfo;
   
10.         p[0] = ((audioObjectType << 3) & 0xf8) | ((sampleRateIndex >> 1) & 0x07);
    
11.         p[1] = ((sampleRateIndex << 7) & 0x80) | ((channelNumber << 3) & 0x70);
    
12.         return decoderSpecificInfo;
    
13. }
    
14. 
    
15. int main(int argc, char* argv[])
    
16. {
    
17.         MP4FileHandle mp4 = NULL;
    
18.         FILE* h264=NULL;
    
19.         FILE* aac = NULL;
    
20.         MP4TrackId videoTrack = MP4_INVALID_TRACK_ID;
    
21.         MP4TrackId audioTrack = MP4_INVALID_TRACK_ID;
    
22.         try {
    
23.                 AC::NaluParse naluParse;
    
24.                 AC::Nalu nalu;
    
25.                 AC::AacADTSHeader adtsHeader;
    
26.                 unsigned char bufferFull[1028];
    
27.                 unsigned char* buf = bufferFull + 4;
    
28.                 int size;
    
29.                 int naluType;
    
30.                 unsigned char* aacData;
    
31.                 int aacDataLength;
    
32.                 int width = 576;
    
33.                 int height = 320;
    
34.                 double frameRate = 29.97;
    
35.                 int timeScale = 90000;
    
36.                 int sampling_frequency_set[] = { 6000   ,88200  ,64000  ,48000  ,44100  ,32000  ,24000  ,22050  ,16000  ,12000  , 11025 , 8000  , 7350 };
    
37.                 mp4 = MP4Create("test.mp4", 0);
    
38.                 if (mp4 == MP4_INVALID_FILE_HANDLE)
    
39.                 {
    
40.                         throw std::exception("Create mp4 handle fialed.\n");
    
41.                 }
    
42.                 h264 = fopen("test.h264", "rb+");
    
43.                 if (!h264)
    
44.                 {
    
45.                         throw std::exception("Opene h264 handle fialed.\n");
    
46. 
    
47.                 }
    
48.                 aac = fopen("test.aac", "rb+");
    
49.                 if (!aac)
    
50.                 {
    
51.                         throw std::exception("Opene aac handle fialed.\n");
    
52. 
    
53.                 }
    
54.                 //  Ƶ
    
55.                 while (1)
    
56.                 {
    
57.                         size = fread(buf, 1, 1024, h264);
    
58.                         if (size < 1)
    
59.                                 break;
    
60.                         naluParse.SendH264Stream(buf, size);
    
61.                         while (naluParse.ReceiveNalu(nalu))
    
62.                         {
    
63.                                 bool isIdr = true;
    
64.                                 naluType = nalu.GetData()[0] & 0x1F;
    
65.                                 switch (naluType)
    
66.                                 {
    
67.                                 case 01:
    
68.                                 case 02:
    
69.                                 case 03:
    
70.                                 case 04:
    
71.                                         isIdr = false;
    
72.                                 case 05://idr
    
73.                                 {
    
74.                                         auto pNalu = nalu.GetData();
    
75.                                         pNalu -= 4;
    
76.                                         pNalu[0] = (nalu.GetDataLength() >> 24) & 0xFF;
    
77.                                         pNalu[1] = (nalu.GetDataLength() >> 16) & 0xFF;
    
78.                                         pNalu[2] = (nalu.GetDataLength() >> 8) & 0xFF;
    
79.                                         pNalu[3] = (nalu.GetDataLength() >> 0) & 0xFF;
    
80.                                         if (!MP4WriteSample(mp4, videoTrack, pNalu, nalu.GetDataLength() + 4, MP4_INVALID_DURATION, 0, isIdr))
    
81.                                         {
    
82.                                                 printf("Error:Can't write sample.\n");
    
83.                                         }
    
84.                                 }
    
85.                                 break;
    
86.                                 case 7: // SPS
    
87.                                 {
    
88.                                         if (videoTrack == MP4_INVALID_TRACK_ID)
    
89.                                         {
    
90.                                                 videoTrack = MP4AddH264VideoTrack
    
91.                                                 (mp4,
    
92.                                                         timeScale,
    
93.                                                         timeScale / frameRate,
    
94.                                                         width,
    
95.                                                         height,
    
96.                                                         nalu.GetData()[1],
    
97.                                                         nalu.GetData()[2],
    
98.                                                         nalu.GetData()[3],
    
99.                                                         3);                     // 4 bytes length before each NAL unit
    
100.                                                 if (videoTrack == MP4_INVALID_TRACK_ID)
     
101.                                                 {
     
102.                                                         printf("Error:Can't add track.\n");
     
103.                                                         return -1;
     
104.                                                 }
     
105.                                                 MP4SetVideoProfileLevel(mp4, 0x7F);
     
106.                                                 MP4AddH264SequenceParameterSet(mp4, videoTrack, nalu.GetData(), nalu.GetDataLength());
     
107.                                         }
     
108.                                 }
     
109.                                 break;
     
110.                                 case 8: // PPS
     
111.                                 {
     
112.                                         MP4AddH264PictureParameterSet(mp4, videoTrack, nalu.GetData(), nalu.GetDataLength());
     
113.                                 }
     
114.                                 break;
     
115.                                 }
     
116.                         }
     
117.                 }
     
118.                 //  Ƶ
     
119.                 while (1)
     
120.                 {
     
121.                         int size;
     
122.                         size = fread(buf, 1, 7, aac);
     
123.                         if (size < 7)
     
124.                                 break;
     
125.                         AC::AacADTSParse::BinaryToHeader(buf, adtsHeader);
     
126.                         size = fread(buf, 1, adtsHeader.aac_frame_length - 7, aac);
     
127.                         if (size != adtsHeader.aac_frame_length - 7)
     
128.                         {
     
129.                                 throw std::exception("incorrect length!");
     
130.                         }
     
131.                         if (adtsHeader.protection_absent == 0)
     
132.                                 //  У  λ
     
133.                         {
     
134.                                 aacData = buf + 2;
     
135.                                 aacDataLength = size - 2;
     
136.                                 //TODO      У  λbuffer[0]  buffer[1]
     
137.                         }
     
138.                         else
     
139.                         {
     
140.                                 aacData = buf;
     
141.                                 aacDataLength = size;
     
142.                         }
     
143.                         //TODO      ȡ  aac    aacData  aacDataLength
     
144.                         if (audioTrack == MP4_INVALID_TRACK_ID)
     
145.                         {
     
146.                                 audioTrack = MP4AddAudioTrack(mp4, sampling_frequency_set[adtsHeader.sampling_frequency_index], 1024, MP4_MPEG4_AUDIO_TYPE);
     
147.                                 if (audioTrack == MP4_INVALID_TRACK_ID)
     
148.                                 {
     
149.                                         throw std::exception("Add audio track failed!");
     
150.                                 }
     
151.                                 MP4SetAudioProfileLevel(mp4, 0x02);
     
152.                                 auto config = GetDecoderSpecificInfo(adtsHeader.profile + 1, adtsHeader.sampling_frequency_index, adtsHeader.channel_configuration);
     
153.                                 if (!MP4SetTrackESConfiguration(mp4, audioTrack, (uint8_t*)&config, 2))
     
154.                                 {
     
155.                                         throw std::exception("set config failed!");
     
156.                                 }
     
157.                         }
     
158.                         MP4WriteSample(mp4, audioTrack, aacData, aacDataLength, MP4_INVALID_DURATION, 0, 1);
     
159.                 }
     
160.         }
     
161.         catch (const std::exception& e)
     
162.         {
     
163.                 printf("%s,\n", e.what());
     
164.         }
     
165.         if (aac)
     
166.                 fclose(aac);
     
167.         if (h264)
     
168.                 fclose(h264);
     
169.         if (mp4)
     
170.                 MP4Close(mp4);
     
171.         return 0;
     
172. }
     
173. /*FILE* f = fopen("test_music.aac", "rb+");
     
174. uint8_t buffer[1024];
     
175. AC::AacADTSHeader h;
     
176. while (1)
     
177. {
     
178.         int size;
     
179.         size = fread(buffer, 1, 7, f);
     
180.         if (size < 7)
     
181.                 break;
     
182.         h.LoadtData(buffer);
     
183.         h.SaveData(buffer);
     
184.         AC::AacADTSHeader h2;
     
185.         h2.LoadtData(buffer);
     
186.         size = fread(buffer, 1, h2.GetAacFrameLength() - 7, f);
     
187.         if (size != h2.GetAacFrameLength() - 7)
     
188.         {
     
189.                 throw;
     
190.         }
     
191. 
     
192. }*/
     
193. 
     
194. 
     
195. //int main(int argc, char* argv[])
     
196. //{
     
197. //        GdiScreenCaptureTest();
     
198. //        MP4FileHandle pHandle = NULL;
     
199. //        FILE* f;
     
200. //        MP4TrackId videoId = MP4_INVALID_TRACK_ID;
     
201. //
     
202. //        int width = 1920;
     
203. //        int height = 1080;
     
204. //        int frameRate = 20;
     
205. //        int timeScale = 90000;
     
206. //        unsigned char fullBuffer[8196] = {0,0,0,0,0};
     
207. //        unsigned char *buffer= fullBuffer+4;
     
208. //        unsigned char* pNalu;
     
209. //        unsigned char naluType;
     
210. //        bool isIdr = true;
     
211. //        f = fopen("test.h264", "rb+");
     
212. //        if (!f)
     
213. //        {
     
214. //                printf("ERROR:Open h264 file fialed.\n");
     
215. //                return -1;
     
216. //        }
     
217. //        for (int i = 1; i <= 8192; i++)
     
218. //        {
     
219. //
     
220. //                AC::NaluParse parse;
     
221. //                pHandle = MP4Create("test1.mp4", 0);
     
222. //                if (pHandle == MP4_INVALID_FILE_HANDLE)
     
223. //                {
     
224. //                        printf("ERROR:Create mp4 handle fialed.\n");
     
225. //                        return -1;
     
226. //                }
     
227. //                while (1)
     
228. //                {
     
229. //                        int size = fread(buffer, 1, i, f);
     
230. //                        if (size < 1)
     
231. //                        {
     
232. //                                break;
     
233. //                        }
     
234. //                        parse.SendH264Stream(buffer, size);
     
235. //                        AC::Nalu nalu;
     
236. //                        while (parse.ReceiveNalu(nalu))
     
237. //                        {
     
238. //                                pNalu = nalu.GetData();
     
239. //                                naluType = pNalu[0] & 0x1F;
     
240. //                                switch (naluType)
     
241. //                                {
     
242. //                                case 01:
     
243. //                                case 02:
     
244. //                                case 03:
     
245. //                                case 04:
     
246. //                                        isIdr = false;
     
247. //                                case 05://idr
     
248. //                                {
     
249. //                                        pNalu -= 4;
     
250. //                                        pNalu[0] = (nalu.GetDataLength() >> 24) & 0xFF;
     
251. //                                        pNalu[1] = (nalu.GetDataLength() >> 16) & 0xFF;
     
252. //                                        pNalu[2] = (nalu.GetDataLength() >> 8) & 0xFF;
     
253. //                                        pNalu[3] = (nalu.GetDataLength() >> 0) & 0xFF;
     
254. //                                        if (!MP4WriteSample(pHandle, videoId, pNalu, nalu.GetDataLength() + 4, MP4_INVALID_DURATION, 0, isIdr))
     
255. //                                        {
     
256. //                                                printf("Error:Can't write sample.\n");
     
257. //                                        }
     
258. //                                        isIdr = true;
     
259. //                                }
     
260. //                                break;
     
261. //                                case 7: // SPS
     
262. //                                {
     
263. //                                        if (videoId == MP4_INVALID_TRACK_ID)
     
264. //                                        {
     
265. //                                                videoId = MP4AddH264VideoTrack
     
266. //                                                (pHandle,
     
267. //                                                        timeScale,
     
268. //                                                        timeScale / frameRate,
     
269. //                                                        width,
     
270. //                                                        height,
     
271. //                                                        pNalu[1],
     
272. //                                                        pNalu[2],
     
273. //                                                        pNalu[3],
     
274. //                                                        3);
     
275. //                                                if (videoId == MP4_INVALID_TRACK_ID)
     
276. //                                                {
     
277. //                                                        printf("Error:Can't add track.\n");
     
278. //                                                        return -1;
     
279. //                                                }
     
280. //                                                MP4AddH264SequenceParameterSet(pHandle, videoId, pNalu, nalu.GetDataLength());
     
281. //                                        }
     
282. //                                }
     
283. //                                break;
     
284. //                                case 8: // PPS
     
285. //                                {
     
286. //                                        MP4AddH264PictureParameterSet(pHandle, videoId, pNalu, nalu.GetDataLength());
     
287. //                                }
     
288. //                                break;
     
289. //                                default:
     
290. //                                        break;
     
291. //                                }
     
292. //                        }
     
293. //                }
     
294. //                MP4Close(pHandle);
     
295. //                fseek(f, 0, SEEK_SET);
     
296. //                videoId = MP4_INVALID_TRACK_ID;
     
297. //                if (!FileHelper::Compare("test.mp4", "test1.mp4"))
     
298. //                {
     
299. //                        throw "error";
     
300. //                }
     
301. //        }
     
302. //
     
303. //        return 0;
     
304. //
     
305. //
     
306. //
     
307. //        try {
     
308. //                WNDCLASS wndclass;
     
309. //                wndclass.style = CS_HREDRAW | CS_VREDRAW;
     
310. //                wndclass.lpfnWndProc = WndProc;
     
311. //                wndclass.cbClsExtra = 0;
     
312. //                wndclass.cbWndExtra = 0;
     
313. //                wndclass.hInstance = GetModuleHandle(NULL);
     
314. //                wndclass.hIcon = LoadIcon(NULL, IDI_APPLICATION);
     
315. //                wndclass.hCursor = LoadCursor(NULL, IDC_ARROW);
     
316. //                wndclass.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
     
317. //                wndclass.lpszMenuName = 0;
     
318. //                wndclass.lpszClassName = L"DemoWindow";
     
319. //                if (!RegisterClass(&wndclass))
     
320. //                {
     
321. //                        MessageBox(NULL, TEXT("        ʧ  !"), L"", MB_ICONERROR);
     
322. //                }
     
323. //                auto title = L"       ";
     
324. //                HWND        hwnd = CreateWindow(
     
325. //                        L"DemoWindow",
     
326. //                        title,
     
327. //                        WS_OVERLAPPEDWINDOW,
     
328. //                        0,
     
329. //                        0,
     
330. //                        1280,
     
331. //                        720,
     
332. //                        NULL,
     
333. //                        NULL,
     
334. //                        GetModuleHandle(NULL),
     
335. //                        NULL
     
336. //                );
     
337. //                ShowWindow(hwnd, SW_SHOW);
     
338. //
     
339. //                AC::SdlVideoRender sr;
     
340. //                sr.SetFormat(AC::PixelFormat::PIXELFORMAT_NV12);
     
341. //                sr.SetWindow(hwnd);
     
342. //                sr.Initial();
     
343. //                while (1)
     
344. //                {
     
345. //                        auto d = AC::MFCameraCapture::GetDevices();
     
346. //                        AC::MFCameraCapture mcc(d[0].Id);
     
347. //                        for (auto i : d[0].SurportForamts)
     
348. //                        {
     
349. //                                if (i.PixelFormat == AC::PixelFormat::PIXELFORMAT_NV12 && i.Width == 1280 && i.Height == 720)
     
350. //                                {
     
351. //                                        mcc.SetVideoFormat(i);
     
352. //                                        break;
     
353. //                                }
     
354. //                        }
     
355. //                        mcc.PixelDataArrived += [&](auto s, AC::IVideoInput::PixelDataArrivedEventArgs* e) {
     
356. //                                sr.Present(e->Frame.Data, e->Frame.DataLength, e->Frame.Width, e->Frame.Height, 0, 0, e->Frame.Width, e->Frame.Height, 0, 0, e->Frame.Width, e->Frame.Height);
     
357. //                        };
     
358. //                        mcc.Open();
     
359. //                        Sleep(50);
     
360. //                }
     
361. //                MSG msg;
     
362. //                HACCEL hAccelTable = NULL;
     
363. //                //     Ϣѭ  :
     
364. //                while (GetMessage(&msg, NULL, 0, 0))
     
365. //                {
     
366. //                        if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))
     
367. //                        {
     
368. //                                TranslateMessage(&msg);
     
369. //                                DispatchMessage(&msg);
     
370. //                        }
     
371. //                }
     
372. //        }
     
373. //        catch (const std::exception& e) {
     
374. //                printf("%s", e.what());
     
375. //        }
     
376. //        //
     
377. //
     
378. //        //GdiScreenCaptureTest();
     
379. //
     
380. //        return 0;
     
381. //}
     
382. 
     
383. 
     
384. 
     
385. ////      
     
386. //
     
387. //static int getNextNalu(unsigned char* h264Frame, int len, int& offset)
     
388. //{
     
389. //        int oldOffset = offset;
     
390. //        int spliterLen = 4;
     
391. //        offset += 3;
     
392. //        while (offset < len)
     
393. //        {
     
394. //                if (h264Frame[offset - 3] == 0 && h264Frame[offset - 2] == 0 && h264Frame[offset - 1] == 1)
     
395. //                {
     
396. //                        if (offset > 3) {
     
397. //                                if (h264Frame[offset - 4] == 0) {
     
398. //                                        spliterLen = 4;
     
399. //                                }
     
400. //                                else
     
401. //                                {
     
402. //                                        spliterLen = 3;
     
403. //                                }
     
404. //                        }
     
405. //                        else {
     
406. //                                spliterLen = 3;
     
407. //                        }
     
408. //                        break;
     
409. //                }
     
410. //                offset++;
     
411. //        }
     
412. //
     
413. //        return offset - oldOffset - spliterLen;
     
414. //}
     
415. //double atime = 0;
     
416. //
     
417. //int GetClock() {
     
418. //        return atime;
     
419. //
     
420. //}
     
421. //
     
422. //MP4FileHandle pHandle = NULL;
     
423. //AC::SdlVideoRender sr;
     
424. //AC::IntelHardwareEncoder* he;
     
425. //MP4TrackId videoId;
     
426. //int addStream = 1;
     
427. //FILE* fh264 = NULL;
     
428. //int64_t _timestamp = 0;
     
429. //
     
430. //class A :public AC::IVideoCaptureCallback
     
431. //{
     
432. //        // ͨ   IVideoCaptureCallback  ̳
     
433. //        virtual void OnCaptrue(const unsigned char* buf, int len, int width, int height, AC::PixelFormat format, unsigned int timestamp) override
     
434. //        {
     
435. //                //sr.Present(buf, len, width, height, 0, 0, width, height, 0, 0, 640, 360);
     
436. //                try {
     
437. //
     
438. //                        if (!he)
     
439. //                        {
     
440. //                                AC::EncodeParam param;
     
441. //                                param.Bitrate = 1024;
     
442. //                                param.Framerate = 20;
     
443. //                                param.Width = 1920;
     
444. //                                param.Height = 1080;
     
445. //                                //param.Profile = AC::PROFILE_AVC_BASELINE;
     
446. //                                //param.GopSize = 50;
     
447. //                                he = new AC::IntelHardwareEncoder(param);
     
448. //
     
449. //                                he->EncodedDataArrived += [&](auto s, auto e) {
     
450. //
     
451. //                                        if (!fh264)
     
452. //                                                fh264 = fopen("test.h264", "wb+");
     
453. //                                        fwrite(e->Frame.Data, 1, e->Frame.DataLength, fh264);
     
454. //                                        unsigned char* pBuf = e->Frame.Data;
     
455. //                                        unsigned char* pNalu = e->Frame.Data;
     
456. //                                        unsigned char naluType;
     
457. //                                        int len = 0;
     
458. //                                        int offset = 0;
     
459. //                                        int num = 0;
     
460. //                                        int width = 1920;
     
461. //                                        int height = 1080;
     
462. //                                        int frameRate = 20;
     
463. //                                        int timeScale = 90000;
     
464. //                                        bool isIdr = true;
     
465. //                                        while (1)
     
466. //                                        {
     
467. //                                                len = getNextNalu(pBuf, e->Frame.DataLength, offset);
     
468. //                                        gotNal:
     
469. //                                                if (len < 0)
     
470. //                                                        break;
     
471. //                                                pNalu = pBuf + offset;
     
472. //                                                naluType = pNalu[0] & 0x1F;
     
473. //                                                switch (naluType)
     
474. //                                                {
     
475. //                                                case 01:
     
476. //                                                case 02:
     
477. //                                                case 03:
     
478. //                                                case 04:
     
479. //                                                        isIdr = false;
     
480. //                                                case 05://idr
     
481. //                                                {
     
482. //                                                        len = e->Frame.DataLength - offset;
     
483. //                                                        if (offset < 4)
     
484. //                                                                break;
     
485. //                                                        pNalu -= 4;
     
486. //                                                        pNalu[0] = (len >> 24) & 0xFF;
     
487. //                                                        pNalu[1] = (len >> 16) & 0xFF;
     
488. //                                                        pNalu[2] = (len >> 8) & 0xFF;
     
489. //                                                        pNalu[3] = (len >> 0) & 0xFF;
     
490. //
     
491. //
     
492. //                                                        auto _duration = e->Frame.Timestamp - _timestamp;
     
493. //                                                        _timestamp = e->Frame.Timestamp;
     
494. //                                                        printf("%d \n", _duration * timeScale / 1000);
     
495. //                                                        if (!MP4WriteSample(pHandle, videoId, pNalu, len + 4, _duration * timeScale / 1000, 0, isIdr))
     
496. //                                                        {
     
497. //                                                                printf("err\n");
     
498. //                                                        }
     
499. //                                                        offset += len;
     
500. //                                                        isIdr = true;
     
501. //                                                }
     
502. //                                                break;
     
503. //                                                case 6: // SEI
     
504. //                                                {
     
505. //                                                        int a = 5;
     
506. //                                                }
     
507. //                                                break;
     
508. //                                                case 7: // SPS
     
509. //                                                {
     
510. //                                                        if (addStream)
     
511. //                                                        {
     
512. //                                                                videoId = MP4AddH264VideoTrack
     
513. //                                                                (pHandle,
     
514. //                                                                        timeScale,              // һ   Ӷ   timescale
     
515. //                                                                        timeScale / frameRate,    // ÿ  ֡ ж  ٸ timescale
     
516. //                                                                        width,                  // width
     
517. //                                                                        height,                 // height
     
518. //                                                                        pNalu[1],               // sps[1] AVCProfileIndication
     
519. //                                                                        pNalu[2],               // sps[2] profile_compat
     
520. //                                                                        pNalu[3],               // sps[3] AVCLevelIndication
     
521. //                                                                        3);                     // 4 bytes length before each NAL unit
     
522. //                                                                if (videoId == MP4_INVALID_TRACK_ID)
     
523. //                                                                {
     
524. //                                                                        printf("Error:Can't add track.\n");
     
525. //                                                                        return -1;
     
526. //                                                                }
     
527. //                                                                MP4SetVideoProfileLevel(pHandle, 0x7F);
     
528. //                                                                addStream = 0;
     
529. //                                                                len = getNextNalu(pBuf, e->Frame.DataLength, offset);
     
530. //                                                                MP4AddH264SequenceParameterSet(pHandle, videoId, pNalu, len);
     
531. //                                                                goto gotNal;
     
532. //                                                        }
     
533. //
     
534. //
     
535. //                                                }
     
536. //                                                break;
     
537. //                                                case 8: // PPS
     
538. //                                                {
     
539. //                                                        len = getNextNalu(pBuf, e->Frame.DataLength, offset);
     
540. //                                                        printf("pps(%d)\n", len);
     
541. //                                                        MP4AddH264PictureParameterSet(pHandle, videoId, pNalu, len);
     
542. //
     
543. //                                                        goto gotNal;
     
544. //                                                }
     
545. //                                                break;
     
546. //                                                case 9: // ֽ  
     
547. //                                                        break;
     
548. //                                                case 10: //   н     
     
549. //                                                        break;
     
550. //                                                default:
     
551. //
     
552. //                                                        break;
     
553. //                                                }
     
554. //                                        }
     
555. //                                };
     
556. //                        }
     
557. //                        auto buffer = he->GetNV12Buffer();
     
558. //                        buffer.Timestamp = GetClock();
     
559. //                        for (int i = 0; i < height; i++)
     
560. //                        {
     
561. //                                memcpy(buffer.GetY() + i * buffer.GetPitch(), buf + i * width, width);
     
562. //                        }
     
563. //                        for (int i = 0; i < height / 2; i++)
     
564. //                        {
     
565. //                                memcpy(buffer.GetUV() + i * buffer.GetPitch(), buf + width * height + i * width, width);
     
566. //                        }
     
567. //                        buffer.IsForceIdr = false;
     
568. //                        he->Write(buffer);
     
569. //                }
     
570. //                catch (const std::exception& e) {
     
571. //                        printf(e.what());
     
572. //                        printf("\n");
     
573. //                }
     
574. //                catch (...) {
     
575. //                        printf("    δ֪ 쳣\n");
     
576. //                }
     
577. //        }
     
578. //        virtual void OnCaptrue(const unsigned char* buf, int len, int width, int height, AC::CodingFormat format, unsigned int timestamp) override
     
579. //        {
     
580. //
     
581. //        }
     
582. //};
     
583. //
     
584. //
     
585. //
     
586. //
     
587. ////   ڹ   
     
588. //static        LRESULT CALLBACK WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
     
589. //{
     
590. //
     
591. //        switch (msg)
     
592. //        {
     
593. //        case WM_DESTROY:
     
594. //                PostQuitMessage(0);
     
595. //                break;
     
596. //        }
     
597. //
     
598. //        return DefWindowProc(hWnd, msg, wParam, lParam);
     
599. //}
     
600. //void GdiScreenCaptureTest() {
     
601. //        WNDCLASS wndclass;
     
602. //        wndclass.style = CS_HREDRAW | CS_VREDRAW;
     
603. //        wndclass.lpfnWndProc = WndProc;
     
604. //        wndclass.cbClsExtra = 0;
     
605. //        wndclass.cbWndExtra = 0;
     
606. //        wndclass.hInstance = GetModuleHandle(NULL);
     
607. //        wndclass.hIcon = LoadIcon(NULL, IDI_APPLICATION);
     
608. //        wndclass.hCursor = LoadCursor(NULL, IDC_ARROW);
     
609. //        wndclass.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
     
610. //        wndclass.lpszMenuName = 0;
     
611. //        wndclass.lpszClassName = L"DemoWindow";
     
612. //        if (!RegisterClass(&wndclass))
     
613. //        {
     
614. //                MessageBox(NULL, TEXT("        ʧ  !"), L"", MB_ICONERROR);
     
615. //        }
     
616. //        auto title = L"       ";
     
617. //        HWND        hwnd = CreateWindow(
     
618. //                L"DemoWindow",
     
619. //                title,
     
620. //                WS_OVERLAPPEDWINDOW,
     
621. //                0,
     
622. //                0,
     
623. //                1280,
     
624. //                720,
     
625. //                NULL,
     
626. //                NULL,
     
627. //                GetModuleHandle(NULL),
     
628. //                NULL
     
629. //        );
     
630. //        ShowWindow(hwnd, SW_SHOW);
     
631. //        sr.SetWindow(hwnd);
     
632. //        sr.SetFormat(AC::PIXELFORMAT_NV12);
     
633. //        sr.Initial();
     
634. //        AC::GdiScreenCapture gc(NULL, AC::PIXELFORMAT_NV12);
     
635. //        A a;
     
636. //        gc.SetCallback(&a);
     
637. //        gc.SetFramerate(20);
     
638. //
     
639. //
     
640. //        AC::SoundCollector sc;
     
641. //        AC::FdkaacEncoder fe({ 2,44100,16 });
     
642. //        sc.SetBufferSize(1024);
     
643. //        fe.SetAudioObjectType(AC::AudioObjectType::AUDIOOBJECTTYPE_AAC_LC);
     
644. //        fe.SetBitrate(256 * 1024);
     
645. //        fe.SetChannelMode(AC::ChannelMode::CHANNELMODE_2);
     
646. //        fe.SetChannelOrder(AC::CHANNELORDER_WAV);
     
647. //        fe.SetBitrateMode(AC::BitrateModde::BITRATEMODDE_CBR);
     
648. //        fe.SetTransportType(AC::TRANSPORTTYPE_MP4_RAW);
     
649. //
     
650. //        if (!pHandle)
     
651. //        {
     
652. //                pHandle = MP4Create("test.mp4", 0);
     
653. //                if (pHandle == MP4_INVALID_FILE_HANDLE)
     
654. //                {
     
655. //                        printf("ERROR:Create mp4 handle fialed.\n");
     
656. //                        return;
     
657. //                }
     
658. //                MP4SetTimeScale(pHandle, 90000);
     
659. //        }
     
660. //
     
661. //        //     AAC track
     
662. //        auto audio = MP4AddAudioTrack(pHandle, 44100, 1024, MP4_MPEG4_AUDIO_TYPE);
     
663. //        if (audio == MP4_INVALID_TRACK_ID)
     
664. //        {
     
665. //                printf("Add audio track failed!\n");
     
666. //                return;
     
667. //        }
     
668. //        FILE* faac = NULL;
     
669. //        faac = fopen("test.aac", "wb+");
     
670. //        //       Ƶ   
     
671. //        MP4SetAudioProfileLevel(pHandle, 0x02);
     
672. //        auto si = fe.GetDecoderSpecificInfo();
     
673. //        auto pSi = (uint8_t*)&si;
     
674. //        uint8_t temp = pSi[0];
     
675. //        pSi[0] = pSi[1];
     
676. //        pSi[1] = temp;
     
677. //        MP4SetTrackESConfiguration(pHandle, audio, (uint8_t*)&si, 2);
     
678. //
     
679. //        int64_t _atimestamp = 0;
     
680. //        int64_t _aduration = 0;
     
681. //
     
682. //        fe.EncodedDataArrived += [&](auto s, auto e) {
     
683. //                fwrite(e->Frame.Data, 1, e->Frame.DataLength, faac);
     
684. //                MP4WriteSample(pHandle, audio, e->Frame.Data, e->Frame.DataLength, MP4_INVALID_DURATION/* _aduration * 44100 / 1000*/, 0, 1);
     
685. //        };
     
686. //        bool isRun = false;
     
687. //        sc.DataArrived += [&](auto s, auto e) {
     
688. //
     
689. //
     
690. //                atime += e->DataLength * 1000.0 / (44100 * 16 / 8 * 2);
     
691. //
     
692. //                if (_atimestamp)
     
693. //                        _aduration = clock() - _atimestamp;
     
694. //                /*_atimestamp = clock();*/
     
695. //
     
696. //                if (!isRun)
     
697. //                {
     
698. //                        _timestamp = GetClock();
     
699. //                        /*atime = 0;
     
700. //                        gc.Start();*/
     
701. //                        isRun = true;
     
702. //                }
     
703. //
     
704. //                fe.Write(e->Data, e->DataLength);
     
705. //        };
     
706. //        _timestamp = GetClock();
     
707. //        sc.Start(2, 44100, 16);
     
708. //        gc.Start();
     
709. //
     
710. //
     
711. //        MSG msg;
     
712. //        HACCEL hAccelTable = NULL;
     
713. //        //     Ϣѭ  :
     
714. //        while (GetMessage(&msg, NULL, 0, 0))
     
715. //        {
     
716. //                if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))
     
717. //                {
     
718. //                        TranslateMessage(&msg);
     
719. //                        DispatchMessage(&msg);
     
720. //                }
     
721. //        }
     
722. //        gc.Stop();
     
723. //        sc.Stop();
     
724. //        MP4Close(pHandle, 0);
     
725. //        fclose(faac);
     
726. //}
     
727. //
     
728. //
     
729. //
     
730. //
     
731. //int main(int argc, char* argv[])
     
732. //{
     
733. //        GdiScreenCaptureTest();
     
734. //
     
735. //        return 0;
     
736. //}
     
737. 
     
738. 
     
739. 
     
740. 
     
741. 
     
742. 
     
743. 
     
744. 
     
745. 
     
746. int main2(int argc, char** argv) {
     
747. 
     
748. 
     
749. 
     
750. 
     
751.         ////std::vector<std::string> files;
     
752.         ////FileHelper::GetFolderFiles("E:\\Download\\Incubus\\IncubusQuest ver10", files);
     
753.         ////for (auto i : files)
     
754.         ////{
     
755.         ////        auto ws = AC::StringHelper::ShifJisToUnicode(i);
     
756.         ////        auto  s = AC::StringHelper::UnicodeToAnsi(ws);
     
757.         ////        int ret = rename(i.c_str(), s.c_str());
     
758.         ////}
     
759. 
     
760. 
     
761.         //int d;
     
762.         //scanf("%d", &d);
     
763. 
     
764.         //auto ox = AC::StringHelper::Sprintf("%d", 15);
     
765. 
     
766.         ////AC::SoundCollectorTest();
     
767.         //AC::SoundPlayTest();
     
768.         //AC::WavFileReader read;
     
769.         //AC::SoundPlay sp;
     
770.         //unsigned char buf[1024];
     
771.         //if (read.OpenWavFile("test_music.wav"))
     
772.         //{
     
773.         //        int channels, sampleRate, bitsPerSample;
     
774.         //        channels = read.GetChannels();
     
775.         //        sampleRate = read.GetSampleRate();
     
776.         //        bitsPerSample = read.GetBitsPerSample();
     
777.         //        sp.Opened += [&](auto s, auto e) {
     
778.         //                printf("  ʼ    :Channels %d SampleRate %d BitsPerSample %d\n", e->Format.Channels, e->Format.SampleRate, e->Format.BitsPerSample);
     
779.         //        };
     
780.         //        sp.DataDone += [&](auto s, auto e) {
     
781.         //                printf("%p   ݲ      :    %d\n", e->Data, e->DataLength);
     
782.         //        };
     
783.         //        sp.Closed += [&](auto s, auto e) {
     
784.         //                printf(" رղ   \n");
     
785.         //        };
     
786.         //        sp.Error += [&](auto s, auto e) {
     
787.         //                printf("%s\n", e->Message.c_str());
     
788.         //        };
     
789.         //        sp.Open(read.GetChannels(), read.GetSampleRate(), read.GetBitsPerSample());
     
790.         //        int size;
     
791.         //        do
     
792.         //        {
     
793.         //                //  ȡ  Ƶ   
     
794.         //                size = read.ReadData(buf, 1024);
     
795.         //                if (size > 0)
     
796.         //                {
     
797.         //                        sp.Write(buf, size);
     
798.         //                }
     
799.         //        } while (size);
     
800.         //}
     
801. 
     
802.         ////auto _play = acf_play_create();
     
803.         //////acf_play_set_beginCallback(_play, beginCallback);
     
804.         //////acf_play_set_renderCallback(_play, renderCallback);
     
805.         ////acf_play_play(_play, "212144271-1-192.mp4", 0);
     
806. 
     
807.         return 0;
     
808. }
     
809. 
     
810. 
     
811. 
     
812. 
     

复制代码