dca58f2c8bd3c2b1eda489173fe81a3d74d83619
[ffmpeg.git] / libavcodec / crystalhd.c
1 /*
2  * - CrystalHD decoder module -
3  *
4  * Copyright(C) 2010,2011 Philip Langdale <ffmpeg.philipl@overt.org>
5  *
6  * This file is part of FFmpeg.
7  *
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.
12  *
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.
17  *
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
21  */
22
23 /*
24  * - Principles of Operation -
25  *
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.
30  *
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.
36  *
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.
40  *
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.
45  *
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.
53  *
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.
62  *
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).
70  */
71
72 /*****************************************************************************
73  * Includes
74  ****************************************************************************/
75
76 #define _XOPEN_SOURCE 600
77 #include <inttypes.h>
78 #include <stdio.h>
79 #include <stdlib.h>
80
81 #include <libcrystalhd/bc_dts_types.h>
82 #include <libcrystalhd/bc_dts_defs.h>
83 #include <libcrystalhd/libcrystalhd_if.h>
84
85 #include "avcodec.h"
86 #include "h264dec.h"
87 #include "internal.h"
88 #include "libavutil/imgutils.h"
89 #include "libavutil/intreadwrite.h"
90 #include "libavutil/opt.h"
91
92 #if HAVE_UNISTD_H
93 #include <unistd.h>
94 #endif
95
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
101
102 /*****************************************************************************
103  * Module private data
104  ****************************************************************************/
105
106 typedef enum {
107     RET_ERROR           = -1,
108     RET_OK              = 0,
109 } CopyRet;
110
111 typedef struct OpaqueList {
112     struct OpaqueList *next;
113     uint64_t fake_timestamp;
114     uint64_t reordered_opaque;
115     uint8_t pic_type;
116 } OpaqueList;
117
118 typedef struct {
119     AVClass *av_class;
120     AVCodecContext *avctx;
121     AVFrame *pic;
122     HANDLE dev;
123
124     uint8_t *orig_extradata;
125     uint32_t orig_extradata_size;
126
127     AVBSFContext *bsfc;
128     AVCodecParserContext *parser;
129
130     uint8_t is_70012;
131     uint8_t *sps_pps_buf;
132     uint32_t sps_pps_size;
133     uint8_t is_nal;
134     uint8_t need_second_field;
135
136     uint64_t last_picture;
137
138     OpaqueList *head;
139     OpaqueList *tail;
140
141     /* Options */
142     uint32_t sWidth;
143 } CHDContext;
144
145 static const AVOption options[] = {
146     { "crystalhd_downscale_width",
147       "Turn on downscaling to the specified width",
148       offsetof(CHDContext, sWidth),
149       AV_OPT_TYPE_INT, {.i64 = 0}, 0, UINT32_MAX,
150       AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM, },
151     { NULL, },
152 };
153
154
155 /*****************************************************************************
156  * Helper functions
157  ****************************************************************************/
158
159 static inline BC_MEDIA_SUBTYPE id2subtype(CHDContext *priv, enum AVCodecID id)
160 {
161     switch (id) {
162     case AV_CODEC_ID_MPEG4:
163         return BC_MSUBTYPE_DIVX;
164     case AV_CODEC_ID_MSMPEG4V3:
165         return BC_MSUBTYPE_DIVX311;
166     case AV_CODEC_ID_MPEG2VIDEO:
167         return BC_MSUBTYPE_MPEG2VIDEO;
168     case AV_CODEC_ID_VC1:
169         return BC_MSUBTYPE_VC1;
170     case AV_CODEC_ID_WMV3:
171         return BC_MSUBTYPE_WMV3;
172     case AV_CODEC_ID_H264:
173         return priv->is_nal ? BC_MSUBTYPE_AVC1 : BC_MSUBTYPE_H264;
174     default:
175         return BC_MSUBTYPE_INVALID;
176     }
177 }
178
179 static inline void print_frame_info(CHDContext *priv, BC_DTS_PROC_OUT *output)
180 {
181     av_log(priv->avctx, AV_LOG_TRACE, "\tYBuffSz: %u\n", output->YbuffSz);
182     av_log(priv->avctx, AV_LOG_TRACE, "\tYBuffDoneSz: %u\n",
183            output->YBuffDoneSz);
184     av_log(priv->avctx, AV_LOG_TRACE, "\tUVBuffDoneSz: %u\n",
185            output->UVBuffDoneSz);
186     av_log(priv->avctx, AV_LOG_TRACE, "\tTimestamp: %"PRIu64"\n",
187            output->PicInfo.timeStamp);
188     av_log(priv->avctx, AV_LOG_TRACE, "\tPicture Number: %u\n",
189            output->PicInfo.picture_number);
190     av_log(priv->avctx, AV_LOG_TRACE, "\tWidth: %u\n",
191            output->PicInfo.width);
192     av_log(priv->avctx, AV_LOG_TRACE, "\tHeight: %u\n",
193            output->PicInfo.height);
194     av_log(priv->avctx, AV_LOG_TRACE, "\tChroma: 0x%03x\n",
195            output->PicInfo.chroma_format);
196     av_log(priv->avctx, AV_LOG_TRACE, "\tPulldown: %u\n",
197            output->PicInfo.pulldown);
198     av_log(priv->avctx, AV_LOG_TRACE, "\tFlags: 0x%08x\n",
199            output->PicInfo.flags);
200     av_log(priv->avctx, AV_LOG_TRACE, "\tFrame Rate/Res: %u\n",
201            output->PicInfo.frame_rate);
202     av_log(priv->avctx, AV_LOG_TRACE, "\tAspect Ratio: %u\n",
203            output->PicInfo.aspect_ratio);
204     av_log(priv->avctx, AV_LOG_TRACE, "\tColor Primaries: %u\n",
205            output->PicInfo.colour_primaries);
206     av_log(priv->avctx, AV_LOG_TRACE, "\tMetaData: %u\n",
207            output->PicInfo.picture_meta_payload);
208     av_log(priv->avctx, AV_LOG_TRACE, "\tSession Number: %u\n",
209            output->PicInfo.sess_num);
210     av_log(priv->avctx, AV_LOG_TRACE, "\tycom: %u\n",
211            output->PicInfo.ycom);
212     av_log(priv->avctx, AV_LOG_TRACE, "\tCustom Aspect: %u\n",
213            output->PicInfo.custom_aspect_ratio_width_height);
214     av_log(priv->avctx, AV_LOG_TRACE, "\tFrames to Drop: %u\n",
215            output->PicInfo.n_drop);
216     av_log(priv->avctx, AV_LOG_TRACE, "\tH264 Valid Fields: 0x%08x\n",
217            output->PicInfo.other.h264.valid);
218 }
219
220
221 /*****************************************************************************
222  * OpaqueList functions
223  ****************************************************************************/
224
225 static uint64_t opaque_list_push(CHDContext *priv, uint64_t reordered_opaque,
226                                  uint8_t pic_type)
227 {
228     OpaqueList *newNode = av_mallocz(sizeof (OpaqueList));
229     if (!newNode) {
230         av_log(priv->avctx, AV_LOG_ERROR,
231                "Unable to allocate new node in OpaqueList.\n");
232         return 0;
233     }
234     if (!priv->head) {
235         newNode->fake_timestamp = TIMESTAMP_UNIT;
236         priv->head              = newNode;
237     } else {
238         newNode->fake_timestamp = priv->tail->fake_timestamp + TIMESTAMP_UNIT;
239         priv->tail->next        = newNode;
240     }
241     priv->tail = newNode;
242     newNode->reordered_opaque = reordered_opaque;
243     newNode->pic_type = pic_type;
244
245     return newNode->fake_timestamp;
246 }
247
248 /*
249  * The OpaqueList is built in decode order, while elements will be removed
250  * in presentation order. If frames are reordered, this means we must be
251  * able to remove elements that are not the first element.
252  *
253  * Returned node must be freed by caller.
254  */
255 static OpaqueList *opaque_list_pop(CHDContext *priv, uint64_t fake_timestamp)
256 {
257     OpaqueList *node = priv->head;
258
259     if (!priv->head) {
260         av_log(priv->avctx, AV_LOG_ERROR,
261                "CrystalHD: Attempted to query non-existent timestamps.\n");
262         return NULL;
263     }
264
265     /*
266      * The first element is special-cased because we have to manipulate
267      * the head pointer rather than the previous element in the list.
268      */
269     if (priv->head->fake_timestamp == fake_timestamp) {
270         priv->head = node->next;
271
272         if (!priv->head->next)
273             priv->tail = priv->head;
274
275         node->next = NULL;
276         return node;
277     }
278
279     /*
280      * The list is processed at arm's length so that we have the
281      * previous element available to rewrite its next pointer.
282      */
283     while (node->next) {
284         OpaqueList *current = node->next;
285         if (current->fake_timestamp == fake_timestamp) {
286             node->next = current->next;
287
288             if (!node->next)
289                priv->tail = node;
290
291             current->next = NULL;
292             return current;
293         } else {
294             node = current;
295         }
296     }
297
298     av_log(priv->avctx, AV_LOG_VERBOSE,
299            "CrystalHD: Couldn't match fake_timestamp.\n");
300     return NULL;
301 }
302
303
304 /*****************************************************************************
305  * Video decoder API function definitions
306  ****************************************************************************/
307
308 static void flush(AVCodecContext *avctx)
309 {
310     CHDContext *priv = avctx->priv_data;
311
312     priv->last_picture      = -1;
313     priv->need_second_field = 0;
314
315     av_frame_unref (priv->pic);
316
317     /* Flush mode 4 flushes all software and hardware buffers. */
318     DtsFlushInput(priv->dev, 4);
319 }
320
321
322 static av_cold int uninit(AVCodecContext *avctx)
323 {
324     CHDContext *priv = avctx->priv_data;
325     HANDLE device;
326
327     device = priv->dev;
328     DtsStopDecoder(device);
329     DtsCloseDecoder(device);
330     DtsDeviceClose(device);
331
332     /*
333      * Restore original extradata, so that if the decoder is
334      * reinitialised, the bitstream detection and filtering
335      * will work as expected.
336      */
337     if (priv->orig_extradata) {
338         av_free(avctx->extradata);
339         avctx->extradata = priv->orig_extradata;
340         avctx->extradata_size = priv->orig_extradata_size;
341         priv->orig_extradata = NULL;
342         priv->orig_extradata_size = 0;
343     }
344
345     av_parser_close(priv->parser);
346     if (priv->bsfc) {
347         av_bsf_free(&priv->bsfc);
348     }
349
350     av_freep(&priv->sps_pps_buf);
351
352     av_frame_free (&priv->pic);
353
354     if (priv->head) {
355        OpaqueList *node = priv->head;
356        while (node) {
357           OpaqueList *next = node->next;
358           av_free(node);
359           node = next;
360        }
361     }
362
363     return 0;
364 }
365
366
367 static av_cold int init_bsf(AVCodecContext *avctx, const char *bsf_name)
368 {
369     CHDContext *priv = avctx->priv_data;
370     const AVBitStreamFilter *bsf;
371     int avret;
372     void *extradata = NULL;
373     size_t size = 0;
374
375     bsf = av_bsf_get_by_name(bsf_name);
376     if (!bsf) {
377         av_log(avctx, AV_LOG_ERROR,
378                "Cannot open the %s BSF!\n", bsf_name);
379         return AVERROR_BSF_NOT_FOUND;
380     }
381
382     avret = av_bsf_alloc(bsf, &priv->bsfc);
383     if (avret != 0) {
384         return avret;
385     }
386
387     avret = avcodec_parameters_from_context(priv->bsfc->par_in, avctx);
388     if (avret != 0) {
389         return avret;
390     }
391
392     avret = av_bsf_init(priv->bsfc);
393     if (avret != 0) {
394         return avret;
395     }
396
397     /* Back up the extradata so it can be restored at close time. */
398     priv->orig_extradata = avctx->extradata;
399     priv->orig_extradata_size = avctx->extradata_size;
400
401     size = priv->bsfc->par_out->extradata_size;
402     extradata = av_malloc(size + AV_INPUT_BUFFER_PADDING_SIZE);
403     if (!extradata) {
404         av_log(avctx, AV_LOG_ERROR,
405                "Failed to allocate copy of extradata\n");
406         return AVERROR(ENOMEM);
407     }
408     memcpy(extradata, priv->bsfc->par_out->extradata, size);
409
410     avctx->extradata = extradata;
411     avctx->extradata_size = size;
412
413     return 0;
414 }
415
416 static av_cold int init(AVCodecContext *avctx)
417 {
418     CHDContext* priv;
419     int avret;
420     BC_STATUS ret;
421     BC_INFO_CRYSTAL version;
422     BC_INPUT_FORMAT format = {
423         .FGTEnable   = FALSE,
424         .Progressive = TRUE,
425         .OptFlags    = 0x80000000 | vdecFrameRate59_94 | 0x40,
426         .width       = avctx->width,
427         .height      = avctx->height,
428     };
429
430     BC_MEDIA_SUBTYPE subtype;
431
432     uint32_t mode = DTS_PLAYBACK_MODE |
433                     DTS_LOAD_FILE_PLAY_FW |
434                     DTS_SKIP_TX_CHK_CPB |
435                     DTS_PLAYBACK_DROP_RPT_MODE |
436                     DTS_SINGLE_THREADED_MODE |
437                     DTS_DFLT_RESOLUTION(vdecRESOLUTION_1080p23_976);
438
439     av_log(avctx, AV_LOG_VERBOSE, "CrystalHD Init for %s\n",
440            avctx->codec->name);
441
442     avctx->pix_fmt = AV_PIX_FMT_YUYV422;
443
444     /* Initialize the library */
445     priv               = avctx->priv_data;
446     priv->avctx        = avctx;
447     priv->is_nal       = avctx->extradata_size > 0 && *(avctx->extradata) == 1;
448     priv->last_picture = -1;
449     priv->pic          = av_frame_alloc();
450
451     subtype = id2subtype(priv, avctx->codec->id);
452     switch (subtype) {
453     case BC_MSUBTYPE_AVC1:
454         avret = init_bsf(avctx, "h264_mp4toannexb");
455         if (avret != 0) {
456             return avret;
457         }
458         subtype = BC_MSUBTYPE_H264;
459         format.startCodeSz = 4;
460         format.pMetaData  = avctx->extradata;
461         format.metaDataSz = avctx->extradata_size;
462         break;
463     case BC_MSUBTYPE_DIVX:
464         avret = init_bsf(avctx, "mpeg4_unpack_bframes");
465         if (avret != 0) {
466             return avret;
467         }
468         format.pMetaData  = avctx->extradata;
469         format.metaDataSz = avctx->extradata_size;
470         break;
471     case BC_MSUBTYPE_H264:
472         format.startCodeSz = 4;
473         // Fall-through
474     case BC_MSUBTYPE_VC1:
475     case BC_MSUBTYPE_WVC1:
476     case BC_MSUBTYPE_WMV3:
477     case BC_MSUBTYPE_WMVA:
478     case BC_MSUBTYPE_MPEG2VIDEO:
479     case BC_MSUBTYPE_DIVX311:
480         format.pMetaData  = avctx->extradata;
481         format.metaDataSz = avctx->extradata_size;
482         break;
483     default:
484         av_log(avctx, AV_LOG_ERROR, "CrystalHD: Unknown codec name\n");
485         return AVERROR(EINVAL);
486     }
487     format.mSubtype = subtype;
488
489     if (priv->sWidth) {
490         format.bEnableScaling = 1;
491         format.ScalingParams.sWidth = priv->sWidth;
492     }
493
494     /* Get a decoder instance */
495     av_log(avctx, AV_LOG_VERBOSE, "CrystalHD: starting up\n");
496     // Initialize the Link and Decoder devices
497     ret = DtsDeviceOpen(&priv->dev, mode);
498     if (ret != BC_STS_SUCCESS) {
499         av_log(avctx, AV_LOG_VERBOSE, "CrystalHD: DtsDeviceOpen failed\n");
500         goto fail;
501     }
502
503     ret = DtsCrystalHDVersion(priv->dev, &version);
504     if (ret != BC_STS_SUCCESS) {
505         av_log(avctx, AV_LOG_VERBOSE,
506                "CrystalHD: DtsCrystalHDVersion failed\n");
507         goto fail;
508     }
509     priv->is_70012 = version.device == 0;
510
511     if (priv->is_70012 &&
512         (subtype == BC_MSUBTYPE_DIVX || subtype == BC_MSUBTYPE_DIVX311)) {
513         av_log(avctx, AV_LOG_VERBOSE,
514                "CrystalHD: BCM70012 doesn't support MPEG4-ASP/DivX/Xvid\n");
515         goto fail;
516     }
517
518     ret = DtsSetInputFormat(priv->dev, &format);
519     if (ret != BC_STS_SUCCESS) {
520         av_log(avctx, AV_LOG_ERROR, "CrystalHD: SetInputFormat failed\n");
521         goto fail;
522     }
523
524     ret = DtsOpenDecoder(priv->dev, BC_STREAM_TYPE_ES);
525     if (ret != BC_STS_SUCCESS) {
526         av_log(avctx, AV_LOG_ERROR, "CrystalHD: DtsOpenDecoder failed\n");
527         goto fail;
528     }
529
530     ret = DtsSetColorSpace(priv->dev, OUTPUT_MODE422_YUY2);
531     if (ret != BC_STS_SUCCESS) {
532         av_log(avctx, AV_LOG_ERROR, "CrystalHD: DtsSetColorSpace failed\n");
533         goto fail;
534     }
535     ret = DtsStartDecoder(priv->dev);
536     if (ret != BC_STS_SUCCESS) {
537         av_log(avctx, AV_LOG_ERROR, "CrystalHD: DtsStartDecoder failed\n");
538         goto fail;
539     }
540     ret = DtsStartCapture(priv->dev);
541     if (ret != BC_STS_SUCCESS) {
542         av_log(avctx, AV_LOG_ERROR, "CrystalHD: DtsStartCapture failed\n");
543         goto fail;
544     }
545
546     if (avctx->codec->id == AV_CODEC_ID_H264) {
547         priv->parser = av_parser_init(avctx->codec->id);
548         if (!priv->parser)
549             av_log(avctx, AV_LOG_WARNING,
550                    "Cannot open the h.264 parser! Interlaced h.264 content "
551                    "will not be detected reliably.\n");
552         priv->parser->flags = PARSER_FLAG_COMPLETE_FRAMES;
553     }
554     av_log(avctx, AV_LOG_VERBOSE, "CrystalHD: Init complete.\n");
555
556     return 0;
557
558  fail:
559     uninit(avctx);
560     return -1;
561 }
562
563
564 static inline CopyRet copy_frame(AVCodecContext *avctx,
565                                  BC_DTS_PROC_OUT *output,
566                                  void *data, int *got_frame)
567 {
568     BC_STATUS ret;
569     BC_DTS_STATUS decoder_status = { 0, };
570     uint8_t trust_interlaced;
571     uint8_t interlaced;
572
573     CHDContext *priv = avctx->priv_data;
574     int64_t pkt_pts  = AV_NOPTS_VALUE;
575     uint8_t pic_type = 0;
576
577     uint8_t bottom_field = (output->PicInfo.flags & VDEC_FLAG_BOTTOMFIELD) ==
578                            VDEC_FLAG_BOTTOMFIELD;
579     uint8_t bottom_first = !!(output->PicInfo.flags & VDEC_FLAG_BOTTOM_FIRST);
580
581     int width    = output->PicInfo.width;
582     int height   = output->PicInfo.height;
583     int bwidth;
584     uint8_t *src = output->Ybuff;
585     int sStride;
586     uint8_t *dst;
587     int dStride;
588
589     if (output->PicInfo.timeStamp != 0) {
590         OpaqueList *node = opaque_list_pop(priv, output->PicInfo.timeStamp);
591         if (node) {
592             pkt_pts = node->reordered_opaque;
593             pic_type = node->pic_type;
594             av_free(node);
595         } else {
596             /*
597              * We will encounter a situation where a timestamp cannot be
598              * popped if a second field is being returned. In this case,
599              * each field has the same timestamp and the first one will
600              * cause it to be popped. To keep subsequent calculations
601              * simple, pic_type should be set a FIELD value - doesn't
602              * matter which, but I chose BOTTOM.
603              */
604             pic_type = PICT_BOTTOM_FIELD;
605         }
606         av_log(avctx, AV_LOG_VERBOSE, "output \"pts\": %"PRIu64"\n",
607                output->PicInfo.timeStamp);
608         av_log(avctx, AV_LOG_VERBOSE, "output picture type %d\n",
609                pic_type);
610     }
611
612     ret = DtsGetDriverStatus(priv->dev, &decoder_status);
613     if (ret != BC_STS_SUCCESS) {
614         av_log(avctx, AV_LOG_ERROR,
615                "CrystalHD: GetDriverStatus failed: %u\n", ret);
616        return RET_ERROR;
617     }
618
619     /*
620      * For most content, we can trust the interlaced flag returned
621      * by the hardware, but sometimes we can't. These are the
622      * conditions under which we can trust the flag:
623      *
624      * 1) It's not h.264 content
625      * 2) The UNKNOWN_SRC flag is not set
626      * 3) We know we're expecting a second field
627      * 4) The hardware reports this picture and the next picture
628      *    have the same picture number.
629      *
630      * Note that there can still be interlaced content that will
631      * fail this check, if the hardware hasn't decoded the next
632      * picture or if there is a corruption in the stream. (In either
633      * case a 0 will be returned for the next picture number)
634      */
635     trust_interlaced = avctx->codec->id != AV_CODEC_ID_H264 ||
636                        !(output->PicInfo.flags & VDEC_FLAG_UNKNOWN_SRC) ||
637                        priv->need_second_field ||
638                        (decoder_status.picNumFlags & ~0x40000000) ==
639                        output->PicInfo.picture_number;
640
641     /*
642      * If we got a false negative for trust_interlaced on the first field,
643      * we will realise our mistake here when we see that the picture number is that
644      * of the previous picture. We cannot recover the frame and should discard the
645      * second field to keep the correct number of output frames.
646      */
647     if (output->PicInfo.picture_number == priv->last_picture && !priv->need_second_field) {
648         av_log(avctx, AV_LOG_WARNING,
649                "Incorrectly guessed progressive frame. Discarding second field\n");
650         /* Returning without providing a picture. */
651         return RET_OK;
652     }
653
654     interlaced = (output->PicInfo.flags & VDEC_FLAG_INTERLACED_SRC) &&
655                  trust_interlaced;
656
657     if (!trust_interlaced && (decoder_status.picNumFlags & ~0x40000000) == 0) {
658         av_log(avctx, AV_LOG_VERBOSE,
659                "Next picture number unknown. Assuming progressive frame.\n");
660     }
661
662     av_log(avctx, AV_LOG_VERBOSE, "Interlaced state: %d | trust_interlaced %d\n",
663            interlaced, trust_interlaced);
664
665     if (priv->pic->data[0] && !priv->need_second_field)
666         av_frame_unref(priv->pic);
667
668     priv->need_second_field = interlaced && !priv->need_second_field;
669
670     if (!priv->pic->data[0]) {
671         if (ff_get_buffer(avctx, priv->pic, AV_GET_BUFFER_FLAG_REF) < 0)
672             return RET_ERROR;
673     }
674
675     bwidth = av_image_get_linesize(avctx->pix_fmt, width, 0);
676     if (priv->is_70012) {
677         int pStride;
678
679         if (width <= 720)
680             pStride = 720;
681         else if (width <= 1280)
682             pStride = 1280;
683         else pStride = 1920;
684         sStride = av_image_get_linesize(avctx->pix_fmt, pStride, 0);
685     } else {
686         sStride = bwidth;
687     }
688
689     dStride = priv->pic->linesize[0];
690     dst     = priv->pic->data[0];
691
692     av_log(priv->avctx, AV_LOG_VERBOSE, "CrystalHD: Copying out frame\n");
693
694     /*
695      * The hardware doesn't return the first sample of a picture.
696      * Ignoring why it behaves this way, it's better to copy the sample from
697      * the second line, rather than the next sample across because the chroma
698      * values should be correct (assuming the decoded video was 4:2:0, which
699      * it was).
700      */
701     *((uint32_t *)src) = *((uint32_t *)(src + sStride));
702
703     if (interlaced) {
704         int dY = 0;
705         int sY = 0;
706
707         height /= 2;
708         if (bottom_field) {
709             av_log(priv->avctx, AV_LOG_VERBOSE, "Interlaced: bottom field\n");
710             dY = 1;
711         } else {
712             av_log(priv->avctx, AV_LOG_VERBOSE, "Interlaced: top field\n");
713             dY = 0;
714         }
715
716         for (sY = 0; sY < height; dY++, sY++) {
717             memcpy(&(dst[dY * dStride]), &(src[sY * sStride]), bwidth);
718             dY++;
719         }
720     } else {
721         av_image_copy_plane(dst, dStride, src, sStride, bwidth, height);
722     }
723
724     priv->pic->interlaced_frame = interlaced;
725     if (interlaced)
726         priv->pic->top_field_first = !bottom_first;
727
728     if (pkt_pts != AV_NOPTS_VALUE) {
729         priv->pic->pts = pkt_pts;
730 #if FF_API_PKT_PTS
731 FF_DISABLE_DEPRECATION_WARNINGS
732         priv->pic->pkt_pts = pkt_pts;
733 FF_ENABLE_DEPRECATION_WARNINGS
734 #endif
735     }
736     av_frame_set_pkt_pos(priv->pic, -1);
737     av_frame_set_pkt_duration(priv->pic, 0);
738     av_frame_set_pkt_size(priv->pic, -1);
739
740     if (!priv->need_second_field) {
741         *got_frame       = 1;
742         if ((ret = av_frame_ref(data, priv->pic)) < 0) {
743             return ret;
744         }
745     }
746
747     return RET_OK;
748 }
749
750
751 static inline CopyRet receive_frame(AVCodecContext *avctx,
752                                     void *data, int *got_frame)
753 {
754     BC_STATUS ret;
755     BC_DTS_PROC_OUT output = {
756         .PicInfo.width  = avctx->width,
757         .PicInfo.height = avctx->height,
758     };
759     CHDContext *priv = avctx->priv_data;
760     HANDLE dev       = priv->dev;
761
762     *got_frame = 0;
763
764     // Request decoded data from the driver
765     ret = DtsProcOutputNoCopy(dev, OUTPUT_PROC_TIMEOUT, &output);
766     if (ret == BC_STS_FMT_CHANGE) {
767         av_log(avctx, AV_LOG_VERBOSE, "CrystalHD: Initial format change\n");
768         avctx->width  = output.PicInfo.width;
769         avctx->height = output.PicInfo.height;
770         switch ( output.PicInfo.aspect_ratio ) {
771         case vdecAspectRatioSquare:
772             avctx->sample_aspect_ratio = (AVRational) {  1,  1};
773             break;
774         case vdecAspectRatio12_11:
775             avctx->sample_aspect_ratio = (AVRational) { 12, 11};
776             break;
777         case vdecAspectRatio10_11:
778             avctx->sample_aspect_ratio = (AVRational) { 10, 11};
779             break;
780         case vdecAspectRatio16_11:
781             avctx->sample_aspect_ratio = (AVRational) { 16, 11};
782             break;
783         case vdecAspectRatio40_33:
784             avctx->sample_aspect_ratio = (AVRational) { 40, 33};
785             break;
786         case vdecAspectRatio24_11:
787             avctx->sample_aspect_ratio = (AVRational) { 24, 11};
788             break;
789         case vdecAspectRatio20_11:
790             avctx->sample_aspect_ratio = (AVRational) { 20, 11};
791             break;
792         case vdecAspectRatio32_11:
793             avctx->sample_aspect_ratio = (AVRational) { 32, 11};
794             break;
795         case vdecAspectRatio80_33:
796             avctx->sample_aspect_ratio = (AVRational) { 80, 33};
797             break;
798         case vdecAspectRatio18_11:
799             avctx->sample_aspect_ratio = (AVRational) { 18, 11};
800             break;
801         case vdecAspectRatio15_11:
802             avctx->sample_aspect_ratio = (AVRational) { 15, 11};
803             break;
804         case vdecAspectRatio64_33:
805             avctx->sample_aspect_ratio = (AVRational) { 64, 33};
806             break;
807         case vdecAspectRatio160_99:
808             avctx->sample_aspect_ratio = (AVRational) {160, 99};
809             break;
810         case vdecAspectRatio4_3:
811             avctx->sample_aspect_ratio = (AVRational) {  4,  3};
812             break;
813         case vdecAspectRatio16_9:
814             avctx->sample_aspect_ratio = (AVRational) { 16,  9};
815             break;
816         case vdecAspectRatio221_1:
817             avctx->sample_aspect_ratio = (AVRational) {221,  1};
818             break;
819         }
820         return RET_OK;
821     } else if (ret == BC_STS_SUCCESS) {
822         int copy_ret = -1;
823         if (output.PoutFlags & BC_POUT_FLAGS_PIB_VALID) {
824             if (priv->last_picture == -1) {
825                 /*
826                  * Init to one less, so that the incrementing code doesn't
827                  * need to be special-cased.
828                  */
829                 priv->last_picture = output.PicInfo.picture_number - 1;
830             }
831
832             print_frame_info(priv, &output);
833
834             if (priv->last_picture + 1 < output.PicInfo.picture_number) {
835                 av_log(avctx, AV_LOG_WARNING,
836                        "CrystalHD: Picture Number discontinuity\n");
837                 /*
838                  * XXX: I have no idea what the semantics of this situation
839                  * are so I don't even know if we've lost frames or which
840                  * ones.
841                  */
842                priv->last_picture = output.PicInfo.picture_number - 1;
843             }
844
845             copy_ret = copy_frame(avctx, &output, data, got_frame);
846             if (*got_frame > 0) {
847                 priv->last_picture++;
848             }
849         } else {
850             /*
851              * An invalid frame has been consumed.
852              */
853             av_log(avctx, AV_LOG_ERROR, "CrystalHD: ProcOutput succeeded with "
854                                         "invalid PIB\n");
855             copy_ret = RET_OK;
856         }
857         DtsReleaseOutputBuffs(dev, NULL, FALSE);
858
859         return copy_ret;
860     } else if (ret == BC_STS_BUSY) {
861         return RET_OK;
862     } else {
863         av_log(avctx, AV_LOG_ERROR, "CrystalHD: ProcOutput failed %d\n", ret);
864         return RET_ERROR;
865     }
866 }
867
868 static int crystalhd_decode_packet(AVCodecContext *avctx, const AVPacket *avpkt)
869 {
870     BC_STATUS bc_ret;
871     CHDContext *priv   = avctx->priv_data;
872     HANDLE dev         = priv->dev;
873     uint8_t pic_type   = 0;
874     AVPacket filtered_packet = { 0 };
875     int ret = 0;
876
877     av_log(avctx, AV_LOG_VERBOSE, "CrystalHD: decode_packet\n");
878
879     if (avpkt && avpkt->size) {
880         int32_t tx_free = (int32_t)DtsTxFreeSize(dev);
881
882         if (priv->bsfc) {
883             AVPacket filter_packet = { 0 };
884
885             ret = av_packet_ref(&filter_packet, avpkt);
886             if (ret < 0) {
887                 av_log(avctx, AV_LOG_ERROR, "CrystalHD: mpv4toannexb filter "
888                        "failed to ref input packet\n");
889                 goto exit;
890             }
891
892             ret = av_bsf_send_packet(priv->bsfc, &filter_packet);
893             if (ret < 0) {
894                 av_log(avctx, AV_LOG_ERROR, "CrystalHD: mpv4toannexb filter "
895                        "failed to send input packet\n");
896                 goto exit;
897             }
898
899             ret = av_bsf_receive_packet(priv->bsfc, &filtered_packet);
900             if (ret < 0) {
901                 av_log(avctx, AV_LOG_ERROR, "CrystalHD: mpv4toannexb filter "
902                        "failed to receive output packet\n");
903                 goto exit;
904             }
905
906             avpkt = &filtered_packet;
907             av_packet_unref(&filter_packet);
908         }
909
910         if (priv->parser) {
911             uint8_t *pout;
912             int psize;
913             int index;
914             H264Context *h = priv->parser->priv_data;
915
916             index = av_parser_parse2(priv->parser, avctx, &pout, &psize,
917                                      avpkt->data, avpkt->size, avpkt->pts,
918                                      avpkt->dts, 0);
919             if (index < 0) {
920                 av_log(avctx, AV_LOG_WARNING,
921                        "CrystalHD: Failed to parse h.264 packet to "
922                        "detect interlacing.\n");
923             } else if (index != avpkt->size) {
924                 av_log(avctx, AV_LOG_WARNING,
925                        "CrystalHD: Failed to parse h.264 packet "
926                        "completely. Interlaced frames may be "
927                        "incorrectly detected.\n");
928             } else {
929                 av_log(avctx, AV_LOG_VERBOSE,
930                        "CrystalHD: parser picture type %d\n",
931                        h->picture_structure);
932                 pic_type = h->picture_structure;
933             }
934         }
935
936         if (avpkt->size < tx_free) {
937             /*
938              * Despite being notionally opaque, either libcrystalhd or
939              * the hardware itself will mangle pts values that are too
940              * small or too large. The docs claim it should be in units
941              * of 100ns. Given that we're nominally dealing with a black
942              * box on both sides, any transform we do has no guarantee of
943              * avoiding mangling so we need to build a mapping to values
944              * we know will not be mangled.
945              */
946             int64_t safe_pts = avpkt->pts == AV_NOPTS_VALUE ? 0 : avpkt->pts;
947             uint64_t pts = opaque_list_push(priv, safe_pts, pic_type);
948             if (!pts) {
949                 ret = AVERROR(ENOMEM);
950                 goto exit;
951             }
952             av_log(priv->avctx, AV_LOG_VERBOSE,
953                    "input \"pts\": %"PRIu64"\n", pts);
954             bc_ret = DtsProcInput(dev, avpkt->data, avpkt->size, pts, 0);
955             if (bc_ret == BC_STS_BUSY) {
956                 av_log(avctx, AV_LOG_WARNING,
957                        "CrystalHD: ProcInput returned busy\n");
958                 ret = AVERROR(EAGAIN);
959                 goto exit;
960             } else if (bc_ret != BC_STS_SUCCESS) {
961                 av_log(avctx, AV_LOG_ERROR,
962                        "CrystalHD: ProcInput failed: %u\n", ret);
963                 ret = -1;
964                 goto exit;
965             }
966         } else {
967             av_log(avctx, AV_LOG_VERBOSE, "CrystalHD: Input buffer full\n");
968             ret = AVERROR(EAGAIN);
969             goto exit;
970         }
971     } else {
972         av_log(avctx, AV_LOG_INFO, "CrystalHD: No more input data\n");
973         ret = AVERROR_EOF;
974         goto exit;
975     }
976  exit:
977     av_packet_unref(&filtered_packet);
978     return ret;
979 }
980
981 static int crystalhd_receive_frame(AVCodecContext *avctx, AVFrame *frame)
982 {
983     BC_STATUS bc_ret;
984     BC_DTS_STATUS decoder_status = { 0, };
985     CopyRet rec_ret;
986     CHDContext *priv   = avctx->priv_data;
987     HANDLE dev         = priv->dev;
988     int got_frame = 0;
989
990     av_log(avctx, AV_LOG_VERBOSE, "CrystalHD: receive_frame\n");
991
992     bc_ret = DtsGetDriverStatus(dev, &decoder_status);
993     if (bc_ret != BC_STS_SUCCESS) {
994         av_log(avctx, AV_LOG_ERROR, "CrystalHD: GetDriverStatus failed\n");
995         return -1;
996     }
997
998     if (decoder_status.ReadyListCount == 0) {
999         av_log(avctx, AV_LOG_INFO, "CrystalHD: Insufficient frames ready. Returning\n");
1000         return AVERROR(EAGAIN);
1001     }
1002
1003     rec_ret = receive_frame(avctx, frame, &got_frame);
1004     if (rec_ret == RET_ERROR) {
1005         return -1;
1006     } else if (got_frame == 0) {
1007         return AVERROR(EAGAIN);
1008     } else {
1009         return 0;
1010     }
1011 }
1012
1013 #define DEFINE_CRYSTALHD_DECODER(x, X) \
1014     static const AVClass x##_crystalhd_class = { \
1015         .class_name = #x "_crystalhd", \
1016         .item_name = av_default_item_name, \
1017         .option = options, \
1018         .version = LIBAVUTIL_VERSION_INT, \
1019     }; \
1020     AVCodec ff_##x##_crystalhd_decoder = { \
1021         .name           = #x "_crystalhd", \
1022         .long_name      = NULL_IF_CONFIG_SMALL("CrystalHD " #X " decoder"), \
1023         .type           = AVMEDIA_TYPE_VIDEO, \
1024         .id             = AV_CODEC_ID_##X, \
1025         .priv_data_size = sizeof(CHDContext), \
1026         .priv_class     = &x##_crystalhd_class, \
1027         .init           = init, \
1028         .close          = uninit, \
1029         .send_packet    = crystalhd_decode_packet, \
1030         .receive_frame  = crystalhd_receive_frame, \
1031         .flush          = flush, \
1032         .capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY | AV_CODEC_CAP_AVOID_PROBING, \
1033         .pix_fmts       = (const enum AVPixelFormat[]){AV_PIX_FMT_YUYV422, AV_PIX_FMT_NONE}, \
1034     };
1035
1036 #if CONFIG_H264_CRYSTALHD_DECODER
1037 DEFINE_CRYSTALHD_DECODER(h264, H264)
1038 #endif
1039
1040 #if CONFIG_MPEG2_CRYSTALHD_DECODER
1041 DEFINE_CRYSTALHD_DECODER(mpeg2, MPEG2VIDEO)
1042 #endif
1043
1044 #if CONFIG_MPEG4_CRYSTALHD_DECODER
1045 DEFINE_CRYSTALHD_DECODER(mpeg4, MPEG4)
1046 #endif
1047
1048 #if CONFIG_MSMPEG4_CRYSTALHD_DECODER
1049 DEFINE_CRYSTALHD_DECODER(msmpeg4, MSMPEG4V3)
1050 #endif
1051
1052 #if CONFIG_VC1_CRYSTALHD_DECODER
1053 DEFINE_CRYSTALHD_DECODER(vc1, VC1)
1054 #endif
1055
1056 #if CONFIG_WMV3_CRYSTALHD_DECODER
1057 DEFINE_CRYSTALHD_DECODER(wmv3, WMV3)
1058 #endif