xuxiuxi

2017-05-11 109ffe9a777658936a38d0c146579a67c60a0d17

 RtspFace/PL_AVFrameBGRA.cpp

@@ -7,22 +7,25 @@
   #include <libavcodec/avcodec.h>

   #include <libavutil/frame.h>

   #include <libavformat/avformat.h>

	
   #include <libyuv.h>

}



#include <libyuv.h>



struct PL_AVFrameBGRA_Internal

{

   uint8_t buffer[1920*1080*4];//#todo

   uint8_t buffer[1920*1080*4];//#todo from config

   size_t buffSize;

   size_t buffSizeMax;

   MB_Frame lastFrame;



   bool payError;

   

   PL_AVFrameBGRA_Config config;

	
   PL_AVFrameBGRA_Internal() : 

      buffSize(0), buffSizeMax(sizeof(buffer)), lastFrame(), 

      payError(true)

      payError(true),

      config()

   {

   }

   

@@ -37,6 +40,9 @@
      

      MB_Frame _lastFrame;

      lastFrame = _lastFrame;

		
      PL_AVFrameBGRA_Config _config;

      config = _config;

   }

};



@@ -59,6 +65,12 @@
{

   PL_AVFrameBGRA_Internal* in = (PL_AVFrameBGRA_Internal*)internal;

   in->reset();

	
   if (args != nullptr)

   {

      PL_AVFrameBGRA_Config* _config = (PL_AVFrameBGRA_Config*)args;

      in->config = *_config;

   }



   return true;

}

@@ -69,64 +81,121 @@
   

}



#define SUBSAMPLE(v, a) ((((v) + (a) - 1)) / (a))



bool PL_AVFrameBGRA::pay(const PipeMaterial& pm)

{

#define SUBSAMPLE(v, a) ((((v) + (a) - 1)) / (a))



   PL_AVFrameBGRA_Internal* in = (PL_AVFrameBGRA_Internal*)internal;

   

   if (pm.type != PipeMaterial::PMT_FRAME)

   {

      LOG(ERROR) << "PL_AVFrameBGRA::pay only support PMT_FRAME";

      LOG_ERROR << "Only support PMT_FRAME" << std::endl;

      return false;

   }

   

   if (pm.buffer == nullptr)

      return false;

   

   int src_height = 0;

   int src_width = 0;

   const uint8* src_y = nullptr;

   const uint8* src_u = nullptr;

    const uint8* src_v = nullptr;

	
   MB_Frame* frame = (MB_Frame*)pm.buffer;

   if (frame->type != MB_Frame::MBFT_PTR_AVFRAME)

   if (frame->type == MB_Frame::MBFT_PTR_AVFRAME)

   {

      LOG(ERROR) << "PL_AVFrameBGRA::pay only support MBFT_PTR_AVFRAME";

      AVFrame* pAVFrame = (AVFrame*)frame->buffer;

      if (pAVFrame == nullptr)

         return false;

		
      src_height = pAVFrame->height;

      src_width = pAVFrame->width;

		
      src_y = pAVFrame->data[0];

      src_u = pAVFrame->data[1];

      src_v = pAVFrame->data[2];

   }

   if (frame->type == MB_Frame::MBFT_YUV420)

   {

      if (frame->buffer == nullptr)

         return false;

		
      src_height = frame->height;

      src_width = frame->width;

		
      src_y = (const uint8*)(frame->buffer);

      src_u = (const uint8*)(src_y + (src_height * src_width));

      src_v = (const uint8*)(src_u + (src_height * src_width / 4));

   }

   else

   {

      LOG_ERROR << "Only support MBFT_PTR_AVFRAME" << std::endl;

      return false;

   }



   AVFrame* pAVFrame = (AVFrame*)frame->buffer;

   if (pAVFrame == nullptr)

      return false;



   const int height = pAVFrame->height;

   const int width = pAVFrame->width;



//int I420ToBGRA(const uint8* src_y, int src_stride_y,

//               const uint8* src_u, int src_stride_u,

//               const uint8* src_v, int src_stride_v,

//               uint8* dst_argb, int dst_stride_argb,

//            int width, int height);

//            int width, int src_height);



   libyuv::I420ToBGRA(pAVFrame->data[0], width, 
                  pAVFrame->data[1], SUBSAMPLE(width, 2), 
                  pAVFrame->data[2], SUBSAMPLE(width, 2), 
                  in->buffer, 4 * width, 
                  width, height);

   if (in->config.convertTo == PL_AVFrameBGRA_Config::I420_TO_BGRA8888)

   {

      libyuv::I420ToBGRA(src_y, src_width, 
                     src_u, SUBSAMPLE(src_width, 2), 
                     src_v, SUBSAMPLE(src_width, 2), 
                     in->buffer, 4 * src_width, 
                     src_width, src_height);



   in->buffSize = in->buffSizeMax;

      in->buffSize = src_width * src_height * 4; // #todo use ret value?

   }

   else if (in->config.convertTo == PL_AVFrameBGRA_Config::I420_TO_ARGB8888)

   {

      libyuv::I420ToARGB(src_y, src_width, 
                     src_u, SUBSAMPLE(src_width, 2), 
                     src_v, SUBSAMPLE(src_width, 2), 
                     in->buffer, 4 * src_width, 
                     src_width, src_height);



      in->buffSize = src_width * src_height * 4; // #todo use ret value?

   }

   else if (in->config.convertTo == PL_AVFrameBGRA_Config::I420_TO_RGBA8888)

   {

      libyuv::I420ToRGBA(src_y, src_width, 
                     src_u, SUBSAMPLE(src_width, 2), 
                     src_v, SUBSAMPLE(src_width, 2), 
                     in->buffer, 4 * src_width, 
                     src_width, src_height);



      in->buffSize = src_width * src_height * 4; // #todo use ret value?

   }

   else if (in->config.convertTo == PL_AVFrameBGRA_Config::I420_TO_ARGB4444)

   {

		
   }

   else

   {

      LOG_ERROR << "PL_AVFrameBGRA_Config.convertTo not support" << std::endl;

      return false;

   }



   //in->buffer readly

   

   in->lastFrame.type = MB_Frame::MBFT_BGRA;

   in->lastFrame.buffer = in->buffer;

   in->lastFrame.buffSize = in->buffSize;

   in->lastFrame.width = width;

   in->lastFrame.height = height;

   in->lastFrame.width = src_width;

   in->lastFrame.height = src_height;

   in->lastFrame.pts = frame->pts;



   //#test

   //static size_t f=0;

   //char fname[50];

   //sprintf(fname, "%u.bgra", ++f);

   //FILE * pFile = fopen (fname,"wb");

   //fwrite (in->buffer , sizeof(char), in->buffSize, pFile);

   //fclose(pFile);

   static size_t f=0;

   char fname[50];

   sprintf(fname, "%u.rgba", ++f);

   FILE * pFile = fopen (fname,"wb");

   fwrite (in->buffer , sizeof(char), in->buffSize, pFile);

   fclose(pFile);



   return true;

}