学步园

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <windows.h>

#include "avformat.h"
#include "avcodec.h"
#include "swscale.h"

#pragma comment (lib, "avcodec.lib")
#pragma comment (lib, "avformat.lib")
#pragma comment (lib, "avutil.lib")
#pragma comment (lib, "swscale.lib")

#ifndef _WINGDI_
#define _WINGDI_

typedef struct tagBITMAPFILEHEADER {
        WORD    bfType;
        DWORD   bfSize;
        WORD    bfReserved1;
        WORD    bfReserved2;
        DWORD   bfOffBits;
} BITMAPFILEHEADER, FAR *LPBITMAPFILEHEADER, *PBITMAPFILEHEADER;

typedef struct tagBITMAPINFOHEADER{
        DWORD      biSize;
        LONG       biWidth;
        LONG       biHeight;
        WORD       biPlanes;
        WORD       biBitCount;
        DWORD      biCompression;
        DWORD      biSizeImage;
        LONG       biXPelsPerMeter;
        LONG       biYPelsPerMeter;
        DWORD      biClrUsed;
        DWORD      biClrImportant;
} BITMAPINFOHEADER, FAR *LPBITMAPINFOHEADER, *PBITMAPINFOHEADER;

#endif

void SaveAsBMP (AVFrame *pFrameRGB, int width, int height, int index, int bpp)
{
 char buf[5] = {0};
 BITMAPFILEHEADER bmpheader;
 BITMAPINFOHEADER bmpinfo;
 FILE *fp;

 char filename[20] = "R://test";
 _itoa (index, buf, 10);
 strcat (filename, buf);
 strcat (filename, ".bmp");
 
 if ( (fp=fopen(filename,"wb+")) == NULL )
  {
   printf ("open file failed!/n");
   return;
  }

 bmpheader.bfType = 0x4d42;
 bmpheader.bfReserved1 = 0;
 bmpheader.bfReserved2 = 0;
 bmpheader.bfOffBits = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER);
 bmpheader.bfSize = bmpheader.bfOffBits + width*height*bpp/8;

 bmpinfo.biSize = sizeof(BITMAPINFOHEADER);
 bmpinfo.biWidth = width;
 bmpinfo.biHeight = height;
 bmpinfo.biPlanes = 1;
 bmpinfo.biBitCount = bpp;
 bmpinfo.biCompression = BI_RGB;
 bmpinfo.biSizeImage = (width*bpp+31)/32*4*height;
 bmpinfo.biXPelsPerMeter = 100;
 bmpinfo.biYPelsPerMeter = 100;
 bmpinfo.biClrUsed = 0;
 bmpinfo.biClrImportant = 0;

 fwrite (&bmpheader, sizeof(bmpheader), 1, fp);
 fwrite (&bmpinfo, sizeof(bmpinfo), 1, fp);
 fwrite (pFrameRGB->data[0], width*height*bpp/8, 1, fp);

 fclose(fp);
}

int main (void)
{
 unsigned int i = 0, videoStream = -1;
 AVCodecContext *pCodecCtx;
 AVFormatContext *pFormatCtx;
 AVCodec *pCodec;
 AVFrame *pFrame, *pFrameRGB;
 struct SwsContext *pSwsCtx;
 const char *filename = "test.avi";
 AVPacket packet;
 int frameFinished;
 int PictureSize;
 uint8_t *buf;

 av_register_all(); 

 if ( av_open_input_file(&pFormatCtx, filename, NULL, 0, NULL) != 0 )
 {
  printf ("av open input file failed!/n");
  exit (1);
 }

 if ( av_find_stream_info(pFormatCtx) < 0 )
 {
  printf ("av find stream info failed!/n");
  exit (1);
 } 

 for ( i=0; i<pFormatCtx->nb_streams; i++ )
  if ( pFormatCtx->streams[i]->codec->codec_type == CODEC_TYPE_VIDEO )
  {
   videoStream = i;
   break;
  }

 if (videoStream == -1)
 {
  printf ("find video stream failed!/n");
  exit (1);
 }

 pCodecCtx = pFormatCtx->streams[videoStream]->codec;

 pCodec = avcodec_find_decoder (pCodecCtx->codec_id);

 if (pCodec == NULL)
 {
  printf ("avcode find decoder failed!/n");
  exit (1);
 }

 if ( avcodec_open(pCodecCtx, pCodec)<0 )
 {
  printf ("avcode open failed!/n");
  exit (1);
 }

 pFrame = avcodec_alloc_frame();
 pFrameRGB = avcodec_alloc_frame();
 
 if ( (pFrame==NULL)||(pFrameRGB==NULL) )
 {
  printf("avcodec alloc frame failed!/n");
  exit (1);
 }

 PictureSize = avpicture_get_size (PIX_FMT_BGR24, pCodecCtx->width, pCodecCtx->height);

 buf = av_malloc(PictureSize);

 if ( buf == NULL )
 {
  printf( "av malloc failed!/n");
  exit(1);
 }

 avpicture_fill ( (AVPicture *)pFrameRGB, buf, PIX_FMT_BGR24, pCodecCtx->width, pCodecCtx->height); 

 pSwsCtx = sws_getContext (pCodecCtx->width,
         pCodecCtx->height,
         pCodecCtx->pix_fmt,
         pCodecCtx->width,
         pCodecCtx->height,
         PIX_FMT_BGR24,
         SWS_BICUBIC,
         NULL, NULL, NULL);

 i = 0;

 while(av_read_frame(pFormatCtx, &packet) >= 0)
 {
  if(packet.stream_index==videoStream)
  {
   avcodec_decode_video(pCodecCtx, pFrame, &frameFinished, packet.data, packet.size);
   
   if(frameFinished)
   {    
    //反转图像
    //*(pFrame->data[0]) =  pCodecCtx->width * (pCodecCtx->height-1);
    //pFrame ->linesize[0] = -(pCodecCtx->height);
    pFrame->data[0] += pFrame->linesize[0] * (pCodecCtx->height - 1);
    pFrame->linesize[0] *= -1;
    pFrame->data[1] += pFrame->linesize[1] * (pCodecCtx->height / 2 - 1);
    pFrame->linesize[1] *= -1;
    pFrame->data[2] += pFrame->linesize[2] * (pCodecCtx->height / 2 - 1);
    pFrame->linesize[2] *= -1;
    
    sws_scale (pSwsCtx, pFrame->data, pFrame->linesize, 0, pCodecCtx->height, pFrameRGB->data, pFrameRGB->linesize);

    SaveAsBMP (pFrameRGB, pCodecCtx->width, pCodecCtx->height, i++, 24);
   }     
  }
  av_free_packet(&packet);
 }

 sws_freeContext (pSwsCtx);
 av_free (pFrame);
 av_free (pFrameRGB);
 avcodec_close (pCodecCtx);
 av_close_input_file (pFormatCtx);

 return 0;
}