FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
crystalhd.c
Go to the documentation of this file.
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 "h264.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 /** 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
104 
105 
106 /*****************************************************************************
107  * Module private data
108  ****************************************************************************/
109 
110 typedef enum {
111  RET_ERROR = -1,
112  RET_OK = 0,
116 } CopyRet;
117 
118 typedef struct OpaqueList {
119  struct OpaqueList *next;
120  uint64_t fake_timestamp;
123 } OpaqueList;
124 
125 typedef struct {
130 
133 
136 
139  uint32_t sps_pps_size;
144  uint64_t decode_wait;
145 
146  uint64_t last_picture;
147 
150 
151  /* Options */
152  uint32_t sWidth;
154 } CHDContext;
155 
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,
162  { NULL, },
163 };
164 
165 
166 /*****************************************************************************
167  * Helper functions
168  ****************************************************************************/
169 
170 static inline BC_MEDIA_SUBTYPE id2subtype(CHDContext *priv, enum AVCodecID id)
171 {
172  switch (id) {
173  case AV_CODEC_ID_MPEG4:
174  return BC_MSUBTYPE_DIVX;
176  return BC_MSUBTYPE_DIVX311;
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;
185  default:
186  return BC_MSUBTYPE_INVALID;
187  }
188 }
189 
190 static inline void print_frame_info(CHDContext *priv, BC_DTS_PROC_OUT *output)
191 {
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);
229 }
230 
231 
232 /*****************************************************************************
233  * OpaqueList functions
234  ****************************************************************************/
235 
236 static uint64_t opaque_list_push(CHDContext *priv, uint64_t reordered_opaque,
237  uint8_t pic_type)
238 {
239  OpaqueList *newNode = av_mallocz(sizeof (OpaqueList));
240  if (!newNode) {
241  av_log(priv->avctx, AV_LOG_ERROR,
242  "Unable to allocate new node in OpaqueList.\n");
243  return 0;
244  }
245  if (!priv->head) {
246  newNode->fake_timestamp = TIMESTAMP_UNIT;
247  priv->head = newNode;
248  } else {
249  newNode->fake_timestamp = priv->tail->fake_timestamp + TIMESTAMP_UNIT;
250  priv->tail->next = newNode;
251  }
252  priv->tail = newNode;
253  newNode->reordered_opaque = reordered_opaque;
254  newNode->pic_type = pic_type;
255 
256  return newNode->fake_timestamp;
257 }
258 
259 /*
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.
263  *
264  * Returned node must be freed by caller.
265  */
266 static OpaqueList *opaque_list_pop(CHDContext *priv, uint64_t fake_timestamp)
267 {
268  OpaqueList *node = priv->head;
269 
270  if (!priv->head) {
271  av_log(priv->avctx, AV_LOG_ERROR,
272  "CrystalHD: Attempted to query non-existent timestamps.\n");
273  return NULL;
274  }
275 
276  /*
277  * The first element is special-cased because we have to manipulate
278  * the head pointer rather than the previous element in the list.
279  */
280  if (priv->head->fake_timestamp == fake_timestamp) {
281  priv->head = node->next;
282 
283  if (!priv->head->next)
284  priv->tail = priv->head;
285 
286  node->next = NULL;
287  return node;
288  }
289 
290  /*
291  * The list is processed at arm's length so that we have the
292  * previous element available to rewrite its next pointer.
293  */
294  while (node->next) {
295  OpaqueList *current = node->next;
296  if (current->fake_timestamp == fake_timestamp) {
297  node->next = current->next;
298 
299  if (!node->next)
300  priv->tail = node;
301 
302  current->next = NULL;
303  return current;
304  } else {
305  node = current;
306  }
307  }
308 
309  av_log(priv->avctx, AV_LOG_VERBOSE,
310  "CrystalHD: Couldn't match fake_timestamp.\n");
311  return NULL;
312 }
313 
314 
315 /*****************************************************************************
316  * Video decoder API function definitions
317  ****************************************************************************/
318 
319 static void flush(AVCodecContext *avctx)
320 {
321  CHDContext *priv = avctx->priv_data;
322 
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;
329 
330  av_frame_unref (priv->pic);
331 
332  /* Flush mode 4 flushes all software and hardware buffers. */
333  DtsFlushInput(priv->dev, 4);
334 }
335 
336 
337 static av_cold int uninit(AVCodecContext *avctx)
338 {
339  CHDContext *priv = avctx->priv_data;
340  HANDLE device;
341 
342  device = priv->dev;
343  DtsStopDecoder(device);
344  DtsCloseDecoder(device);
345  DtsDeviceClose(device);
346 
347  /*
348  * Restore original extradata, so that if the decoder is
349  * reinitialised, the bitstream detection and filtering
350  * will work as expected.
351  */
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;
358  }
359 
360  av_parser_close(priv->parser);
361  if (priv->bsfc) {
363  }
364 
365  av_freep(&priv->sps_pps_buf);
366 
367  av_frame_free (&priv->pic);
368 
369  if (priv->head) {
370  OpaqueList *node = priv->head;
371  while (node) {
372  OpaqueList *next = node->next;
373  av_free(node);
374  node = next;
375  }
376  }
377 
378  return 0;
379 }
380 
381 
382 static av_cold int init(AVCodecContext *avctx)
383 {
384  CHDContext* priv;
385  BC_STATUS ret;
386  BC_INFO_CRYSTAL version;
387  BC_INPUT_FORMAT format = {
388  .FGTEnable = FALSE,
389  .Progressive = TRUE,
390  .OptFlags = 0x80000000 | vdecFrameRate59_94 | 0x40,
391  .width = avctx->width,
392  .height = avctx->height,
393  };
394 
395  BC_MEDIA_SUBTYPE subtype;
396 
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);
403 
404  av_log(avctx, AV_LOG_VERBOSE, "CrystalHD Init for %s\n",
405  avctx->codec->name);
406 
407  avctx->pix_fmt = AV_PIX_FMT_YUYV422;
408 
409  /* Initialize the library */
410  priv = avctx->priv_data;
411  priv->avctx = avctx;
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();
416 
417  subtype = id2subtype(priv, avctx->codec->id);
418  switch (subtype) {
419  case BC_MSUBTYPE_AVC1:
420  {
421  uint8_t *dummy_p;
422  int dummy_int;
423 
424  /* Back up the extradata so it can be restored at close time. */
426  if (!priv->orig_extradata) {
427  av_log(avctx, AV_LOG_ERROR,
428  "Failed to allocate copy of extradata\n");
429  return AVERROR(ENOMEM);
430  }
431  priv->orig_extradata_size = avctx->extradata_size;
432  memcpy(priv->orig_extradata, avctx->extradata, avctx->extradata_size);
433 
434  priv->bsfc = av_bitstream_filter_init("h264_mp4toannexb");
435  if (!priv->bsfc) {
436  av_log(avctx, AV_LOG_ERROR,
437  "Cannot open the h264_mp4toannexb BSF!\n");
438  return AVERROR_BSF_NOT_FOUND;
439  }
440  av_bitstream_filter_filter(priv->bsfc, avctx, NULL, &dummy_p,
441  &dummy_int, NULL, 0, 0);
442  }
443  subtype = BC_MSUBTYPE_H264;
444  // Fall-through
445  case BC_MSUBTYPE_H264:
446  format.startCodeSz = 4;
447  // Fall-through
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;
457  break;
458  default:
459  av_log(avctx, AV_LOG_ERROR, "CrystalHD: Unknown codec name\n");
460  return AVERROR(EINVAL);
461  }
462  format.mSubtype = subtype;
463 
464  if (priv->sWidth) {
465  format.bEnableScaling = 1;
466  format.ScalingParams.sWidth = priv->sWidth;
467  }
468 
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");
475  goto fail;
476  }
477 
478  ret = DtsCrystalHDVersion(priv->dev, &version);
479  if (ret != BC_STS_SUCCESS) {
480  av_log(avctx, AV_LOG_VERBOSE,
481  "CrystalHD: DtsCrystalHDVersion failed\n");
482  goto fail;
483  }
484  priv->is_70012 = version.device == 0;
485 
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");
490  goto fail;
491  }
492 
493  ret = DtsSetInputFormat(priv->dev, &format);
494  if (ret != BC_STS_SUCCESS) {
495  av_log(avctx, AV_LOG_ERROR, "CrystalHD: SetInputFormat failed\n");
496  goto fail;
497  }
498 
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");
502  goto fail;
503  }
504 
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");
508  goto fail;
509  }
510  ret = DtsStartDecoder(priv->dev);
511  if (ret != BC_STS_SUCCESS) {
512  av_log(avctx, AV_LOG_ERROR, "CrystalHD: DtsStartDecoder failed\n");
513  goto fail;
514  }
515  ret = DtsStartCapture(priv->dev);
516  if (ret != BC_STS_SUCCESS) {
517  av_log(avctx, AV_LOG_ERROR, "CrystalHD: DtsStartCapture failed\n");
518  goto fail;
519  }
520 
521  if (avctx->codec->id == AV_CODEC_ID_H264) {
522  priv->parser = av_parser_init(avctx->codec->id);
523  if (!priv->parser)
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");
528  }
529  av_log(avctx, AV_LOG_VERBOSE, "CrystalHD: Init complete.\n");
530 
531  return 0;
532 
533  fail:
534  uninit(avctx);
535  return -1;
536 }
537 
538 
539 static inline CopyRet copy_frame(AVCodecContext *avctx,
540  BC_DTS_PROC_OUT *output,
541  void *data, int *got_frame)
542 {
543  BC_STATUS ret;
544  BC_DTS_STATUS decoder_status = { 0, };
545  uint8_t trust_interlaced;
547 
548  CHDContext *priv = avctx->priv_data;
549  int64_t pkt_pts = AV_NOPTS_VALUE;
550  uint8_t pic_type = 0;
551 
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);
555 
556  int width = output->PicInfo.width;
557  int height = output->PicInfo.height;
558  int bwidth;
559  uint8_t *src = output->Ybuff;
560  int sStride;
561  uint8_t *dst;
562  int dStride;
563 
564  if (output->PicInfo.timeStamp != 0) {
565  OpaqueList *node = opaque_list_pop(priv, output->PicInfo.timeStamp);
566  if (node) {
567  pkt_pts = node->reordered_opaque;
568  pic_type = node->pic_type;
569  av_free(node);
570  } else {
571  /*
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.
578  */
579  pic_type = PICT_BOTTOM_FIELD;
580  }
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",
584  pic_type);
585  }
586 
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);
591  return RET_ERROR;
592  }
593 
594  /*
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:
598  *
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.
604  *
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)
609  */
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;
615 
616  /*
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.
621  */
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. */
626  return RET_OK;
627  }
628 
629  interlaced = (output->PicInfo.flags & VDEC_FLAG_INTERLACED_SRC) &&
630  trust_interlaced;
631 
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");
635  }
636 
637  av_log(avctx, AV_LOG_VERBOSE, "Interlaced state: %d | trust_interlaced %d\n",
638  interlaced, trust_interlaced);
639 
640  if (priv->pic->data[0] && !priv->need_second_field)
641  av_frame_unref(priv->pic);
642 
643  priv->need_second_field = interlaced && !priv->need_second_field;
644 
645  if (!priv->pic->data[0]) {
646  if (ff_get_buffer(avctx, priv->pic, AV_GET_BUFFER_FLAG_REF) < 0)
647  return RET_ERROR;
648  }
649 
650  bwidth = av_image_get_linesize(avctx->pix_fmt, width, 0);
651  if (priv->is_70012) {
652  int pStride;
653 
654  if (width <= 720)
655  pStride = 720;
656  else if (width <= 1280)
657  pStride = 1280;
658  else pStride = 1920;
659  sStride = av_image_get_linesize(avctx->pix_fmt, pStride, 0);
660  } else {
661  sStride = bwidth;
662  }
663 
664  dStride = priv->pic->linesize[0];
665  dst = priv->pic->data[0];
666 
667  av_log(priv->avctx, AV_LOG_VERBOSE, "CrystalHD: Copying out frame\n");
668 
669  if (interlaced) {
670  int dY = 0;
671  int sY = 0;
672 
673  height /= 2;
674  if (bottom_field) {
675  av_log(priv->avctx, AV_LOG_VERBOSE, "Interlaced: bottom field\n");
676  dY = 1;
677  } else {
678  av_log(priv->avctx, AV_LOG_VERBOSE, "Interlaced: top field\n");
679  dY = 0;
680  }
681 
682  for (sY = 0; sY < height; dY++, sY++) {
683  memcpy(&(dst[dY * dStride]), &(src[sY * sStride]), bwidth);
684  dY++;
685  }
686  } else {
687  av_image_copy_plane(dst, dStride, src, sStride, bwidth, height);
688  }
689 
691  if (interlaced)
692  priv->pic->top_field_first = !bottom_first;
693 
694  priv->pic->pkt_pts = pkt_pts;
695 
696  if (!priv->need_second_field) {
697  *got_frame = 1;
698  if ((ret = av_frame_ref(data, priv->pic)) < 0) {
699  return ret;
700  }
701  }
702 
703  /*
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
708  * the first case.
709  */
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;
714  }
715 
716  /*
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.
723  *
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)
727  */
728  return priv->need_second_field &&
729  (!(output->PicInfo.flags & VDEC_FLAG_UNKNOWN_SRC) ||
730  pic_type == PICT_FRAME) ?
732 }
733 
734 
735 static inline CopyRet receive_frame(AVCodecContext *avctx,
736  void *data, int *got_frame)
737 {
738  BC_STATUS ret;
739  BC_DTS_PROC_OUT output = {
740  .PicInfo.width = avctx->width,
741  .PicInfo.height = avctx->height,
742  };
743  CHDContext *priv = avctx->priv_data;
744  HANDLE dev = priv->dev;
745 
746  *got_frame = 0;
747 
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};
757  break;
758  case vdecAspectRatio12_11:
759  avctx->sample_aspect_ratio = (AVRational) { 12, 11};
760  break;
761  case vdecAspectRatio10_11:
762  avctx->sample_aspect_ratio = (AVRational) { 10, 11};
763  break;
764  case vdecAspectRatio16_11:
765  avctx->sample_aspect_ratio = (AVRational) { 16, 11};
766  break;
767  case vdecAspectRatio40_33:
768  avctx->sample_aspect_ratio = (AVRational) { 40, 33};
769  break;
770  case vdecAspectRatio24_11:
771  avctx->sample_aspect_ratio = (AVRational) { 24, 11};
772  break;
773  case vdecAspectRatio20_11:
774  avctx->sample_aspect_ratio = (AVRational) { 20, 11};
775  break;
776  case vdecAspectRatio32_11:
777  avctx->sample_aspect_ratio = (AVRational) { 32, 11};
778  break;
779  case vdecAspectRatio80_33:
780  avctx->sample_aspect_ratio = (AVRational) { 80, 33};
781  break;
782  case vdecAspectRatio18_11:
783  avctx->sample_aspect_ratio = (AVRational) { 18, 11};
784  break;
785  case vdecAspectRatio15_11:
786  avctx->sample_aspect_ratio = (AVRational) { 15, 11};
787  break;
788  case vdecAspectRatio64_33:
789  avctx->sample_aspect_ratio = (AVRational) { 64, 33};
790  break;
791  case vdecAspectRatio160_99:
792  avctx->sample_aspect_ratio = (AVRational) {160, 99};
793  break;
794  case vdecAspectRatio4_3:
795  avctx->sample_aspect_ratio = (AVRational) { 4, 3};
796  break;
797  case vdecAspectRatio16_9:
798  avctx->sample_aspect_ratio = (AVRational) { 16, 9};
799  break;
800  case vdecAspectRatio221_1:
801  avctx->sample_aspect_ratio = (AVRational) {221, 1};
802  break;
803  }
804  return RET_COPY_AGAIN;
805  } else if (ret == BC_STS_SUCCESS) {
806  int copy_ret = -1;
807  if (output.PoutFlags & BC_POUT_FLAGS_PIB_VALID) {
808  if (priv->last_picture == -1) {
809  /*
810  * Init to one less, so that the incrementing code doesn't
811  * need to be special-cased.
812  */
813  priv->last_picture = output.PicInfo.picture_number - 1;
814  }
815 
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;
823  }
824 
825  print_frame_info(priv, &output);
826 
827  if (priv->last_picture + 1 < output.PicInfo.picture_number) {
828  av_log(avctx, AV_LOG_WARNING,
829  "CrystalHD: Picture Number discontinuity\n");
830  /*
831  * Have we lost frames? If so, we need to shrink the
832  * pipeline length appropriately.
833  *
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
836  * ones.
837  *
838  * In any case, only warn the first time.
839  */
840  priv->last_picture = output.PicInfo.picture_number - 1;
841  }
842 
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);
849  }
850  } else {
851  /*
852  * An invalid frame has been consumed.
853  */
854  av_log(avctx, AV_LOG_ERROR, "CrystalHD: ProcOutput succeeded with "
855  "invalid PIB\n");
856  avctx->has_b_frames--;
857  copy_ret = RET_OK;
858  }
859  DtsReleaseOutputBuffs(dev, NULL, FALSE);
860 
861  return copy_ret;
862  } else if (ret == BC_STS_BUSY) {
863  return RET_COPY_AGAIN;
864  } else {
865  av_log(avctx, AV_LOG_ERROR, "CrystalHD: ProcOutput failed %d\n", ret);
866  return RET_ERROR;
867  }
868 }
869 
870 
871 static int decode(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
872 {
873  BC_STATUS ret;
874  BC_DTS_STATUS decoder_status = { 0, };
875  CopyRet rec_ret;
876  CHDContext *priv = avctx->priv_data;
877  HANDLE dev = priv->dev;
878  uint8_t *in_data = avpkt->data;
879  int len = avpkt->size;
880  int free_data = 0;
881  uint8_t pic_type = 0;
882 
883  av_log(avctx, AV_LOG_VERBOSE, "CrystalHD: decode_frame\n");
884 
885  if (avpkt->size == 7 && !priv->bframe_bug) {
886  /*
887  * The use of a drop frame triggers the bug
888  */
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) {
893  /*
894  * Delay frames don't trigger the bug
895  */
896  av_log(avctx, AV_LOG_INFO,
897  "CrystalHD: Disabling work-around for packed b-frame bug\n");
898  priv->bframe_bug = 0;
899  }
900 
901  if (len) {
902  int32_t tx_free = (int32_t)DtsTxFreeSize(dev);
903 
904  if (priv->parser) {
905  int ret = 0;
906 
907  if (priv->bsfc) {
908  ret = av_bitstream_filter_filter(priv->bsfc, avctx, NULL,
909  &in_data, &len,
910  avpkt->data, len, 0);
911  }
912  free_data = ret > 0;
913 
914  if (ret >= 0) {
915  uint8_t *pout;
916  int psize;
917  int index;
918  H264Context *h = priv->parser->priv_data;
919 
920  index = av_parser_parse2(priv->parser, avctx, &pout, &psize,
921  in_data, len, avctx->internal->pkt->pts,
922  avctx->internal->pkt->dts, 0);
923  if (index < 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");
932  } else {
933  av_log(avctx, AV_LOG_VERBOSE,
934  "CrystalHD: parser picture type %d\n",
935  h->picture_structure);
936  pic_type = h->picture_structure;
937  }
938  } else {
939  av_log(avctx, AV_LOG_WARNING,
940  "CrystalHD: mp4toannexb filter failed to filter "
941  "packet. Interlaced frames may be incorrectly "
942  "detected.\n");
943  }
944  }
945 
946  if (len < tx_free - 1024) {
947  /*
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.
955  */
956  uint64_t pts = opaque_list_push(priv, avctx->internal->pkt->pts, pic_type);
957  if (!pts) {
958  if (free_data) {
959  av_freep(&in_data);
960  }
961  return AVERROR(ENOMEM);
962  }
963  av_log(priv->avctx, AV_LOG_VERBOSE,
964  "input \"pts\": %"PRIu64"\n", pts);
965  ret = DtsProcInput(dev, in_data, len, pts, 0);
966  if (free_data) {
967  av_freep(&in_data);
968  }
969  if (ret == BC_STS_BUSY) {
970  av_log(avctx, AV_LOG_WARNING,
971  "CrystalHD: ProcInput returned busy\n");
972  usleep(BASE_WAIT);
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);
977  return -1;
978  }
979  avctx->has_b_frames++;
980  } else {
981  av_log(avctx, AV_LOG_WARNING, "CrystalHD: Input buffer full\n");
982  len = 0; // We didn't consume any bytes.
983  }
984  } else {
985  av_log(avctx, AV_LOG_INFO, "CrystalHD: No more input data\n");
986  }
987 
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--;
992  return len;
993  }
994 
995  ret = DtsGetDriverStatus(dev, &decoder_status);
996  if (ret != BC_STS_SUCCESS) {
997  av_log(avctx, AV_LOG_ERROR, "CrystalHD: GetDriverStatus failed\n");
998  return -1;
999  }
1000 
1001  /*
1002  * No frames ready. Don't try to extract.
1003  *
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
1007  * succeed.
1008  */
1009  if (priv->output_ready < 2) {
1010  if (decoder_status.ReadyListCount != 0)
1011  priv->output_ready++;
1012  usleep(BASE_WAIT);
1013  av_log(avctx, AV_LOG_INFO, "CrystalHD: Filling pipeline.\n");
1014  return len;
1015  } else if (decoder_status.ReadyListCount == 0) {
1016  /*
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
1020  * decode call.
1021  */
1022  usleep(BASE_WAIT);
1023  priv->decode_wait += WAIT_UNIT;
1024  av_log(avctx, AV_LOG_INFO, "CrystalHD: No frames ready. Returning\n");
1025  return len;
1026  }
1027 
1028  do {
1029  rec_ret = receive_frame(avctx, data, got_frame);
1030  if (rec_ret == RET_OK && *got_frame == 0) {
1031  /*
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.
1037  */
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) {
1041  /*
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.
1048  */
1049  av_log(avctx, AV_LOG_VERBOSE, "Trying to get second field.\n");
1050  while (1) {
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)
1058  break;
1059  }
1060  }
1061  av_log(avctx, AV_LOG_VERBOSE, "CrystalHD: Got second field.\n");
1062  } else if (rec_ret == RET_SKIP_NEXT_COPY) {
1063  /*
1064  * Two input packets got turned into a field pair. Gawd.
1065  */
1066  av_log(avctx, AV_LOG_VERBOSE,
1067  "Don't output on next decode call.\n");
1068  priv->skip_next_output = 1;
1069  }
1070  /*
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
1076  * valid pts.
1077  */
1078  } while (rec_ret == RET_COPY_AGAIN);
1079  usleep(priv->decode_wait);
1080  return len;
1081 }
1082 
1083 
1084 #if CONFIG_H264_CRYSTALHD_DECODER
1085 static AVClass h264_class = {
1086  "h264_crystalhd",
1088  options,
1090 };
1091 
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),
1098  .init = init,
1099  .close = uninit,
1100  .decode = decode,
1101  .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,
1102  .flush = flush,
1104  .priv_class = &h264_class,
1105 };
1106 #endif
1107 
1108 #if CONFIG_MPEG2_CRYSTALHD_DECODER
1109 static AVClass mpeg2_class = {
1110  "mpeg2_crystalhd",
1112  options,
1114 };
1115 
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),
1122  .init = init,
1123  .close = uninit,
1124  .decode = decode,
1125  .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,
1126  .flush = flush,
1128  .priv_class = &mpeg2_class,
1129 };
1130 #endif
1131 
1132 #if CONFIG_MPEG4_CRYSTALHD_DECODER
1133 static AVClass mpeg4_class = {
1134  "mpeg4_crystalhd",
1136  options,
1138 };
1139 
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),
1146  .init = init,
1147  .close = uninit,
1148  .decode = decode,
1149  .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,
1150  .flush = flush,
1152  .priv_class = &mpeg4_class,
1153 };
1154 #endif
1155 
1156 #if CONFIG_MSMPEG4_CRYSTALHD_DECODER
1157 static AVClass msmpeg4_class = {
1158  "msmpeg4_crystalhd",
1160  options,
1162 };
1163 
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),
1170  .init = init,
1171  .close = uninit,
1172  .decode = decode,
1174  .flush = flush,
1176  .priv_class = &msmpeg4_class,
1177 };
1178 #endif
1179 
1180 #if CONFIG_VC1_CRYSTALHD_DECODER
1181 static AVClass vc1_class = {
1182  "vc1_crystalhd",
1184  options,
1186 };
1187 
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),
1194  .init = init,
1195  .close = uninit,
1196  .decode = decode,
1197  .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,
1198  .flush = flush,
1200  .priv_class = &vc1_class,
1201 };
1202 #endif
1203 
1204 #if CONFIG_WMV3_CRYSTALHD_DECODER
1205 static AVClass wmv3_class = {
1206  "wmv3_crystalhd",
1208  options,
1210 };
1211 
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),
1218  .init = init,
1219  .close = uninit,
1220  .decode = decode,
1221  .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,
1222  .flush = flush,
1224  .priv_class = &wmv3_class,
1225 };
1226 #endif
uint64_t last_picture
Definition: crystalhd.c:146
#define NULL
Definition: coverity.c:32
const struct AVCodec * codec
Definition: avcodec.h:1658
int av_image_get_linesize(enum AVPixelFormat pix_fmt, int width, int plane)
Compute the size of an image line with format pix_fmt and width width for the plane plane...
Definition: imgutils.c:75
This structure describes decoded (raw) audio or video data.
Definition: frame.h:184
AVOption.
Definition: opt.h:245
static const AVClass h264_class
Definition: h264.c:1392
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:101
misc image utilities
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
#define LIBAVUTIL_VERSION_INT
Definition: version.h:70
uint8_t is_nal
Definition: crystalhd.c:140
attribute_deprecated int av_bitstream_filter_filter(AVBitStreamFilterContext *bsfc, AVCodecContext *avctx, const char *args, uint8_t **poutbuf, int *poutbuf_size, const uint8_t *buf, int buf_size, int keyframe)
Filter bitstream.
static OpaqueList * opaque_list_pop(CHDContext *priv, uint64_t fake_timestamp)
Definition: crystalhd.c:266
uint8_t * orig_extradata
Definition: crystalhd.c:131
int size
Definition: avcodec.h:1581
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel...
Definition: avcodec.h:2060
AVPacket * pkt
Current packet as passed into the decoder, to avoid having to pass the packet into every function...
Definition: internal.h:144
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1877
#define AV_CODEC_CAP_EXPERIMENTAL
Codec is experimental and is thus avoided in favor of non experimental encoders.
Definition: avcodec.h:1011
int version
Definition: avisynth_c.h:629
H264Context.
Definition: h264.h:461
static CopyRet receive_frame(AVCodecContext *avctx, void *data, int *got_frame)
Definition: crystalhd.c:735
uint8_t bframe_bug
Definition: crystalhd.c:153
static av_cold int init(AVCodecContext *avctx)
Definition: crystalhd.c:382
AVCodec.
Definition: avcodec.h:3542
int picture_structure
Definition: h264.h:527
uint32_t sWidth
Definition: crystalhd.c:152
#define TIMESTAMP_UNIT
Step between fake timestamps passed to hardware in units of 100ns.
Definition: crystalhd.c:99
AVCodecContext * avctx
Definition: crystalhd.c:127
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
Definition: avcodec.h:981
OpaqueList * tail
Definition: crystalhd.c:149
uint8_t
#define av_cold
Definition: attributes.h:82
#define av_malloc(s)
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:140
static av_cold int uninit(AVCodecContext *avctx)
Definition: crystalhd.c:337
mode
Definition: f_perms.c:27
AVOptions.
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
Definition: frame.c:374
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1764
#define PICT_BOTTOM_FIELD
Definition: mpegutils.h:38
#define height
uint8_t * data
Definition: avcodec.h:1580
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:192
int interlaced_frame
The content of the picture is interlaced.
Definition: frame.h:318
#define av_log(a,...)
H.264 / AVC / MPEG-4 part10 codec.
enum AVCodecID id
Definition: avcodec.h:3556
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: avcodec.h:189
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
int has_b_frames
Size of the frame reordering buffer in the decoder.
Definition: avcodec.h:1971
av_default_item_name
#define AVERROR(e)
Definition: error.h:43
CopyRet
Definition: crystalhd.c:110
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:153
#define FALSE
Definition: windows2linux.h:37
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:176
attribute_deprecated AVBitStreamFilterContext * av_bitstream_filter_init(const char *name)
Create and initialize a bitstream filter context given a bitstream filter name.
static void flush(AVCodecContext *avctx)
Definition: crystalhd.c:319
#define PICT_TOP_FIELD
Definition: mpegutils.h:37
const char * name
Name of the codec implementation.
Definition: avcodec.h:3549
static uint64_t opaque_list_push(CHDContext *priv, uint64_t reordered_opaque, uint8_t pic_type)
Definition: crystalhd.c:236
AVBitStreamFilterContext * bsfc
Definition: crystalhd.c:134
#define WAIT_UNIT
Increment in us to adjust wait in decode()
Definition: crystalhd.c:103
#define fail()
Definition: checkasm.h:81
uint32_t sps_pps_size
Definition: crystalhd.c:139
AVCodecParserContext * parser
Definition: crystalhd.c:135
static void print_frame_info(CHDContext *priv, BC_DTS_PROC_OUT *output)
Definition: crystalhd.c:190
uint8_t interlaced
Definition: mxfenc.c:1823
int av_parser_parse2(AVCodecParserContext *s, AVCodecContext *avctx, uint8_t **poutbuf, int *poutbuf_size, const uint8_t *buf, int buf_size, int64_t pts, int64_t dts, int64_t pos)
Parse a packet.
Definition: parser.c:136
#define width
static const AVOption options[]
Definition: crystalhd.c:156
int width
picture width / height.
Definition: avcodec.h:1836
PVOID HANDLE
OpaqueList * head
Definition: crystalhd.c:148
uint8_t * sps_pps_buf
Definition: crystalhd.c:138
attribute_deprecated void av_bitstream_filter_close(AVBitStreamFilterContext *bsf)
Release bitstream filter context.
int32_t
void av_parser_close(AVCodecParserContext *s)
Definition: parser.c:235
#define TRUE
Definition: windows2linux.h:33
uint64_t reordered_opaque
Definition: crystalhd.c:121
uint64_t fake_timestamp
Definition: crystalhd.c:120
#define AVERROR_BSF_NOT_FOUND
Bitstream filter not found.
Definition: error.h:49
#define src
Definition: vp9dsp.c:530
preferred ID for MPEG-1/2 video decoding
Definition: avcodec.h:194
HANDLE dev
Definition: crystalhd.c:129
struct OpaqueList * next
Definition: crystalhd.c:119
#define AV_LOG_INFO
Standard information.
Definition: log.h:187
AVCodecParserContext * av_parser_init(int codec_id)
Definition: parser.c:51
Libavcodec external API header.
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:215
uint32_t orig_extradata_size
Definition: crystalhd.c:132
#define AV_OPT_FLAG_VIDEO_PARAM
Definition: opt.h:281
main external API structure.
Definition: avcodec.h:1649
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: utils.c:928
packed YUV 4:2:2, 16bpp, Y0 Cb Y1 Cr
Definition: pixfmt.h:63
int extradata_size
Definition: avcodec.h:1765
static const char * format
Definition: movenc.c:47
Describe the class of an AVClass context structure.
Definition: log.h:67
static BC_MEDIA_SUBTYPE id2subtype(CHDContext *priv, enum AVCodecID id)
Definition: crystalhd.c:170
int index
Definition: gxfenc.c:89
uint8_t need_second_field
Definition: crystalhd.c:142
rational number numerator/denominator
Definition: rational.h:43
#define AV_OPT_FLAG_DECODING_PARAM
a generic parameter which can be set by the user for demuxing or decoding
Definition: opt.h:276
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:262
int64_t pkt_pts
PTS copied from the AVPacket that was decoded to produce this frame.
Definition: frame.h:273
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:484
static int64_t pts
Global timestamp for the audio frames.
uint8_t is_70012
Definition: crystalhd.c:137
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:198
uint8_t output_ready
Definition: crystalhd.c:141
AVClass * av_class
Definition: crystalhd.c:126
common internal api header.
#define OUTPUT_PROC_TIMEOUT
Timeout parameter passed to DtsProcOutput() in us.
Definition: crystalhd.c:97
#define PARSER_FLAG_COMPLETE_FRAMES
Definition: avcodec.h:4957
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:731
static const AVClass mpeg4_class
void * priv_data
Definition: avcodec.h:1691
#define PICT_FRAME
Definition: mpegutils.h:39
#define av_free(p)
uint64_t decode_wait
Definition: crystalhd.c:144
#define BASE_WAIT
Initial value in us of the wait in decode()
Definition: crystalhd.c:101
int top_field_first
If the content is interlaced, is top field displayed first.
Definition: frame.h:323
int len
struct AVCodecInternal * internal
Private context used for internal data.
Definition: avcodec.h:1699
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
Definition: avcodec.h:1579
#define av_freep(p)
uint8_t pic_type
Definition: crystalhd.c:122
static int decode(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: crystalhd.c:871
AVFrame * pic
Definition: crystalhd.c:128
void av_image_copy_plane(uint8_t *dst, int dst_linesize, const uint8_t *src, int src_linesize, int bytewidth, int height)
Copy image plane from src to dst.
Definition: imgutils.c:287
uint8_t skip_next_output
Definition: crystalhd.c:143
AVPixelFormat
Pixel format.
Definition: pixfmt.h:60
This structure stores compressed data.
Definition: avcodec.h:1557
#define AV_GET_BUFFER_FLAG_REF
The decoder will keep a reference to the frame and may reuse it later.
Definition: avcodec.h:1341
void * av_mallocz(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
Definition: mem.c:252
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:956
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:1573
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:240
static CopyRet copy_frame(AVCodecContext *avctx, BC_DTS_PROC_OUT *output, void *data, int *got_frame)
Definition: crystalhd.c:539