2 * - CrystalHD decoder module -
4 * Copyright(C) 2010,2011 Philip Langdale <ffmpeg.philipl@overt.org>
6 * This file is part of FFmpeg.
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.
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.
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
24 * - Principles of Operation -
26 * The CrystalHD decoder operates at the bitstream level - which is an even
27 * higher level than the decoding hardware you typically see in modern GPUs.
28 * This means it has a very simple interface, in principle. You feed demuxed
29 * packets in one end and get decoded picture (fields/frames) out the other.
31 * Of course, nothing is ever that simple. Due, at the very least, to b-frame
32 * dependencies in the supported formats, the hardware has a delay between
33 * when a packet goes in, and when a picture comes out. Furthermore, this delay
34 * is not just a function of time, but also one of the dependency on additional
35 * frames being fed into the decoder to satisfy the b-frame dependencies.
37 * As such, a pipeline will build up that is roughly equivalent to the required
38 * DPB for the file being played. If that was all it took, things would still
39 * be simple - so, of course, it isn't.
41 * The hardware has a way of indicating that a picture is ready to be copied out,
42 * but this is unreliable - and sometimes the attempt will still fail so, based
43 * on testing, the code will wait until 3 pictures are ready before starting
44 * to copy out - and this has the effect of extending the pipeline.
46 * Finally, while it is tempting to say that once the decoder starts outputting
47 * frames, the software should never fail to return a frame from a decode(),
48 * this is a hard assertion to make, because the stream may switch between
49 * differently encoded content (number of b-frames, interlacing, etc) which
50 * might require a longer pipeline than before. If that happened, you could
51 * deadlock trying to retrieve a frame that can't be decoded without feeding
52 * in additional packets.
54 * As such, the code will return in the event that a picture cannot be copied
55 * out, leading to an increase in the length of the pipeline. This in turn,
56 * means we have to be sensitive to the time it takes to decode a picture;
57 * We do not want to give up just because the hardware needed a little more
58 * time to prepare the picture! For this reason, there are delays included
59 * in the decode() path that ensure that, under normal conditions, the hardware
60 * will only fail to return a frame if it really needs additional packets to
61 * complete the decoding.
63 * Finally, to be explicit, we do not want the pipeline to grow without bound
64 * for two reasons: 1) The hardware can only buffer a finite number of packets,
65 * and 2) The client application may not be able to cope with arbitrarily long
66 * delays in the video path relative to the audio path. For example. MPlayer
67 * can only handle a 20 picture delay (although this is arbitrary, and needs
68 * to be extended to fully support the CrystalHD where the delay could be up
69 * to 32 pictures - consider PAFF H.264 content with 16 b-frames).
72 /*****************************************************************************
74 ****************************************************************************/
76 #define _XOPEN_SOURCE 600
81 #include <libcrystalhd/bc_dts_types.h>
82 #include <libcrystalhd/bc_dts_defs.h>
83 #include <libcrystalhd/libcrystalhd_if.h>
88 #include "libavutil/imgutils.h"
89 #include "libavutil/intreadwrite.h"
90 #include "libavutil/opt.h"
96 /** Timeout parameter passed to DtsProcOutput() in us */
97 #define OUTPUT_PROC_TIMEOUT 50
98 /** Step between fake timestamps passed to hardware in units of 100ns */
99 #define TIMESTAMP_UNIT 100000
100 /** Initial value in us of the wait in decode() */
101 #define BASE_WAIT 10000
102 /** Increment in us to adjust wait in decode() */
103 #define WAIT_UNIT 1000
106 /*****************************************************************************
107 * Module private data
108 ****************************************************************************/
114 RET_SKIP_NEXT_COPY
= 2,
115 RET_COPY_NEXT_FIELD
= 3,
118 typedef struct OpaqueList
{
119 struct OpaqueList
*next
;
120 uint64_t fake_timestamp
;
121 uint64_t reordered_opaque
;
127 AVCodecContext
*avctx
;
131 uint8_t *orig_extradata
;
132 uint32_t orig_extradata_size
;
134 AVBitStreamFilterContext
*bsfc
;
135 AVCodecParserContext
*parser
;
138 uint8_t *sps_pps_buf
;
139 uint32_t sps_pps_size
;
141 uint8_t output_ready
;
142 uint8_t need_second_field
;
143 uint8_t skip_next_output
;
144 uint64_t decode_wait
;
146 uint64_t last_picture
;
156 static const AVOption options
[] = {
157 { "crystalhd_downscale_width",
158 "Turn on downscaling to the specified width",
159 offsetof(CHDContext
, sWidth
),
160 AV_OPT_TYPE_INT
, {.i64
= 0}, 0, UINT32_MAX
,
161 AV_OPT_FLAG_VIDEO_PARAM
| AV_OPT_FLAG_DECODING_PARAM
, },
166 /*****************************************************************************
168 ****************************************************************************/
170 static inline BC_MEDIA_SUBTYPE
id2subtype(CHDContext
*priv
, enum AVCodecID id
)
173 case AV_CODEC_ID_MPEG4
:
174 return BC_MSUBTYPE_DIVX
;
175 case AV_CODEC_ID_MSMPEG4V3
:
176 return BC_MSUBTYPE_DIVX311
;
177 case AV_CODEC_ID_MPEG2VIDEO
:
178 return BC_MSUBTYPE_MPEG2VIDEO
;
179 case AV_CODEC_ID_VC1
:
180 return BC_MSUBTYPE_VC1
;
181 case AV_CODEC_ID_WMV3
:
182 return BC_MSUBTYPE_WMV3
;
183 case AV_CODEC_ID_H264
:
184 return priv
->is_nal
? BC_MSUBTYPE_AVC1
: BC_MSUBTYPE_H264
;
186 return BC_MSUBTYPE_INVALID
;
190 static inline void print_frame_info(CHDContext
*priv
, BC_DTS_PROC_OUT
*output
)
192 av_log(priv
->avctx
, AV_LOG_VERBOSE
, "\tYBuffSz: %u\n", output
->YbuffSz
);
193 av_log(priv
->avctx
, AV_LOG_VERBOSE
, "\tYBuffDoneSz: %u\n",
194 output
->YBuffDoneSz
);
195 av_log(priv
->avctx
, AV_LOG_VERBOSE
, "\tUVBuffDoneSz: %u\n",
196 output
->UVBuffDoneSz
);
197 av_log(priv
->avctx
, AV_LOG_VERBOSE
, "\tTimestamp: %"PRIu64
"\n",
198 output
->PicInfo
.timeStamp
);
199 av_log(priv
->avctx
, AV_LOG_VERBOSE
, "\tPicture Number: %u\n",
200 output
->PicInfo
.picture_number
);
201 av_log(priv
->avctx
, AV_LOG_VERBOSE
, "\tWidth: %u\n",
202 output
->PicInfo
.width
);
203 av_log(priv
->avctx
, AV_LOG_VERBOSE
, "\tHeight: %u\n",
204 output
->PicInfo
.height
);
205 av_log(priv
->avctx
, AV_LOG_VERBOSE
, "\tChroma: 0x%03x\n",
206 output
->PicInfo
.chroma_format
);
207 av_log(priv
->avctx
, AV_LOG_VERBOSE
, "\tPulldown: %u\n",
208 output
->PicInfo
.pulldown
);
209 av_log(priv
->avctx
, AV_LOG_VERBOSE
, "\tFlags: 0x%08x\n",
210 output
->PicInfo
.flags
);
211 av_log(priv
->avctx
, AV_LOG_VERBOSE
, "\tFrame Rate/Res: %u\n",
212 output
->PicInfo
.frame_rate
);
213 av_log(priv
->avctx
, AV_LOG_VERBOSE
, "\tAspect Ratio: %u\n",
214 output
->PicInfo
.aspect_ratio
);
215 av_log(priv
->avctx
, AV_LOG_VERBOSE
, "\tColor Primaries: %u\n",
216 output
->PicInfo
.colour_primaries
);
217 av_log(priv
->avctx
, AV_LOG_VERBOSE
, "\tMetaData: %u\n",
218 output
->PicInfo
.picture_meta_payload
);
219 av_log(priv
->avctx
, AV_LOG_VERBOSE
, "\tSession Number: %u\n",
220 output
->PicInfo
.sess_num
);
221 av_log(priv
->avctx
, AV_LOG_VERBOSE
, "\tycom: %u\n",
222 output
->PicInfo
.ycom
);
223 av_log(priv
->avctx
, AV_LOG_VERBOSE
, "\tCustom Aspect: %u\n",
224 output
->PicInfo
.custom_aspect_ratio_width_height
);
225 av_log(priv
->avctx
, AV_LOG_VERBOSE
, "\tFrames to Drop: %u\n",
226 output
->PicInfo
.n_drop
);
227 av_log(priv
->avctx
, AV_LOG_VERBOSE
, "\tH264 Valid Fields: 0x%08x\n",
228 output
->PicInfo
.other
.h264
.valid
);
232 /*****************************************************************************
233 * OpaqueList functions
234 ****************************************************************************/
236 static uint64_t opaque_list_push(CHDContext
*priv
, uint64_t reordered_opaque
,
239 OpaqueList
*newNode
= av_mallocz(sizeof (OpaqueList
));
241 av_log(priv
->avctx
, AV_LOG_ERROR
,
242 "Unable to allocate new node in OpaqueList.\n");
246 newNode
->fake_timestamp
= TIMESTAMP_UNIT
;
247 priv
->head
= newNode
;
249 newNode
->fake_timestamp
= priv
->tail
->fake_timestamp
+ TIMESTAMP_UNIT
;
250 priv
->tail
->next
= newNode
;
252 priv
->tail
= newNode
;
253 newNode
->reordered_opaque
= reordered_opaque
;
254 newNode
->pic_type
= pic_type
;
256 return newNode
->fake_timestamp
;
260 * The OpaqueList is built in decode order, while elements will be removed
261 * in presentation order. If frames are reordered, this means we must be
262 * able to remove elements that are not the first element.
264 * Returned node must be freed by caller.
266 static OpaqueList
*opaque_list_pop(CHDContext
*priv
, uint64_t fake_timestamp
)
268 OpaqueList
*node
= priv
->head
;
271 av_log(priv
->avctx
, AV_LOG_ERROR
,
272 "CrystalHD: Attempted to query non-existent timestamps.\n");
277 * The first element is special-cased because we have to manipulate
278 * the head pointer rather than the previous element in the list.
280 if (priv
->head
->fake_timestamp
== fake_timestamp
) {
281 priv
->head
= node
->next
;
283 if (!priv
->head
->next
)
284 priv
->tail
= priv
->head
;
291 * The list is processed at arm's length so that we have the
292 * previous element available to rewrite its next pointer.
295 OpaqueList
*current
= node
->next
;
296 if (current
->fake_timestamp
== fake_timestamp
) {
297 node
->next
= current
->next
;
302 current
->next
= NULL
;
309 av_log(priv
->avctx
, AV_LOG_VERBOSE
,
310 "CrystalHD: Couldn't match fake_timestamp.\n");
315 /*****************************************************************************
316 * Video decoder API function definitions
317 ****************************************************************************/
319 static void flush(AVCodecContext
*avctx
)
321 CHDContext
*priv
= avctx
->priv_data
;
323 avctx
->has_b_frames
= 0;
324 priv
->last_picture
= -1;
325 priv
->output_ready
= 0;
326 priv
->need_second_field
= 0;
327 priv
->skip_next_output
= 0;
328 priv
->decode_wait
= BASE_WAIT
;
330 av_frame_unref (priv
->pic
);
332 /* Flush mode 4 flushes all software and hardware buffers. */
333 DtsFlushInput(priv
->dev
, 4);
337 static av_cold
int uninit(AVCodecContext
*avctx
)
339 CHDContext
*priv
= avctx
->priv_data
;
343 DtsStopDecoder(device
);
344 DtsCloseDecoder(device
);
345 DtsDeviceClose(device
);
348 * Restore original extradata, so that if the decoder is
349 * reinitialised, the bitstream detection and filtering
350 * will work as expected.
352 if (priv
->orig_extradata
) {
353 av_free(avctx
->extradata
);
354 avctx
->extradata
= priv
->orig_extradata
;
355 avctx
->extradata_size
= priv
->orig_extradata_size
;
356 priv
->orig_extradata
= NULL
;
357 priv
->orig_extradata_size
= 0;
360 av_parser_close(priv
->parser
);
362 av_bitstream_filter_close(priv
->bsfc
);
365 av_freep(&priv
->sps_pps_buf
);
367 av_frame_free (&priv
->pic
);
370 OpaqueList
*node
= priv
->head
;
372 OpaqueList
*next
= node
->next
;
382 static av_cold
int init(AVCodecContext
*avctx
)
386 BC_INFO_CRYSTAL version
;
387 BC_INPUT_FORMAT format
= {
390 .OptFlags
= 0x80000000 | vdecFrameRate59_94
| 0x40,
391 .width
= avctx
->width
,
392 .height
= avctx
->height
,
395 BC_MEDIA_SUBTYPE subtype
;
397 uint32_t mode
= DTS_PLAYBACK_MODE
|
398 DTS_LOAD_FILE_PLAY_FW
|
399 DTS_SKIP_TX_CHK_CPB
|
400 DTS_PLAYBACK_DROP_RPT_MODE
|
401 DTS_SINGLE_THREADED_MODE
|
402 DTS_DFLT_RESOLUTION(vdecRESOLUTION_1080p23_976
);
404 av_log(avctx
, AV_LOG_VERBOSE
, "CrystalHD Init for %s\n",
407 avctx
->pix_fmt
= AV_PIX_FMT_YUYV422
;
409 /* Initialize the library */
410 priv
= avctx
->priv_data
;
412 priv
->is_nal
= avctx
->extradata_size
> 0 && *(avctx
->extradata
) == 1;
413 priv
->last_picture
= -1;
414 priv
->decode_wait
= BASE_WAIT
;
415 priv
->pic
= av_frame_alloc();
417 subtype
= id2subtype(priv
, avctx
->codec
->id
);
419 case BC_MSUBTYPE_AVC1
:
424 /* Back up the extradata so it can be restored at close time. */
425 priv
->orig_extradata
= av_malloc(avctx
->extradata_size
+ FF_INPUT_BUFFER_PADDING_SIZE
);
426 if (!priv
->orig_extradata
) {
427 av_log(avctx
, AV_LOG_ERROR
,
428 "Failed to allocate copy of extradata\n");
429 return AVERROR(ENOMEM
);
431 priv
->orig_extradata_size
= avctx
->extradata_size
;
432 memcpy(priv
->orig_extradata
, avctx
->extradata
, avctx
->extradata_size
);
434 priv
->bsfc
= av_bitstream_filter_init("h264_mp4toannexb");
436 av_log(avctx
, AV_LOG_ERROR
,
437 "Cannot open the h264_mp4toannexb BSF!\n");
438 return AVERROR_BSF_NOT_FOUND
;
440 av_bitstream_filter_filter(priv
->bsfc
, avctx
, NULL
, &dummy_p
,
441 &dummy_int
, NULL
, 0, 0);
443 subtype
= BC_MSUBTYPE_H264
;
445 case BC_MSUBTYPE_H264
:
446 format
.startCodeSz
= 4;
448 case BC_MSUBTYPE_VC1
:
449 case BC_MSUBTYPE_WVC1
:
450 case BC_MSUBTYPE_WMV3
:
451 case BC_MSUBTYPE_WMVA
:
452 case BC_MSUBTYPE_MPEG2VIDEO
:
453 case BC_MSUBTYPE_DIVX
:
454 case BC_MSUBTYPE_DIVX311
:
455 format
.pMetaData
= avctx
->extradata
;
456 format
.metaDataSz
= avctx
->extradata_size
;
459 av_log(avctx
, AV_LOG_ERROR
, "CrystalHD: Unknown codec name\n");
460 return AVERROR(EINVAL
);
462 format
.mSubtype
= subtype
;
465 format
.bEnableScaling
= 1;
466 format
.ScalingParams
.sWidth
= priv
->sWidth
;
469 /* Get a decoder instance */
470 av_log(avctx
, AV_LOG_VERBOSE
, "CrystalHD: starting up\n");
471 // Initialize the Link and Decoder devices
472 ret
= DtsDeviceOpen(&priv
->dev
, mode
);
473 if (ret
!= BC_STS_SUCCESS
) {
474 av_log(avctx
, AV_LOG_VERBOSE
, "CrystalHD: DtsDeviceOpen failed\n");
478 ret
= DtsCrystalHDVersion(priv
->dev
, &version
);
479 if (ret
!= BC_STS_SUCCESS
) {
480 av_log(avctx
, AV_LOG_VERBOSE
,
481 "CrystalHD: DtsCrystalHDVersion failed\n");
484 priv
->is_70012
= version
.device
== 0;
486 if (priv
->is_70012
&&
487 (subtype
== BC_MSUBTYPE_DIVX
|| subtype
== BC_MSUBTYPE_DIVX311
)) {
488 av_log(avctx
, AV_LOG_VERBOSE
,
489 "CrystalHD: BCM70012 doesn't support MPEG4-ASP/DivX/Xvid\n");
493 ret
= DtsSetInputFormat(priv
->dev
, &format
);
494 if (ret
!= BC_STS_SUCCESS
) {
495 av_log(avctx
, AV_LOG_ERROR
, "CrystalHD: SetInputFormat failed\n");
499 ret
= DtsOpenDecoder(priv
->dev
, BC_STREAM_TYPE_ES
);
500 if (ret
!= BC_STS_SUCCESS
) {
501 av_log(avctx
, AV_LOG_ERROR
, "CrystalHD: DtsOpenDecoder failed\n");
505 ret
= DtsSetColorSpace(priv
->dev
, OUTPUT_MODE422_YUY2
);
506 if (ret
!= BC_STS_SUCCESS
) {
507 av_log(avctx
, AV_LOG_ERROR
, "CrystalHD: DtsSetColorSpace failed\n");
510 ret
= DtsStartDecoder(priv
->dev
);
511 if (ret
!= BC_STS_SUCCESS
) {
512 av_log(avctx
, AV_LOG_ERROR
, "CrystalHD: DtsStartDecoder failed\n");
515 ret
= DtsStartCapture(priv
->dev
);
516 if (ret
!= BC_STS_SUCCESS
) {
517 av_log(avctx
, AV_LOG_ERROR
, "CrystalHD: DtsStartCapture failed\n");
521 if (avctx
->codec
->id
== AV_CODEC_ID_H264
) {
522 priv
->parser
= av_parser_init(avctx
->codec
->id
);
524 av_log(avctx
, AV_LOG_WARNING
,
525 "Cannot open the h.264 parser! Interlaced h.264 content "
526 "will not be detected reliably.\n");
527 priv
->parser
->flags
= PARSER_FLAG_COMPLETE_FRAMES
;
529 av_log(avctx
, AV_LOG_VERBOSE
, "CrystalHD: Init complete.\n");
539 static inline CopyRet
copy_frame(AVCodecContext
*avctx
,
540 BC_DTS_PROC_OUT
*output
,
541 void *data
, int *got_frame
)
544 BC_DTS_STATUS decoder_status
= { 0, };
545 uint8_t trust_interlaced
;
548 CHDContext
*priv
= avctx
->priv_data
;
549 int64_t pkt_pts
= AV_NOPTS_VALUE
;
550 uint8_t pic_type
= 0;
552 uint8_t bottom_field
= (output
->PicInfo
.flags
& VDEC_FLAG_BOTTOMFIELD
) ==
553 VDEC_FLAG_BOTTOMFIELD
;
554 uint8_t bottom_first
= !!(output
->PicInfo
.flags
& VDEC_FLAG_BOTTOM_FIRST
);
556 int width
= output
->PicInfo
.width
;
557 int height
= output
->PicInfo
.height
;
559 uint8_t *src
= output
->Ybuff
;
564 if (output
->PicInfo
.timeStamp
!= 0) {
565 OpaqueList
*node
= opaque_list_pop(priv
, output
->PicInfo
.timeStamp
);
567 pkt_pts
= node
->reordered_opaque
;
568 pic_type
= node
->pic_type
;
572 * We will encounter a situation where a timestamp cannot be
573 * popped if a second field is being returned. In this case,
574 * each field has the same timestamp and the first one will
575 * cause it to be popped. To keep subsequent calculations
576 * simple, pic_type should be set a FIELD value - doesn't
577 * matter which, but I chose BOTTOM.
579 pic_type
= PICT_BOTTOM_FIELD
;
581 av_log(avctx
, AV_LOG_VERBOSE
, "output \"pts\": %"PRIu64
"\n",
582 output
->PicInfo
.timeStamp
);
583 av_log(avctx
, AV_LOG_VERBOSE
, "output picture type %d\n",
587 ret
= DtsGetDriverStatus(priv
->dev
, &decoder_status
);
588 if (ret
!= BC_STS_SUCCESS
) {
589 av_log(avctx
, AV_LOG_ERROR
,
590 "CrystalHD: GetDriverStatus failed: %u\n", ret
);
595 * For most content, we can trust the interlaced flag returned
596 * by the hardware, but sometimes we can't. These are the
597 * conditions under which we can trust the flag:
599 * 1) It's not h.264 content
600 * 2) The UNKNOWN_SRC flag is not set
601 * 3) We know we're expecting a second field
602 * 4) The hardware reports this picture and the next picture
603 * have the same picture number.
605 * Note that there can still be interlaced content that will
606 * fail this check, if the hardware hasn't decoded the next
607 * picture or if there is a corruption in the stream. (In either
608 * case a 0 will be returned for the next picture number)
610 trust_interlaced
= avctx
->codec
->id
!= AV_CODEC_ID_H264
||
611 !(output
->PicInfo
.flags
& VDEC_FLAG_UNKNOWN_SRC
) ||
612 priv
->need_second_field
||
613 (decoder_status
.picNumFlags
& ~0x40000000) ==
614 output
->PicInfo
.picture_number
;
617 * If we got a false negative for trust_interlaced on the first field,
618 * we will realise our mistake here when we see that the picture number is that
619 * of the previous picture. We cannot recover the frame and should discard the
620 * second field to keep the correct number of output frames.
622 if (output
->PicInfo
.picture_number
== priv
->last_picture
&& !priv
->need_second_field
) {
623 av_log(avctx
, AV_LOG_WARNING
,
624 "Incorrectly guessed progressive frame. Discarding second field\n");
625 /* Returning without providing a picture. */
629 interlaced
= (output
->PicInfo
.flags
& VDEC_FLAG_INTERLACED_SRC
) &&
632 if (!trust_interlaced
&& (decoder_status
.picNumFlags
& ~0x40000000) == 0) {
633 av_log(avctx
, AV_LOG_VERBOSE
,
634 "Next picture number unknown. Assuming progressive frame.\n");
637 av_log(avctx
, AV_LOG_VERBOSE
, "Interlaced state: %d | trust_interlaced %d\n",
638 interlaced
, trust_interlaced
);
640 if (priv
->pic
->data
[0] && !priv
->need_second_field
)
641 av_frame_unref(priv
->pic
);
643 priv
->need_second_field
= interlaced
&& !priv
->need_second_field
;
645 if (!priv
->pic
->data
[0]) {
646 if (ff_get_buffer(avctx
, priv
->pic
, AV_GET_BUFFER_FLAG_REF
) < 0)
650 bwidth
= av_image_get_linesize(avctx
->pix_fmt
, width
, 0);
651 if (priv
->is_70012
) {
656 else if (width
<= 1280)
659 sStride
= av_image_get_linesize(avctx
->pix_fmt
, pStride
, 0);
664 dStride
= priv
->pic
->linesize
[0];
665 dst
= priv
->pic
->data
[0];
667 av_log(priv
->avctx
, AV_LOG_VERBOSE
, "CrystalHD: Copying out frame\n");
675 av_log(priv
->avctx
, AV_LOG_VERBOSE
, "Interlaced: bottom field\n");
678 av_log(priv
->avctx
, AV_LOG_VERBOSE
, "Interlaced: top field\n");
682 for (sY
= 0; sY
< height
; dY
++, sY
++) {
683 memcpy(&(dst
[dY
* dStride
]), &(src
[sY
* sStride
]), bwidth
);
687 av_image_copy_plane(dst
, dStride
, src
, sStride
, bwidth
, height
);
690 priv
->pic
->interlaced_frame
= interlaced
;
692 priv
->pic
->top_field_first
= !bottom_first
;
694 priv
->pic
->pkt_pts
= pkt_pts
;
696 if (!priv
->need_second_field
) {
698 if ((ret
= av_frame_ref(data
, priv
->pic
)) < 0) {
704 * Two types of PAFF content have been observed. One form causes the
705 * hardware to return a field pair and the other individual fields,
706 * even though the input is always individual fields. We must skip
707 * copying on the next decode() call to maintain pipeline length in
710 if (!interlaced
&& (output
->PicInfo
.flags
& VDEC_FLAG_UNKNOWN_SRC
) &&
711 (pic_type
== PICT_TOP_FIELD
|| pic_type
== PICT_BOTTOM_FIELD
)) {
712 av_log(priv
->avctx
, AV_LOG_VERBOSE
, "Fieldpair from two packets.\n");
713 return RET_SKIP_NEXT_COPY
;
717 * The logic here is purely based on empirical testing with samples.
718 * If we need a second field, it could come from a second input packet,
719 * or it could come from the same field-pair input packet at the current
720 * field. In the first case, we should return and wait for the next time
721 * round to get the second field, while in the second case, we should
722 * ask the decoder for it immediately.
724 * Testing has shown that we are dealing with the fieldpair -> two fields
725 * case if the VDEC_FLAG_UNKNOWN_SRC is not set or if the input picture
726 * type was PICT_FRAME (in this second case, the flag might still be set)
728 return priv
->need_second_field
&&
729 (!(output
->PicInfo
.flags
& VDEC_FLAG_UNKNOWN_SRC
) ||
730 pic_type
== PICT_FRAME
) ?
731 RET_COPY_NEXT_FIELD
: RET_OK
;
735 static inline CopyRet
receive_frame(AVCodecContext
*avctx
,
736 void *data
, int *got_frame
)
739 BC_DTS_PROC_OUT output
= {
740 .PicInfo
.width
= avctx
->width
,
741 .PicInfo
.height
= avctx
->height
,
743 CHDContext
*priv
= avctx
->priv_data
;
744 HANDLE dev
= priv
->dev
;
748 // Request decoded data from the driver
749 ret
= DtsProcOutputNoCopy(dev
, OUTPUT_PROC_TIMEOUT
, &output
);
750 if (ret
== BC_STS_FMT_CHANGE
) {
751 av_log(avctx
, AV_LOG_VERBOSE
, "CrystalHD: Initial format change\n");
752 avctx
->width
= output
.PicInfo
.width
;
753 avctx
->height
= output
.PicInfo
.height
;
754 switch ( output
.PicInfo
.aspect_ratio
) {
755 case vdecAspectRatioSquare
:
756 avctx
->sample_aspect_ratio
= (AVRational
) { 1, 1};
758 case vdecAspectRatio12_11
:
759 avctx
->sample_aspect_ratio
= (AVRational
) { 12, 11};
761 case vdecAspectRatio10_11
:
762 avctx
->sample_aspect_ratio
= (AVRational
) { 10, 11};
764 case vdecAspectRatio16_11
:
765 avctx
->sample_aspect_ratio
= (AVRational
) { 16, 11};
767 case vdecAspectRatio40_33
:
768 avctx
->sample_aspect_ratio
= (AVRational
) { 40, 33};
770 case vdecAspectRatio24_11
:
771 avctx
->sample_aspect_ratio
= (AVRational
) { 24, 11};
773 case vdecAspectRatio20_11
:
774 avctx
->sample_aspect_ratio
= (AVRational
) { 20, 11};
776 case vdecAspectRatio32_11
:
777 avctx
->sample_aspect_ratio
= (AVRational
) { 32, 11};
779 case vdecAspectRatio80_33
:
780 avctx
->sample_aspect_ratio
= (AVRational
) { 80, 33};
782 case vdecAspectRatio18_11
:
783 avctx
->sample_aspect_ratio
= (AVRational
) { 18, 11};
785 case vdecAspectRatio15_11
:
786 avctx
->sample_aspect_ratio
= (AVRational
) { 15, 11};
788 case vdecAspectRatio64_33
:
789 avctx
->sample_aspect_ratio
= (AVRational
) { 64, 33};
791 case vdecAspectRatio160_99
:
792 avctx
->sample_aspect_ratio
= (AVRational
) {160, 99};
794 case vdecAspectRatio4_3
:
795 avctx
->sample_aspect_ratio
= (AVRational
) { 4, 3};
797 case vdecAspectRatio16_9
:
798 avctx
->sample_aspect_ratio
= (AVRational
) { 16, 9};
800 case vdecAspectRatio221_1
:
801 avctx
->sample_aspect_ratio
= (AVRational
) {221, 1};
804 return RET_COPY_AGAIN
;
805 } else if (ret
== BC_STS_SUCCESS
) {
807 if (output
.PoutFlags
& BC_POUT_FLAGS_PIB_VALID
) {
808 if (priv
->last_picture
== -1) {
810 * Init to one less, so that the incrementing code doesn't
811 * need to be special-cased.
813 priv
->last_picture
= output
.PicInfo
.picture_number
- 1;
816 if (avctx
->codec
->id
== AV_CODEC_ID_MPEG4
&&
817 output
.PicInfo
.timeStamp
== 0 && priv
->bframe_bug
) {
818 av_log(avctx
, AV_LOG_VERBOSE
,
819 "CrystalHD: Not returning packed frame twice.\n");
820 priv
->last_picture
++;
821 DtsReleaseOutputBuffs(dev
, NULL
, FALSE
);
822 return RET_COPY_AGAIN
;
825 print_frame_info(priv
, &output
);
827 if (priv
->last_picture
+ 1 < output
.PicInfo
.picture_number
) {
828 av_log(avctx
, AV_LOG_WARNING
,
829 "CrystalHD: Picture Number discontinuity\n");
831 * Have we lost frames? If so, we need to shrink the
832 * pipeline length appropriately.
834 * XXX: I have no idea what the semantics of this situation
835 * are so I don't even know if we've lost frames or which
838 * In any case, only warn the first time.
840 priv
->last_picture
= output
.PicInfo
.picture_number
- 1;
843 copy_ret
= copy_frame(avctx
, &output
, data
, got_frame
);
844 if (*got_frame
> 0) {
845 avctx
->has_b_frames
--;
846 priv
->last_picture
++;
847 av_log(avctx
, AV_LOG_VERBOSE
, "CrystalHD: Pipeline length: %u\n",
848 avctx
->has_b_frames
);
852 * An invalid frame has been consumed.
854 av_log(avctx
, AV_LOG_ERROR
, "CrystalHD: ProcOutput succeeded with "
856 avctx
->has_b_frames
--;
859 DtsReleaseOutputBuffs(dev
, NULL
, FALSE
);
862 } else if (ret
== BC_STS_BUSY
) {
863 return RET_COPY_AGAIN
;
865 av_log(avctx
, AV_LOG_ERROR
, "CrystalHD: ProcOutput failed %d\n", ret
);
871 static int decode(AVCodecContext
*avctx
, void *data
, int *got_frame
, AVPacket
*avpkt
)
874 BC_DTS_STATUS decoder_status
= { 0, };
876 CHDContext
*priv
= avctx
->priv_data
;
877 HANDLE dev
= priv
->dev
;
878 uint8_t *in_data
= avpkt
->data
;
879 int len
= avpkt
->size
;
881 uint8_t pic_type
= 0;
883 av_log(avctx
, AV_LOG_VERBOSE
, "CrystalHD: decode_frame\n");
885 if (avpkt
->size
== 7 && !priv
->bframe_bug
) {
887 * The use of a drop frame triggers the bug
889 av_log(avctx
, AV_LOG_INFO
,
890 "CrystalHD: Enabling work-around for packed b-frame bug\n");
891 priv
->bframe_bug
= 1;
892 } else if (avpkt
->size
== 8 && priv
->bframe_bug
) {
894 * Delay frames don't trigger the bug
896 av_log(avctx
, AV_LOG_INFO
,
897 "CrystalHD: Disabling work-around for packed b-frame bug\n");
898 priv
->bframe_bug
= 0;
902 int32_t tx_free
= (int32_t)DtsTxFreeSize(dev
);
908 ret
= av_bitstream_filter_filter(priv
->bsfc
, avctx
, NULL
,
910 avpkt
->data
, len
, 0);
918 H264Context
*h
= priv
->parser
->priv_data
;
920 index
= av_parser_parse2(priv
->parser
, avctx
, &pout
, &psize
,
921 in_data
, len
, avctx
->internal
->pkt
->pts
,
922 avctx
->internal
->pkt
->dts
, 0);
924 av_log(avctx
, AV_LOG_WARNING
,
925 "CrystalHD: Failed to parse h.264 packet to "
926 "detect interlacing.\n");
927 } else if (index
!= len
) {
928 av_log(avctx
, AV_LOG_WARNING
,
929 "CrystalHD: Failed to parse h.264 packet "
930 "completely. Interlaced frames may be "
931 "incorrectly detected.\n");
933 av_log(avctx
, AV_LOG_VERBOSE
,
934 "CrystalHD: parser picture type %d\n",
935 h
->picture_structure
);
936 pic_type
= h
->picture_structure
;
939 av_log(avctx
, AV_LOG_WARNING
,
940 "CrystalHD: mp4toannexb filter failed to filter "
941 "packet. Interlaced frames may be incorrectly "
946 if (len
< tx_free
- 1024) {
948 * Despite being notionally opaque, either libcrystalhd or
949 * the hardware itself will mangle pts values that are too
950 * small or too large. The docs claim it should be in units
951 * of 100ns. Given that we're nominally dealing with a black
952 * box on both sides, any transform we do has no guarantee of
953 * avoiding mangling so we need to build a mapping to values
954 * we know will not be mangled.
956 uint64_t pts
= opaque_list_push(priv
, avctx
->internal
->pkt
->pts
, pic_type
);
961 return AVERROR(ENOMEM
);
963 av_log(priv
->avctx
, AV_LOG_VERBOSE
,
964 "input \"pts\": %"PRIu64
"\n", pts
);
965 ret
= DtsProcInput(dev
, in_data
, len
, pts
, 0);
969 if (ret
== BC_STS_BUSY
) {
970 av_log(avctx
, AV_LOG_WARNING
,
971 "CrystalHD: ProcInput returned busy\n");
973 return AVERROR(EBUSY
);
974 } else if (ret
!= BC_STS_SUCCESS
) {
975 av_log(avctx
, AV_LOG_ERROR
,
976 "CrystalHD: ProcInput failed: %u\n", ret
);
979 avctx
->has_b_frames
++;
981 av_log(avctx
, AV_LOG_WARNING
, "CrystalHD: Input buffer full\n");
982 len
= 0; // We didn't consume any bytes.
985 av_log(avctx
, AV_LOG_INFO
, "CrystalHD: No more input data\n");
988 if (priv
->skip_next_output
) {
989 av_log(avctx
, AV_LOG_VERBOSE
, "CrystalHD: Skipping next output.\n");
990 priv
->skip_next_output
= 0;
991 avctx
->has_b_frames
--;
995 ret
= DtsGetDriverStatus(dev
, &decoder_status
);
996 if (ret
!= BC_STS_SUCCESS
) {
997 av_log(avctx
, AV_LOG_ERROR
, "CrystalHD: GetDriverStatus failed\n");
1002 * No frames ready. Don't try to extract.
1004 * Empirical testing shows that ReadyListCount can be a damn lie,
1005 * and ProcOut still fails when count > 0. The same testing showed
1006 * that two more iterations were needed before ProcOutput would
1009 if (priv
->output_ready
< 2) {
1010 if (decoder_status
.ReadyListCount
!= 0)
1011 priv
->output_ready
++;
1013 av_log(avctx
, AV_LOG_INFO
, "CrystalHD: Filling pipeline.\n");
1015 } else if (decoder_status
.ReadyListCount
== 0) {
1017 * After the pipeline is established, if we encounter a lack of frames
1018 * that probably means we're not giving the hardware enough time to
1019 * decode them, so start increasing the wait time at the end of a
1023 priv
->decode_wait
+= WAIT_UNIT
;
1024 av_log(avctx
, AV_LOG_INFO
, "CrystalHD: No frames ready. Returning\n");
1029 rec_ret
= receive_frame(avctx
, data
, got_frame
);
1030 if (rec_ret
== RET_OK
&& *got_frame
== 0) {
1032 * This case is for when the encoded fields are stored
1033 * separately and we get a separate avpkt for each one. To keep
1034 * the pipeline stable, we should return nothing and wait for
1035 * the next time round to grab the second field.
1036 * H.264 PAFF is an example of this.
1038 av_log(avctx
, AV_LOG_VERBOSE
, "Returning after first field.\n");
1039 avctx
->has_b_frames
--;
1040 } else if (rec_ret
== RET_COPY_NEXT_FIELD
) {
1042 * This case is for when the encoded fields are stored in a
1043 * single avpkt but the hardware returns then separately. Unless
1044 * we grab the second field before returning, we'll slip another
1045 * frame in the pipeline and if that happens a lot, we're sunk.
1046 * So we have to get that second field now.
1047 * Interlaced mpeg2 and vc1 are examples of this.
1049 av_log(avctx
, AV_LOG_VERBOSE
, "Trying to get second field.\n");
1051 usleep(priv
->decode_wait
);
1052 ret
= DtsGetDriverStatus(dev
, &decoder_status
);
1053 if (ret
== BC_STS_SUCCESS
&&
1054 decoder_status
.ReadyListCount
> 0) {
1055 rec_ret
= receive_frame(avctx
, data
, got_frame
);
1056 if ((rec_ret
== RET_OK
&& *got_frame
> 0) ||
1057 rec_ret
== RET_ERROR
)
1061 av_log(avctx
, AV_LOG_VERBOSE
, "CrystalHD: Got second field.\n");
1062 } else if (rec_ret
== RET_SKIP_NEXT_COPY
) {
1064 * Two input packets got turned into a field pair. Gawd.
1066 av_log(avctx
, AV_LOG_VERBOSE
,
1067 "Don't output on next decode call.\n");
1068 priv
->skip_next_output
= 1;
1071 * If rec_ret == RET_COPY_AGAIN, that means that either we just handled
1072 * a FMT_CHANGE event and need to go around again for the actual frame,
1073 * we got a busy status and need to try again, or we're dealing with
1074 * packed b-frames, where the hardware strangely returns the packed
1075 * p-frame twice. We choose to keep the second copy as it carries the
1078 } while (rec_ret
== RET_COPY_AGAIN
);
1079 usleep(priv
->decode_wait
);
1084 #if CONFIG_H264_CRYSTALHD_DECODER
1085 static AVClass h264_class
= {
1087 av_default_item_name
,
1089 LIBAVUTIL_VERSION_INT
,
1092 AVCodec ff_h264_crystalhd_decoder
= {
1093 .name
= "h264_crystalhd",
1094 .long_name
= NULL_IF_CONFIG_SMALL("H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10 (CrystalHD acceleration)"),
1095 .type
= AVMEDIA_TYPE_VIDEO
,
1096 .id
= AV_CODEC_ID_H264
,
1097 .priv_data_size
= sizeof(CHDContext
),
1101 .capabilities
= CODEC_CAP_DR1
| CODEC_CAP_DELAY
,
1103 .pix_fmts
= (const enum AVPixelFormat
[]){AV_PIX_FMT_YUYV422
, AV_PIX_FMT_NONE
},
1104 .priv_class
= &h264_class
,
1108 #if CONFIG_MPEG2_CRYSTALHD_DECODER
1109 static AVClass mpeg2_class
= {
1111 av_default_item_name
,
1113 LIBAVUTIL_VERSION_INT
,
1116 AVCodec ff_mpeg2_crystalhd_decoder
= {
1117 .name
= "mpeg2_crystalhd",
1118 .long_name
= NULL_IF_CONFIG_SMALL("MPEG-2 Video (CrystalHD acceleration)"),
1119 .type
= AVMEDIA_TYPE_VIDEO
,
1120 .id
= AV_CODEC_ID_MPEG2VIDEO
,
1121 .priv_data_size
= sizeof(CHDContext
),
1125 .capabilities
= CODEC_CAP_DR1
| CODEC_CAP_DELAY
,
1127 .pix_fmts
= (const enum AVPixelFormat
[]){AV_PIX_FMT_YUYV422
, AV_PIX_FMT_NONE
},
1128 .priv_class
= &mpeg2_class
,
1132 #if CONFIG_MPEG4_CRYSTALHD_DECODER
1133 static AVClass mpeg4_class
= {
1135 av_default_item_name
,
1137 LIBAVUTIL_VERSION_INT
,
1140 AVCodec ff_mpeg4_crystalhd_decoder
= {
1141 .name
= "mpeg4_crystalhd",
1142 .long_name
= NULL_IF_CONFIG_SMALL("MPEG-4 Part 2 (CrystalHD acceleration)"),
1143 .type
= AVMEDIA_TYPE_VIDEO
,
1144 .id
= AV_CODEC_ID_MPEG4
,
1145 .priv_data_size
= sizeof(CHDContext
),
1149 .capabilities
= CODEC_CAP_DR1
| CODEC_CAP_DELAY
,
1151 .pix_fmts
= (const enum AVPixelFormat
[]){AV_PIX_FMT_YUYV422
, AV_PIX_FMT_NONE
},
1152 .priv_class
= &mpeg4_class
,
1156 #if CONFIG_MSMPEG4_CRYSTALHD_DECODER
1157 static AVClass msmpeg4_class
= {
1158 "msmpeg4_crystalhd",
1159 av_default_item_name
,
1161 LIBAVUTIL_VERSION_INT
,
1164 AVCodec ff_msmpeg4_crystalhd_decoder
= {
1165 .name
= "msmpeg4_crystalhd",
1166 .long_name
= NULL_IF_CONFIG_SMALL("MPEG-4 Part 2 Microsoft variant version 3 (CrystalHD acceleration)"),
1167 .type
= AVMEDIA_TYPE_VIDEO
,
1168 .id
= AV_CODEC_ID_MSMPEG4V3
,
1169 .priv_data_size
= sizeof(CHDContext
),
1173 .capabilities
= CODEC_CAP_DR1
| CODEC_CAP_DELAY
| CODEC_CAP_EXPERIMENTAL
,
1175 .pix_fmts
= (const enum AVPixelFormat
[]){AV_PIX_FMT_YUYV422
, AV_PIX_FMT_NONE
},
1176 .priv_class
= &msmpeg4_class
,
1180 #if CONFIG_VC1_CRYSTALHD_DECODER
1181 static AVClass vc1_class
= {
1183 av_default_item_name
,
1185 LIBAVUTIL_VERSION_INT
,
1188 AVCodec ff_vc1_crystalhd_decoder
= {
1189 .name
= "vc1_crystalhd",
1190 .long_name
= NULL_IF_CONFIG_SMALL("SMPTE VC-1 (CrystalHD acceleration)"),
1191 .type
= AVMEDIA_TYPE_VIDEO
,
1192 .id
= AV_CODEC_ID_VC1
,
1193 .priv_data_size
= sizeof(CHDContext
),
1197 .capabilities
= CODEC_CAP_DR1
| CODEC_CAP_DELAY
,
1199 .pix_fmts
= (const enum AVPixelFormat
[]){AV_PIX_FMT_YUYV422
, AV_PIX_FMT_NONE
},
1200 .priv_class
= &vc1_class
,
1204 #if CONFIG_WMV3_CRYSTALHD_DECODER
1205 static AVClass wmv3_class
= {
1207 av_default_item_name
,
1209 LIBAVUTIL_VERSION_INT
,
1212 AVCodec ff_wmv3_crystalhd_decoder
= {
1213 .name
= "wmv3_crystalhd",
1214 .long_name
= NULL_IF_CONFIG_SMALL("Windows Media Video 9 (CrystalHD acceleration)"),
1215 .type
= AVMEDIA_TYPE_VIDEO
,
1216 .id
= AV_CODEC_ID_WMV3
,
1217 .priv_data_size
= sizeof(CHDContext
),
1221 .capabilities
= CODEC_CAP_DR1
| CODEC_CAP_DELAY
,
1223 .pix_fmts
= (const enum AVPixelFormat
[]){AV_PIX_FMT_YUYV422
, AV_PIX_FMT_NONE
},
1224 .priv_class
= &wmv3_class
,