audio

// media.cpp : 定义控制台应用程序的入口点。
//

https://wenku.baidu.com/view/e910c474c5da50e2524d7fb4.html

https://blog.csdn.net/leixiaohua1020/article/details/10528443

最主要这个\examples\demuxing_decoding.c

#include "stdafx.h"

/*
int _tmain(int argc, _TCHAR* argv[])
{
    return 0;
}
*/
#include "stdafx.h"
extern "C"
{
#include <stdio.h>

#include "libavformat/avformat.h"
#include "libavutil/dict.h"

#include <libavcodec/avcodec.h>
#include <libavformat/avformat.h>

#include <libswscale/swscale.h>
}
#pragma comment(lib,"lib/avcodec.lib")
#pragma comment(lib,"lib/avformat.lib")
#pragma comment(lib,"lib/avutil")
//#pragma comment(lib,"lib/SDLmain.lib")
#pragma comment(lib,"lib/avdevice.lib")
#pragma comment(lib,"lib/avfilter.lib")
#pragma comment(lib,"lib/postproc.lib")

#pragma comment(lib,"lib/swresample.lib")
#pragma comment(lib,"lib/swscale.lib")

#pragma comment(lib, "sdl2.lib")
#include <iostream>

#include <SDL2/SDL.h>
#include <SDL2/SDL_thread.h>

#ifdef __MINGW32__
#undef main
#endif

#include <stdio.h>

int
randomInt(int min, int max)
{
    return min + rand() % (max - min + );
}
 #define MAX_AUDIO_FRAME_SIZE 192000
SDL_AudioSpec wanted_spec, spec;

int audio_decode_frame(AVCodecContext *aCodecCtx, uint8_t *audio_buf, int buf_size) {
    static AVPacket pkt;
    static uint8_t *audio_pkt_data = NULL;
    static int audio_pkt_size = ;
    static AVFrame frame;

    int len1, data_size = ;

    for (;;) {
        while(audio_pkt_size > ) {
            int got_frame = ;
            len1 = avcodec_decode_audio4(aCodecCtx, &frame, &got_frame, &pkt);
            if (len1 < ) {
                // if error, skip frame.
                audio_pkt_size = ;
                break;
            }
            audio_pkt_data += len1;
            audio_pkt_size -= len1;
            if (got_frame) {
                data_size = av_samples_get_buffer_size(NULL, aCodecCtx->channels, frame.nb_samples, aCodecCtx->sample_fmt, );
                memcpy(audio_buf, frame.data[], data_size);
            }
            if (data_size <= ) {
                // No data yet, get more frames.
                continue;
            }
            // We have data, return it and come back for more later.
            return data_size;
        }
        if (pkt.data) {
            av_packet_unref(&pkt);
        }

        //if (packet_queue_get(&audioq, &pkt, 1) < 0)
        {
            return -;
        }
        audio_pkt_data = pkt.data;
        audio_pkt_size = pkt.size;
    }
}

void audio_callback(void *userdata, Uint8 *stream, int len) {
    AVCodecContext *aCodecCtx = (AVCodecContext *)userdata;
    int len1, audio_size;

    static uint8_t audio_buf[(MAX_AUDIO_FRAME_SIZE * ) / ];
    static unsigned int audio_buf_size = ;
    static unsigned int audio_buf_index = ;

    while (len > ) {
        if (audio_buf_index >= audio_buf_size) {
            // We have already sent all our data; get more.
            audio_size = audio_decode_frame(aCodecCtx, audio_buf, audio_buf_size);
            if (audio_size < ) {
                // If error, output silence.
                audio_buf_size = ; // arbitrary?
                memset(audio_buf, , audio_buf_size);
            } else {
                audio_buf_size = audio_size;
            }
            audio_buf_index = ;
        }
        len1 = audio_buf_size - audio_buf_index;
        if (len1 > len) {
            len1 = len;
        }
        memcpy(stream, (uint8_t *) audio_buf + audio_buf_index, len1);
        len -= len1;
        stream += len1;
        audio_buf_index += len1;
    }
}

int _tmain(int argc, char *argv[]) {
    AVFormatContext *pFormatCtx = NULL;
    int             i, videoStream,audioStream;
    AVCodecContext  *pCodecCtx = NULL,*pCodecAudioCtx = NULL;
    AVCodec         *pCodec = NULL,*pCodecAudio = NULL;
    AVFrame         *pFrame = NULL;
    AVPacket        packet;
    int             frameFinished;
    //float           aspect_ratio;

    AVDictionary    *optionsDict = NULL ,*audioOptionsDict=NULL;
    struct SwsContext *sws_ctx = NULL;
    //SDL_CreateTexture();
    SDL_Texture    *bmp = NULL;
    SDL_Window     *screen = NULL;
    SDL_Rect        rect;
    SDL_Event       event;
    /*
    if(argc < 2) {
        fprintf(stderr, "Usage: test <file>\n");
        exit(1);
    }*/
    // Register all formats and codecs
    av_register_all();

    if(SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_TIMER)) {
        fprintf(stderr, "Could not initialize SDL - %s\n", SDL_GetError());
        exit();
    }

    // Open video file
    if(avformat_open_input(&pFormatCtx,"D://shitu.mkv"/* argv[1]"D://3s.mp4"*/, NULL, NULL)!=)
        return -; // Couldn't open file

    if(avformat_find_stream_info(pFormatCtx, NULL)<)
        return -; // Couldn't find stream information

    // Dump information about file onto standard error
    av_dump_format(pFormatCtx, , argv[], );

    // Find the first video stream
    videoStream=-;
    for(i=; i<pFormatCtx->nb_streams; i++)
        if(pFormatCtx->streams[i]->codec->codec_type==AVMEDIA_TYPE_VIDEO) {
            videoStream=i;
            break;
        }
        else if(pFormatCtx->streams[i]->codec->codec_type==AVMEDIA_TYPE_AUDIO) {
            audioStream=i;
            break;
        }
    if(videoStream==-||audioStream==-)
        return -; // Didn't find a video stream

    // Get a pointer to the codec context for the video stream
    pCodecCtx=pFormatCtx->streams[videoStream]->codec;
    pCodecAudioCtx=pFormatCtx->streams[audioStream]->codec;
    // Find the decoder for the video stream
    pCodec=avcodec_find_decoder(pCodecCtx->codec_id);
    if(pCodec==NULL) {
        fprintf(stderr, "Unsupported codec!\n");
        return -; // Codec not found
    }

    pCodecAudio=avcodec_find_decoder(pCodecAudioCtx->codec_id);
    if(pCodecAudio==NULL) {
        fprintf(stderr, "Unsupported audio codec!\n");
        return -; // Codec not found
    }

    // Open codec
    if(avcodec_open2(pCodecCtx, pCodec, &optionsDict)<)
        return -; // Could not open codec

    //--
    if (SDL_OpenAudio(&wanted_spec, &spec) < ) {
        fprintf(stderr, "SDL_OpenAudio: %s\n", SDL_GetError());
        return -;

    }

    avcodec_open2(pCodecAudioCtx, pCodecAudio, &audioOptionsDict);
    //--

    pFrame=av_frame_alloc();
    AVFrame* pFrameYUV =av_frame_alloc();

    if( pFrameYUV == NULL )
        return -;
    //--
     AVFrame* pAudioFrame =av_frame_alloc();
    //--
    screen = SDL_CreateWindow("My Game Window",SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED,
                              pCodecCtx->width,  pCodecCtx->height,
                              SDL_WINDOW_FULLSCREEN | SDL_WINDOW_OPENGL);
    SDL_Renderer *renderer = SDL_CreateRenderer(screen, -, );

    if(!screen) {
        fprintf(stderr, "SDL: could not set video mode - exiting\n");
        exit();
    }

    bmp = SDL_CreateTexture(renderer,SDL_PIXELFORMAT_YV12,SDL_TEXTUREACCESS_STREAMING,pCodecCtx->width,pCodecCtx->height);

    sws_ctx = sws_getContext(pCodecCtx->width,pCodecCtx->height, pCodecCtx->pix_fmt, pCodecCtx->width,pCodecCtx->height,
     AV_PIX_FMT_YUV420P,SWS_BILINEAR,NULL,NULL, NULL);

    int numBytes = avpicture_get_size(AV_PIX_FMT_YUV420P, pCodecCtx->width,
                                  pCodecCtx->height);
    uint8_t* buffer = (uint8_t *)av_malloc(numBytes*sizeof(uint8_t));

    avpicture_fill((AVPicture *)pFrameYUV, buffer, AV_PIX_FMT_YUV420P,
                   pCodecCtx->width, pCodecCtx->height);

    i=;

    rect.x = ;
    rect.y = ;
    rect.w = pCodecCtx->width;
    rect.h = pCodecCtx->height;

    while(av_read_frame(pFormatCtx, &packet)>=) {
        // Is this a packet from the video stream?
        if(packet.stream_index==videoStream) {
            // Decode video frame
            avcodec_decode_video2(pCodecCtx, pFrame, &frameFinished,
                                  &packet);

            // Did we get a video frame?
            if(frameFinished) {
                sws_scale(sws_ctx,(uint8_t const * const *)pFrame->data, pFrame->linesize, ,
                 pCodecCtx->height, pFrameYUV->data, pFrameYUV->linesize);
                ////iPitch 计算yuv一行数据占的字节数
                SDL_UpdateTexture( bmp, &rect, pFrameYUV->data[], pFrameYUV->linesize[] );
                SDL_RenderClear( renderer );
                SDL_RenderCopy( renderer, bmp, &rect, &rect );
                SDL_RenderPresent( renderer );
            }
            SDL_Delay();
            //Sleep(500);
        }else if (packet.stream_index == audioStream) {
        }

        // Free the packet that was allocated by av_read_frame
        av_free_packet(&packet);
        SDL_PollEvent(&event);
        switch(event.type) {
            case SDL_QUIT:
                SDL_Quit();
                exit();
                break;
            default:
                break;
        }

    }

    SDL_DestroyTexture(bmp);

    // Free the YUV frame
    av_free(pFrame);
    av_free(pFrameYUV);
    // Close the codec
    avcodec_close(pCodecCtx);

    // Close the video file
    avformat_close_input(&pFormatCtx);

    return ;
}

https://www.cnblogs.com/lgh1992314/p/5834639.html

这个_-to thi tha

回看tha视频，不要杂念，杂容易慢，一段只一件