2. 程式人生 > 實用技巧 >libyuv實現通用的cvt,resize,crop功能

libyuv實現通用的cvt,resize,crop功能

阿新 • • 發佈：2020-10-09

我實現的思路是所有的格式先轉成i420，然後進行crop resize 以及cvt的操作。

Get Fourcc code

uint32_t Scaler::GetFOURCC(const Scaler::Buffer *src) {
  uint32_t fourcc = 0;
  
  switch (src->color) {
    case Scaler::ColorFormat::YUV_I420:
      fourcc = libyuv::FourCC::FOURCC_I420;
      break;
    
    case Scaler::ColorFormat::YUV_NV21:
      fourcc = libyuv::FourCC::FOURCC_NV21;
      break;
    
    case Scaler::ColorFormat::YUV_NV12:
      fourcc = libyuv::FourCC::FOURCC_NV12;
      break;
    
    case Scaler::ColorFormat::BGR:
      fourcc = libyuv::FourCC::FOURCC_24BG;
      break;

    case Scaler::ColorFormat::RGB:
      fourcc = libyuv::FourCC::FOURCC_RAW;
      break;
    
    case Scaler::ColorFormat::BGRA:
      fourcc = libyuv::FourCC::FOURCC_ARGB;
      break;
    
    case Scaler::ColorFormat::ARGB:
      fourcc = libyuv::FourCC::FOURCC_BGRA;
      break;
    
    case Scaler::ColorFormat::RGBA:
      fourcc = libyuv::FourCC::FOURCC_ABGR;
      break;

    case Scaler::ColorFormat::ABGR:
      fourcc = libyuv::FourCC::FOURCC_RGBA;
      break;

    default:
      LOG(ERROR) << "libyuv not support this color cvt I420";
      break;
  }
  return fourcc;
}

Process

bool LibyuvProcess(const Scaler::Buffer *src, Scaler::Buffer *dst, const Scaler::Rect *crop) {
  if (!src || !dst) return false;

  if (!crop && src->width == dst->width && src->height == dst->height && src->color == dst->color) {
    // copy src to dst directly 
    bool src_continus = IsBufferContinus_(src);
    bool dst_continus = IsBufferContinus_(dst);
    if (src->color <= Scaler::ColorFormat::YUV_I420) {
      if (src_continus && dst_continus) {
        memcpy(dst->data[0], src->data[0], src->width * src->height * 3 / 2);
      } else {
        memcpy(dst->data[0], src->data[0], src->width * src->height);
        memcpy(dst->data[1], src->data[1], src->width * src->height / 4);
        memcpy(dst->data[2], src->data[2], src->width * src->height / 4);
      }

    } else if (src->color <= Scaler::ColorFormat::YUV_NV12) {
      if (src_continus && dst_continus) {
         memcpy(dst->data[0], src->data[0], src->width * src->height * 3 / 2);
      } else {
         memcpy(dst->data[0], src->data[0], src->width * src->height);
         memcpy(dst->data[1], src->data[1], src->width * src->height / 2); 
      }

    } else if (src->color <= Scaler::ColorFormat::RGB) {
      memcpy(dst->data[0], src->data[0], src->width * src->height * 3);
      dst->data[1] = dst->data[2] = nullptr;
    } else if (src->color <= Scaler::ColorFormat::ARGB) {
      memcpy(dst->data[0], src->data[0], src->width * src->height * 4);
      dst->data[1] = dst->data[2] = nullptr;
    } else {
      LOG(ERROR) << "scaler, we not realize this color space" << src->color;
      return false;
    }
    for (size_t i = 0; i < 3; i++) {
      dst->stride[i] = src->stride[i];
    }
    return true;
  } 
  /*
    // TODO after firist, "else if" is test , will be move future
    if (src->color == Scaler::ColorFormat::BGR && dst->color == Scaler::ColorFormat::YUV_NV21) {
      Scaler::LibyuvCvtBGRToNV21_Process(src, dst, crop);
    } else if (src->color == ColorFormat::YUV_NV21 && dst->color == ColorFormat::YUV_NV21) {
      Scaler::LibyuvResize_NV21(src, dst);
    } else if (src->color == ColorFormat::BGR && dst->color == ColorFormat::YUV_I420) {
      Scaler::LibyuvCvtBGRtoI420(src, dst);
    } else if (src->color == ColorFormat::YUV_I420 && dst->color == ColorFormat::YUV_I420) {
      Scaler::LibyuvResize_I420(src, dst);
    }
  */
    uint32_t width = src->width;
    uint32_t height = src->height;
    Scaler::Buffer *src_crop = nullptr;
    Scaler::Buffer *resize_buf = nullptr;
    if (crop != nullptr) {
      width = crop->w;
      height = crop->h;
      if (width == dst->width && height == dst->height && src->color == dst->color) {
        if (src->color == Scaler::ColorFormat::YUV_I420) {
          dst->stride[0] = src->width;
          dst->stride[1] = dst->stride[2] = src->width >> 1;
          memcpy(dst->data[0], src->data[0], src->stride[0] * src->height);
          memcpy(dst->data[1], src->data[1], dst->stride[1] * dst->height / 2);
          memcpy(dst->data[1], src->data[1], dst->stride[1] * dst->height / 2);
        } else if (src->color <= ColorFormat::YUV_NV12) {
          dst->stride[0] = dst->stride[1] = src->width;
          memcpy(dst->data[0], src->data[0], src->stride[0] * src->height);
          memcpy(dst->data[1], src->data[1], src->stride[1] * src->height);
        } else if (src->color <= ColorFormat::ARGB) {
          dst->stride[0] = src->stride[0];
          memcpy(dst->data[0], src->data[0], dst->stride[0] * src->height);
        } else {
          LOG(ERROR) << "scaler not support this color space";
        }
        return true;
      } else {
        src_crop = new Scaler::Buffer();
        src_crop->color = Scaler::ColorFormat::YUV_I420;
        src_crop->width = crop->w;
        src_crop->height = crop->h;
        src_crop->stride[0] = src_crop->width;
        src_crop->stride[1] = src_crop->stride[2] = src_crop->width >> 1;
        src_crop->data[0] = new uint8_t[src_crop->width * src_crop->height * 3 / 2];
        src_crop->data[1] = src_crop->data[0] + src_crop->width * src_crop->height;
        src_crop->data[2] = src_crop->data[1] + src_crop->width * src_crop->height / 4;
        Scaler::LibyuvToI420(src, src_crop, crop);
      }
    }
    

    if (width != dst->width || height != dst->height) {
      resize_buf = new Scaler::Buffer();
      memset(resize_buf, 0, sizeof(Scaler::Buffer));
      resize_buf->color= Scaler::ColorFormat::YUV_I420;
      resize_buf->width = dst->width;
      resize_buf->height = dst->height;
      resize_buf->stride[0] = resize_buf->width;
      resize_buf->stride[1] = resize_buf->stride[2] = resize_buf->width >> 1;
      resize_buf->data[0] = new uint8_t[resize_buf->width * resize_buf->height * 3 / 2];
      resize_buf->data[1] = resize_buf->data[0] + resize_buf->width * resize_buf->height;
      resize_buf->data[2] = resize_buf->data[1] + resize_buf->width * resize_buf->height / 4;

      if (src_crop == nullptr) {
        src_crop = new Scaler::Buffer();
        src_crop->color = Scaler::ColorFormat::YUV_I420;
        src_crop->width = src->width;
        src_crop->height = src->height;
        src_crop->stride[0] = src_crop->width;
        src_crop->stride[1] = src_crop->stride[2] = src_crop->width >> 1;
        src_crop->data[0] = new uint8_t[src_crop->width * src_crop->height * 3 / 2];
        src_crop->data[1] = src_crop->data[0] + src_crop->width * src_crop->height;
        src_crop->data[2] = src_crop->data[1] + src_crop->width * src_crop->height / 4;
        Scaler::LibyuvToI420(src, src_crop, nullptr); 
      } 

      libyuv::I420Scale(src_crop->data[0], src_crop->stride[0],
                        src_crop->data[1], src_crop->stride[1],
                        src_crop->data[2], src_crop->stride[2],
                        src_crop->width, src_crop->height,
                        resize_buf->data[0], resize_buf->stride[0],
                        resize_buf->data[1], resize_buf->stride[1],
                        resize_buf->data[2], resize_buf->stride[2],
                        resize_buf->width, resize_buf->height,
                        libyuv::FilterMode::kFilterNone);
    }

    if (dst->color != Scaler::ColorFormat::YUV_I420) {
      // i420 covert to dst->color, output to dst->data
      if (resize_buf != nullptr) {
        Scaler::LibyuvConvertFromI420(resize_buf, dst);
        if (src_crop != nullptr) {
          delete[] src_crop->data[0];
          src_crop->data[0] = nullptr;
          delete src_crop;
          src_crop = nullptr;
        }
        delete[] resize_buf->data[0];
        delete resize_buf;
        resize_buf->data[0] = resize_buf->data[1] = resize_buf->data[2] = nullptr;
        resize_buf = nullptr;
        return true;
      }  
      if (src_crop == nullptr) {
        src_crop = new Scaler::Buffer();
        src_crop->color = Scaler::ColorFormat::YUV_I420;
        src_crop->width = src->width;
        src_crop->height = src->height;
        src_crop->stride[0] = src_crop->width;
        src_crop->stride[1] = src_crop->stride[2] = src_crop->width >> 1;
        src_crop->data[0] = new uint8_t[src_crop->width * src_crop->height * 3 / 2];
        src_crop->data[1] = src_crop->data[0] + src_crop->width * src_crop->height;
        src_crop->data[2] = src_crop->data[1] + src_crop->width * src_crop->height / 4;
        Scaler::LibyuvToI420(src, src_crop, nullptr);
      }
      Scaler::LibyuvConvertFromI420(src_crop, dst);
      if (src_crop != nullptr) {
        delete[] src_crop->data[0];
        delete src_crop;
        src_crop->data[0] = src_crop->data[1] = src_crop->data[2] = nullptr;
        src_crop = nullptr;
      }
      return true;

    } else {
      if (resize_buf != nullptr) {
        memcpy(dst->data[0], resize_buf->data[0], dst->width * dst->height * 3 / 2);
      } else {
        Scaler::LibyuvToI420(src, dst, nullptr); 
      }
    }
    if (src_crop != nullptr) {
      delete[] src_crop->data[0];
      src_crop->data[0] = src_crop->data[1] = src_crop->data[2] = nullptr;
      delete src_crop;
      src_crop = nullptr;
    }
    if (resize_buf != nullptr) {
      delete[] resize_buf->data[0];
      resize_buf->data[0] = resize_buf->data[1] = resize_buf->data[2] = nullptr;
      delete resize_buf;
      resize_buf = nullptr;
    }
    return true;
}

轉換成Ｉ４２０

void Scaler::LibyuvToI420(const Buffer *src,
                          Buffer *dst,
                          const Rect *crop) {
  size_t frame_size = 0;
  if (src->color <= Scaler::ColorFormat::YUV_NV12) {
    frame_size = src->stride[0] * src->height * 3 / 2;
  } else if (src->color <= Scaler::ColorFormat::ARGB) {
    frame_size = src->stride[0] * src->height;
  }
  uint32_t fourcc = Scaler::GetFOURCC(src);
  if (crop != nullptr) {
    libyuv::ConvertToI420(src->data[0], frame_size,
                          dst->data[0], dst->stride[0],
                          dst->data[1], dst->stride[1],
                          dst->data[2], dst->stride[2],
                          crop->x, crop->y,
                          src->width, src->height,
                          crop->w, crop->h,
                          libyuv::RotationMode::kRotate0,
                          fourcc);

  } else {
    libyuv::ConvertToI420(src->data[0], frame_size,
                         dst->data[0], dst->stride[0],
                         dst->data[1], dst->stride[1],
                         dst->data[2], dst->stride[2],
                         0, 0,
                         src->width, src->height,
                         dst->width, dst->height,
                         libyuv::RotationMode::kRotate0,
                         fourcc);
  }

}

由I420轉成輸出格式

void Scaler::LibyuvConvertFromI420(const Buffer *src,
                                   Buffer *dst) {
  /*
  size_t frame_size = 0;
  if (src->color <= Scaler::ColorFormat::YUV_NV12) {
    frame_size = src->stride[0] * src->height * 3 / 2;
  } else if (src->color <= Scaler::ColorFormat::ARGB) {
    frame_size = src->stride[0] * src->height;
  }
  */
  uint32_t fourcc = Scaler::GetFOURCC(dst);
  libyuv::ConvertFromI420(src->data[0], src->stride[0],
                          src->data[1], src->stride[1],
                          src->data[2], src->stride[2],
                          dst->data[0],dst->stride[0],
                          dst->width, dst->height,
                          fourcc);
}

因為轉成ｉ４２0中間格式，所以要求圖片長寬必須是偶數

相關推薦

libyuv實現通用的cvt,resize,crop功能

我實現的思路是所有的格式先轉成i420，然後進行crop resize 以及cvt的操作。 Get Fourcc code

Java 用註解實現通用功能-csv檔案的讀取為例

引言 使用java註解可以實現一些共通的功能，假設有幾種格式的csv檔案，編碼，分隔符，頭部行數之類的定義各不相同，但我們想統一的處理他們，那就需要一個共通的方法。

Arcgis模型構建器案例教程-while和for實現通用的迴圈迭代功能

Arcgis模型構建器案例教程-while和for實現通用的迴圈迭代功能 功能：利用模型構建器的while和for，實現多種通用迴圈功能。

Redis 到底是怎麼實現“附近的人”這個功能的呢？

作者簡介 萬汨，餓了麼資深開發工程師。iOS，Go，Java均有涉獵。目前主攻大資料開發。喜歡騎行、爬山。

Spring框架實現AOP新增日誌記錄功能過程詳解

這篇文章主要介紹了Spring框架實現AOP新增日誌記錄功能過程詳解,文中通過示例程式碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下

C語言 不使用strcat函式實現連線兩個字串功能程式碼

字串連線函式： 字串連線就是將一個字串連線到另一個字串的末尾，使其組合成一個新的字串，在字串處理函式中，strcat 函式具有字串連線功能。下面是用C語言實現不使用是strcat 函式實現連線兩個字串的功能。

利用Java實現複製Excel工作表功能

本文歸納了關於Java如何複製Excel工作表的方法，按不同複製需求，可分為： 1. 複製工作表

Java實現商城訂單超時取消功能

大多數的B2C商城專案都會有限時活動，當用戶下單後都會有支付超時時間，當訂單超時後訂單的狀態就會自動變成已取消 ，這個功能的實現有很多種方法，本文的實現方法適合大多數比較小的商城使用。

AccessibilityService實現微信發紅包功能

在AccessibilityService中我們可以做模擬操作，下面記述下通過AccessibilityService實現微信發紅包的功能

springboot實現多檔案上傳功能

本文實現springboot的多檔案上傳，首先建立一個springboot專案，新增spring-boot-starter-web依賴。

SpringSecurity動態載入使用者角色許可權實現登入及鑑權功能

很多人覺得Spring Security實現登入驗證很難，我最開始學習的時候也這樣覺得。因為我好久都沒看懂我該怎麼樣將自己寫的用於接收使用者名稱密碼的Controller與Spring Security結合使用，這是一個先入為主的誤區。後來

Spring Boot 2 整合 QuartJob 實現定時器實時管理功能

一、QuartJob簡介 1、一句話描述 Quartz是一個完全由java編寫的開源作業排程框架，形式簡易，功能強大。

JAVA基於陣列實現的商品資訊查詢功能示例

本文例項講述了JAVA基於陣列實現的商品資訊查詢功能。分享給大家供大家參考，具體如下：

Android實現通用篩選欄

今天來寫一個通用的篩選欄的實現,也是因為之前專案中要好多地方用到篩選欄這麼個東西,所以為了之後用起來比較方便,就簡單的做了一些封裝.廢話不多說,看一下效果圖:

基於Redis無序集合如何實現禁止多端登入功能

前言 一個集合型別可以儲存最多2^32 -1 個字串 集合型別在redis內部使用值為空的散列表（hash table）實現，所以集合中的加入或刪除元素等時間複雜度為O(1)。

Python實現的redis分散式鎖功能示例

本文例項講述了Python實現的redis分散式鎖功能。分享給大家供大家參考，具體如下：

利用Python程式碼實現一鍵摳背景功能

前言 又是一個逛csdn發現的一個有趣的小專案，可以一鍵摳背景，需要用到removebg模組及其API，API可從其官網免費獲取，網址如下https://www.remove.bg/zh

Python實現圖片識別加翻譯功能

Python使用百度AI介面實現圖片識別加翻譯 python誕生30週年 # encoding:utf-8 import requests

python基於TCP實現的檔案下載器功能案例

本文例項講述了python基於TCP實現的檔案下載器功能。分享給大家供大家參考，具體如下：

Python udp網路程式實現傳送、接收資料功能示例

本文例項講述了Python udp網路程式實現傳送、接收資料功能。分享給大家供大家參考，具體如下：