Debian Codegraph @

lib/aviread/FFReadHandler.cpp

raw ◀ ▶
3 Debian patches touch this file
1 #include "FFReadHandler.h"
2 #include "FFReadStream.h"
3 #include "avm_output.h"
4
5 #include "avm_avformat.h"
•6 #include "avm_avcodec.h"
7
8 #include <stdlib.h>
9 #include <string.h>
10 #include <unistd.h>
11
12 AVM_BEGIN_NAMESPACE;
13
14 class AVStreamPacket : public StreamPacket
15 {
16 AVPacket packet;
17
18 /// \internal disabled
19 AVStreamPacket(const AVStreamPacket&) {}
20 /// \internal disabled
21 AVStreamPacket& operator=(const AVStreamPacket&) { return *this; }
22
23 public:
24 AVStreamPacket() : StreamPacket() {}
25 virtual ~AVStreamPacket() {
26 if (memory)
27 {
•28 av_packet_unref(&packet);
29 memory = 0;
30 }
31 }
32
33 AVPacket& GetAVPacket() { return packet; }
34 const AVPacket& GetAVPacket() const { return packet; }
35 void UpdateMembers() {
36 memory = packet.data;
37 size = packet.size;
38 read = 0;
39 }
40 };
41
42
43 FFReadHandler::FFReadHandler()
44 : m_pContext(0)
45 {
46 static int g_iInitilized = 0;
47
48 if (!g_iInitilized)
49 {
50 g_iInitilized++;
51 }
52 }
53
54 FFReadHandler::~FFReadHandler()
55 {
56 if (m_pContext)
57 {
58 flush();
59
60 while (m_Streams.size() > 0)
61 {
62 delete m_Streams.back();
63 m_Streams.pop_back();
64 }
•65 avformat_close_input(&m_pContext);
66 }
67 }
68
69 int FFReadHandler::Init(const char* url)
70 {
71 AVInputFormat* fmt = 0;
72
73 // av_find_input_format(url);
74 //printf("find input format %p %s\n", fmt, b);
•75 int r = avformat_open_input(&m_pContext, url,
76 fmt, NULL);
77 if (r < 0)
78 {
79 AVM_WRITE("FF reader", "Open Input failed %d\n", r);
80 return -1;
81 }
82
•83 if (avformat_find_stream_info(m_pContext, NULL) < 0)
84 return -1;
85
86 AVM_WRITE("FF reader", "Format:'%s' Stream(s):%d\n", m_pContext->iformat->long_name, m_pContext->nb_streams);
87
88 m_Streams.resize(m_pContext->nb_streams);
89 for (unsigned i = 0; i < m_pContext->nb_streams; ++i)
90 {
•91 AVCodecParameters* avp = m_pContext->streams[i]->codecpar;
92 const AVCodec* codec = avcodec_find_decoder(avp->codec_id);
93 AVCodecContext* avc = avcodec_alloc_context3(codec);
94 avcodec_parameters_to_context(avc, avp);
95 AVM_WRITE("FF reader", "S: %d %s CodecID:%x bitrate:%d (%d) samplerate:%d chn:%d framerate:%d/%d wxh %dx%d %d/%d\n",
96 i, codec ? codec->name : "", avc->codec_id, avc->bit_rate, avc->bit_rate_tolerance,
•97 avc->sample_rate, avc->ch_layout.nb_channels, avc->time_base.num, avc->time_base.den,
98 avc->width, avc->height, avc->sample_aspect_ratio.num, avc->sample_aspect_ratio.den);
99 m_Streams[i] = new FFReadStream(this, i, m_pContext->streams[i]);
100 }
101
102 //m_pContext->iformat->read_header(m_pContext, &avfp);
103 //printf("samprate %d\nchn %d\nframerate %d\nwidth %d\nheigth %d\n",
104 // avfp.sample_rate, avfp.channels, avfp.frame_rate, avfp.width, avfp.height);
105 return 0;
106 }
107
108 size_t FFReadHandler::GetHeader(void* header, size_t size)
109 {
110 if (header)//&& (size >= sizeof(AVIMainHeader)))
111 {
112 memset(header, 0, size);
113 //memcpy(pheader, &m_MainHeader, sizeof(AVIMainHeader));
114 }
115 return 0;//sizeof(AVIMainHeader);
116 }
117
118 IMediaReadStream* FFReadHandler::GetStream(uint_t stream_id,
119 IStream::StreamType type)
120 {
121 int t;
122 uint_t cnt = 0;
123 switch (type)
124 {
•125 case IStream::Audio: t = AVMEDIA_TYPE_AUDIO; break;
126 case IStream::Video: t = AVMEDIA_TYPE_VIDEO; break;
127 default: return 0;
128 }
129
130 for (unsigned i = 0; i < m_pContext->nb_streams; ++i)
131 {
•132 if (m_pContext->streams[i]->codecpar->codec_type == t)
133 {
134 if (cnt == stream_id)
135 return m_Streams[i];
136 cnt++;
137 }
138 }
139
140 return 0;
141 }
142
143 size_t FFReadHandler::GetStreamCount(IStream::StreamType type)
144 {
145 int t;
146 size_t cnt = 0;
147
148 switch (type)
149 {
•150 case IStream::Audio: t = AVMEDIA_TYPE_AUDIO; break;
151 case IStream::Video: t = AVMEDIA_TYPE_VIDEO; break;
152 default: return 0;
153 }
154
155 for (unsigned i = 0; i < m_pContext->nb_streams; ++i)
•156 if (m_pContext->streams[i]->codecpar->codec_type == t)
157 cnt++;
158 return cnt;
159 }
160
161 void FFReadHandler::flush()
162 {
163 for (size_t i = 0; i < m_Streams.size(); ++i)
164 {
165 while (m_Streams[i]->m_Packets.size())
166 {
167 m_Streams[i]->m_Packets.front()->Release();
168 m_Streams[i]->m_Packets.pop();
169 }
170 m_Streams[i]->m_uiPosition = 0;
171 }
172 }
173
174 //int FFReadHandler::seek(framepos_t pos)
175 int FFReadHandler::seek(double timepos)
176 {
177 Locker locker(m_Mutex);
178 flush();
179 //AVM_WRITE("FF reader", 1, "seek(%f) %" PRId64 "\n", timepos, m_pContext->start_time);
180 int64_t sp = ((m_pContext->start_time != (int64_t)AV_NOPTS_VALUE)
181 ? m_pContext->start_time : 0) + int64_t(timepos * AV_TIME_BASE);
182 #if 1
183 av_seek_frame(m_pContext, -1, sp, 0);
184 #else
185 #ifndef INT64_MIN
186 #define INT64_MIN (-0x7fffffffffffffffLL-1)
187 #endif
188 #ifndef INT64_MAX
189 #define INT64_MAX INT64_C(9223372036854775807)
190 #endif
191 avformat_seek_file(m_pContext, -1, INT64_MIN, sp, INT64_MAX, 0);
192 #endif
193 return 0;
194 }
195
196 int FFReadHandler::readPacket()
197 {
198 Locker locker(m_Mutex);
199 AVStreamPacket* p = new AVStreamPacket();
200 AVPacket& pkt = p->GetAVPacket();
201 AVM_WRITE("FF reader", 5, "readPacket()\n");
202 if (av_read_frame(m_pContext, &pkt) < 0)
203 {
204 p->Release();
•205 if (m_pContext->pb && m_pContext->pb->error)
206 AVM_WRITE("FF reader", "error seen\n");
207
208 //if (!url_feof(m_pContext->pb))
209 // AVM_WRITE("FF reader", "ffmpeg packet error and not eof??\n");
210
211 return -1;
212 }
213
214 //printf("FFMPEG pktsize: %u %" PRId64 " %d\n", pkt.size, pkt.pts, pkt.stream_index);fflush(stdout);
215
216 p->UpdateMembers();
217
218 if ((size_t)pkt.stream_index >= m_Streams.size()) {
219 AVM_WRITE("FF reader", "new stream?? i:%d n:%d sz:%" PRIsz "\n",
220 pkt.stream_index, m_pContext->nb_streams, m_Streams.size());
221 p->Release();
222 return 0;
223 }
224
225 FFReadStream& s = *m_Streams[pkt.stream_index];
226 AVStream& ast = *m_pContext->streams[pkt.stream_index];
227
228 p->SetPos(s.m_uiPosition);
229 p->SetTimestamp(((pkt.pts != (int64_t)AV_NOPTS_VALUE) ? pkt.pts : pkt.dts)
230 * AV_TIME_BASE * ast.time_base.num / ast.time_base.den - s.GetStartTime());
•231 if (pkt.flags & AV_PKT_FLAG_KEY)
232 p->SetFlags(p->GetFlags() | KEYFRAME);
233
234 if (p->GetTimestamp() < 0)
235 p->SetTimestamp(0);
236
237 //AVM_WRITE("FF reader", "st:%d n/d:%d/%d ts:%" PRId64 " d:%" PRId64 " dur:%d p:%" PRId64 "\n",
238 // pkt.stream_index, ast.time_base.num, ast.time_base.den,
239 // p->timestamp, pkt.dts, pkt.duration, pkt.pts);
•240 //if (ast->codec.codec_type == AVMEDIA_TYPE_VIDEO) printf("FRATE %d pts:%lld %d %d t:%lld\n", p->position, pkt.pts,ast->codec.frame_rate_base, ast->codec.frame_rate, p->timestamp);
241 //else printf("Bitrate %d\n", ast->codec.bit_rate);
242 //printf("TIMESTAMP %" PRId64 " pts: %" PRId64 " dts: %" PRId64 "\n", p->timestamp, pkt.pts, pkt.dts);
243
•244 switch (ast.codecpar->codec_type)
245 {
•246 case AVMEDIA_TYPE_AUDIO:
247 s.m_uiPosition += pkt.size;
248 break;
•249 case AVMEDIA_TYPE_VIDEO:
250 default:
251 s.m_uiPosition++;
252 break;
253 }
254 #if 0
255 printf("---ReadPacket i:%d sz:%d pts:%" PRId64 " size:%d (%" PRId64 ", %d)\n",
256 pkt.stream_index, s.m_Packets.size(), pkt.pts, pkt.size, p->timestamp, pkt.flags);
257 #endif
258
259 if (s.m_Packets.size() >= s.m_Packets.capacity() - 1)
260 {
261 if (1)
262 AVM_WRITE("FF reader", "got too many packets in the queue %d??? (%" PRIsz ", %" PRIsz ")\n",
263 pkt.stream_index, s.m_Packets.size(), s.m_Packets.capacity());
264 s.m_Packets.front()->Release();
265 s.m_Packets.pop();
266 }
267
268 s.m_Packets.push(p);
269 return 0;
270 }
271
272 IMediaReadHandler* CreateFFReadHandler(const char *pszFile)
273 {
274 FFReadHandler* h = new FFReadHandler();
275 if (h && h->Init(pszFile) == 0)
276 return h;
277
278 delete h;
279 return 0;
280 }
281
282 AVM_END_NAMESPACE;