src/lib/ffmpeg_decoder.cc

   1 /*
   2     Copyright (C) 2012-2018 Carl Hetherington <cth@carlh.net>
   3
   4     This file is part of DCP-o-matic.
   5
   6     DCP-o-matic is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 2 of the License, or
   9     (at your option) any later version.
  10
  11     DCP-o-matic is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with DCP-o-matic.  If not, see <http://www.gnu.org/licenses/>.
  18
  19 */
  20
  21 /** @file  src/ffmpeg_decoder.cc
  22  *  @brief A decoder using FFmpeg to decode content.
  23  */
  24
  25 #include "filter.h"
  26 #include "exceptions.h"
  27 #include "image.h"
  28 #include "util.h"
  29 #include "log.h"
  30 #include "dcpomatic_log.h"
  31 #include "ffmpeg_decoder.h"
  32 #include "text_decoder.h"
  33 #include "ffmpeg_audio_stream.h"
  34 #include "ffmpeg_subtitle_stream.h"
  35 #include "video_filter_graph.h"
  36 #include "audio_buffers.h"
  37 #include "ffmpeg_content.h"
  38 #include "raw_image_proxy.h"
  39 #include "video_decoder.h"
  40 #include "film.h"
  41 #include "audio_decoder.h"
  42 #include "compose.hpp"
  43 #include "text_content.h"
  44 #include "audio_content.h"
  45 #include "frame_interval_checker.h"
  46 #include <dcp/subtitle_string.h>
  47 #include <sub/ssa_reader.h>
  48 #include <sub/subtitle.h>
  49 #include <sub/collect.h>
  50 extern "C" {
  51 #include <libavcodec/avcodec.h>
  52 #include <libavformat/avformat.h>
  53 }
  54 #include <boost/algorithm/string.hpp>
  55 #include <vector>
  56 #include <iomanip>
  57 #include <iostream>
  58 #include <stdint.h>
  59
  60 #include "i18n.h"
  61
  62 using std::cout;
  63 using std::string;
  64 using std::vector;
  65 using std::list;
  66 using std::min;
  67 using std::pair;
  68 using std::max;
  69 using std::map;
  70 using std::shared_ptr;
  71 using std::make_shared;
  72 using std::make_pair;
  73 using boost::is_any_of;
  74 using boost::split;
  75 using boost::optional;
  76 using std::dynamic_pointer_cast;
  77 using dcp::Size;
  78 using namespace dcpomatic;
  79
  80
  81 FFmpegDecoder::FFmpegDecoder (shared_ptr<const Film> film, shared_ptr<const FFmpegContent> c, bool fast)
  82         : FFmpeg (c)
  83         , Decoder (film)
  84 {
  85         if (c->video && c->video->use()) {
  86                 video = make_shared<VideoDecoder>(this, c);
  87                 _pts_offset = pts_offset (c->ffmpeg_audio_streams(), c->first_video(), c->active_video_frame_rate(film));
  88                 /* It doesn't matter what size or pixel format this is, it just needs to be black */
  89                 _black_image = make_shared<Image>(AV_PIX_FMT_RGB24, dcp::Size (128, 128), true);
  90                 _black_image->make_black ();
  91         } else {
  92                 _pts_offset = {};
  93         }
  94
  95         if (c->audio) {
  96                 audio = make_shared<AudioDecoder>(this, c->audio, fast);
  97         }
  98
  99         if (c->only_text()) {
 100                 /* XXX: this time here should be the time of the first subtitle, not 0 */
 101                 text.push_back (make_shared<TextDecoder>(this, c->only_text(), ContentTime()));
 102         }
 103
 104         for (auto i: c->ffmpeg_audio_streams()) {
 105                 _next_time[i] = boost::optional<dcpomatic::ContentTime>();
 106         }
 107 }
 108
 109
 110 bool
 111 FFmpegDecoder::flush ()
 112 {
 113         /* Flush video and audio once */
 114
 115         bool did_something = false;
 116         if (video) {
 117                 if (decode_and_process_video_packet(nullptr)) {
 118                         did_something = true;
 119                 }
 120         }
 121
 122         for (auto i: ffmpeg_content()->ffmpeg_audio_streams()) {
 123                 auto context = _codec_context[i->index(_format_context)];
 124                 int r = avcodec_send_packet (context, nullptr);
 125                 if (r < 0 && r != AVERROR_EOF) {
 126                         /* EOF can happen if we've already sent a flush packet */
 127                         throw DecodeError (N_("avcodec_send_packet"), N_("FFmpegDecoder::flush"), r);
 128                 }
 129                 r = avcodec_receive_frame (context, _frame);
 130                 if (r >= 0) {
 131                         process_audio_frame (i);
 132                         did_something = true;
 133                 }
 134         }
 135
 136         if (did_something) {
 137                 /* We want to be called again */
 138                 return false;
 139         }
 140
 141         /* Make sure all streams are the same length and round up to the next video frame */
 142
 143         auto const frc = film()->active_frame_rate_change(_ffmpeg_content->position());
 144         ContentTime full_length (_ffmpeg_content->full_length(film()), frc);
 145         full_length = full_length.ceil (frc.source);
 146         if (video) {
 147                 double const vfr = _ffmpeg_content->video_frame_rate().get();
 148                 auto const f = full_length.frames_round (vfr);
 149                 auto v = video->position(film()).get_value_or(ContentTime()).frames_round(vfr) + 1;
 150                 while (v < f) {
 151                         video->emit (film(), shared_ptr<const ImageProxy> (new RawImageProxy (_black_image)), v);
 152                         ++v;
 153                 }
 154         }
 155
 156         for (auto i: _ffmpeg_content->ffmpeg_audio_streams ()) {
 157                 auto a = audio->stream_position(film(), i);
 158                 /* Unfortunately if a is 0 that really means that we don't know the stream position since
 159                    there has been no data on it since the last seek.  In this case we'll just do nothing
 160                    here.  I'm not sure if that's the right idea.
 161                 */
 162                 if (a > ContentTime()) {
 163                         while (a < full_length) {
 164                                 auto to_do = min (full_length - a, ContentTime::from_seconds (0.1));
 165                                 auto silence = make_shared<AudioBuffers>(i->channels(), to_do.frames_ceil (i->frame_rate()));
 166                                 silence->make_silent ();
 167                                 audio->emit (film(), i, silence, a, true);
 168                                 a += to_do;
 169                         }
 170                 }
 171         }
 172
 173         if (audio) {
 174                 audio->flush ();
 175         }
 176
 177         return true;
 178 }
 179
 180
 181 bool
 182 FFmpegDecoder::pass ()
 183 {
 184         auto packet = av_packet_alloc();
 185         DCPOMATIC_ASSERT (packet);
 186
 187         int r = av_read_frame (_format_context, packet);
 188
 189         /* AVERROR_INVALIDDATA can apparently be returned sometimes even when av_read_frame
 190            has pretty-much succeeded (and hence generated data which should be processed).
 191            Hence it makes sense to continue here in that case.
 192         */
 193         if (r < 0 && r != AVERROR_INVALIDDATA) {
 194                 if (r != AVERROR_EOF) {
 195                         /* Maybe we should fail here, but for now we'll just finish off instead */
 196                         char buf[256];
 197                         av_strerror (r, buf, sizeof(buf));
 198                         LOG_ERROR (N_("error on av_read_frame (%1) (%2)"), &buf[0], r);
 199                 }
 200
 201                 av_packet_free (&packet);
 202                 return flush ();
 203         }
 204
 205         int const si = packet->stream_index;
 206         auto fc = _ffmpeg_content;
 207
 208         if (_video_stream && si == _video_stream.get() && video && !video->ignore()) {
 209                 decode_and_process_video_packet (packet);
 210         } else if (fc->subtitle_stream() && fc->subtitle_stream()->uses_index(_format_context, si) && !only_text()->ignore()) {
 211                 decode_and_process_subtitle_packet (packet);
 212         } else {
 213                 decode_and_process_audio_packet (packet);
 214         }
 215
 216         av_packet_free (&packet);
 217         return false;
 218 }
 219
 220
 221 /** @param data pointer to array of pointers to buffers.
 222  *  Only the first buffer will be used for non-planar data, otherwise there will be one per channel.
 223  */
 224 shared_ptr<AudioBuffers>
 225 FFmpegDecoder::deinterleave_audio (AVFrame* frame)
 226 {
 227         auto format = static_cast<AVSampleFormat>(frame->format);
 228
 229         /* XXX: can't we use swr_convert() to do the format conversion? */
 230
 231         int const channels = frame->channels;
 232         int const frames = frame->nb_samples;
 233         int const total_samples = frames * channels;
 234         auto audio = make_shared<AudioBuffers>(channels, frames);
 235         auto data = audio->data();
 236
 237         switch (format) {
 238         case AV_SAMPLE_FMT_U8:
 239         {
 240                 auto p = reinterpret_cast<uint8_t *> (frame->data[0]);
 241                 int sample = 0;
 242                 int channel = 0;
 243                 for (int i = 0; i < total_samples; ++i) {
 244                         data[channel][sample] = float(*p++) / (1 << 23);
 245
 246                         ++channel;
 247                         if (channel == channels) {
 248                                 channel = 0;
 249                                 ++sample;
 250                         }
 251                 }
 252         }
 253         break;
 254
 255         case AV_SAMPLE_FMT_S16:
 256         {
 257                 auto p = reinterpret_cast<int16_t *> (frame->data[0]);
 258                 int sample = 0;
 259                 int channel = 0;
 260                 for (int i = 0; i < total_samples; ++i) {
 261                         data[channel][sample] = float(*p++) / (1 << 15);
 262
 263                         ++channel;
 264                         if (channel == channels) {
 265                                 channel = 0;
 266                                 ++sample;
 267                         }
 268                 }
 269         }
 270         break;
 271
 272         case AV_SAMPLE_FMT_S16P:
 273         {
 274                 auto p = reinterpret_cast<int16_t **> (frame->data);
 275                 for (int i = 0; i < channels; ++i) {
 276                         for (int j = 0; j < frames; ++j) {
 277                                 data[i][j] = static_cast<float>(p[i][j]) / (1 << 15);
 278                         }
 279                 }
 280         }
 281         break;
 282
 283         case AV_SAMPLE_FMT_S32:
 284         {
 285                 auto p = reinterpret_cast<int32_t *> (frame->data[0]);
 286                 int sample = 0;
 287                 int channel = 0;
 288                 for (int i = 0; i < total_samples; ++i) {
 289                         data[channel][sample] = static_cast<float>(*p++) / 2147483648;
 290
 291                         ++channel;
 292                         if (channel == channels) {
 293                                 channel = 0;
 294                                 ++sample;
 295                         }
 296                 }
 297         }
 298         break;
 299
 300         case AV_SAMPLE_FMT_S32P:
 301         {
 302                 auto p = reinterpret_cast<int32_t **> (frame->data);
 303                 for (int i = 0; i < channels; ++i) {
 304                         for (int j = 0; j < frames; ++j) {
 305                                 data[i][j] = static_cast<float>(p[i][j]) / 2147483648;
 306                         }
 307                 }
 308         }
 309         break;
 310
 311         case AV_SAMPLE_FMT_FLT:
 312         {
 313                 auto p = reinterpret_cast<float*> (frame->data[0]);
 314                 int sample = 0;
 315                 int channel = 0;
 316                 for (int i = 0; i < total_samples; ++i) {
 317                         data[channel][sample] = *p++;
 318
 319                         ++channel;
 320                         if (channel == channels) {
 321                                 channel = 0;
 322                                 ++sample;
 323                         }
 324                 }
 325         }
 326         break;
 327
 328         case AV_SAMPLE_FMT_FLTP:
 329         {
 330                 auto p = reinterpret_cast<float**> (frame->data);
 331                 DCPOMATIC_ASSERT (frame->channels <= channels);
 332                 /* Sometimes there aren't as many channels in the frame as in the stream */
 333                 for (int i = 0; i < frame->channels; ++i) {
 334                         memcpy (data[i], p[i], frames * sizeof(float));
 335                 }
 336                 for (int i = frame->channels; i < channels; ++i) {
 337                         audio->make_silent (i);
 338                 }
 339         }
 340         break;
 341
 342         default:
 343                 throw DecodeError (String::compose(_("Unrecognised audio sample format (%1)"), static_cast<int>(format)));
 344         }
 345
 346         return audio;
 347 }
 348
 349
 350 AVSampleFormat
 351 FFmpegDecoder::audio_sample_format (shared_ptr<FFmpegAudioStream> stream) const
 352 {
 353         return static_cast<AVSampleFormat>(stream->stream(_format_context)->codecpar->format);
 354 }
 355
 356
 357 int
 358 FFmpegDecoder::bytes_per_audio_sample (shared_ptr<FFmpegAudioStream> stream) const
 359 {
 360         return av_get_bytes_per_sample (audio_sample_format (stream));
 361 }
 362
 363
 364 void
 365 FFmpegDecoder::seek (ContentTime time, bool accurate)
 366 {
 367         Decoder::seek (time, accurate);
 368
 369         /* If we are doing an `accurate' seek, we need to use pre-roll, as
 370            we don't really know what the seek will give us.
 371         */
 372
 373         auto pre_roll = accurate ? ContentTime::from_seconds (2) : ContentTime (0);
 374         time -= pre_roll;
 375
 376         /* XXX: it seems debatable whether PTS should be used here...
 377            http://www.mjbshaw.com/2012/04/seeking-in-ffmpeg-know-your-timestamp.html
 378         */
 379
 380         optional<int> stream;
 381
 382         if (_video_stream) {
 383                 stream = _video_stream;
 384         } else {
 385                 DCPOMATIC_ASSERT (_ffmpeg_content->audio);
 386                 auto s = dynamic_pointer_cast<FFmpegAudioStream>(_ffmpeg_content->audio->stream());
 387                 if (s) {
 388                         stream = s->index (_format_context);
 389                 }
 390         }
 391
 392         DCPOMATIC_ASSERT (stream);
 393
 394         auto u = time - _pts_offset;
 395         if (u < ContentTime ()) {
 396                 u = ContentTime ();
 397         }
 398         av_seek_frame (
 399                 _format_context,
 400                 stream.get(),
 401                 u.seconds() / av_q2d (_format_context->streams[stream.get()]->time_base),
 402                 AVSEEK_FLAG_BACKWARD
 403                 );
 404
 405         {
 406                 /* Force re-creation of filter graphs to reset them and hence to make sure
 407                    they don't have any pre-seek frames knocking about.
 408                 */
 409                 boost::mutex::scoped_lock lm (_filter_graphs_mutex);
 410                 _filter_graphs.clear ();
 411         }
 412
 413         if (video_codec_context ()) {
 414                 avcodec_flush_buffers (video_codec_context());
 415         }
 416
 417         for (auto i: ffmpeg_content()->ffmpeg_audio_streams()) {
 418                 avcodec_flush_buffers (_codec_context[i->index(_format_context)]);
 419         }
 420
 421         if (subtitle_codec_context ()) {
 422                 avcodec_flush_buffers (subtitle_codec_context ());
 423         }
 424
 425         _have_current_subtitle = false;
 426
 427         for (auto& i: _next_time) {
 428                 i.second = boost::optional<dcpomatic::ContentTime>();
 429         }
 430
 431         /* We find that we get some errors from av_send_packet after a seek.  Perhaps we should ignore
 432          * all of them (which seems risky), or perhaps we should have some proper fix.  But instead
 433          * let's ignore the next 2 errors.
 434          */
 435         _errors_to_ignore = 2;
 436 }
 437
 438
 439 shared_ptr<FFmpegAudioStream>
 440 FFmpegDecoder::audio_stream_from_index (int index) const
 441 {
 442         /* XXX: inefficient */
 443         auto streams = ffmpeg_content()->ffmpeg_audio_streams();
 444         auto stream = streams.begin();
 445         while (stream != streams.end() && !(*stream)->uses_index(_format_context, index)) {
 446                 ++stream;
 447         }
 448
 449         if (stream == streams.end ()) {
 450                 return {};
 451         }
 452
 453         return *stream;
 454 }
 455
 456
 457 void
 458 FFmpegDecoder::process_audio_frame (shared_ptr<FFmpegAudioStream> stream)
 459 {
 460         auto data = deinterleave_audio (_frame);
 461
 462         ContentTime ct;
 463         if (_frame->pts == AV_NOPTS_VALUE) {
 464                 /* In some streams we see not every frame coming through with a timestamp; for those
 465                    that have AV_NOPTS_VALUE we need to work out the timestamp ourselves.  This is
 466                    particularly noticeable with TrueHD streams (see #1111).
 467                    */
 468                 if (_next_time[stream]) {
 469                         ct = *_next_time[stream];
 470                 }
 471         } else {
 472                 ct = ContentTime::from_seconds (
 473                         _frame->best_effort_timestamp *
 474                         av_q2d (stream->stream(_format_context)->time_base))
 475                         + _pts_offset;
 476         }
 477
 478         _next_time[stream] = ct + ContentTime::from_frames(data->frames(), stream->frame_rate());
 479
 480         if (ct < ContentTime()) {
 481                 /* Discard audio data that comes before time 0 */
 482                 auto const remove = min (int64_t(data->frames()), (-ct).frames_ceil(double(stream->frame_rate())));
 483                 data->move (data->frames() - remove, remove, 0);
 484                 data->set_frames (data->frames() - remove);
 485                 ct += ContentTime::from_frames (remove, stream->frame_rate());
 486         }
 487
 488         if (ct < ContentTime()) {
 489                 LOG_WARNING (
 490                         "Crazy timestamp %1 for %2 samples in stream %3 (ts=%4 tb=%5, off=%6)",
 491                         to_string(ct),
 492                         data->frames(),
 493                         stream->id(),
 494                         _frame->best_effort_timestamp,
 495                         av_q2d(stream->stream(_format_context)->time_base),
 496                         to_string(_pts_offset)
 497                         );
 498         }
 499
 500         /* Give this data provided there is some, and its time is sane */
 501         if (ct >= ContentTime() && data->frames() > 0) {
 502                 audio->emit (film(), stream, data, ct);
 503         }
 504 }
 505
 506
 507 void
 508 FFmpegDecoder::decode_and_process_audio_packet (AVPacket* packet)
 509 {
 510         auto stream = audio_stream_from_index (packet->stream_index);
 511         if (!stream) {
 512                 return;
 513         }
 514
 515         auto context = _codec_context[stream->index(_format_context)];
 516
 517         int r = avcodec_send_packet (context, packet);
 518         if (r < 0) {
 519                 /* We could cope with AVERROR(EAGAIN) and re-send the packet but I think it should never happen.
 520                  * Likewise I think AVERROR_EOF should not happen.
 521                  */
 522                 if (_errors_to_ignore > 0) {
 523                         /* We see errors here after a seek, which is hopefully to be nothing to worry about */
 524                         --_errors_to_ignore;
 525                         LOG_GENERAL("Ignoring error %1 avcodec_send_packet after seek; will ignore %2 more", r, _errors_to_ignore);
 526                         return;
 527                 }
 528                 throw DecodeError (N_("avcodec_send_packet"), N_("FFmpegDecoder::decode_and_process_audio_packet"), r);
 529         }
 530
 531         while (r >= 0) {
 532                 r = avcodec_receive_frame (context, _frame);
 533                 if (r == AVERROR(EAGAIN)) {
 534                         /* More input is required */
 535                         return;
 536                 }
 537
 538                 /* We choose to be relaxed here about other errors; it seems that there may be valid
 539                  * data to decode even if an error occurred.  #352 may be related (though this was
 540                  * when we were using an old version of the FFmpeg API).
 541                  */
 542                 process_audio_frame (stream);
 543         }
 544 }
 545
 546
 547 bool
 548 FFmpegDecoder::decode_and_process_video_packet (AVPacket* packet)
 549 {
 550         DCPOMATIC_ASSERT (_video_stream);
 551
 552         auto context = video_codec_context();
 553
 554         int r = avcodec_send_packet (context, packet);
 555         if (r < 0 && !(r == AVERROR_EOF && !packet)) {
 556                 /* We could cope with AVERROR(EAGAIN) and re-send the packet but I think it should never happen.
 557                  * AVERROR_EOF can happen during flush if we've already sent a flush packet.
 558                  */
 559                 throw DecodeError (N_("avcodec_send_packet"), N_("FFmpegDecoder::decode_and_process_video_packet"), r);
 560         }
 561
 562         r = avcodec_receive_frame (context, _frame);
 563         if (r == AVERROR(EAGAIN) || r == AVERROR_EOF || (r < 0 && !packet)) {
 564                 /* More input is required, no more frames are coming, or we are flushing and there was
 565                  * some error which we just want to ignore.
 566                  */
 567                 return false;
 568         } else if (r < 0) {
 569                 throw DecodeError (N_("avcodec_receive_frame"), N_("FFmpeg::decode_and_process_video_packet"), r);
 570         }
 571
 572         /* We assume we'll only get one frame here, which I think is safe */
 573
 574         boost::mutex::scoped_lock lm (_filter_graphs_mutex);
 575
 576         shared_ptr<VideoFilterGraph> graph;
 577
 578         auto i = _filter_graphs.begin();
 579         while (i != _filter_graphs.end() && !(*i)->can_process (dcp::Size (_frame->width, _frame->height), (AVPixelFormat) _frame->format)) {
 580                 ++i;
 581         }
 582
 583         if (i == _filter_graphs.end ()) {
 584                 dcp::Fraction vfr (lrint(_ffmpeg_content->video_frame_rate().get() * 1000), 1000);
 585                 graph = make_shared<VideoFilterGraph>(dcp::Size (_frame->width, _frame->height), (AVPixelFormat) _frame->format, vfr);
 586                 graph->setup (_ffmpeg_content->filters ());
 587                 _filter_graphs.push_back (graph);
 588                 LOG_GENERAL (N_("New graph for %1x%2, pixel format %3"), _frame->width, _frame->height, _frame->format);
 589         } else {
 590                 graph = *i;
 591         }
 592
 593         auto images = graph->process (_frame);
 594
 595         for (auto const& i: images) {
 596
 597                 auto image = i.first;
 598
 599                 if (i.second != AV_NOPTS_VALUE) {
 600                         double const pts = i.second * av_q2d(_format_context->streams[_video_stream.get()]->time_base) + _pts_offset.seconds();
 601
 602                         video->emit (
 603                                 film(),
 604                                 make_shared<RawImageProxy>(image),
 605                                 llrint(pts * _ffmpeg_content->active_video_frame_rate(film()))
 606                                 );
 607                 } else {
 608                         LOG_WARNING_NC ("Dropping frame without PTS");
 609                 }
 610         }
 611
 612         return true;
 613 }
 614
 615
 616 void
 617 FFmpegDecoder::decode_and_process_subtitle_packet (AVPacket* packet)
 618 {
 619         int got_subtitle;
 620         AVSubtitle sub;
 621         if (avcodec_decode_subtitle2 (subtitle_codec_context(), &sub, &got_subtitle, packet) < 0 || !got_subtitle) {
 622                 return;
 623         }
 624
 625         auto sub_period = subtitle_period (packet, ffmpeg_content()->subtitle_stream()->stream(_format_context), sub);
 626
 627         /* Stop any current subtitle, either at the time it was supposed to stop, or now if now is sooner */
 628         if (_have_current_subtitle) {
 629                 if (_current_subtitle_to) {
 630                         only_text()->emit_stop (min(*_current_subtitle_to, sub_period.from + _pts_offset));
 631                 } else {
 632                         only_text()->emit_stop (sub_period.from + _pts_offset);
 633                 }
 634                 _have_current_subtitle = false;
 635         }
 636
 637         if (sub.num_rects <= 0) {
 638                 /* Nothing new in this subtitle */
 639                 avsubtitle_free (&sub);
 640                 return;
 641         }
 642
 643         /* Subtitle PTS (within the source, not taking into account any of the
 644            source that we may have chopped off for the DCP).
 645         */
 646         ContentTime from;
 647         from = sub_period.from + _pts_offset;
 648         if (sub_period.to) {
 649                 _current_subtitle_to = *sub_period.to + _pts_offset;
 650         } else {
 651                 _current_subtitle_to = optional<ContentTime>();
 652                 _have_current_subtitle = true;
 653         }
 654
 655         for (unsigned int i = 0; i < sub.num_rects; ++i) {
 656                 auto const rect = sub.rects[i];
 657
 658                 switch (rect->type) {
 659                 case SUBTITLE_NONE:
 660                         break;
 661                 case SUBTITLE_BITMAP:
 662                         process_bitmap_subtitle (rect, from);
 663                         break;
 664                 case SUBTITLE_TEXT:
 665                         cout << "XXX: SUBTITLE_TEXT " << rect->text << "\n";
 666                         break;
 667                 case SUBTITLE_ASS:
 668                         process_ass_subtitle (rect->ass, from);
 669                         break;
 670                 }
 671         }
 672
 673         if (_current_subtitle_to) {
 674                 only_text()->emit_stop (*_current_subtitle_to);
 675         }
 676
 677         avsubtitle_free (&sub);
 678 }
 679
 680
 681 void
 682 FFmpegDecoder::process_bitmap_subtitle (AVSubtitleRect const * rect, ContentTime from)
 683 {
 684         /* Note BGRA is expressed little-endian, so the first byte in the word is B, second
 685            G, third R, fourth A.
 686         */
 687         auto image = make_shared<Image>(AV_PIX_FMT_BGRA, dcp::Size (rect->w, rect->h), true);
 688
 689 #ifdef DCPOMATIC_HAVE_AVSUBTITLERECT_PICT
 690         /* Start of the first line in the subtitle */
 691         auto sub_p = rect->pict.data[0];
 692         /* sub_p looks up into a BGRA palette which is at rect->pict.data[1];
 693            (i.e. first byte B, second G, third R, fourth A)
 694         */
 695         auto const palette = rect->pict.data[1];
 696 #else
 697         /* Start of the first line in the subtitle */
 698         auto sub_p = rect->data[0];
 699         /* sub_p looks up into a BGRA palette which is at rect->data[1].
 700            (first byte B, second G, third R, fourth A)
 701         */
 702         auto const* palette = rect->data[1];
 703 #endif
 704         /* And the stream has a map of those palette colours to colours
 705            chosen by the user; created a `mapped' palette from those settings.
 706         */
 707         auto colour_map = ffmpeg_content()->subtitle_stream()->colours();
 708         vector<RGBA> mapped_palette (rect->nb_colors);
 709         for (int i = 0; i < rect->nb_colors; ++i) {
 710                 RGBA c (palette[2], palette[1], palette[0], palette[3]);
 711                 auto j = colour_map.find (c);
 712                 if (j != colour_map.end ()) {
 713                         mapped_palette[i] = j->second;
 714                 } else {
 715                         /* This colour was not found in the FFmpegSubtitleStream's colour map; probably because
 716                            it is from a project that was created before this stuff was added.  Just use the
 717                            colour straight from the original palette.
 718                         */
 719                         mapped_palette[i] = c;
 720                 }
 721                 palette += 4;
 722         }
 723
 724         /* Start of the output data */
 725         auto out_p = image->data()[0];
 726
 727         for (int y = 0; y < rect->h; ++y) {
 728                 auto sub_line_p = sub_p;
 729                 auto out_line_p = out_p;
 730                 for (int x = 0; x < rect->w; ++x) {
 731                         auto const p = mapped_palette[*sub_line_p++];
 732                         *out_line_p++ = p.b;
 733                         *out_line_p++ = p.g;
 734                         *out_line_p++ = p.r;
 735                         *out_line_p++ = p.a;
 736                 }
 737 #ifdef DCPOMATIC_HAVE_AVSUBTITLERECT_PICT
 738                 sub_p += rect->pict.linesize[0];
 739 #else
 740                 sub_p += rect->linesize[0];
 741 #endif
 742                 out_p += image->stride()[0];
 743         }
 744
 745         int target_width = subtitle_codec_context()->width;
 746         if (target_width == 0 && video_codec_context()) {
 747                 /* subtitle_codec_context()->width == 0 has been seen in the wild but I don't
 748                    know if it's supposed to mean something from FFmpeg's point of view.
 749                 */
 750                 target_width = video_codec_context()->width;
 751         }
 752         int target_height = subtitle_codec_context()->height;
 753         if (target_height == 0 && video_codec_context()) {
 754                 target_height = video_codec_context()->height;
 755         }
 756         DCPOMATIC_ASSERT (target_width);
 757         DCPOMATIC_ASSERT (target_height);
 758         dcpomatic::Rect<double> const scaled_rect (
 759                 static_cast<double>(rect->x) / target_width,
 760                 static_cast<double>(rect->y) / target_height,
 761                 static_cast<double>(rect->w) / target_width,
 762                 static_cast<double>(rect->h) / target_height
 763                 );
 764
 765         only_text()->emit_bitmap_start (from, image, scaled_rect);
 766 }
 767
 768
 769 void
 770 FFmpegDecoder::process_ass_subtitle (string ass, ContentTime from)
 771 {
 772         /* We have no styles and no Format: line, so I'm assuming that FFmpeg
 773            produces a single format of Dialogue: lines...
 774         */
 775
 776         int commas = 0;
 777         string text;
 778         for (size_t i = 0; i < ass.length(); ++i) {
 779                 if (commas < 9 && ass[i] == ',') {
 780                         ++commas;
 781                 } else if (commas == 9) {
 782                         text += ass[i];
 783                 }
 784         }
 785
 786         if (text.empty ()) {
 787                 return;
 788         }
 789
 790         sub::RawSubtitle base;
 791         auto raw = sub::SSAReader::parse_line (
 792                 base,
 793                 text,
 794                 _ffmpeg_content->video->size().width,
 795                 _ffmpeg_content->video->size().height
 796                 );
 797
 798         for (auto const& i: sub::collect<vector<sub::Subtitle>>(raw)) {
 799                 only_text()->emit_plain_start (from, i);
 800         }
 801 }