environment settings

zhangmeng

2021-03-03 4a6d9312cc1c9d62d66c4def71246d9faae29edb

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
#include "parser_callback.h" 
 
#include <stdint.h> 
#include <stdlib.h> 
#include <stdio.h> 
#include "types.h" 
 
parser_callback::parser_callback(std::list<AVPacket> *videoList, std::list<AVPacket> *audioList, 
                                 Cond *condVideo, Cond *condAudio) 
    : mConditon_Video(condVideo), 
      mVideoPacktList(videoList), 
      mConditon_Audio(condAudio), 
      mAudioPacktList(audioList), 
      quit_(0) { 
} 
 
parser_callback::~parser_callback() { 
} 
 
int parser_callback::push_packet(const packet_t* pkt, const av_type_t type) { 
 
 
    while (isVideoQueneFull() || isAudioQueneFull()) { 
        mSleep(1000); 
    } 
    if (quit_) return 0; 
 
    if (type == AV_VIDEO) { 
        AVPacket *avPacket = av_packet_alloc(); 
        avPacket->data = (uint8_t *)malloc(pkt->length); 
        memcpy(avPacket->data, pkt->data, pkt->length); 
        avPacket->size = pkt->length; 
//        printf("pkt->dts:%d, pkt->pts:%d\n", pkt->dts, pkt->pts); 
        avPacket->dts = pkt->dts; 
        avPacket->pts = pkt->pts; 
        avPacket->stream_index = type; 
        inputVideoQuene(*avPacket); 
    } else if (type == AV_AUDIO) { 
        AVPacket *avPacket = av_packet_alloc(); 
        avPacket->data = (uint8_t *)malloc(pkt->length); 
        memcpy(avPacket->data, pkt->data, pkt->length); 
        avPacket->size = pkt->length; 
        avPacket->dts = pkt->dts; 
        avPacket->pts = pkt->pts; 
        avPacket->stream_index = type; 
        inputAudioQuene(*avPacket); 
    } 
 
    free(pkt->data); 
    free((void*)pkt); 
    return (int)pkt->length; 
} 
 
int parser_callback::open_codec(const int codec_type, const av_type_t type) { 
    return 0; 
} 
 
int parser_callback::is_quit() { 
    return quit_; 
} 
 
int parser_callback::quit() { 
    quit_ = 1; 
    return 0; 
} 
 
int parser_callback::push_finish() { 
    return 0; 
} 
 
bool parser_callback::inputVideoQuene(const AVPacket &pkt) 
{ 
    if (av_dup_packet((AVPacket*)&pkt) < 0) 
    { 
        printf("ERROR: av_dup_packet((AVPacket*)&pkt) < 0"); 
        return false; 
    } 
 
    mConditon_Video->Lock(); 
    mVideoPacktList->push_back(pkt); 
    mConditon_Video->Signal(); 
    mConditon_Video->Unlock(); 
 
    return true; 
} 
 
bool parser_callback::isVideoQueneFull() 
{ 
//    mConditon_Video->Lock(); 
    bool ret = mVideoPacktList->size() > MAX_VIDEO_SIZE; 
//    mConditon_Video->Signal(); 
//    mConditon_Video->Unlock(); 
 
    return ret; 
} 
 
bool parser_callback::inputAudioQuene(const AVPacket &pkt) 
{ 
    if (av_dup_packet((AVPacket*)&pkt) < 0) 
    { 
        printf("ERROR: av_dup_packet((AVPacket*)&pkt) < 0"); 
        return false; 
    } 
 
    mConditon_Audio->Lock(); 
    mAudioPacktList->push_back(pkt); 
    mConditon_Audio->Signal(); 
    mConditon_Audio->Unlock(); 
 
    return true; 
} 
 
bool parser_callback::isAudioQueneFull() 
{ 
//    mConditon_Audio->Lock(); 
    bool ret = mAudioPacktList->size() > MAX_AUDIO_SIZE; 
//    mConditon_Audio->Signal(); 
//    mConditon_Audio->Unlock(); 
 
    return ret; 
}