ffmpeg解碼h264檔案，opencv顯示

阿新 • • 發佈：2019-01-16

H264.h

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <string.h>
#include <winsock2.h>

typedef struct
{
    int startcodeprefix_len;      //! 4 for parameter sets and first slice in picture, 3 for everything else (suggested)
    unsigned len;                 //! Length of the NAL unit (Excluding the start code, which does not belong to the NALU) 

    unsigned max_size;            //! Nal Unit Buffer size
    int forbidden_bit;            //! should be always FALSE
    int nal_reference_idc;        //! NALU_PRIORITY_xxxx
    int nal_unit_type;            //! NALU_TYPE_xxxx    
    char *buf;                    //! contains the first byte followed by the EBSP 

    unsigned short lost_packets;  //! true, if packet loss is detected
} NALU_t;

int GetNalu();
void FreeNALU(NALU_t *n);
NALU_t *AllocNALU(int buffersize);
void OpenBitstreamFile(char *fn);
int GetAnnexbNALU(NALU_t *nalu);
void dump(NALU_t *nal);
int DumpChar(char * filename, char * buf, int len);
FILE * getFile();

H264.cpp

// rtspSend.cpp : Defines the entry point for the console application.
//


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <memory.h>
#include "h264.h"
static char* dumpRoot = ".\\dump\\";
static char file2open[1024];
#define  UDP_MAX_SIZE 1400



FILE *bits = NULL;                //!< the bit stream file
static int FindStartCode2(unsigned char *Buf);//查詢開始字元0x000001
static int FindStartCode3(unsigned char *Buf);//查詢開始字元0x00000001

// 
 static int info2=0, info3=0;
// RTP_FIXED_HEADER *rtp_hdr;

// NALU_HEADER      *nalu_hdr;
// FU_INDICATOR *fu_ind;
// FU_HEADER        *fu_hdr;

FILE * getFile()
{
    return bits;
}

//為NALU_t結構體分配記憶體空間
NALU_t *AllocNALU(int buffersize)
{
    NALU_t *nal =NULL;

    if ((nal = (NALU_t*)calloc (1, sizeof (NALU_t))) == NULL)
    {
        printf("AllocNALU: n");
        exit(0);
    }

    nal->max_size=buffersize;

    if ((nal->buf = (char*)calloc (buffersize, sizeof (char))) == NULL)
    {
        free (nal);
        printf ("AllocNALU: nal->buf");
        exit(0);
    }

    return nal;
}

//釋放
void FreeNALU(NALU_t *n)
{
    if (n)
    {
        if (n->buf)
        {
            free(n->buf);
            n->buf=NULL;
        }
        free (n);
    }
}

void OpenBitstreamFile (char *fn)
{
    if (NULL == (bits=fopen(fn, "rb")))
    {
        printf("open file error\n");
        exit(0);
    }
}

//這個函式輸入為一個NAL結構體，主要功能為得到一個完整的NALU並儲存在NALU_t的buf中，
//獲取他的長度，填充F,IDC,TYPE位。
//並且返回兩個開始字元之間間隔的位元組數，即包含有字首的NALU的長度
int GetAnnexbNALU (NALU_t *nalu)
{
    int pos = 0;
    int StartCodeFound, rewind;
    unsigned char *Buf;

    if ((Buf = (unsigned char*)calloc (nalu->max_size , sizeof(char))) == NULL) 
        printf ("GetAnnexbNALU: Could not allocate Buf memory\n");

    nalu->startcodeprefix_len=3;//初始化碼流序列的開始字元為3個位元組

    if (3 != fread (Buf, 1, 3, bits))//從碼流中讀3個位元組
    {
        free(Buf);
        return 0;
    }
    info2 = FindStartCode2 (Buf);//判斷是否為0x000001 
    if(info2 != 1) 
    {
        //如果不是，再讀一個位元組
        if(1 != fread(Buf+3, 1, 1, bits))//讀一個位元組
        {
            free(Buf);
            return 0;
        }
        info3 = FindStartCode3 (Buf);//判斷是否為0x00000001
        if (info3 != 1)//如果不是，返回-1
        { 
            free(Buf);
            return -1;
        }
        else 
        {
            //如果是0x00000001,得到開始字首為4個位元組
            pos = 4;
            nalu->startcodeprefix_len = 4;
        }
    }
    else
    {
        //如果是0x000001,得到開始字首為3個位元組
        nalu->startcodeprefix_len = 3;
        pos = 3;
    }
    //查詢下一個開始字元的標誌位
    StartCodeFound = 0;
    info2 = 0;
    info3 = 0;

    while (!StartCodeFound)
    {
        if (feof (bits))//判斷是否到了檔案尾
        {
            nalu->len = (pos-1)-nalu->startcodeprefix_len;
            memcpy (nalu->buf, &Buf[nalu->startcodeprefix_len], nalu->len);     
            nalu->forbidden_bit = nalu->buf[0] & 0x80; //1 bit
            nalu->nal_reference_idc = nalu->buf[0] & 0x60; // 2 bit
            nalu->nal_unit_type = (nalu->buf[0]) & 0x1f;// 5 bit
            free(Buf);
            return pos-1;
        }
        Buf[pos++] = fgetc (bits);//讀一個位元組到BUF中
        info3 = FindStartCode3(&Buf[pos-4]);//判斷是否為0x00000001
        if(info3 != 1)
            info2 = FindStartCode2(&Buf[pos-3]);//判斷是否為0x000001
        StartCodeFound = (info2 == 1 || info3 == 1);
    }

    // Here, we have found another start code (and read length of startcode bytes more than we should
    // have.  Hence, go back in the file
    rewind = (info3 == 1)? -4 : -3;

    if (0 != fseek (bits, rewind, SEEK_CUR))//把檔案指標指向前一個NALU的末尾
    {
        free(Buf);
        printf("GetAnnexbNALU: Cannot fseek in the bit stream file");
    }

    // Here the Start code, the complete NALU, and the next start code is in the Buf.  
    // The size of Buf is pos, pos+rewind are the number of bytes excluding the next
    // start code, and (pos+rewind)-startcodeprefix_len is the size of the NALU excluding the start code

    nalu->len = (pos+rewind)-nalu->startcodeprefix_len;
    memcpy (nalu->buf, &Buf[nalu->startcodeprefix_len], nalu->len);//拷貝一個完整NALU，不拷貝起始字首0x000001或0x00000001
    nalu->forbidden_bit = nalu->buf[0] & 0x80;      //1 bit
    nalu->nal_reference_idc = nalu->buf[0] & 0x60;  //2 bit
    nalu->nal_unit_type = (nalu->buf[0]) & 0x1f;    //5 bit
    free(Buf);

    return (pos+rewind);//返回兩個開始字元之間間隔的位元組數，即包含有字首的NALU的長度
}

static int FindStartCode2 (unsigned char *Buf)
{
    if(Buf[0]!=0 || Buf[1]!=0 || Buf[2] !=1) 
        return 0; //判斷是否為0x000001,如果是返回1
    else 
        return 1;
}

static int FindStartCode3 (unsigned char *Buf)
{
    if(Buf[0]!=0 || Buf[1]!=0 || Buf[2] !=0 || Buf[3] !=1) 
        return 0;//判斷是否為0x00000001,如果是返回1
    else 
        return 1;
}

int rtpnum = 0;

//輸出NALU長度和TYPE
void dump(NALU_t *nal)
{
    if (!nal) 
        return;
    printf("%3d, len: %6d  ",rtpnum++, nal->len);
    printf("nal_unit_type: %x\n", nal->nal_unit_type);
}

int DumpChar(char * filename, char * buf, int len)
{
    FILE* file;
    int w, h;
    unsigned char * temp = (unsigned char *)buf;
    sprintf(file2open, "%s%s", dumpRoot, filename);
    int mHeight = 0;
    int mWidth = 100;
    int mYu = 0;
    mHeight = len / 100;
    mYu = len % 100;
    file = fopen(file2open, "w+");
    for (h = 0; h < mHeight; h++)
    {
        for (w = 0; w < mWidth - 1; w++)
        {
            fprintf_s(file, "%3x,", temp[h * mWidth + w]);
        }
        fprintf_s(file, "%3x\n", temp[h * mWidth + w]);
    }

    for (w = 0; w < mYu - 1; w++)
    {
        fprintf_s(file, "%3x,", temp[h * mWidth + w]);
    }
    fprintf_s(file, "%3x\n", temp[h * mWidth + w]);
    fclose(file);
    return 0;
}

Nalu2BGR.h

extern "C"
{
#include "libavcodec/avcodec.h"
#include "libavformat/avformat.h"
#include "libswscale/swscale.h"
#include "libavutil/avutil.h" 
};

typedef struct
{
    AVCodec         *pCodec = NULL;
    AVCodecContext  *pCodecCtx = NULL;
    SwsContext      *img_convert_ctx = NULL;
    AVFrame         *pFrame = NULL;
    AVFrame         *pFrameBGR = NULL;

    int first;
    unsigned char * outBuffer;

}Nalu2BGR_Info;

Nalu2BGR_Info * H264_Init(void);
int H264_2_RGB(Nalu2BGR_Info * pNalu2BGR_Info, char *inputbuf, int frame_size, unsigned char *outputbuf, unsigned int*outsize);
void H264_Release(Nalu2BGR_Info * pNalu2BGR_Info);

Nalu2BGR.cpp

#include "Nalu2BGR.h"

Nalu2BGR_Info * H264_Init(void)
{
    Nalu2BGR_Info * pNalu2BGR_Info = (Nalu2BGR_Info *)calloc(1, sizeof(Nalu2BGR_Info));
    /* register all the codecs */
    avcodec_register_all();

    /* find the h264 video decoder */
    pNalu2BGR_Info->pCodec = avcodec_find_decoder(AV_CODEC_ID_H264);
    if (!pNalu2BGR_Info->pCodec) {
        fprintf(stderr, "codec not found\n");
    }
    pNalu2BGR_Info->pCodecCtx = avcodec_alloc_context3(pNalu2BGR_Info->pCodec);

    //初始化引數，下面的引數應該由具體的業務決定  
    pNalu2BGR_Info->pCodecCtx->time_base.num = 1;
    pNalu2BGR_Info->pCodecCtx->frame_number = 1; //每包一個視訊幀  
    pNalu2BGR_Info->pCodecCtx->codec_type = AVMEDIA_TYPE_VIDEO;
    pNalu2BGR_Info->pCodecCtx->bit_rate = 0;
    pNalu2BGR_Info->pCodecCtx->time_base.den = 30;//幀率  
    pNalu2BGR_Info->pCodecCtx->width = 640;//視訊寬  
    pNalu2BGR_Info->pCodecCtx->height = 480;//視訊高  

    /* open the coderc */
    if (avcodec_open2(pNalu2BGR_Info->pCodecCtx, pNalu2BGR_Info->pCodec, NULL) < 0) {
        fprintf(stderr, "could not open codec\n");
    }
    // Allocate video frame  
    //pNalu2BGR_Info->pFrame = new AVFrame[640 * 480 * 3];
    pNalu2BGR_Info->pFrame = av_frame_alloc();
    if (pNalu2BGR_Info->pFrame == NULL)
        return NULL;
    // Allocate an AVFrame structure  
    //pNalu2BGR_Info->pFrameBGR = new AVFrame[640 * 480 * 3];
    pNalu2BGR_Info->pFrameBGR = av_frame_alloc();
    if (pNalu2BGR_Info->pFrameBGR == NULL)
        return NULL;
    pNalu2BGR_Info->first = 0;
    pNalu2BGR_Info->outBuffer = NULL;
    return pNalu2BGR_Info;

}

int H264_2_RGB(Nalu2BGR_Info * pNalu2BGR_Info, char *inputbuf, int frame_size, unsigned char *outputbuf, unsigned int*outsize)
{
    uint8_t         *buffer = NULL;

    AVCodec         *pCodec = pNalu2BGR_Info->pCodec;
    AVCodecContext  *pCodecCtx = pNalu2BGR_Info->pCodecCtx;

    AVFrame         *pFrame = pNalu2BGR_Info->pFrame;
    AVFrame         *pFrameBGR = pNalu2BGR_Info->pFrameBGR;

    printf("Video decoding\n");
    int ret, got_picture;
    AVPacket packet;
    av_init_packet(&packet);
    packet.size = frame_size;
    packet.data = (uint8_t *)inputbuf;

    ret = avcodec_decode_video2(pCodecCtx, pFrame, &got_picture, &packet);
    if (ret < 0)
    {
        printf("Decode Error. ret = %d（解碼錯誤）\n", ret);
        return -1;
    }
    if (pNalu2BGR_Info->first == 0)
    {
        pNalu2BGR_Info->outBuffer = (uint8_t *)av_malloc(avpicture_get_size(AV_PIX_FMT_BGR24, pCodecCtx->width, pCodecCtx->height));
        avpicture_fill((AVPicture *)pFrameBGR, pNalu2BGR_Info->outBuffer, AV_PIX_FMT_BGR24, pCodecCtx->width, pCodecCtx->height);
        pNalu2BGR_Info->first = 1;
        pNalu2BGR_Info->img_convert_ctx = sws_getContext(pCodecCtx->width, pCodecCtx->height, pCodecCtx->pix_fmt, pCodecCtx->width, pCodecCtx->height, AV_PIX_FMT_BGR24, SWS_BICUBIC, NULL, NULL, NULL);

    }
    sws_scale(pNalu2BGR_Info->img_convert_ctx, (const uint8_t* const*)pFrame->data, pFrame->linesize, 0, pCodecCtx->height, pFrameBGR->data, pFrameBGR->linesize);
    memcpy(outputbuf, pFrameBGR->data[0], pCodecCtx->width * pCodecCtx->height * 3);
    *outsize = pCodecCtx->width * pCodecCtx->height * 3;

    return 0;
}
void H264_Release(Nalu2BGR_Info * pNalu2BGR_Info)
{
    avcodec_close(pNalu2BGR_Info->pCodecCtx);
    av_free(pNalu2BGR_Info->pCodecCtx);
    av_free(pNalu2BGR_Info->pFrame);
    av_free(pNalu2BGR_Info->pFrameBGR);
    free(pNalu2BGR_Info->outBuffer);
}

main.cpp

#include "opencv2/opencv.hpp"
#include "Nalu2BGR.h"
#include "H264.h"


int main(int argc, char* argv[])
{
    OpenBitstreamFile("./src01.h264");
    NALU_t *nal;
    char fName[300];
    int Frame = 0;
    nal = AllocNALU(8000000);//為結構體nalu_t及其成員buf分配空間。返回值為指向nalu_t儲存空間的指標

    Nalu2BGR_Info * pNalu2BGR_Info = H264_Init();

    unsigned char *outputbuf = (unsigned char *)calloc(1000 * 1000, sizeof(char));
    unsigned int outsize = 0;

    unsigned char *m_pData = (unsigned char *)calloc(1000 * 1000, sizeof(char));

    int sizeHeBing = 0;
    while (!feof(getFile()))
    {
        GetAnnexbNALU(nal);//每執行一次，檔案的指標指向本次找到的NALU的末尾，
                           //下一個位置即為下個NALU的起始碼0x000001
        dump(nal);//輸出NALU長度和TYPE

        sprintf(fName, "dump[Len=%d][%d].txt", nal->len, Frame);

        memset(m_pData, 0, 4);
        m_pData[3] = 1;
        memcpy(m_pData + 4, nal->buf, nal->len);
        sizeHeBing = nal->len + 4;
        Frame++;

        int ret = H264_2_RGB(pNalu2BGR_Info, (char *)m_pData, sizeHeBing, outputbuf, &outsize);
        if (ret != 0)
            continue;

        cv::Mat  image = cv::Mat(pNalu2BGR_Info->pCodecCtx->height, pNalu2BGR_Info->pCodecCtx->width, CV_8UC3);

        memcpy(image.data, outputbuf, pNalu2BGR_Info->pCodecCtx->height * pNalu2BGR_Info->pCodecCtx->width * 3);

        cv::imshow("xxx", image);

        cv::waitKey(40);


    }

    FreeNALU(nal);
    return 0;
}

ffmpeg解碼h264檔案，opencv顯示

H264.h #include <stdio.h> #include <stdlib.h> #include <conio.h> #include <string.h> #include <winsock2

FFmpeg解碼MP4檔案為h264和YUV檔案

#include <iostream> #ifdef __cplusplus extern "C" { #endif #include <libavcodec/avcodec.h> #include <libavformat/avformat.h> #in

FFmpeg解碼H264裸流並轉換成opencv Mat

最近要搞一些視訊推流的事情,要解析H264裸流並且獲取opencv格式的Mat資料給演算法工程師們跑演算法.相關資源一直很難找到,經常都是太舊導致API版本都更新換代了,沒辦法讓新人或者外行[比如我]快速驗證程式碼是否可行.在參考多個部落格,前人的程式碼

ffmpeg解碼視訊檔案並播放

最近學習了一下如何使用ffmpeg解碼音視訊，網上的教程挺多但是也挺雜的，搞了好幾天，明白了ffmpeg解碼音視訊的大體流程，這裡記錄一下ffmpeg解碼視訊並播放音視訊的例子，但並沒有做音訊、視訊播放的同步處理。直接上程式碼: #include &l

使用FFMpeg 解碼音訊檔案

本篇文章將介紹使用FFMpeg解碼音訊檔案為PCM的資料。使用FFMpeg獲取想要的音訊資料的步驟如下：解封裝(MP3檔案)->解碼(MP3編碼)->PCM資料重取樣 1. 解封裝使用FFMpeg解封裝的步驟如下：使用函式 av_re

Qt 讀寫檔案，並顯示到tablewidget

//將表格資料寫入檔案 void DiagramTableItem::saveTable() { QString fileName = QFileDialog::getSaveFileName(0,tr("儲存檔案"),

使用ffmpeg解碼音訊檔案到PCM格式

最近忙於使用ffmpeg播放音樂檔案的專案，現將開發經驗總結如下：一、解碼音樂檔案的大致流程如下： 1，開啟音樂檔案，呼叫av_open_input_file() 2，查詢audio stream，呼叫av_find_stream_info() 3，查詢對應的decode

Android FFMpeg（三）——使用FFMpeg解碼h264、aac

前面部落格記錄了FFMpeg的編譯，編譯後我們可以拿到FFMpeg的動態庫和靜態庫，拿到這些庫檔案後，通常我們需要做個簡單的封裝才能在Android上層愉快的使用。本篇部落格的是從拿到FFMpeg靜態庫到使用FFMpeg解碼視訊的過程，記錄儘可能的詳盡，可能會讓

find+grep查詢檔案，並顯示檔名

find . -name "*.c" -exec grep array {} -H \; 同時可以加-i，表示忽略大小寫： find . -name "*.c" -exec grep -i array {} -H \;

Android實現Service下載檔案，Notification顯示下載進度

先放個gif。。最終效果如果：主要演示了android從伺服器下載檔案，呼叫Notification顯示下載進度，並且在下載完畢以後點選通知會跳轉到安裝APK的介面，演示是在真實的網路環境中使用真實的URL進行演示，來看看程式碼： MainActivi

HTML Help Workshop製作幫助檔案，圖片顯示不了的解決方法

HTML檔案是Word另存得來得，製作成chm格式後圖片顯示不了。這個問題和路徑有關，網路上討論的也很多，昨天在網上搜索了下，最簡單的方法如下：(1)右鍵html檔案，選擇用FrontPage開啟(2)刪除此圖片，重新“插入/圖片/來自檔案”

解碼H264檔案的一些基礎知識

這段時間一直在進行編寫H264檔案的解析類，因此對於H264檔案的格式有了初步的瞭解，官方文件也看了個大概。這篇文章主要是總結了一些為解碼H264檔案而需要的一些前期知識，話不多說，下面是乾貨，有些是自己在wiki上翻譯過來的，有些是看官方文件後發現的一些關鍵部

通過JSP實現：從網頁上上載一個文字檔案，能顯示上傳成功。之後點一個按鈕能在網頁上顯示出該文字檔案的大小（位元組數）。

（1）在E:\apache-tomcat-8.0.52\webapps\ROOT目錄下建立dou.jsp和upload.jsp檔案：兩個檔案的內容如下： dou.jsp <%@ page contentType="text/html; ch

Android使用FFmpeg 解碼H264並播放（三）

上一節記錄了Android使用FFmpeg解碼H264的過程。這一節記錄在Android上播放的過程。問題描述在開發中使用某攝像頭的SDK，只能獲取到一幀幀的 H264 視訊資料，不知道視訊流地址，需要自己解碼出影象並播放。問題解決 A

VTK-Python 9 讀取CT slice檔案，並顯示三維影象

#!/usr/bin/env python import vtk aRenderer = vtk.vtkRenderer(); renWin = vtk.vtkRenderWindow(); renWin.AddRenderer(aRenderer); iren = v

java呼叫FFmpeg解碼本地檔案使用Javacv

package com.aast.test; import java.io.*; import java.nio.ByteBuffer; import org.bytedeco.javacpp.*; import org.bytedeco.javacpp.annotati

Android使用FFmpeg 解碼H264並播放（二）

上一節記錄了Android使用FFmpeg環境搭建過程。這一節記錄視訊解碼過程。問題描述在開發中使用某攝像頭的SDK，只能獲取到一幀幀的 H264 視訊資料，不知道視訊流地址，需要自己解碼出影象並播放。問題解決編譯FFmpeg 點選

在iOS平臺使用ffmpeg解碼h264視訊流

對於視訊檔案和rtsp之類的主流視訊傳輸協議，ffmpeg提供avformat_open_input介面，直接將檔案路徑或URL傳入即可開啟。讀取視訊資料、解碼器初始引數設定等，都可以通過呼叫API來完成。但是對於h264流，沒有任何封裝格式，也就無法使用libavformat。所以許多工作需要自己手工完

FFmpeg解碼H264視訊流

1、寫在前面此文章主要包含解碼H264視訊流資料，主要有以下幾點： 1、H264視訊幀為Annex B格式，若使用AVCC格式可自行研究； 2、H264視訊裸流，非解碼視訊檔案(若有需要我後期可新增這部分程式碼); 3、支援輸

FFmpeg把MP4檔案解碼為YUV，然後通過SDL播放

#include <iostream> extern "C" { #include <libavcodec/avcodec.h> #include <libavformat/avformat.h> #include <libswscale/swsca

ffmpeg解碼h264檔案，opencv顯示

相關推薦