PageRenderTime 53ms CodeModel.GetById 22ms RepoModel.GetById 0ms app.codeStats 0ms

/external/ffmpeg/libavcodec/rl2.c

https://gitlab.com/brian0218/rk3188_r-box_android4.2.2_sdk
C | 234 lines | 141 code | 37 blank | 56 comment | 21 complexity | 76768a8ce47564e698bb48c6134dcf42 MD5 | raw file
  1. /*
  2. * RL2 Video Decoder
  3. * Copyright (C) 2008 Sascha Sommer (saschasommer@freenet.de)
  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. * @file
  23. * RL2 Video Decoder
  24. * @author Sascha Sommer (saschasommer@freenet.de)
  25. * @see http://wiki.multimedia.cx/index.php?title=RL2
  26. */
  27. #include <stdio.h>
  28. #include <stdlib.h>
  29. #include <string.h>
  30. #include "libavutil/internal.h"
  31. #include "libavutil/intreadwrite.h"
  32. #include "libavutil/mem.h"
  33. #include "avcodec.h"
  34. #define EXTRADATA1_SIZE (6 + 256 * 3) ///< video base, clr count, palette
  35. typedef struct Rl2Context {
  36. AVCodecContext *avctx;
  37. AVFrame frame;
  38. unsigned short video_base; ///< initial drawing offset
  39. unsigned int clr_count; ///< number of used colors (currently unused)
  40. unsigned char* back_frame; ///< background frame
  41. unsigned int palette[AVPALETTE_COUNT];
  42. } Rl2Context;
  43. /**
  44. * Run Length Decode a single 320x200 frame
  45. * @param s rl2 context
  46. * @param in input buffer
  47. * @param size input buffer size
  48. * @param out output buffer
  49. * @param stride stride of the output buffer
  50. * @param video_base offset of the rle data inside the frame
  51. */
  52. static void rl2_rle_decode(Rl2Context *s,const unsigned char* in,int size,
  53. unsigned char* out,int stride,int video_base){
  54. int base_x = video_base % s->avctx->width;
  55. int base_y = video_base / s->avctx->width;
  56. int stride_adj = stride - s->avctx->width;
  57. int i;
  58. const unsigned char* back_frame = s->back_frame;
  59. const unsigned char* in_end = in + size;
  60. const unsigned char* out_end = out + stride * s->avctx->height;
  61. unsigned char* line_end;
  62. /** copy start of the background frame */
  63. for(i=0;i<=base_y;i++){
  64. if(s->back_frame)
  65. memcpy(out,back_frame,s->avctx->width);
  66. out += stride;
  67. back_frame += s->avctx->width;
  68. }
  69. back_frame += base_x - s->avctx->width;
  70. line_end = out - stride_adj;
  71. out += base_x - stride;
  72. /** decode the variable part of the frame */
  73. while(in < in_end){
  74. unsigned char val = *in++;
  75. int len = 1;
  76. if(val >= 0x80){
  77. if(in >= in_end)
  78. break;
  79. len = *in++;
  80. if(!len)
  81. break;
  82. }
  83. if(len >= out_end - out)
  84. break;
  85. if(s->back_frame)
  86. val |= 0x80;
  87. else
  88. val &= ~0x80;
  89. while(len--){
  90. *out++ = (val == 0x80)? *back_frame:val;
  91. back_frame++;
  92. if(out == line_end){
  93. out += stride_adj;
  94. line_end += stride;
  95. if(len >= out_end - out)
  96. break;
  97. }
  98. }
  99. }
  100. /** copy the rest from the background frame */
  101. if(s->back_frame){
  102. while(out < out_end){
  103. memcpy(out, back_frame, line_end - out);
  104. back_frame += line_end - out;
  105. out = line_end + stride_adj;
  106. line_end += stride;
  107. }
  108. }
  109. }
  110. /**
  111. * Initialize the decoder
  112. * @param avctx decoder context
  113. * @return 0 success, -1 on error
  114. */
  115. static av_cold int rl2_decode_init(AVCodecContext *avctx)
  116. {
  117. Rl2Context *s = avctx->priv_data;
  118. int back_size;
  119. int i;
  120. s->avctx = avctx;
  121. avctx->pix_fmt = AV_PIX_FMT_PAL8;
  122. avcodec_get_frame_defaults(&s->frame);
  123. /** parse extra data */
  124. if(!avctx->extradata || avctx->extradata_size < EXTRADATA1_SIZE){
  125. av_log(avctx, AV_LOG_ERROR, "invalid extradata size\n");
  126. return -1;
  127. }
  128. /** get frame_offset */
  129. s->video_base = AV_RL16(&avctx->extradata[0]);
  130. s->clr_count = AV_RL32(&avctx->extradata[2]);
  131. if(s->video_base >= avctx->width * avctx->height){
  132. av_log(avctx, AV_LOG_ERROR, "invalid video_base\n");
  133. return -1;
  134. }
  135. /** initialize palette */
  136. for(i=0;i<AVPALETTE_COUNT;i++)
  137. s->palette[i] = 0xFFU << 24 | AV_RB24(&avctx->extradata[6 + i * 3]);
  138. /** decode background frame if present */
  139. back_size = avctx->extradata_size - EXTRADATA1_SIZE;
  140. if(back_size > 0){
  141. unsigned char* back_frame = av_mallocz(avctx->width*avctx->height);
  142. if(!back_frame)
  143. return -1;
  144. rl2_rle_decode(s,avctx->extradata + EXTRADATA1_SIZE,back_size,
  145. back_frame,avctx->width,0);
  146. s->back_frame = back_frame;
  147. }
  148. return 0;
  149. }
  150. static int rl2_decode_frame(AVCodecContext *avctx,
  151. void *data, int *data_size,
  152. AVPacket *avpkt)
  153. {
  154. const uint8_t *buf = avpkt->data;
  155. int buf_size = avpkt->size;
  156. Rl2Context *s = avctx->priv_data;
  157. if(s->frame.data[0])
  158. avctx->release_buffer(avctx, &s->frame);
  159. /** get buffer */
  160. s->frame.reference= 0;
  161. if(avctx->get_buffer(avctx, &s->frame)) {
  162. av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n");
  163. return -1;
  164. }
  165. /** run length decode */
  166. rl2_rle_decode(s,buf,buf_size,s->frame.data[0],s->frame.linesize[0],s->video_base);
  167. /** make the palette available on the way out */
  168. memcpy(s->frame.data[1], s->palette, AVPALETTE_SIZE);
  169. *data_size = sizeof(AVFrame);
  170. *(AVFrame*)data = s->frame;
  171. /** report that the buffer was completely consumed */
  172. return buf_size;
  173. }
  174. /**
  175. * Uninit decoder
  176. * @param avctx decoder context
  177. * @return 0 success, -1 on error
  178. */
  179. static av_cold int rl2_decode_end(AVCodecContext *avctx)
  180. {
  181. Rl2Context *s = avctx->priv_data;
  182. if(s->frame.data[0])
  183. avctx->release_buffer(avctx, &s->frame);
  184. av_free(s->back_frame);
  185. return 0;
  186. }
  187. AVCodec ff_rl2_decoder = {
  188. .name = "rl2",
  189. .type = AVMEDIA_TYPE_VIDEO,
  190. .id = AV_CODEC_ID_RL2,
  191. .priv_data_size = sizeof(Rl2Context),
  192. .init = rl2_decode_init,
  193. .close = rl2_decode_end,
  194. .decode = rl2_decode_frame,
  195. .capabilities = CODEC_CAP_DR1,
  196. .long_name = NULL_IF_CONFIG_SMALL("RL2 video"),
  197. };