• FFmpeg与其他库的交互

    转载：https://www.cnblogs.com/lidabo/p/15826544.html

    视频软件不是仅靠一个FFmpeg就能完成。FFmpeg只包括流的读写及编码解码，其他操作都得靠其他库来实现。比如播放视频需要界面库；播放声音需要播放声音的库或系统API等。所以这一块也是重中之重。下面我介绍几种常用FFmpeg与其他库交互方式。

    将avframe与qt互转

    AVFrame转QImage比较简单，不过这儿有一个坑在于，直接指定数据的方式上面，一旦数据失效那么图片也会失效。此处的比较友好的做法是再构造一次

    1. // AVFrame 转 QImage
    2. // 首先确保图像帧格式为 AV_PIX_FMT_RGB32，如果不是，那么转一次
    3. AVFrame *_frame_rgb32 = _video_format_convet (_frame_xxx, AV_PIX_FMT_RGB32);
    4. // 此处 _img_tmp 即可用，与 _frame_rgb32 共用数据区域
    5. QImage _img_tmp (_frame_rgb32->data [0], _frame_rgb32->width, _frame_rgb32->height, QImage::Format_RGB32);
    6. //但如果想让 _frame_rgb32 释放后继续使用，那么需要再构造一次
    7. QImage _img { 640, 480, QImage::Format_ARGB32 };
    8. QPainter _p (&_img);
    9. _p.drawImage (_img.rect (), _img_tmp, _img_tmp.rect ());
    10.  
    11. // QImage 转 AVFrame
    12. AVFrame *_frame_rgb32 = av_frame_alloc ();
    13. _frame_rgb32->width = img.width ();
    14. _frame_rgb32->height = img.height ();
    15. _frame_rgb32->format = AV_PIX_FMT_RGB32;
    16. av_frame_get_buffer (_frame_rgb32, 0);
    17. memcpy (_frame_rgb32->data [0], img.bits (), _frame_rgb32->width * _frame_rgb32->height * 4);

    将avframe与gdiplus互转

    AVFrame转Gdiplus::Bitmap也是比较容易的，不过还是需要注意GDI+初始化不要忘了

    1. // AVFrame 转 Gdiplus::Bitmap
    2. // 此时 _frame_rgb32 为有效 AVFrame
    3. Gdiplus::Bitmap _bmp (_frame_rgb32->width, _frame_rgb32->height, PixelFormat32bppARGB);
    4. Gdiplus::BitmapData _data;
    5. _bmp.LockBits (&Gdiplus::Rect (0, 0, _bmp.GetWidth (), _bmp.GetHeight ()), Gdiplus::ImageLockModeWrite, PixelFormat32bppARGB, &_data);
    6. memcpy (_data.Scan0, _frame_rgb32->data [0], _frame_rgb32->width * _frame_rgb32->height * 4);
    7. _bmp.UnlockBits (&_data);
    8.  
    9. // Gdiplus::Bitmap 转 AVFrame
    10. // 此时 _bmp 为有效 Gdiplus::Bitmap
    11. AVFrame *_frame_rgb32 = av_frame_alloc ();
    12. _frame_rgb32->width = _bmp.GetWidth ();
    13. _frame_rgb32->height = _bmp.GetHeight ();
    14. _frame_rgb32->format = AV_PIX_FMT_RGB32;
    15. av_frame_get_buffer (_frame_rgb32, 0);
    16. Gdiplus::BitmapData _data;
    17. _bmp.LockBits (&Gdiplus::Rect (0, 0, _bmp.GetWidth (), _bmp.GetHeight ()), Gdiplus::ImageLockModeRead, PixelFormat32bppARGB, &_data);
    18. memcpy (_frame_rgb32->data [0], _data.Scan0, _frame_rgb32->width * _frame_rgb32->height * 4);
    19. _bmp.UnlockBits (&_data);

    使用sdl1播放视频

    1. // 首先是SDL初始化代码
    2. SDL_Init (SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_TIMER);
    3.  
    4. // 然后是创建SDL2窗口及SDL2图片
    5. SDL_Surface *_screen = SDL_SetVideoMode (_frame_yuv420p->width, _frame_yuv420p->height, 0, SDL_SWSURFACE);
    6. SDL_Overlay *_bmp = SDL_CreateYUVOverlay (_frame_yuv420p->width, _frame_yuv420p->height, SDL_YV12_OVERLAY, _screen);
    7. SDL_Rect _rect { 0, 0, _frame_yuv420p->width, _frame_yuv420p->height };
    8.  
    9. // 然后是循环播放内部，将AVFrame结构体数据移动到SDL图片上
    10. SDL_LockYUVOverlay (_bmp);
    11. memcpy (_bmp->pixels [0], _frame_yuv420p->data [0], _frame_yuv420p->width * _frame_yuv420p->height);
    12. memcpy (_bmp->pixels [1], _frame_yuv420p->data [1], _frame_yuv420p->width * _frame_yuv420p->height / 4);
    13. memcpy (_bmp->pixels [2], _frame_yuv420p->data [2], _frame_yuv420p->width * _frame_yuv420p->height / 4);
    14. _frame_yuv420p->linesize [0] = _bmp->pitches [0];
    15. _frame_yuv420p->linesize [1] = _bmp->pitches [2];
    16. _frame_yuv420p->linesize [2] = _bmp->pitches [1];
    17. SDL_UnlockYUVOverlay (_bmp);
    18. SDL_DisplayYUVOverlay (_bmp, &_rect);
    19. // 暂停
    20. SDL_Delay (50);
    21.  
    22. // 展示完毕，退出
    23. SDL_Quit ();

    使用sdl2播放视频

    1. // 首先是SDL初始化代码
    2. SDL_Init (SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_TIMER);
    3.  
    4. // 然后是创建SDL2窗口及SDL2图片
    5. SDL_Window *_screen = SDL_CreateWindow ("My Window", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, 640, 480, SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE);
    6. SDL_Renderer* _sdlRenderer = SDL_CreateRenderer (_screen, -1, 0);
    7. SDL_Texture* _sdlTexture = SDL_CreateTexture (_sdlRenderer, SDL_PIXELFORMAT_YV12, SDL_TEXTUREACCESS_STREAMING, 640, 480);
    8. SDL_Rect _rect { 0, 0, 640, 480 };
    9.  
    10. // 然后是循环播放内部，将AVFrame结构体数据移动到SDL2图片上
    11. int _sz = _frame_yuv420p->width * _frame_yuv420p->height;
    12. uint8_t *_buf = new uint8_t [_sz * 3 / 2];
    13. memcpy (_buf, _frame_yuv420p->data [0], _sz);
    14. memcpy (_buf + _sz * 5 / 4, _frame_yuv420p->data [1], _sz / 4);
    15. memcpy (_buf + _sz, _frame_yuv420p->data [2], _sz / 4);
    16. SDL_UpdateTexture (_sdlTexture, NULL, _buf, 640);
    17. SDL_RenderClear (_sdlRenderer);
    18. SDL_RenderCopy (_sdlRenderer, _sdlTexture, NULL, &_rect);
    19. SDL_RenderPresent (_sdlRenderer);
    20. delete _buf;
    21. // 暂停
    22. SDL_Delay (50);
    23.  
    24. // 展示完毕，退出
    25. SDL_Quit ();

    使用sdl2播放音频

    SDL2播放音频有一个问题在于，仅支持单例。也就是不能创建两个对象一起播放。

    1. // 全局变量，用于控制播音进度，通常实现写在类里面作为类成员变量
    2. volatile Uint8 *_audio_pos = nullptr;
    3. volatile Uint32 _audio_len = 0;
    4.  
    5. // 回调函数。实际播音通过这个函数来实现
    6. void _fill_audio (void *udata, Uint8 *stream, int len) {
    7.     // 如果控制进度写到类/结构体成员，那么udata就传递指针
    8.     SDL_memset (stream, 0, len);
    9.     if (_audio_len == 0)
    10.         return;
    11.     len = (len > (int) _audio_len ? _audio_len : len);
    12.     //SDL_MixAudio (stream, (const Uint8*) _audio_pos, len, SDL_MIX_MAXVOLUME);
    13.     SDL_MixAudioFormat (stream, (const Uint8*) _audio_pos, AUDIO_S16, len, SDL_MIX_MAXVOLUME);
    14.     _audio_pos += len;
    15.     _audio_len -= len;
    16. }
    17.  
    18. // 初始化
    19. SDL_AudioSpec _spec;
    20. _spec.freq = _frame_s16->sample_rate;
    21. _spec.format = AUDIO_S16SYS;
    22. _spec.channels = _frame_s16->channels;
    23. _spec.silence = 0;
    24. _spec.samples = 1024;
    25. _spec.callback = &AudioPlay2::_fill_audio;
    26. _spec.userdata = nullptr; // 或者 this，根据需求决定是否传递
    27. if (int _ret = SDL_OpenAudio (&_spec, NULL)) {
    28.     printf ("SDL_OpenAudio failed\n");
    29.     return;
    30. }
    31. SDL_PauseAudio (0);
    32.  
    33. // 开始播放过程，每读一帧就调用一遍
    34. _audio_pos = _frame_s16->data [0];
    35. _audio_len = _frame_s16->nb_samples * _frame_s16->channels * 2;
    36. while (_audio_len > 0)
    37.     SDL_Delay (1);
    38.  
    39. // 释放
    40. SDL_CloseAudio ();

    使用wave函数播放音频

    wave系列函数仅支持Windows平台，范围从WinXP到Win10，比较古老，但相对于SDL2来说可以少引用一个库。另外这两者的实现特别像，几乎可以不用修改架构实现与SDL2的互相迁移。

    1. // 全局变量，用于控制播放进度
    2. volatile LPWAVEHDR _pwh = nullptr;
    3.  
    4. // 回调函数具有Win32特色，需要指定调用协定
    5. void CALLBACK _wave_out_proc (HWAVEOUT hwo, UINT uMsg, DWORD_PTR dwInstance, DWORD_PTR dwParam1, DWORD_PTR dwParam2) {
    6.     // 此处 dwInstance 为用户指定的指针
    7.     if (WOM_DONE == uMsg) {
    8.         while (_pwh) {
    9.             std::this_thread::sleep_for (std::chrono::milliseconds (1));
    10.         }
    11.         _pwh = (LPWAVEHDR) dwParam1;
    12.     }
    13. }
    14.  
    15. // 初始化
    16. WAVEFORMATEX _wfex;
    17. _wfex.wFormatTag = WAVE_FORMAT_PCM;
    18. _wfex.nChannels = (WORD) _frame_s16->channels;
    19. _wfex.nSamplesPerSec = (DWORD) _frame_s16->sample_rate;
    20. _wfex.wBitsPerSample = 16;
    21. _wfex.cbSize = sizeof (_wfex);
    22. _wfex.nBlockAlign = _wfex.wBitsPerSample * _wfex.nChannels / 8;
    23. _wfex.nAvgBytesPerSec = m_wfex.nSamplesPerSec * m_wfex.nBlockAlign;
    24. if (::waveOutOpen (nullptr, 0, &_wfex, 0, 0, WAVE_FORMAT_QUERY) != 0) {
    25.     printf ("waveOutOpen failed\n");
    26.     return;
    27. }
    28. if (::waveOutOpen (&_hwo, WAVE_MAPPER, &_wfex, (DWORD_PTR) _wave_out_proc, (DWORD_PTR) this, CALLBACK_FUNCTION) != 0) {
    29.     printf ("waveOutOpen failed\n");
    30.     return;
    31. }
    32.  
    33. // 开始播放过程，每读一帧就调用一遍
    34. LPWAVEHDR _pwh = new WAVEHDR;
    35. if (!_pwh)
    36.     return false;
    37. memset (_pwh, 0, sizeof (WAVEHDR));
    38. _pwh->dwLoops = 1;
    39. _pwh->dwBufferLength = (DWORD) _frame_s16->nb_samples * _frame_s16->channels * 2;
    40. _pwh->lpData = new char [_pwh->dwBufferLength];
    41. if (!_pwh->lpData) {
    42.     delete _pwh;
    43.     return;
    44. }
    45. memcpy (_pwh->lpData, _frame_s16->data[0], _pwh->dwBufferLength);
    46. if (::waveOutPrepareHeader (_hwo, _pwh, sizeof (WAVEHDR)) != 0) {
    47.     delete [] _pwh->lpData;
    48.     delete _pwh;
    49.     return;
    50. }
    51. if (::waveOutWrite (_hwo, _pwh, sizeof (WAVEHDR)) != 0) {
    52.     delete [] _pwh->lpData;
    53.     delete _pwh;
    54.     return;
    55. }
    56.  
    57. // 释放
    58. if (_hwo) {
    59.     ::waveOutReset (_hwo);
    60.     ::waveOutClose (_hwo);
    61.     _hwo = NULL;
    62. }

    枚举dshow设备

    这个用到了dshow函数，操作稍微有点麻烦，获取一个设备需要一大堆代码。建议不要深究，需要的时候直接复制就好啦。

    此处不用FFmpeg的原因是，截至目前FFmpeg暂不支持以编程的方式获取列表，如果通过读控制台的方式还涉及到解析等，说白了还是FFmpeg的锅。

    地址：DirectShow – FFmpeg

    1. // dshow头文件
    2. #include <string>
    3. #include <vector>
    4. #include <dshow.h>
    5. #include <dvdmedia.h>
    6. #pragma comment (lib, "Strmiids.lib")
    7. #pragma comment (lib, "Winmm.lib")
    8.  
    9. // 注意调用枚举前需要调用COM+初始化
    10. ::CoInitializeEx (NULL, COINIT_APARTMENTTHREADED);
    11.  
    12. // 枚举所有dshow视频设备
    13. std::vector<std::wstring> _video_names;
    14. ICreateDevEnum* pSysDevEnum = nullptr;
    15. if (SUCCEEDED (CoCreateInstance (CLSID_SystemDeviceEnum, nullptr, CLSCTX_INPROC_SERVER, IID_ICreateDevEnum, (void**) &pSysDevEnum))) {
    16.     IEnumMoniker* pEnumCat = nullptr;
    17.     if (SUCCEEDED (pSysDevEnum->CreateClassEnumerator (CLSID_VideoInputDeviceCategory, &pEnumCat, 0))) {
    18.         IMoniker* pMoniker = nullptr;
    19.         ULONG cFetched = 0;
    20.         while (SUCCEEDED (pEnumCat->Next (1, &pMoniker, &cFetched)) && cFetched) {
    21.             IPropertyBag* pPropBag = nullptr;
    22.             if (SUCCEEDED (pMoniker->BindToStorage (nullptr, nullptr, IID_IPropertyBag, (void**) &pPropBag))) {
    23.                 VARIANT varName;
    24.                 VariantInit (&varName);
    25.                 if (SUCCEEDED (pPropBag->Read (L"FriendlyName", &varName, 0))) {
    26.                     _video_names.push_back (varName.bstrVal);
    27.                 }
    28.                 VariantClear (&varName);
    29.                 if (pPropBag)
    30.                     pPropBag->Release ();
    31.             }
    32.             if (pPropBag)
    33.                 pPropBag->Release ();
    34.         }
    35.         if (pMoniker)
    36.             pMoniker->Release ();
    37.     }
    38.     if (pEnumCat)
    39.         pEnumCat->Release ();
    40. }
    41. if (pSysDevEnum)
    42.     pSysDevEnum->Release ();
    43.  
    44. // 枚举所有dshow音频设备
    45. std::vector<std::wstring> _audio_names;
    46. ICreateDevEnum* pSysDevEnum = NULL;
    47. if (SUCCEEDED (CoCreateInstance (CLSID_SystemDeviceEnum, NULL, CLSCTX_INPROC_SERVER, IID_ICreateDevEnum, (void**) &pSysDevEnum))) {
    48.     IEnumMoniker* pEnumCat = nullptr;
    49.     if (SUCCEEDED (pSysDevEnum->CreateClassEnumerator (CLSID_AudioInputDeviceCategory, &pEnumCat, 0))) {
    50.         IMoniker* pMoniker = nullptr;
    51.         ULONG cFetched;
    52.         while (SUCCEEDED (pEnumCat->Next (1, &pMoniker, &cFetched)) && cFetched) {
    53.             IPropertyBag* pPropBag = nullptr;
    54.             if (SUCCEEDED (pMoniker->BindToStorage (nullptr, nullptr, IID_IPropertyBag, (void**) &pPropBag))) {
    55.                 VARIANT varName;
    56.                 VariantInit (&varName);
    57.                 if (SUCCEEDED (pPropBag->Read (L"FriendlyName", &varName, 0)))
    58.                     _audio_names.push_back (varName.bstrVal);
    59.                 VariantClear (&varName);
    60.             }
    61.             if (pPropBag)
    62.                 pPropBag->Release ();
    63.             pMoniker->Release ();
    64.             pMoniker = nullptr;
    65.         }
    66.         if (pMoniker)
    67.             pMoniker->Release ();
    68.     }
    69.     if (pEnumCat)
    70.         pEnumCat->Release ();
    71. }
    72. if (pSysDevEnum)
    73.     pSysDevEnum->Release ();

    使用windows捕获扬声器输出

    一个通过调用COM+组件实现的例子，代码比较多，不建议实际去研究，用着没问题就行了。有一个问题需要注意下：Win764位系统上不支持设置通道数，一旦设置后很容易捕获失败，所以后面需要自己手动转一次。代码中已经已经将音频数据转为了FFmpeg可用的AVFrame，可以直接用于处理或转码。

    1. HRESULT _r = 0;
    2. DWORD _nTaskIndex = 0;
    3. REFERENCE_TIME _hnsDefaultDevicePeriod = 0;
    4. LARGE_INTEGER _liFirstFire { 0 };
    5. //
    6. HANDLE _hEventStarted = ::CreateEvent (NULL, TRUE, FALSE, NULL);
    7. HANDLE _hEventStop = ::CreateEvent (NULL, TRUE, FALSE, NULL);
    8. HANDLE _hTimerWakeUp = ::CreateWaitableTimer (NULL, FALSE, NULL);
    9. HANDLE _hTask = AvSetMmThreadCharacteristics (_T ("Capture"), &_nTaskIndex);
    10. SetEvent (_hEventStarted);
    11. AVFrame *_frame = av_frame_alloc ();
    12. //
    13. IMMDeviceEnumerator *_pEnumerator = nullptr;
    14. IMMDevice *_pDevice = nullptr;
    15. IAudioClient *_pAudioClient = nullptr;
    16. WAVEFORMATEX *_pwfx = nullptr;
    17. IAudioCaptureClient *_pCaptureClient = nullptr;
    18. do {
    19.     if (FAILED (_r = CoCreateInstance (__uuidof(MMDeviceEnumerator), NULL, CLSCTX_ALL, __uuidof(IMMDeviceEnumerator), (void**) &_pEnumerator))) {
    20.         LOG_INFO ("CoCreateInstance failed %d", _r);
    21.         break;
    22.     }
    23.     if (FAILED (_r = _pEnumerator->GetDefaultAudioEndpoint (eRender, eConsole, &_pDevice))) {
    24.         LOG_INFO ("_pEnumerator->GetDefaultAudioEndpoint failed %d", _r);
    25.         break;
    26.     }
    27.     if (FAILED (_r = _pDevice->Activate (__uuidof(IAudioClient), CLSCTX_ALL, NULL, (void**) &_pAudioClient))) {
    28.         LOG_INFO ("_pDevice->Activate failed %d", _r);
    29.         break;
    30.     }
    31.     if (FAILED (_r = _pAudioClient->GetDevicePeriod (&_hnsDefaultDevicePeriod, NULL))) {
    32.         LOG_INFO ("_pAudioClient->GetDevicePeriod failed %d", _r);
    33.         break;
    34.     }
    35.     if (FAILED (_r = _pAudioClient->GetMixFormat (&_pwfx))) {
    36.         LOG_INFO ("_pAudioClient->GetMixFormat failed %d", _r);
    37.         break;
    38.     }
    39.     //
    40.     _pwfx->wBitsPerSample = 16;
    41.     _pwfx->nSamplesPerSec = _sample_rate;
    42.     //_pwfx->nChannels = _channel_num;
    43.     _pwfx->nBlockAlign = _pwfx->nChannels * _pwfx->wBitsPerSample / 8;
    44.     _pwfx->nAvgBytesPerSec = _pwfx->nBlockAlign * _pwfx->nSamplesPerSec;
    45.     if (_pwfx->wFormatTag == WAVE_FORMAT_IEEE_FLOAT) {
    46.         _pwfx->wFormatTag = WAVE_FORMAT_PCM;
    47.     } else if (_pwfx->wFormatTag == WAVE_FORMAT_EXTENSIBLE) {
    48.         PWAVEFORMATEXTENSIBLE _pEx = reinterpret_cast<PWAVEFORMATEXTENSIBLE>(_pwfx);
    49.         if (IsEqualGUID (KSDATAFORMAT_SUBTYPE_IEEE_FLOAT, _pEx->SubFormat)) {
    50.             _pEx->SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
    51.             _pEx->Samples.wValidBitsPerSample = _pwfx->wBitsPerSample;
    52.         }
    53.     } else {
    54.         LOG_INFO ("unknown format 0x%04X", _pwfx->wFormatTag);
    55.         break;
    56.     }
    57.     //
    58.     size_t _FrameSize = (_pwfx->wBitsPerSample / 8) * _pwfx->nChannels;// 每帧长度（字节）
    59.     _frame->channels = _pwfx->nChannels;
    60.     _frame->channel_layout = av_get_default_channel_layout (_frame->channels);
    61.     _frame->sample_rate = _pwfx->nSamplesPerSec;
    62.     _frame->format = AV_SAMPLE_FMT_S16;
    63.     //_frame->format = AV_SAMPLE_FMT_FLT;
    64.     //
    65.     if (FAILED (_r = _pAudioClient->Initialize (AUDCLNT_SHAREMODE_SHARED, AUDCLNT_STREAMFLAGS_LOOPBACK, 0, 0, _pwfx, nullptr))) {
    66.         LOG_INFO ("_pAudioClient->Initialize failed %d", _r);
    67.         break;
    68.     }
    69.     if (FAILED (_r = _pAudioClient->GetService (__uuidof(IAudioCaptureClient), (void**) &_pCaptureClient))) {
    70.         LOG_INFO ("_pAudioClient->GetService failed %d", _r);
    71.         break;
    72.     }
    73.     _liFirstFire.QuadPart = -_hnsDefaultDevicePeriod / 2; // negative means relative time
    74.     LONG _lTimeBetweenFires = (LONG) _hnsDefaultDevicePeriod / 2 / (10 * 1000); // convert to milliseconds
    75.     if (!SetWaitableTimer (_hTimerWakeUp, &_liFirstFire, _lTimeBetweenFires, NULL, NULL, FALSE)) {
    76.         LOG_INFO ("SetWaitableTimer failed %d", ::GetLastError ());
    77.         break;
    78.     }
    79.     if (FAILED (_r = _pAudioClient->Start ())) {
    80.         LOG_INFO ("_pAudioClient->Start failed %d", _r);
    81.         break;
    82.     }
    83.     //
    84.     HANDLE _waitArray [2] = { _hEventStop, _hTimerWakeUp };
    85.     while (true) {
    86.         DWORD _dwWaitResult = WaitForMultipleObjects (_countof (_waitArray), _waitArray, FALSE, INFINITE);
    87.         if (WAIT_OBJECT_0 + 1 != _dwWaitResult)
    88.             break;
    89.         UINT32 _nNextPacketSize = 0;
    90.         if (FAILED (_r = _pCaptureClient->GetNextPacketSize (&_nNextPacketSize)))
    91.             break;
    92.         if (_nNextPacketSize == 0)
    93.             continue;
    94.         //
    95.         BYTE *_pData = nullptr;
    96.         UINT32 _nNumFramesToRead = 0;
    97.         DWORD _dwFlags = 0;
    98.         if (FAILED (_r = _pCaptureClient->GetBuffer (&_pData, &_nNumFramesToRead, &_dwFlags, nullptr, nullptr))) {
    99.             break;
    100.         }
    101.         if (_nNumFramesToRead == 0)
    102.             continue;
    103.         if (_frame->nb_samples != _nNumFramesToRead) {// * _pwfx->nChannels
    104.             if (_frame->data [0])
    105.                 av_frame_unref (_frame);
    106.             _frame->nb_samples = _nNumFramesToRead;// * _pwfx->nChannels
    107.             av_frame_get_buffer (_frame, 1);
    108.         }
    109.         //
    110.         if ((_dwFlags & AUDCLNT_BUFFERFLAGS_SILENT) > 0) {
    111.             memset (_frame->data [0], 0, _nNumFramesToRead*_FrameSize);
    112.         } else {
    113.             ::CopyMemory (_frame->data [0], _pData, _nNumFramesToRead*_FrameSize);
    114.         }
    115.         // 此处已转码成功
    116.         // _callback (_frame);
    117.         _pCaptureClient->ReleaseBuffer (_nNumFramesToRead);
    118.     }
    119. } while (false);
    120. //
    121. if (_pCaptureClient)
    122.     _pCaptureClient->Release ();
    123. av_frame_free (&_frame);
    124. if (_pwfx)
    125.     CoTaskMemFree (_pwfx);
    126. if (_pAudioClient)
    127.     _pAudioClient->Release ();
    128. if (_pDevice)
    129.     _pDevice->Release ();
    130. if (_pEnumerator)
    131.     _pEnumerator->Release ();
    132. AvRevertMmThreadCharacteristics (_hTask);
    133. ::CloseHandle (_hTimerWakeUp);
    134. ::CloseHandle (_hEventStop);
    135. ::CloseHandle (_hEventStarted);

    程序结构

    对于播放器来说，只需要解码然后展示就行了

    1. #include <头文件>
    2.  
    3. int main (int argc, char* argv[]) {
    4.     // 初始化
    5.     // 打开输入流
    6.     new_thread {
    7.         while (_run) {
    8.             // 图像处理
    9.             // 从摄像头输入流中读一个AVPacket
    10.             // 将AVPacket解码为AVFrame
    11.             // 根据实际需求考虑是否需要转换AVFrame的像素格式
    12.             // 展示图片（SDL2或者其他界面库）
    13.         }
    14.     }
    15.     new_thread {
    16.         while (_run) {
    17.             // 音频处理
    18.             // 从麦克风输入流中读一个AVPacket
    19.             // 将AVPacket解码为AVFrame
    20.             // 根据实际需求考虑是否需要转换AVFrame的采样格式
    21.             // 播放声音（SDL2或其他音频库）
    22.         }
    23.     }
    24.     while (_run) {
    25.         // wait...
    26.     }
    27.     // 关闭输入流
    28.     return 0;
    29. }

    对于一个视频监控软件来说，由于需要一边读摄像头一边展示，还要一边存文件，但不用读声音了，所以架构就是把这两者合并起来

    1. #include <头文件>
    2.  
    3. int main (int argc, char* argv[]) {
    4.     // 初始化
    5.     // 打开摄像头
    6.     // 打开输出流
    7.     new_thread {
    8.         while (_run) {
    9.             // 图像处理
    10.             // 从摄像头输入流中读一个AVPacket
    11.             // 将AVPacket解码为AVFrame
    12.             // 根据实际需求考虑是否需要转换AVFrame的像素格式
    13.             // 展示图片（SDL2或者其他界面库）
    14.             // 将AVFrame编码为AVPacket
    15.             // send一帧
    16.             // 控制速度
    17.         }
    18.     }
    19.     while (_run) {
    20.         // wait...
    21.     }
    22.     // 关闭输出流
    23.     // 关闭摄像头输入流
    24.     return 0;
    25. }

  • 相关阅读:
    IDA软件为什么运行不起来
    微信小程序入门级
    Fisher辨别分析
    ORM概念
    JVM内存模型
    树莓派4B_OpenCv学习笔记19：OpenCV舵机云台物体追踪
    做大数据开发一定要知道几个重要的框架和工具及知识点
    【最新版】ChatGPT/GPT4科研应用与AI绘图论文写作（最新增加Claude3、Gemini、Sora、GPTs技术及AI领域中的集中大模型的最新技术）
    STM32收入高也好找工作，所以我学嵌入式linux终究是错付了吗
    Spring boot项目集成security
  • 原文地址：https://blog.csdn.net/yaningli/article/details/128031216