Implement avcodec_decode_video2(), _audio3() and _subtitle2() which takes an
[ffmpeg.git] / libavcodec / libschroedingerdec.c
1 /*
2  * Dirac decoder 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 libavcodec/libschroedingerdec.c
24 * Dirac decoder 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 #include "avcodec.h"
31 #include "libdirac_libschro.h"
32 #include "libschroedinger.h"
33
34 #undef NDEBUG
35 #include <assert.h>
36
37
38 #include <schroedinger/schro.h>
39 #include <schroedinger/schrodebug.h>
40 #include <schroedinger/schrovideoformat.h>
41
42 /** libschroedinger decoder private data */
43 typedef struct FfmpegSchroDecoderParams
44 {
45     /** Schroedinger video format */
46     SchroVideoFormat *format;
47
48     /** Schroedinger frame format */
49     SchroFrameFormat frame_format;
50
51     /** decoder handle */
52     SchroDecoder* decoder;
53
54     /** queue storing decoded frames */
55     FfmpegDiracSchroQueue dec_frame_queue;
56
57     /** end of sequence signalled */
58     int eos_signalled;
59
60     /** end of sequence pulled */
61     int eos_pulled;
62
63     /** decoded picture */
64     AVPicture dec_pic;
65 } FfmpegSchroDecoderParams;
66
67 typedef struct FfmpegSchroParseUnitContext
68 {
69     const uint8_t *buf;
70     int           buf_size;
71 } FfmpegSchroParseUnitContext;
72
73
74 static void libschroedinger_decode_buffer_free (SchroBuffer *schro_buf,
75                                                 void *priv);
76
77 static void FfmpegSchroParseContextInit (FfmpegSchroParseUnitContext *parse_ctx,
78                                          const uint8_t *buf, int buf_size)
79 {
80     parse_ctx->buf           = buf;
81     parse_ctx->buf_size      = buf_size;
82 }
83
84 static SchroBuffer* FfmpegFindNextSchroParseUnit (FfmpegSchroParseUnitContext *parse_ctx)
85 {
86     SchroBuffer *enc_buf = NULL;
87     int next_pu_offset = 0;
88     unsigned char *in_buf;
89
90     if (parse_ctx->buf_size < 13 ||
91         parse_ctx->buf[0] != 'B' ||
92         parse_ctx->buf[1] != 'B' ||
93         parse_ctx->buf[2] != 'C' ||
94         parse_ctx->buf[3] != 'D')
95         return NULL;
96
97     next_pu_offset = (parse_ctx->buf[5] << 24) +
98                      (parse_ctx->buf[6] << 16) +
99                      (parse_ctx->buf[7] <<  8) +
100                       parse_ctx->buf[8];
101
102     if (next_pu_offset == 0 &&
103         SCHRO_PARSE_CODE_IS_END_OF_SEQUENCE(parse_ctx->buf[4]))
104         next_pu_offset = 13;
105
106     if (next_pu_offset <= 0 || parse_ctx->buf_size < next_pu_offset)
107         return NULL;
108
109     in_buf = av_malloc(next_pu_offset);
110     memcpy (in_buf, parse_ctx->buf, next_pu_offset);
111     enc_buf = schro_buffer_new_with_data (in_buf, next_pu_offset);
112     enc_buf->free = libschroedinger_decode_buffer_free;
113     enc_buf->priv = in_buf;
114
115     parse_ctx->buf += next_pu_offset;
116     parse_ctx->buf_size -= next_pu_offset;
117
118     return enc_buf;
119 }
120
121 /**
122 * Returns FFmpeg chroma format.
123 */
124 static enum PixelFormat GetFfmpegChromaFormat(SchroChromaFormat schro_pix_fmt)
125 {
126     int num_formats = sizeof(ffmpeg_schro_pixel_format_map) /
127                       sizeof(ffmpeg_schro_pixel_format_map[0]);
128     int idx;
129
130     for (idx = 0; idx < num_formats; ++idx) {
131         if (ffmpeg_schro_pixel_format_map[idx].schro_pix_fmt == schro_pix_fmt) {
132             return ffmpeg_schro_pixel_format_map[idx].ff_pix_fmt;
133         }
134     }
135     return PIX_FMT_NONE;
136 }
137
138 static av_cold int libschroedinger_decode_init(AVCodecContext *avccontext)
139 {
140
141     FfmpegSchroDecoderParams *p_schro_params = avccontext->priv_data ;
142     /* First of all, initialize our supporting libraries. */
143     schro_init();
144
145     schro_debug_set_level(avccontext->debug);
146     p_schro_params->decoder =  schro_decoder_new();
147     schro_decoder_set_skip_ratio(p_schro_params->decoder, 1);
148
149     if (!p_schro_params->decoder)
150         return -1;
151
152     /* Initialize the decoded frame queue. */
153     ff_dirac_schro_queue_init (&p_schro_params->dec_frame_queue);
154     return 0 ;
155 }
156
157 static void libschroedinger_decode_buffer_free (SchroBuffer *schro_buf,
158                                                 void *priv)
159 {
160     av_freep(&priv);
161 }
162
163 static void libschroedinger_decode_frame_free (void *frame)
164 {
165     schro_frame_unref(frame);
166 }
167
168 static void libschroedinger_handle_first_access_unit(AVCodecContext *avccontext)
169 {
170     FfmpegSchroDecoderParams *p_schro_params = avccontext->priv_data;
171     SchroDecoder *decoder = p_schro_params->decoder;
172
173     p_schro_params->format = schro_decoder_get_video_format (decoder);
174
175     /* Tell FFmpeg about sequence details. */
176     if(avcodec_check_dimensions(avccontext, p_schro_params->format->width,
177                                 p_schro_params->format->height) < 0) {
178         av_log(avccontext, AV_LOG_ERROR, "invalid dimensions (%dx%d)\n",
179                p_schro_params->format->width, p_schro_params->format->height);
180         avccontext->height = avccontext->width = 0;
181         return;
182     }
183     avccontext->height  = p_schro_params->format->height;
184     avccontext->width   = p_schro_params->format->width;
185     avccontext->pix_fmt =
186                    GetFfmpegChromaFormat(p_schro_params->format->chroma_format);
187
188     if (ff_get_schro_frame_format( p_schro_params->format->chroma_format,
189                                    &p_schro_params->frame_format) == -1) {
190         av_log (avccontext, AV_LOG_ERROR,
191                 "This codec currently only supports planar YUV 4:2:0, 4:2:2 "
192                 "and 4:4:4 formats.\n");
193         return;
194     }
195
196     avccontext->time_base.den = p_schro_params->format->frame_rate_numerator;
197     avccontext->time_base.num = p_schro_params->format->frame_rate_denominator;
198
199     if (p_schro_params->dec_pic.data[0] == NULL)
200     {
201         avpicture_alloc(&p_schro_params->dec_pic,
202                         avccontext->pix_fmt,
203                         avccontext->width,
204                         avccontext->height);
205     }
206 }
207
208 static int libschroedinger_decode_frame(AVCodecContext *avccontext,
209                                         void *data, int *data_size,
210                                         AVPacket *avpkt)
211 {
212     const uint8_t *buf = avpkt->data;
213     int buf_size = avpkt->size;
214
215     FfmpegSchroDecoderParams *p_schro_params = avccontext->priv_data;
216     SchroDecoder *decoder = p_schro_params->decoder;
217     SchroVideoFormat *format;
218     AVPicture *picture = data;
219     SchroBuffer *enc_buf;
220     SchroFrame* frame;
221     int state;
222     int go = 1;
223     int outer = 1;
224     FfmpegSchroParseUnitContext parse_ctx;
225
226     *data_size = 0;
227
228     FfmpegSchroParseContextInit (&parse_ctx, buf, buf_size);
229     if (buf_size == 0) {
230         if (!p_schro_params->eos_signalled) {
231             state = schro_decoder_push_end_of_stream(decoder);
232             p_schro_params->eos_signalled = 1;
233         }
234     }
235
236     /* Loop through all the individual parse units in the input buffer */
237     do {
238         if ((enc_buf = FfmpegFindNextSchroParseUnit(&parse_ctx))) {
239             /* Push buffer into decoder. */
240             if (SCHRO_PARSE_CODE_IS_PICTURE(enc_buf->data[4]) &&
241                 SCHRO_PARSE_CODE_NUM_REFS(enc_buf->data[4]) > 0)
242                 avccontext->has_b_frames = 1;
243             state = schro_decoder_push (decoder, enc_buf);
244             if (state == SCHRO_DECODER_FIRST_ACCESS_UNIT)
245                   libschroedinger_handle_first_access_unit(avccontext);
246             go = 1;
247         }
248         else
249             outer = 0;
250     format = p_schro_params->format;
251
252     while (go) {
253         /* Parse data and process result. */
254         state = schro_decoder_wait (decoder);
255         switch (state)
256         {
257         case SCHRO_DECODER_FIRST_ACCESS_UNIT:
258             libschroedinger_handle_first_access_unit (avccontext);
259             break;
260
261         case SCHRO_DECODER_NEED_BITS:
262             /* Need more input data - stop iterating over what we have. */
263             go = 0;
264             break;
265
266         case SCHRO_DECODER_NEED_FRAME:
267             /* Decoder needs a frame - create one and push it in. */
268
269             frame = schro_frame_new_and_alloc(NULL,
270                                               p_schro_params->frame_format,
271                                               format->width,
272                                               format->height);
273             schro_decoder_add_output_picture (decoder, frame);
274             break;
275
276         case SCHRO_DECODER_OK:
277             /* Pull a frame out of the decoder. */
278             frame = schro_decoder_pull (decoder);
279
280             if (frame) {
281                 ff_dirac_schro_queue_push_back(
282                                              &p_schro_params->dec_frame_queue,
283                                              frame);
284             }
285             break;
286         case SCHRO_DECODER_EOS:
287             go = 0;
288             p_schro_params->eos_pulled = 1;
289             schro_decoder_reset (decoder);
290             outer = 0;
291             break;
292
293         case SCHRO_DECODER_ERROR:
294             return -1;
295             break;
296         }
297     }
298     } while(outer);
299
300     /* Grab next frame to be returned from the top of the queue. */
301     frame = ff_dirac_schro_queue_pop(&p_schro_params->dec_frame_queue);
302
303     if (frame != NULL) {
304         memcpy (p_schro_params->dec_pic.data[0],
305                 frame->components[0].data,
306                 frame->components[0].length);
307
308         memcpy (p_schro_params->dec_pic.data[1],
309                 frame->components[1].data,
310                 frame->components[1].length);
311
312         memcpy (p_schro_params->dec_pic.data[2],
313                 frame->components[2].data,
314                 frame->components[2].length);
315
316         /* Fill picture with current buffer data from Schroedinger. */
317         avpicture_fill(picture, p_schro_params->dec_pic.data[0],
318                        avccontext->pix_fmt,
319                        avccontext->width, avccontext->height);
320
321         *data_size = sizeof(AVPicture);
322
323         /* Now free the frame resources. */
324         libschroedinger_decode_frame_free (frame);
325     }
326     return buf_size;
327 }
328
329
330 static av_cold int libschroedinger_decode_close(AVCodecContext *avccontext)
331 {
332     FfmpegSchroDecoderParams *p_schro_params = avccontext->priv_data;
333     /* Free the decoder. */
334     schro_decoder_free (p_schro_params->decoder);
335     av_freep(&p_schro_params->format);
336
337     avpicture_free (&p_schro_params->dec_pic);
338
339     /* Free data in the output frame queue. */
340     ff_dirac_schro_queue_free (&p_schro_params->dec_frame_queue,
341                                libschroedinger_decode_frame_free);
342
343     return 0 ;
344 }
345
346 static void libschroedinger_flush (AVCodecContext *avccontext)
347 {
348     /* Got a seek request. Free the decoded frames queue and then reset
349      * the decoder */
350     FfmpegSchroDecoderParams *p_schro_params = avccontext->priv_data;
351
352     /* Free data in the output frame queue. */
353     ff_dirac_schro_queue_free (&p_schro_params->dec_frame_queue,
354                                libschroedinger_decode_frame_free);
355
356     ff_dirac_schro_queue_init (&p_schro_params->dec_frame_queue);
357     schro_decoder_reset(p_schro_params->decoder);
358     p_schro_params->eos_pulled = 0;
359     p_schro_params->eos_signalled = 0;
360 }
361
362 AVCodec libschroedinger_decoder = {
363      "libschroedinger",
364     CODEC_TYPE_VIDEO,
365     CODEC_ID_DIRAC,
366     sizeof(FfmpegSchroDecoderParams),
367     libschroedinger_decode_init,
368     NULL,
369     libschroedinger_decode_close,
370     libschroedinger_decode_frame,
371     CODEC_CAP_DELAY,
372     .flush = libschroedinger_flush,
373     .long_name = NULL_IF_CONFIG_SMALL("libschroedinger Dirac 2.2"),
374 };