ZoneMinder
/
zoneminder
mirror of https://github.com/ZoneMinder/zoneminder.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

ffmpeg: exit dumpPacket early if debug logging is not enabled

pull/3133/head
Peter Keresztes Schmidt 2021-02-06 14:46:28 +01:00
parent 3d20183020
commit 938676b129
9 changed files with 69 additions and 85 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/zm_event.cpp
View File

@ -553,7 +553,7 @@ void Event::AddPacket(ZMPacket *packet) {
have_video_keyframe = have_video_keyframe || ( ( packet->codec_type == AVMEDIA_TYPE_VIDEO ) && packet->keyframe );
Debug(2, "have_video_keyframe %d codec_type %d == video? %d packet keyframe %d",
have_video_keyframe, packet->codec_type, (packet->codec_type == AVMEDIA_TYPE_VIDEO), packet->keyframe);
dumpPacket(&packet->packet, "Adding to event");
ZM_DUMP_PACKET(packet->packet, "Adding to event");
if ( videoStore ) {
if ( have_video_keyframe ) {
videoStore->writePacket(packet);

54
src/zm_ffmpeg.cpp
View File

@ -649,36 +649,6 @@ int zm_send_frame_receive_packet(AVCodecContext *ctx, AVFrame *frame, AVPacket &
return 1;
} // end int zm_send_frame_receive_packet
void dumpPacket(AVStream *stream, AVPacket *pkt, const char *text) {
char b[10240];
double pts_time = (double)av_rescale_q(pkt->pts,
stream->time_base,
AV_TIME_BASE_Q
) / AV_TIME_BASE;
snprintf(b, sizeof(b),
" pts: %" PRId64 "=%f, dts: %" PRId64
", size: %d, stream_index: %d, flags: %04x, keyframe(%d) pos: %" PRId64
", duration: %"
#if LIBAVCODEC_VERSION_CHECK(57, 64, 0, 64, 0)
PRIu64
#else
"d"
#endif
"\n",
pkt->pts,
pts_time,
pkt->dts,
pkt->size,
pkt->stream_index,
pkt->flags,
pkt->flags & AV_PKT_FLAG_KEY,
pkt->pos,
pkt->duration);
Debug(2, "%s:%d:%s: %s", __FILE__, __LINE__, text, b);
}
void zm_free_codec( AVCodecContext **ctx ) {
if ( *ctx ) {
avcodec_close(*ctx);
@ -690,30 +660,6 @@ void zm_free_codec( AVCodecContext **ctx ) {
} // end if
}
void dumpPacket(AVPacket *pkt, const char *text) {
char b[10240];
snprintf(b, sizeof(b),
" pts: %" PRId64 ", dts: %" PRId64
", size: %d, stream_index: %d, flags: %04x, keyframe(%d) pos: %" PRId64
", duration: %"
#if LIBAVCODEC_VERSION_CHECK(57, 64, 0, 64, 0)
PRId64
#else
"d"
#endif
"\n",
pkt->pts,
pkt->dts,
pkt->size,
pkt->stream_index,
pkt->flags,
pkt->flags & AV_PKT_FLAG_KEY,
pkt->pos,
pkt->duration);
Debug(2, "%s:%d:%s: %s", __FILE__, __LINE__, text, b);
}
void zm_packet_copy_rescale_ts(const AVPacket *ipkt, AVPacket *opkt, const AVRational src_tb, const AVRational dst_tb) {
opkt->pts = ipkt->pts;
opkt->dts = ipkt->dts;

47
src/zm_ffmpeg.h
View File

@ -350,6 +350,49 @@ void zm_dump_codecpar(const AVCodecParameters *par);
);
#endif
#if LIBAVCODEC_VERSION_CHECK(57, 64, 0, 64, 0)
# define AV_PACKET_DURATION_FMT PRId64
#else
# define AV_PACKET_DURATION_FMT "d"
#endif
#ifndef DBG_OFF
# define ZM_DUMP_PACKET(pkt, text) \
Debug(2, "%s: pts: %" PRId64 ", dts: %" PRId64 \
", size: %d, stream_index: %d, flags: %04x, keyframe(%d) pos: %" PRId64 ", duration: %" AV_PACKET_DURATION_FMT, \
text,\
pkt.pts,\
pkt.dts,\
pkt.size,\
pkt.stream_index,\
pkt.flags,\
pkt.flags & AV_PKT_FLAG_KEY,\
pkt.pos,\
pkt.duration)
# define ZM_DUMP_STREAM_PACKET(stream, pkt, text) \
if (logDebugging()) { \
double pts_time = static_cast<double>(av_rescale_q(pkt.pts, stream->time_base, AV_TIME_BASE_Q)) / AV_TIME_BASE; \
\
Debug(2, "%s: pts: %" PRId64 "=%f, dts: %" PRId64 \
", size: %d, stream_index: %d, flags: %04x, keyframe(%d) pos: %" PRId64", duration: %" AV_PACKET_DURATION_FMT, \
text, \
pkt.pts, \
pts_time, \
pkt.dts, \
pkt.size, \
pkt.stream_index, \
pkt.flags, \
pkt.flags & AV_PKT_FLAG_KEY, \
pkt.pos, \
pkt.duration) \
}
#else
# define ZM_DUMP_PACKET(pkt, text)
# define ZM_DUMP_STREAM_PACKET(stream, pkt, text)
#endif
#if LIBAVCODEC_VERSION_CHECK(56, 8, 0, 60, 100)
#define zm_av_packet_unref(packet) av_packet_unref(packet)
#define zm_av_packet_ref(dst, src) av_packet_ref(dst, src)
@ -397,8 +440,6 @@ int zm_receive_packet(AVCodecContext *context, AVPacket &packet);
int zm_send_packet_receive_frame(AVCodecContext *context, AVFrame *frame, AVPacket &packet);
int zm_send_frame_receive_packet(AVCodecContext *context, AVFrame *frame, AVPacket &packet);
void dumpPacket(AVStream *, AVPacket *,const char *text="");
void dumpPacket(AVPacket *,const char *text="");
void zm_packet_copy_rescale_ts(const AVPacket *ipkt, AVPacket *opkt, const AVRational src_tb, const AVRational dst_tb);
#if defined(HAVE_LIBSWRESAMPLE) || defined(HAVE_LIBAVRESAMPLE)
@ -429,6 +470,4 @@ int zm_resample_get_delay(
int zm_add_samples_to_fifo(AVAudioFifo *fifo, AVFrame *frame);
int zm_get_samples_from_fifo(AVAudioFifo *fifo, AVFrame *frame);
#endif // ZM_FFMPEG_H

2
src/zm_ffmpeg_camera.cpp
View File

@ -204,7 +204,7 @@ int FfmpegCamera::Capture(ZMPacket &zm_packet) {
}
return -1;
}
dumpPacket(mFormatContext->streams[packet.stream_index], &packet, "ffmpeg_camera in");
ZM_DUMP_STREAM_PACKET(mFormatContext->streams[packet.stream_index], packet, "ffmpeg_camera in");
#if LIBAVCODEC_VERSION_CHECK(57, 64, 0, 64, 0)
zm_packet.codec_type = mFormatContext->streams[packet.stream_index]->codecpar->codec_type;

2
src/zm_ffmpeg_input.cpp
View File

@ -170,7 +170,7 @@ AVFrame *FFmpeg_Input::get_frame(int stream_id) {
packet.stream_index, ret, av_make_error_string(ret).c_str());
return nullptr;
}
dumpPacket(input_format_context->streams[packet.stream_index], &packet, "Received packet");
ZM_DUMP_STREAM_PACKET(input_format_context->streams[packet.stream_index], packet, "Received packet");
if ( (stream_id >= 0) && (packet.stream_index != stream_id) ) {
Debug(1,"Packet is not for our stream (%d)", packet.stream_index );

2
src/zm_packet.cpp
View File

@ -271,7 +271,7 @@ AVPacket *ZMPacket::set_packet(AVPacket *p) {
if ( zm_av_packet_ref(&packet, p) < 0 ) {
Error("error refing packet");
}
//dumpPacket(&packet, "zmpacket:");
//ZM_DUMP_PACKET(packet, "zmpacket:");
gettimeofday(timestamp, nullptr);
keyframe = p->flags & AV_PKT_FLAG_KEY;
return &packet;

13
src/zm_packetqueue.cpp
View File

@ -492,14 +492,14 @@ packetqueue_iterator *PacketQueue::get_event_start_packet_it(
iterators.push_back(it);
*it = snapshot_it;
dumpPacket(&((*(*it))->packet));
ZM_DUMP_PACKET((*(*it))->packet, "");
// Step one count back pre_event_count frames as the minimum
// Do not assume that snapshot_it is video
// snapshot it might already point to the beginning
while ( ( *it != pktQueue.begin() ) and pre_event_count ) {
Debug(1, "Previous packet pre_event_count %d stream_index %d keyframe %d",
pre_event_count, (*(*it))->packet.stream_index, (*(*it))->keyframe);
dumpPacket(&((*(*it))->packet));
ZM_DUMP_PACKET((*(*it))->packet, "");
if ( (*(*it))->packet.stream_index == video_stream_id ) {
pre_event_count --;
if ( ! pre_event_count )
@ -520,19 +520,19 @@ packetqueue_iterator *PacketQueue::get_event_start_packet_it(
} else {
Warning("Hit end of packetqueue before satisfying pre_event_count. Needed %d more video frames", pre_event_count);
}
dumpPacket(&((*(*it))->packet));
ZM_DUMP_PACKET((*(*it))->packet, "");
}
return it;
}
// Not at beginning, so must be pointing at a video keyframe or maybe pre_event_count == 0
if ( (*(*it))->keyframe ) {
dumpPacket(&((*(*it))->packet), "Found video keyframe, Returning");
ZM_DUMP_PACKET((*(*it))->packet, "Found video keyframe, Returning");
return it;
}
while ( (*it)-- != pktQueue.begin() ) {
dumpPacket(&((*(*it))->packet), "No keyframe");
ZM_DUMP_PACKET((*(*it))->packet, "No keyframe");
if ( (*(*it))->packet.stream_index == video_stream_id and (*(*it))->keyframe )
return it; // Success
}
@ -546,8 +546,7 @@ void PacketQueue::dumpQueue() {
std::list<ZMPacket *>::reverse_iterator it;
for ( it = pktQueue.rbegin(); it != pktQueue.rend(); ++ it ) {
ZMPacket *zm_packet = *it;
AVPacket *av_packet = &(zm_packet->packet);
dumpPacket(av_packet);
ZM_DUMP_PACKET(zm_packet->packet, "");
}
}

2
src/zm_rtsp_server_device_source.cpp
View File

@ -159,7 +159,7 @@ int ZoneMinderDeviceSource::getNextFrame() {
// Convert pts to timeval
int64_t pts = av_rescale_q(pkt->dts, m_stream->time_base, AV_TIME_BASE_Q);
timeval tv = { pts/1000000, pts%1000000 };
dumpPacket(m_stream, pkt, "rtspServer");
ZM_DUMP_STREAM_PACKET(m_stream, (*pkt), "rtspServer");
Debug(2, "pts %" PRId64 " pkt.pts %" PRId64 " tv %d.%d", pts, pkt->pts, tv.tv_sec, tv.tv_usec);
std::list< std::pair<unsigned char*, size_t> > framesList = this->splitFrames(pkt->data, pkt->size);

16
src/zm_videostore.cpp
View File

@ -559,9 +559,9 @@ void VideoStore::flush_codecs() {
break;
}
dumpPacket(&pkt, "raw from encoder");
ZM_DUMP_PACKET(pkt, "raw from encoder");
av_packet_rescale_ts(&pkt, audio_out_ctx->time_base, audio_out_stream->time_base);
dumpPacket(audio_out_stream, &pkt, "writing flushed packet");
ZM_DUMP_STREAM_PACKET(audio_out_stream, pkt, "writing flushed packet");
write_packet(&pkt, audio_out_stream);
zm_av_packet_unref(&pkt);
} // while have buffered frames
@ -1039,7 +1039,7 @@ int VideoStore::writeVideoFramePacket(ZMPacket *zm_packet) {
}
return ret;
}
dumpPacket(&opkt, "packet returned by codec");
ZM_DUMP_PACKET(opkt, "packet returned by codec");
// Need to adjust pts/dts values from codec time to stream time
if ( opkt.pts != AV_NOPTS_VALUE )
@ -1119,7 +1119,7 @@ int VideoStore::writeVideoFramePacket(ZMPacket *zm_packet) {
av_packet_rescale_ts(&opkt, video_in_stream->time_base, video_out_stream->time_base);
dumpPacket(video_out_stream, &opkt, "after pts adjustment");
ZM_DUMP_STREAM_PACKET(video_out_stream, opkt, "after pts adjustment");
} // end if codec matches
write_packet(&opkt, video_out_stream);
@ -1138,7 +1138,7 @@ int VideoStore::writeAudioFramePacket(ZMPacket *zm_packet) {
return 0;
// FIXME -ve return codes do not free packet in ffmpeg_camera at the moment
}
dumpPacket(audio_in_stream, ipkt, "input packet");
ZM_DUMP_STREAM_PACKET(audio_in_stream, (*ipkt), "input packet");
if ( !audio_first_dts ) {
audio_first_dts = ipkt->dts;
@ -1148,7 +1148,7 @@ int VideoStore::writeAudioFramePacket(ZMPacket *zm_packet) {
// Need to adjust pts before feeding to decoder.... should really copy the pkt instead of modifying it
ipkt->pts -= audio_first_dts;
ipkt->dts -= audio_first_dts;
dumpPacket(audio_in_stream, ipkt, "after pts adjustment");
ZM_DUMP_STREAM_PACKET(audio_in_stream, (*ipkt), "after pts adjustment");
if ( audio_out_codec ) {
// I wonder if we can get multiple frames per packet? Probably
@ -1205,7 +1205,7 @@ int VideoStore::writeAudioFramePacket(ZMPacket *zm_packet) {
opkt.pts = ipkt->pts;
opkt.dts = ipkt->dts;
av_packet_rescale_ts(&opkt, audio_in_stream->time_base, audio_out_stream->time_base);
dumpPacket(audio_out_stream, &opkt, "after stream pts adjustment");
ZM_DUMP_STREAM_PACKET(audio_out_stream, opkt, "after stream pts adjustment");
write_packet(&opkt, audio_out_stream);
zm_av_packet_unref(&opkt);
@ -1257,7 +1257,7 @@ int VideoStore::write_packet(AVPacket *pkt, AVStream *stream) {
pkt->pts = pkt->dts;
}
dumpPacket(stream, pkt, "finished pkt");
ZM_DUMP_STREAM_PACKET(stream, (*pkt), "finished pkt");
next_dts[stream->index] = opkt.dts + opkt.duration;
Debug(3, "video_next_dts has become %" PRId64, next_dts[stream->index]);