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 boost::is_any_of;
  73 using boost::split;
  74 using boost::optional;
  75 using std::dynamic_pointer_cast;
  76 using dcp::Size;
  77 using namespace dcpomatic;
  78
  79
  80 FFmpegDecoder::FFmpegDecoder (shared_ptr<const Film> film, shared_ptr<const FFmpegContent> c, bool fast)
  81         : FFmpeg (c)
  82         , Decoder (film)
  83         , _have_current_subtitle (false)
  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.reset (new 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         _next_time.resize (_format_context->nb_streams);
 105 }
 106
 107
 108 void
 109 FFmpegDecoder::flush ()
 110 {
 111         /* Get any remaining frames */
 112
 113         _packet.data = 0;
 114         _packet.size = 0;
 115
 116         /* XXX: should we reset _packet.data and size after each *_decode_* call? */
 117
 118         while (video && decode_video_packet()) {}
 119
 120         if (audio) {
 121                 decode_audio_packet ();
 122         }
 123
 124         /* Make sure all streams are the same length and round up to the next video frame */
 125
 126         auto const frc = film()->active_frame_rate_change(_ffmpeg_content->position());
 127         ContentTime full_length (_ffmpeg_content->full_length(film()), frc);
 128         full_length = full_length.ceil (frc.source);
 129         if (video) {
 130                 double const vfr = _ffmpeg_content->video_frame_rate().get();
 131                 auto const f = full_length.frames_round (vfr);
 132                 auto v = video->position(film()).get_value_or(ContentTime()).frames_round(vfr) + 1;
 133                 while (v < f) {
 134                         video->emit (film(), shared_ptr<const ImageProxy> (new RawImageProxy (_black_image)), v);
 135                         ++v;
 136                 }
 137         }
 138
 139         for (auto i: _ffmpeg_content->ffmpeg_audio_streams ()) {
 140                 auto a = audio->stream_position(film(), i);
 141                 /* Unfortunately if a is 0 that really means that we don't know the stream position since
 142                    there has been no data on it since the last seek.  In this case we'll just do nothing
 143                    here.  I'm not sure if that's the right idea.
 144                 */
 145                 if (a > ContentTime()) {
 146                         while (a < full_length) {
 147                                 auto to_do = min (full_length - a, ContentTime::from_seconds (0.1));
 148                                 auto silence = make_shared<AudioBuffers>(i->channels(), to_do.frames_ceil (i->frame_rate()));
 149                                 silence->make_silent ();
 150                                 audio->emit (film(), i, silence, a, true);
 151                                 a += to_do;
 152                         }
 153                 }
 154         }
 155
 156         if (audio) {
 157                 audio->flush ();
 158         }
 159 }
 160
 161
 162 bool
 163 FFmpegDecoder::pass ()
 164 {
 165         int r = av_read_frame (_format_context, &_packet);
 166
 167         /* AVERROR_INVALIDDATA can apparently be returned sometimes even when av_read_frame
 168            has pretty-much succeeded (and hence generated data which should be processed).
 169            Hence it makes sense to continue here in that case.
 170         */
 171         if (r < 0 && r != AVERROR_INVALIDDATA) {
 172                 if (r != AVERROR_EOF) {
 173                         /* Maybe we should fail here, but for now we'll just finish off instead */
 174                         char buf[256];
 175                         av_strerror (r, buf, sizeof(buf));
 176                         LOG_ERROR (N_("error on av_read_frame (%1) (%2)"), &buf[0], r);
 177                 }
 178
 179                 flush ();
 180                 return true;
 181         }
 182
 183         int const si = _packet.stream_index;
 184         auto fc = _ffmpeg_content;
 185
 186         if (_video_stream && si == _video_stream.get() && video && !video->ignore()) {
 187                 decode_video_packet ();
 188         } else if (fc->subtitle_stream() && fc->subtitle_stream()->uses_index(_format_context, si) && !only_text()->ignore()) {
 189                 decode_subtitle_packet ();
 190         } else {
 191                 decode_audio_packet ();
 192         }
 193
 194         av_packet_unref (&_packet);
 195         return false;
 196 }
 197
 198
 199 /** @param data pointer to array of pointers to buffers.
 200  *  Only the first buffer will be used for non-planar data, otherwise there will be one per channel.
 201  */
 202 shared_ptr<AudioBuffers>
 203 FFmpegDecoder::deinterleave_audio (shared_ptr<FFmpegAudioStream> stream) const
 204 {
 205         DCPOMATIC_ASSERT (bytes_per_audio_sample (stream));
 206
 207 DCPOMATIC_DISABLE_WARNINGS
 208         int const size = av_samples_get_buffer_size (
 209                 0, stream->stream(_format_context)->codec->channels, _frame->nb_samples, audio_sample_format (stream), 1
 210                 );
 211 DCPOMATIC_ENABLE_WARNINGS
 212
 213         /* XXX: can't we just use _frame->nb_samples directly here? */
 214         /* XXX: can't we use swr_convert() to do the format conversion? */
 215
 216         /* Deinterleave and convert to float */
 217
 218         /* total_samples and frames will be rounded down here, so if there are stray samples at the end
 219            of the block that do not form a complete sample or frame they will be dropped.
 220         */
 221         int const total_samples = size / bytes_per_audio_sample (stream);
 222         int const channels = stream->channels();
 223         int const frames = total_samples / channels;
 224         auto audio = make_shared<AudioBuffers>(channels, frames);
 225         auto data = audio->data();
 226
 227         switch (audio_sample_format (stream)) {
 228         case AV_SAMPLE_FMT_U8:
 229         {
 230                 uint8_t* p = reinterpret_cast<uint8_t *> (_frame->data[0]);
 231                 int sample = 0;
 232                 int channel = 0;
 233                 for (int i = 0; i < total_samples; ++i) {
 234                         data[channel][sample] = float(*p++) / (1 << 23);
 235
 236                         ++channel;
 237                         if (channel == channels) {
 238                                 channel = 0;
 239                                 ++sample;
 240                         }
 241                 }
 242         }
 243         break;
 244
 245         case AV_SAMPLE_FMT_S16:
 246         {
 247                 int16_t* p = reinterpret_cast<int16_t *> (_frame->data[0]);
 248                 int sample = 0;
 249                 int channel = 0;
 250                 for (int i = 0; i < total_samples; ++i) {
 251                         data[channel][sample] = float(*p++) / (1 << 15);
 252
 253                         ++channel;
 254                         if (channel == channels) {
 255                                 channel = 0;
 256                                 ++sample;
 257                         }
 258                 }
 259         }
 260         break;
 261
 262         case AV_SAMPLE_FMT_S16P:
 263         {
 264                 int16_t** p = reinterpret_cast<int16_t **> (_frame->data);
 265                 for (int i = 0; i < channels; ++i) {
 266                         for (int j = 0; j < frames; ++j) {
 267                                 data[i][j] = static_cast<float>(p[i][j]) / (1 << 15);
 268                         }
 269                 }
 270         }
 271         break;
 272
 273         case AV_SAMPLE_FMT_S32:
 274         {
 275                 int32_t* p = reinterpret_cast<int32_t *> (_frame->data[0]);
 276                 int sample = 0;
 277                 int channel = 0;
 278                 for (int i = 0; i < total_samples; ++i) {
 279                         data[channel][sample] = static_cast<float>(*p++) / 2147483648;
 280
 281                         ++channel;
 282                         if (channel == channels) {
 283                                 channel = 0;
 284                                 ++sample;
 285                         }
 286                 }
 287         }
 288         break;
 289
 290         case AV_SAMPLE_FMT_S32P:
 291         {
 292                 int32_t** p = reinterpret_cast<int32_t **> (_frame->data);
 293                 for (int i = 0; i < channels; ++i) {
 294                         for (int j = 0; j < frames; ++j) {
 295                                 data[i][j] = static_cast<float>(p[i][j]) / 2147483648;
 296                         }
 297                 }
 298         }
 299         break;
 300
 301         case AV_SAMPLE_FMT_FLT:
 302         {
 303                 float* p = reinterpret_cast<float*> (_frame->data[0]);
 304                 int sample = 0;
 305                 int channel = 0;
 306                 for (int i = 0; i < total_samples; ++i) {
 307                         data[channel][sample] = *p++;
 308
 309                         ++channel;
 310                         if (channel == channels) {
 311                                 channel = 0;
 312                                 ++sample;
 313                         }
 314                 }
 315         }
 316         break;
 317
 318         case AV_SAMPLE_FMT_FLTP:
 319         {
 320                 float** p = reinterpret_cast<float**> (_frame->data);
 321                 DCPOMATIC_ASSERT (_frame->channels <= channels);
 322                 /* Sometimes there aren't as many channels in the _frame as in the stream */
 323                 for (int i = 0; i < _frame->channels; ++i) {
 324                         memcpy (data[i], p[i], frames * sizeof(float));
 325                 }
 326                 for (int i = _frame->channels; i < channels; ++i) {
 327                         audio->make_silent (i);
 328                 }
 329         }
 330         break;
 331
 332         default:
 333                 throw DecodeError (String::compose (_("Unrecognised audio sample format (%1)"), static_cast<int> (audio_sample_format (stream))));
 334         }
 335
 336         return audio;
 337 }
 338
 339
 340 AVSampleFormat
 341 FFmpegDecoder::audio_sample_format (shared_ptr<FFmpegAudioStream> stream) const
 342 {
 343 DCPOMATIC_DISABLE_WARNINGS
 344         return stream->stream (_format_context)->codec->sample_fmt;
 345 DCPOMATIC_ENABLE_WARNINGS
 346 }
 347
 348
 349 int
 350 FFmpegDecoder::bytes_per_audio_sample (shared_ptr<FFmpegAudioStream> stream) const
 351 {
 352         return av_get_bytes_per_sample (audio_sample_format (stream));
 353 }
 354
 355
 356 void
 357 FFmpegDecoder::seek (ContentTime time, bool accurate)
 358 {
 359         Decoder::seek (time, accurate);
 360
 361         /* If we are doing an `accurate' seek, we need to use pre-roll, as
 362            we don't really know what the seek will give us.
 363         */
 364
 365         auto pre_roll = accurate ? ContentTime::from_seconds (2) : ContentTime (0);
 366         time -= pre_roll;
 367
 368         /* XXX: it seems debatable whether PTS should be used here...
 369            http://www.mjbshaw.com/2012/04/seeking-in-ffmpeg-know-your-timestamp.html
 370         */
 371
 372         optional<int> stream;
 373
 374         if (_video_stream) {
 375                 stream = _video_stream;
 376         } else {
 377                 DCPOMATIC_ASSERT (_ffmpeg_content->audio);
 378                 auto s = dynamic_pointer_cast<FFmpegAudioStream>(_ffmpeg_content->audio->stream());
 379                 if (s) {
 380                         stream = s->index (_format_context);
 381                 }
 382         }
 383
 384         DCPOMATIC_ASSERT (stream);
 385
 386         auto u = time - _pts_offset;
 387         if (u < ContentTime ()) {
 388                 u = ContentTime ();
 389         }
 390         av_seek_frame (
 391                 _format_context,
 392                 stream.get(),
 393                 u.seconds() / av_q2d (_format_context->streams[stream.get()]->time_base),
 394                 AVSEEK_FLAG_BACKWARD
 395                 );
 396
 397         {
 398                 /* Force re-creation of filter graphs to reset them and hence to make sure
 399                    they don't have any pre-seek frames knocking about.
 400                 */
 401                 boost::mutex::scoped_lock lm (_filter_graphs_mutex);
 402                 _filter_graphs.clear ();
 403         }
 404
 405         if (video_codec_context ()) {
 406                 avcodec_flush_buffers (video_codec_context());
 407         }
 408
 409 DCPOMATIC_DISABLE_WARNINGS
 410         for (auto i: ffmpeg_content()->ffmpeg_audio_streams()) {
 411                 avcodec_flush_buffers (i->stream(_format_context)->codec);
 412         }
 413 DCPOMATIC_ENABLE_WARNINGS
 414
 415         if (subtitle_codec_context ()) {
 416                 avcodec_flush_buffers (subtitle_codec_context ());
 417         }
 418
 419         _have_current_subtitle = false;
 420
 421         for (auto& i: _next_time) {
 422                 i = optional<ContentTime>();
 423         }
 424 }
 425
 426
 427 void
 428 FFmpegDecoder::decode_audio_packet ()
 429 {
 430         /* Audio packets can contain multiple frames, so we may have to call avcodec_decode_audio4
 431            several times.
 432         */
 433
 434         AVPacket copy_packet = _packet;
 435         int const stream_index = copy_packet.stream_index;
 436
 437         /* XXX: inefficient */
 438         auto streams = ffmpeg_content()->ffmpeg_audio_streams();
 439         auto stream = streams.begin ();
 440         while (stream != streams.end () && !(*stream)->uses_index (_format_context, stream_index)) {
 441                 ++stream;
 442         }
 443
 444         if (stream == streams.end ()) {
 445                 /* The packet's stream may not be an audio one; just ignore it in this method if so */
 446                 return;
 447         }
 448
 449 DCPOMATIC_DISABLE_WARNINGS
 450         while (copy_packet.size > 0) {
 451
 452                 int frame_finished;
 453                 int decode_result = avcodec_decode_audio4 ((*stream)->stream (_format_context)->codec, _frame, &frame_finished, &copy_packet);
 454                 if (decode_result < 0) {
 455                         /* avcodec_decode_audio4 can sometimes return an error even though it has decoded
 456                            some valid data; for example dca_subframe_footer can return AVERROR_INVALIDDATA
 457                            if it overreads the auxiliary data.  ffplay carries on if frame_finished is true,
 458                            even in the face of such an error, so I think we should too.
 459
 460                            Returning from the method here caused mantis #352.
 461                         */
 462                         LOG_WARNING ("avcodec_decode_audio4 failed (%1)", decode_result);
 463
 464                         /* Fudge decode_result so that we come out of the while loop when
 465                            we've processed this data.
 466                         */
 467                         decode_result = copy_packet.size;
 468                 }
 469
 470                 if (frame_finished) {
 471                         shared_ptr<AudioBuffers> data = deinterleave_audio (*stream);
 472
 473                         ContentTime ct;
 474                         if (_frame->pts == AV_NOPTS_VALUE) {
 475                                 /* In some streams we see not every frame coming through with a timestamp; for those
 476                                    that have AV_NOPTS_VALUE we need to work out the timestamp ourselves.  This is
 477                                    particularly noticeable with TrueHD streams (see #1111).
 478                                 */
 479                                 if (_next_time[stream_index]) {
 480                                         ct = *_next_time[stream_index];
 481                                 }
 482                         } else {
 483                                 ct = ContentTime::from_seconds (
 484                                         av_frame_get_best_effort_timestamp (_frame) *
 485                                         av_q2d ((*stream)->stream (_format_context)->time_base))
 486                                         + _pts_offset;
 487                         }
 488
 489                         _next_time[stream_index] = ct + ContentTime::from_frames(data->frames(), (*stream)->frame_rate());
 490
 491                         if (ct < ContentTime()) {
 492                                 /* Discard audio data that comes before time 0 */
 493                                 auto const remove = min (int64_t (data->frames()), (-ct).frames_ceil(double((*stream)->frame_rate ())));
 494                                 data->move (data->frames() - remove, remove, 0);
 495                                 data->set_frames (data->frames() - remove);
 496                                 ct += ContentTime::from_frames (remove, (*stream)->frame_rate ());
 497                         }
 498
 499                         if (ct < ContentTime()) {
 500                                 LOG_WARNING (
 501                                         "Crazy timestamp %1 for %2 samples in stream %3 packet pts %4 (ts=%5 tb=%6, off=%7)",
 502                                         to_string(ct),
 503                                         data->frames(),
 504                                         copy_packet.stream_index,
 505                                         copy_packet.pts,
 506                                         av_frame_get_best_effort_timestamp(_frame),
 507                                         av_q2d((*stream)->stream(_format_context)->time_base),
 508                                         to_string(_pts_offset)
 509                                         );
 510                         }
 511 DCPOMATIC_ENABLE_WARNINGS
 512
 513                         /* Give this data provided there is some, and its time is sane */
 514                         if (ct >= ContentTime() && data->frames() > 0) {
 515                                 audio->emit (film(), *stream, data, ct);
 516                         }
 517                 }
 518
 519                 copy_packet.data += decode_result;
 520                 copy_packet.size -= decode_result;
 521         }
 522 }
 523
 524
 525 bool
 526 FFmpegDecoder::decode_video_packet ()
 527 {
 528         DCPOMATIC_ASSERT (_video_stream);
 529
 530         int frame_finished;
 531 DCPOMATIC_DISABLE_WARNINGS
 532         if (avcodec_decode_video2 (video_codec_context(), _frame, &frame_finished, &_packet) < 0 || !frame_finished) {
 533                 return false;
 534         }
 535 DCPOMATIC_ENABLE_WARNINGS
 536
 537         boost::mutex::scoped_lock lm (_filter_graphs_mutex);
 538
 539         shared_ptr<VideoFilterGraph> graph;
 540
 541         auto i = _filter_graphs.begin();
 542         while (i != _filter_graphs.end() && !(*i)->can_process (dcp::Size (_frame->width, _frame->height), (AVPixelFormat) _frame->format)) {
 543                 ++i;
 544         }
 545
 546         if (i == _filter_graphs.end ()) {
 547                 dcp::Fraction vfr (lrint(_ffmpeg_content->video_frame_rate().get() * 1000), 1000);
 548                 graph = make_shared<VideoFilterGraph>(dcp::Size (_frame->width, _frame->height), (AVPixelFormat) _frame->format, vfr);
 549                 graph->setup (_ffmpeg_content->filters ());
 550                 _filter_graphs.push_back (graph);
 551                 LOG_GENERAL (N_("New graph for %1x%2, pixel format %3"), _frame->width, _frame->height, _frame->format);
 552         } else {
 553                 graph = *i;
 554         }
 555
 556         auto images = graph->process (_frame);
 557
 558         for (auto const& i: images) {
 559
 560                 auto image = i.first;
 561
 562                 if (i.second != AV_NOPTS_VALUE) {
 563                         double const pts = i.second * av_q2d(_format_context->streams[_video_stream.get()]->time_base) + _pts_offset.seconds();
 564
 565                         video->emit (
 566                                 film(),
 567                                 make_shared<RawImageProxy>(image),
 568                                 llrint(pts * _ffmpeg_content->active_video_frame_rate(film()))
 569                                 );
 570                 } else {
 571                         LOG_WARNING_NC ("Dropping frame without PTS");
 572                 }
 573         }
 574
 575         return true;
 576 }
 577
 578
 579 void
 580 FFmpegDecoder::decode_subtitle_packet ()
 581 {
 582         int got_subtitle;
 583         AVSubtitle sub;
 584         if (avcodec_decode_subtitle2 (subtitle_codec_context(), &sub, &got_subtitle, &_packet) < 0 || !got_subtitle) {
 585                 return;
 586         }
 587
 588         /* Stop any current subtitle, either at the time it was supposed to stop, or now if now is sooner */
 589         if (_have_current_subtitle) {
 590                 if (_current_subtitle_to) {
 591                         only_text()->emit_stop (min(*_current_subtitle_to, subtitle_period(sub).from + _pts_offset));
 592                 } else {
 593                         only_text()->emit_stop (subtitle_period(sub).from + _pts_offset);
 594                 }
 595                 _have_current_subtitle = false;
 596         }
 597
 598         if (sub.num_rects <= 0) {
 599                 /* Nothing new in this subtitle */
 600                 return;
 601         }
 602
 603         /* Subtitle PTS (within the source, not taking into account any of the
 604            source that we may have chopped off for the DCP).
 605         */
 606         auto sub_period = subtitle_period (sub);
 607         ContentTime from;
 608         from = sub_period.from + _pts_offset;
 609         if (sub_period.to) {
 610                 _current_subtitle_to = *sub_period.to + _pts_offset;
 611         } else {
 612                 _current_subtitle_to = optional<ContentTime>();
 613                 _have_current_subtitle = true;
 614         }
 615
 616         for (unsigned int i = 0; i < sub.num_rects; ++i) {
 617                 auto const rect = sub.rects[i];
 618
 619                 switch (rect->type) {
 620                 case SUBTITLE_NONE:
 621                         break;
 622                 case SUBTITLE_BITMAP:
 623                         decode_bitmap_subtitle (rect, from);
 624                         break;
 625                 case SUBTITLE_TEXT:
 626                         cout << "XXX: SUBTITLE_TEXT " << rect->text << "\n";
 627                         break;
 628                 case SUBTITLE_ASS:
 629                         decode_ass_subtitle (rect->ass, from);
 630                         break;
 631                 }
 632         }
 633
 634         if (_current_subtitle_to) {
 635                 only_text()->emit_stop (*_current_subtitle_to);
 636         }
 637
 638         avsubtitle_free (&sub);
 639 }
 640
 641
 642 void
 643 FFmpegDecoder::decode_bitmap_subtitle (AVSubtitleRect const * rect, ContentTime from)
 644 {
 645         /* Note BGRA is expressed little-endian, so the first byte in the word is B, second
 646            G, third R, fourth A.
 647         */
 648         auto image = make_shared<Image>(AV_PIX_FMT_BGRA, dcp::Size (rect->w, rect->h), true);
 649
 650 #ifdef DCPOMATIC_HAVE_AVSUBTITLERECT_PICT
 651         /* Start of the first line in the subtitle */
 652         auto sub_p = rect->pict.data[0];
 653         /* sub_p looks up into a BGRA palette which is at rect->pict.data[1];
 654            (i.e. first byte B, second G, third R, fourth A)
 655         */
 656         auto const palette = rect->pict.data[1];
 657 #else
 658         /* Start of the first line in the subtitle */
 659         auto sub_p = rect->data[0];
 660         /* sub_p looks up into a BGRA palette which is at rect->data[1].
 661            (first byte B, second G, third R, fourth A)
 662         */
 663         auto const* palette = rect->data[1];
 664 #endif
 665         /* And the stream has a map of those palette colours to colours
 666            chosen by the user; created a `mapped' palette from those settings.
 667         */
 668         auto colour_map = ffmpeg_content()->subtitle_stream()->colours();
 669         vector<RGBA> mapped_palette (rect->nb_colors);
 670         for (int i = 0; i < rect->nb_colors; ++i) {
 671                 RGBA c (palette[2], palette[1], palette[0], palette[3]);
 672                 auto j = colour_map.find (c);
 673                 if (j != colour_map.end ()) {
 674                         mapped_palette[i] = j->second;
 675                 } else {
 676                         /* This colour was not found in the FFmpegSubtitleStream's colour map; probably because
 677                            it is from a project that was created before this stuff was added.  Just use the
 678                            colour straight from the original palette.
 679                         */
 680                         mapped_palette[i] = c;
 681                 }
 682                 palette += 4;
 683         }
 684
 685         /* Start of the output data */
 686         auto out_p = image->data()[0];
 687
 688         for (int y = 0; y < rect->h; ++y) {
 689                 auto sub_line_p = sub_p;
 690                 auto out_line_p = out_p;
 691                 for (int x = 0; x < rect->w; ++x) {
 692                         auto const p = mapped_palette[*sub_line_p++];
 693                         *out_line_p++ = p.b;
 694                         *out_line_p++ = p.g;
 695                         *out_line_p++ = p.r;
 696                         *out_line_p++ = p.a;
 697                 }
 698 #ifdef DCPOMATIC_HAVE_AVSUBTITLERECT_PICT
 699                 sub_p += rect->pict.linesize[0];
 700 #else
 701                 sub_p += rect->linesize[0];
 702 #endif
 703                 out_p += image->stride()[0];
 704         }
 705
 706         int target_width = subtitle_codec_context()->width;
 707         if (target_width == 0 && video_codec_context()) {
 708                 /* subtitle_codec_context()->width == 0 has been seen in the wild but I don't
 709                    know if it's supposed to mean something from FFmpeg's point of view.
 710                 */
 711                 target_width = video_codec_context()->width;
 712         }
 713         int target_height = subtitle_codec_context()->height;
 714         if (target_height == 0 && video_codec_context()) {
 715                 target_height = video_codec_context()->height;
 716         }
 717         DCPOMATIC_ASSERT (target_width);
 718         DCPOMATIC_ASSERT (target_height);
 719         dcpomatic::Rect<double> const scaled_rect (
 720                 static_cast<double>(rect->x) / target_width,
 721                 static_cast<double>(rect->y) / target_height,
 722                 static_cast<double>(rect->w) / target_width,
 723                 static_cast<double>(rect->h) / target_height
 724                 );
 725
 726         only_text()->emit_bitmap_start (from, image, scaled_rect);
 727 }
 728
 729
 730 void
 731 FFmpegDecoder::decode_ass_subtitle (string ass, ContentTime from)
 732 {
 733         /* We have no styles and no Format: line, so I'm assuming that FFmpeg
 734            produces a single format of Dialogue: lines...
 735         */
 736
 737         int commas = 0;
 738         string text;
 739         for (size_t i = 0; i < ass.length(); ++i) {
 740                 if (commas < 9 && ass[i] == ',') {
 741                         ++commas;
 742                 } else if (commas == 9) {
 743                         text += ass[i];
 744                 }
 745         }
 746
 747         if (text.empty ()) {
 748                 return;
 749         }
 750
 751         sub::RawSubtitle base;
 752         auto raw = sub::SSAReader::parse_line (
 753                 base,
 754                 text,
 755                 _ffmpeg_content->video->size().width,
 756                 _ffmpeg_content->video->size().height
 757                 );
 758
 759         for (auto const& i: sub::collect<vector<sub::Subtitle>>(raw)) {
 760                 only_text()->emit_plain_start (from, i);
 761         }
 762 }