xbmc/cores/FFmpeg.cpp

   1 /*
   2  *  Copyright (C) 2005-2018 Team Kodi
   3  *  This file is part of Kodi - https://kodi.tv
   4  *
   5  *  SPDX-License-Identifier: GPL-2.0-or-later
   6  *  See LICENSES/README.md for more information.
   7  */
   8
   9 #include "cores/FFmpeg.h"
  10
  11 #include "ServiceBroker.h"
  12 #include "settings/AdvancedSettings.h"
  13 #include "settings/SettingsComponent.h"
  14 #include "threads/CriticalSection.h"
  15 #include "threads/Thread.h"
  16 #include "utils/StringUtils.h"
  17 #include "utils/log.h"
  18
  19 extern "C"
  20 {
  21 #include <libavcodec/bsf.h>
  22 }
  23
  24 #include <map>
  25 #include <mutex>
  26
  27 static thread_local CFFmpegLog* CFFmpegLogTls;
  28
  29 namespace FFMPEG_HELP_TOOLS
  30 {
  31
  32 std::string FFMpegErrorToString(int err)
  33 {
  34   std::string text;
  35   text.resize(AV_ERROR_MAX_STRING_SIZE);
  36   av_strerror(err, text.data(), AV_ERROR_MAX_STRING_SIZE);
  37   return text;
  38 }
  39
  40 } // namespace FFMPEG_HELP_TOOLS
  41
  42 void CFFmpegLog::SetLogLevel(int level)
  43 {
  44   CFFmpegLog::ClearLogLevel();
  45   CFFmpegLog *log = new CFFmpegLog();
  46   log->level = level;
  47   CFFmpegLogTls = log;
  48 }
  49
  50 int CFFmpegLog::GetLogLevel()
  51 {
  52   CFFmpegLog* log = CFFmpegLogTls;
  53   if (!log)
  54     return -1;
  55   return log->level;
  56 }
  57
  58 void CFFmpegLog::ClearLogLevel()
  59 {
  60   CFFmpegLog* log = CFFmpegLogTls;
  61   CFFmpegLogTls = nullptr;
  62   if (log)
  63     delete log;
  64 }
  65
  66 static CCriticalSection m_logSection;
  67 std::map<const CThread*, std::string> g_logbuffer;
  68
  69 void ff_flush_avutil_log_buffers(void)
  70 {
  71   std::unique_lock<CCriticalSection> lock(m_logSection);
  72   /* Loop through the logbuffer list and remove any blank buffers
  73      If the thread using the buffer is still active, it will just
  74      add a new buffer next time it writes to the log */
  75   std::map<const CThread*, std::string>::iterator it;
  76   for (it = g_logbuffer.begin(); it != g_logbuffer.end(); )
  77     if ((*it).second.empty())
  78       g_logbuffer.erase(it++);
  79     else
  80       ++it;
  81 }
  82
  83 void ff_avutil_log(void* ptr, int level, const char* format, va_list va)
  84 {
  85   std::unique_lock<CCriticalSection> lock(m_logSection);
  86   const CThread* threadId = CThread::GetCurrentThread();
  87   std::string &buffer = g_logbuffer[threadId];
  88
  89   AVClass* avc= ptr ? *(AVClass**)ptr : NULL;
  90
  91   int maxLevel = AV_LOG_WARNING;
  92   if (CFFmpegLog::GetLogLevel() > 0)
  93     maxLevel = AV_LOG_INFO;
  94
  95   if (level > maxLevel && !CServiceBroker::GetLogging().CanLogComponent(LOGFFMPEG))
  96     return;
  97   else if (CServiceBroker::GetSettingsComponent()->GetAdvancedSettings()->m_logLevel <= LOG_LEVEL_NORMAL)
  98     return;
  99
 100   int type;
 101   switch (level)
 102   {
 103     case AV_LOG_INFO:
 104       type = LOGINFO;
 105       break;
 106
 107     case AV_LOG_ERROR:
 108       type = LOGERROR;
 109       break;
 110
 111     case AV_LOG_DEBUG:
 112     default:
 113       type = LOGDEBUG;
 114       break;
 115   }
 116
 117   std::string message = StringUtils::FormatV(format, va);
 118   std::string prefix = StringUtils::Format("ffmpeg[{}]: ", fmt::ptr(threadId));
 119   if (avc)
 120   {
 121     if (avc->item_name)
 122       prefix += std::string("[") + avc->item_name(ptr) + "] ";
 123     else if (avc->class_name)
 124       prefix += std::string("[") + avc->class_name + "] ";
 125   }
 126
 127   buffer += message;
 128   int pos, start = 0;
 129   while ((pos = buffer.find_first_of('\n', start)) >= 0)
 130   {
 131     if (pos > start)
 132       CLog::Log(type, "{}{}", prefix, buffer.substr(start, pos - start));
 133     start = pos+1;
 134   }
 135   buffer.erase(0, start);
 136 }
 137
 138 FFmpegExtraData::FFmpegExtraData(size_t size)
 139   : m_data(reinterpret_cast<uint8_t*>(av_mallocz(size + AV_INPUT_BUFFER_PADDING_SIZE))),
 140     m_size(size)
 141 {
 142   // using av_mallocz because some APIs require at least the padding to be zeroed, e.g. AVCodecParameters
 143   if (!m_data)
 144     throw std::bad_alloc();
 145 }
 146
 147 FFmpegExtraData::FFmpegExtraData(const uint8_t* data, size_t size) : FFmpegExtraData(size)
 148 {
 149   if (size > 0)
 150     std::memcpy(m_data, data, size);
 151 }
 152
 153 FFmpegExtraData::~FFmpegExtraData()
 154 {
 155   av_free(m_data);
 156 }
 157
 158 FFmpegExtraData::FFmpegExtraData(const FFmpegExtraData& e) : FFmpegExtraData(e.m_size)
 159 {
 160   if (m_size > 0)
 161     std::memcpy(m_data, e.m_data, m_size);
 162 }
 163
 164 FFmpegExtraData::FFmpegExtraData(FFmpegExtraData&& other) noexcept : FFmpegExtraData()
 165 {
 166   std::swap(m_data, other.m_data);
 167   std::swap(m_size, other.m_size);
 168 }
 169
 170 FFmpegExtraData& FFmpegExtraData::operator=(const FFmpegExtraData& other)
 171 {
 172   if (this != &other)
 173   {
 174     if (m_size >= other.m_size && other.m_size > 0) // reuse current buffer if large enough
 175     {
 176       std::memcpy(m_data, other.m_data, other.m_size);
 177       m_size = other.m_size;
 178     }
 179     else
 180     {
 181       FFmpegExtraData extraData(other);
 182       *this = std::move(extraData);
 183     }
 184   }
 185   return *this;
 186 }
 187
 188 FFmpegExtraData& FFmpegExtraData::operator=(FFmpegExtraData&& other) noexcept
 189 {
 190   if (this != &other)
 191   {
 192     std::swap(m_data, other.m_data);
 193     std::swap(m_size, other.m_size);
 194   }
 195   return *this;
 196 }
 197
 198 bool FFmpegExtraData::operator==(const FFmpegExtraData& other) const
 199 {
 200   return m_size == other.m_size && (m_size == 0 || std::memcmp(m_data, other.m_data, m_size) == 0);
 201 }
 202
 203 bool FFmpegExtraData::operator!=(const FFmpegExtraData& other) const
 204 {
 205   return !(*this == other);
 206 }
 207
 208 uint8_t* FFmpegExtraData::TakeData()
 209 {
 210   auto tmp = m_data;
 211   m_data = nullptr;
 212   m_size = 0;
 213   return tmp;
 214 }
 215
 216 FFmpegExtraData GetPacketExtradata(const AVPacket* pkt, const AVCodecParameters* codecPar)
 217 {
 218   constexpr int FF_MAX_EXTRADATA_SIZE = ((1 << 28) - AV_INPUT_BUFFER_PADDING_SIZE);
 219
 220   if (!pkt)
 221     return {};
 222
 223   /* extract_extradata bitstream filter is implemented only
 224    * for certain codecs, as noted in discussion of PR#21248
 225    */
 226
 227   AVCodecID codecId = codecPar->codec_id;
 228
 229   // clang-format off
 230   if (
 231     codecId != AV_CODEC_ID_MPEG1VIDEO &&
 232     codecId != AV_CODEC_ID_MPEG2VIDEO &&
 233     codecId != AV_CODEC_ID_H264 &&
 234     codecId != AV_CODEC_ID_HEVC &&
 235     codecId != AV_CODEC_ID_MPEG4 &&
 236     codecId != AV_CODEC_ID_VC1 &&
 237     codecId != AV_CODEC_ID_AV1 &&
 238     codecId != AV_CODEC_ID_AVS2 &&
 239     codecId != AV_CODEC_ID_AVS3 &&
 240     codecId != AV_CODEC_ID_CAVS
 241   )
 242     // clang-format on
 243     return {};
 244
 245   const AVBitStreamFilter* f = av_bsf_get_by_name("extract_extradata");
 246   if (!f)
 247     return {};
 248
 249   AVBSFContext* bsf = nullptr;
 250   int ret = av_bsf_alloc(f, &bsf);
 251   if (ret < 0)
 252     return {};
 253
 254   ret = avcodec_parameters_copy(bsf->par_in, codecPar);
 255   if (ret < 0)
 256   {
 257     av_bsf_free(&bsf);
 258     return {};
 259   }
 260
 261   ret = av_bsf_init(bsf);
 262   if (ret < 0)
 263   {
 264     av_bsf_free(&bsf);
 265     return {};
 266   }
 267
 268   AVPacket* dstPkt = av_packet_alloc();
 269   if (!dstPkt)
 270   {
 271     CLog::LogF(LOGERROR, "failed to allocate packet");
 272
 273     av_bsf_free(&bsf);
 274     return {};
 275   }
 276   AVPacket* pktRef = dstPkt;
 277
 278   ret = av_packet_ref(pktRef, pkt);
 279   if (ret < 0)
 280   {
 281     av_bsf_free(&bsf);
 282     av_packet_free(&dstPkt);
 283     return {};
 284   }
 285
 286   ret = av_bsf_send_packet(bsf, pktRef);
 287   if (ret < 0)
 288   {
 289     av_packet_unref(pktRef);
 290     av_bsf_free(&bsf);
 291     av_packet_free(&dstPkt);
 292     return {};
 293   }
 294
 295   FFmpegExtraData extraData;
 296   ret = 0;
 297   while (ret >= 0)
 298   {
 299     ret = av_bsf_receive_packet(bsf, pktRef);
 300     if (ret < 0)
 301     {
 302       if (ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
 303         break;
 304
 305       continue;
 306     }
 307
 308     size_t retExtraDataSize = 0;
 309     uint8_t* retExtraData =
 310         av_packet_get_side_data(pktRef, AV_PKT_DATA_NEW_EXTRADATA, &retExtraDataSize);
 311     if (retExtraData && retExtraDataSize > 0 && retExtraDataSize < FF_MAX_EXTRADATA_SIZE)
 312     {
 313       try
 314       {
 315         extraData = FFmpegExtraData(retExtraData, retExtraDataSize);
 316       }
 317       catch (const std::bad_alloc&)
 318       {
 319         CLog::LogF(LOGERROR, "failed to allocate {} bytes for extradata", retExtraDataSize);
 320
 321         av_packet_unref(pktRef);
 322         av_bsf_free(&bsf);
 323         av_packet_free(&dstPkt);
 324         return {};
 325       }
 326
 327       CLog::LogF(LOGDEBUG, "fetching extradata, extradata_size({})", retExtraDataSize);
 328
 329       av_packet_unref(pktRef);
 330       break;
 331     }
 332
 333     av_packet_unref(pktRef);
 334   }
 335
 336   av_bsf_free(&bsf);
 337   av_packet_free(&dstPkt);
 338
 339   return extraData;
 340 }