libdiracdec.c 6.71 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
/*
 * Dirac decoder support via libdirac library
 * Copyright (c) 2005 BBC, Andrew Kennedy <dirac at rd dot bbc dot co dot uk>
 * Copyright (c) 2006-2008 BBC, Anuradha Suraparaju <asuraparaju at gmail dot com >
 *
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * FFmpeg is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

/**
24
* @file
25 26 27 28 29 30
* Dirac decoder support via libdirac library; more details about the Dirac
* project can be found at http://dirac.sourceforge.net/.
* The libdirac_decoder library implements Dirac specification version 2.2
* (http://dirac.sourceforge.net/specification.html).
*/

31
#include "libavcore/imgutils.h"
32 33 34 35 36 37 38 39
#include "libdirac.h"

#undef NDEBUG
#include <assert.h>

#include <libdirac_decoder/dirac_parser.h>

/** contains a single frame returned from Dirac */
40
typedef struct FfmpegDiracDecoderParams {
41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57
    /** decoder handle */
    dirac_decoder_t* p_decoder;

    /** buffer to hold decoded frame */
    unsigned char* p_out_frame_buf;
} FfmpegDiracDecoderParams;


/**
* returns FFmpeg chroma format
*/
static enum PixelFormat GetFfmpegChromaFormat(dirac_chroma_t dirac_pix_fmt)
{
    int num_formats = sizeof(ffmpeg_dirac_pixel_format_map) /
                      sizeof(ffmpeg_dirac_pixel_format_map[0]);
    int idx;

58 59
    for (idx = 0; idx < num_formats; ++idx)
        if (ffmpeg_dirac_pixel_format_map[idx].dirac_pix_fmt == dirac_pix_fmt)
60 61 62 63
            return ffmpeg_dirac_pixel_format_map[idx].ff_pix_fmt;
    return PIX_FMT_NONE;
}

64
static av_cold int libdirac_decode_init(AVCodecContext *avccontext)
65 66
{

67
    FfmpegDiracDecoderParams *p_dirac_params = avccontext->priv_data;
68 69 70 71 72
    p_dirac_params->p_decoder =  dirac_decoder_init(avccontext->debug);

    if (!p_dirac_params->p_decoder)
        return -1;

73
    return 0;
74 75 76 77
}

static int libdirac_decode_frame(AVCodecContext *avccontext,
                                 void *data, int *data_size,
78
                                 AVPacket *avpkt)
79
{
80 81
    const uint8_t *buf = avpkt->data;
    int buf_size = avpkt->size;
82 83 84 85 86 87 88 89 90

    FfmpegDiracDecoderParams *p_dirac_params = avccontext->priv_data;
    AVPicture *picture = data;
    AVPicture pic;
    int pict_size;
    unsigned char *buffer[3];

    *data_size = 0;

91
    if (buf_size > 0) {
92
        /* set data to decode into buffer */
93 94
        dirac_buffer(p_dirac_params->p_decoder, buf, buf + buf_size);
        if ((buf[4] & 0x08) == 0x08 && (buf[4] & 0x03))
95 96
            avccontext->has_b_frames = 1;
    }
97 98
    while (1) {
         /* parse data and process result */
99 100
        DecoderState state = dirac_parse(p_dirac_params->p_decoder);
        switch (state) {
101 102 103 104 105 106
        case STATE_BUFFER:
            return buf_size;

        case STATE_SEQUENCE:
        {
            /* tell FFmpeg about sequence details */
107
            dirac_sourceparams_t *src_params = &p_dirac_params->p_decoder->src_params;
108

109
            if (av_image_check_size(src_params->width, src_params->height,
110
                                    0, avccontext) < 0) {
111 112 113 114 115 116 117 118 119 120 121
                av_log(avccontext, AV_LOG_ERROR, "Invalid dimensions (%dx%d)\n",
                       src_params->width, src_params->height);
                avccontext->height = avccontext->width = 0;
                return -1;
            }

            avccontext->height = src_params->height;
            avccontext->width  = src_params->width;

            avccontext->pix_fmt = GetFfmpegChromaFormat(src_params->chroma);
            if (avccontext->pix_fmt == PIX_FMT_NONE) {
122 123 124
                av_log(avccontext, AV_LOG_ERROR,
                       "Dirac chroma format %d not supported currently\n",
                       src_params->chroma);
125 126 127 128 129 130 131 132 133 134 135 136 137 138 139
                return -1;
            }

            avccontext->time_base.den = src_params->frame_rate.numerator;
            avccontext->time_base.num = src_params->frame_rate.denominator;

            /* calculate output dimensions */
            avpicture_fill(&pic, NULL, avccontext->pix_fmt,
                           avccontext->width, avccontext->height);

            pict_size = avpicture_get_size(avccontext->pix_fmt,
                                           avccontext->width,
                                           avccontext->height);

            /* allocate output buffer */
140
            if (!p_dirac_params->p_out_frame_buf)
141
                p_dirac_params->p_out_frame_buf = av_malloc(pict_size);
142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174
            buffer[0] = p_dirac_params->p_out_frame_buf;
            buffer[1] = p_dirac_params->p_out_frame_buf +
                        pic.linesize[0] * avccontext->height;
            buffer[2] = buffer[1] +
                        pic.linesize[1] * src_params->chroma_height;

            /* tell Dirac about output destination */
            dirac_set_buf(p_dirac_params->p_decoder, buffer, NULL);
            break;
        }
        case STATE_SEQUENCE_END:
            break;

        case STATE_PICTURE_AVAIL:
            /* fill picture with current buffer data from Dirac */
            avpicture_fill(picture, p_dirac_params->p_out_frame_buf,
                           avccontext->pix_fmt,
                           avccontext->width, avccontext->height);
            *data_size = sizeof(AVPicture);
            return buf_size;

        case STATE_INVALID:
            return -1;

        default:
            break;
        }
    }

    return buf_size;
}


175
static av_cold int libdirac_decode_close(AVCodecContext *avccontext)
176 177
{
    FfmpegDiracDecoderParams *p_dirac_params = avccontext->priv_data;
178
    dirac_decoder_close(p_dirac_params->p_decoder);
179 180 181

    av_freep(&p_dirac_params->p_out_frame_buf);

182
    return 0;
183 184
}

185
static void libdirac_flush(AVCodecContext *avccontext)
186 187 188 189
{
    /* Got a seek request. We will need free memory held in the private
     * context and free the current Dirac decoder handle and then open
     * a new decoder handle. */
190 191
    libdirac_decode_close(avccontext);
    libdirac_decode_init(avccontext);
192 193 194 195 196 197 198
    return;
}



AVCodec libdirac_decoder = {
    "libdirac",
199
    AVMEDIA_TYPE_VIDEO,
200 201 202 203 204 205 206
    CODEC_ID_DIRAC,
    sizeof(FfmpegDiracDecoderParams),
    libdirac_decode_init,
    NULL,
    libdirac_decode_close,
    libdirac_decode_frame,
    CODEC_CAP_DELAY,
207
    .flush = libdirac_flush,
208
    .long_name = NULL_IF_CONFIG_SMALL("libdirac Dirac 2.2"),
209
};