Ticket #7290: av.c

//
//  av.c
//  splayer
//
//  Created by 韩爱东 on 2018/6/25.
//  Copyright © 2018年 韩爱东. All rights reserved.
//

#include "av.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>
#include <unistd.h>
#include "libavcodec/avcodec.h"
#include "libavformat/avformat.h"
#include "libswscale/swscale.h"

#define INBUF_SIZE 4096
AVFrame *frame;
AVCodecContext *codec_ctx;
pthread_mutex_t frame_lock = PTHREAD_MUTEX_INITIALIZER;
#if 1
static void pgm_save(unsigned char *buf, int wrap, int xsize, int ysize, char *filename)
{
        FILE *f;
        int i;
        f = fopen(filename,"w");
        fprintf(f, "P5\n%d %d\n%d\n", xsize, ysize, 255);
        for (i = 0; i < ysize; i++)
                fwrite(buf + i * wrap, 1, xsize, f);
        fclose(f);
}
#endif
static void decode(AVCodecContext *dec_ctx, AVFrame *frame, AVPacket *pkt, const char *filename)
{
        char buf[1024] = {0};
        int ret;
        
        ret = avcodec_send_packet(dec_ctx, pkt);
        if (ret < 0)
        {
                fprintf(stderr, "Error sending a packet for decoding\n");
                return;
        }
        
        while (ret >= 0)
        {
                ret = avcodec_receive_frame(dec_ctx, frame);
                if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
                {
                        printf("err ret = %d.%d, %d\n", ret, AVERROR(EAGAIN), AVERROR_EOF);
                        return;
                }
                else if (ret < 0)
                {
                        fprintf(stderr, "Error during decoding\n");
                        return;
                }
                //printf("saving frame %3d\n", dec_ctx->frame_number);
                fflush(stdout);
                /* the picture is allocated by the decoder. no need to
                 free it */
                snprintf(buf, sizeof(buf), "%s-%d", filename, dec_ctx->frame_number);
                pgm_save(frame->data[0], frame->linesize[0], frame->width, frame->height, buf);
        }
}

void decode_file(int t)
{
        char *filename = "/Users/lpz/splayer/splayer/splayer/ii.mp4";
        char *outfilename = "/Users/lpz/splayer/splayer/splayer/test/ee";
        AVPacket *pkt = NULL;
        AVCodec *codec = NULL;
        AVStream *stream = NULL;
        AVFormatContext *fmt_ctx = NULL;
        
        int i = 0;
        int videoStream = 0;
        
        avformat_open_input(&fmt_ctx, filename, NULL, NULL);//打开一个视频
        avformat_find_stream_info(fmt_ctx, NULL);//读取视频，然后得到流和码率等信息
        av_dump_format(fmt_ctx, 0, filename, 0);
        for(i = 0; i < fmt_ctx->nb_streams; ++i)
        {
                stream = fmt_ctx->streams[i];
                if(fmt_ctx->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
                {
                        videoStream=i;
                
                        break;
                }
        }
        printf("videoStream = %d\n", videoStream);
        
        codec =  avcodec_find_decoder(stream->codecpar->codec_id);
        codec_ctx = avcodec_alloc_context3(codec);//需要使用avcodec_free_context释放
        
        //事实上codecpar包含了大部分解码器相关的信息，这里是直接从AVCodecParameters复制到AVCodecContext
        avcodec_parameters_to_context(codec_ctx, stream->codecpar);
        avcodec_open2(codec_ctx, codec, NULL);
        
        pkt = av_packet_alloc();
        if (!pkt)
        {
                return;
        }

        frame = av_frame_alloc();
        if (!frame)
        {
                fprintf(stderr, "Could not allocate video frame\n");
                return;
        }
        while(av_read_frame(fmt_ctx, pkt) >= 0)
        {
                printf("pkt->size = %d. %d\n", pkt->size, pkt->stream_index);
                if(pkt->stream_index == videoStream && pkt->size > 0)
                {
                        //pthread_mutex_lock(&frame_lock);
                        decode(codec_ctx, frame, pkt, outfilename);
                        //printf("frame = %#x, %d, %d.\n", frame->data[0], frame->width, frame->height);
                        //pthread_mutex_unlock(&frame_lock);
                }
                
                usleep(40000);
        }
        /* flush the decoder */
        avcodec_close(codec_ctx);
        avcodec_free_context(&codec_ctx);
        av_frame_free(&frame);
        av_packet_free(&pkt);
        return;
}

int main()
{
        pthread_t tid;
        if(pthread_mutex_init(&frame_lock, NULL) != 0)
        {
                return -1;
        }

        pthread_create(&tid, NULL, (void *)&decode_file, &tid);
        sleep(100);
        return 0;
}