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