← Back to branch summary

~ubuntu-branches/ubuntu/natty/libav/natty-security

« back to all changes in this revision

Viewing changes to libavcodec/libschroedingerenc.c

  • Committer: Bazaar Package Importer
  • Author(s): Reinhard Tartler
  • Date: 2011-03-20 12:09:31 UTC
  • Revision ID: james.westby@ubuntu.com-20110320120931-nfhi9tiok27gxhw1
Tags: upstream-0.6.2
Import upstream version 0.6.2

Show diffs side-by-side

added added

removed removed

Lines of Context:
libavcodec/libschroedingerenc.c
 
1
/*
 
2
 * Dirac encoder support via Schroedinger libraries
 
3
 * Copyright (c) 2008 BBC, Anuradha Suraparaju <asuraparaju at gmail dot com >
 
4
 *
 
5
 * This file is part of FFmpeg.
 
6
 *
 
7
 * FFmpeg is free software; you can redistribute it and/or
 
8
 * modify it under the terms of the GNU Lesser General Public
 
9
 * License as published by the Free Software Foundation; either
 
10
 * version 2.1 of the License, or (at your option) any later version.
 
11
 *
 
12
 * FFmpeg is distributed in the hope that it will be useful,
 
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
15
 * Lesser General Public License for more details.
 
16
 *
 
17
 * You should have received a copy of the GNU Lesser General Public
 
18
 * License along with FFmpeg; if not, write to the Free Software
 
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
20
 */
 
21
 
 
22
/**
 
23
* @file
 
24
* Dirac encoder support via libschroedinger-1.0 libraries. More details about
 
25
* the Schroedinger project can be found at http://www.diracvideo.org/.
 
26
* The library implements Dirac Specification Version 2.2
 
27
* (http://dirac.sourceforge.net/specification.html).
 
28
*/
 
29
 
 
30
#undef NDEBUG
 
31
#include <assert.h>
 
32
 
 
33
#include <schroedinger/schro.h>
 
34
#include <schroedinger/schrodebug.h>
 
35
#include <schroedinger/schrovideoformat.h>
 
36
 
 
37
#include "avcodec.h"
 
38
#include "libdirac_libschro.h"
 
39
#include "libschroedinger.h"
 
40
 
 
41
 
 
42
/** libschroedinger encoder private data */
 
43
typedef struct FfmpegSchroEncoderParams {
 
44
    /** Schroedinger video format */
 
45
    SchroVideoFormat *format;
 
46
 
 
47
    /** Schroedinger frame format */
 
48
    SchroFrameFormat frame_format;
 
49
 
 
50
    /** frame being encoded */
 
51
    AVFrame picture;
 
52
 
 
53
    /** frame size */
 
54
    int frame_size;
 
55
 
 
56
    /** Schroedinger encoder handle*/
 
57
    SchroEncoder* encoder;
 
58
 
 
59
    /** buffer to store encoder output before writing it to the frame queue*/
 
60
    unsigned char *enc_buf;
 
61
 
 
62
    /** Size of encoder buffer*/
 
63
    int enc_buf_size;
 
64
 
 
65
    /** queue storing encoded frames */
 
66
    FfmpegDiracSchroQueue enc_frame_queue;
 
67
 
 
68
    /** end of sequence signalled */
 
69
    int eos_signalled;
 
70
 
 
71
    /** end of sequence pulled */
 
72
    int eos_pulled;
 
73
} FfmpegSchroEncoderParams;
 
74
 
 
75
/**
 
76
* Works out Schro-compatible chroma format.
 
77
*/
 
78
static int SetSchroChromaFormat(AVCodecContext *avccontext)
 
79
{
 
80
    int num_formats = sizeof(ffmpeg_schro_pixel_format_map) /
 
81
                      sizeof(ffmpeg_schro_pixel_format_map[0]);
 
82
    int idx;
 
83
 
 
84
    FfmpegSchroEncoderParams* p_schro_params = avccontext->priv_data;
 
85
 
 
86
    for (idx = 0; idx < num_formats; ++idx) {
 
87
        if (ffmpeg_schro_pixel_format_map[idx].ff_pix_fmt ==
 
88
            avccontext->pix_fmt) {
 
89
            p_schro_params->format->chroma_format =
 
90
                            ffmpeg_schro_pixel_format_map[idx].schro_pix_fmt;
 
91
            return 0;
 
92
        }
 
93
    }
 
94
 
 
95
    av_log(avccontext, AV_LOG_ERROR,
 
96
           "This codec currently only supports planar YUV 4:2:0, 4:2:2"
 
97
           " and 4:4:4 formats.\n");
 
98
 
 
99
    return -1;
 
100
}
 
101
 
 
102
static int libschroedinger_encode_init(AVCodecContext *avccontext)
 
103
{
 
104
    FfmpegSchroEncoderParams* p_schro_params = avccontext->priv_data;
 
105
    SchroVideoFormatEnum preset;
 
106
 
 
107
    /* Initialize the libraries that libschroedinger depends on. */
 
108
    schro_init();
 
109
 
 
110
    /* Create an encoder object. */
 
111
    p_schro_params->encoder = schro_encoder_new();
 
112
 
 
113
    if (!p_schro_params->encoder) {
 
114
        av_log(avccontext, AV_LOG_ERROR,
 
115
               "Unrecoverable Error: schro_encoder_new failed. ");
 
116
        return -1;
 
117
    }
 
118
 
 
119
    /* Initialize the format. */
 
120
    preset = ff_get_schro_video_format_preset(avccontext);
 
121
    p_schro_params->format =
 
122
                    schro_encoder_get_video_format(p_schro_params->encoder);
 
123
    schro_video_format_set_std_video_format(p_schro_params->format, preset);
 
124
    p_schro_params->format->width  = avccontext->width;
 
125
    p_schro_params->format->height = avccontext->height;
 
126
 
 
127
    if (SetSchroChromaFormat(avccontext) == -1)
 
128
        return -1;
 
129
 
 
130
    if (ff_get_schro_frame_format(p_schro_params->format->chroma_format,
 
131
                                  &p_schro_params->frame_format) == -1) {
 
132
        av_log(avccontext, AV_LOG_ERROR,
 
133
               "This codec currently supports only planar YUV 4:2:0, 4:2:2"
 
134
               " and 4:4:4 formats.\n");
 
135
        return -1;
 
136
    }
 
137
 
 
138
    p_schro_params->format->frame_rate_numerator   = avccontext->time_base.den;
 
139
    p_schro_params->format->frame_rate_denominator = avccontext->time_base.num;
 
140
 
 
141
    p_schro_params->frame_size = avpicture_get_size(avccontext->pix_fmt,
 
142
                                                    avccontext->width,
 
143
                                                    avccontext->height);
 
144
 
 
145
    avccontext->coded_frame = &p_schro_params->picture;
 
146
 
 
147
    if (!avccontext->gop_size) {
 
148
        schro_encoder_setting_set_double(p_schro_params->encoder,
 
149
                                         "gop_structure",
 
150
                                         SCHRO_ENCODER_GOP_INTRA_ONLY);
 
151
 
 
152
        if (avccontext->coder_type == FF_CODER_TYPE_VLC)
 
153
            schro_encoder_setting_set_double(p_schro_params->encoder,
 
154
                                             "enable_noarith", 1);
 
155
    } else {
 
156
        schro_encoder_setting_set_double(p_schro_params->encoder,
 
157
                                         "gop_structure",
 
158
                                         SCHRO_ENCODER_GOP_BIREF);
 
159
        avccontext->has_b_frames = 1;
 
160
    }
 
161
 
 
162
    /* FIXME - Need to handle SCHRO_ENCODER_RATE_CONTROL_LOW_DELAY. */
 
163
    if (avccontext->flags & CODEC_FLAG_QSCALE) {
 
164
        if (!avccontext->global_quality) {
 
165
            /* lossless coding */
 
166
            schro_encoder_setting_set_double(p_schro_params->encoder,
 
167
                                             "rate_control",
 
168
                                             SCHRO_ENCODER_RATE_CONTROL_LOSSLESS);
 
169
        } else {
 
170
            int noise_threshold;
 
171
            schro_encoder_setting_set_double(p_schro_params->encoder,
 
172
                                             "rate_control",
 
173
                                             SCHRO_ENCODER_RATE_CONTROL_CONSTANT_NOISE_THRESHOLD);
 
174
 
 
175
            noise_threshold = avccontext->global_quality / FF_QP2LAMBDA;
 
176
            if (noise_threshold > 100)
 
177
                noise_threshold = 100;
 
178
            schro_encoder_setting_set_double(p_schro_params->encoder,
 
179
                                             "noise_threshold",
 
180
                                             noise_threshold);
 
181
        }
 
182
    } else {
 
183
        schro_encoder_setting_set_double(p_schro_params->encoder,
 
184
                                         "rate_control",
 
185
                                         SCHRO_ENCODER_RATE_CONTROL_CONSTANT_BITRATE);
 
186
 
 
187
        schro_encoder_setting_set_double(p_schro_params->encoder,
 
188
                                         "bitrate",
 
189
                                         avccontext->bit_rate);
 
190
 
 
191
    }
 
192
 
 
193
    if (avccontext->flags & CODEC_FLAG_INTERLACED_ME)
 
194
        /* All material can be coded as interlaced or progressive
 
195
           irrespective of the type of source material. */
 
196
        schro_encoder_setting_set_double(p_schro_params->encoder,
 
197
                                         "interlaced_coding", 1);
 
198
 
 
199
    /* FIXME: Signal range hardcoded to 8-bit data until both libschroedinger
 
200
     * and libdirac support other bit-depth data. */
 
201
    schro_video_format_set_std_signal_range(p_schro_params->format,
 
202
                                            SCHRO_SIGNAL_RANGE_8BIT_VIDEO);
 
203
 
 
204
    /* Set the encoder format. */
 
205
    schro_encoder_set_video_format(p_schro_params->encoder,
 
206
                                   p_schro_params->format);
 
207
 
 
208
    /* Set the debug level. */
 
209
    schro_debug_set_level(avccontext->debug);
 
210
 
 
211
    schro_encoder_start(p_schro_params->encoder);
 
212
 
 
213
    /* Initialize the encoded frame queue. */
 
214
    ff_dirac_schro_queue_init(&p_schro_params->enc_frame_queue);
 
215
    return 0;
 
216
}
 
217
 
 
218
static SchroFrame *libschroedinger_frame_from_data(AVCodecContext *avccontext,
 
219
                                                   void *in_data)
 
220
{
 
221
    FfmpegSchroEncoderParams* p_schro_params = avccontext->priv_data;
 
222
    SchroFrame *in_frame;
 
223
    /* Input line size may differ from what the codec supports. Especially
 
224
     * when transcoding from one format to another. So use avpicture_layout
 
225
     * to copy the frame. */
 
226
    in_frame = ff_create_schro_frame(avccontext, p_schro_params->frame_format);
 
227
 
 
228
    if (in_frame)
 
229
        avpicture_layout((AVPicture *)in_data, avccontext->pix_fmt,
 
230
                          avccontext->width, avccontext->height,
 
231
                          in_frame->components[0].data,
 
232
                          p_schro_params->frame_size);
 
233
 
 
234
    return in_frame;
 
235
}
 
236
 
 
237
static void SchroedingerFreeFrame(void *data)
 
238
{
 
239
    FfmpegDiracSchroEncodedFrame *enc_frame = data;
 
240
 
 
241
    av_freep(&(enc_frame->p_encbuf));
 
242
    av_free(enc_frame);
 
243
}
 
244
 
 
245
static int libschroedinger_encode_frame(AVCodecContext *avccontext,
 
246
                                        unsigned char *frame,
 
247
                                        int buf_size, void *data)
 
248
{
 
249
    int enc_size = 0;
 
250
    FfmpegSchroEncoderParams* p_schro_params = avccontext->priv_data;
 
251
    SchroEncoder *encoder = p_schro_params->encoder;
 
252
    struct FfmpegDiracSchroEncodedFrame* p_frame_output = NULL;
 
253
    int go = 1;
 
254
    SchroBuffer *enc_buf;
 
255
    int presentation_frame;
 
256
    int parse_code;
 
257
    int last_frame_in_sequence = 0;
 
258
 
 
259
    if (!data) {
 
260
        /* Push end of sequence if not already signalled. */
 
261
        if (!p_schro_params->eos_signalled) {
 
262
            schro_encoder_end_of_stream(encoder);
 
263
            p_schro_params->eos_signalled = 1;
 
264
        }
 
265
    } else {
 
266
        /* Allocate frame data to schro input buffer. */
 
267
        SchroFrame *in_frame = libschroedinger_frame_from_data(avccontext,
 
268
                                                               data);
 
269
        /* Load next frame. */
 
270
        schro_encoder_push_frame(encoder, in_frame);
 
271
    }
 
272
 
 
273
    if (p_schro_params->eos_pulled)
 
274
        go = 0;
 
275
 
 
276
    /* Now check to see if we have any output from the encoder. */
 
277
    while (go) {
 
278
        SchroStateEnum state;
 
279
        state = schro_encoder_wait(encoder);
 
280
        switch (state) {
 
281
        case SCHRO_STATE_HAVE_BUFFER:
 
282
        case SCHRO_STATE_END_OF_STREAM:
 
283
            enc_buf = schro_encoder_pull(encoder, &presentation_frame);
 
284
            assert(enc_buf->length > 0);
 
285
            assert(enc_buf->length <= buf_size);
 
286
            parse_code = enc_buf->data[4];
 
287
 
 
288
            /* All non-frame data is prepended to actual frame data to
 
289
             * be able to set the pts correctly. So we don't write data
 
290
             * to the frame output queue until we actually have a frame
 
291
             */
 
292
            p_schro_params->enc_buf = av_realloc(p_schro_params->enc_buf,
 
293
                                                 p_schro_params->enc_buf_size + enc_buf->length);
 
294
 
 
295
            memcpy(p_schro_params->enc_buf + p_schro_params->enc_buf_size,
 
296
                   enc_buf->data, enc_buf->length);
 
297
            p_schro_params->enc_buf_size += enc_buf->length;
 
298
 
 
299
 
 
300
            if (state == SCHRO_STATE_END_OF_STREAM) {
 
301
                p_schro_params->eos_pulled = 1;
 
302
                go = 0;
 
303
            }
 
304
 
 
305
            if (!SCHRO_PARSE_CODE_IS_PICTURE(parse_code)) {
 
306
                schro_buffer_unref(enc_buf);
 
307
                break;
 
308
            }
 
309
 
 
310
            /* Create output frame. */
 
311
            p_frame_output = av_mallocz(sizeof(FfmpegDiracSchroEncodedFrame));
 
312
            /* Set output data. */
 
313
            p_frame_output->size     = p_schro_params->enc_buf_size;
 
314
            p_frame_output->p_encbuf = p_schro_params->enc_buf;
 
315
            if (SCHRO_PARSE_CODE_IS_INTRA(parse_code) &&
 
316
                SCHRO_PARSE_CODE_IS_REFERENCE(parse_code))
 
317
                p_frame_output->key_frame = 1;
 
318
 
 
319
            /* Parse the coded frame number from the bitstream. Bytes 14
 
320
             * through 17 represesent the frame number. */
 
321
                p_frame_output->frame_num = (enc_buf->data[13] << 24) +
 
322
                                            (enc_buf->data[14] << 16) +
 
323
                                            (enc_buf->data[15] <<  8) +
 
324
                                             enc_buf->data[16];
 
325
 
 
326
            ff_dirac_schro_queue_push_back(&p_schro_params->enc_frame_queue,
 
327
                                           p_frame_output);
 
328
            p_schro_params->enc_buf_size = 0;
 
329
            p_schro_params->enc_buf      = NULL;
 
330
 
 
331
            schro_buffer_unref(enc_buf);
 
332
 
 
333
            break;
 
334
 
 
335
        case SCHRO_STATE_NEED_FRAME:
 
336
            go = 0;
 
337
            break;
 
338
 
 
339
        case SCHRO_STATE_AGAIN:
 
340
            break;
 
341
 
 
342
        default:
 
343
            av_log(avccontext, AV_LOG_ERROR, "Unknown Schro Encoder state\n");
 
344
            return -1;
 
345
        }
 
346
    }
 
347
 
 
348
    /* Copy 'next' frame in queue. */
 
349
 
 
350
    if (p_schro_params->enc_frame_queue.size == 1 &&
 
351
        p_schro_params->eos_pulled)
 
352
        last_frame_in_sequence = 1;
 
353
 
 
354
    p_frame_output = ff_dirac_schro_queue_pop(&p_schro_params->enc_frame_queue);
 
355
 
 
356
    if (!p_frame_output)
 
357
        return 0;
 
358
 
 
359
    memcpy(frame, p_frame_output->p_encbuf, p_frame_output->size);
 
360
    avccontext->coded_frame->key_frame = p_frame_output->key_frame;
 
361
    /* Use the frame number of the encoded frame as the pts. It is OK to
 
362
     * do so since Dirac is a constant frame rate codec. It expects input
 
363
     * to be of constant frame rate. */
 
364
    avccontext->coded_frame->pts = p_frame_output->frame_num;
 
365
    enc_size = p_frame_output->size;
 
366
 
 
367
    /* Append the end of sequence information to the last frame in the
 
368
     * sequence. */
 
369
    if (last_frame_in_sequence && p_schro_params->enc_buf_size > 0) {
 
370
        memcpy(frame + enc_size, p_schro_params->enc_buf,
 
371
               p_schro_params->enc_buf_size);
 
372
        enc_size += p_schro_params->enc_buf_size;
 
373
        av_freep(&p_schro_params->enc_buf);
 
374
        p_schro_params->enc_buf_size = 0;
 
375
    }
 
376
 
 
377
    /* free frame */
 
378
    SchroedingerFreeFrame(p_frame_output);
 
379
 
 
380
    return enc_size;
 
381
}
 
382
 
 
383
 
 
384
static int libschroedinger_encode_close(AVCodecContext *avccontext)
 
385
{
 
386
 
 
387
    FfmpegSchroEncoderParams* p_schro_params = avccontext->priv_data;
 
388
 
 
389
    /* Close the encoder. */
 
390
    schro_encoder_free(p_schro_params->encoder);
 
391
 
 
392
    /* Free data in the output frame queue. */
 
393
    ff_dirac_schro_queue_free(&p_schro_params->enc_frame_queue,
 
394
                              SchroedingerFreeFrame);
 
395
 
 
396
 
 
397
    /* Free the encoder buffer. */
 
398
    if (p_schro_params->enc_buf_size)
 
399
        av_freep(&p_schro_params->enc_buf);
 
400
 
 
401
    /* Free the video format structure. */
 
402
    av_freep(&p_schro_params->format);
 
403
 
 
404
    return 0;
 
405
}
 
406
 
 
407
 
 
408
AVCodec libschroedinger_encoder = {
 
409
    "libschroedinger",
 
410
    AVMEDIA_TYPE_VIDEO,
 
411
    CODEC_ID_DIRAC,
 
412
    sizeof(FfmpegSchroEncoderParams),
 
413
    libschroedinger_encode_init,
 
414
    libschroedinger_encode_frame,
 
415
    libschroedinger_encode_close,
 
416
   .capabilities = CODEC_CAP_DELAY,
 
417
   .pix_fmts     = (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_YUV444P, PIX_FMT_NONE},
 
418
   .long_name    = NULL_IF_CONFIG_SMALL("libschroedinger Dirac 2.2"),
 
419
};