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

shane007

- Q+ X% k8 I5 L/ H最近找到了一些和幽魂系列Phantasmagoria 有关的资料，
也许将来可以用于汉化。
  X! |3 N# _( ]$ Q
+ _- p# c1 T: t: e5 j- {和日文版有关的信息
http://anthonylarme.tripod.com/phantas/phintgtp.html

相关工具
http://anthonylarme.tripod.com/phantas/phcheats.html
  c" w& n1 O% a% D-----------------------------------------------------------------------
2012/1/2  更新
关于幽魂游戏的字幕
Phantasmagoria subtitles function discovered - ScummVM :: Forums
2 R2 Z# z+ j  L/ b
VMD文件
Subtitling Sierra VMD Files | Breaking Eggs And Making Omelettes (multimedia.cx)VMD - MultimediaWiki
* K9 `) @# I/ {* z5 j6 H
7 p, i5 |- ?1 s' U( P字幕
Subtitling Sierra RBT Files | Breaking Eggs And Making Omelettes (multimedia.cx)

FFmpeg/subtitle-rbt.c at feature/VMD_encoder · multimediamike/FFmpeg · GitHub

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

复制代码

* k! m: R0 F5 w; y+ Y

5 |" q, h% q( v4 ^

soring123

这游戏有字幕吗？

shane007

引用第1楼soring123于2009-11-19 11:09发表的  :
& `! k: b3 l4 M  P8 }3 l) h% O这游戏有字幕吗？

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

soring123

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

shane007

引用第3楼soring123于2009-11-19 17:07发表的  :
我记得是没字幕的 比较麻烦 都是视频的

. E7 W& O3 q* L! s) r/ f$ v( `给视频外挂字幕方式汉化也许能行。
要结合dosbox和代理dll技术。

宿矢

求汉化啊！

shane007

顶上来