环境：VS 2015
    windows下用ffmpeg获取视频缩略图 - 图1

    运行程序，生成RGB图像数据:
    windows下用ffmpeg获取视频缩略图 - 图2

    将RGB图像数据转换成yuv格式，通过ffmpeg命令，如下：
    windows下用ffmpeg获取视频缩略图 - 图3

    windows下用ffmpeg获取视频缩略图 - 图4

    完整代码：

    1. #include "stdafx.h"
    2. extern "C"
    3. {
    4. #include "libavformat\avformat.h"
    5. #include "libswscale\swscale.h"
    6. }
    7. #define DEBUG_SPEND_TIME 1
    8. #ifdef DEBUG_SPEND_TIME
    9. #ifdef _WIN32
    10. #include "windows.h"
    11. #include "mmsystem.h"
    12. #pragma comment(lib, "winmm.lib")
    13. #else
    14. #include <sys/time.h>
    15. #endif
    16. #endif
    18. AVFormatContext* m_pFormatContext = NULL;
    19. AVCodecContext*  m_pCodecContext = NULL;
    20. int              m_nStreamIndex[AVMEDIA_TYPE_NB] = { -1 };
    21. AVCodec*         m_pVideoCodec = NULL;
    22. AVFrame*         m_pAVFrame = NULL;
    23. AVFrame*         m_pThumbFrame = NULL;
    25. const char* strInputFileName[] = {
    26.     "C:\\oppo.mp4",
    27. };
    28. const char strThumbFileName[] = "D:\\thumb.rgb";
    29. #define THUMB_WIDTH   640
    30. #define THUMB_HEIGHT  480
    31. #define BRIGHTNESS_VALUE 0xF0
    32. #define DARKNESS_VALUE   0x30
    34. int initFFmpegContext()
    35. {
    36.     avcodec_register_all();
    37.     av_register_all();
    39.     return 0;
    40. }
    43. int setDataSource(const char* url)
    44. {
    45.     int ret = -1;
    46.     if (m_pFormatContext)
    47.     {
    48.         avformat_free_context(m_pFormatContext);
    49.         m_pFormatContext = NULL;
    50.     }
    52.     m_pFormatContext = avformat_alloc_context();
    53.     if (!m_pFormatContext)
    54.     {
    55.         return -1;
    56.     }
    57.     ret = avformat_open_input(&m_pFormatContext, url, NULL, NULL);
    58.     if (ret != 0)
    59.     {
    60.         delete m_pFormatContext;
    61.         return ret;
    62.     }
    64.     ret = avformat_find_stream_info(m_pFormatContext, NULL);
    65.     if (ret != 0)
    66.     {
    67.         delete m_pFormatContext;
    68.         return ret;
    69.     }
    71.     m_nStreamIndex[AVMEDIA_TYPE_VIDEO] = av_find_best_stream(m_pFormatContext, AVMEDIA_TYPE_VIDEO, -1, -1, NULL, 0);
    72.     m_nStreamIndex[AVMEDIA_TYPE_AUDIO] = av_find_best_stream(m_pFormatContext, AVMEDIA_TYPE_AUDIO, -1, -1, NULL, 0);
    74.     return ret;
    75. }
    77. int openDecoder()
    78. {
    79.     int ret = -1;
    80.     m_pCodecContext = m_pFormatContext->streams[m_nStreamIndex[AVMEDIA_TYPE_VIDEO]]->codec;
    81.     if (m_pCodecContext)
    82.     {
    83.         m_pVideoCodec = avcodec_find_decoder(m_pCodecContext->codec_id);
    84.         ret = avcodec_open2(m_pCodecContext, m_pVideoCodec, NULL);
    85.         if (ret != 0)
    86.         {
    87.             return ret;
    88.         }
    89.         avcodec_flush_buffers(m_pCodecContext);
    90.     }
    91.     return ret;
    92. }
    94. void closeDecoder()
    95. {
    96.     if (m_pVideoCodec)
    97.     {
    98.         avcodec_close(m_pCodecContext);
    99.         m_pCodecContext = NULL;
    100.     }
    101. }
    103. int decodeOneFrame(AVFrame* pFrame)
    104. {
    105.     int ret = 0;
    107.     bool frame_found = false;
    108.     int  decoded_frame_count = 0;
    109.     AVPacket pkt;
    110.     do
    111.     {
    112.         int got_frame = 0;
    113.         ret = av_read_frame(m_pFormatContext, &pkt);
    114.         if (ret < 0)
    115.         {
    116.             break;
    117.         }
    118.         if (pkt.flags != AV_PKT_FLAG_KEY)
    119.         {
    120.             av_free_packet(&pkt);
    121.             continue;
    122.         }
    123.         if (pkt.stream_index == m_nStreamIndex[AVMEDIA_TYPE_VIDEO])
    124.         {
    125.             ret = avcodec_decode_video2(m_pCodecContext, pFrame, &got_frame, &pkt);
    126.             if (got_frame && ret >=0)
    127.             {
    128.                 if (pFrame->width != m_pCodecContext->width || pFrame->height != m_pCodecContext->height)
    129.                 {
    130.                     m_pCodecContext->width = pFrame->width;
    131.                     m_pCodecContext->height = pFrame->height;
    132.                     decoded_frame_count++;
    133.                     av_free_packet(&pkt);
    134.                     continue;
    135.                 }
    136.                 decoded_frame_count++;
    137.                 //skip black and white pitures
    138.                 uint32_t y_value = 0;
    139.                 uint32_t y_half = 0;
    140.                 uint32_t y_count = 0;
    141.                 int pixel_count = pFrame->width * pFrame->height;
    142.                 bool bHalf = false;
    143.                 for (int i = 0; i < pixel_count; i+=3)
    144.                 {
    145.                     uint8_t y_temp = (uint8_t)(*(uint8_t*)((uint8_t*)(pFrame->data[0]) + i));
    146.                     y_value += y_temp;
    147.                     y_count++;
    149.                     if (!bHalf && i > pixel_count / 6)
    150.                     {
    151.                         y_half = y_value / y_count;
    152.                         bHalf = true;
    153.                     }
    154.                 }
    156.                 y_value /= y_count;
    157.                 if (y_half == y_value)
    158.                 {
    159.                     printf("decoded frame count = %d y_half=%d == y_value=%d, skip this frame!\n", decoded_frame_count, y_half, y_value);
    160.                     continue;
    161.                 }
    162.                 if (y_value < BRIGHTNESS_VALUE && y_value > DARKNESS_VALUE)
    163.                 {
    164.                     frame_found = true;
    165.                     printf("frame_found = true -----------------------decoded frame count = %d\n", decoded_frame_count);
    166.                 }
    167.             }
    168. #ifdef SAVE_YUV_FRAME    
    169.             char szName[128];
    170.             sprintf(szName, "D:\\test_%d.yuv", frame_count);
    172.             // save the yuv
    173.             FILE *pFile = fopen(szName, "ab");
    174.             if (pFile)
    175.             {
    176.                 fwrite(pFrame->data[0], 1, pFrame->width * pFrame->height, pFile);
    177.                 fwrite(pFrame->data[1], 1, pFrame->width * pFrame->height * 1 / 4, pFile);
    178.                 fwrite(pFrame->data[2], 1, pFrame->width * pFrame->height * 1 / 4, pFile);
    179.                 fclose(pFile);
    180.             }
    181. #endif            
    182.         }
    183.         av_free_packet(&pkt);
    185.     } while ((!frame_found) && (ret >= 0));
    187.     av_free_packet(&pkt);
    189.     return ret;
    190. }
    192. int getThumbnail(AVFrame* pInputFrame, AVFrame* pOutputFrame, int desW, int desH)
    193. {
    194.     if (pInputFrame == NULL || pOutputFrame == NULL)
    195.     {
    196.         return -1;
    197.     }
    198.     SwsContext* pSwsContext = NULL;
    199.     pSwsContext = sws_getCachedContext(pSwsContext, pInputFrame->width, pInputFrame->height, (AVPixelFormat)pInputFrame->format,
    200.         desW, desH, AV_PIX_FMT_RGB565, SWS_BICUBIC, NULL, NULL, NULL);
    202.     if (pSwsContext == NULL)
    203.     {
    204.         return -1;
    205.     }
    207.     m_pThumbFrame->width = desW;
    208.     m_pThumbFrame->height = desH;
    209.     m_pThumbFrame->format = AV_PIX_FMT_RGB565;
    211.     av_frame_get_buffer(m_pThumbFrame, 16);
    213.     sws_scale(pSwsContext, pInputFrame->data, pInputFrame->linesize, 0, pInputFrame->height, m_pThumbFrame->data, m_pThumbFrame->linesize);
    215.     sws_freeContext(pSwsContext);
    217.     return 0;
    218. }
    220. int getFrameAt(int64_t timeUs, int width, int height)
    221. {
    222.     int ret = -1;
    223.     AVFrame* pFrame = NULL;
    225.     ret = avformat_seek_file(m_pFormatContext, -1, INT16_MIN, timeUs, INT16_MAX, 0);
    227.     pFrame = av_frame_alloc();
    228.     m_pThumbFrame = av_frame_alloc();
    229.     ret = openDecoder();
    230.     if (ret != 0)
    231.     {
    232.         av_frame_free(&pFrame);
    233.         av_frame_free(&m_pThumbFrame);
    234.         return ret;
    235.     }
    236. #ifdef DEBUG_SPEND_TIME
    237. #ifdef _WIN32
    238.     DWORD start_time = timeGetTime();
    239. #else
    240.     struct timeval start, end;
    241.     gettimeofday(&start, NULL);
    242. #endif
    243. #endif
    245.     ret = decodeOneFrame(pFrame);
    246.     if (ret < 0)
    247.     {
    248.         av_frame_free(&pFrame);
    249.         av_frame_free(&m_pThumbFrame);
    250.         return ret;
    251.     }
    252. #ifdef DEBUG_SPEND_TIME
    253. #ifdef _WIN32
    254.     DWORD end_time = timeGetTime();
    255.     printf("decodeOneFrame spend time = %d ms\n", end_time - start_time);
    256. #else
    257.     gettimeofday(&end, NULL);
    258.     int spend_time = (end.tv_sec - start.tv_sec) * 1000 + (end.tv_usec - start.tv_usec) / 1000;
    259.     printf("spend_time = %d ms\n", spend_time);
    260. #endif
    261. #endif
    263.     ret = getThumbnail(pFrame, m_pThumbFrame, width, height);
    264.     if (ret < 0)
    265.     {
    266.         av_frame_free(&pFrame);
    267.         av_frame_free(&m_pThumbFrame);
    268.         return ret;
    269.     }
    271.     // save the rgb565
    272.     FILE *pFile = fopen(strThumbFileName, "ab");
    273.     if (pFile)
    274.     {
    275.         fwrite(m_pThumbFrame->data[0], 1, m_pThumbFrame->width * m_pThumbFrame->height * 2, pFile);
    276.         fclose(pFile);
    277.     }
    279.     av_frame_free(&pFrame);
    280.     av_frame_free(&m_pThumbFrame);
    282.     closeDecoder();    
    284.     return ret;
    285. }
    289. int _tmain(int argc, _TCHAR* argv[])
    290. {
    291.     int ret = -1;
    292.     initFFmpegContext();
    294.     int file_count = sizeof(strInputFileName) / sizeof(strInputFileName[0]);
    295.     for (int i = 0; i < file_count; i++)
    296.     {
    297.         const char* pFileName = strInputFileName[i];
    298.         ret = setDataSource(pFileName);
    300.         getFrameAt(-1, THUMB_WIDTH, THUMB_HEIGHT);
    301.     }
    303.     //pause
    304.     printf("finished, pause ....\n");
    305.     getchar();
    307.     return 0;
    308. }

    如约智惠.png