git.sesse.net Git - ffmpeg/blob - libavcodec/libdiracenc.c

   1 /*
   2  * Dirac encoding support via libdirac library
   3  * Copyright (c) 2005 BBC, Andrew Kennedy <dirac at rd dot bbc dot co dot uk>
   4  * Copyright (c) 2006-2008 BBC, Anuradha Suraparaju <asuraparaju at gmail dot com >
   5  *
   6  * This file is part of FFmpeg.
   7  *
   8  * FFmpeg is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * FFmpeg is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with FFmpeg; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  21  */
  22
  23 /**
  24 * @file libdiracenc.c
  25 * Dirac encoding support via libdirac library; more details about the
  26 * Dirac project can be found at http://dirac.sourceforge.net/.
  27 * The libdirac_encoder library implements Dirac specification version 2.2
  28 * (http://dirac.sourceforge.net/specification.html).
  29 */
  30
  31 #include "libdirac_libschro.h"
  32 #include "libdirac.h"
  33
  34 #undef NDEBUG
  35 #include <assert.h>
  36
  37
  38 #include <libdirac_encoder/dirac_encoder.h>
  39
  40 /** Dirac encoder private data */
  41 typedef struct FfmpegDiracEncoderParams
  42 {
  43     /** Dirac encoder context */
  44     dirac_encoder_context_t enc_ctx;
  45
  46     /** frame being encoded */
  47     AVFrame picture;
  48
  49     /** frame size */
  50     int frame_size;
  51
  52     /** Dirac encoder handle */
  53     dirac_encoder_t* p_encoder;
  54
  55     /** input frame buffer */
  56     unsigned char *p_in_frame_buf;
  57
  58     /** buffer to store encoder output before writing it to the frame queue */
  59     unsigned char *enc_buf;
  60
  61     /** size of encoder buffer */
  62     int enc_buf_size;
  63
  64     /** queue storing encoded frames */
  65     FfmpegDiracSchroQueue enc_frame_queue;
  66
  67     /** end of sequence signalled by user, 0 - false, 1 - true */
  68     int eos_signalled;
  69
  70     /** end of sequence returned by encoder, 0 - false, 1 - true */
  71     int eos_pulled;
  72 } FfmpegDiracEncoderParams;
  73
  74 /**
  75 * Works out Dirac-compatible chroma format.
  76 */
  77 static dirac_chroma_t GetDiracChromaFormat(enum PixelFormat ff_pix_fmt)
  78 {
  79     int num_formats = sizeof(ffmpeg_dirac_pixel_format_map) /
  80                       sizeof(ffmpeg_dirac_pixel_format_map[0]);
  81     int idx;
  82
  83     for (idx = 0; idx < num_formats; ++idx) {
  84         if (ffmpeg_dirac_pixel_format_map[idx].ff_pix_fmt == ff_pix_fmt) {
  85             return ffmpeg_dirac_pixel_format_map[idx].dirac_pix_fmt;
  86         }
  87     }
  88     return formatNK;
  89 }
  90
  91 /**
  92 * Dirac video preset table. Ensure that this tables matches up correctly
  93 * with the ff_dirac_schro_video_format_info table in libdirac_libschro.c.
  94 */
  95 static const VideoFormat ff_dirac_video_formats[]={
  96     VIDEO_FORMAT_CUSTOM           ,
  97     VIDEO_FORMAT_QSIF525          ,
  98     VIDEO_FORMAT_QCIF             ,
  99     VIDEO_FORMAT_SIF525           ,
 100     VIDEO_FORMAT_CIF              ,
 101     VIDEO_FORMAT_4SIF525          ,
 102     VIDEO_FORMAT_4CIF             ,
 103     VIDEO_FORMAT_SD_480I60        ,
 104     VIDEO_FORMAT_SD_576I50        ,
 105     VIDEO_FORMAT_HD_720P60        ,
 106     VIDEO_FORMAT_HD_720P50        ,
 107     VIDEO_FORMAT_HD_1080I60       ,
 108     VIDEO_FORMAT_HD_1080I50       ,
 109     VIDEO_FORMAT_HD_1080P60       ,
 110     VIDEO_FORMAT_HD_1080P50       ,
 111     VIDEO_FORMAT_DIGI_CINEMA_2K24 ,
 112     VIDEO_FORMAT_DIGI_CINEMA_4K24 ,
 113 };
 114
 115 /**
 116 * Returns the video format preset matching the input video dimensions and
 117 * time base.
 118 */
 119 static VideoFormat GetDiracVideoFormatPreset (AVCodecContext *avccontext)
 120 {
 121     unsigned int num_formats = sizeof(ff_dirac_video_formats) /
 122                                sizeof(ff_dirac_video_formats[0]);
 123
 124     unsigned int idx = ff_dirac_schro_get_video_format_idx (avccontext);
 125
 126     return (idx < num_formats) ?
 127                  ff_dirac_video_formats[idx] : VIDEO_FORMAT_CUSTOM;
 128 }
 129
 130 static int libdirac_encode_init(AVCodecContext *avccontext)
 131 {
 132
 133     FfmpegDiracEncoderParams* p_dirac_params = avccontext->priv_data;
 134     int no_local = 1;
 135     int verbose = avccontext->debug;
 136     VideoFormat preset;
 137
 138     /* get Dirac preset */
 139     preset = GetDiracVideoFormatPreset(avccontext);
 140
 141     /* initialize the encoder context */
 142     dirac_encoder_context_init (&(p_dirac_params->enc_ctx), preset);
 143
 144     p_dirac_params->enc_ctx.src_params.chroma =
 145                                 GetDiracChromaFormat(avccontext->pix_fmt);
 146
 147     if (p_dirac_params->enc_ctx.src_params.chroma == formatNK) {
 148         av_log (avccontext, AV_LOG_ERROR,
 149                 "Unsupported pixel format %d. This codec supports only "
 150                 "Planar YUV formats (yuv420p, yuv422p, yuv444p\n",
 151                 avccontext->pix_fmt);
 152         return -1;
 153     }
 154
 155     p_dirac_params->enc_ctx.src_params.frame_rate.numerator   =
 156                                              avccontext->time_base.den;
 157     p_dirac_params->enc_ctx.src_params.frame_rate.denominator =
 158                                              avccontext->time_base.num;
 159
 160     p_dirac_params->enc_ctx.src_params.width  = avccontext->width;
 161     p_dirac_params->enc_ctx.src_params.height = avccontext->height;
 162
 163     p_dirac_params->frame_size = avpicture_get_size(avccontext->pix_fmt,
 164                                                     avccontext->width,
 165                                                     avccontext->height);
 166
 167     avccontext->coded_frame = &p_dirac_params->picture;
 168
 169     if (no_local) {
 170         p_dirac_params->enc_ctx.decode_flag = 0;
 171         p_dirac_params->enc_ctx.instr_flag  = 0;
 172     } else {
 173         p_dirac_params->enc_ctx.decode_flag = 1;
 174         p_dirac_params->enc_ctx.instr_flag  = 1;
 175     }
 176
 177     /* Intra-only sequence */
 178     if (avccontext->gop_size == 0 )
 179         p_dirac_params->enc_ctx.enc_params.num_L1 = 0;
 180     else
 181         avccontext->has_b_frames = 1;
 182
 183     if (avccontext->flags & CODEC_FLAG_QSCALE) {
 184         if (avccontext->global_quality != 0) {
 185             p_dirac_params->enc_ctx.enc_params.qf =
 186                             avccontext->global_quality / (FF_QP2LAMBDA*10.0);
 187             /* if it is not default bitrate then send target rate. */
 188             if (avccontext->bit_rate >= 1000 &&
 189                 avccontext->bit_rate != 200000) {
 190                p_dirac_params->enc_ctx.enc_params.trate =
 191                              avccontext->bit_rate / 1000;
 192             }
 193         } else
 194             p_dirac_params->enc_ctx.enc_params.lossless = 1;
 195     } else if (avccontext->bit_rate >= 1000)
 196         p_dirac_params->enc_ctx.enc_params.trate = avccontext->bit_rate / 1000;
 197
 198     if ((preset > VIDEO_FORMAT_QCIF || preset < VIDEO_FORMAT_QSIF525) &&
 199          avccontext->bit_rate == 200000) {
 200         p_dirac_params->enc_ctx.enc_params.trate = 0;
 201     }
 202
 203     if (avccontext->flags & CODEC_FLAG_INTERLACED_ME) {
 204         /* all material can be coded as interlaced or progressive
 205          * irrespective of the type of source material */
 206         p_dirac_params->enc_ctx.enc_params.picture_coding_mode = 1;
 207     }
 208
 209     p_dirac_params->p_encoder = dirac_encoder_init (&(p_dirac_params->enc_ctx),
 210                                                     verbose );
 211
 212     if (!p_dirac_params->p_encoder) {
 213         av_log(avccontext, AV_LOG_ERROR,
 214                "Unrecoverable Error: dirac_encoder_init failed. ");
 215         return EXIT_FAILURE;
 216     }
 217
 218     /* allocate enough memory for the incoming data */
 219     p_dirac_params->p_in_frame_buf = av_malloc(p_dirac_params->frame_size);
 220
 221     /* initialize the encoded frame queue */
 222     ff_dirac_schro_queue_init(&p_dirac_params->enc_frame_queue);
 223
 224     return 0 ;
 225 }
 226
 227 static void DiracFreeFrame (void *data)
 228 {
 229     FfmpegDiracSchroEncodedFrame *enc_frame = data;
 230
 231     av_freep (&(enc_frame->p_encbuf));
 232     av_free(enc_frame);
 233 }
 234
 235 static int libdirac_encode_frame(AVCodecContext *avccontext,
 236                                  unsigned char *frame,
 237                                  int buf_size, void *data)
 238 {
 239     int enc_size = 0;
 240     dirac_encoder_state_t state;
 241     FfmpegDiracEncoderParams* p_dirac_params = avccontext->priv_data;
 242     FfmpegDiracSchroEncodedFrame* p_frame_output = NULL;
 243     FfmpegDiracSchroEncodedFrame* p_next_output_frame = NULL;
 244     int go = 1;
 245     int last_frame_in_sequence = 0;
 246
 247     if (data == NULL) {
 248         /* push end of sequence if not already signalled */
 249         if (!p_dirac_params->eos_signalled) {
 250             dirac_encoder_end_sequence( p_dirac_params->p_encoder );
 251             p_dirac_params->eos_signalled = 1;
 252         }
 253     } else {
 254
 255         /* Allocate frame data to Dirac input buffer.
 256          * Input line size may differ from what the codec supports,
 257          * especially when transcoding from one format to another.
 258          * So use avpicture_layout to copy the frame. */
 259         avpicture_layout ((AVPicture *)data, avccontext->pix_fmt,
 260                           avccontext->width, avccontext->height,
 261                           p_dirac_params->p_in_frame_buf,
 262                           p_dirac_params->frame_size);
 263
 264         /* load next frame */
 265         if (dirac_encoder_load (p_dirac_params->p_encoder,
 266                                 p_dirac_params->p_in_frame_buf,
 267                                 p_dirac_params->frame_size ) < 0) {
 268             av_log(avccontext, AV_LOG_ERROR, "Unrecoverable Encoder Error."
 269                    " dirac_encoder_load failed...\n");
 270             return -1;
 271         }
 272     }
 273
 274     if (p_dirac_params->eos_pulled)
 275         go = 0;
 276
 277     while(go) {
 278         p_dirac_params->p_encoder->enc_buf.buffer = frame;
 279         p_dirac_params->p_encoder->enc_buf.size   = buf_size;
 280         /* process frame */
 281         state = dirac_encoder_output ( p_dirac_params->p_encoder );
 282
 283         switch (state)
 284         {
 285         case ENC_STATE_AVAIL:
 286         case ENC_STATE_EOS:
 287             assert (p_dirac_params->p_encoder->enc_buf.size > 0);
 288
 289             /* All non-frame data is prepended to actual frame data to
 290              * be able to set the pts correctly. So we don't write data
 291              * to the frame output queue until we actually have a frame
 292              */
 293
 294             p_dirac_params->enc_buf = av_realloc (
 295                                       p_dirac_params->enc_buf,
 296                                       p_dirac_params->enc_buf_size +
 297                                       p_dirac_params->p_encoder->enc_buf.size
 298                                       );
 299             memcpy(p_dirac_params->enc_buf + p_dirac_params->enc_buf_size,
 300                    p_dirac_params->p_encoder->enc_buf.buffer,
 301                    p_dirac_params->p_encoder->enc_buf.size);
 302
 303             p_dirac_params->enc_buf_size +=
 304                                      p_dirac_params->p_encoder->enc_buf.size;
 305
 306             if (state == ENC_STATE_EOS) {
 307                 p_dirac_params->eos_pulled = 1;
 308                 go = 0;
 309             }
 310
 311             /* If non-frame data, don't output it until it we get an
 312              * encoded frame back from the encoder. */
 313             if (p_dirac_params->p_encoder->enc_pparams.pnum == -1)
 314                 break;
 315
 316             /* create output frame */
 317             p_frame_output = av_mallocz(sizeof(FfmpegDiracSchroEncodedFrame));
 318             /* set output data */
 319             p_frame_output->size     = p_dirac_params->enc_buf_size;
 320             p_frame_output->p_encbuf = p_dirac_params->enc_buf;
 321             p_frame_output->frame_num =
 322                             p_dirac_params->p_encoder->enc_pparams.pnum;
 323
 324             if (p_dirac_params->p_encoder->enc_pparams.ptype == INTRA_PICTURE &&
 325                 p_dirac_params->p_encoder->enc_pparams.rtype == REFERENCE_PICTURE)
 326                 p_frame_output->key_frame = 1;
 327
 328             ff_dirac_schro_queue_push_back (&p_dirac_params->enc_frame_queue,
 329                                             p_frame_output);
 330
 331             p_dirac_params->enc_buf_size = 0;
 332             p_dirac_params->enc_buf      = NULL;
 333             break;
 334
 335         case ENC_STATE_BUFFER:
 336             go = 0;
 337             break;
 338
 339         case ENC_STATE_INVALID:
 340             av_log(avccontext, AV_LOG_ERROR,
 341                    "Unrecoverable Dirac Encoder Error. Quitting...\n");
 342             return -1;
 343
 344         default:
 345             av_log(avccontext, AV_LOG_ERROR, "Unknown Dirac Encoder state\n");
 346             return -1;
 347         }
 348     }
 349
 350     /* copy 'next' frame in queue */
 351
 352     if (p_dirac_params->enc_frame_queue.size == 1 &&
 353         p_dirac_params->eos_pulled)
 354         last_frame_in_sequence = 1;
 355
 356     p_next_output_frame =
 357           ff_dirac_schro_queue_pop(&p_dirac_params->enc_frame_queue);
 358
 359     if (p_next_output_frame == NULL)
 360         return 0;
 361
 362     memcpy(frame, p_next_output_frame->p_encbuf, p_next_output_frame->size);
 363     avccontext->coded_frame->key_frame = p_next_output_frame->key_frame;
 364     /* Use the frame number of the encoded frame as the pts. It is OK to do
 365      * so since Dirac is a constant framerate codec. It expects input to be
 366      * of constant framerate. */
 367     avccontext->coded_frame->pts = p_next_output_frame->frame_num;
 368     enc_size = p_next_output_frame->size;
 369
 370     /* Append the end of sequence information to the last frame in the
 371      * sequence. */
 372     if (last_frame_in_sequence && p_dirac_params->enc_buf_size > 0)
 373     {
 374         memcpy (frame + enc_size, p_dirac_params->enc_buf,
 375                 p_dirac_params->enc_buf_size);
 376         enc_size += p_dirac_params->enc_buf_size;
 377         av_freep (&p_dirac_params->enc_buf);
 378         p_dirac_params->enc_buf_size = 0;
 379     }
 380
 381     /* free frame */
 382     DiracFreeFrame(p_next_output_frame);
 383
 384     return enc_size;
 385 }
 386
 387 static int libdirac_encode_close(AVCodecContext *avccontext)
 388 {
 389     FfmpegDiracEncoderParams* p_dirac_params  = avccontext->priv_data;
 390
 391     /* close the encoder */
 392     dirac_encoder_close(p_dirac_params->p_encoder );
 393
 394     /* free data in the output frame queue */
 395     ff_dirac_schro_queue_free(&p_dirac_params->enc_frame_queue,
 396                               DiracFreeFrame);
 397
 398     /* free the encoder buffer */
 399     if (p_dirac_params->enc_buf_size)
 400         av_freep(&p_dirac_params->enc_buf);
 401
 402     /* free the input frame buffer */
 403     av_freep(&p_dirac_params->p_in_frame_buf);
 404
 405     return 0 ;
 406 }
 407
 408
 409 AVCodec libdirac_encoder = {
 410     "libdirac",
 411     CODEC_TYPE_VIDEO,
 412     CODEC_ID_DIRAC,
 413     sizeof(FfmpegDiracEncoderParams),
 414     libdirac_encode_init,
 415     libdirac_encode_frame,
 416     libdirac_encode_close,
 417    .capabilities= CODEC_CAP_DELAY,
 418    .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_YUV444P, -1},
 419    .long_name= NULL_IF_CONFIG_SMALL("libdirac Dirac 2.2"),
 420 } ;