[第4波]幽魂系列汉化的有关资料

shane007

; L+ e& ]1 R1 z2 a
% U6 [: f6 _$ v) d最近找到了一些和幽魂系列Phantasmagoria 有关的资料，
也许将来可以用于汉化。
$ r% A) D' F6 f. e5 f' n1 G8 K# G
; I$ [& [7 s( y2 {" F和日文版有关的信息
http://anthonylarme.tripod.com/phantas/phintgtp.html

  m4 c  R% s% ?8 z6 d相关工具
http://anthonylarme.tripod.com/phantas/phcheats.html
. v* U/ R7 r3 b' H# R. k-----------------------------------------------------------------------
9 D8 j' }- s% k7 ~. ]2012/1/2  更新
! z# G0 Y$ C. X  {) o1 o, e! w关于幽魂游戏的字幕
Phantasmagoria subtitles function discovered - ScummVM :: Forums

VMD文件
$ S$ c! X* C9 I5 D5 N1 }' Q, [Subtitling Sierra VMD Files | Breaking Eggs And Making Omelettes (multimedia.cx)VMD - MultimediaWiki
* l8 D1 f% A4 z( Y2 r
字幕
Subtitling Sierra RBT Files | Breaking Eggs And Making Omelettes (multimedia.cx)

! {, Y4 }4 o9 c3 c' \0 q, _' HFFmpeg/subtitle-rbt.c at feature/VMD_encoder · multimediamike/FFmpeg · GitHub
9 N* g( c- ?  h% |

1. /*
   
2. * subtitle-rbt.c
   
3. *  by Mike Melanson (mike -at- multimedia.cx)
   . U- l' S* q" Y+ s) ]: Z5 U
4. *
   
5. * build with this command:
   - H8 o8 f0 D1 K" y# f8 k
6. *   gcc -g -Wall subtitle-rbt.c -o subtitle-rbt -lm -lass
   
7. */
   
8. 
   . g4 a2 R1 [( C) P
9. #include <inttypes.h>
   ! o; o, p6 a6 L- E' M- X0 G2 u
10. #include <math.h>
    
11. #include <stdio.h>
    
12. #include <stdlib.h>
    
13. #include <string.h>
    
14. 
    
15. #include <ass/ass.h>
    0 h( D/ {$ ]# C4 \2 k& e
16. 
    
17. #define LE_16(x) ((((uint8_t*)(x))[1] <<  8) | ((uint8_t*)(x))[0])
    ! [; m- b* d$ X" P1 e) L" V
18. 
    0 H; A1 [2 F) v( x/ S" p
19. #define LE_32(x) (((uint32_t)(((uint8_t*)(x))[3]) << 24) |  \
    ; H9 a0 C6 D+ l
20.                              (((uint8_t*)(x))[2]  << 16) |  \
    7 N8 W" H, R6 [: s! v
21.                              (((uint8_t*)(x))[1]  <<  8) |  \
    
22.                               ((uint8_t*)(x))[0])
    , W! W  S0 y3 X: F: r
23. 
    
24. /*********************************************************************/
    ; Q' Y& o5 A7 K$ z8 J" R
25. 
    : G8 K7 i, d& _9 y' r1 T- r
26. /* Bit reader stuff */
    : s  G( b: ]3 S5 t7 a+ w
27. 
    0 @5 ]: d$ g  p
28. typedef struct
    
29. {
    2 X# ~  c( p+ o+ B) ]
30.     uint8_t *bytestream;
      o9 E% ~% |5 N
31.     int bytestream_size;
    
32.     int index;
    4 ]) O: X' x6 }6 d  V0 I1 r" U' h
33.     uint32_t bits;
    
34.     int bits_in_buffer;
    5 l% [/ F9 ~# ^4 _: M! `3 x3 J' w
35. } get_bits_context;
    
36. 
    
37. static inline void reload_bits(get_bits_context *gb)
    
38. {
    * m  c4 y+ t) X& N& b6 S* p6 x" Z
39.     while (gb->bits_in_buffer <= 24)
    
40.     {
    * y$ X( ?$ `4 {9 u- v2 Z
41.         if (gb->index < gb->bytestream_size)
    
42.             gb->bits |= (gb->bytestream[gb->index++] << (24 - gb->bits_in_buffer));
    
43.         gb->bits_in_buffer += 8;
    
44.     }
    1 v3 X7 @) r5 i; E" Z& X' }& q
45. }
    7 _& t4 V; ?. r. [( p. p
46. 
    
47. static void init_get_bits(get_bits_context *gb, uint8_t *bytestream, int size)
    8 M) l; `+ v# S+ _( c; a
48. {
    
49.     gb->bytestream = malloc(size);
    : U$ k8 u* p: o- j. C+ r
50.     memcpy(gb->bytestream, bytestream, size);
    3 o& j/ t) g& E8 J; ?9 z( d0 T
51.     gb->bytestream_size = size;
      m8 y" A. T7 h7 v. _2 H
52.     gb->index = 0;
    6 F; i$ n2 u' m  ~. n# N
53.     gb->bits = 0;
    0 B0 A1 r; x/ r8 j9 Z6 h
54.     gb->bits_in_buffer = 0;
    : ~& v% c6 }3 O" K  {
55. 
    
56.     reload_bits(gb);
    
57. }
    $ z& S+ D- z4 w  w5 E
58. 
    
59. /* read bits without consuming them from the stream */
    4 }* |  O& ^# u9 Z; D4 {
60. static int view_bits(get_bits_context *gb, int count)
    
61. {
    ; T) T' u9 X- N4 `5 k
62.     if (count >= 24)
    
63.         return -1;
    # D4 D' G  Z; D$ u  @' h' u
64.     if (gb->bits_in_buffer < count)
    
65.         reload_bits(gb);
    
66.     return (gb->bits >> (32 - count));
    
67. }
    ' y  i5 |$ v+ q' L- @( |! ~
68. 
    / E* [8 i' b/ |0 e' M( b" m0 f0 q# Q
69. /* read and consume bits from the stream */
    
70. static int read_bits(get_bits_context *gb, int count)
    4 U2 U1 j  O  M% g5 K+ r9 z" u% l
71. {
    
72.     int value;
    4 E/ j: y0 q% P5 Z! K$ i" C
73. 
    ; g, c, s2 n. h0 o
74.     if (count >= 24)
    - A7 d/ E! J; x: w
75.         return -1;
    4 R# D3 m2 f  V% p! x4 L( e& e5 X# X' K6 T
76. 
    
77.     value = view_bits(gb, count);
    
78.     gb->bits <<= count;
    
79.     gb->bits_in_buffer -= count;
    
80. 
    
81.     return value;
      h5 W1 `7 N! V8 G
82. }
    ; N' C, @+ ~: e) ^
83. 
    
84. static void delete_get_bits(get_bits_context *gb)
    
85. {
    1 L$ k! ]1 F& |# Q5 y1 A8 J
86.     free(gb->bytestream);
    
87. }
    8 }0 A8 @: p7 `8 r
88. 
    4 L; D: f- [# Z/ D& E) F+ t
89. /*********************************************************************/
    
90. 
    + u0 J0 u! n$ C: ]/ o* q
91. /* Bit writer stuff */
    ' T2 P9 V5 O. J$ l+ ~! }" _( y2 {
92. 
      f) e) C1 u- a. ^: p( {
93. #define MAX_PUT_BITS_BYTES 63000
    
94. typedef struct
    
95. {
      m/ ^, T8 H/ I
96.     uint8_t bytes[MAX_PUT_BITS_BYTES];
    
97.     int byte_index;
    0 ?# g2 u5 W. o6 T' f$ @2 A
98.     uint32_t bit_buffer;
    
99.     int bits_buffered;
      T; U, d4 t8 N! V0 L
100. } put_bits_context;
     5 z6 ]6 [; j6 u4 A" b6 [( c9 @5 e% P
101. 
     
102. static void reset_put_bits(put_bits_context *pb)
     
103. {
     
104.     memset(pb->bytes, 0, MAX_PUT_BITS_BYTES);
     ; j' M: j  K2 `, U
105.     pb->byte_index = 0;
     
106.     pb->bit_buffer = 0;
     : t) {' z7 J0 F: n% e
107.     pb->bits_buffered = 0;
     
108. }
     
109. 
     
110. static put_bits_context *init_put_bits()
     
111. {
     1 ]9 |' q  z7 c( j8 e. x. k
112.     put_bits_context *pb;
     
113. 
     
114.     pb = malloc(sizeof(put_bits_context));
     
115.     reset_put_bits(pb);
     ! m+ c& c: u" k; I3 m9 V' [
116. 
     2 G  ]/ ~" X* V1 t1 z
117.     return pb;
     
118. }
     
119. 
     1 D" L. z$ P, r5 H7 O# l9 j9 h% j
120. static void put_bits(put_bits_context *pb, int bits, int count)
     
121. {
     . K. O# p1 T, c; E% U( a5 F! `
122.     pb->bit_buffer <<= count;
     3 O+ {% r, @5 ^. g* o) s  C. V4 D' s1 H
123.     pb->bit_buffer |= (bits & (~(0xFFFFFFFF << count)));
     
124.     pb->bits_buffered += count;
     
125. 
     ( d: q& w) N) _
126.     while (pb->bits_buffered >= 8)
     8 c# P, a2 }' K% d
127.     {
     
128.         pb->bytes[pb->byte_index++] = pb->bit_buffer >> (pb->bits_buffered - 8);
     
129.         pb->bit_buffer &= (~(0xFFFFFFFF << (pb->bits_buffered - 8)));
     
130.         pb->bits_buffered -= 8;
     - p- A* R- [2 g" p1 H
131.     }
     9 ^; @/ T- ^0 I6 Q
132. 
     
133.     if (pb->byte_index >= MAX_PUT_BITS_BYTES)
     3 ~2 _# `9 Q; h4 O. f4 J: U: q2 b3 W
134.     {
     ! ^) y% t+ v& ^, s2 g/ I; `! \
135.         printf("HELP! Bit overflow\n");
     / I7 n8 u$ C: m
136.         exit(1);
     6 x/ ~9 {- I7 W0 i, w: ~3 a
137.     }
     6 K# ?6 q: v& z: y
138. }
     
139. 
     
140. static void put_bits_flush(put_bits_context *pb)
     
141. {
     
142.     if (pb->bits_buffered > 0)
     ) z( T, t- B3 E
143.         pb->bytes[pb->byte_index++] = pb->bit_buffer << (8 - pb->bits_buffered);
     ; }; r( l9 R) @0 n5 e- F* {9 X
144. }
     ( W5 ]* z: `$ z9 z. v
145. 
     7 Z% x2 M7 j( _6 b/ u
146. static void delete_put_bits(put_bits_context *pb)
     : N& I+ e. g; y) V  q  ~2 z  u6 ?6 j% m
147. {
     + O' s8 Y* j2 L$ V
148.     free(pb->bytes);
     
149. }
     
150. 
     . [, I$ K( Y0 l7 [
151. /*********************************************************************/
     % Y- E( t  e7 J
152. 
     / g  p7 ?# L- d, Y
153. /* RBT functions */
     
154. 
     5 ^, k' ]! P* L7 h, O% c* B
155. #define PALETTE_COUNT 256
     
156. #define RBT_HEADER_SIZE 60
     
157. #define UNKNOWN_TABLE_SIZE (1024+512)
     4 u: x1 L, m# J* o, T
158. #define SUBTITLE_THRESHOLD 0x70
     
159. #define MILLISECONDS_PER_FRAME 100
     
160. 
     
161. /* VLC table */
     . K' `4 L! c; m+ X' R) V  g
162. #define VLC_SIZE 4
     ; B& g) }3 _% K- S1 g
163. static struct
     9 l& |; X; E5 ]9 C4 j/ X
164. {
     
165.     int count;
     
166.     int value;
     
167. } lzs_vlc_table[] =
     
168. {
     
169.     /* code length = 2 bits; value = 2 */
     
170.     /* 0000 */ { 2, 2 },
     + y: z; |) i2 w7 K
171.     /* 0001 */ { 2, 2 },
     + m' i2 K1 {9 Z: R' l# c9 k
172.     /* 0010 */ { 2, 2 },
     
173.     /* 0011 */ { 2, 2 },
     
174. 
     9 `' O# m% J6 k2 N0 e$ L% }
175.     /* code length = 2 bits; value = 3 */
     $ j% u; L' A' w- T3 v( [
176.     /* 0100 */ { 2, 3 },
     
177.     /* 0101 */ { 2, 3 },
     # F" t2 U6 E. L% J4 C/ s% {0 t
178.     /* 0110 */ { 2, 3 },
     
179.     /* 0111 */ { 2, 3 },
     
180. 
     
181.     /* code length = 2 bits; value = 4 */
     
182.     /* 1000 */ { 2, 4 },
     
183.     /* 1001 */ { 2, 4 },
     
184.     /* 1010 */ { 2, 4 },
     
185.     /* 1011 */ { 2, 4 },
     
186. 
     
187.     /* code length = 4 bits; value = 5 */
     : U" c8 m4 h5 Y' W
188.     /* 1100 */ { 4, 5 },
     : N/ X' ~4 F( e& c; ~4 Q; T! ]7 ~
189. 
     $ D" Y0 l1 J) J! y/ x/ _; e8 p
190.     /* code length = 4 bits; value = 6 */
     
191.     /* 1101 */ { 4, 6 },
     
192. 
     
193.     /* code length = 4 bits; value = 7 */
     
194.     /* 1110 */ { 4, 7 },
     
195. 
     3 h8 A* B* c- k: a# u* ~
196.     /* special case */
     / @8 S  l) D" \6 x- o
197.     /* 1111 */ { 4, 8 }
     
198. };
     * X8 }( y2 b5 N" x% {
199. 
     
200. typedef struct
     8 |: l! y/ t! x' X/ x
201. {
     ; g( W* o' `% W% ]
202.     int version;
     
203.     int width;
     
204.     int height;
     $ Z6 ^# ^# \9 W( `" ]
205.     int frame_count;
     
206.     int audio_chunk_size;
     
207.     uint8_t palette[PALETTE_COUNT * 3];
     , G( `; P) \6 l' a: \
208.     off_t video_frame_size_table_offset;
     
209.     uint8_t *video_frame_size_table;
     
210.     off_t frame_size_table_offset;
     
211.     uint8_t *frame_size_table;
     
212.     uint8_t *frame_load_buffer;
     ) z# ]$ R5 Q5 F, Z) k6 Y- a, A& W( O
213.     int dump_frames;
     0 _( O& B8 D" P( C  `/ f6 V0 p
214. 
     9 O/ |- m& o+ \( F# H* v
215.     /* subtitle library */
     $ d0 K# j4 `1 V$ v3 V; F/ r
216.     ASS_Library *ass_lib;
     
217.     ASS_Renderer *ass_renderer;
     5 }5 }2 D8 E5 }" }7 C( k
218.     ASS_Track *ass_track;
     2 [6 R; F* d& u5 U1 A% |
219. } rbt_dec_context;
     ' S; t$ n+ n. J; W2 ^
220. 
     
221. static void dump_pnm_file(char *filename, rbt_dec_context *rbt,
     
222.     uint8_t *image, int width, int height)
     $ K) h2 S% L8 g. A1 H
223. {
     % q) r' h2 o- g7 u8 V8 a
224.     FILE *outfile;
     ) [4 l+ J1 e' Z' ^& w
225.     uint8_t bytes[3];
     , g. T& y+ n  W  h# c
226.     int p;
     9 P  W$ w& @4 e! p
227.     uint8_t pixel;
     2 m7 z7 n( a9 T. o/ b
228. 
     
229.     outfile = fopen(filename, "wb");
     % b* u7 p6 z( s! \) o. u& _
230.     fprintf(outfile, "P6\n%d %d\n255\n", width, height);
     
231.     for (p = 0; p < width * height; p++)
     9 p: I) l% k% m/ v5 b; N
232.     {
     
233.         pixel = image[p];
     
234.         bytes[0] = rbt->palette[pixel*3+0];
     ' y. ~- R+ }6 Q5 l) w0 H
235.         bytes[1] = rbt->palette[pixel*3+1];
     3 Z; T) X9 K5 n2 [0 Y& W' a
236.         bytes[2] = rbt->palette[pixel*3+2];
     " H7 @' u1 i. b
237.         fwrite(bytes, 3, 1, outfile);
     
238.     }
     * b2 K( {2 q! Z5 R( |, h: _4 n
239.     fclose(outfile);
     
240. }
     
241. 
     
242. static int load_and_copy_rbt_header(rbt_dec_context *rbt, FILE *inrbt_file, FILE *outrbt_file)
     
243. {
     ' `' v+ n+ H! u
244.     uint8_t header[RBT_HEADER_SIZE];
     1 p8 z4 ~+ J1 y$ u2 K; S: o. w
245.     int palette_data_size;
     3 U" R. r7 H8 g+ d
246.     uint8_t *palette_chunk;
     
247.     int unknown_chunk_size;
     
248.     uint8_t *unknown_chunk;
     
249.     uint8_t unknown_table[UNKNOWN_TABLE_SIZE];
     . C, h3 R1 |/ X, {# t
250.     off_t padding_size;
     
251.     uint8_t *padding;
     0 R1 A, h$ }- C! k# U( S
252.     int i;
     4 R! G7 K: k' ?% _+ @3 F+ B/ T4 c2 {
253.     int frame_size;
     % J  P( K" W0 o
254.     int max_frame_size;
     0 i2 W& C" W  d/ w4 @% Y
255.     int first_palette_index;
     6 ^0 Q0 J4 y1 r5 M1 L
256.     int palette_count;
     
257.     int palette_type;
     
258.     int palette_index;
     - S, Z1 p8 w7 @
259. 
     2 w, D2 o" i& u; p9 ]6 N
260.     fseek(inrbt_file, 0, SEEK_SET);
     
261.     fseek(outrbt_file, 0, SEEK_SET);
     
262. 
     
263.     /* load the header */
     2 u" V" f: R1 l2 G& N$ X+ h
264.     if (fread(header, RBT_HEADER_SIZE, 1, inrbt_file) != 1)
     
265.     {
     0 `) k# K: t' m4 h
266.         printf("problem reading initial RBT header\n");
     $ j3 h  u, I& r. p
267.         return 0;
       Z+ I; q4 e* Q" K9 D
268.     }
     
269. 
     
270.     /* copy header to the output */
     
271.     if (fwrite(header, RBT_HEADER_SIZE, 1, outrbt_file) != 1)
     ' {. n3 X$ E- M! E. H& b0 R" Y# @
272.     {
     ! o) N3 T" g' x6 }% M/ H- Y5 k
273.         printf("problem writing initial RBT header\n");
     ) D5 Y6 t( J. c/ p& K
274.         return 0;
     " c( s8 }9 t" ?5 x  @' L  v, W
275.     }
     * G" h5 v( c! K- c. {4 b+ K! s
276. 
     
277.     rbt->version = LE_16(&header[6]);
     
278.     rbt->audio_chunk_size = LE_16(&header[8]);
     
279.     rbt->frame_count = LE_16(&header[14]);
     
280. 
     & E3 d# N. P. n& c, b+ i4 B& j
281.     /* transfer the unknown data, if it's there */
     3 o  G9 r8 j  T. L+ w! Y9 Z
282.     unknown_chunk_size = LE_16(&header[18]);
     ) z9 W" `* a5 D
283.     if (unknown_chunk_size > 0)
     
284.     {
     : I0 V% K! C6 k$ _) L! l
285.         unknown_chunk = malloc(unknown_chunk_size);
     
286.         if (fread(unknown_chunk, unknown_chunk_size, 1, inrbt_file) != 1)
     ) [5 J8 C  K1 Y$ T6 e* s5 l
287.         {
     
288.             printf("problem reading unknown data\n");
     / e" s$ o; X/ |# @5 s4 `0 F" x  O; t
289.             return 0;
     
290.         }
     5 a5 l! n& }' s
291.         if (fwrite(unknown_chunk, unknown_chunk_size, 1, outrbt_file) != 1)
     
292.         {
     6 ^+ l1 B6 N! z' b
293.             printf("problem writing unknown data\n");
     0 [6 c; y$ j$ L
294.             return 0;
     
295.         }
     ; M5 S' ]6 G8 j7 i! m. U+ m$ w1 P7 ^
296.         free(unknown_chunk);
     " g* c& Y4 Z  v& l3 a
297.     }
     
298. 
     
299.     /* transfer the palette chunk */
     9 }$ @# W4 r4 s$ r; V7 U
300.     palette_data_size = LE_16(&header[16]);
     
301.     palette_chunk = malloc(palette_data_size);
     , {& _" M4 k/ D! R
302.     if (fread(palette_chunk, palette_data_size, 1, inrbt_file) != 1)
     
303.     {
     " m9 _8 ^5 W. l( \  Q& @
304.         printf("problem reading palette\n");
     ' x( {  T5 U, J! a: i& a6 ^. v
305.         return 0;
     
306.     }
     7 p. E6 X4 {1 G% m6 ]6 @8 a
307.     if (fwrite(palette_chunk, palette_data_size, 1, outrbt_file) != 1)
     
308.     {
     8 n) |$ U2 ~) ?& l, P
309.         printf("problem writing palette\n");
       r/ q8 h" m' R, X) t9 Y
310.         return 0;
     
311.     }
     
312.     /* load the palette into the internal context */
     0 g! K6 W1 s7 W* s) }
313.     memset(rbt->palette, 0, PALETTE_COUNT * 3);
     ( }) s5 k5 a- D- `4 C
314.     first_palette_index = palette_chunk[25];
     . q9 M. q- l0 r  d; e/ F, F
315.     palette_count = LE_16(&palette_chunk[29]);
     
316.     palette_type = palette_chunk[32];
     0 v* P: P$ q  t$ ~. t% q# Q# w* n. e
317.     palette_index = (palette_type == 0) ? 38 : 37;
     
318.     for (i = first_palette_index; i < first_palette_index + palette_count; i++)
     ! B9 D8 y0 R# E8 b
319.     {
     
320.         rbt->palette[i*3+0] = palette_chunk[palette_index++];
     
321.         rbt->palette[i*3+1] = palette_chunk[palette_index++];
     
322.         rbt->palette[i*3+2] = palette_chunk[palette_index++];
     3 O7 C5 R- t) x  t
323.     }
     
324.     free(palette_chunk);
     ) }! I$ C- H* p5 e% g$ @' ?
325. 
     
326.     /* copy the video frame size table (2 bytes per frame), as a placeholder */
     0 q# P9 v# S" y- r4 ^7 J
327.     rbt->video_frame_size_table = malloc(rbt->frame_count * sizeof(uint16_t));
     
328.     if (fread(rbt->video_frame_size_table, rbt->frame_count * sizeof(uint16_t), 1, inrbt_file) != 1)
     7 W& S. W' X2 r4 B2 A
329.     {
     
330.         printf("problem reading frame table\n");
     
331.         return 0;
     , a: `2 v* i  Y
332.     }
     ' h+ [: B' o, u8 b4 {+ s3 S- [% _
333.     rbt->video_frame_size_table_offset = ftell(outrbt_file);
     
334.     if (fwrite(rbt->video_frame_size_table, rbt->frame_count * sizeof(uint16_t), 1, outrbt_file) != 1)
     $ ^8 U- k  w5 l8 w' P8 O
335.     {
     0 q; H& C( K' Y& ?. `! m. s% I
336.         printf("problem writing frame table\n");
     & g# \' |5 C) K2 W2 p
337.         return 0;
     , J) u. O$ y9 b" `: T+ ~+ r) {. o" ~
338.     }
     + P" ~3 T5 R" J; \" x2 x3 r
339. 
     7 h# t0 ~* f8 h# J9 [' z% Q
340.     /* copy the frame size table (2 bytes per frame), as a placeholder */
     
341.     rbt->frame_size_table = malloc(rbt->frame_count * sizeof(uint16_t));
     ; {$ Z. u3 w! v7 X  O1 D3 u" @
342.     if (fread(rbt->frame_size_table, rbt->frame_count * sizeof(uint16_t), 1, inrbt_file) != 1)
     # I) K3 p4 b3 w; ~6 \
343.     {
     
344.         printf("problem reading frame table\n");
     
345.         return 0;
     7 V- O2 f6 d; u) x& i
346.     }
     
347.     rbt->frame_size_table_offset = ftell(outrbt_file);
     1 |+ t* c4 A7 @% i$ t: l" C) Z
348.     if (fwrite(rbt->frame_size_table, rbt->frame_count * sizeof(uint16_t), 1, outrbt_file) != 1)
     ) K5 |0 l4 F" n% B5 E( ~8 O  M& ~& y; n
349.     {
     , W. M. C% {" g' F! U7 `' a
350.         printf("problem writing frame table\n");
     # D6 h0 Q* G/ E  M3 D3 X' h1 x
351.         return 0;
     + p) P4 d4 p3 l
352.     }
     8 W7 O  A% g% x! j4 j
353. 
     
354.     /* find the max frame size */
       \, h; \. \; O. n7 G5 b9 L$ I
355.     max_frame_size = 0;
     ' {% ]7 U" B+ ]4 R
356.     for (i = 0; i < rbt->frame_count; i++)
     * U9 W( u+ Y. |( v; B; [& |  N
357.     {
     1 V& K' V8 \+ e* }! N4 U) F
358.         frame_size = LE_16(&rbt->frame_size_table[i*2]);
     , ?5 f9 F0 i) r
359.         if (frame_size > max_frame_size)
     
360.             max_frame_size = frame_size;
     
361.     }
     
362.     rbt->frame_load_buffer = malloc(max_frame_size);
     8 u5 r. z4 Q$ O; Q' H, M6 y5 r
363. 
     
364.     /* transfer the unknown table(s) */
     
365.     if (fread(unknown_table, UNKNOWN_TABLE_SIZE, 1, inrbt_file) != 1)
     
366.     {
     ( J- S# q1 }" j  r
367.         printf("problem reading unknown table\n");
     
368.         return 0;
     
369.     }
     
370.     if (fwrite(unknown_table, UNKNOWN_TABLE_SIZE, 1, outrbt_file) != 1)
     
371.     {
     
372.         printf("problem writing unknown table\n");
     
373.         return 0;
     3 T: V/ S3 M* V3 V& s4 Y2 H
374.     }
     
375. 
     4 c: w9 ~$ x$ s) x( Q
376.     /* copy over padding */
     ) d* p% P$ z4 l, P. B5 C
377.     padding_size = 0x800 - (ftell(inrbt_file) & 0x7FF);
     
378.     if (padding_size)
     8 q8 U  _# \# C7 O1 P! @& t
379.     {
     
380.         padding = malloc(padding_size);
     
381.         if (fread(padding, padding_size, 1, inrbt_file) != 1)
     
382.         {
     6 t, q0 B7 l! i! t) N6 D
383.             printf("problem reading padding\n");
     
384.             return 0;
     
385.         }
     : j; c, }' r3 Y  |: m1 Z& c6 ^
386.         if (fwrite(padding, padding_size, 1, outrbt_file) != 1)
     
387.         {
     
388.             printf("problem writing padding\n");
     ) f' P4 }0 J9 E1 G1 D: }3 T
389.             return 0;
     & o- J* F) f' P. f+ E1 j# A
390.         }
     : ^) g) v' g3 `+ E
391.         free(padding);
     
392.     }
     0 j8 z+ C" _( [" w2 v
393. 
     1 n$ d& Y4 N" B) \, ^
394.     return 1;
     
395. }
     
396. 
     
397. static int get_lzs_back_ref_length(get_bits_context *gb)
     
398. {
     - i& f% F- v; a4 `7 B. b
399.     int vlc;
     
400.     int count;
     
401.     int value;
     7 X4 K! I9 h! F8 {; i
402. 
     0 D8 o# R. @, T% X
403.     vlc = view_bits(gb, VLC_SIZE);
     
404.     count = lzs_vlc_table[vlc].count;
     $ \" R# M& p2 k* ^6 ?
405.     value = lzs_vlc_table[vlc].value;
     
406. 
     , C0 A! R& d! X9 c+ T
407.     read_bits(gb, count);
     . N& F; _- J/ ^6 k( ]* B* |. j
408.     if (value == 8)
     . O9 J6 r2 f3 m: R- d5 D; R
409.     {
     : Z$ l5 H+ T0 h/ f
410.         do
     
411.         {
     : ~- s* K" D- X: Q1 Q
412.             vlc = read_bits(gb, VLC_SIZE);
     
413.             value += vlc;
     0 s' f# O. W* w8 E: r" N- L
414.         }
     
415.         while (vlc == 0xF);
     
416.     }
     
417. 
     $ I  K5 h8 l+ t' B# F+ w4 E4 Z; @  J
418.     return value;
     ( m$ l) ^6 u  l. c/ E5 g
419. }
     
420. 
     
421. static void compress_window(put_bits_context *pb, uint8_t *full_window,
     
422.     int full_window_stride,
     
423.     int window_top, int window_bottom, int window_left, int window_right)
     ; @, |% u2 P) n$ H5 _. m
424. {
     
425.     int last_pixel;
     
426.     int run_size;
     - {+ A" }  ^3 H
427.     int x;
     
428.     int y;
     % ^7 i6 t% |$ A  a
429.     int start_index;
     6 V8 t' i# E9 ]4 I4 B: l9 a" A
430.     int end_index;
     
431.     int encode_last_run;
     ) P! D7 C! s$ f9 z. X( L% b! }% p9 K
432. 
     
433.     last_pixel = full_window[0];
     7 p8 P8 g2 H' ]) X5 G
434.     run_size = 1;
     
435.     for (y = window_top; y <= window_bottom; y++)
     ) m% a1 c0 }& N
436.     {
     
437.         start_index = y * full_window_stride + window_left;
     
438.         if (y == window_top)
     
439.             start_index += 1;
     4 s4 u; \  c9 j6 L
440.         end_index = y * full_window_stride + window_right;
     
441.         if (y == window_bottom)
     
442.             encode_last_run = 1;
     
443.         else
     ' r2 r0 U; a, u' u
444.             encode_last_run = 0;
     6 d" y4 V0 s* J0 H' k9 k* C7 y
445.         for (x = start_index; x < end_index; x++)
     - O6 i8 z  B4 b5 ?  c9 Y  D
446.         {
     * a( ?6 A* C) ?' O" \
447.             if (!encode_last_run && full_window[x] == last_pixel)
     
448.                 run_size++;
     $ c5 k2 L/ u: \& {: i) a: S
449.             else
     
450.             {
     9 Y$ l+ b& g8 c+ h  A; q1 P
451.                 if (run_size == 1)
     / V8 h1 W! W6 ^% l
452.                 {
     6 k' n( S9 y$ e6 ]4 s2 h9 m
453.                     /* encode a 0 bit followed by raw pixel byte */
     
454.                     put_bits(pb, 0, 1);
     # b7 m) O! @) _2 b; F3 b- m( ~* \8 [! P
455.                     put_bits(pb, last_pixel, 8);
     
456.                 }
     ) Y  ^6 R& O5 ]$ r0 `: ~# N
457.                 else if (run_size == 2)
     ) O+ Y! X  |: G
458.                 {
     
459.                     /* encode a 0 bit followed by raw pixel byte */
     
460.                     put_bits(pb, 0, 1);
     : v" X' u, a8 _- n: x( r4 P6 j# T# X
461.                     put_bits(pb, last_pixel, 8);
     
462.                     put_bits(pb, 0, 1);
     
463.                     put_bits(pb, last_pixel, 8);
     
464.                 }
     
465.                 else
     
466.                 {
     
467.                     /* encode a 0 bit followed by raw pixel byte */
     
468.                     put_bits(pb, 0, 1);
     ' ~! g& y! l: _
469.                     put_bits(pb, last_pixel, 8);
     
470.                     run_size--;
     
471.                     /* encode a run: a 1 bit, followed by a back reference
     0 O& b9 J) ]2 H) A# W
472.                      * offset (-1), followed by a length */
     
473.                     put_bits(pb, 1, 1);
     , h$ {1 j3 t& t2 F8 l" o% {9 g
474.                     put_bits(pb, 1, 1);  /* 1 = 7-bit offset */
     5 m0 r; k0 Q# z; M9 V; \
475.                     put_bits(pb, 1, 7);
     
476.                     if (run_size <= 4)
     1 U4 [1 ~, u4 ^* ~; {1 {
477.                     {
     
478.                         /* lengths 2, 3, and 4 are 2 bits */
     
479.                         put_bits(pb, run_size - 2, 2);
     
480.                     }
     
481.                     else if (run_size <= 7)
     4 h3 K; V: W- g3 g, H: V# \. b1 V! `
482.                     {
     
483.                         /* lengths 5, 6, and 7 are 4 bits */
     ; ]; X7 q! Z- Y( g
484.                         put_bits(pb, run_size + 7, 4);
     
485.                     }
     7 J% C, J& m+ x. o+ t$ F
486.                     else
     
487.                     {
     ! C& N( i& @3 W7 @* Y! h- @
488.                         /* arbitrary length; start by encoding 0xF which
     ( R; u6 w: R) g+ R
489.                          * stands in for an initial version of 8 */
     
490.                         put_bits(pb, 0xF, 4);
     4 j# {/ w- h0 t! O
491.                         run_size -= 8;
     ' n! \& p" q# e  }; J
492. 
     
493.                         /* encode blocks of 4 bits until run_size is 0 */
     : R; G3 }8 L2 y& Z# g
494.                         while (run_size >= 0)
     
495.                         {
     6 p; e) N5 B1 G3 L" D" W# }$ B4 u
496.                             if (run_size >= 15)
     ( d5 b! A3 x, z' t/ Z
497.                             {
     
498.                                 put_bits(pb, 0xF, 4);
     0 n& N0 `2 z- W* b: Z
499.                                 run_size -= 0xF;
     7 z$ N& ]; c% W+ `, |  ?# ^/ h
500.                             }
     % u- S6 f1 n/ R
501.                             else
     
502.                             {
     
503.                                 put_bits(pb, run_size, 4);
     
504.                                 run_size = -1;
     ) Z2 t% q3 r# S$ z5 e
505.                             }
     - y  i& o, n2 e/ j$ b2 m
506.                         }
     * f) C" E. \. c$ c4 b
507.                     }
     * r! Z" l7 T. E/ l; y9 C
508.                 }
     
509. 
     : X* `" \/ w$ @9 @% v, p. x
510.                 last_pixel = full_window[x];
     
511.                 run_size = 1;
     8 v# N' n! |) q1 Q6 h
512. 
     
513.                 /* this single x iteration was only here to close the final run */
     
514.                 if (y == window_bottom)
     
515.                     break;
     
516.             }
     ' c3 D4 ?# ]  b. C- }/ n3 ?
517.         }
     
518.     }
     ; K; e! A6 n. H( t9 E7 f8 I1 v8 {
519. 
     
520.     /* close the bitstream by encoding a back reference with length 0 */
     
521.     put_bits(pb, 1, 1);  /* back reference run */
     
522.     put_bits(pb, 1, 1);  /* 1 = 7-bit offset */
     ) ^6 w& t* o$ e9 A0 W# E/ }
523.     put_bits(pb, 0, 7);  /* length 0 */
     
524. 
     " W- @0 B, @, V3 d5 A; Y3 j
525.     put_bits_flush(pb);
     
526. }
     
527. 
     
528. /* compute Euclidean distance between an RGB color and the desired target */
     
529. static int compute_rgb_distance(int r1, int r2, int g1, int g2, int b1, int b2)
     0 \) V: U2 r0 x6 v( r$ X
530. {
     3 d6 [6 D1 I1 X! E
531.     return sqrt((r1 - r2) * (r1 - r2) +
     5 @9 ?, U8 C+ A% Y
532.                 (g1 - g2) * (g1 - g2) +
     1 o8 a& o; Q+ Q; V6 h
533.                 (b1 - b2) * (b1 - b2));
     6 @: L; q% B4 V8 R* ?* T
534. }
     
535. 
     $ i5 V" g. i, e% R0 n1 E4 q9 X% i1 c
536. static uint8_t find_nearest_color(rbt_dec_context *rbt, int r, int g, int b)
     
537. {
     
538.     int i;
     % w# i, }4 K+ Q- [- {2 J
539.     int nearest_distance;
     
540.     int distance;
     
541.     int rp;
     6 ]0 [, \% [; g) o: J5 n: G
542.     int gp;
     
543.     int bp;
     ; j, `- `" X8 }
544.     uint8_t palette_index;
     
545. 
     + i- S1 u6 _6 v. O( l
546.     nearest_distance = 999999999;
     
547.     palette_index = 0;
     9 T' G$ n1 }/ F5 u9 j+ `
548.     for (i = 0; i < 256; i++)
     # W6 L& C9 o4 d: Q* y
549.     {
     
550.         rp = rbt->palette[i * 3 + 0];
     2 h1 p  i% X  q# E' c* z
551.         gp = rbt->palette[i * 3 + 1];
     7 A2 y! g8 H# n2 k
552.         bp = rbt->palette[i * 3 + 2];
     6 H+ b* }# }7 w) _
553.         distance = compute_rgb_distance(r, rp, g, gp, b, bp);
     ' @* {: R! c+ i% k7 I. _
554.         if (distance < nearest_distance)
     & o* F2 ]! A( E5 p5 _/ b
555.         {
     7 t* i- b" @1 i8 n$ \% X
556.             nearest_distance = distance;
     . O8 d3 Z! \( W  a& e3 P1 b
557.             palette_index = i;
     2 {$ C! ]6 m8 }
558.         }
     
559.         /* can't get closer than 0; break early */
     * V8 D, D8 J: L! A
560.         if (distance == 0)
     
561.             break;
     
562.     }
     
563. 
     
564.     return palette_index;
     - U0 U- J/ ?1 b! Z' d0 o
565. }
     
566. 
     / @4 c' x% c: T7 `5 o4 D- q
567. static void subtitle_frame(rbt_dec_context *rbt, uint8_t *frame,
     8 C; e6 c* M, S6 h# a6 m, a' a
568.     int width, int height, int timestamp)
     
569. {
     5 C1 A' a3 t7 h' P' d" h
570.     ASS_Image *subtitles;
     
571.     int detect_change;
     ' `1 q% y' Y! w
572.     uint8_t subtitle_pixel;
     
573.     int x, y;
     4 N* R+ L4 y) f9 G3 G; ?
574.     uint8_t *frame_ptr;
     
575.     uint8_t *subtitle_ptr;
       H0 w! L8 C+ y: w% g
576. 
     
577.     /* ask library for the subtitle for this timestamp */
     ( Y# U' z0 }0 Q* _' f; P8 t5 }$ v
578.     subtitles = ass_render_frame(rbt->ass_renderer, rbt->ass_track,
     
579.         timestamp, &detect_change);
     
580. 
     
581.     /* render the list of subtitles onto the decoded frame */
     
582.     while (subtitles)
     
583.     {
     
584.         /* palette components are only 6 bits, so shift an extra 2
     
585.          * bits off each component */
     
586.         subtitle_pixel = find_nearest_color(rbt,
     
587.             (subtitles->color >> 10) & 0xFF,
     6 ^: ?3 ?! K1 ]) L$ {/ F
588.             (subtitles->color >> 18) & 0xFF,
     
589.             (subtitles->color >> 26) & 0xFF);
     ) D1 K: D4 K( Y* _
590.         for (y = 0; y < subtitles->h; y++)
     " D* r8 j: g* i3 q; u! P( B7 I  C, R
591.         {
     
592.             subtitle_ptr = &subtitles->bitmap[y * subtitles->stride];
     
593.             frame_ptr = &frame[(subtitles->dst_y + y) * width + subtitles->dst_x];
     ' ^1 F' v* C5 J# p; x) _) q  t
594.             for (x = 0; x < subtitles->w; x++, frame_ptr++, subtitle_ptr++)
     
595.             {
     
596.                 if (*subtitle_ptr >= SUBTITLE_THRESHOLD)
     
597.                     *frame_ptr = subtitle_pixel;
     
598.             }
     
599.         }
     8 R  d, a4 \5 z& k: V
600.         subtitles = subtitles->next;
     , E2 V% ?6 h& f0 s7 {1 _
601.     }
     0 j) E; @8 z& X1 h: [* o
602. }
     
603. 
     % {$ H$ a2 r0 y4 o' H
604. static int copy_frames(rbt_dec_context *rbt, FILE *inrbt_file, FILE *outrbt_file,
     
605.     int origin_x, int origin_y, int window_width, int window_height)
     
606. {
     6 A( E* A% h  l5 s/ T
607.     int i;
     
608.     int j;
     & Y, m! u7 q5 G; I2 f: j
609.     int scale;
     - \6 n8 j& v- T8 v* Z
610.     int width;
     * |- j* K4 ~8 ?& K5 B* b0 q; v
611.     int height;
     
612.     int max_width;
     6 f% l! h, I* j1 y4 X
613.     int max_height;
     
614.     int frame_x;
     8 _4 _: s! F9 q9 a; _- q8 W
615.     int frame_y;
     0 I/ K! y+ K: v6 ]* Q
616.     int fragment_count;
     3 k0 g0 e# D2 P
617.     int decoded_size;
     4 H" n' L" L% o: Q
618.     uint8_t *decoded_frame;
     
619.     int fragment;
     
620.     int fragment_compressed_size;
     : H# W& E& S- H- a4 O1 c0 z( t
621.     int fragment_decompressed_size;
     " v6 Y7 Y1 X+ \) T+ H6 Q7 Y! D
622.     int compression_type;
     
623.     int index;
     & S) {! C+ G$ }, C! r/ o
624.     int out_index;
       C9 [' R' p% n: J3 I7 {# B
625.     get_bits_context gb;
     + f3 t' H# W( V! ]
626.     int frame_size;
     & q3 m  u  ^' E/ ^& E
627.     int video_frame_size;
     4 o9 v" n: v: C' S
628.     int audio_frame_size;
     / g. [/ _& N9 A% z- p
629. 
     3 S: i, |& h$ D; f- j3 y( _$ ^2 L
630.     int back_ref_offset_type;
     
631.     int back_ref_offset;
     
632.     int back_ref_length;
     # s1 s- k" \4 X8 m
633.     int back_ref_start;
     
634.     int back_ref_end;
     
635. 
     - ^& L$ E/ H: a1 w
636.     uint8_t *full_window;
     8 @* n+ X* [2 e
637.     int full_window_size;
     
638.     int y;
     5 a* y  M0 Q9 s' }* y+ |; D7 V
639.     int window_top;
     
640.     int window_bottom;
     
641.     int window_left;
     
642.     int window_right;
     # I4 c. |, x) k7 m  G( P# c
643.     int window_size;
     % d2 }: H( D8 p
644. 
     
645.     char filename[30];
     
646. 
     8 k5 j# c" k7 B* O+ f9 l
647.     put_bits_context *pb;
     
648. 
     
649.     full_window_size = window_width * window_height;
     
650.     full_window = malloc(full_window_size);
     
651.     pb = init_put_bits();
     ) Y. v+ I+ v. S1 T' I
652. 
     & a7 A8 J1 g# a7 m6 ~, X
653.     max_width = 0;
     
654.     max_height = 0;
     
655. 
     3 X4 ]1 x$ b# C" Y
656.     for (i = 0; i < rbt->frame_count; i++)
     
657.     {
     
658.         /* read the entire frame (includes audio and video) */
     4 K2 X) \* X& E& ]# s
659.         frame_size = LE_16(&rbt->frame_size_table[i*2]);
     ; m  ~  Z6 U4 X( u9 V
660.         video_frame_size = LE_16(&rbt->video_frame_size_table[i*2]);
     # ?  J- v- u; a0 u& c$ `9 o2 Z
661.         audio_frame_size = frame_size - video_frame_size;
     
662.         if (fread(rbt->frame_load_buffer, frame_size, 1, inrbt_file) != 1)
     ' i8 ]) [) l5 p7 @; o& M  m! E4 X
663.         {
     % |/ F" l2 D, S7 N( i7 n3 }, S/ @- \
664.             printf("problem reading frame %d\n", i);
     
665.             return 0;
       u, ?0 A. e: X0 x  E1 }4 r
666.         }
     8 @' v# U) T: L* r9 i/ l1 J
667. 
     
668.         scale = rbt->frame_load_buffer[3];
     
669.         width = LE_16(&rbt->frame_load_buffer[4]);
     2 C, }1 S+ N# @
670.         if (max_width < width)
     
671.             max_width = width;
     
672.         if (max_height < height)
     
673.             max_height = height;
     9 |" ~/ n4 M% u6 Q& Q
674.         height = LE_16(&rbt->frame_load_buffer[6]);
     
675.         frame_x = LE_16(&rbt->frame_load_buffer[12]);
     6 n1 g: U5 l) c; d7 Z
676.         frame_y = LE_16(&rbt->frame_load_buffer[14]);
     
677.         fragment_count = LE_16(&rbt->frame_load_buffer[18]);
     1 z2 p9 e6 j8 [$ F* F
678.         decoded_size = width * height;
     
679. 
     . d5 k& ?" F# K
680.         printf("processing frame %d: %d%%, %dx%d, origin @ (%d, %d), %d fragments\n", i, scale, width, height, frame_x, frame_y, fragment_count);
     
681. 
     
682.         /* decode the frame */
     
683.         decoded_frame = malloc(decoded_size);
     3 }+ A4 s& {) A
684.         index = 24;
     
685.         out_index = 0;
     + Z9 J4 [8 C3 j7 S7 x0 @  j5 p) I4 c
686.         for (fragment = 0; fragment < fragment_count; fragment++)
     
687.         {
     
688.             fragment_compressed_size = LE_32(&rbt->frame_load_buffer[index]);
     
689.             index += 4;
     
690.             fragment_decompressed_size = LE_32(&rbt->frame_load_buffer[index]);
     , h. E6 ?/ j% x; U3 S
691.             index += 4;
     ; m# p" u- r+ o5 _3 M" {- b5 q
692.             compression_type = LE_16(&rbt->frame_load_buffer[index]);
     $ N" S0 r4 A5 U1 R* _
693.             index += 2;
     
694. 
       z3 `& B" h0 d! S2 H* I& U
695.             if (compression_type == 0)
     
696.             {
     
697.                 init_get_bits(&gb, &rbt->frame_load_buffer[index],
     ) C% g7 _" D4 J" b" l
698.                     fragment_compressed_size);
     + A: O1 _( w) C  i5 Z! d$ `5 s( A* W
699. 
     
700.                 while (out_index < fragment_decompressed_size)
     9 T  T+ B' ?$ _% S0 M! W
701.                 {
     
702.                     if (read_bits(&gb, 1))
     7 `8 Y- k9 S) @
703.                     {
     ) Z8 f; I' s( {7 p
704.                         /* decode back reference offset type */
     
705.                         back_ref_offset_type = read_bits(&gb, 1);
     
706. 
     3 d) U, ?6 l: ~/ [( V
707.                         /* back reference offset is 7 or 11 bits */
     
708.                         back_ref_offset = read_bits(&gb,
     + |1 c: K7 |/ Z& m( z8 r& K
709.                             (back_ref_offset_type) ? 7 : 11);
     
710. 
     
711.                         /* get the length of the back reference */
     * p: u4 E9 S" ^& i; b
712.                         back_ref_length = get_lzs_back_ref_length(&gb);
     
713.                         back_ref_start = out_index - back_ref_offset;
     " N9 Y" V: p/ M) s
714.                         back_ref_end = back_ref_start + back_ref_length;
       W) x9 ?5 a6 ~6 y
715. 
     
716.                         /* copy the back reference, byte by byte */
     
717.                         for (j = back_ref_start; j < back_ref_end; j++)
     
718.                             decoded_frame[out_index++] = decoded_frame[j];
     
719.                     }
     
720.                     else
     / t; S: F2 b* h$ o% u! R& N6 [
721.                     {
     
722.                         /* read raw pixel byte */
     1 ]. o  N; Y5 x, u
723.                         decoded_frame[out_index++] = read_bits(&gb, 8) & 0xFF;
     ( Z9 v! u, [: k: k( Q, g1 ]5 j* N) R
724.                     }
     
725.                 }
     " m* Q; h1 A: D( ]* X0 B
726. 
     - ?' F: t+ b. }7 ^7 ]  M5 Z
727.                 delete_get_bits(&gb);
     * N; }! `+ V  B; i. W) u
728.             }
     $ {: x0 ~" }6 V/ P( K8 q) d2 s
729. 
     ) F6 s: t$ p/ F6 E1 |  m  z
730.             /* next fragment */
     : t2 Q' n3 m# @" \. i
731.             index += fragment_compressed_size;
     
732.         }
     
733. 
     2 x- W! A& i- ~6 Q$ l6 T
734.         if (rbt->dump_frames)
     8 I6 U4 R3 F5 @1 R
735.         {
     
736.             /* dump the original frame */
     
737.             sprintf(filename, "original-frame-%03d.pnm", i);
     / n9 i  |6 p8 P0 @. g+ E8 J9 i
738.             dump_pnm_file(filename, rbt, decoded_frame, width, height);
     
739.         }
     ! I. N8 P3 f# [( Y- f
740. 
     4 J4 S( U# F; B% o- j
741.         /* transfer the image onto the frame window */
     
742.         memset(full_window, 0xFF, full_window_size);
     ! {. f2 U3 c9 q( ?
743.         index = 0;
     
744.         for (y = 0; y < height; y++)
     ' M  ^5 q. @5 Q1 }
745.         {
     
746.             out_index = window_width * (frame_y + y) + frame_x;
     
747.             memcpy(&full_window[out_index], &decoded_frame[index], width);
     # v1 v; V/ W4 z/ b4 k! Q
748.             index += width;
     7 Z3 P1 W4 G" x. j* J. Q
749.         }
     , y+ h) ?# }2 u. l1 ^
750. 
     6 J* P4 J5 U0 E/ D% ]: N
751.         /* write the subtitle */
     
752.         subtitle_frame(rbt, full_window, window_width, window_height,
     
753.             i * MILLISECONDS_PER_FRAME);
     
754. 
     3 W) b7 V, {( r5 f
755.         /* figure out the smallest change window */
     % i8 j! G  V) F- u  o/ V' }
756.         window_top = frame_y;
     
757.         window_bottom = window_height;
     2 A- l7 Y9 o6 d9 \) d+ {8 Z5 ]! @/ y
758.         window_left = 0;
     2 v. |6 n: ]; Y' ?8 z
759.         window_right = window_width;
     
760.         window_size = (window_right - window_left) * (window_bottom - window_top);
     
761. 
     ! f' V2 T0 e. d% m. E
762.         /* compress the frame */
     & o4 ]5 ?1 A' T' M& g) q% |
763.         reset_put_bits(pb);
     9 @- Z9 e" D* [1 z+ U  t3 T
764.         compress_window(pb, full_window, window_width, window_top,
     
765.             window_bottom, window_left, window_right);
     
766. 
     ) A' f: {: E. g- ]0 X' W
767.         if (rbt->dump_frames)
     % d$ H4 {% Q$ ?  v- g
768.         {
     ! g1 E; A! q) r1 x( z+ ?
769.             /* dump the frame plotted onto the full window prior to encoding,
     
770.              * with subtitle */
     & E) d  n3 o; P' Z( [0 X9 ~
771.             sprintf(filename, "pre-encoding-frame-%03d.pnm", i);
     
772.             dump_pnm_file(filename, rbt, full_window, window_width, window_height);
     9 i" f) O  u& o2 L* d1 x
773.         }
     
774. 
     
775.         free(decoded_frame);
     
776. 
     
777.         /* update the frame header */
     
778.         /* width */
     * {! Q3 _; g4 j, Z" W6 c
779.         rbt->frame_load_buffer[4] = (window_right - window_left) & 0xFF;
     6 V! ~7 p+ h, ?& W4 A4 H' f
780.         rbt->frame_load_buffer[5] = (window_right - window_left) >> 8;
     % W7 `0 w. ?# z$ a& q
781.         /* height */
     8 `1 Z: k/ c; t: J2 G
782.         rbt->frame_load_buffer[6] = (window_bottom - window_top) & 0xFF;
     ' Q8 M  l  y( @, ^9 n
783.         rbt->frame_load_buffer[7] = (window_bottom - window_top) >> 8;
     
784.         /* origin X */
       O5 p4 \9 r* E
785.         rbt->frame_load_buffer[12] = window_left & 0xFF;
     , ?" o4 m( b6 f- h; O
786.         rbt->frame_load_buffer[13] = window_left >> 8;
     
787.         /* origin Y */
     4 I, }5 ]+ f' K/ T' L: r+ t2 l
788.         rbt->frame_load_buffer[14] = window_top & 0xFF;
     7 X+ I, i; S7 ]" _
789.         rbt->frame_load_buffer[15] = window_top >> 8;
     
790.         /* fragment payload size */
     
791.         rbt->frame_load_buffer[16] = (pb->byte_index + 10) & 0xFF;
     1 Q! `' y. [* F2 l
792.         rbt->frame_load_buffer[17] = (pb->byte_index + 10) >> 8;
     9 \; ]  {8 c1 r* r" E
793.         /* fragment count (1) */
     
794.         rbt->frame_load_buffer[18] = 1;
     9 C% N/ ^9 l2 [
795.         rbt->frame_load_buffer[19] = 0;
     5 [% {1 }1 C$ Y$ M7 o. V& d
796. 
     
797.         /* update the fragment header */
     
798.         /* compressed size */
     
799.         rbt->frame_load_buffer[24 + 0] = (pb->byte_index >>  0) & 0xFF;
     # |4 M# S* ^& C# j# x5 U
800.         rbt->frame_load_buffer[24 + 1] = (pb->byte_index >>  8) & 0xFF;
     
801.         rbt->frame_load_buffer[24 + 2] = (pb->byte_index >> 16) & 0xFF;
     
802.         rbt->frame_load_buffer[24 + 3] = (pb->byte_index >> 24) & 0xFF;
     : G% i  E  \- q6 J
803.         /* decompressed size */
     
804.         rbt->frame_load_buffer[24 + 4] = (window_size >>  0) & 0xFF;
     3 c9 V! ~; L" m/ N) ~) A
805.         rbt->frame_load_buffer[24 + 5] = (window_size >>  8) & 0xFF;
       k3 i6 ]* r' L3 h, y% j
806.         rbt->frame_load_buffer[24 + 6] = (window_size >> 16) & 0xFF;
     
807.         rbt->frame_load_buffer[24 + 7] = (window_size >> 24) & 0xFF;
     3 _/ E1 u3 ?% r: Q. K9 O, V% O! u
808.         /* compression format 0 */
     
809.         rbt->frame_load_buffer[24 + 8] = 0;
     ( R$ b+ O# {' R# |7 `* r4 y4 o0 e
810.         rbt->frame_load_buffer[24 + 9] = 0;
     
811. 
     / `# c- Z: N; \2 Y" c
812.         /* write the 24-byte frame header and the 10-byte fragment header */
     $ l0 \( W7 _3 k
813.         if (fwrite(rbt->frame_load_buffer, 24 + 10, 1, outrbt_file) != 1)
     
814.         {
     $ c; ?. W! b/ u! K% |  @% u
815.             printf("problem writing frame %d\n", i);
     
816.             return 0;
     1 h& Z. ~/ |: T0 U7 Z, l4 f& m
817.         }
     4 |% N: J/ O; j; u8 r* T8 N" o! Q
818. 
     ' A* B; a# C- i
819.         /* write the new compressed frame data */
     4 M! U) X6 a4 y0 z
820.         if (fwrite(pb->bytes, pb->byte_index, 1, outrbt_file) != 1)
     
821.         {
       \( E9 p7 H: T+ D: ^
822.             printf("problem writing frame %d\n", i);
     5 Z# M1 w: x) S: A  \$ u1 l
823.             return 0;
     9 k$ H' a0 a# V9 p# n" z8 B
824.         }
     
825. 
     
826.         /* write the audio data */
     
827.         if (fwrite(&rbt->frame_load_buffer[video_frame_size], frame_size - video_frame_size, 1, outrbt_file) != 1)
     5 R- `3 a5 @4 T
828.         {
     
829.             printf("problem writing frame %d\n", i);
     
830.             return 0;
     
831.         }
     
832. 
     
833.         /* update the table entries */
     
834.         video_frame_size = pb->byte_index + 24 + 10;
     ) W5 E2 o1 B) g3 w2 \( g. D+ H* Z
835.         frame_size = video_frame_size + audio_frame_size;
     5 E+ f% N4 @& V2 h3 i* V
836.         rbt->frame_size_table[i*2+0] = frame_size & 0xFF;
     
837.         rbt->frame_size_table[i*2+1] = frame_size >> 8;
     
838.         rbt->video_frame_size_table[i*2+0] = video_frame_size & 0xFF;
     
839.         rbt->video_frame_size_table[i*2+1] = video_frame_size >> 8;
     
840.     }
     
841. 
     8 v4 }3 ~2 `% x0 A, d( R
842.     printf("maximum dimensions seen are %dx%d\n", max_width, max_height);
     
843. 
     ' j% I5 e4 E3 w3 [
844.     delete_put_bits(pb);
     4 @5 b. t2 H9 _" S
845.     free(full_window);
     
846. 
     5 Z; i' u1 Z; D2 F$ Z9 J4 l
847.     return 1;
     + p( b: _8 F* q+ N3 k: V2 w
848. }
     
849. 
     
850. int main(int argc, char *argv[])
     
851. {
     3 n7 {2 s0 a( o: q# e$ [0 r
852.     char *subtitle_filename;
     8 E2 E7 y" o9 e+ u
853.     FILE *subtitle_file;
     ) Q% t; W9 X" X/ i( C: ]8 \
854.     char *inrbt_filename;
       H) ]6 y3 \1 t9 n3 g1 X
855.     FILE *inrbt_file;
     7 S/ n- l: r/ V8 g
856.     char *outrbt_filename;
     
857.     FILE *outrbt_file;
     4 b9 H2 V0 ~9 _; ^' L) U, P
858.     rbt_dec_context rbt;
     
859.     int origin_x;
     
860.     int origin_y;
     % W% `7 N  ^- |5 V! R3 I
861.     int window_width;
     
862.     int window_height;
     
863. 
     " V1 F: o. A" i+ U: f; S
864.     /* testing the bit functions */
     
865. #if 0
     
866.     int i;
     
867.     uint8_t bytestream[] = { 0x55, 0xAA, 0x00, 0xAA, 0x55, 0x77, 0xFF, 0x1B, 0x70, 0x8F };
     * N4 N8 `! ]5 ^( H0 N( q
868.     int bytestream_size = 10;
     * S8 o, W" M, n! W+ t  G& d
869.     get_bits_context gb;
     ) v) a. _9 X, \  k2 S
870.     put_bits_context *pb;
     $ i. v$ Y# m1 O4 y
871.     int bits;
     
872. 
     
873.     init_get_bits(&gb, bytestream, bytestream_size);
     7 L1 @5 D# K9 W  l% a; H
874.     pb = init_put_bits();
     
875. 
     8 L0 y; H% i& l7 @
876.     for (i = 1; i <= 12; i++)
     
877.     {
     
878.         bits = view_bits(&gb, i);
     / f2 }7 b2 T( p& _) ~( H
879.         printf("view %d bits: %d\n", i, bits);
     5 @, Y7 N" b: z2 ?$ C" d' @
880.         printf("read %d bits: %d\n", i, read_bits(&gb, i));
     & _2 T' o3 Q' U' D9 D
881.         put_bits(pb, bits, i);
     
882.     }
     
883.     put_bits_flush(pb);
     $ w2 m- a1 u* H0 B1 ?
884. 
     
885.     printf("original bytestream:\n");
     4 Q( t# X; ]+ {3 e6 G6 r
886.     for (i = 0; i < bytestream_size; i++)
     
887.         printf(" %02X", bytestream[i]);
     # g( ~: C5 Z) i( ^
888.     printf("\nnewbytestream:\n");
     
889.     for (i = 0; i < pb->byte_index; i++)
     
890.         printf(" %02X", pb->bytes[i]);
     - C' c+ n( `& F' L) |$ L1 z
891.     printf("\n");
     / r. b1 I  X7 Q4 W/ d
892. 
     
893.     delete_get_bits(&gb);
     ( F8 A  j/ j" X
894.     free(pb);
     
895. #endif
     : f6 \3 o% _0 u* x, ]. f$ E2 y
896. 
     
897.     /* validate the number of arguments */
     
898.     if (argc != 8 && argc != 9)
     + \& r' \4 Y4 d% U, u7 J! C
899.     {
     " D! W/ G8 F1 x: \. }
900.         printf("USAGE: subtitle-rbt <subtitles.ass> <in.rbt> <out.rbt> <origin X> <origin Y> <width> <height> [dump_frames]\n");
     ! Z) n1 z6 n# d, [5 x7 m7 X1 V4 [
901.         return 1;
     
902.     }
     
903.     subtitle_filename = argv[1];
     
904.     inrbt_filename = argv[2];
     
905.     outrbt_filename = argv[3];
     
906.     origin_x = atoi(argv[4]);
     % ~" Y' \( m+ W9 M1 g+ C
907.     origin_y = atoi(argv[5]);
     
908.     window_width = atoi(argv[6]);
     
909.     window_height = atoi(argv[7]);
     + E! r/ R& s6 s' j/ C' d
910.     rbt.dump_frames = 0;
     6 O( f# y3 r) V6 M8 v; Y8 @* y
911.     if (argc == 9)
     
912.         rbt.dump_frames = 1;
     
913. 
     0 F# g8 k3 `) x8 Q
914.     /* verify that the specified input files are valid */
     - j! o/ I7 _; ~8 R
915.     subtitle_file = fopen(subtitle_filename, "r");
     8 w) m9 E1 U* z' T  |  x
916.     if (!subtitle_file)
     # e: y1 ^$ h! ?. E+ H2 Q) C
917.     {
     1 I" O* N2 z5 V- b! f
918.         perror(subtitle_filename);
     
919.         return 1;
     ; s- R) ^* P& e
920.     }
     * t" n) V) F* \" ?9 W0 F
921.     fclose(subtitle_file);
     ) j6 C3 Z7 Z1 n. [9 \+ a* e) r
922.     inrbt_file = fopen(inrbt_filename, "rb");
     2 E# g$ J4 G' B) v
923.     if (!inrbt_file)
     
924.     {
     # T# R8 i$ F4 N5 |/ [, P( v" k
925.         perror(inrbt_filename);
     ! b, l! k3 c3 n( y/ w7 Y. \2 U
926.         return 1;
     
927.     }
     
928. 
     
929.     /* initialize the subtitle support */
     
930.     rbt.ass_lib = ass_library_init();
     
931.     rbt.ass_renderer = ass_renderer_init(rbt.ass_lib);
     : @9 U3 }: n# G' o9 Y
932.     rbt.ass_track = ass_read_file(rbt.ass_lib, subtitle_filename, "UTF-8");
     / X. f1 G0 {: c/ a
933.     ass_set_frame_size(rbt.ass_renderer, window_width, window_height);
     
934.     ass_set_fonts(rbt.ass_renderer, NULL, NULL, 1, NULL, 1);
     . ^0 m0 u5 w* o: z: J6 Q: d
935. 
     . G: X3 _* v4 x1 L+ e1 t
936.     /* open the output file */
     
937.     outrbt_file = fopen(outrbt_filename, "wb");
     3 O5 W  i, U6 o9 g
938.     if (!outrbt_file)
     
939.     {
     , }! E6 r$ u( B1 l& Z' d
940.         perror(outrbt_filename);
     7 H# o4 C+ x  Q# k; f" t9 c$ C" V
941.         return 1;
     8 b4 F" d: l' [" L
942.     }
     6 L% W0 [) y, N
943. 
     
944.     /* transfer header from input to output */
     
945.     if (!load_and_copy_rbt_header(&rbt, inrbt_file, outrbt_file))
       j+ }; H1 s/ k# F) W* Y7 A, `
946.         return 1;
     
947. 
     
948.     /* rewrite the frames */
     ; s) y6 @$ |( E* e6 V, y/ d) `. I
949.     if (!copy_frames(&rbt, inrbt_file, outrbt_file, origin_x, origin_y,
       A5 p7 ~9 Q/ u5 h; H4 `+ m
950.         window_width, window_height))
     : H5 @; j. R) ~( M$ o. O
951.         return 1;
     ' j' B5 d* `' l! H  S
952. 
       y5 C- ~3 i8 m: H) w9 Y$ ~9 j
953.     /* write the modified frame size tables back to the file */
     . {: h+ U$ @, D1 r* [* Q7 d" J
954.     fseek(outrbt_file, rbt.video_frame_size_table_offset, SEEK_SET);
     
955.     fwrite(rbt.video_frame_size_table, rbt.frame_count * sizeof(uint16_t), 1, outrbt_file);
     
956.     fseek(outrbt_file, rbt.frame_size_table_offset, SEEK_SET);
     
957.     fwrite(rbt.frame_size_table, rbt.frame_count * sizeof(uint16_t), 1, outrbt_file);
     
958. 
     
959.     /* finished with files */
     3 H& R5 V8 \; u- o
960.     fclose(inrbt_file);
     2 a1 v5 D2 N5 _9 |$ Y; }
961.     fclose(outrbt_file);
     4 J" u5 z$ D9 c/ ~3 A  v
962. 
     
963.     /* clean up subtitle library */
     ' W# P+ b; _# i
964.     ass_free_track(rbt.ass_track);
     ) M: Q/ B' V9 r- q) x6 b" X, }3 D$ O
965.     ass_renderer_done(rbt.ass_renderer);
     & x/ @/ ?; R/ _, F; W5 y. K, t9 r
966.     ass_library_done(rbt.ass_lib);
     9 X! A& e0 Q0 G5 c! B/ k
967. 
     ( b" X1 P: l$ R
968.     /* clean up */
     
969.     free(rbt.frame_load_buffer);
     . ?+ ?0 S. U5 N$ }3 d
970.     free(rbt.video_frame_size_table);
     
971.     free(rbt.frame_size_table);
     % Q, Z3 |9 L* _& Q$ }( {3 X( I
972. 
     
973.     return 0;
     
974. }

复制代码

/ V) a. U& q& `

shane007

顶上来

宿矢

求汉化啊！

shane007

引用第3楼soring123于2009-11-19 17:07发表的  :
: L; l" ]& A5 H/ l我记得是没字幕的 比较麻烦 都是视频的

给视频外挂字幕方式汉化也许能行。
要结合dosbox和代理dll技术。

soring123

我记得是没字幕的 比较麻烦 都是视频的

shane007

引用第1楼soring123于2009-11-19 11:09发表的  :
这游戏有字幕吗？

好像没有字幕，我说的是给视频外挂字幕方式的汉化。
就像syberia2汉化版下面那行字一样。

soring123

这游戏有字幕吗？