Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | RSS feed

  1. /*
  2.  * NuppelVideo decoder
  3.  * Copyright (c) 2006 Reimar Doeffinger
  4.  *
  5.  * This file is part of FFmpeg.
  6.  *
  7.  * FFmpeg is free software; you can redistribute it and/or
  8.  * modify it under the terms of the GNU Lesser General Public
  9.  * License as published by the Free Software Foundation; either
  10.  * version 2.1 of the License, or (at your option) any later version.
  11.  *
  12.  * FFmpeg is distributed in the hope that it will be useful,
  13.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15.  * Lesser General Public License for more details.
  16.  *
  17.  * You should have received a copy of the GNU Lesser General Public
  18.  * License along with FFmpeg; if not, write to the Free Software
  19.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20.  */
  21.  
  22. #include <stdio.h>
  23. #include <stdlib.h>
  24. #include <limits.h>
  25.  
  26. #include "libavutil/bswap.h"
  27. #include "libavutil/common.h"
  28. #include "libavutil/lzo.h"
  29. #include "libavutil/imgutils.h"
  30. #include "avcodec.h"
  31. #include "internal.h"
  32. #include "rtjpeg.h"
  33.  
  34. typedef struct {
  35.     AVFrame pic;
  36.     int codec_frameheader;
  37.     int quality;
  38.     int width, height;
  39.     unsigned int decomp_size;
  40.     unsigned char *decomp_buf;
  41.     uint32_t lq[64], cq[64];
  42.     RTJpegContext rtj;
  43.     DSPContext dsp;
  44. } NuvContext;
  45.  
  46. static const uint8_t fallback_lquant[] = {
  47.     16,  11,  10,  16,  24,  40,  51,  61,
  48.     12,  12,  14,  19,  26,  58,  60,  55,
  49.     14,  13,  16,  24,  40,  57,  69,  56,
  50.     14,  17,  22,  29,  51,  87,  80,  62,
  51.     18,  22,  37,  56,  68, 109, 103,  77,
  52.     24,  35,  55,  64,  81, 104, 113,  92,
  53.     49,  64,  78,  87, 103, 121, 120, 101,
  54.     72,  92,  95,  98, 112, 100, 103,  99
  55. };
  56.  
  57. static const uint8_t fallback_cquant[] = {
  58.     17, 18, 24, 47, 99, 99, 99, 99,
  59.     18, 21, 26, 66, 99, 99, 99, 99,
  60.     24, 26, 56, 99, 99, 99, 99, 99,
  61.     47, 66, 99, 99, 99, 99, 99, 99,
  62.     99, 99, 99, 99, 99, 99, 99, 99,
  63.     99, 99, 99, 99, 99, 99, 99, 99,
  64.     99, 99, 99, 99, 99, 99, 99, 99,
  65.     99, 99, 99, 99, 99, 99, 99, 99
  66. };
  67.  
  68. /**
  69.  * @brief copy frame data from buffer to AVFrame, handling stride.
  70.  * @param f destination AVFrame
  71.  * @param src source buffer, does not use any line-stride
  72.  * @param width width of the video frame
  73.  * @param height height of the video frame
  74.  */
  75. static void copy_frame(AVFrame *f, const uint8_t *src, int width, int height)
  76. {
  77.     AVPicture pic;
  78.     avpicture_fill(&pic, src, AV_PIX_FMT_YUV420P, width, height);
  79.     av_picture_copy((AVPicture *)f, &pic, AV_PIX_FMT_YUV420P, width, height);
  80. }
  81.  
  82. /**
  83.  * @brief extract quantization tables from codec data into our context
  84.  */
  85. static int get_quant(AVCodecContext *avctx, NuvContext *c, const uint8_t *buf,
  86.                      int size)
  87. {
  88.     int i;
  89.     if (size < 2 * 64 * 4) {
  90.         av_log(avctx, AV_LOG_ERROR, "insufficient rtjpeg quant data\n");
  91.         return AVERROR_INVALIDDATA;
  92.     }
  93.     for (i = 0; i < 64; i++, buf += 4)
  94.         c->lq[i] = AV_RL32(buf);
  95.     for (i = 0; i < 64; i++, buf += 4)
  96.         c->cq[i] = AV_RL32(buf);
  97.     return 0;
  98. }
  99.  
  100. /**
  101.  * @brief set quantization tables from a quality value
  102.  */
  103. static void get_quant_quality(NuvContext *c, int quality)
  104. {
  105.     int i;
  106.     quality = FFMAX(quality, 1);
  107.     for (i = 0; i < 64; i++) {
  108.         c->lq[i] = (fallback_lquant[i] << 7) / quality;
  109.         c->cq[i] = (fallback_cquant[i] << 7) / quality;
  110.     }
  111. }
  112.  
  113. static int codec_reinit(AVCodecContext *avctx, int width, int height,
  114.                         int quality)
  115. {
  116.     NuvContext *c = avctx->priv_data;
  117.     int ret;
  118.  
  119.     width  = FFALIGN(width,  2);
  120.     height = FFALIGN(height, 2);
  121.     if (quality >= 0)
  122.         get_quant_quality(c, quality);
  123.     if (width != c->width || height != c->height) {
  124.         // also reserve space for a possible additional header
  125.         int buf_size = height * width * 3 / 2
  126.                      + FFMAX(AV_LZO_OUTPUT_PADDING, FF_INPUT_BUFFER_PADDING_SIZE)
  127.                      + RTJPEG_HEADER_SIZE;
  128.         if (buf_size > INT_MAX/8)
  129.             return -1;
  130.         if ((ret = av_image_check_size(height, width, 0, avctx)) < 0)
  131.             return ret;
  132.         avctx->width  = c->width  = width;
  133.         avctx->height = c->height = height;
  134.         av_fast_malloc(&c->decomp_buf, &c->decomp_size,
  135.                        buf_size);
  136.         if (!c->decomp_buf) {
  137.             av_log(avctx, AV_LOG_ERROR,
  138.                    "Can't allocate decompression buffer.\n");
  139.             return AVERROR(ENOMEM);
  140.         }
  141.         ff_rtjpeg_decode_init(&c->rtj, &c->dsp, c->width, c->height,
  142.                               c->lq, c->cq);
  143.         av_frame_unref(&c->pic);
  144.         return 1;
  145.     } else if (quality != c->quality)
  146.         ff_rtjpeg_decode_init(&c->rtj, &c->dsp, c->width, c->height,
  147.                               c->lq, c->cq);
  148.  
  149.     return 0;
  150. }
  151.  
  152. static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
  153.                         AVPacket *avpkt)
  154. {
  155.     const uint8_t *buf = avpkt->data;
  156.     int buf_size       = avpkt->size;
  157.     NuvContext *c      = avctx->priv_data;
  158.     AVFrame *picture   = data;
  159.     int orig_size      = buf_size;
  160.     int keyframe, ret;
  161.     int size_change = 0;
  162.     int result, init_frame = !avctx->frame_number;
  163.     enum {
  164.         NUV_UNCOMPRESSED  = '0',
  165.         NUV_RTJPEG        = '1',
  166.         NUV_RTJPEG_IN_LZO = '2',
  167.         NUV_LZO           = '3',
  168.         NUV_BLACK         = 'N',
  169.         NUV_COPY_LAST     = 'L'
  170.     } comptype;
  171.  
  172.     if (buf_size < 12) {
  173.         av_log(avctx, AV_LOG_ERROR, "coded frame too small\n");
  174.         return AVERROR_INVALIDDATA;
  175.     }
  176.  
  177.     // codec data (rtjpeg quant tables)
  178.     if (buf[0] == 'D' && buf[1] == 'R') {
  179.         int ret;
  180.         // skip rest of the frameheader.
  181.         buf       = &buf[12];
  182.         buf_size -= 12;
  183.         ret       = get_quant(avctx, c, buf, buf_size);
  184.         if (ret < 0)
  185.             return ret;
  186.         ff_rtjpeg_decode_init(&c->rtj, &c->dsp, c->width, c->height, c->lq,
  187.                               c->cq);
  188.         return orig_size;
  189.     }
  190.  
  191.     if (buf_size < 12 || buf[0] != 'V') {
  192.         av_log(avctx, AV_LOG_ERROR, "not a nuv video frame\n");
  193.         return AVERROR_INVALIDDATA;
  194.     }
  195.     comptype = buf[1];
  196.     switch (comptype) {
  197.     case NUV_RTJPEG_IN_LZO:
  198.     case NUV_RTJPEG:
  199.         keyframe = !buf[2];
  200.         break;
  201.     case NUV_COPY_LAST:
  202.         keyframe = 0;
  203.         break;
  204.     default:
  205.         keyframe = 1;
  206.         break;
  207.     }
  208. retry:
  209.     // skip rest of the frameheader.
  210.     buf       = &buf[12];
  211.     buf_size -= 12;
  212.     if (comptype == NUV_RTJPEG_IN_LZO || comptype == NUV_LZO) {
  213.         int outlen = c->decomp_size - FFMAX(FF_INPUT_BUFFER_PADDING_SIZE, AV_LZO_OUTPUT_PADDING);
  214.         int inlen  = buf_size;
  215.         if (av_lzo1x_decode(c->decomp_buf, &outlen, buf, &inlen)) {
  216.             av_log(avctx, AV_LOG_ERROR, "error during lzo decompression\n");
  217.             return AVERROR_INVALIDDATA;
  218.         }
  219.         buf      = c->decomp_buf;
  220.         buf_size = c->decomp_size - FFMAX(FF_INPUT_BUFFER_PADDING_SIZE, AV_LZO_OUTPUT_PADDING) - outlen;
  221.     }
  222.     if (c->codec_frameheader) {
  223.         int w, h, q;
  224.         if (buf_size < RTJPEG_HEADER_SIZE) {
  225.             av_log(avctx, AV_LOG_ERROR, "Too small NUV video frame\n");
  226.             return AVERROR_INVALIDDATA;
  227.         }
  228.         // There seem to exist two variants of this header: one starts with 'V'
  229.         // and 5 bytes unknown, the other matches current MythTV and is 4 bytes size,
  230.         // 1 byte header size (== 12), 1 byte version (== 0)
  231.         if (buf[0] != 'V' && AV_RL16(&buf[4]) != 0x000c) {
  232.             av_log(avctx, AV_LOG_ERROR, "Unknown secondary frame header (wrong codec_tag?)\n");
  233.             return AVERROR_INVALIDDATA;
  234.         }
  235.         w = AV_RL16(&buf[6]);
  236.         h = AV_RL16(&buf[8]);
  237.         q = buf[10];
  238.         if ((result = codec_reinit(avctx, w, h, q)) < 0)
  239.             return result;
  240.         if (result) {
  241.             buf = avpkt->data;
  242.             buf_size = avpkt->size;
  243.             size_change = 1;
  244.             goto retry;
  245.         }
  246.         buf       = &buf[RTJPEG_HEADER_SIZE];
  247.         buf_size -= RTJPEG_HEADER_SIZE;
  248.     }
  249.  
  250.     if (size_change || keyframe) {
  251.         av_frame_unref(&c->pic);
  252.         init_frame = 1;
  253.     }
  254.  
  255.     if ((result = ff_reget_buffer(avctx, &c->pic)) < 0)
  256.         return result;
  257.     if (init_frame) {
  258.         memset(c->pic.data[0], 0,    avctx->height * c->pic.linesize[0]);
  259.         memset(c->pic.data[1], 0x80, avctx->height * c->pic.linesize[1] / 2);
  260.         memset(c->pic.data[2], 0x80, avctx->height * c->pic.linesize[2] / 2);
  261.     }
  262.  
  263.     c->pic.pict_type = keyframe ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_P;
  264.     c->pic.key_frame = keyframe;
  265.     // decompress/copy/whatever data
  266.     switch (comptype) {
  267.     case NUV_LZO:
  268.     case NUV_UNCOMPRESSED: {
  269.         int height = c->height;
  270.         if (buf_size < c->width * height * 3 / 2) {
  271.             av_log(avctx, AV_LOG_ERROR, "uncompressed frame too short\n");
  272.             height = buf_size / c->width / 3 * 2;
  273.         }
  274.         if(height > 0)
  275.             copy_frame(&c->pic, buf, c->width, height);
  276.         break;
  277.     }
  278.     case NUV_RTJPEG_IN_LZO:
  279.     case NUV_RTJPEG:
  280.         ret = ff_rtjpeg_decode_frame_yuv420(&c->rtj, &c->pic, buf, buf_size);
  281.         if (ret < 0)
  282.             return ret;
  283.         break;
  284.     case NUV_BLACK:
  285.         memset(c->pic.data[0], 0, c->width * c->height);
  286.         memset(c->pic.data[1], 128, c->width * c->height / 4);
  287.         memset(c->pic.data[2], 128, c->width * c->height / 4);
  288.         break;
  289.     case NUV_COPY_LAST:
  290.         /* nothing more to do here */
  291.         break;
  292.     default:
  293.         av_log(avctx, AV_LOG_ERROR, "unknown compression\n");
  294.         return AVERROR_INVALIDDATA;
  295.     }
  296.  
  297.     if ((result = av_frame_ref(picture, &c->pic)) < 0)
  298.         return result;
  299.  
  300.     *got_frame = 1;
  301.     return orig_size;
  302. }
  303.  
  304. static av_cold int decode_init(AVCodecContext *avctx)
  305. {
  306.     NuvContext *c  = avctx->priv_data;
  307.     int ret;
  308.  
  309.     avctx->pix_fmt = AV_PIX_FMT_YUV420P;
  310.     c->pic.data[0] = NULL;
  311.     c->decomp_buf  = NULL;
  312.     c->quality     = -1;
  313.     c->width       = 0;
  314.     c->height      = 0;
  315.  
  316.     c->codec_frameheader = avctx->codec_tag == MKTAG('R', 'J', 'P', 'G');
  317.  
  318.     if (avctx->extradata_size)
  319.         get_quant(avctx, c, avctx->extradata, avctx->extradata_size);
  320.  
  321.     ff_dsputil_init(&c->dsp, avctx);
  322.  
  323.     if ((ret = codec_reinit(avctx, avctx->width, avctx->height, -1)) < 0)
  324.         return ret;
  325.  
  326.     return 0;
  327. }
  328.  
  329. static av_cold int decode_end(AVCodecContext *avctx)
  330. {
  331.     NuvContext *c = avctx->priv_data;
  332.  
  333.     av_freep(&c->decomp_buf);
  334.     av_frame_unref(&c->pic);
  335.  
  336.     return 0;
  337. }
  338.  
  339. AVCodec ff_nuv_decoder = {
  340.     .name           = "nuv",
  341.     .long_name      = NULL_IF_CONFIG_SMALL("NuppelVideo/RTJPEG"),
  342.     .type           = AVMEDIA_TYPE_VIDEO,
  343.     .id             = AV_CODEC_ID_NUV,
  344.     .priv_data_size = sizeof(NuvContext),
  345.     .init           = decode_init,
  346.     .close          = decode_end,
  347.     .decode         = decode_frame,
  348.     .capabilities   = CODEC_CAP_DR1,
  349. };
  350.