fftools/ffmpeg_enc.c

   1 /*
   2  * This file is part of FFmpeg.
   3  *
   4  * FFmpeg is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * FFmpeg is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with FFmpeg; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  17  */
  18
  19 #include <math.h>
  20 #include <stdint.h>
  21
  22 #include "ffmpeg.h"
  23
  24 #include "libavutil/avassert.h"
  25 #include "libavutil/avstring.h"
  26 #include "libavutil/avutil.h"
  27 #include "libavutil/dict.h"
  28 #include "libavutil/display.h"
  29 #include "libavutil/eval.h"
  30 #include "libavutil/frame.h"
  31 #include "libavutil/intreadwrite.h"
  32 #include "libavutil/log.h"
  33 #include "libavutil/mem.h"
  34 #include "libavutil/pixdesc.h"
  35 #include "libavutil/rational.h"
  36 #include "libavutil/time.h"
  37 #include "libavutil/timestamp.h"
  38
  39 #include "libavcodec/avcodec.h"
  40
  41 typedef struct EncoderPriv {
  42     Encoder        e;
  43
  44     void          *log_parent;
  45     char           log_name[32];
  46
  47     // combined size of all the packets received from the encoder
  48     uint64_t data_size;
  49
  50     // number of packets received from the encoder
  51     uint64_t packets_encoded;
  52
  53     int opened;
  54     int attach_par;
  55
  56     Scheduler      *sch;
  57     unsigned        sch_idx;
  58 } EncoderPriv;
  59
  60 static EncoderPriv *ep_from_enc(Encoder *enc)
  61 {
  62     return (EncoderPriv*)enc;
  63 }
  64
  65 // data that is local to the decoder thread and not visible outside of it
  66 typedef struct EncoderThread {
  67     AVFrame *frame;
  68     AVPacket  *pkt;
  69 } EncoderThread;
  70
  71 void enc_free(Encoder **penc)
  72 {
  73     Encoder *enc = *penc;
  74
  75     if (!enc)
  76         return;
  77
  78     if (enc->enc_ctx)
  79         av_freep(&enc->enc_ctx->stats_in);
  80     avcodec_free_context(&enc->enc_ctx);
  81
  82     av_freep(penc);
  83 }
  84
  85 static const char *enc_item_name(void *obj)
  86 {
  87     const EncoderPriv *ep = obj;
  88
  89     return ep->log_name;
  90 }
  91
  92 static const AVClass enc_class = {
  93     .class_name                = "Encoder",
  94     .version                   = LIBAVUTIL_VERSION_INT,
  95     .parent_log_context_offset = offsetof(EncoderPriv, log_parent),
  96     .item_name                 = enc_item_name,
  97 };
  98
  99 int enc_alloc(Encoder **penc, const AVCodec *codec,
 100               Scheduler *sch, unsigned sch_idx, void *log_parent)
 101 {
 102     EncoderPriv *ep;
 103     int ret = 0;
 104
 105     *penc = NULL;
 106
 107     ep = av_mallocz(sizeof(*ep));
 108     if (!ep)
 109         return AVERROR(ENOMEM);
 110
 111     ep->e.class    = &enc_class;
 112     ep->log_parent = log_parent;
 113
 114     ep->sch     = sch;
 115     ep->sch_idx = sch_idx;
 116
 117     snprintf(ep->log_name, sizeof(ep->log_name), "enc:%s", codec->name);
 118
 119     ep->e.enc_ctx = avcodec_alloc_context3(codec);
 120     if (!ep->e.enc_ctx) {
 121         ret = AVERROR(ENOMEM);
 122         goto fail;
 123     }
 124
 125     *penc = &ep->e;
 126
 127     return 0;
 128 fail:
 129     enc_free((Encoder**)&ep);
 130     return ret;
 131 }
 132
 133 static int hw_device_setup_for_encode(Encoder *e, AVCodecContext *enc_ctx,
 134                                       AVBufferRef *frames_ref)
 135 {
 136     const AVCodecHWConfig *config;
 137     HWDevice *dev = NULL;
 138
 139     if (frames_ref &&
 140         ((AVHWFramesContext*)frames_ref->data)->format ==
 141         enc_ctx->pix_fmt) {
 142         // Matching format, will try to use hw_frames_ctx.
 143     } else {
 144         frames_ref = NULL;
 145     }
 146
 147     for (int i = 0;; i++) {
 148         config = avcodec_get_hw_config(enc_ctx->codec, i);
 149         if (!config)
 150             break;
 151
 152         if (frames_ref &&
 153             config->methods & AV_CODEC_HW_CONFIG_METHOD_HW_FRAMES_CTX &&
 154             (config->pix_fmt == AV_PIX_FMT_NONE ||
 155              config->pix_fmt == enc_ctx->pix_fmt)) {
 156             av_log(e, AV_LOG_VERBOSE, "Using input "
 157                    "frames context (format %s) with %s encoder.\n",
 158                    av_get_pix_fmt_name(enc_ctx->pix_fmt),
 159                    enc_ctx->codec->name);
 160             enc_ctx->hw_frames_ctx = av_buffer_ref(frames_ref);
 161             if (!enc_ctx->hw_frames_ctx)
 162                 return AVERROR(ENOMEM);
 163             return 0;
 164         }
 165
 166         if (!dev &&
 167             config->methods & AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX)
 168             dev = hw_device_get_by_type(config->device_type);
 169     }
 170
 171     if (dev) {
 172         av_log(e, AV_LOG_VERBOSE, "Using device %s "
 173                "(type %s) with %s encoder.\n", dev->name,
 174                av_hwdevice_get_type_name(dev->type), enc_ctx->codec->name);
 175         enc_ctx->hw_device_ctx = av_buffer_ref(dev->device_ref);
 176         if (!enc_ctx->hw_device_ctx)
 177             return AVERROR(ENOMEM);
 178     } else {
 179         // No device required, or no device available.
 180     }
 181     return 0;
 182 }
 183
 184 int enc_open(void *opaque, const AVFrame *frame)
 185 {
 186     OutputStream *ost = opaque;
 187     InputStream *ist = ost->ist;
 188     Encoder              *e = ost->enc;
 189     EncoderPriv         *ep = ep_from_enc(e);
 190     AVCodecContext *enc_ctx = e->enc_ctx;
 191     Decoder            *dec = NULL;
 192     const AVCodec      *enc = enc_ctx->codec;
 193     OutputFile          *of = ost->file;
 194     FrameData *fd;
 195     int frame_samples = 0;
 196     int ret;
 197
 198     if (ep->opened)
 199         return 0;
 200
 201     // frame is always non-NULL for audio and video
 202     av_assert0(frame || (enc->type != AVMEDIA_TYPE_VIDEO && enc->type != AVMEDIA_TYPE_AUDIO));
 203
 204     if (frame) {
 205         av_assert0(frame->opaque_ref);
 206         fd = (FrameData*)frame->opaque_ref->data;
 207
 208         for (int i = 0; i < frame->nb_side_data; i++) {
 209             const AVSideDataDescriptor *desc = av_frame_side_data_desc(frame->side_data[i]->type);
 210
 211             if (!(desc->props & AV_SIDE_DATA_PROP_GLOBAL))
 212                 continue;
 213
 214             ret = av_frame_side_data_clone(&enc_ctx->decoded_side_data,
 215                                            &enc_ctx->nb_decoded_side_data,
 216                                            frame->side_data[i],
 217                                            AV_FRAME_SIDE_DATA_FLAG_UNIQUE);
 218             if (ret < 0)
 219                 return ret;
 220         }
 221     }
 222
 223     if (ist)
 224         dec = ist->decoder;
 225
 226     // the timebase is chosen by filtering code
 227     if (ost->type == AVMEDIA_TYPE_AUDIO || ost->type == AVMEDIA_TYPE_VIDEO) {
 228         enc_ctx->time_base      = frame->time_base;
 229         enc_ctx->framerate      = fd->frame_rate_filter;
 230     }
 231
 232     switch (enc_ctx->codec_type) {
 233     case AVMEDIA_TYPE_AUDIO:
 234         av_assert0(frame->format != AV_SAMPLE_FMT_NONE &&
 235                    frame->sample_rate > 0 &&
 236                    frame->ch_layout.nb_channels > 0);
 237         enc_ctx->sample_fmt     = frame->format;
 238         enc_ctx->sample_rate    = frame->sample_rate;
 239         ret = av_channel_layout_copy(&enc_ctx->ch_layout, &frame->ch_layout);
 240         if (ret < 0)
 241             return ret;
 242
 243         if (ost->bits_per_raw_sample)
 244             enc_ctx->bits_per_raw_sample = ost->bits_per_raw_sample;
 245         else
 246             enc_ctx->bits_per_raw_sample = FFMIN(fd->bits_per_raw_sample,
 247                                                  av_get_bytes_per_sample(enc_ctx->sample_fmt) << 3);
 248         break;
 249
 250     case AVMEDIA_TYPE_VIDEO: {
 251         av_assert0(frame->format != AV_PIX_FMT_NONE &&
 252                    frame->width > 0 &&
 253                    frame->height > 0);
 254         enc_ctx->width  = frame->width;
 255         enc_ctx->height = frame->height;
 256         enc_ctx->sample_aspect_ratio =
 257             ost->frame_aspect_ratio.num ? // overridden by the -aspect cli option
 258             av_mul_q(ost->frame_aspect_ratio, (AVRational){ enc_ctx->height, enc_ctx->width }) :
 259             frame->sample_aspect_ratio;
 260
 261         enc_ctx->pix_fmt = frame->format;
 262
 263         if (ost->bits_per_raw_sample)
 264             enc_ctx->bits_per_raw_sample = ost->bits_per_raw_sample;
 265         else
 266             enc_ctx->bits_per_raw_sample = FFMIN(fd->bits_per_raw_sample,
 267                                                  av_pix_fmt_desc_get(enc_ctx->pix_fmt)->comp[0].depth);
 268
 269         enc_ctx->color_range            = frame->color_range;
 270         enc_ctx->color_primaries        = frame->color_primaries;
 271         enc_ctx->color_trc              = frame->color_trc;
 272         enc_ctx->colorspace             = frame->colorspace;
 273         enc_ctx->chroma_sample_location = frame->chroma_location;
 274
 275         if (enc_ctx->flags & (AV_CODEC_FLAG_INTERLACED_DCT | AV_CODEC_FLAG_INTERLACED_ME) ||
 276             (frame->flags & AV_FRAME_FLAG_INTERLACED)
 277 #if FFMPEG_OPT_TOP
 278             || ost->top_field_first >= 0
 279 #endif
 280             ) {
 281             int top_field_first =
 282 #if FFMPEG_OPT_TOP
 283                 ost->top_field_first >= 0 ?
 284                 ost->top_field_first :
 285 #endif
 286                 !!(frame->flags & AV_FRAME_FLAG_TOP_FIELD_FIRST);
 287
 288             if (enc->id == AV_CODEC_ID_MJPEG)
 289                 enc_ctx->field_order = top_field_first ? AV_FIELD_TT : AV_FIELD_BB;
 290             else
 291                 enc_ctx->field_order = top_field_first ? AV_FIELD_TB : AV_FIELD_BT;
 292         } else
 293             enc_ctx->field_order = AV_FIELD_PROGRESSIVE;
 294
 295         break;
 296         }
 297     case AVMEDIA_TYPE_SUBTITLE:
 298         enc_ctx->time_base = AV_TIME_BASE_Q;
 299
 300         if (!enc_ctx->width) {
 301             enc_ctx->width     = ost->ist->par->width;
 302             enc_ctx->height    = ost->ist->par->height;
 303         }
 304
 305         av_assert0(dec);
 306         if (dec->subtitle_header) {
 307             /* ASS code assumes this buffer is null terminated so add extra byte. */
 308             enc_ctx->subtitle_header = av_mallocz(dec->subtitle_header_size + 1);
 309             if (!enc_ctx->subtitle_header)
 310                 return AVERROR(ENOMEM);
 311             memcpy(enc_ctx->subtitle_header, dec->subtitle_header,
 312                    dec->subtitle_header_size);
 313             enc_ctx->subtitle_header_size = dec->subtitle_header_size;
 314         }
 315
 316         break;
 317     default:
 318         av_assert0(0);
 319         break;
 320     }
 321
 322     if (ost->bitexact)
 323         enc_ctx->flags |= AV_CODEC_FLAG_BITEXACT;
 324
 325     if (enc->capabilities & AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE)
 326         enc_ctx->flags |= AV_CODEC_FLAG_COPY_OPAQUE;
 327
 328     enc_ctx->flags |= AV_CODEC_FLAG_FRAME_DURATION;
 329
 330     ret = hw_device_setup_for_encode(e, enc_ctx, frame ? frame->hw_frames_ctx : NULL);
 331     if (ret < 0) {
 332         av_log(e, AV_LOG_ERROR,
 333                "Encoding hardware device setup failed: %s\n", av_err2str(ret));
 334         return ret;
 335     }
 336
 337     if ((ret = avcodec_open2(enc_ctx, enc, NULL)) < 0) {
 338         if (ret != AVERROR_EXPERIMENTAL)
 339             av_log(e, AV_LOG_ERROR, "Error while opening encoder - maybe "
 340                    "incorrect parameters such as bit_rate, rate, width or height.\n");
 341         return ret;
 342     }
 343
 344     ep->opened = 1;
 345
 346     if (enc_ctx->frame_size)
 347         frame_samples = enc_ctx->frame_size;
 348
 349     if (enc_ctx->bit_rate && enc_ctx->bit_rate < 1000 &&
 350         enc_ctx->codec_id != AV_CODEC_ID_CODEC2 /* don't complain about 700 bit/s modes */)
 351         av_log(e, AV_LOG_WARNING, "The bitrate parameter is set too low."
 352                                     " It takes bits/s as argument, not kbits/s\n");
 353
 354     ret = of_stream_init(of, ost, enc_ctx);
 355     if (ret < 0)
 356         return ret;
 357
 358     return frame_samples;
 359 }
 360
 361 static int check_recording_time(OutputStream *ost, int64_t ts, AVRational tb)
 362 {
 363     OutputFile *of = ost->file;
 364
 365     if (of->recording_time != INT64_MAX &&
 366         av_compare_ts(ts, tb, of->recording_time, AV_TIME_BASE_Q) >= 0) {
 367         return 0;
 368     }
 369     return 1;
 370 }
 371
 372 static int do_subtitle_out(OutputFile *of, OutputStream *ost, const AVSubtitle *sub,
 373                            AVPacket *pkt)
 374 {
 375     Encoder *e = ost->enc;
 376     EncoderPriv *ep = ep_from_enc(e);
 377     int subtitle_out_max_size = 1024 * 1024;
 378     int subtitle_out_size, nb, i, ret;
 379     AVCodecContext *enc;
 380     int64_t pts;
 381
 382     if (sub->pts == AV_NOPTS_VALUE) {
 383         av_log(e, AV_LOG_ERROR, "Subtitle packets must have a pts\n");
 384         return exit_on_error ? AVERROR(EINVAL) : 0;
 385     }
 386     if ((of->start_time != AV_NOPTS_VALUE && sub->pts < of->start_time))
 387         return 0;
 388
 389     enc = e->enc_ctx;
 390
 391     /* Note: DVB subtitle need one packet to draw them and one other
 392        packet to clear them */
 393     /* XXX: signal it in the codec context ? */
 394     if (enc->codec_id == AV_CODEC_ID_DVB_SUBTITLE)
 395         nb = 2;
 396     else if (enc->codec_id == AV_CODEC_ID_ASS)
 397         nb = FFMAX(sub->num_rects, 1);
 398     else
 399         nb = 1;
 400
 401     /* shift timestamp to honor -ss and make check_recording_time() work with -t */
 402     pts = sub->pts;
 403     if (of->start_time != AV_NOPTS_VALUE)
 404         pts -= of->start_time;
 405     for (i = 0; i < nb; i++) {
 406         AVSubtitle local_sub = *sub;
 407
 408         if (!check_recording_time(ost, pts, AV_TIME_BASE_Q))
 409             return AVERROR_EOF;
 410
 411         ret = av_new_packet(pkt, subtitle_out_max_size);
 412         if (ret < 0)
 413             return AVERROR(ENOMEM);
 414
 415         local_sub.pts = pts;
 416         // start_display_time is required to be 0
 417         local_sub.pts               += av_rescale_q(sub->start_display_time, (AVRational){ 1, 1000 }, AV_TIME_BASE_Q);
 418         local_sub.end_display_time  -= sub->start_display_time;
 419         local_sub.start_display_time = 0;
 420
 421         if (enc->codec_id == AV_CODEC_ID_DVB_SUBTITLE && i == 1)
 422             local_sub.num_rects = 0;
 423         else if (enc->codec_id == AV_CODEC_ID_ASS && sub->num_rects > 0) {
 424             local_sub.num_rects = 1;
 425             local_sub.rects += i;
 426         }
 427
 428         e->frames_encoded++;
 429
 430         subtitle_out_size = avcodec_encode_subtitle(enc, pkt->data, pkt->size, &local_sub);
 431         if (subtitle_out_size < 0) {
 432             av_log(e, AV_LOG_FATAL, "Subtitle encoding failed\n");
 433             return subtitle_out_size;
 434         }
 435
 436         av_shrink_packet(pkt, subtitle_out_size);
 437         pkt->time_base = AV_TIME_BASE_Q;
 438         pkt->pts       = sub->pts;
 439         pkt->duration = av_rescale_q(sub->end_display_time, (AVRational){ 1, 1000 }, pkt->time_base);
 440         if (enc->codec_id == AV_CODEC_ID_DVB_SUBTITLE) {
 441             /* XXX: the pts correction is handled here. Maybe handling
 442                it in the codec would be better */
 443             if (i == 0)
 444                 pkt->pts += av_rescale_q(sub->start_display_time, (AVRational){ 1, 1000 }, pkt->time_base);
 445             else
 446                 pkt->pts += av_rescale_q(sub->end_display_time, (AVRational){ 1, 1000 }, pkt->time_base);
 447         }
 448         pkt->dts = pkt->pts;
 449
 450         ret = sch_enc_send(ep->sch, ep->sch_idx, pkt);
 451         if (ret < 0) {
 452             av_packet_unref(pkt);
 453             return ret;
 454         }
 455     }
 456
 457     return 0;
 458 }
 459
 460 void enc_stats_write(OutputStream *ost, EncStats *es,
 461                      const AVFrame *frame, const AVPacket *pkt,
 462                      uint64_t frame_num)
 463 {
 464     Encoder      *e = ost->enc;
 465     EncoderPriv *ep = ep_from_enc(e);
 466     AVIOContext *io = es->io;
 467     AVRational   tb = frame ? frame->time_base : pkt->time_base;
 468     int64_t     pts = frame ? frame->pts : pkt->pts;
 469
 470     AVRational  tbi = (AVRational){ 0, 1};
 471     int64_t    ptsi = INT64_MAX;
 472
 473     const FrameData *fd = NULL;
 474
 475     if (frame ? frame->opaque_ref : pkt->opaque_ref) {
 476         fd   = (const FrameData*)(frame ? frame->opaque_ref->data : pkt->opaque_ref->data);
 477         tbi  = fd->dec.tb;
 478         ptsi = fd->dec.pts;
 479     }
 480
 481     pthread_mutex_lock(&es->lock);
 482
 483     for (size_t i = 0; i < es->nb_components; i++) {
 484         const EncStatsComponent *c = &es->components[i];
 485
 486         switch (c->type) {
 487         case ENC_STATS_LITERAL:         avio_write (io, c->str,     c->str_len);                    continue;
 488         case ENC_STATS_FILE_IDX:        avio_printf(io, "%d",       ost->file->index);              continue;
 489         case ENC_STATS_STREAM_IDX:      avio_printf(io, "%d",       ost->index);                    continue;
 490         case ENC_STATS_TIMEBASE:        avio_printf(io, "%d/%d",    tb.num, tb.den);                continue;
 491         case ENC_STATS_TIMEBASE_IN:     avio_printf(io, "%d/%d",    tbi.num, tbi.den);              continue;
 492         case ENC_STATS_PTS:             avio_printf(io, "%"PRId64,  pts);                           continue;
 493         case ENC_STATS_PTS_IN:          avio_printf(io, "%"PRId64,  ptsi);                          continue;
 494         case ENC_STATS_PTS_TIME:        avio_printf(io, "%g",       pts * av_q2d(tb));              continue;
 495         case ENC_STATS_PTS_TIME_IN:     avio_printf(io, "%g",       ptsi == INT64_MAX ?
 496                                                                     INFINITY : ptsi * av_q2d(tbi)); continue;
 497         case ENC_STATS_FRAME_NUM:       avio_printf(io, "%"PRIu64,  frame_num);                     continue;
 498         case ENC_STATS_FRAME_NUM_IN:    avio_printf(io, "%"PRIu64,  fd ? fd->dec.frame_num : -1);   continue;
 499         }
 500
 501         if (frame) {
 502             switch (c->type) {
 503             case ENC_STATS_SAMPLE_NUM:  avio_printf(io, "%"PRIu64,  e->samples_encoded);            continue;
 504             case ENC_STATS_NB_SAMPLES:  avio_printf(io, "%d",       frame->nb_samples);             continue;
 505             default: av_assert0(0);
 506             }
 507         } else {
 508             switch (c->type) {
 509             case ENC_STATS_DTS:         avio_printf(io, "%"PRId64,  pkt->dts);                      continue;
 510             case ENC_STATS_DTS_TIME:    avio_printf(io, "%g",       pkt->dts * av_q2d(tb));         continue;
 511             case ENC_STATS_PKT_SIZE:    avio_printf(io, "%d",       pkt->size);                     continue;
 512             case ENC_STATS_KEYFRAME:    avio_write(io, (pkt->flags & AV_PKT_FLAG_KEY) ?
 513                                                        "K" : "N", 1);                               continue;
 514             case ENC_STATS_BITRATE: {
 515                 double duration = FFMAX(pkt->duration, 1) * av_q2d(tb);
 516                 avio_printf(io, "%g",  8.0 * pkt->size / duration);
 517                 continue;
 518             }
 519             case ENC_STATS_AVG_BITRATE: {
 520                 double duration = pkt->dts * av_q2d(tb);
 521                 avio_printf(io, "%g",  duration > 0 ? 8.0 * ep->data_size / duration : -1.);
 522                 continue;
 523             }
 524             default: av_assert0(0);
 525             }
 526         }
 527     }
 528     avio_w8(io, '\n');
 529     avio_flush(io);
 530
 531     pthread_mutex_unlock(&es->lock);
 532 }
 533
 534 static inline double psnr(double d)
 535 {
 536     return -10.0 * log10(d);
 537 }
 538
 539 static int update_video_stats(OutputStream *ost, const AVPacket *pkt, int write_vstats)
 540 {
 541     Encoder        *e = ost->enc;
 542     EncoderPriv   *ep = ep_from_enc(e);
 543     const uint8_t *sd = av_packet_get_side_data(pkt, AV_PKT_DATA_QUALITY_STATS,
 544                                                 NULL);
 545     AVCodecContext *enc = e->enc_ctx;
 546     enum AVPictureType pict_type;
 547     int64_t frame_number;
 548     double ti1, bitrate, avg_bitrate;
 549     double psnr_val = -1;
 550     int quality;
 551
 552     quality        = sd ? AV_RL32(sd) : -1;
 553     pict_type      = sd ? sd[4] : AV_PICTURE_TYPE_NONE;
 554
 555     atomic_store(&ost->quality, quality);
 556
 557     if ((enc->flags & AV_CODEC_FLAG_PSNR) && sd && sd[5]) {
 558         // FIXME the scaling assumes 8bit
 559         double error = AV_RL64(sd + 8) / (enc->width * enc->height * 255.0 * 255.0);
 560         if (error >= 0 && error <= 1)
 561             psnr_val = psnr(error);
 562     }
 563
 564     if (!write_vstats)
 565         return 0;
 566
 567     /* this is executed just the first time update_video_stats is called */
 568     if (!vstats_file) {
 569         vstats_file = fopen(vstats_filename, "w");
 570         if (!vstats_file) {
 571             perror("fopen");
 572             return AVERROR(errno);
 573         }
 574     }
 575
 576     frame_number = ep->packets_encoded;
 577     if (vstats_version <= 1) {
 578         fprintf(vstats_file, "frame= %5"PRId64" q= %2.1f ", frame_number,
 579                 quality / (float)FF_QP2LAMBDA);
 580     } else  {
 581         fprintf(vstats_file, "out= %2d st= %2d frame= %5"PRId64" q= %2.1f ",
 582                 ost->file->index, ost->index, frame_number,
 583                 quality / (float)FF_QP2LAMBDA);
 584     }
 585
 586     if (psnr_val >= 0)
 587         fprintf(vstats_file, "PSNR= %6.2f ", psnr_val);
 588
 589     fprintf(vstats_file,"f_size= %6d ", pkt->size);
 590     /* compute pts value */
 591     ti1 = pkt->dts * av_q2d(pkt->time_base);
 592     if (ti1 < 0.01)
 593         ti1 = 0.01;
 594
 595     bitrate     = (pkt->size * 8) / av_q2d(enc->time_base) / 1000.0;
 596     avg_bitrate = (double)(ep->data_size * 8) / ti1 / 1000.0;
 597     fprintf(vstats_file, "s_size= %8.0fKiB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
 598            (double)ep->data_size / 1024, ti1, bitrate, avg_bitrate);
 599     fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(pict_type));
 600
 601     return 0;
 602 }
 603
 604 static int encode_frame(OutputFile *of, OutputStream *ost, AVFrame *frame,
 605                         AVPacket *pkt)
 606 {
 607     Encoder            *e = ost->enc;
 608     EncoderPriv       *ep = ep_from_enc(e);
 609     AVCodecContext   *enc = e->enc_ctx;
 610     const char *type_desc = av_get_media_type_string(enc->codec_type);
 611     const char    *action = frame ? "encode" : "flush";
 612     int ret;
 613
 614     if (frame) {
 615         FrameData *fd = frame_data(frame);
 616
 617         if (!fd)
 618             return AVERROR(ENOMEM);
 619
 620         fd->wallclock[LATENCY_PROBE_ENC_PRE] = av_gettime_relative();
 621
 622         if (ost->enc_stats_pre.io)
 623             enc_stats_write(ost, &ost->enc_stats_pre, frame, NULL,
 624                             e->frames_encoded);
 625
 626         e->frames_encoded++;
 627         e->samples_encoded += frame->nb_samples;
 628
 629         if (debug_ts) {
 630             av_log(e, AV_LOG_INFO, "encoder <- type:%s "
 631                    "frame_pts:%s frame_pts_time:%s time_base:%d/%d\n",
 632                    type_desc,
 633                    av_ts2str(frame->pts), av_ts2timestr(frame->pts, &enc->time_base),
 634                    enc->time_base.num, enc->time_base.den);
 635         }
 636
 637         if (frame->sample_aspect_ratio.num && !ost->frame_aspect_ratio.num)
 638             enc->sample_aspect_ratio = frame->sample_aspect_ratio;
 639     }
 640
 641     update_benchmark(NULL);
 642
 643     ret = avcodec_send_frame(enc, frame);
 644     if (ret < 0 && !(ret == AVERROR_EOF && !frame)) {
 645         av_log(e, AV_LOG_ERROR, "Error submitting %s frame to the encoder\n",
 646                type_desc);
 647         return ret;
 648     }
 649
 650     while (1) {
 651         FrameData *fd;
 652
 653         av_packet_unref(pkt);
 654
 655         ret = avcodec_receive_packet(enc, pkt);
 656         update_benchmark("%s_%s %d.%d", action, type_desc,
 657                          of->index, ost->index);
 658
 659         pkt->time_base = enc->time_base;
 660
 661         /* if two pass, output log on success and EOF */
 662         if ((ret >= 0 || ret == AVERROR_EOF) && ost->logfile && enc->stats_out)
 663             fprintf(ost->logfile, "%s", enc->stats_out);
 664
 665         if (ret == AVERROR(EAGAIN)) {
 666             av_assert0(frame); // should never happen during flushing
 667             return 0;
 668         } else if (ret < 0) {
 669             if (ret != AVERROR_EOF)
 670                 av_log(e, AV_LOG_ERROR, "%s encoding failed\n", type_desc);
 671             return ret;
 672         }
 673
 674         fd = packet_data(pkt);
 675         if (!fd)
 676             return AVERROR(ENOMEM);
 677         fd->wallclock[LATENCY_PROBE_ENC_POST] = av_gettime_relative();
 678
 679         // attach stream parameters to first packet if requested
 680         avcodec_parameters_free(&fd->par_enc);
 681         if (ep->attach_par && !ep->packets_encoded) {
 682             fd->par_enc = avcodec_parameters_alloc();
 683             if (!fd->par_enc)
 684                 return AVERROR(ENOMEM);
 685
 686             ret = avcodec_parameters_from_context(fd->par_enc, enc);
 687             if (ret < 0)
 688                 return ret;
 689         }
 690
 691         pkt->flags |= AV_PKT_FLAG_TRUSTED;
 692
 693         if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
 694             ret = update_video_stats(ost, pkt, !!vstats_filename);
 695             if (ret < 0)
 696                 return ret;
 697         }
 698
 699         if (ost->enc_stats_post.io)
 700             enc_stats_write(ost, &ost->enc_stats_post, NULL, pkt,
 701                             ep->packets_encoded);
 702
 703         if (debug_ts) {
 704             av_log(e, AV_LOG_INFO, "encoder -> type:%s "
 705                    "pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s "
 706                    "duration:%s duration_time:%s\n",
 707                    type_desc,
 708                    av_ts2str(pkt->pts), av_ts2timestr(pkt->pts, &enc->time_base),
 709                    av_ts2str(pkt->dts), av_ts2timestr(pkt->dts, &enc->time_base),
 710                    av_ts2str(pkt->duration), av_ts2timestr(pkt->duration, &enc->time_base));
 711         }
 712
 713         ep->data_size += pkt->size;
 714
 715         ep->packets_encoded++;
 716
 717         ret = sch_enc_send(ep->sch, ep->sch_idx, pkt);
 718         if (ret < 0) {
 719             av_packet_unref(pkt);
 720             return ret;
 721         }
 722     }
 723
 724     av_assert0(0);
 725 }
 726
 727 static enum AVPictureType forced_kf_apply(void *logctx, KeyframeForceCtx *kf,
 728                                           const AVFrame *frame)
 729 {
 730     double pts_time;
 731
 732     if (kf->ref_pts == AV_NOPTS_VALUE)
 733         kf->ref_pts = frame->pts;
 734
 735     pts_time = (frame->pts - kf->ref_pts) * av_q2d(frame->time_base);
 736     if (kf->index < kf->nb_pts &&
 737         av_compare_ts(frame->pts, frame->time_base, kf->pts[kf->index], AV_TIME_BASE_Q) >= 0) {
 738         kf->index++;
 739         goto force_keyframe;
 740     } else if (kf->pexpr) {
 741         double res;
 742         kf->expr_const_values[FKF_T] = pts_time;
 743         res = av_expr_eval(kf->pexpr,
 744                            kf->expr_const_values, NULL);
 745         av_log(logctx, AV_LOG_TRACE,
 746                "force_key_frame: n:%f n_forced:%f prev_forced_n:%f t:%f prev_forced_t:%f -> res:%f\n",
 747                kf->expr_const_values[FKF_N],
 748                kf->expr_const_values[FKF_N_FORCED],
 749                kf->expr_const_values[FKF_PREV_FORCED_N],
 750                kf->expr_const_values[FKF_T],
 751                kf->expr_const_values[FKF_PREV_FORCED_T],
 752                res);
 753
 754         kf->expr_const_values[FKF_N] += 1;
 755
 756         if (res) {
 757             kf->expr_const_values[FKF_PREV_FORCED_N] = kf->expr_const_values[FKF_N] - 1;
 758             kf->expr_const_values[FKF_PREV_FORCED_T] = kf->expr_const_values[FKF_T];
 759             kf->expr_const_values[FKF_N_FORCED]     += 1;
 760             goto force_keyframe;
 761         }
 762     } else if (kf->type == KF_FORCE_SOURCE && (frame->flags & AV_FRAME_FLAG_KEY)) {
 763         goto force_keyframe;
 764     }
 765
 766     return AV_PICTURE_TYPE_NONE;
 767
 768 force_keyframe:
 769     av_log(logctx, AV_LOG_DEBUG, "Forced keyframe at time %f\n", pts_time);
 770     return AV_PICTURE_TYPE_I;
 771 }
 772
 773 static int frame_encode(OutputStream *ost, AVFrame *frame, AVPacket *pkt)
 774 {
 775     Encoder *e = ost->enc;
 776     OutputFile *of = ost->file;
 777     enum AVMediaType type = ost->type;
 778
 779     if (type == AVMEDIA_TYPE_SUBTITLE) {
 780         const AVSubtitle *subtitle = frame && frame->buf[0] ?
 781                                      (AVSubtitle*)frame->buf[0]->data : NULL;
 782
 783         // no flushing for subtitles
 784         return subtitle && subtitle->num_rects ?
 785                do_subtitle_out(of, ost, subtitle, pkt) : 0;
 786     }
 787
 788     if (frame) {
 789         if (!check_recording_time(ost, frame->pts, frame->time_base))
 790             return AVERROR_EOF;
 791
 792         if (type == AVMEDIA_TYPE_VIDEO) {
 793             frame->quality   = e->enc_ctx->global_quality;
 794             frame->pict_type = forced_kf_apply(e, &ost->kf, frame);
 795
 796 #if FFMPEG_OPT_TOP
 797             if (ost->top_field_first >= 0) {
 798                 frame->flags &= ~AV_FRAME_FLAG_TOP_FIELD_FIRST;
 799                 frame->flags |= AV_FRAME_FLAG_TOP_FIELD_FIRST * (!!ost->top_field_first);
 800             }
 801 #endif
 802         } else {
 803             if (!(e->enc_ctx->codec->capabilities & AV_CODEC_CAP_PARAM_CHANGE) &&
 804                 e->enc_ctx->ch_layout.nb_channels != frame->ch_layout.nb_channels) {
 805                 av_log(e, AV_LOG_ERROR,
 806                        "Audio channel count changed and encoder does not support parameter changes\n");
 807                 return 0;
 808             }
 809         }
 810     }
 811
 812     return encode_frame(of, ost, frame, pkt);
 813 }
 814
 815 static void enc_thread_set_name(const OutputStream *ost)
 816 {
 817     char name[16];
 818     snprintf(name, sizeof(name), "enc%d:%d:%s", ost->file->index, ost->index,
 819              ost->enc->enc_ctx->codec->name);
 820     ff_thread_setname(name);
 821 }
 822
 823 static void enc_thread_uninit(EncoderThread *et)
 824 {
 825     av_packet_free(&et->pkt);
 826     av_frame_free(&et->frame);
 827
 828     memset(et, 0, sizeof(*et));
 829 }
 830
 831 static int enc_thread_init(EncoderThread *et)
 832 {
 833     memset(et, 0, sizeof(*et));
 834
 835     et->frame = av_frame_alloc();
 836     if (!et->frame)
 837         goto fail;
 838
 839     et->pkt = av_packet_alloc();
 840     if (!et->pkt)
 841         goto fail;
 842
 843     return 0;
 844
 845 fail:
 846     enc_thread_uninit(et);
 847     return AVERROR(ENOMEM);
 848 }
 849
 850 int encoder_thread(void *arg)
 851 {
 852     OutputStream *ost = arg;
 853     Encoder        *e = ost->enc;
 854     EncoderPriv   *ep = ep_from_enc(e);
 855     EncoderThread et;
 856     int ret = 0, input_status = 0;
 857     int name_set = 0;
 858
 859     ret = enc_thread_init(&et);
 860     if (ret < 0)
 861         goto finish;
 862
 863     /* Open the subtitle encoders immediately. AVFrame-based encoders
 864      * are opened through a callback from the scheduler once they get
 865      * their first frame
 866      *
 867      * N.B.: because the callback is called from a different thread,
 868      * enc_ctx MUST NOT be accessed before sch_enc_receive() returns
 869      * for the first time for audio/video. */
 870     if (ost->type != AVMEDIA_TYPE_VIDEO && ost->type != AVMEDIA_TYPE_AUDIO) {
 871         ret = enc_open(ost, NULL);
 872         if (ret < 0)
 873             goto finish;
 874     }
 875
 876     while (!input_status) {
 877         input_status = sch_enc_receive(ep->sch, ep->sch_idx, et.frame);
 878         if (input_status < 0) {
 879             if (input_status == AVERROR_EOF) {
 880                 av_log(e, AV_LOG_VERBOSE, "Encoder thread received EOF\n");
 881                 if (ep->opened)
 882                     break;
 883
 884                 av_log(e, AV_LOG_ERROR, "Could not open encoder before EOF\n");
 885                 ret = AVERROR(EINVAL);
 886             } else {
 887                 av_log(e, AV_LOG_ERROR, "Error receiving a frame for encoding: %s\n",
 888                        av_err2str(ret));
 889                 ret = input_status;
 890             }
 891             goto finish;
 892         }
 893
 894         if (!name_set) {
 895             enc_thread_set_name(ost);
 896             name_set = 1;
 897         }
 898
 899         ret = frame_encode(ost, et.frame, et.pkt);
 900
 901         av_packet_unref(et.pkt);
 902         av_frame_unref(et.frame);
 903
 904         if (ret < 0) {
 905             if (ret == AVERROR_EOF)
 906                 av_log(e, AV_LOG_VERBOSE, "Encoder returned EOF, finishing\n");
 907             else
 908                 av_log(e, AV_LOG_ERROR, "Error encoding a frame: %s\n",
 909                        av_err2str(ret));
 910             break;
 911         }
 912     }
 913
 914     // flush the encoder
 915     if (ret == 0 || ret == AVERROR_EOF) {
 916         ret = frame_encode(ost, NULL, et.pkt);
 917         if (ret < 0 && ret != AVERROR_EOF)
 918             av_log(e, AV_LOG_ERROR, "Error flushing encoder: %s\n",
 919                    av_err2str(ret));
 920     }
 921
 922     // EOF is normal thread termination
 923     if (ret == AVERROR_EOF)
 924         ret = 0;
 925
 926 finish:
 927     enc_thread_uninit(&et);
 928
 929     return ret;
 930 }
 931
 932 int enc_loopback(Encoder *enc)
 933 {
 934     EncoderPriv *ep = ep_from_enc(enc);
 935     ep->attach_par = 1;
 936     return ep->sch_idx;
 937 }