Commit | Line | Data |
---|---|---|
2ba45a60 DM |
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 | |
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 <string.h> | |
31 | ||
32 | #include "libavutil/imgutils.h" | |
33 | #include "libavutil/internal.h" | |
34 | #include "libavutil/intreadwrite.h" | |
35 | #include "libavutil/mem.h" | |
36 | #include "avcodec.h" | |
37 | #include "internal.h" | |
38 | #include "libschroedinger.h" | |
39 | ||
40 | #include <schroedinger/schro.h> | |
41 | #include <schroedinger/schrodebug.h> | |
42 | #include <schroedinger/schrovideoformat.h> | |
43 | ||
44 | /** SchroFrame and Pts relation */ | |
45 | typedef struct LibSchroFrameContext { | |
46 | SchroFrame *frame; | |
47 | int64_t pts; | |
48 | } LibSchroFrameContext; | |
49 | ||
50 | /** libschroedinger decoder private data */ | |
51 | typedef struct SchroDecoderParams { | |
52 | /** Schroedinger video format */ | |
53 | SchroVideoFormat *format; | |
54 | ||
55 | /** Schroedinger frame format */ | |
56 | SchroFrameFormat frame_format; | |
57 | ||
58 | /** decoder handle */ | |
59 | SchroDecoder* decoder; | |
60 | ||
61 | /** queue storing decoded frames */ | |
62 | FFSchroQueue dec_frame_queue; | |
63 | ||
64 | /** end of sequence signalled */ | |
65 | int eos_signalled; | |
66 | ||
67 | /** end of sequence pulled */ | |
68 | int eos_pulled; | |
69 | } SchroDecoderParams; | |
70 | ||
71 | typedef struct SchroParseUnitContext { | |
72 | const uint8_t *buf; | |
73 | int buf_size; | |
74 | } SchroParseUnitContext; | |
75 | ||
76 | ||
77 | static void libschroedinger_decode_buffer_free(SchroBuffer *schro_buf, | |
78 | void *priv) | |
79 | { | |
80 | av_freep(&priv); | |
81 | } | |
82 | ||
83 | static void parse_context_init(SchroParseUnitContext *parse_ctx, | |
84 | const uint8_t *buf, int buf_size) | |
85 | { | |
86 | parse_ctx->buf = buf; | |
87 | parse_ctx->buf_size = buf_size; | |
88 | } | |
89 | ||
90 | static SchroBuffer *find_next_parse_unit(SchroParseUnitContext *parse_ctx) | |
91 | { | |
92 | SchroBuffer *enc_buf = NULL; | |
93 | int next_pu_offset = 0; | |
94 | unsigned char *in_buf; | |
95 | ||
96 | if (parse_ctx->buf_size < 13 || | |
97 | parse_ctx->buf[0] != 'B' || | |
98 | parse_ctx->buf[1] != 'B' || | |
99 | parse_ctx->buf[2] != 'C' || | |
100 | parse_ctx->buf[3] != 'D') | |
101 | return NULL; | |
102 | ||
103 | next_pu_offset = (parse_ctx->buf[5] << 24) + | |
104 | (parse_ctx->buf[6] << 16) + | |
105 | (parse_ctx->buf[7] << 8) + | |
106 | parse_ctx->buf[8]; | |
107 | ||
108 | if (next_pu_offset == 0 && | |
109 | SCHRO_PARSE_CODE_IS_END_OF_SEQUENCE(parse_ctx->buf[4])) | |
110 | next_pu_offset = 13; | |
111 | ||
112 | if (next_pu_offset <= 0 || parse_ctx->buf_size < next_pu_offset) | |
113 | return NULL; | |
114 | ||
115 | in_buf = av_malloc(next_pu_offset); | |
116 | if (!in_buf) { | |
117 | av_log(parse_ctx, AV_LOG_ERROR, "Unable to allocate input buffer\n"); | |
118 | return NULL; | |
119 | } | |
120 | ||
121 | memcpy(in_buf, parse_ctx->buf, next_pu_offset); | |
122 | enc_buf = schro_buffer_new_with_data(in_buf, next_pu_offset); | |
123 | enc_buf->free = libschroedinger_decode_buffer_free; | |
124 | enc_buf->priv = in_buf; | |
125 | ||
126 | parse_ctx->buf += next_pu_offset; | |
127 | parse_ctx->buf_size -= next_pu_offset; | |
128 | ||
129 | return enc_buf; | |
130 | } | |
131 | ||
132 | /** | |
133 | * Returns FFmpeg chroma format. | |
134 | */ | |
135 | static enum AVPixelFormat get_chroma_format(SchroChromaFormat schro_pix_fmt) | |
136 | { | |
137 | int num_formats = sizeof(schro_pixel_format_map) / | |
138 | sizeof(schro_pixel_format_map[0]); | |
139 | int idx; | |
140 | ||
141 | for (idx = 0; idx < num_formats; ++idx) | |
142 | if (schro_pixel_format_map[idx].schro_pix_fmt == schro_pix_fmt) | |
143 | return schro_pixel_format_map[idx].ff_pix_fmt; | |
144 | return AV_PIX_FMT_NONE; | |
145 | } | |
146 | ||
147 | static av_cold int libschroedinger_decode_init(AVCodecContext *avctx) | |
148 | { | |
149 | ||
150 | SchroDecoderParams *p_schro_params = avctx->priv_data; | |
151 | /* First of all, initialize our supporting libraries. */ | |
152 | schro_init(); | |
153 | ||
154 | schro_debug_set_level(avctx->debug); | |
155 | p_schro_params->decoder = schro_decoder_new(); | |
156 | schro_decoder_set_skip_ratio(p_schro_params->decoder, 1); | |
157 | ||
158 | if (!p_schro_params->decoder) | |
159 | return -1; | |
160 | ||
161 | /* Initialize the decoded frame queue. */ | |
162 | ff_schro_queue_init(&p_schro_params->dec_frame_queue); | |
163 | return 0; | |
164 | } | |
165 | ||
166 | static void libschroedinger_decode_frame_free(void *frame) | |
167 | { | |
168 | schro_frame_unref(frame); | |
169 | } | |
170 | ||
171 | static void libschroedinger_handle_first_access_unit(AVCodecContext *avctx) | |
172 | { | |
173 | SchroDecoderParams *p_schro_params = avctx->priv_data; | |
174 | SchroDecoder *decoder = p_schro_params->decoder; | |
175 | ||
176 | p_schro_params->format = schro_decoder_get_video_format(decoder); | |
177 | ||
178 | /* Tell FFmpeg about sequence details. */ | |
179 | if (av_image_check_size(p_schro_params->format->width, | |
180 | p_schro_params->format->height, 0, avctx) < 0) { | |
181 | av_log(avctx, AV_LOG_ERROR, "invalid dimensions (%dx%d)\n", | |
182 | p_schro_params->format->width, p_schro_params->format->height); | |
183 | avctx->height = avctx->width = 0; | |
184 | return; | |
185 | } | |
186 | avctx->height = p_schro_params->format->height; | |
187 | avctx->width = p_schro_params->format->width; | |
188 | avctx->pix_fmt = get_chroma_format(p_schro_params->format->chroma_format); | |
189 | ||
190 | if (ff_get_schro_frame_format(p_schro_params->format->chroma_format, | |
191 | &p_schro_params->frame_format) == -1) { | |
192 | av_log(avctx, AV_LOG_ERROR, | |
193 | "This codec currently only supports planar YUV 4:2:0, 4:2:2 " | |
194 | "and 4:4:4 formats.\n"); | |
195 | return; | |
196 | } | |
197 | ||
f6fa7814 DM |
198 | avctx->framerate.num = p_schro_params->format->frame_rate_numerator; |
199 | avctx->framerate.den = p_schro_params->format->frame_rate_denominator; | |
2ba45a60 DM |
200 | } |
201 | ||
202 | static int libschroedinger_decode_frame(AVCodecContext *avctx, | |
203 | void *data, int *got_frame, | |
204 | AVPacket *avpkt) | |
205 | { | |
206 | const uint8_t *buf = avpkt->data; | |
207 | int buf_size = avpkt->size; | |
208 | int64_t pts = avpkt->pts; | |
209 | SchroTag *tag; | |
210 | ||
211 | SchroDecoderParams *p_schro_params = avctx->priv_data; | |
212 | SchroDecoder *decoder = p_schro_params->decoder; | |
213 | SchroBuffer *enc_buf; | |
214 | SchroFrame* frame; | |
215 | AVFrame *avframe = data; | |
216 | int state; | |
217 | int go = 1; | |
218 | int outer = 1; | |
219 | SchroParseUnitContext parse_ctx; | |
220 | LibSchroFrameContext *framewithpts = NULL; | |
221 | ||
222 | *got_frame = 0; | |
223 | ||
224 | parse_context_init(&parse_ctx, buf, buf_size); | |
225 | if (!buf_size) { | |
226 | if (!p_schro_params->eos_signalled) { | |
227 | state = schro_decoder_push_end_of_stream(decoder); | |
228 | p_schro_params->eos_signalled = 1; | |
229 | } | |
230 | } | |
231 | ||
232 | /* Loop through all the individual parse units in the input buffer */ | |
233 | do { | |
234 | if ((enc_buf = find_next_parse_unit(&parse_ctx))) { | |
235 | /* Set Schrotag with the pts to be recovered after decoding*/ | |
236 | enc_buf->tag = schro_tag_new(av_malloc(sizeof(int64_t)), av_free); | |
237 | if (!enc_buf->tag->value) { | |
238 | av_log(avctx, AV_LOG_ERROR, "Unable to allocate SchroTag\n"); | |
239 | return AVERROR(ENOMEM); | |
240 | } | |
241 | AV_WN(64, enc_buf->tag->value, pts); | |
242 | /* Push buffer into decoder. */ | |
243 | if (SCHRO_PARSE_CODE_IS_PICTURE(enc_buf->data[4]) && | |
244 | SCHRO_PARSE_CODE_NUM_REFS(enc_buf->data[4]) > 0) | |
245 | avctx->has_b_frames = 1; | |
246 | state = schro_decoder_push(decoder, enc_buf); | |
247 | if (state == SCHRO_DECODER_FIRST_ACCESS_UNIT) | |
248 | libschroedinger_handle_first_access_unit(avctx); | |
249 | go = 1; | |
250 | } else | |
251 | outer = 0; | |
252 | ||
253 | while (go) { | |
254 | /* Parse data and process result. */ | |
255 | state = schro_decoder_wait(decoder); | |
256 | switch (state) { | |
257 | case SCHRO_DECODER_FIRST_ACCESS_UNIT: | |
258 | libschroedinger_handle_first_access_unit(avctx); | |
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 | frame = ff_create_schro_frame(avctx, | |
269 | p_schro_params->frame_format); | |
270 | schro_decoder_add_output_picture(decoder, frame); | |
271 | break; | |
272 | ||
273 | case SCHRO_DECODER_OK: | |
274 | /* Pull a frame out of the decoder. */ | |
275 | tag = schro_decoder_get_picture_tag(decoder); | |
276 | frame = schro_decoder_pull(decoder); | |
277 | ||
278 | if (frame) { | |
279 | /* Add relation between schroframe and pts. */ | |
280 | framewithpts = av_malloc(sizeof(LibSchroFrameContext)); | |
281 | if (!framewithpts) { | |
282 | av_log(avctx, AV_LOG_ERROR, "Unable to allocate FrameWithPts\n"); | |
283 | return AVERROR(ENOMEM); | |
284 | } | |
285 | framewithpts->frame = frame; | |
286 | framewithpts->pts = AV_RN64(tag->value); | |
287 | ff_schro_queue_push_back(&p_schro_params->dec_frame_queue, | |
288 | framewithpts); | |
289 | } | |
290 | break; | |
291 | case SCHRO_DECODER_EOS: | |
292 | go = 0; | |
293 | p_schro_params->eos_pulled = 1; | |
294 | schro_decoder_reset(decoder); | |
295 | outer = 0; | |
296 | break; | |
297 | ||
298 | case SCHRO_DECODER_ERROR: | |
299 | return -1; | |
300 | break; | |
301 | } | |
302 | } | |
303 | } while (outer); | |
304 | ||
305 | /* Grab next frame to be returned from the top of the queue. */ | |
306 | framewithpts = ff_schro_queue_pop(&p_schro_params->dec_frame_queue); | |
307 | ||
308 | if (framewithpts && framewithpts->frame) { | |
309 | int ret; | |
310 | ||
311 | if ((ret = ff_get_buffer(avctx, avframe, 0)) < 0) | |
312 | return ret; | |
313 | ||
314 | memcpy(avframe->data[0], | |
315 | framewithpts->frame->components[0].data, | |
316 | framewithpts->frame->components[0].length); | |
317 | ||
318 | memcpy(avframe->data[1], | |
319 | framewithpts->frame->components[1].data, | |
320 | framewithpts->frame->components[1].length); | |
321 | ||
322 | memcpy(avframe->data[2], | |
323 | framewithpts->frame->components[2].data, | |
324 | framewithpts->frame->components[2].length); | |
325 | ||
326 | /* Fill frame with current buffer data from Schroedinger. */ | |
327 | avframe->pkt_pts = framewithpts->pts; | |
328 | avframe->linesize[0] = framewithpts->frame->components[0].stride; | |
329 | avframe->linesize[1] = framewithpts->frame->components[1].stride; | |
330 | avframe->linesize[2] = framewithpts->frame->components[2].stride; | |
331 | ||
332 | *got_frame = 1; | |
333 | ||
334 | /* Now free the frame resources. */ | |
335 | libschroedinger_decode_frame_free(framewithpts->frame); | |
336 | av_free(framewithpts); | |
337 | } else { | |
338 | data = NULL; | |
339 | *got_frame = 0; | |
340 | } | |
341 | return buf_size; | |
342 | } | |
343 | ||
344 | ||
345 | static av_cold int libschroedinger_decode_close(AVCodecContext *avctx) | |
346 | { | |
347 | SchroDecoderParams *p_schro_params = avctx->priv_data; | |
348 | /* Free the decoder. */ | |
349 | schro_decoder_free(p_schro_params->decoder); | |
350 | av_freep(&p_schro_params->format); | |
351 | ||
352 | /* Free data in the output frame queue. */ | |
353 | ff_schro_queue_free(&p_schro_params->dec_frame_queue, | |
354 | libschroedinger_decode_frame_free); | |
355 | ||
356 | return 0; | |
357 | } | |
358 | ||
359 | static void libschroedinger_flush(AVCodecContext *avctx) | |
360 | { | |
361 | /* Got a seek request. Free the decoded frames queue and then reset | |
362 | * the decoder */ | |
363 | SchroDecoderParams *p_schro_params = avctx->priv_data; | |
364 | ||
365 | /* Free data in the output frame queue. */ | |
366 | ff_schro_queue_free(&p_schro_params->dec_frame_queue, | |
367 | libschroedinger_decode_frame_free); | |
368 | ||
369 | ff_schro_queue_init(&p_schro_params->dec_frame_queue); | |
370 | schro_decoder_reset(p_schro_params->decoder); | |
371 | p_schro_params->eos_pulled = 0; | |
372 | p_schro_params->eos_signalled = 0; | |
373 | } | |
374 | ||
375 | AVCodec ff_libschroedinger_decoder = { | |
376 | .name = "libschroedinger", | |
377 | .long_name = NULL_IF_CONFIG_SMALL("libschroedinger Dirac 2.2"), | |
378 | .type = AVMEDIA_TYPE_VIDEO, | |
379 | .id = AV_CODEC_ID_DIRAC, | |
380 | .priv_data_size = sizeof(SchroDecoderParams), | |
381 | .init = libschroedinger_decode_init, | |
382 | .close = libschroedinger_decode_close, | |
383 | .decode = libschroedinger_decode_frame, | |
384 | .capabilities = CODEC_CAP_DELAY, | |
385 | .flush = libschroedinger_flush, | |
386 | }; |